Struct Interpreter

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

Main interpreter structure that contains all components defines in InterpreterTypes.s

Fields

bytecode: <WIRE as InterpreterTypes>::Bytecode

stack: <WIRE as InterpreterTypes>::Stack

return_data: <WIRE as InterpreterTypes>::ReturnData

memory: <WIRE as InterpreterTypes>::Memory

input: <WIRE as InterpreterTypes>::Input

sub_routine: <WIRE as InterpreterTypes>::SubRoutineStack

control: <WIRE as InterpreterTypes>::Control

runtime_flag: <WIRE as InterpreterTypes>::RuntimeFlag

extend: <WIRE as InterpreterTypes>::Extend

Implementations

impl<EXT> Interpreter<EthInterpreter<EXT>>

where EXT: Default,

pub fn new( memory: SharedMemory, bytecode: ExtBytecode, inputs: InputsImpl, is_static: bool, is_eof_init: bool, spec_id: SpecId, gas_limit: u64, ) -> Interpreter<EthInterpreter<EXT>>

Create new interpreter

pub fn with_bytecode( self, bytecode: Bytecode, ) -> Interpreter<EthInterpreter<EXT>>

Sets the bytecode that is going to be executed

impl<IW> Interpreter<IW>

where IW: InterpreterTypes,

pub fn reset_control(&mut self)

Resets the control to the initial state. so that we can run the interpreter again.

pub fn take_next_action(&mut self) -> InterpreterAction

Takes the next action from the control and returns it.

pub fn run_plain<H>( &mut self, instruction_table: &[for<'a> fn(&'a mut Interpreter<IW>, &'a mut H); 256], host: &mut H, ) -> InterpreterAction

where H: Host + ?Sized,

Executes the interpreter until it returns or stops.

impl<IW> Interpreter<IW>

where IW: InterpreterTypes, <IW as InterpreterTypes>::Output: From<InterpreterAction>,

pub fn take_next_action_as_output(&mut self) -> <IW as InterpreterTypes>::Output

Takes the next action from the control and returns it as the specific Output type.

pub fn run_plain_as_output<H>( &mut self, instruction_table: &[for<'a> fn(&'a mut Interpreter<IW>, &'a mut H); 256], host: &mut H, ) -> <IW as InterpreterTypes>::Output

where H: Host + ?Sized,

Executes the interpreter until it returns or stops, returning the specific Output type.

Trait Implementations

impl<WIRE> Clone for Interpreter<WIRE>

where WIRE: Clone + InterpreterTypes, <WIRE as InterpreterTypes>::Bytecode: Clone, <WIRE as InterpreterTypes>::Stack: Clone, <WIRE as InterpreterTypes>::ReturnData: Clone, <WIRE as InterpreterTypes>::Memory: Clone, <WIRE as InterpreterTypes>::Input: Clone, <WIRE as InterpreterTypes>::SubRoutineStack: Clone, <WIRE as InterpreterTypes>::Control: Clone, <WIRE as InterpreterTypes>::RuntimeFlag: Clone, <WIRE as InterpreterTypes>::Extend: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<WIRE> Debug for Interpreter<WIRE>

where WIRE: Debug + InterpreterTypes, <WIRE as InterpreterTypes>::Bytecode: Debug, <WIRE as InterpreterTypes>::Stack: Debug, <WIRE as InterpreterTypes>::ReturnData: Debug, <WIRE as InterpreterTypes>::Memory: Debug, <WIRE as InterpreterTypes>::Input: Debug, <WIRE as InterpreterTypes>::SubRoutineStack: Debug, <WIRE as InterpreterTypes>::Control: Debug, <WIRE as InterpreterTypes>::RuntimeFlag: Debug, <WIRE as InterpreterTypes>::Extend: Debug,

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

Formats the value using the given formatter.

impl Default for Interpreter

fn default() -> Interpreter

Returns the “default value” for a type.

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

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<Interpreter<WIRE>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<WIRE> Serialize for Interpreter<WIRE>

where WIRE: InterpreterTypes, <WIRE as InterpreterTypes>::Bytecode: Serialize, <WIRE as InterpreterTypes>::Stack: Serialize, <WIRE as InterpreterTypes>::ReturnData: Serialize, <WIRE as InterpreterTypes>::Memory: Serialize, <WIRE as InterpreterTypes>::Input: Serialize, <WIRE as InterpreterTypes>::SubRoutineStack: Serialize, <WIRE as InterpreterTypes>::Control: Serialize, <WIRE as InterpreterTypes>::RuntimeFlag: Serialize, <WIRE as InterpreterTypes>::Extend: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.