Struct Env

pub struct Env { /* private fields */ }

Environment of the assembly

Implementations

impl Env

Symbols handling

pub fn options(&self) -> &EnvOptions

pub fn symbols(&self) -> &SymbolsTableCaseDependent

pub fn symbols_mut(&mut self) -> &mut SymbolsTableCaseDependent

pub fn get_fname<E: ExprEvaluationExt + Debug>( &self, exp: &E, ) -> Result<String, AssemblerError>

pub fn resolve_expr_may_fail_in_first_pass<E: ExprEvaluationExt>( &self, exp: &E, ) -> Result<ExprResult, AssemblerError>

Compute the expression thanks to the symbol table of the environment. If the expression is not solvable in first pass, 0 is returned. If the expression is not solvable in second pass, an error is returned

However, when assembling in a crunched section, the expression MUST NOT fail. edit: why ? I do not get it now and I have removed this limitation

pub fn resolve_index_may_fail_in_first_pass<E: ExprEvaluationExt>( &self, (op, exp): (BinaryOperation, &E), ) -> Result<ExprResult, AssemblerError>

pub fn resolve_expr_may_fail_in_first_pass_with_default<E: ExprEvaluationExt, R: Into<ExprResult>>( &self, exp: &E, r: R, ) -> Result<ExprResult, AssemblerError>

impl Env

Report handling

pub fn report(&self, start: &Instant) -> Report<'_>

impl Env

Handle the file search relatively to the current file

pub fn enter_current_working_file<P: AsRef<Utf8Path>>(&mut self, f: P)

pub fn leave_current_working_file(&mut self) -> Option<Utf8PathBuf>

pub fn get_current_working_directory(&self) -> Option<&Utf8Path>

pub fn has_current_working_directory(&self) -> bool

impl Env

Error handling

pub fn add_error_discardable_one_pass( &mut self, e: AssemblerError, ) -> Result<(), AssemblerError>

If the error has not been raised at the previous pass, store it and do not propagate it. Otherwise, propagate it

impl Env

pub fn with_table(symbols: &SymbolsTable) -> Self

Create an environment that embeds a copy of the given table and is configured to be in the latest pass. Mainly used for tests. TODO use bon here

pub fn with_table_case_dependent(symbols: &SymbolsTableCaseDependent) -> Self

TODO use bon here

pub fn warnings(&self) -> &[AssemblerError]

pub fn handle_post_actions( &mut self, ) -> Result<(Option<RemuChunk>, Option<WabpChunk>), AssemblerError>

Handle the actions to do after assembling. ATM it is only the save of data for each page

pub fn observer(&self) -> Rc<dyn EnvEventObserver>

pub fn handle_print(&mut self) -> Result<(), AssemblerError>

impl Env

Output handling

pub fn logical_output_address(&self) -> u16

Return the address where the next byte will be written

pub fn physical_output_address(&self) -> PhysicalAddress

pub fn physical_code_address(&self) -> PhysicalAddress

pub fn logical_code_address(&self) -> u16

Return the address of dollar

pub fn output_limit_address(&self) -> u16

pub fn code_limit_address(&self) -> u16

pub fn start_address(&self) -> Option<u16>

pub fn maximum_address(&self) -> u16

pub fn update_dollar(&mut self)

. Update the value of $ in the symbol table in order to take the current output address

pub fn get_memory(&self, start: u16, size: u16) -> Vec<u8>

Produce the memory for the required limits TODO check that the implementation is still correct with snapshot inclusion BUG does not take into account extra bank configuration

pub fn produced_bytes(&self) -> Vec<u8>

Returns the stream of bytes produced for a 64k compilation

pub fn loading_address(&self) -> Option<u16>

Returns the address of the 1st written byte

pub fn execution_address(&self) -> Option<u16>

Returns the address from when to start the program TODO really configure this address

pub fn output_byte(&mut self, v: u8) -> Result<bool, AssemblerError>

Output one byte either in the appropriate bank of the snapshot or in the termporary bank return true if it raised an override warning

pub fn allow_memory_override(&self) -> bool

pub fn output_bytes(&mut self, bytes: &[u8]) -> Result<(), AssemblerError>

Write consecutives bytes

pub fn peek(&self, address: &PhysicalAddress) -> u8

pub fn poke( &mut self, byte: u8, address: &PhysicalAddress, ) -> Result<(), AssemblerError>

pub fn size(&self) -> u16

Get the size of the generated binary. ATTENTION it can only work when geneating 0x10000 files

pub fn eval(&self, expr: &Expr) -> Result<ExprResult, AssemblerError>

Evaluate the expression according to the current state of the environment

pub fn sna(&self) -> &Snapshot

Examples found in repository

examples/generate_loop4000.rs (line 10)

fn build_sna(code: &str) -> Snapshot {
    let listing =
        parse_z80_with_context_builder(code, Default::default()).expect("Unable to parse z80 code");
    let (_, env) = visit_tokens_all_passes_with_options(&listing, Default::default())
        .expect("Unable to assemble z80 code");
    let sna = env.sna().clone();

    sna
}

pub fn sna_version(&self) -> SnapshotVersion

pub fn save_sna<P: AsRef<Utf8Path>>(&self, fname: P) -> Result<(), Error>

pub fn save_cpr<P: AsRef<Utf8Path>>( &self, fname: P, ) -> Result<(), AssemblerError>

impl Env

pub fn add_warning(&mut self, warning: AssemblerError)

impl Env

Visit directives

pub fn visit_org_set_arguments( &mut self, code_adr: u16, output_adr: u16, ) -> Result<(), AssemblerError>

impl Env

pub fn generate_symbols_output<W: Write>( &self, w: &mut W, fmt: SymbolOutputFormat, ) -> Result<()>

Write in w the list of symbols

pub fn visit_listing<T: ListingElement + Visited + MayHaveSpan>( &mut self, listing: &[T], ) -> Result<(), AssemblerError>

Visit all the tokens of the slice of tokens. Return true if an additional pass is requested

pub fn visit_macro_definition( &mut self, name: &str, arguments: &[&str], code: &str, source: Option<&Z80Span>, flavor: AssemblerFlavor, ) -> Result<(), AssemblerError>

pub fn visit_waitnops<E: ExprEvaluationExt>( &mut self, count: &E, ) -> Result<(), AssemblerError>

pub fn visit_struct_definition<T: ListingElement + ToSimpleToken, S1: SourceString, S2: AsRef<str>>( &mut self, name: S1, content: &[(S2, T)], source: Option<&Z80Span>, ) -> Result<(), AssemblerError>

pub fn visit_buildcpr(&mut self) -> Result<(), AssemblerError>

pub fn visit_buildsna( &mut self, version: Option<&SnapshotVersion>, ) -> Result<(), AssemblerError>

pub fn visit_assembler_control<C: AssemblerControlCommand>( &mut self, cmd: &C, span: Option<&Z80Span>, ) -> Result<(), AssemblerError>

pub fn visit_align<E: ExprEvaluationExt>( &mut self, boundary: &E, fill: Option<&E>, ) -> Result<(), AssemblerError>

pub fn logical_to_physical_address(&self, address: u16) -> PhysicalAddress

return the page and bank configuration for the given address at the current mmr configuration https://grimware.org/doku.php/documentations/devices/gatearray#mmr

pub fn visit_undef<S: SourceString>( &mut self, label: S, ) -> Result<(), AssemblerError>

Remove the given variable from the table of symbols

pub fn visit_protect<E: ExprEvaluationExt>( &mut self, start: &E, stop: &E, ) -> Result<(), AssemblerError>

pub fn visit_print(&mut self, info: &[FormattedExpr], span: Option<&Z80Span>)

Print the evaluation of the expression in the 2nd pass

pub fn visit_pause(&mut self, span: Option<&Z80Span>)

pub fn visit_fail( &self, info: Option<&[FormattedExpr]>, ) -> Result<(), AssemblerError>

pub fn visit_save<E: ExprEvaluationExt + Debug>( &mut self, amsdos_fname: &E, address: Option<&E>, size: Option<&E>, save_type: Option<&SaveType>, dsk_fname: Option<&E>, _side: Option<&E>, ) -> Result<(), AssemblerError>

pub fn visit_charset( &mut self, format: &CharsetFormat, ) -> Result<(), AssemblerError>

pub fn visit_snainit<E: ExprEvaluationExt + Debug>( &mut self, fname: &E, ) -> Result<(), AssemblerError>

pub fn visit_snaset( &mut self, flag: &SnapshotFlag, value: &FlagValue, ) -> Result<(), AssemblerError>

pub fn visit_incbin(&mut self, data: &[u8]) -> Result<(), AssemblerError>

pub fn visit_crunched_section<'tokens, T: Visited + ListingElement + MayHaveSpan + Sync>( &mut self, kind: &CrunchType, lst: &mut [ProcessedToken<'tokens, T>], previous_bytes: &mut Option<Vec<u8>>, previous_crunched_bytes: &mut Option<Vec<u8>>, span: Option<&Z80Span>, ) -> Result<(), AssemblerError>

where <T as ListingElement>::Expr: ExprEvaluationExt + ExprElement, ProcessedToken<'tokens, T>: FunctionBuilder, <<T as ListingElement>::TestKind as TestKindElement>::Expr: ExprEvaluationExt,

Handle a crunched section. bytes generated during previous pass or previous loop are provided TO NOT crunched them an additional time if they are similar

impl Env

Visit the tokens during several passes without providing a specific symbol table.

pub fn new(options: EnvOptions) -> Self

pub fn pass(&self) -> &AssemblingPass

impl Env

pub fn visit_return<E: ExprEvaluationExt>( &mut self, e: &E, ) -> Result<(), AssemblerError>

pub fn user_defined_function( &self, name: &str, ) -> Result<&Function, AssemblerError>

pub fn any_function<'res>( &'res self, name: &'res str, ) -> Result<&'res Function, AssemblerError>

impl Env

pub fn visit_while<'token, E, T>( &mut self, cond: &E, code: &mut [ProcessedToken<'token, T>], span: Option<&Z80Span>, ) -> Result<(), AssemblerError>

where T: ListingElement<Expr = E> + Visited + MayHaveSpan + Sync, <T as ListingElement>::Expr: ExprEvaluationExt + ExprElement, <<T as ListingElement>::TestKind as TestKindElement>::Expr: ExprEvaluationExt, ProcessedToken<'token, T>: FunctionBuilder,

pub fn visit_iterate<'token, E: ExprEvaluationExt, T: ListingElement<Expr = E> + Visited + MayHaveSpan + Sync>( &mut self, counter_name: &str, values: Either<&Vec<E>, &E>, code: &mut [ProcessedToken<'token, T>], span: Option<&Z80Span>, ) -> Result<(), AssemblerError>

where <T as ListingElement>::Expr: ExprEvaluationExt + ExprElement, <<T as ListingElement>::TestKind as TestKindElement>::Expr: ExprEvaluationExt, ProcessedToken<'token, T>: FunctionBuilder,

Handle the iterate repetition directive Values is either a list of values or a Expression that represents a list

pub fn visit_rorg<'token, T, E>( &mut self, address: &E, code: &mut [ProcessedToken<'token, T>], span: Option<&Z80Span>, ) -> Result<(), AssemblerError>

where E: ExprEvaluationExt, T: ListingElement<Expr = E> + Visited + MayHaveSpan + Sync, <T as ListingElement>::Expr: ExprEvaluationExt + ExprElement, <<T as ListingElement>::TestKind as TestKindElement>::Expr: ExprEvaluationExt, ProcessedToken<'token, T>: FunctionBuilder,

pub fn visit_confined<'token, E: ExprEvaluationExt, T>( &mut self, lst: &mut [ProcessedToken<'token, T>], span: Option<&Z80Span>, ) -> Result<(), AssemblerError>

where T: ListingElement<Expr = E> + Visited + MayHaveSpan + Sync, <T as ListingElement>::Expr: ExprEvaluationExt + ExprElement, <<T as ListingElement>::TestKind as TestKindElement>::Expr: ExprEvaluationExt, ProcessedToken<'token, T>: FunctionBuilder,

pub fn visit_for<'token, E: ExprEvaluationExt, T>( &mut self, label: &str, start: &E, stop: &E, step: Option<&E>, code: &mut [ProcessedToken<'token, T>], span: Option<&Z80Span>, ) -> Result<(), AssemblerError>

where T: ListingElement<Expr = E> + Visited + MayHaveSpan + Sync, <T as ListingElement>::Expr: ExprEvaluationExt + ExprElement, <<T as ListingElement>::TestKind as TestKindElement>::Expr: ExprEvaluationExt, ProcessedToken<'token, T>: FunctionBuilder,

Handle the for directive

pub fn visit_repeat_until<'token, E, T>( &mut self, cond: &E, code: &mut [ProcessedToken<'token, T>], span: Option<&Z80Span>, ) -> Result<(), AssemblerError>

where E: ExprEvaluationExt, T: ListingElement<Expr = E> + Visited + MayHaveSpan + Sync, <T as ListingElement>::Expr: ExprEvaluationExt + ExprElement, <<T as ListingElement>::TestKind as TestKindElement>::Expr: ExprEvaluationExt, ProcessedToken<'token, T>: FunctionBuilder,

Handle the standard repetition directive

pub fn visit_starting_index<E>( &mut self, start: Option<&E>, step: Option<&E>, ) -> Result<(), AssemblerError>

where E: ExprEvaluationExt,

pub fn visit_repeat<'token, T, E>( &mut self, count: &E, code: &mut [ProcessedToken<'token, T>], counter_name: Option<&str>, counter_start: Option<&E>, counter_step: Option<&E>, span: Option<&Z80Span>, ) -> Result<(), AssemblerError>

where E: ExprEvaluationExt, T: ListingElement<Expr = E> + Visited + MayHaveSpan + Sync, <T as ListingElement>::Expr: ExprEvaluationExt + ExprElement, <<T as ListingElement>::TestKind as TestKindElement>::Expr: ExprEvaluationExt, ProcessedToken<'token, T>: FunctionBuilder,

Handle the standard repetition directive

impl Env

Macro related code

pub fn inc_macro_seed(&mut self)

pub fn macro_seed(&self) -> usize

impl Env

Warnings related code

pub fn cleanup_warnings(&mut self)

impl Env

pub fn visit_basic<S: SourceString, S2: SourceString, E: ExprEvaluationExt>( &mut self, variables: Option<Vec<S>>, hidden_lines: Option<&Vec<E>>, code: S2, ) -> Result<(), AssemblerError>

pub fn assemble_basic<S: SourceString, S2: SourceString, E: ExprEvaluationExt>( &mut self, variables: Option<Vec<S>>, hidden_lines: Option<&Vec<E>>, code: S2, ) -> Result<Vec<u8>, AssemblerError>

impl Env

pub fn assemble_cp<D: DataAccessElem>( &mut self, arg: &D, ) -> Result<Bytes, AssemblerError>

where <D as DataAccessElem>::Expr: ExprEvaluationExt + ExprElement,

pub fn assemble_sub<D: DataAccessElem>( &mut self, arg: &D, ) -> Result<Bytes, AssemblerError>

where <D as DataAccessElem>::Expr: ExprEvaluationExt + ExprElement,

pub fn assemble_sbc<D: DataAccessElem>( &mut self, arg1: Option<&D>, arg2: &D, ) -> Result<Bytes, AssemblerError>

where <D as DataAccessElem>::Expr: ExprEvaluationExt + ExprElement,

pub fn assemble_shift<D: DataAccessElem>( &mut self, mne: Mnemonic, target: &D, hidden: Option<&D>, ) -> Result<Bytes, AssemblerError>

where <D as DataAccessElem>::Expr: ExprEvaluationExt + ExprElement,

Trait Implementations

impl Clone for Env

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Env

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

Formats the value using the given formatter.

impl Default for Env

fn default() -> Self

Returns the “default value” for a type.