Struct SimpleGarnishData

pub struct SimpleGarnishData<T = NoCustom>
where
    T: Clone + PartialEq + Eq + PartialOrd + Debug + Hash,
{ /* private fields */ }

Implementation of GarnishData. Uses standard Rust collections for storing data.

Implementations

impl SimpleGarnishData<NoCustom>

pub fn new() -> Self

impl<T> SimpleGarnishData<T>

where T: Clone + PartialEq + Eq + PartialOrd + Debug + Hash,

pub fn new_custom() -> Self

pub fn add_custom(&mut self, data: T) -> Result<usize, DataError>

pub fn add_stack_frame( &mut self, frame: SimpleStackFrame, ) -> Result<usize, DataError>

pub fn get_custom(&self, addr: usize) -> Result<T, DataError>

pub fn get_symbols(&self) -> &HashMap<u64, String>

pub fn get_registers(&self) -> &Vec<usize>

pub fn get_jump_points(&self) -> &Vec<usize>

pub fn get_instructions(&self) -> &Vec<SimpleInstruction>

pub fn get_data(&self) -> &SimpleDataList<T>

pub fn get_data_mut(&mut self) -> &mut SimpleDataList<T>

pub fn get_raw_data(&self, index: usize) -> Option<SimpleData<T>>

pub fn set_end_of_constant(&mut self, addr: usize) -> Result<(), DataError>

pub fn get_end_of_constant_data(&self) -> usize

pub fn get_current_instruction(&self) -> Option<(Instruction, Option<usize>)>

pub fn advance_instruction_cursor(&mut self) -> Result<(), String>

pub fn display_current_value(&self) -> String

where T: Display + DisplayForCustomItem,

pub fn collect_concatenation_indices( &self, left: usize, right: usize, ) -> Vec<usize>

Trait Implementations

impl<T> Clone for SimpleGarnishData<T>

where T: Clone + PartialEq + Eq + PartialOrd + Debug + Hash + Clone,

fn clone(&self) -> SimpleGarnishData<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for SimpleGarnishData<T>

where T: Clone + PartialEq + Eq + PartialOrd + Debug + Hash + Debug,

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

Formats the value using the given formatter.

impl<T> GarnishData for SimpleGarnishData<T>

where T: Clone + PartialEq + Eq + PartialOrd + Debug + Hash,

type Error = DataError

type Symbol = u64

type Byte = u8

type Char = char

type Number = SimpleNumber

type Size = usize

type SizeIterator = SizeIterator

type NumberIterator = NumberIterator

type InstructionIterator = SizeIterator

type DataIndexIterator = SizeIterator

type ValueIndexIterator = SizeIterator

type RegisterIndexIterator = SizeIterator

type JumpTableIndexIterator = SizeIterator

type JumpPathIndexIterator = SizeIterator

type ListIndexIterator = NumberIterator

type ListItemIterator = DataIndexIterator

type ConcatenationItemIterator = DataIndexIterator

fn get_data_len(&self) -> usize

fn get_data_iter(&self) -> SizeIterator

fn get_value_stack_len(&self) -> usize

fn push_value_stack(&mut self, addr: usize) -> Result<(), Self::Error>

fn pop_value_stack(&mut self) -> Option<usize>

fn get_value(&self, index: usize) -> Option<usize>

fn get_value_mut(&mut self, index: usize) -> Option<&mut usize>

fn get_current_value(&self) -> Option<usize>

fn get_current_value_mut(&mut self) -> Option<&mut usize>

fn get_value_iter(&self) -> Self::ValueIndexIterator

fn get_data_type(&self, index: usize) -> Result<GarnishDataType, Self::Error>

fn get_number(&self, index: usize) -> Result<SimpleNumber, Self::Error>

fn get_type(&self, addr: Self::Size) -> Result<GarnishDataType, Self::Error>

fn get_char(&self, index: Self::Size) -> Result<Self::Char, Self::Error>

fn get_byte(&self, addr: Self::Size) -> Result<Self::Byte, Self::Error>

fn get_symbol(&self, index: usize) -> Result<u64, Self::Error>

fn get_expression(&self, index: usize) -> Result<usize, Self::Error>

fn get_external(&self, index: usize) -> Result<usize, Self::Error>

fn get_pair(&self, index: usize) -> Result<(usize, usize), Self::Error>

fn get_concatenation(&self, index: usize) -> Result<(usize, usize), Self::Error>

fn get_range( &self, addr: Self::Size, ) -> Result<(Self::Size, Self::Size), Self::Error>

fn get_slice( &self, addr: Self::Size, ) -> Result<(Self::Size, Self::Size), Self::Error>

fn get_list_len(&self, index: usize) -> Result<usize, Self::Error>

fn get_list_item( &self, list_index: usize, item_index: SimpleNumber, ) -> Result<usize, Self::Error>

fn get_list_associations_len(&self, index: usize) -> Result<usize, Self::Error>

fn get_list_association( &self, list_index: usize, item_index: SimpleNumber, ) -> Result<usize, Self::Error>

fn get_list_item_with_symbol( &self, list_addr: usize, sym: u64, ) -> Result<Option<usize>, Self::Error>

fn get_list_items_iter(&self, list_addr: Self::Size) -> Self::ListIndexIterator

fn get_list_associations_iter( &self, list_addr: Self::Size, ) -> Self::ListIndexIterator

fn get_char_list_len(&self, addr: Self::Size) -> Result<Self::Size, Self::Error>

fn get_char_list_item( &self, addr: Self::Size, item_index: Self::Number, ) -> Result<Self::Char, Self::Error>

fn get_char_list_iter(&self, list_addr: Self::Size) -> Self::ListIndexIterator

fn get_byte_list_len(&self, addr: Self::Size) -> Result<Self::Size, Self::Error>

fn get_byte_list_item( &self, addr: Self::Size, item_index: Self::Number, ) -> Result<Self::Byte, Self::Error>

fn get_byte_list_iter(&self, list_addr: Self::Size) -> Self::ListIndexIterator

fn get_symbol_list_len( &self, addr: Self::Size, ) -> Result<Self::Size, Self::Error>

fn get_symbol_list_item( &self, addr: Self::Size, item_index: Self::Number, ) -> Result<Self::Symbol, Self::Error>

fn get_symbol_list_iter(&self, list_addr: Self::Size) -> Self::ListIndexIterator

fn get_list_item_iter(&self, list_addr: Self::Size) -> Self::ListItemIterator

fn get_concatenation_iter( &self, addr: Self::Size, ) -> Self::ConcatenationItemIterator

fn get_slice_iter(&self, addr: Self::Size) -> Self::ListIndexIterator

fn get_list_slice_item_iter( &self, list_addr: Self::Size, ) -> Self::ListItemIterator

fn get_concatenation_slice_iter( &self, addr: Self::Size, ) -> Self::ConcatenationItemIterator

fn add_unit(&mut self) -> Result<usize, Self::Error>

fn add_true(&mut self) -> Result<usize, Self::Error>

fn add_false(&mut self) -> Result<usize, Self::Error>

fn add_number(&mut self, value: SimpleNumber) -> Result<usize, Self::Error>

fn add_type( &mut self, value: GarnishDataType, ) -> Result<Self::Size, Self::Error>

fn add_char(&mut self, value: Self::Char) -> Result<Self::Size, Self::Error>

fn add_byte(&mut self, value: Self::Byte) -> Result<Self::Size, Self::Error>

fn add_symbol(&mut self, value: u64) -> Result<usize, Self::Error>

fn add_expression(&mut self, value: usize) -> Result<usize, Self::Error>

fn add_external(&mut self, value: usize) -> Result<usize, Self::Error>

fn add_pair(&mut self, value: (usize, usize)) -> Result<usize, Self::Error>

fn add_concatenation( &mut self, left: Self::Size, right: Self::Size, ) -> Result<Self::Size, Self::Error>

fn add_range( &mut self, start: Self::Size, end: Self::Size, ) -> Result<Self::Size, Self::Error>

fn add_slice( &mut self, list: Self::Size, range: Self::Size, ) -> Result<Self::Size, Self::Error>

fn merge_to_symbol_list( &mut self, first: Self::Size, second: Self::Size, ) -> Result<Self::Size, Self::Error>

fn start_list(&mut self, _: usize) -> Result<(), Self::Error>

fn add_to_list( &mut self, addr: usize, is_associative: bool, ) -> Result<(), Self::Error>

fn end_list(&mut self) -> Result<usize, Self::Error>

fn start_char_list(&mut self) -> Result<(), Self::Error>

fn add_to_char_list(&mut self, c: Self::Char) -> Result<(), Self::Error>

fn end_char_list(&mut self) -> Result<Self::Size, Self::Error>

fn start_byte_list(&mut self) -> Result<(), Self::Error>

fn add_to_byte_list(&mut self, c: Self::Byte) -> Result<(), Self::Error>

fn end_byte_list(&mut self) -> Result<Self::Size, Self::Error>

fn get_register_len(&self) -> Self::Size

fn push_register(&mut self, addr: usize) -> Result<(), Self::Error>

fn get_register(&self, addr: Self::Size) -> Option<Self::Size>

fn pop_register(&mut self) -> Result<Option<Self::Size>, Self::Error>

fn get_register_iter(&self) -> Self::RegisterIndexIterator

fn get_instruction_len(&self) -> usize

fn push_instruction( &mut self, instruction: Instruction, data: Option<usize>, ) -> Result<usize, Self::Error>

fn get_instruction(&self, index: usize) -> Option<(Instruction, Option<usize>)>

fn get_instruction_iter(&self) -> Self::InstructionIterator

fn get_instruction_cursor(&self) -> usize

fn set_instruction_cursor(&mut self, index: usize) -> Result<(), Self::Error>

fn get_jump_table_len(&self) -> usize

fn push_jump_point(&mut self, index: usize) -> Result<(), Self::Error>

fn get_jump_point(&self, index: usize) -> Option<usize>

fn get_jump_point_mut(&mut self, index: usize) -> Option<&mut usize>

fn get_jump_table_iter(&self) -> Self::JumpTableIndexIterator

fn push_jump_path(&mut self, index: usize) -> Result<(), Self::Error>

fn pop_jump_path(&mut self) -> Option<usize>

fn get_jump_path_iter(&self) -> Self::JumpPathIndexIterator

fn size_to_number(from: Self::Size) -> Self::Number

fn number_to_size(from: Self::Number) -> Option<Self::Size>

fn number_to_char(from: Self::Number) -> Option<Self::Char>

fn number_to_byte(from: Self::Number) -> Option<Self::Byte>

fn char_to_number(from: Self::Char) -> Option<Self::Number>

fn char_to_byte(from: Self::Char) -> Option<Self::Byte>

fn byte_to_number(from: Self::Byte) -> Option<Self::Number>

fn byte_to_char(from: Self::Byte) -> Option<Self::Char>

fn add_char_list_from( &mut self, from: Self::Size, ) -> Result<Self::Size, Self::Error>

fn add_byte_list_from( &mut self, from: Self::Size, ) -> Result<Self::Size, Self::Error>

fn add_symbol_from( &mut self, from: Self::Size, ) -> Result<Self::Size, Self::Error>

fn add_byte_from(&mut self, from: Self::Size) -> Result<Self::Size, Self::Error>

fn add_number_from( &mut self, from: Self::Size, ) -> Result<Self::Size, Self::Error>

fn parse_number(from: &str) -> Result<Self::Number, Self::Error>

fn parse_symbol(from: &str) -> Result<Self::Symbol, Self::Error>

fn parse_char(from: &str) -> Result<Self::Char, Self::Error>

fn parse_byte(from: &str) -> Result<Self::Byte, Self::Error>

fn parse_char_list(from: &str) -> Result<Vec<Self::Char>, Self::Error>

fn parse_byte_list(from: &str) -> Result<Vec<Self::Byte>, Self::Error>

fn parse_add_symbol(&mut self, from: &str) -> Result<Self::Size, Self::Error>

fn make_size_iterator_range( min: Self::Size, max: Self::Size, ) -> Self::SizeIterator

fn make_number_iterator_range( min: Self::Number, max: Self::Number, ) -> Self::NumberIterator

fn parse_add_number(&mut self, from: &str) -> Result<Self::Size, Self::Error>

fn parse_add_char(&mut self, from: &str) -> Result<Self::Size, Self::Error>

fn parse_add_byte(&mut self, from: &str) -> Result<Self::Size, Self::Error>

fn parse_add_char_list(&mut self, from: &str) -> Result<Self::Size, Self::Error>

fn parse_add_byte_list(&mut self, from: &str) -> Result<Self::Size, Self::Error>