Struct PCodeState

pub struct PCodeState<T: StateValue, O: Order> { /* private fields */ }

Implementations

impl<T: StateValue, O: Order> PCodeState<T, O>

pub fn new( memory: PagedState<T>, translator: &Translator, convention: &Convention, ) -> Self

pub fn convention(&self) -> &Convention

pub fn memory(&self) -> &PagedState<T>

pub fn memory_mut(&mut self) -> &mut PagedState<T>

pub fn memory_space(&self) -> Arc<AddressSpace>

pub fn memory_space_ref(&self) -> &AddressSpace

pub fn registers(&self) -> &RegisterState<T, O>

pub fn registers_mut(&mut self) -> &mut RegisterState<T, O>

pub fn temporaries(&self) -> &UniqueState<T>

pub fn temporaries_mut(&mut self) -> &mut UniqueState<T>

pub fn with_operand_values<U, F>( &self, operand: &Operand, f: F, ) -> Result<U, Error>

where F: FnOnce(&[T]) -> U,

pub fn with_operand_values_mut<U, F>( &mut self, operand: &Operand, f: F, ) -> Result<U, Error>

where F: FnOnce(&mut [T]) -> U,

pub fn get_operand<V: FromStateValues<T>>( &self, operand: &Operand, ) -> Result<V, Error>

pub fn set_operand<V: IntoStateValues<T>>( &mut self, operand: &Operand, value: V, ) -> Result<(), Error>

pub fn view_values_from<A>(&self, address: A) -> Result<&[T], Error>

where A: Into<Address>,

impl<O: Order> PCodeState<u8, O>

pub fn program_counter_value(&self) -> Result<Address, Error>

pub fn stack_pointer_value(&self) -> Result<Address, Error>

pub fn get_pointer(&self, address: Address) -> Result<Address, Error>

pub fn get_address(&self, operand: &Operand) -> Result<Address, Error>

pub fn set_program_counter_value<A>(&mut self, value: A) -> Result<(), Error>

where A: Into<Address>,

pub fn set_stack_pointer_value<A>(&mut self, value: A) -> Result<(), Error>

where A: Into<Address>,

pub fn set_address<A>( &mut self, operand: &Operand, value: A, ) -> Result<(), Error>

where A: Into<Address>,

Trait Implementations

impl<T: StateValue, O: Order> AsMut<PCodeState<T, O>> for PCodeState<T, O>

fn as_mut(&mut self) -> &mut Self

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: StateValue, O: Order> AsRef<PCodeState<T, O>> for PCodeState<T, O>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone + StateValue, O: Clone + Order> Clone for PCodeState<T, O>

fn clone(&self) -> PCodeState<T, O>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + StateValue, O: Debug + Order> Debug for PCodeState<T, O>

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

Formats the value using the given formatter.

impl<V: StateValue, O: Order> State for PCodeState<V, O>

type Error = Error

fn fork(&self) -> Self

fn restore(&mut self, other: &Self)

impl<V: StateValue, O: Order> StateOps for PCodeState<V, O>

type Value = V

fn copy_values<F, T>( &mut self, from: F, to: T, size: usize, ) -> Result<(), Self::Error>

where F: Into<Address>, T: Into<Address>,

fn get_values<A>( &self, address: A, values: &mut [Self::Value], ) -> Result<(), Self::Error>

where A: Into<Address>,

fn view_values<A>( &self, address: A, size: usize, ) -> Result<&[Self::Value], Self::Error>

where A: Into<Address>,

fn view_values_mut<A>( &mut self, address: A, size: usize, ) -> Result<&mut [Self::Value], Self::Error>

where A: Into<Address>,

fn set_values<A>( &mut self, address: A, values: &[Self::Value], ) -> Result<(), Self::Error>

where A: Into<Address>,

fn len(&self) -> usize

fn write<A, O: Order, V: IntoStateValues<Self::Value>>( &mut self, address: A, value: V, ) -> Result<(), Self::Error>

where A: Into<Address>,

fn read<A, O: Order, V: FromStateValues<Self::Value>>( &self, address: A, size: usize, ) -> Result<V, Self::Error>

where A: Into<Address>,