Enum runestick::Inst

pub enum Inst {
    Not,
    Add,
    AddAssign {
        offset: usize,
    },
    Sub,
    SubAssign {
        offset: usize,
    },
    Mul,
    MulAssign {
        offset: usize,
    },
    Div,
    DivAssign {
        offset: usize,
    },
    Rem,
    Fn {
        hash: Hash,
    },
    Closure {
        hash: Hash,
        count: usize,
    },
    Call {
        hash: Hash,
        args: usize,
    },
    CallInstance {
        hash: Hash,
        args: usize,
    },
    LoadInstanceFn {
        hash: Hash,
    },
    CallFn {
        args: usize,
    },
    IndexGet,
    TupleIndexGet {
        index: usize,
    },
    TupleIndexSet {
        index: usize,
    },
    TupleIndexGetAt {
        offset: usize,
        index: usize,
    },
    ObjectSlotIndexGet {
        slot: usize,
    },
    ObjectSlotIndexGetAt {
        offset: usize,
        slot: usize,
    },
    IndexSet,
    Integer {
        number: i64,
    },
    Float {
        number: f64,
    },
    Await,
    Select {
        len: usize,
    },
    Pop,
    PopN {
        count: usize,
    },
    PopAndJumpIf {
        count: usize,
        offset: isize,
    },
    PopAndJumpIfNot {
        count: usize,
        offset: isize,
    },
    Clean {
        count: usize,
    },
    Copy {
        offset: usize,
    },
    Drop {
        offset: usize,
    },
    Dup,
    Replace {
        offset: usize,
    },
    Return,
    ReturnUnit,
    Lt,
    Gt,
    Lte,
    Gte,
    Eq,
    Neq,
    Jump {
        offset: isize,
    },
    JumpIf {
        offset: isize,
    },
    JumpIfNot {
        offset: isize,
    },
    JumpIfBranch {
        branch: i64,
        offset: isize,
    },
    Unit,
    Bool {
        value: bool,
    },
    Vec {
        count: usize,
    },
    Tuple {
        count: usize,
    },
    Object {
        slot: usize,
    },
    TypedObject {
        hash: Hash,
        slot: usize,
    },
    VariantObject {
        enum_hash: Hash,
        hash: Hash,
        slot: usize,
    },
    Char {
        c: char,
    },
    Byte {
        b: u8,
    },
    String {
        slot: usize,
    },
    Bytes {
        slot: usize,
    },
    StringConcat {
        len: usize,
        size_hint: usize,
    },
    Is,
    IsNot,
    And,
    Or,
    IsUnit,
    IsValue,
    Unwrap,
    EqByte {
        byte: u8,
    },
    EqCharacter {
        character: char,
    },
    EqInteger {
        integer: i64,
    },
    EqStaticString {
        slot: usize,
    },
    MatchSequence {
        type_check: TypeCheck,
        len: usize,
        exact: bool,
    },
    MatchObject {
        type_check: TypeCheck,
        slot: usize,
        exact: bool,
    },
    Type {
        hash: Hash,
    },
    Yield,
    YieldUnit,
    Panic {
        reason: PanicReason,
    },
}

An operation in the stack-based virtual machine.

Variants

Not

Not operator. Takes a boolean from the top of the stack and inverts its logical value.

Operation

<bool>
=> <bool>

Add

Add two things together.

This is the result of an <a> + <b> expression.

AddAssign

Add a value to the given frame offset.

This is the result of an <offset> += <b> expression.

Fields of AddAssign

offset: usize

The frame offset to assign to.

Sub

Subtract two things.

This is the result of an <a> - <b> expression.

SubAssign

Subtract a value to the given frame offset.

This is the result of an <offset> -= <b> expression.

Fields of SubAssign

offset: usize

The frame offset to assign to.

Mul

Multiply two things.

This is the result of an <a> * <b> expression.

MulAssign

Multiply a value to the given frame offset.

This is the result of an <offset> *= <b> expression.

Fields of MulAssign

offset: usize

The frame offset to assign to.

Div

Divide two things.

This is the result of an <a> / <b> expression.

DivAssign

Divide a value to the given frame offset.

This is the result of an <offset> /= <b> expression.

Fields of DivAssign

offset: usize

The frame offset to assign to.

Rem

Remainder operation.

This is the result of an <a> % <b> expression.

Operation

<value>
<value>
=> <value>

Fn

Encode a function pointer on the stack.

Operation

=> <fn>

Fields of Fn

hash: Hash

The hash to construct a function pointer from.

Closure

Construct a closure that takes the given number of arguments and captures count elements from the top of the stack.

Operation

<value..>
=> <fn>

Fields of Closure

hash: Hash

The hash of the internally stored closure function.

count: usize

The number of arguments to store in the environment on the stack.

Call

Perform a function call.

It will construct a new stack frame which includes the last args number of entries.

Fields of Call

hash: Hash

The hash of the function to call.

args: usize

The number of arguments expected on the stack for this call.

CallInstance

Perform a instance function call.

The instance being called on should be on top of the stack, followed by args number of arguments.

Fields of CallInstance

hash: Hash

The hash of the name of the function to call.

args: usize

The number of arguments expected on the stack for this call.

LoadInstanceFn

Lookup the specified instance function and put it on the stack. This might help in cases where a single instance function is called many times (like in a loop) since it avoids calculating its full hash on every iteration.

Note that this does not resolve that the instance function exists, only that the instance does.

Operation

<value>
=> <fn>

Fields of LoadInstanceFn

hash: Hash

The name hash of the instance function.

CallFn

Perform a function call on a function pointer stored on the stack.

Operation

<fn>
<args...>
=> <ret>

Fields of CallFn

args: usize

The number of arguments expected on the stack for this call.

IndexGet

Perform an index get operation. Pushing the result on the stack.

Operation

<target>
<index>
=> <value>

TupleIndexGet

Get the given index out of a tuple on the top of the stack. Errors if the item doesn't exist or the item is not a tuple.

Operation

<tuple>
=> <value>

Fields of TupleIndexGet

index: usize

The index to fetch.

TupleIndexSet

Set the given index of the tuple on the stack, with the given value.

Operation

<value>
<tuple>
=> *nothing*

Fields of TupleIndexSet

index: usize

The index to set.

TupleIndexGetAt

Get the given index out of a tuple from the given variable slot. Errors if the item doesn't exist or the item is not a tuple.

Operation

=> <value>

Fields of TupleIndexGetAt

offset: usize

The slot offset to load the tuple from.

index: usize

The index to fetch.

ObjectSlotIndexGet

Get the given index out of an object on the top of the stack. Errors if the item doesn't exist or the item is not an object.

The index is identifier by a static string slot, which is provided as an argument.

Operation

<object>
=> <value>

Fields of ObjectSlotIndexGet

slot: usize

The static string slot corresponding to the index to fetch.

ObjectSlotIndexGetAt

Get the given index out of an object from the given variable slot. Errors if the item doesn't exist or the item is not an object.

The index is identifier by a static string slot, which is provided as an argument.

Operation

=> <value>

Fields of ObjectSlotIndexGetAt

offset: usize

The slot offset to get the value to test from.

slot: usize

The static string slot corresponding to the index to fetch.

IndexSet

Perform an index set operation.

Operation

<target>
<index>
<value>
=> *noop*

Integer

Push a literal integer.

Fields of Integer

number: i64

The number to push.

Float

Push a literal float into a slot.

Fields of Float

number: f64

The number to push.

Await

Await the future that is on the stack and push the value that it produces.

Operation

<future>
=> <value>

Select

Select over len futures on the stack. Sets the branch register to the index of the branch that completed. And pushes its value on the stack.

This operation will block the VM until at least one of the underlying futures complete.

Operation

<future...>
=> <value>

Fields of Select

len: usize

The number of futures to poll.

Pop

Pop the value on the stack, discarding its result.

Operation

<value>
=>

PopN

Pop the given number of elements from the stack.

Operation

<value..>
=> *noop*

Fields of PopN

count: usize

The number of elements to pop from the stack.

PopAndJumpIf

If the stop of the stack is true, will pop the given count entries on the stack and jump to the given offset.

Operation

<bool>
=> *noop*

Fields of PopAndJumpIf

count: usize

The number of entries to pop of the condition is true.

offset: isize

The offset to jump if the condition is true.

PopAndJumpIfNot

If the stop of the stack is false, will pop the given count entries on the stack and jump to the given offset.

Operation

<bool>
=> *noop*

Fields of PopAndJumpIfNot

count: usize

The number of entries to pop of the condition is true.

offset: isize

The offset to jump if the condition is true.

Clean

Clean the stack by keeping the top of it, and popping count values under it.

Operation

<top>
<value..>
=> <top>

Fields of Clean

count: usize

The number of entries in the stack to pop.

Copy

Copy a variable from a location offset relative to the current call frame.

A copy is very cheap. It simply means pushing a reference to the stack.

Fields of Copy

offset: usize

Offset to copy value from.

Drop

Drop the value in the given frame offset, cleaning out it's slot in memory.

Operation

=> *noop*

Fields of Drop

offset: usize

Frame offset to drop.

Dup

Duplicate the value at the top of the stack.

Operation

=> <value>

Replace

Replace a value at the offset relative from the top of the stack, with the top of the stack.

Fields of Replace

offset: usize

Offset to swap value from.

Return

Pop the current stack frame and restore the instruction pointer from it.

The stack frame will be cleared, and the value on the top of the stack will be left on top of it.

ReturnUnit

Pop the current stack frame and restore the instruction pointer from it.

The stack frame will be cleared, and a unit value will be pushed to the top of the stack.

Lt

Compare two values on the stack for lt and push the result as a boolean on the stack.

Gt

Compare two values on the stack for gt and push the result as a boolean on the stack.

Lte

Compare two values on the stack for lte and push the result as a boolean on the stack.

Gte

Compare two values on the stack for gte and push the result as a boolean on the stack.

Eq

Compare two values on the stack for equality and push the result as a boolean on the stack.

Operation

<b>
<a>
=> <bool>

Neq

Compare two values on the stack for inequality and push the result as a boolean on the stack.

Operation

<b>
<a>
=> <bool>

Jump

Unconditionally jump to offset relative to the current instruction pointer.

Operation

*nothing*
=> *nothing*

Fields of Jump

offset: isize

Offset to jump to.

JumpIf

Jump to offset relative to the current instruction pointer if the condition is true.

Operation

<boolean>
=> *nothing*

Fields of JumpIf

offset: isize

Offset to jump to.

JumpIfNot

Jump to offset relative to the current instruction pointer if the condition is false.

Operation

<boolean>
=> *nothing*

Fields of JumpIfNot

offset: isize

Offset to jump to.

JumpIfBranch

Compares the branch register with the top of the stack, and if they match pops the top of the stack and performs the jump to offset.

Operation

<integer>
=> *nothing*

Fields of JumpIfBranch

branch: i64

The branch value to compare against.

offset: isize

The offset to jump.

Unit

Push a unit value onto the stack.

Operation

=> <unit>

Bool

Push a boolean value onto the stack.

Operation

=> <boolean>

Fields of Bool

value: bool

The boolean value to push.

Vec

Construct a push a vector value onto the stack. The number of elements in the vector are determined by count and are popped from the stack.

Operation

<value..>
=> <vec>

Fields of Vec

count: usize

The size of the vector.

Tuple

Construct a push a tuple value onto the stack. The number of elements in the tuple are determined by count and are popped from the stack.

Operation

<value..>
=> <tuple>

Fields of Tuple

count: usize

The size of the tuple.

Object

Construct a push an object onto the stack. The number of elements in the object are determined the slot of the object keys slot and are popped from the stack.

For each element, a value is popped corresponding to the object key.

Operation

<value..>
=> <object>

Fields of Object

slot: usize

The static slot of the object keys.

TypedObject

Construct a push an object of the given type onto the stack. The number of elements in the object are determined the slot of the object keys slot and are popped from the stack.

For each element, a value is popped corresponding to the object key.

Operation

<value..>
=> <object>

Fields of TypedObject

hash: Hash

The type of the object to construct.

slot: usize

The static slot of the object keys.

VariantObject

Construct a push an object of the given type onto the stack. The number of elements in the object are determined the slot of the object keys slot and are popped from the stack.

For each element, a value is popped corresponding to the object key.

Operation

<value..>
=> <object>

Fields of VariantObject

enum_hash: Hash

The enum the variant belongs to.

hash: Hash

The type of the object to construct.

slot: usize

The static slot of the object keys.

Char

Load a literal character.

Operation

=> <char>

Fields of Char

c: char

The literal character to load.

Byte

Load a literal byte.

Operation

=> <byte>

Fields of Byte

b: u8

The literal byte to load.

String

Load a literal string from a static string slot.

Operation

=> <string>

Fields of String

slot: usize

The static string slot to load the string from.

Bytes

Load a literal byte string from a static byte string slot.

Operation

=> <bytes>

Fields of Bytes

slot: usize

The static byte string slot to load the string from.

StringConcat

Pop the given number of values from the stack, and concatenate a string from them.

This is a dedicated template-string optimization.

Operation

<value...>
=> <string>

Fields of StringConcat

len: usize

The number of items to pop from the stack.

size_hint: usize

The minimum string size used.

Is

Test if the top of the stack is an instance of the second item on the stack.

Operation

<type>
<value>
=> <boolean>

IsNot

Test if the top of the stack is not an instance of the second item on the stack.

Operation

<type>
<value>
=> <boolean>

And

Pop two values from the stack and test if they are both boolean true.

Operation

<boolean>
<boolean>
=> <boolean>

Or

Pop two values from the stack and test if either of them are boolean true.

Operation

<boolean>
<boolean>
=> <boolean>

IsUnit

Test if the top of the stack is a unit.

Operation

<value>
=> <boolean>

IsValue

Test if the top of the stack is a value.

This expects the top of the stack to be an option or a result, and it is a value if these are either Some or Ok.

Operation

<value>
=> <boolean>

Unwrap

Unwrap a result from the top of the stack. This causes a vm error if the top of the stack is not an ok result.

Operation

<result>
=> <value>

EqByte

Test if the top of the stack is a specific byte.

Operation

<value>
=> <boolean>

Fields of EqByte

byte: u8

The byte to test against.

EqCharacter

Test if the top of the stack is a specific character.

Operation

<value>
=> <boolean>

Fields of EqCharacter

character: char

The character to test against.

EqInteger

Test if the top of the stack is a specific integer.

Operation

<value>
=> <boolean>

Fields of EqInteger

integer: i64

The integer to test against.

EqStaticString

Compare the top of the stack against a static string slot.

Operation

<value>
=> <boolean>

Fields of EqStaticString

slot: usize

The slot to test against.

MatchSequence

Test that the top of the stack is a tuple with the given length requirements.

Operation

<value>
=> <boolean>

Fields of MatchSequence

type_check: TypeCheck

Type constraints that the sequence must match.

len: usize

The minimum length to test for.

exact: bool

Whether the operation should check exact true or minimum length false.

MatchObject

Test that the top of the stack is an object matching the given slot of object keys.

Operation

<object>
=> <boolean>

Fields of MatchObject

type_check: TypeCheck

Type constraints that the object must match.

slot: usize

The slot of object keys to use.

exact: bool

Whether the operation should check exact true or minimum length false.

Type

Push the type with the given hash as a value on the stack.

Operation

=> <value>

Fields of Type

hash: Hash

The hash of the type.

Yield

Perform a generator yield where the value yielded is expected to be found at the top of the stack.

This causes the virtual machine to suspend itself.

Operation

<value>
=> <value>

YieldUnit

Perform a generator yield with a unit.

This causes the virtual machine to suspend itself.

Operation

=> <unit>

Panic

Cause the VM to panic and error out without a reason.

This should only be used during testing or extreme scenarios that are completely unrecoverable.

Fields of Panic

reason: PanicReason

The reason for the panic.

Trait Implementations

impl Clone for Inst

fn clone(&self) -> Inst

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Inst

impl Debug for Inst

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

Formats the value using the given formatter.

impl Display for Inst

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

Formats the value using the given formatter.