Struct Execution 

pub struct Execution {
    pub globals: Vec<VMValue>,
    pub stack: Vec<VMValue>,
    pub time: VMValue,
    pub outputs: FxHashMap<String, VMValue>,
    pub debug: bool,
    /* private fields */
}

Fields

globals: Vec<VMValue>

Global variables. The parser keeps count of all global variables and we allocate the array on creation.

stack: Vec<VMValue>

The execution stack.

time: VMValue

Time

outputs: FxHashMap<String, VMValue>

Custom outputs set by special ops (legacy; prefer HostHandler)

debug: bool

When true, print a trace of every op before execution.

Implementations

impl Execution

pub fn new(var_size: usize) -> Self

pub fn default() -> Self

pub fn new_from_var(execution: &Execution) -> Self

pub fn reset(&mut self, var_size: usize)

When switching between programs we need to resize the count of global variables.

pub fn execute_op(&mut self, op: &NodeOp, program: &Program)

pub fn execute_op_host<H: HostHandler>( &mut self, op: &NodeOp, program: &Program, host: &mut H, )

pub fn execute(&mut self, code: &[NodeOp], program: &Program)

pub fn execute_host<H: HostHandler>( &mut self, code: &[NodeOp], program: &Program, host: &mut H, )

pub fn execute_function_no_args( &mut self, index: usize, program: &Program, ) -> VMValue

Call a function with no arguments

pub fn execute_function( &mut self, args: &[VMValue], index: usize, program: &Program, ) -> VMValue

Call a function with arguments provided as a slice.

pub fn execute_function_host<H: HostHandler>( &mut self, args: &[VMValue], index: usize, program: &Program, host: &mut H, ) -> VMValue

Execute a user function, invoking host handler methods inline for host-sensitive ops.