Struct Process 

pub struct Process {

    pub pid: Pid,
    pub parent: Option<Pid>,
    pub current_module: Option<String>,
    pub pc: usize,
    pub inline_code: Option<Vec<Instruction>>,
    pub registers: [Value; 1024],
    pub mailbox: VecDeque<Message>,
    pub links: Vec<Pid>,
    pub monitors: Vec<(u64, Pid)>,
    pub monitored_by: Vec<(u64, Pid)>,
    pub status: ProcessStatus,
    pub exit_reason: Value,
    pub trap_exit: bool,
    pub timeout: Option<u32>,
    pub call_stack: Vec<CallFrame>,
    pub stack: Vec<Value>,
    pub dictionary: HashMap<Value, Value>,
    pub try_stack: Vec<TryFrame>,
    pub current_exception: Option<(Value, Value, Vec<String>)>,
    pub binary_match_state: Option<(Vec<u8>, usize)>,
}

Process state

Fields

pid: Pid

parent: Option<Pid>

current_module: Option<String>

Current module being executed (None if running inline code).

pc: usize

Program counter - index into current module’s code or inline_code.

inline_code: Option<Vec<Instruction>>

Inline code for processes spawned with raw instructions (backwards compat).

registers: [Value; 1024]

mailbox: VecDeque<Message>

links: Vec<Pid>

monitors: Vec<(u64, Pid)>

Monitors this process has set up: (ref, target_pid)

monitored_by: Vec<(u64, Pid)>

Processes that are monitoring this one: (ref, monitoring_pid)

status: ProcessStatus

exit_reason: Value

Exit reason when process terminates (default: :normal for Done, :crashed for Crashed)

trap_exit: bool

When true, exit signals from linked processes become messages instead of killing this process

timeout: Option<u32>

Remaining timeout (in reductions) when waiting for a message

call_stack: Vec<CallFrame>

Call stack for function calls (stores return context)

stack: Vec<Value>

Data stack for saving/restoring values (Push/Pop)

dictionary: HashMap<Value, Value>

Process dictionary for per-process key-value storage

try_stack: Vec<TryFrame>

Exception handler stack for try/catch/after

current_exception: Option<(Value, Value, Vec<String>)>

Current exception being handled (class, reason, stacktrace)

binary_match_state: Option<(Vec<u8>, usize)>

Binary match state: (binary bytes, current bit position)

Implementations

impl Process

pub fn new(pid: Pid, parent: Option<Pid>, code: Vec<Instruction>) -> Self

Create a new process with inline code (backwards compatible).

pub fn new_with_module( pid: Pid, parent: Option<Pid>, module: String, entry: usize, ) -> Self

Create a new process that runs a module function.

Trait Implementations

impl Debug for Process

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.