Enum Instruction 

pub enum Instruction {
    End,
    Work {
        amount: u32,
    },
    Spawn {
        code: Vec<Instruction>,
        dest: Register,
    },
    SpawnLink {
        code: Vec<Instruction>,
        dest: Register,
    },
    Send {
        to: Source,
        msg: String,
    },
    Receive {
        dest: Register,
    },
    ReceiveTimeout {
        dest: Register,
        timeout: u32,
    },
    Link {
        target: Source,
    },
    Unlink {
        target: Source,
    },
    Monitor {
        target: Source,
        dest: Register,
    },
    Demonitor {
        monitor_ref: Register,
    },
    Register {
        name: String,
    },
    Unregister {
        name: String,
    },
    WhereIs {
        name: String,
        dest: Register,
    },
    Print {
        source: Source,
    },
    Crash,
    Exit {
        reason: Register,
    },
    TrapExit {
        enable: bool,
    },
    LoadInt {
        value: i64,
        dest: Register,
    },
    Move {
        source: Register,
        dest: Register,
    },
    Add {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Sub {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Mul {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Div {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Mod {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Eq {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Ne {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Lt {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Lte {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Gt {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Gte {
        a: Operand,
        b: Operand,
        dest: Register,
    },
    Jump {
        target: usize,
    },
    JumpIf {
        cond: Operand,
        target: usize,
    },
    JumpUnless {
        cond: Operand,
        target: usize,
    },
    Call {
        target: usize,
    },
    Return,
    CallMFA {
        module: String,
        function: String,
        arity: u8,
    },
    CallLocal {
        function: String,
        arity: u8,
    },
    TailCallMFA {
        module: String,
        function: String,
        arity: u8,
    },
    TailCallLocal {
        function: String,
        arity: u8,
    },
    MakeFun {
        module: String,
        function: String,
        arity: u8,
        dest: Register,
    },
    Apply {
        fun: Register,
        arity: u8,
    },
    MakeClosure {
        module: String,
        function: String,
        arity: u8,
        captures: Vec<Register>,
        dest: Register,
    },
    SpawnMFA {
        module: String,
        function: String,
        arity: u8,
        dest: Register,
    },
    SpawnLinkMFA {
        module: String,
        function: String,
        arity: u8,
        dest: Register,
    },
    Push {
        source: Operand,
    },
    Pop {
        dest: Register,
    },
    LoadAtom {
        name: String,
        dest: Register,
    },
    MakeTuple {
        arity: u8,
        dest: Register,
    },
    TupleElement {
        tuple: Register,
        index: u8,
        dest: Register,
    },
    TupleArity {
        tuple: Register,
        dest: Register,
    },
    Match {
        source: Register,
        pattern: Pattern,
        fail_target: usize,
    },
    ReceiveMatch {
        clauses: Vec<(Pattern, usize)>,
        timeout: Option<u32>,
        timeout_target: usize,
    },
    MakeList {
        length: u8,
        dest: Register,
    },
    Cons {
        head: Register,
        tail: Register,
        dest: Register,
    },
    ListHead {
        list: Register,
        dest: Register,
    },
    ListTail {
        list: Register,
        dest: Register,
    },
    ListIsEmpty {
        list: Register,
        dest: Register,
    },
    ListLength {
        list: Register,
        dest: Register,
    },
    ListAppend {
        a: Register,
        b: Register,
        dest: Register,
    },
    ListReverse {
        list: Register,
        dest: Register,
    },
    ListNth {
        list: Register,
        n: Register,
        dest: Register,
    },
    ListMember {
        elem: Register,
        list: Register,
        dest: Register,
    },
    IsInteger {
        source: Register,
        dest: Register,
    },
    IsAtom {
        source: Register,
        dest: Register,
    },
    IsTuple {
        source: Register,
        dest: Register,
    },
    IsList {
        source: Register,
        dest: Register,
    },
    IsPid {
        source: Register,
        dest: Register,
    },
    IsFunction {
        source: Register,
        dest: Register,
    },
    IsString {
        source: Register,
        dest: Register,
    },
    IsMap {
        source: Register,
        dest: Register,
    },
    PutDict {
        key: Register,
        value: Register,
        dest: Register,
    },
    GetDict {
        key: Register,
        dest: Register,
    },
    EraseDict {
        key: Register,
        dest: Register,
    },
    GetDictKeys {
        dest: Register,
    },
    MakeMap {
        count: u8,
        dest: Register,
    },
    MapGet {
        map: Register,
        key: Register,
        dest: Register,
    },
    MapGetDefault {
        map: Register,
        key: Register,
        default: Register,
        dest: Register,
    },
    MapPut {
        map: Register,
        key: Register,
        value: Register,
        dest: Register,
    },
    MapRemove {
        map: Register,
        key: Register,
        dest: Register,
    },
    MapHas {
        map: Register,
        key: Register,
        dest: Register,
    },
    MapSize {
        map: Register,
        dest: Register,
    },
    MapKeys {
        map: Register,
        dest: Register,
    },
    MapValues {
        map: Register,
        dest: Register,
    },
    MakeBinary {
        bytes: Vec<u8>,
        dest: Register,
    },
    BinarySize {
        bin: Register,
        dest: Register,
    },
    BinaryAt {
        bin: Register,
        index: Register,
        dest: Register,
    },
    BinarySlice {
        bin: Register,
        start: Register,
        len: Register,
        dest: Register,
    },
    BinaryConcat {
        a: Register,
        b: Register,
        dest: Register,
    },
    IsBinary {
        source: Register,
        dest: Register,
    },
    StringToBinary {
        source: Register,
        dest: Register,
    },
    BinaryToString {
        source: Register,
        dest: Register,
    },
    BinaryConstructSegments {
        segments: Vec<(SegmentSource, BitSegment)>,
        dest: Register,
    },
    BinaryMatchStart {
        source: Register,
    },
    BinaryMatchSegment {
        segment: BitSegment,
        dest: Register,
        fail_target: usize,
    },
    BinaryMatchRest {
        dest: Register,
    },
    BinaryGetInteger {
        bin: Register,
        bit_offset: Register,
        segment: BitSegment,
        dest: Register,
    },
    BinaryPutInteger {
        bin: Register,
        bit_offset: Register,
        value: Register,
        segment: BitSegment,
        dest: Register,
    },
    MakeRef {
        dest: Register,
    },
    IsRef {
        source: Register,
        dest: Register,
    },
    LoadFloat {
        value: f64,
        dest: Register,
    },
    IsFloat {
        source: Register,
        dest: Register,
    },
    IntToFloat {
        source: Register,
        dest: Register,
    },
    FloatToInt {
        source: Register,
        dest: Register,
    },
    Floor {
        source: Register,
        dest: Register,
    },
    Ceil {
        source: Register,
        dest: Register,
    },
    Round {
        source: Register,
        dest: Register,
    },
    Trunc {
        source: Register,
        dest: Register,
    },
    Sqrt {
        source: Register,
        dest: Register,
    },
    Abs {
        source: Register,
        dest: Register,
    },
    Pow {
        base: Register,
        exp: Register,
        dest: Register,
    },
    SendAfter {
        delay: u32,
        to: Source,
        msg: Register,
        dest: Register,
    },
    StartTimer {
        delay: u32,
        msg: Register,
        dest: Register,
    },
    CancelTimer {
        timer_ref: Register,
        dest: Register,
    },
    ReadTimer {
        timer_ref: Register,
        dest: Register,
    },
    PrintLn {
        source: Register,
    },
    ReadLine {
        dest: Register,
    },
    FileRead {
        path: Register,
        dest: Register,
    },
    FileWrite {
        path: Register,
        content: Register,
        dest: Register,
    },
    FileExists {
        path: Register,
        dest: Register,
    },
    FileDelete {
        path: Register,
        dest: Register,
    },
    SelfPid {
        dest: Register,
    },
    ProcessList {
        dest: Register,
    },
    ProcessCount {
        dest: Register,
    },
    IsAlive {
        pid: Register,
        dest: Register,
    },
    ProcessInfo {
        pid: Register,
        dest: Register,
    },
    ModuleList {
        dest: Register,
    },
    FunctionExported {
        module: Register,
        function: Register,
        arity: Register,
        dest: Register,
    },
    Try {
        catch_target: usize,
        after_target: Option<usize>,
    },
    EndTry,
    Throw {
        class: Register,
        reason: Register,
    },
    GetException {
        dest: Register,
    },
    ClearException,
    Reraise,
}

Bytecode instructions

Variants

End

Process is done

Work

Do some work (costs amount reductions)

Fields

amount: u32

Spawn

Spawn a new process running code, store child PID in register

Fields

code: Vec<Instruction>

dest: Register

SpawnLink

Spawn a new process and atomically link to it

Fields

code: Vec<Instruction>

dest: Register

Send

Send a message to a process

Fields

to: Source

msg: String

Receive

Receive a message matching a pattern, block if none available For now, just receives any user message into a register

Fields

dest: Register

ReceiveTimeout

Receive with timeout (in reductions). If no message arrives before timeout expires, receives “TIMEOUT” instead.

Fields

dest: Register

timeout: u32

Link

Link to another process (bidirectional crash notification)

Fields

target: Source

Unlink

Remove a bidirectional link to another process

Fields

target: Source

Monitor

Monitor another process (one-way crash notification) Returns a monitor reference in dest for later demonitoring

Fields

target: Source

dest: Register

Demonitor

Cancel a monitor by its reference

Fields

monitor_ref: Register

Register

Register current process with a name

Fields

name: String

Unregister

Unregister a name

Fields

name: String

WhereIs

Look up a registered name, store PID (or None) in register

Fields

name: String

dest: Register

Print

Print a value (for debugging)

Fields

source: Source

Crash

Crash the process (for testing links)

Exit

Exit the process with a reason (from register) If reason is :normal, linked processes are not signaled (unless they trap_exit) If reason is abnormal, linked processes receive exit signal

Fields

reason: Register

TrapExit

Set the trap_exit flag for this process When true, exit signals from linked processes become {:EXIT, Pid, Reason} messages When false (default), abnormal exit signals kill this process

Fields

enable: bool

LoadInt

Load an immediate integer into a register

Fields

value: i64

dest: Register

Move

Move (copy) any value from source register to dest register

Fields

source: Register

dest: Register

Add

Add two operands, store result in dest

Fields

a: Operand

b: Operand

dest: Register

Sub

Subtract b from a, store result in dest

Fields

a: Operand

b: Operand

dest: Register

Mul

Multiply two operands, store result in dest

Fields

a: Operand

b: Operand

dest: Register

Div

Divide a by b, store result in dest (integer division)

Fields

a: Operand

b: Operand

dest: Register

Mod

Modulo a by b, store result in dest

Fields

a: Operand

b: Operand

dest: Register

Eq

Compare equal: dest = (a == b) ? 1 : 0

Fields

a: Operand

b: Operand

dest: Register

Ne

Compare not equal: dest = (a != b) ? 1 : 0

Fields

a: Operand

b: Operand

dest: Register

Lt

Compare less than: dest = (a < b) ? 1 : 0

Fields

a: Operand

b: Operand

dest: Register

Lte

Compare less than or equal: dest = (a <= b) ? 1 : 0

Fields

a: Operand

b: Operand

dest: Register

Gt

Compare greater than: dest = (a > b) ? 1 : 0

Fields

a: Operand

b: Operand

dest: Register

Gte

Compare greater than or equal: dest = (a >= b) ? 1 : 0

Fields

a: Operand

b: Operand

dest: Register

Jump

Unconditional jump to instruction index

Fields

target: usize

JumpIf

Jump to target if condition is truthy (non-zero integer)

Fields

cond: Operand

target: usize

JumpUnless

Jump to target if condition is falsy (zero or non-integer)

Fields

cond: Operand

target: usize

Call

Call a function: push return address onto call stack, jump to target

Fields

target: usize

Return

Return from function: pop return address from call stack, jump to it If call stack is empty, ends the process

CallMFA

Call a function by MFA (Module:Function/Arity) Arguments must be in R0..R(arity-1) before call Return value will be in R0

Fields

module: String

function: String

arity: u8

CallLocal

Call a local function in the current module More efficient than CallMFA when calling within same module

Fields

function: String

arity: u8

TailCallMFA

Tail call MFA - call without pushing return frame

Fields

module: String

function: String

arity: u8

TailCallLocal

Tail call local - call without pushing return frame

Fields

function: String

arity: u8

MakeFun

Create a function reference and store in register

Fields

module: String

function: String

arity: u8

dest: Register

Apply

Apply a function reference (from register) to arguments Fun must be a Value::Fun or Value::Closure in the specified register Arguments in R0..R(arity-1)

Fields

fun: Register

arity: u8

MakeClosure

Create a closure capturing values from registers The closure references module:function but captures current register values When applied, captured values are placed after explicit arguments

Fields

module: String

function: String

arity: u8

captures: Vec<Register>

dest: Register

SpawnMFA

Spawn a process running module:function/arity Arguments for the function must be in R0..R(arity-1)

Fields

module: String

function: String

arity: u8

dest: Register

SpawnLinkMFA

Spawn and link, running module:function/arity

Fields

module: String

function: String

arity: u8

dest: Register

Push

Push a value onto the data stack

Fields

source: Operand

Pop

Pop a value from the data stack into a register Crashes if stack is empty

Fields

dest: Register

LoadAtom

Load an atom into a register

Fields

name: String

dest: Register

MakeTuple

Create a tuple from the top arity stack elements Elements are popped in reverse order (first pushed = first element)

Fields

arity: u8

dest: Register

TupleElement

Get an element from a tuple by index (0-based) Crashes if not a tuple or index out of bounds

Fields

tuple: Register

index: u8

dest: Register

TupleArity

Get the arity (size) of a tuple Crashes if not a tuple

Fields

tuple: Register

dest: Register

Match

Match a value against a pattern On success: binds variables and continues to next instruction On failure: jumps to fail_target

Fields

source: Register

pattern: Pattern

fail_target: usize

ReceiveMatch

Receive with pattern matching Scans mailbox for first message matching any clause pattern. On match: removes message, binds variables, jumps to clause target. No match: blocks until a message arrives. Timeout: if set and expires, jumps to timeout_target.

Fields

clauses: Vec<(Pattern, usize)>

List of (pattern, jump_target) clauses

timeout: Option<u32>

Optional timeout in reductions

timeout_target: usize

Where to jump on timeout

MakeList

Create a list from the top length stack elements Elements are popped in reverse order (first pushed = first element)

Fields

length: u8

dest: Register

Cons

Cons: prepend an element to a list [elem | list] Crashes if tail is not a list

Fields

head: Register

tail: Register

dest: Register

ListHead

Get the head (first element) of a list Crashes if not a list or empty

Fields

list: Register

dest: Register

ListTail

Get the tail (rest) of a list Crashes if not a list or empty

Fields

list: Register

dest: Register

ListIsEmpty

Check if a list is empty, store 1 (true) or 0 (false)

Fields

list: Register

dest: Register

ListLength

Get the length of a list (O(n))

Fields

list: Register

dest: Register

ListAppend

Append two lists (a ++ b) Crashes if either is not a list

Fields

a: Register

b: Register

dest: Register

ListReverse

Reverse a list Crashes if not a list

Fields

list: Register

dest: Register

ListNth

Get the nth element of a list (0-based) Crashes if not a list or index out of bounds

Fields

list: Register

n: Register

dest: Register

ListMember

Check if an element is a member of a list Stores 1 (true) or 0 (false)

Fields

elem: Register

list: Register

dest: Register

IsInteger

Check if value is an integer Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

IsAtom

Check if value is an atom Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

IsTuple

Check if value is a tuple Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

IsList

Check if value is a list (including empty list) Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

IsPid

Check if value is a PID Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

IsFunction

Check if value is a function (Fun or Closure) Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

IsString

Check if value is a string/binary Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

IsMap

Check if value is a map Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

PutDict

Store value in process dictionary, returns old value (or None) in dest

Fields

key: Register

value: Register

dest: Register

GetDict

Get value from process dictionary, stores None if key not found

Fields

key: Register

dest: Register

EraseDict

Remove key from process dictionary, returns old value (or None) in dest

Fields

key: Register

dest: Register

GetDictKeys

Get all keys from process dictionary as a list

Fields

dest: Register

MakeMap

Create a map from key-value pairs on the stack Pops count pairs (2*count values: k1, v1, k2, v2, …) from stack

Fields

count: u8

dest: Register

MapGet

Get value from map by key, crashes if key not found

Fields

map: Register

key: Register

dest: Register

MapGetDefault

Get value from map by key, returns default if not found

Fields

map: Register

key: Register

default: Register

dest: Register

MapPut

Insert/update key-value in map, returns new map (maps are immutable)

Fields

map: Register

key: Register

value: Register

dest: Register

MapRemove

Remove key from map, returns new map (maps are immutable)

Fields

map: Register

key: Register

dest: Register

MapHas

Check if key exists in map, stores 1 (true) or 0 (false)

Fields

map: Register

key: Register

dest: Register

MapSize

Get number of entries in map

Fields

map: Register

dest: Register

MapKeys

Get all keys from map as a list

Fields

map: Register

dest: Register

MapValues

Get all values from map as a list

Fields

map: Register

dest: Register

MakeBinary

Create a binary from literal bytes

Fields

bytes: Vec<u8>

dest: Register

BinarySize

Get the size (byte length) of a binary

Fields

bin: Register

dest: Register

BinaryAt

Get a byte at index (0-based) Crashes if not a binary or index out of bounds

Fields

bin: Register

index: Register

dest: Register

BinarySlice

Extract a slice from a binary Crashes if not a binary or range out of bounds

Fields

bin: Register

start: Register

len: Register

dest: Register

BinaryConcat

Concatenate two binaries Crashes if either is not a binary

Fields

a: Register

b: Register

dest: Register

IsBinary

Check if value is a binary Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

StringToBinary

Convert a string to a binary (UTF-8 encoded)

Fields

source: Register

dest: Register

BinaryToString

Convert a binary to a string (assumes UTF-8) Crashes if binary is not valid UTF-8

Fields

source: Register

dest: Register

BinaryConstructSegments

Construct a binary from segments Each segment specifies a value, type, size, endianness, and signedness Usage: push segment values to stack, then call with segment specs

Fields

segments: Vec<(SegmentSource, BitSegment)>

Segment specifications (in order)

dest: Register

Destination register for the constructed binary

BinaryMatchStart

Start matching a binary - prepares for segment extraction Stores match state (current position) internally

Fields

source: Register

Source binary to match

BinaryMatchSegment

Match a segment from the binary at current position Advances the match position by the segment size Jumps to fail_target if match fails (not enough bytes, etc.)

Fields

segment: BitSegment

Segment specification

dest: Register

Destination register for extracted value

fail_target: usize

Jump target if match fails

BinaryMatchRest

Get the remaining bytes after matching Returns the rest of the binary as a new binary value

Fields

dest: Register

Destination register for remaining bytes

BinaryGetInteger

Get an integer from a binary at bit offset with specified segment For random access bit extraction

Fields

bin: Register

Source binary

bit_offset: Register

Bit offset (from start)

segment: BitSegment

Segment specification

dest: Register

Destination register

BinaryPutInteger

Put an integer into a binary at bit offset with specified segment Creates a new binary with the value inserted

Fields

bin: Register

Source binary

bit_offset: Register

Bit offset (from start)

value: Register

Value to insert

segment: BitSegment

Segment specification

dest: Register

Destination register

MakeRef

Create a new unique reference

Fields

dest: Register

IsRef

Check if value is a reference Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

LoadFloat

Load a floating-point immediate into a register

Fields

value: f64

dest: Register

IsFloat

Check if value is a float Stores 1 (true) or 0 (false)

Fields

source: Register

dest: Register

IntToFloat

Convert integer to float

Fields

source: Register

dest: Register

FloatToInt

Convert float to integer (truncates toward zero)

Fields

source: Register

dest: Register

Floor

Floor: round down to nearest integer (as float)

Fields

source: Register

dest: Register

Ceil

Ceil: round up to nearest integer (as float)

Fields

source: Register

dest: Register

Round

Round: round to nearest integer (as float)

Fields

source: Register

dest: Register

Trunc

Trunc: truncate toward zero (as float)

Fields

source: Register

dest: Register

Sqrt

Square root

Fields

source: Register

dest: Register

Abs

Absolute value (works for both int and float)

Fields

source: Register

dest: Register

Pow

Power: base^exponent (both operands, result is float)

Fields

base: Register

exp: Register

dest: Register

SendAfter

Send a message to a process after a delay (in reductions) Returns a timer reference in dest for cancellation

Fields

delay: u32

to: Source

msg: Register

dest: Register

StartTimer

Start a timer that sends {:timeout, ref, msg} to self after delay Returns the timer reference in dest

Fields

delay: u32

msg: Register

dest: Register

CancelTimer

Cancel a pending timer by its reference Returns the remaining time if timer was active, or :ok if already fired

Fields

timer_ref: Register

dest: Register

ReadTimer

Read the remaining time on a timer (0 if already fired or cancelled)

Fields

timer_ref: Register

dest: Register

PrintLn

Print a value to stdout with newline

Fields

source: Register

ReadLine

Read a line from stdin into register as String Returns :eof atom if end of input

Fields

dest: Register

FileRead

Read entire file contents as binary Returns {:ok, binary} or {:error, reason}

Fields

path: Register

dest: Register

FileWrite

Write binary/string to file Returns :ok or {:error, reason}

Fields

path: Register

content: Register

dest: Register

FileExists

Check if file exists Returns 1 (true) or 0 (false)

Fields

path: Register

dest: Register

FileDelete

Delete a file Returns :ok or {:error, reason}

Fields

path: Register

dest: Register

SelfPid

Get own PID into register

Fields

dest: Register

ProcessList

Get list of all process PIDs

Fields

dest: Register

ProcessCount

Get count of live processes

Fields

dest: Register

IsAlive

Check if a process is alive Returns 1 (true) or 0 (false)

Fields

pid: Register

dest: Register

ProcessInfo

Get process info as tuple Returns {status, mailbox_len, links_count, monitors_count, trap_exit}

Fields

pid: Register

dest: Register

ModuleList

Get list of loaded module names

Fields

dest: Register

FunctionExported

Check if function is exported Returns 1 (true) or 0 (false)

Fields

module: Register

function: Register

arity: Register

dest: Register

Try

Begin a try block. Pushes exception handler onto try stack. catch_target: where to jump on exception after_target: optional cleanup block (always runs)

Fields

catch_target: usize

after_target: Option<usize>

EndTry

End a try block successfully. Pops handler from try stack. If there’s an after block, jumps to it.

Throw

Throw an exception. Unwinds to nearest catch handler. class: :error, :exit, or :throw reason: the exception reason (from register)

Fields

class: Register

reason: Register

GetException

Get the current exception as {class, reason, stacktrace} tuple Used in catch blocks to access exception details

Fields

dest: Register

ClearException

Clear the current exception (after handling)

Reraise

Re-raise the current exception (in catch block)

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.