Enum Token 

pub enum Token {
    Abyte(Expr, Vec<Expr>),
    Align(Expr, Option<Expr>),
    AssemblerControl(StandardAssemblerControlCommand),
    Assert(Expr, Option<Vec<FormattedExpr>>),
    Assign {
        label: SmolStr,
        expr: Expr,
        op: Option<BinaryOperation>,
    },
    Bank(Option<Expr>),
    Bankset(Expr),
    Basic(Option<Vec<SmolStr>>, Option<Vec<Expr>>, String),
    Break,
    Breakpoint {
        address: Option<Expr>,
        type: Option<RemuBreakPointType>,
        access: Option<RemuBreakPointAccessMode>,
        run: Option<RemuBreakPointRunMode>,
        mask: Option<Expr>,
        size: Option<Expr>,
        value: Option<Expr>,
        value_mask: Option<Expr>,
        condition: Option<Expr>,
        name: Option<Expr>,
        step: Option<Expr>,
    },
    BuildCpr,
    BuildSna(Option<SnapshotVersion>),
    Charset(CharsetFormat),
    Comment(String),
    CrunchedBinary(CrunchType, SmolStr),
    CrunchedSection(CrunchType, BaseListing<Token>),
    Defb(Vec<Expr>),
    Defs(Vec<(Expr, Option<Expr>)>),
    Defw(Vec<Expr>),
    End,
    Equ {
        label: SmolStr,
        expr: Expr,
    },
    Export(Vec<SmolStr>),
    Fail(Option<Vec<FormattedExpr>>),
    Field {
        label: SmolStr,
        expr: Expr,
    },
    For {
        label: SmolStr,
        start: Expr,
        stop: Expr,
        step: Option<Expr>,
        listing: BaseListing<Token>,
    },
    Function(SmolStr, Vec<SmolStr>, BaseListing<Token>),
    If(Vec<(TestKind, BaseListing<Token>)>, Option<BaseListing<Token>>),
    Incbin {
        fname: Expr,
        offset: Option<Expr>,
        length: Option<Expr>,
        extended_offset: Option<Expr>,
        off: bool,
        transformation: BinaryTransformation,
    },
    Include(Expr, Option<SmolStr>, bool),
    Iterate(SmolStr, Either<Vec<Expr>, Expr>, BaseListing<Token>),
    Label(SmolStr),
    Let(SmolStr, Expr),
    Limit(Expr),
    List,
    Macro {
        name: SmolStr,
        params: Vec<SmolStr>,
        content: String,
        flavor: AssemblerFlavor,
    },
    MacroCall(SmolStr, Vec<MacroParam>),
    Map(Expr),
    Module(SmolStr, BaseListing<Token>),
    MultiPop(Vec<DataAccess>),
    MultiPush(Vec<DataAccess>),
    Next {
        label: SmolStr,
        source: SmolStr,
        expr: Option<Expr>,
    },
    NoExport(Vec<SmolStr>),
    NoList,
    OpCode(Mnemonic, Option<DataAccess>, Option<DataAccess>, Option<Register8>),
    Org {
        val1: Expr,
        val2: Option<Expr>,
    },
    Pause,
    Print(Vec<FormattedExpr>),
    Protect(Expr, Expr),
    Range(String, Expr, Expr),
    Repeat(Expr, BaseListing<Token>, Option<SmolStr>, Option<Expr>),
    RepeatToken {
        token: Box<Token>,
        repeat: Expr,
    },
    RepeatUntil(Expr, BaseListing<Token>),
    Return(Expr),
    Rorg(Expr, BaseListing<Token>),
    Run(Expr, Option<Expr>),
    Save {
        filename: Expr,
        address: Option<Expr>,
        size: Option<Expr>,
        save_type: Option<SaveType>,
        dsk_filename: Option<Expr>,
        side: Option<Expr>,
    },
    Section(SmolStr),
    SetCPC(Expr),
    SetCrtc(Expr),
    SetN {
        label: SmolStr,
        source: SmolStr,
        expr: Option<Expr>,
    },
    Skip(Expr),
    SnaInit(Expr),
    SnaSet(SnapshotFlag, FlagValue),
    StableTicker(StableTickerAction<SmolStr>),
    StartingIndex {
        start: Option<Expr>,
        step: Option<Expr>,
    },
    Str(Vec<Expr>),
    Struct(SmolStr, Vec<(SmolStr, Token)>),
    Switch(Expr, Vec<(Expr, BaseListing<Token>, bool)>, Option<BaseListing<Token>>),
    Undef(SmolStr),
    WaitNops(Expr),
    While(Expr, BaseListing<Token>),
}

The embeded Listing can be of several kind (with the token or with decorated version of the token)

Variants

Abyte(Expr, Vec<Expr>)

Align(Expr, Option<Expr>)

AssemblerControl(StandardAssemblerControlCommand)

Assert(Expr, Option<Vec<FormattedExpr>>)

Assign

Fields

label: SmolStr

expr: Expr

op: Option<BinaryOperation>

Bank(Option<Expr>)

Configure the bank - completely incompatible with rasm behavior The expression corresponds to the GATE ARRAY value to select the bank of interest

Bankset(Expr)

Basic(Option<Vec<SmolStr>>, Option<Vec<Expr>>, String)

Basic code which tokens will be included in the code (imported variables, lines to hide, code)

Break

Breakpoint

Fields

address: Option<Expr>

type: Option<RemuBreakPointType>

access: Option<RemuBreakPointAccessMode>

run: Option<RemuBreakPointRunMode>

mask: Option<Expr>

size: Option<Expr>

value: Option<Expr>

value_mask: Option<Expr>

condition: Option<Expr>

name: Option<Expr>

step: Option<Expr>

BuildCpr

BuildSna(Option<SnapshotVersion>)

Charset(CharsetFormat)

Comment(String)

CrunchedBinary(CrunchType, SmolStr)

CrunchedSection(CrunchType, BaseListing<Token>)

Defb(Vec<Expr>)

Defs(Vec<(Expr, Option<Expr>)>)

Defw(Vec<Expr>)

End

Equ

Fields

label: SmolStr

expr: Expr

Export(Vec<SmolStr>)

Fail(Option<Vec<FormattedExpr>>)

Field

Fields

label: SmolStr

expr: Expr

For

Fields

label: SmolStr

start: Expr

stop: Expr

step: Option<Expr>

listing: BaseListing<Token>

Function(SmolStr, Vec<SmolStr>, BaseListing<Token>)

Function embeds a listing with a limited number of possible instructions and return a value

If(Vec<(TestKind, BaseListing<Token>)>, Option<BaseListing<Token>>)

Conditional expression. _0 contains all the expression and the appropriate code, _1 contains the else case

Incbin

Include of an asm file _0 contains the name of the file, _1 contains the content of the file. It is not loaded at the creation of the Token because there is not enough context to know where to load file

Fields

fname: Expr

offset: Option<Expr>

length: Option<Expr>

extended_offset: Option<Expr>

off: bool

transformation: BinaryTransformation

Include(Expr, Option<SmolStr>, bool)

Iterate(SmolStr, Either<Vec<Expr>, Expr>, BaseListing<Token>)

Label(SmolStr)

Let(SmolStr, Expr)

Limit(Expr)

List

Macro

Fields

name: SmolStr

params: Vec<SmolStr>

content: String

flavor: AssemblerFlavor

MacroCall(SmolStr, Vec<MacroParam>)

Map(Expr)

Module(SmolStr, BaseListing<Token>)

MultiPop(Vec<DataAccess>)

MultiPush(Vec<DataAccess>)

Next

Fields

label: SmolStr

source: SmolStr

expr: Option<Expr>

NoExport(Vec<SmolStr>)

NoList

OpCode(Mnemonic, Option<DataAccess>, Option<DataAccess>, Option<Register8>)

Very last argument concerns only few undocumented instructions that save their results in a register

Org

Fields

val1: Expr

val2: Option<Expr>

Pause

Print(Vec<FormattedExpr>)

Protect(Expr, Expr)

Range(String, Expr, Expr)

Define a named section in the current page

Repeat(Expr, BaseListing<Token>, Option<SmolStr>, Option<Expr>)

Duplicate the token stream

RepeatToken

Fields

token: Box<Token>

repeat: Expr

RepeatUntil(Expr, BaseListing<Token>)

Return(Expr)

Return value from a function

Rorg(Expr, BaseListing<Token>)

Set the value of $ to Expr

Run(Expr, Option<Expr>)

Save

Fields

filename: Expr

address: Option<Expr>

size: Option<Expr>

save_type: Option<SaveType>

dsk_filename: Option<Expr>

side: Option<Expr>

Section(SmolStr)

SetCPC(Expr)

SetCrtc(Expr)

SetN

Fields

label: SmolStr

source: SmolStr

expr: Option<Expr>

Skip(Expr)

SnaInit(Expr)

This directive setup a value for a given flag of the snapshot

SnaSet(SnapshotFlag, FlagValue)

StableTicker(StableTickerAction<SmolStr>)

StartingIndex

Fields

start: Option<Expr>

step: Option<Expr>

Str(Vec<Expr>)

Struct(SmolStr, Vec<(SmolStr, Token)>)

Switch(Expr, Vec<(Expr, BaseListing<Token>, bool)>, Option<BaseListing<Token>>)

Undef(SmolStr)

WaitNops(Expr)

While(Expr, BaseListing<Token>)

Implementations

impl Token

pub fn new_opcode( mne: Mnemonic, arg1: Option<DataAccess>, arg2: Option<DataAccess>, ) -> Token

pub fn fix_relative_jumps_after_disassembling(&mut self)

When diassembling code, the token with relative information are not appropriate

pub fn is_opcode(&self) -> bool

pub fn is_output_opcode(&self) -> bool

pub fn is_input_opcode(&self) -> bool

pub fn is_retlike_opcode(&self) -> bool

pub fn is_autocopy_opcode(&self) -> bool

Check if it is an undocumented instruction that makes a copy of the data to save in an additional register

pub fn label(&self) -> Option<&str>

pub fn is_label(&self) -> bool

pub fn macro_name(&self) -> Option<&str>

pub fn macro_arguments(&self) -> Option<&[SmolStr]>

pub fn macro_content(&self) -> Option<&str>

pub fn org_expr(&self) -> Option<&Expr>

👎Deprecated since 0.1.1: please use expr instead as other token need it

Rename the @labels in macros XXX no more needed - to remove later

pub fn expr(&self) -> Option<&Expr>

pub fn has_at_least_one_listing(&self) -> bool

Return true for directives that can emebed some listing information

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Token

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

Formats the value using the given formatter.

impl Display for Token

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

Formats the value using the given formatter.

impl From<&Token> for DbLikeKind

fn from(token: &Token) -> Self

Converts to this type from the input type.

impl From<u8> for Token

fn from(byte: u8) -> Token

Converts to this type from the input type.

impl Hash for Token

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl ListingElement for Token

type AssemblerControlCommand = StandardAssemblerControlCommand

type DataAccess = DataAccess

type Expr = Expr

type MacroParam = MacroParam

type TestKind = TestKind

fn is_run(&self) -> bool

fn is_repeat_token(&self) -> bool

fn repeat_token(&self) -> &Token

fn is_save(&self) -> bool

fn is_breakpoint(&self) -> bool

fn run_expr(&self) -> &<Token as ListingElement>::Expr

fn equ_symbol(&self) -> &str

fn rorg_expr(&self) -> &<Token as ListingElement>::Expr

fn equ_value(&self) -> &<Token as ListingElement>::Expr

fn assign_symbol(&self) -> &str

fn module_name(&self) -> &str

fn mnemonic(&self) -> Option<&Mnemonic>

fn mnemonic_arg2(&self) -> Option<&<Token as ListingElement>::DataAccess>

fn mnemonic_arg1_mut( &mut self, ) -> Option<&mut <Token as ListingElement>::DataAccess>

fn iterate_counter_name(&self) -> &str

fn iterate_values( &self, ) -> Either<&Vec<<Token as ListingElement>::Expr>, &<Token as ListingElement>::Expr>

fn mnemonic_arg2_mut( &mut self, ) -> Option<&mut <Token as ListingElement>::DataAccess>

fn while_expr(&self) -> &<Token as ListingElement>::Expr

fn assign_value(&self) -> &<Token as ListingElement>::Expr

fn is_switch(&self) -> bool

fn is_if(&self) -> bool

fn is_repeat(&self) -> bool

fn is_for(&self) -> bool

fn is_directive(&self) -> bool

fn is_module(&self) -> bool

fn is_while(&self) -> bool

fn is_iterate(&self) -> bool

fn is_repeat_until(&self) -> bool

fn is_include(&self) -> bool

fn is_incbin(&self) -> bool

fn is_call_macro_or_build_struct(&self) -> bool

fn is_function_definition(&self) -> bool

fn is_crunched_section(&self) -> bool

fn is_rorg(&self) -> bool

fn is_db(&self) -> bool

fn is_dw(&self) -> bool

fn is_str(&self) -> bool

fn is_set(&self) -> bool

fn is_buildcpr(&self) -> bool

fn is_assembler_control(&self) -> bool

fn is_assert(&self) -> bool

fn is_assign(&self) -> bool

fn is_comment(&self) -> bool

fn is_equ(&self) -> bool

fn is_label(&self) -> bool

fn is_org(&self) -> bool

fn org_first(&self) -> &<Token as ListingElement>::Expr

fn org_second(&self) -> Option<&<Token as ListingElement>::Expr>

fn is_print(&self) -> bool

fn for_label(&self) -> &str

fn for_start(&self) -> &<Token as ListingElement>::Expr

fn for_stop(&self) -> &<Token as ListingElement>::Expr

fn for_step(&self) -> Option<&<Token as ListingElement>::Expr>

fn repeat_until_condition(&self) -> &<Token as ListingElement>::Expr

fn repeat_count(&self) -> &<Token as ListingElement>::Expr

fn repeat_counter_name(&self) -> Option<&str>

fn repeat_counter_start(&self) -> Option<&<Token as ListingElement>::Expr>

fn is_macro_definition(&self) -> bool

fn macro_definition_name(&self) -> &str

fn macro_definition_arguments(&self) -> SmallVec<[&str; 4]>

fn macro_definition_code(&self) -> &str

fn macro_call_name(&self) -> &str

fn macro_call_arguments(&self) -> &[<Token as ListingElement>::MacroParam]

fn if_nb_tests(&self) -> usize

fn incbin_fname(&self) -> &<Token as ListingElement>::Expr

fn incbin_offset(&self) -> Option<&<Token as ListingElement>::Expr>

fn incbin_length(&self) -> Option<&<Token as ListingElement>::Expr>

fn incbin_transformation(&self) -> &BinaryTransformation

fn include_fname(&self) -> &<Token as ListingElement>::Expr

fn include_namespace(&self) -> Option<&str>

fn include_once(&self) -> bool

fn function_definition_name(&self) -> &str

fn function_definition_params(&self) -> SmallVec<[&str; 4]>

fn crunched_section_kind(&self) -> &CrunchType

fn switch_expr(&self) -> &<Token as ListingElement>::Expr

fn data_exprs(&self) -> &[<Token as ListingElement>::Expr]

fn to_token(&self) -> Cow<'_, Token>

fn is_warning(&self) -> bool

fn warning_token(&self) -> &Token

fn warning_message(&self) -> &str

fn module_listing(&self) -> &[Token]

fn while_listing(&self) -> &[Token]

fn mnemonic_arg1(&self) -> Option<&<Token as ListingElement>::DataAccess>

fn iterate_listing(&self) -> &[Token]

fn for_listing(&self) -> &[Token]

fn repeat_until_listing(&self) -> &[Token]

fn repeat_listing(&self) -> &[Token]

fn if_test( &self, idx: usize, ) -> (&<Token as ListingElement>::TestKind, &[Token])

fn if_else(&self) -> Option<&[Token]>

fn function_definition_inner(&self) -> &[Token]

fn crunched_section_listing(&self) -> &[Token]

fn rorg_listing(&self) -> &[Token]

fn is_confined(&self) -> bool

fn confined_listing(&self) -> &[Token]

fn switch_cases( &self, ) -> Box<dyn Iterator<Item = (&<Token as ListingElement>::Expr, &[Token], bool)> + '_>

fn switch_default(&self) -> Option<&[Token]>

fn repeat_counter_step(&self) -> Option<&<Token as ListingElement>::Expr>

fn assembler_control_command( &self, ) -> &<Token as ListingElement>::AssemblerControlCommand

fn assembler_control_get_max_passes( &self, ) -> Option<&<Token as ListingElement>::Expr>

fn assembler_control_get_listing(&self) -> &[Token]

fn macro_flavor(&self) -> AssemblerFlavor

fn defer_listing_output(&self) -> bool

fn is_opcode(&self) -> bool

fn include_is_standard_include(&self) -> bool

fn starts_with_label(&self) -> bool

impl MayHaveSpan for Token

fn possible_span(&self) -> Option<&Z80Span>

fn span(&self) -> &Z80Span

fn has_span(&self) -> bool

impl ParseToken for Token

type Output = Token

fn parse_token(src: &str) -> Result<Self::Output, String>

impl ParsingStateVerified for Token

fn is_accepted(&self, state: &ParsingState) -> bool

impl PartialEq for Token

fn eq(&self, other: &Token) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ReturnExpr for Token

type Expr = Expr

fn return_expr(&self) -> Option<&Self::Expr>

impl ToSimpleToken for Token

fn as_simple_token(&self) -> Cow<'_, Token>

Convert the token in its simplest form

impl TokenExt for Token

fn unroll(&self, env: &mut Env) -> Option<Result<Vec<&Self>, AssemblerError>>

Unroll the tokens when in a repetition loop TODO return an iterator in order to not produce the vector each time

fn disassemble_data(&self) -> Result<Listing, String>

Generate the listing of opcodes for directives that contain data Defb/defw/Defs in order to have mnemonics. Fails when some values are not opcodes

fn estimated_duration(&self) -> Result<usize, AssemblerError>

Returns an estimation of the duration. This estimation may be wrong for instruction having several states.

fn fallback_number_of_bytes(&self) -> Result<usize, String>

returns the number of bytes without assembling it

fn to_bytes_with_options( &self, option: EnvOptions, ) -> Result<Vec<u8>, AssemblerError>

fn number_of_bytes(&self) -> Result<usize, String>

Returns the number of bytes of the instructions by assembling it

fn number_of_bytes_with_context( &self, table: &mut SymbolsTableCaseDependent, ) -> Result<usize, String>

Return the number of bytes of the token given the provided context

fn to_bytes(&self) -> Result<Vec<u8>, AssemblerError>

Dummy version that assemble without taking into account the context TODO find a way to not build a symbol table each time

fn to_bytes_with_context( &self, table: &mut SymbolsTableCaseDependent, ) -> Result<Vec<u8>, AssemblerError>

Assemble the symbol taking into account some context, but never modify this context

fn is_valid(&self) -> bool

Check if the token is valid. We consider a token vlaid if it is possible to assemble it

impl Visited for Token

fn visited(&self, env: &mut Env) -> Result<(), AssemblerError>

Make all the necessary for the given token

impl Eq for Token

impl StructuralPartialEq for Token