Enum RuntimeInstruction 

pub enum RuntimeInstruction {
    Span(u32, u32, u32),
    Label,
    FunctionStart,
    FunctionEnd,
    Breakpoint,
    Branch(u32),
    ConditionalBranch(u32, u32),
    Return(u32),
    IndirectCall,
    Call(u32, u32),
    Halt,
    Print,
    Load(Type, u32),
    Store(Type, u32),
    Dup,
    HeapAlloc(u32),
    GetItem,
    HeapDealloc,
    Const(Value),
    Add(Type),
    Sub(Type),
    Mul(Type),
    Div(Type),
    Rem(Type),
    Neg(Type),
    Shl(Type),
    Shr(Type),
    Rol(Type),
    Ror(Type),
    BitAnd(Type),
    BitOr(Type),
    BitXor(Type),
    Not,
    And,
    Or,
    Xor,
    Eq(Type),
    Ne(Type),
    Lt(Type),
    Gt(Type),
    Le(Type),
    Ge(Type),
}

Runtime bytecode instructions.

Source text parses into the separate SurfaceInstruction enum below. Keeping the source and runtime forms separate lets patterns carry symbolic names and surface types until a resolver converts them to runtime values. Runtime variant order remains stable because it determines derived opcodes.

Variants

Span(u32, u32, u32)

span file:file_id start:u32 end:u32 span 0 1 2 — three space-separated u32s.

Label

Label definition.

FunctionStart

func_start <name> — marks function entry. <name> is symbolic and orchestrator-resolved; the unit variant carries no payload.

FunctionEnd

func_end <name> — marks function exit (debug only).

Breakpoint

breakpoint. Must precede Branch (whose token br would be a prefix of breakpoint).

Branch(u32)

br <target> — symbolic. Deferred to orchestrator.

ConditionalBranch(u32, u32)

cond_br <true_target>, <false_target> — symbolic. Deferred.

Return(u32)

ret (bare) is the form real .sst uses; numeric ret <n> has no precedent so we defer. Orchestrator emits Return(0) for bare ret.

IndirectCall

call_indirect. Must precede Call for the prefix check.

Call(u32, u32)

call <arity>, <addr> — symbolic addr. Deferred.

Halt

halt — stop execution.

Print

print — write top-of-stack to stdout.

Load(Type, u32)

load.<type> <address> — two fields with single-space separator.

Store(Type, u32)

store.<type> <address>.

Dup

dup.

HeapAlloc(u32)

heap_alloc <n>.

GetItem

get_item. Must precede Ge (token ge ⊂ get_item).

HeapDealloc

heap_dealloc — pops a HeapRef and marks the slot dead, returning it to the free list for reuse by the next heap_alloc.

Const(Value)

const.<type> <literal> — numeric/bool only here. .str/.fn_ref/ .heap_ref are orchestrator-handled.

Add(Type)

Sub(Type)

Mul(Type)

Div(Type)

Rem(Type)

Neg(Type)

Shl(Type)

Shr(Type)

Rol(Type)

Ror(Type)

BitAnd(Type)

BitOr(Type)

BitXor(Type)

Not

And

Or

Xor

Eq(Type)

Ne(Type)

Lt(Type)

Gt(Type)

Le(Type)

Ge(Type)

Trait Implementations

impl CanonicalInstructionSyntax for RuntimeInstruction

fn variants() -> &'static [CanonicalInstructionVariantSyntax]

impl Clone for RuntimeInstruction

fn clone(&self) -> RuntimeInstruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuntimeInstruction

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

Formats the value using the given formatter.

impl Display for RuntimeInstruction

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

Formats the value using the given formatter.

impl<T: Into<Value>> From<T> for RuntimeInstruction

fn from(value: T) -> Self

Converts to this type from the input type.

impl FromBytesWithOpcode for RuntimeInstruction

fn from_bytes_with_opcode<R: Read>(bytes: &mut R, opcode: u8) -> Result<Self>

impl OpCode for RuntimeInstruction

fn width() -> u32

fn opcode(&self) -> u8

impl PartialEq for RuntimeInstruction

fn eq(&self, other: &RuntimeInstruction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl WriteBytes for RuntimeInstruction

fn write_bytes<W: Write>(&self, io: &mut W) -> Result<()>

impl StructuralPartialEq for RuntimeInstruction