Enum gluon_vm::types::Instruction

pub enum Instruction {
    PushInt(VmInt),
    PushByte(u8),
    PushFloat(EqFloat),
    PushString(VmIndex),
    PushUpVar(VmIndex),
    Push(VmIndex),
    Call(VmIndex),
    TailCall(VmIndex),
    ConstructVariant {
        tag: VmIndex,
        args: VmIndex,
    },
    ConstructPolyVariant {
        tag: VmIndex,
        args: VmIndex,
    },
    NewVariant {
        tag: VmIndex,
        args: VmIndex,
    },
    NewRecord {
        record: VmIndex,
        args: VmIndex,
    },
    CloseData {
        index: VmIndex,
    },
    ConstructRecord {
        record: VmIndex,
        args: VmIndex,
    },
    ConstructArray(VmIndex),
    GetOffset(VmIndex),
    GetField(VmIndex),
    Split,
    TestTag(VmTag),
    TestPolyTag(VmIndex),
    Jump(VmIndex),
    CJump(VmIndex),
    Pop(VmIndex),
    Slide(VmIndex),
    MakeClosure {
        function_index: VmIndex,
        upvars: VmIndex,
    },
    NewClosure {
        function_index: VmIndex,
        upvars: VmIndex,
    },
    CloseClosure(VmIndex),
    AddInt,
    SubtractInt,
    MultiplyInt,
    DivideInt,
    IntLT,
    IntEQ,
    AddByte,
    SubtractByte,
    MultiplyByte,
    DivideByte,
    ByteLT,
    ByteEQ,
    AddFloat,
    SubtractFloat,
    MultiplyFloat,
    DivideFloat,
    FloatLT,
    FloatEQ,
    Return,
}

Enum which represent the instructions executed by the virtual machine.

The binary arithmetic instructions pop two values of the stack and then push the result.

Variants

PushInt(VmInt)

Push an integer to the stack

PushByte(u8)

Push a byte to the stack

PushFloat(EqFloat)

Push a float to the stack

PushString(VmIndex)

Push a string to the stack by loading the string at index in the currently executing function

PushUpVar(VmIndex)

Push a variable to the stack by loading the upvariable at index from the currently executing function

Push(VmIndex)

Push the value at index

Call(VmIndex)

Call a function by passing it args number of arguments. The function is at the index in the stack just before the arguments. After the call is all arguments are removed and the function is replaced by the result of the call.

TailCall(VmIndex)

Tailcalls a function, removing the current stack frame before calling it. See Call.

ConstructVariant

Fields

tag: VmIndex

The tag of the data

args: VmIndex

How many arguments that is taken from the stack to construct the data.

Constructs a data value tagged by tag by taking the top args values of the stack.

ConstructPolyVariant

Fields

tag: VmIndex

The tag of the data

args: VmIndex

How many arguments that is taken from the stack to construct the data.

NewVariant

Fields

tag: VmIndex

The tag of the data

args: VmIndex

How many arguments that is taken from the stack to construct the data.

NewRecord

Fields

record: VmIndex

Index to the specification describing which fields this record contains

args: VmIndex

How large the record is

CloseData

Fields

index: VmIndex

Where the record is located

ConstructRecord

Fields

record: VmIndex

Index to the specification describing which fields this record contains

args: VmIndex

How many arguments that is taken from the stack to construct the data.

ConstructArray(VmIndex)

Constructs an array containing args values.

GetOffset(VmIndex)

Retrieves the field at offset of an object at the top of the stack. The result of the field access replaces the object on the stack.

GetField(VmIndex)

Retrieves the field of a polymorphic record by retrieving the string constant at index and using that to retrieve lookup the field. The result of the field access replaces the object on the stack.

Split

Splits a object, pushing all contained values to the stack.

TestTag(VmTag)

Tests if the value at the top of the stack is tagged with tag. Pushes True if the tag matches, otherwise False

TestPolyTag(VmIndex)

Jump(VmIndex)

Jumps to the instruction at index in the currently executing function.

CJump(VmIndex)

Jumps to the instruction at index in the currently executing function if True is at the top of the stack and pops that value.

Pop(VmIndex)

Pops the top n values from the stack.

Slide(VmIndex)

Pops the top value from the stack, then pops n more values, finally the first value is pushed back to the stack.

MakeClosure

Fields

function_index: VmIndex

The index in the currently executing function which the function data is located at

upvars: VmIndex

How many upvariables the closure contains

Creates a closure with the function at function_index of the currently executing function and upvars upvariables popped from the top of the stack.

NewClosure

Fields

function_index: VmIndex

The index in the currently executing function which the function data is located at

upvars: VmIndex

How many upvariables the closure contains

Creates a closure with the function at function_index of the currently executing function. The closure has room for upvars upvariables but these are not filled until the matching call to ClosureClosure is executed.

CloseClosure(VmIndex)

Fills the previously allocated closure with n upvariables.

AddInt

SubtractInt

MultiplyInt

DivideInt

IntLT

IntEQ

AddByte

SubtractByte

MultiplyByte

DivideByte

ByteLT

ByteEQ

AddFloat

SubtractFloat

MultiplyFloat

DivideFloat

FloatLT

FloatEQ

Return

Implementations

impl Instruction

pub fn adjust(&self) -> i32

Returns by how much the stack is adjusted when executing the instruction self.

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a copy 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.

impl<'de> Deserialize<'de> for Instruction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Instruction

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Instruction

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Instruction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Instruction

impl Eq for Instruction

impl StructuralEq for Instruction

impl StructuralPartialEq for Instruction