Struct VmState 

pub struct VmState<'a> {

    pub code: OwnedCellSlice,
    pub throw_on_code_access: bool,
    pub stack: SafeRc<Stack>,
    pub signature_domains: SafeRc<Vec<SignatureDomain>>,
    pub cr: ControlRegs,
    pub committed_state: Option<CommittedState>,
    pub steps: u64,
    pub quit0: SafeRc<QuitCont>,
    pub quit1: SafeRc<QuitCont>,
    pub gas: GasConsumer<'a>,
    pub cp: &'static DispatchTable,
    pub debug: Option<&'a mut dyn Write>,
    pub modifiers: BehaviourModifiers,
    pub version: VmVersion,
    pub parent: Option<Box<ParentVmState<'a>>>,
}

Full execution state.

Fields

code: OwnedCellSlice

Current code slice.

throw_on_code_access: bool

Whether VM state is completely invalid.

stack: SafeRc<Stack>

Main VM stack.

signature_domains: SafeRc<Vec<SignatureDomain>>

Signature domain stack.

cr: ControlRegs

Control registers.

committed_state: Option<CommittedState>

Commited data and actions.

steps: u64

Number of execution steps.

quit0: SafeRc<QuitCont>

c0 continuation.

quit1: SafeRc<QuitCont>

c1 continuation.

gas: GasConsumer<'a>

Gas usage.

cp: &'static DispatchTable

Current codepage.

debug: Option<&'a mut dyn Write>

Debug instructions output.

modifiers: BehaviourModifiers

VM behaviour modifiers.

version: VmVersion

Version.

parent: Option<Box<ParentVmState<'a>>>

Parent VM state.

Implementations

impl<'a> VmState<'a>

pub const DEFAULT_VERSION: VmVersion = VmVersion::LATEST_TON

pub const MAX_DATA_DEPTH: u16 = 512

pub fn builder() -> VmStateBuilder<'a>

pub fn step(&mut self) -> VmResult<i32>

pub fn run(&mut self) -> i32

pub fn try_commit(&mut self) -> bool

pub fn force_commit(&mut self) -> Result<(), Error>

pub fn take_stack(&mut self) -> SafeRc<Stack>

pub fn ref_to_cont(&mut self, code: Cell) -> VmResult<RcCont>

pub fn c1_envelope_if(&mut self, cond: bool, cont: RcCont, save: bool) -> RcCont

pub fn c1_envelope(&mut self, cont: RcCont, save: bool) -> RcCont

pub fn c1_save_set(&mut self)

pub fn extract_cc( &mut self, mode: SaveCr, stack_copy: Option<u16>, nargs: Option<u16>, ) -> VmResult<RcCont>

pub fn throw_exception(&mut self, n: i32) -> VmResult<i32>

pub fn throw_exception_with_arg( &mut self, n: i32, arg: RcStackValue, ) -> VmResult<i32>

pub fn throw_out_of_gas(&mut self) -> i32

pub fn call(&mut self, cont: RcCont) -> VmResult<i32>

pub fn call_ext( &mut self, cont: RcCont, pass_args: Option<u16>, ret_args: Option<u16>, ) -> VmResult<i32>

pub fn jump(&mut self, cont: RcCont) -> VmResult<i32>

pub fn jump_ext( &mut self, cont: RcCont, pass_args: Option<u16>, ) -> VmResult<i32>

pub fn ret(&mut self) -> VmResult<i32>

pub fn ret_ext(&mut self, ret_args: Option<u16>) -> VmResult<i32>

pub fn ret_alt(&mut self) -> VmResult<i32>

pub fn ret_alt_ext(&mut self, ret_args: Option<u16>) -> VmResult<i32>

pub fn repeat(&mut self, body: RcCont, after: RcCont, n: u32) -> VmResult<i32>

pub fn until(&mut self, body: RcCont, after: RcCont) -> VmResult<i32>

pub fn loop_while( &mut self, cond: RcCont, body: RcCont, after: RcCont, ) -> VmResult<i32>

pub fn again(&mut self, body: RcCont) -> VmResult<i32>

pub fn adjust_cr(&mut self, save: &ControlRegs)

pub fn preclear_cr(&mut self, save: &ControlRegs)

pub fn set_c0(&mut self, cont: RcCont)

pub fn set_code(&mut self, code: OwnedCellSlice, cp: u16) -> VmResult<()>

pub fn force_cp(&mut self, cp: u16) -> VmResult<()>