Enum Op 

pub enum Op {
    Nil,
    True,
    False,
    Const(u32),
    Pop,
    Dup,
    Swap,
    GetLocal(u16),
    SetLocal(u16),
    GetUpval(u16),
    SetUpval(u16),
    GetGlobal(u32),
    SetGlobal(u32),
    NewTable,
    SetField(u32),
    GetField(u32),
    SetIndex,
    GetIndex,
    TableAppend,
    SetList(u16),
    Len,
    Neg,
    Not,
    BitNot,
    Add,
    Sub,
    Mul,
    Div,
    IDiv,
    Mod,
    Pow,
    Concat,
    Eq,
    NotEq,
    Lt,
    LtEq,
    Gt,
    GtEq,
    BitAnd,
    BitOr,
    BitXor,
    Shl,
    Shr,
    Jump(i32),
    JumpIf(i32),
    JumpIfNot(i32),
    JumpIfNotPop(i32),
    JumpIfPop(i32),
    Call(u8, u8),
    CallMethod(u32, u8, u8),
    Return(u8),
    TailCall(u8),
    Closure(u32),
    Close(u16),
    ForPrep(u16),
    ForStep,
    ForStepJump(i32),
    NumForInit,
    NumForStep(i32),
    Vararg(u8),
    LineInfo(u32),
}

VM instruction. Operands are embedded to allow the interpreter to avoid secondary table lookups on the hot path.

Variants

Nil

Push nil.

True

Push true.

False

Push false.

Const(u32)

Push proto.constants[idx].

Pop

Dup

Swap

GetLocal(u16)

SetLocal(u16)

GetUpval(u16)

SetUpval(u16)

GetGlobal(u32)

SetGlobal(u32)

NewTable

SetField(u32)

SetField(kidx): pop val; table = peek; table[const_str] = val.

GetField(u32)

GetField(kidx): pop table; push table[const_str].

SetIndex

SetIndex: pop val, key; table = peek; table[key] = val.

GetIndex

GetIndex: pop key, table; push table[key].

TableAppend

TableAppend: pop val; table = peek; append val to array part.

SetList(u16)

SetList(n): pop n values; table = peek; assign t[1..n].

Len

Neg

Not

BitNot

Add

Sub

Mul

Div

IDiv

Mod

Pow

Concat

Eq

NotEq

Lt

LtEq

Gt

GtEq

BitAnd

BitOr

BitXor

Shl

Shr

Jump(i32)

Relative unconditional jump. ip += offset (can be negative).

JumpIf(i32)

Peek top; if truthy jump (no pop).

JumpIfNot(i32)

Peek top; if falsy jump (no pop).

JumpIfNotPop(i32)

Pop top; if falsy jump — used for short-circuit and.

JumpIfPop(i32)

Pop top; if truthy jump — used for short-circuit or.

Call(u8, u8)

Call(nargs, nret): pop nargs + callee; push nret results (0 = all).

CallMethod(u32, u8, u8)

CallMethod(name_kidx, nargs, nret): obj on stack; method = const_str.

Return(u8)

Return(n): pop n values and return (0 = return all).

TailCall(u8)

Tail-call optimisation.

Closure(u32)

Create a closure from proto.protos[idx], capturing upvalues.

Close(u16)

Close the upvalue at local slot slot.

ForPrep(u16)

Prepare generic-for: push iterator state.

ForStep

Advance generic-for; pop results if exhausted (implied jump offset in combination with ForStepJump).

ForStepJump(i32)

Like ForStep but with a jump offset for the exhausted case.

NumForInit

Push and validate [start, limit, step] for numeric-for.

NumForStep(i32)

Advance numeric-for; jump by offset if done.

Vararg(u8)

Push n vararg values (0 = all).

LineInfo(u32)

Trait Implementations

impl Clone for Op

fn clone(&self) -> Op

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Op

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

Formats the value using the given formatter.

impl PartialEq for Op

fn eq(&self, other: &Op) -> 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 StructuralPartialEq for Op