Enum Opcode 

pub enum Opcode {
    Push(u64),
    PushBool(bool),
    PushStr(String),
    PushNil,
    Pop,
    Dup,
    Swap,
    Add,
    Sub,
    Mul,
    Div,
    Mod,
    Eq,
    Lt,
    Le,
    Not,
    And,
    Or,
    Jump(i32),
    JumpIf(i32),
    JumpIfNot(i32),
    Call(u32),
    Return,
    Load(u32),
    Store(u32),
    LoadGlobal(String),
    MakeClosure(u32),
    Apply,
    Halt,
}

A single bytecode instruction.

Variants

Push(u64)

Push a natural number onto the stack.

PushBool(bool)

Push a boolean onto the stack.

PushStr(String)

Push a string onto the stack.

PushNil

Push nil (unit) onto the stack.

Pop

Discard the top of the stack.

Dup

Duplicate the top of the stack.

Swap

Swap the top two stack elements.

Add

Add the top two naturals.

Sub

Subtract (second - top).

Mul

Multiply the top two naturals.

Div

Divide (second / top). Errors on division by zero.

Mod

Modulo (second % top). Errors on division by zero.

Eq

Equality comparison; pushes Bool.

Lt

Less-than comparison; pushes Bool.

Le

Less-than-or-equal comparison; pushes Bool.

Not

Boolean NOT.

And

Boolean AND.

Or

Boolean OR.

Jump(i32)

Unconditional jump by a signed offset from the next instruction.

JumpIf(i32)

Jump if the top of the stack is Bool(true) (pops the condition).

JumpIfNot(i32)

Jump if the top of the stack is Bool(false) (pops the condition).

Call(u32)

Call a function at position u32 in the chunk (simplified model).

Return

Return from the current function.

Load(u32)

Load local variable at index.

Store(u32)

Store top-of-stack into local variable at index (does not pop).

LoadGlobal(String)

Load a named global value.

MakeClosure(u32)

Create a closure over u32 captured values from the stack.

Apply

Apply a closure on the stack to the argument below it.

Halt

Stop execution.

Trait Implementations

impl Clone for Opcode

fn clone(&self) -> Opcode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Opcode

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

Formats the value using the given formatter.

impl PartialEq for Opcode

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