Struct cpclib_asm::preamble::SymbolsTableCaseDependent

pub struct SymbolsTableCaseDependent { /* private fields */ }

Wrapper around the Values table in order to easily manage the fact that the assembler is case dependent or independant

Implementations

impl SymbolsTableCaseDependent

pub fn current_address(&self) -> Result<u16, SymbolError>

pub fn set_current_address(&mut self, addr: PhysicalAddress)

pub fn set_current_output_address(&mut self, addr: PhysicalAddress)

pub fn closest_symbol<S>( &self, symbol: S, for: SymbolFor ) -> Result<Option<SmolStr>, SymbolError>where S: Into<Symbol>,

pub fn push_seed(&mut self, seed: usize)

pub fn pop_seed(&mut self)

pub fn new( table: SymbolsTable, case_sensitive: bool ) -> SymbolsTableCaseDependent

pub fn is_case_sensitive(&self) -> bool

pub fn table(&self) -> &SymbolsTable

pub fn laxist() -> SymbolsTableCaseDependent

Build a laxists vesion of the table : do not care of case and absences of Valuees

pub fn normalize_symbol<S>(&self, symbol: S) -> Symbolwhere S: Into<Symbol>,

Modify the Value value depending on the case confurigration (do nothing, or set uppercase)

pub fn set_table(&mut self, table: SymbolsTable)

pub fn set_current_label<S>(&mut self, symbol: S) -> Result<(), SymbolError>where S: Into<Symbol>,

pub fn set_symbol_to_current_address<S>( &mut self, symbol: S ) -> Result<(), SymbolError>where S: Into<Symbol>,

pub fn set_symbol_to_value<S, V>( &mut self, symbol: S, value: V ) -> Result<Option<Value>, SymbolError>where S: Into<Symbol>, V: Into<Value>,

pub fn update_symbol_to_value<S, E>( &mut self, symbol: S, value: E ) -> Result<(), SymbolError>where S: Into<Symbol>, E: Into<Value>,

pub fn prefixed_value<S>( &self, prefix: &LabelPrefix, symbol: S ) -> Result<Option<u16>, SymbolError>where S: Into<Symbol>,

pub fn contains_symbol<S>(&self, symbol: S) -> Result<bool, SymbolError>where S: Into<Symbol>,

pub fn symbol_exist_in_current_pass<S>( &self, symbol: S ) -> Result<bool, SymbolError>where S: Into<Symbol>,

pub fn new_pass(&mut self)

pub fn kind<S>(&self, symbol: S) -> Result<&'static str, SymbolError>where S: Into<Symbol>,

Trait Implementations

impl AsRef<SymbolsTable> for SymbolsTableCaseDependent

fn as_ref(&self) -> &SymbolsTable

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

impl Clone for SymbolsTableCaseDependent

fn clone(&self) -> SymbolsTableCaseDependent

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SymbolsTableCaseDependent

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

Formats the value using the given formatter.

impl Default for SymbolsTableCaseDependent

By default, the assembler is case sensitive

fn default() -> SymbolsTableCaseDependent

Returns the “default value” for a type.

impl SymbolsTableTrait for SymbolsTableCaseDependent

fn is_used<S>(&self, symbol: S) -> boolwhere S: Into<Symbol>,

Return true if the symbol has already been used in an expression

fn use_symbol<S>(&mut self, symbol: S)where S: Into<Symbol>,

Add a symbol to the list of used symbols

fn expression_symbol(&self) -> Vec<(&Symbol, &Value), Global>

Return the symbols that correspond to integer values

fn int_value<S>(&self, symbol: S) -> Result<Option<i32>, SymbolError>where S: Into<Symbol>,

Return the integer value corredponding to this symbol (if any)

fn counter_value<S>(&self, symbol: S) -> Result<Option<i32>, SymbolError>where S: Into<Symbol>,

fn macro_value<S>(&self, symbol: S) -> Result<Option<&Macro>, SymbolError>where S: Into<Symbol>,

fn struct_value<S>(&self, symbol: S) -> Result<Option<&Struct>, SymbolError>where S: Into<Symbol>,

fn value<S>(&self, symbol: S) -> Result<Option<&Value>, SymbolError>where S: Into<Symbol>,

fn remove_symbol<S>(&mut self, symbol: S) -> Result<Option<Value>, SymbolError>where S: Into<Symbol>,

fn address_value<S>( &self, symbol: S ) -> Result<Option<&PhysicalAddress>, SymbolError>where S: Into<Symbol>,

fn assign_symbol_to_value<S, V>( &mut self, symbol: S, value: V ) -> Result<Option<Value>, SymbolError>where S: Into<Symbol>, V: Into<Value>,

fn enter_namespace(&mut self, namespace: &str)

fn leave_namespace(&mut self) -> Result<Symbol, SymbolError>