Struct Machine

pub struct Machine {
    pub stack: Vec<Ref<Value>>,
    pub registers: BTreeMap<String, Ref<Value>>,
}

Fields

stack: Vec<Ref<Value>>

A dynamically allocated stack to push and pop values onto and off of

registers: BTreeMap<String, Ref<Value>>

The place to store named values (variables)

Implementations

impl Machine

pub fn new() -> Self

Return a new instance of a Machine with empty stack and registers

pub fn get_arg(&mut self) -> Value

#################################################### The following functions are meant to be used to interface and interact with the virtual machine #################################################### FOR FOREIGN FUNCTIONS This gets an argument from the call to this foreign function by popping a value off the stack, and removing the reference

pub fn return_value(&mut self, value: Value)

FOR FOREIGN FUNCTIONS This pushes a return value onto the stack

pub fn duplicate(self) -> Self

#################################################### The following functions represent instructions that are natively supported by the virtual machine. These are not meant to be used by foreign functions, but they CAN be used without worry. #################################################### This function duplicates the current machine. This is VERY IMPORTANT. It iterates through the stack and copies each item into a new machine.

This is ONLY used to create the context for functions. If we don’t do this, the context Machine never goes out of scope, and never lets the Refs die. This causes a memory leak.

The addition of this method fixes the memory leak.

pub fn push(&mut self, value: Ref<Value>)

Push an item onto the stack

pub fn pop(&mut self) -> Ref<Value>

Pop an item off of the stack, and return it If the stack is empty, return an Error

pub fn copy(&mut self)

1. Pop off a REFERENCE value from the stack
2. Push a copy the object and remove the reference

pub fn assign(&mut self)

1. Pop off a REFERENCE value from the stack
2. Pop off a VALUE value from the stack
3. Assign the value of VALUE to the memory location of REFERENCE

This can be used to assign to an indexed value from a list or table

pub fn index(&mut self)

1. Pop off the INDEX value from the stack
2. Pop off a TABLE value from the stack
3. Push the TABLE[INDEX] reference onto the stack

pub fn method_call(&mut self)

1. Pop off the INDEX value from the stack
2. Pop off a TABLE value from the stack
3. Push the TABLE onto the stack
4. Call the value at TABLE[INDEX] as a function

pub fn call(&mut self)

1. Pop off function from the stack
2. Call it with this Machine instance

pub fn for_loop(&mut self)

1. Pop off a COUNTER identifier from the stack
2. Pop off an ELEMENT identifier from the stack
3. Pop off a LIST value from the stack
4. Pop off a BODY function from the stack
5. For COUNTER, ELEMENT in enumeration of LIST:
6. Store LIST[COUNTER] in ELEMENT
7. Call BODY with current instance
8. Increment COUNTER

pub fn while_loop(&mut self)

1. Pop off a CONDITION function from the stack
2. Pop off a BODY function from the stack
3. Call the CONDITION function with the context of this instance
4. If the return value is true, run the BODY function with the context of this instance
5. Goto step 3

pub fn if_then_else(&mut self)

1. Pop off a CONDITION function from the stack
2. Pop off a THEN function from the stack
3. Pop off an ELSE function from the stack
4. Call the CONDITION function with the context of this instance
5. If the return value is true, run the THEN function with the context of this instance
6. If the return value is false, run the ELSE function with the context of this instance

pub fn store(&mut self)

1. Pop off a KEY value from the stack
2. Pop off a VALUE value from the stack
3. Assign the value of VALUE to the register named KEY

pub fn load(&mut self)

1. Pop off a KEY value from the stack
2. Push the value in the register named KEY to the stack

Trait Implementations

impl Clone for Machine

fn clone(&self) -> Machine

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Machine

fn default() -> Machine

Returns the “default value” for a type.

impl Display for Machine

How to print Machine / convert Machine to string This is for debugging code and seeing the current instance of the machine

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

Formats the value using the given formatter.

impl PartialEq for Machine

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

fn partial_cmp(&self, other: &Machine) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Machine