Struct Interpreter

pub struct Interpreter<WIRE: InterpreterTypes> {
    pub bytecode: WIRE::Bytecode,
    pub stack: WIRE::Stack,
    pub return_data: WIRE::ReturnData,
    pub memory: WIRE::Memory,
    pub input: WIRE::Input,
    pub sub_routine: WIRE::SubRoutineStack,
    pub control: WIRE::Control,
    pub runtime_flag: WIRE::RuntimeFlag,
    pub extend: WIRE::Extend,
}

Fields

bytecode: WIRE::Bytecode

stack: WIRE::Stack

return_data: WIRE::ReturnData

memory: WIRE::Memory

input: WIRE::Input

sub_routine: WIRE::SubRoutineStack

control: WIRE::Control

runtime_flag: WIRE::RuntimeFlag

extend: WIRE::Extend

Implementations

impl<EXT: Default, MG: MemoryGetter> Interpreter<EthInterpreter<EXT, MG>>

pub fn new( memory: Rc<RefCell<MG>>, bytecode: Bytecode, inputs: InputsImpl, is_static: bool, is_eof_init: bool, spec_id: SpecId, gas_limit: u64, ) -> Self

Create new interpreter

impl<IW: InterpreterTypes> Interpreter<IW>

pub fn run<FN, H: Host>( &mut self, instruction_table: &[FN; 256], host: &mut H, ) -> InterpreterAction

where FN: CustomInstruction<Wire = IW, Host = H>,

Executes the interpreter until it returns or stops.

Trait Implementations

impl<WIRE: Clone + InterpreterTypes> Clone for Interpreter<WIRE>

where WIRE::Bytecode: Clone, WIRE::Stack: Clone, WIRE::ReturnData: Clone, WIRE::Memory: Clone, WIRE::Input: Clone, WIRE::SubRoutineStack: Clone, WIRE::Control: Clone, WIRE::RuntimeFlag: Clone, WIRE::Extend: Clone,

fn clone(&self) -> Interpreter<WIRE>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<WIRE: Debug + InterpreterTypes> Debug for Interpreter<WIRE>

where WIRE::Bytecode: Debug, WIRE::Stack: Debug, WIRE::ReturnData: Debug, WIRE::Memory: Debug, WIRE::Input: Debug, WIRE::SubRoutineStack: Debug, WIRE::Control: Debug, WIRE::RuntimeFlag: Debug, WIRE::Extend: Debug,

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

Formats the value using the given formatter.

impl<'de, WIRE: InterpreterTypes> Deserialize<'de> for Interpreter<WIRE>

where WIRE::Bytecode: Deserialize<'de>, WIRE::Stack: Deserialize<'de>, WIRE::ReturnData: Deserialize<'de>, WIRE::Memory: Deserialize<'de>, WIRE::Input: Deserialize<'de>, WIRE::SubRoutineStack: Deserialize<'de>, WIRE::Control: Deserialize<'de>, WIRE::RuntimeFlag: Deserialize<'de>, WIRE::Extend: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<WIRE: InterpreterTypes> Serialize for Interpreter<WIRE>

where WIRE::Bytecode: Serialize, WIRE::Stack: Serialize, WIRE::ReturnData: Serialize, WIRE::Memory: Serialize, WIRE::Input: Serialize, WIRE::SubRoutineStack: Serialize, WIRE::Control: Serialize, WIRE::RuntimeFlag: Serialize, WIRE::Extend: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.