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

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

Fields of ConstructVariant

tag: VmIndex

The tag of the data

args: VmIndex

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

ConstructPolyVariant

Fields of ConstructPolyVariant

tag: VmIndex

The tag of the data

args: VmIndex

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

NewVariant

Fields of NewVariant

tag: VmIndex

The tag of the data

args: VmIndex

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

NewRecord

Fields of NewRecord

record: VmIndex

Index to the specification describing which fields this record contains

args: VmIndex

How large the record is

CloseData

Fields of CloseData

index: VmIndex

Where the record is located

ConstructRecord

Fields of ConstructRecord

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

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

Fields of MakeClosure

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

NewClosure

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.

Fields of NewClosure

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

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 Copy for Instruction

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 Eq for Instruction

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, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<Instruction> 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: &Instruction) -> bool

This method tests for !=.

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 StructuralEq for Instruction

impl StructuralPartialEq for Instruction