Struct State

struct State<'i> {
    pub global_map: GlobalMap,
    pub stack_frame: StackFrame<'i>,
    pub stack: Vec<StackFrame<'i>>,
    pub memory: Memory,
    pub ir: &'i TranslationUnit,
}

Fields

global_map: GlobalMap

Maps each global variable to a pointer value.

When a function call occurs, registers can be initialized by global_registers

stack_frame: StackFrame<'i>

stack: Vec<StackFrame<'i>>

memory: Memory

ir: &'i TranslationUnit

Implementations

impl<'i> State<'i>

fn new( ir: &'i TranslationUnit, args: Vec<Value>, ) -> Result<State<'i>, InterpreterError>

fn alloc_global_variables(&mut self) -> Result<(), InterpreterError>

fn alloc_local_variables(&mut self) -> Result<(), InterpreterError>

fn write_args( &mut self, bid_init: BlockId, args: Vec<Value>, ) -> Result<(), InterpreterError>

fn step(&mut self) -> Result<Option<Value>, InterpreterError>

fn run(&mut self) -> Result<Value, InterpreterError>

fn interp_args( &self, signature: &FunctionSignature, args: &[Operand], ) -> Result<Vec<Value>, InterpreterError>

fn interp_jump( &mut self, arg: &JumpArg, ) -> Result<Option<Value>, InterpreterError>

fn interp_block_exit( &mut self, block_exit: &BlockExit, ) -> Result<Option<Value>, InterpreterError>

fn interp_instruction( &mut self, instruction: &Instruction, ) -> Result<(), InterpreterError>

fn interp_operand(&self, operand: &Operand) -> Result<Value, InterpreterError>

fn interp_constant(&self, value: Constant) -> Value

fn interp_ptr( &mut self, pointer: &Value, ) -> Result<(usize, isize, Dtype), InterpreterError>

Trait Implementations

impl<'i> Debug for State<'i>

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

Formats the value using the given formatter.

impl<'i> PartialEq for State<'i>

fn eq(&self, other: &State<'i>) -> 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<'i> StructuralPartialEq for State<'i>