Enum cpclib_asm::preamble::instructions::Token

pub enum Token {
    Align(Expr, Option<Expr>),
    Assert(Expr, Option<Vec<FormattedExpr, Global>>),
    Assign(SmolStr, Expr, Option<BinaryOperation>),
    Bank(Option<Expr>),
    Bankset(Expr),
    Basic(Option<Vec<SmolStr, Global>>, Option<Vec<u16, Global>>, String),
    Break,
    Breakpoint(Option<Expr>),
    BuildCpr,
    BuildSna(Option<SnapshotVersion>),
    Charset(CharsetFormat),
    Comment(String),
    CrunchedBinary(CrunchType, SmolStr),
    CrunchedSection(CrunchType, BaseListing<Token>),
    Defb(Vec<Expr, Global>),
    Defs(Vec<(Expr, Option<Expr>), Global>),
    Defw(Vec<Expr, Global>),
    End,
    Equ(SmolStr, Expr),
    Export(Vec<SmolStr, Global>),
    Fail(Option<Vec<FormattedExpr, Global>>),
    For {
        label: SmolStr,
        start: Expr,
        stop: Expr,
        step: Option<Expr>,
        listing: BaseListing<Token>,
    },
    Function(SmolStr, Vec<SmolStr, Global>, BaseListing<Token>),
    If(Vec<(TestKind, BaseListing<Token>), Global>, Option<BaseListing<Token>>),
    Incbin {
        fname: String,
        offset: Option<Expr>,
        length: Option<Expr>,
        extended_offset: Option<Expr>,
        off: bool,
        transformation: BinaryTransformation,
    },
    Include(String, Option<SmolStr>, bool),
    Iterate(SmolStr, Vec<Expr, Global>, BaseListing<Token>),
    Label(SmolStr),
    Let(SmolStr, Expr),
    Limit(Expr),
    List,
    Macro(SmolStr, Vec<SmolStr, Global>, String),
    MacroCall(SmolStr, Vec<MacroParam, Global>),
    Module(SmolStr, BaseListing<Token>),
    MultiPop(Vec<DataAccess, Global>),
    MultiPush(Vec<DataAccess, Global>),
    Next(SmolStr, SmolStr, Option<Expr>),
    NoExport(Vec<SmolStr, Global>),
    NoList,
    OpCode(Mnemonic, Option<DataAccess>, Option<DataAccess>, Option<Register8>),
    Org(Expr, Option<Expr>),
    Pause,
    Print(Vec<FormattedExpr, Global>),
    Protect(Expr, Expr),
    Range(String, Expr, Expr),
    Repeat(Expr, BaseListing<Token>, Option<SmolStr>, Option<Expr>),
    RepeatUntil(Expr, BaseListing<Token>),
    Return(Expr),
    Rorg(Expr, BaseListing<Token>),
    Run(Expr, Option<Expr>),
    Save {
        filename: String,
        address: Option<Expr>,
        size: Option<Expr>,
        save_type: Option<SaveType>,
        dsk_filename: Option<String>,
        side: Option<Expr>,
    },
    Section(SmolStr),
    SetCPC(Expr),
    SetCrtc(Expr),
    SetN(SmolStr, SmolStr, Option<Expr>),
    SnaInit(String),
    SnaSet(SnapshotFlag, FlagValue),
    StableTicker(StableTickerAction),
    Str(Vec<Expr, Global>),
    Struct(SmolStr, Vec<(SmolStr, Token), Global>),
    Switch(Expr, Vec<(Expr, BaseListing<Token>, bool), Global>, 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

Align(Expr, Option<Expr>)

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

Assign(SmolStr, Expr, 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, Global>>, Option<Vec<u16, Global>>, String)

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

Break

Breakpoint(Option<Expr>)

BuildCpr

BuildSna(Option<SnapshotVersion>)

Charset(CharsetFormat)

Comment(String)

CrunchedBinary(CrunchType, SmolStr)

CrunchedSection(CrunchType, BaseListing<Token>)

Defb(Vec<Expr, Global>)

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

Defw(Vec<Expr, Global>)

End

Equ(SmolStr, Expr)

Export(Vec<SmolStr, Global>)

Fail(Option<Vec<FormattedExpr, Global>>)

For

Fields

label: SmolStr

start: Expr

stop: Expr

step: Option<Expr>

listing: BaseListing<Token>

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

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

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

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

Incbin

Fields

fname: String

offset: Option<Expr>

length: Option<Expr>

extended_offset: Option<Expr>

off: bool

transformation: BinaryTransformation

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

Include(String, Option<SmolStr>, bool)

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

Label(SmolStr)

Let(SmolStr, Expr)

Limit(Expr)

List

Macro(SmolStr, Vec<SmolStr, Global>, String)

MacroCall(SmolStr, Vec<MacroParam, Global>)

Module(SmolStr, BaseListing<Token>)

MultiPop(Vec<DataAccess, Global>)

MultiPush(Vec<DataAccess, Global>)

Next(SmolStr, SmolStr, Option<Expr>)

NoExport(Vec<SmolStr, Global>)

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(Expr, Option<Expr>)

Pause

Print(Vec<FormattedExpr, Global>)

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

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: String

address: Option<Expr>

size: Option<Expr>

save_type: Option<SaveType>

dsk_filename: Option<String>

side: Option<Expr>

Section(SmolStr)

SetCPC(Expr)

SetCrtc(Expr)

SetN(SmolStr, SmolStr, Option<Expr>)

SnaInit(String)

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

SnaSet(SnapshotFlag, FlagValue)

StableTicker(StableTickerAction)

Str(Vec<Expr, Global>)

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

Switch(Expr, Vec<(Expr, BaseListing<Token>, bool), Global>, 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 copy 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 ListingElement for Token

type Expr = Expr

type MacroParam = MacroParam

type TestKind = TestKind

fn is_equ(&self) -> bool

fn equ_symbol(&self) -> &str

fn equ_value(&self) -> &Expr

fn is_warning(&self) -> bool

fn warning_token(&self) -> &Token

fn warning_message(&self) -> &str

fn is_module(&self) -> bool

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

fn module_name(&self) -> &str

fn is_while(&self) -> bool

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

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

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

fn mnemonic_arg1(&self) -> Option<&DataAccess>

fn mnemonic_arg2(&self) -> Option<&DataAccess>

fn mnemonic_arg1_mut(&mut self) -> Option<&mut DataAccess>

fn mnemonic_arg2_mut(&mut self) -> Option<&mut DataAccess>

fn is_directive(&self) -> bool

fn is_iterate(&self) -> bool

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

fn iterate_counter_name(&self) -> &str

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

fn is_for(&self) -> bool

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

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 is_repeat_until(&self) -> bool

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

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

fn is_repeat(&self) -> bool

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

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 is_if(&self) -> bool

fn if_nb_tests(&self) -> usize

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

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

fn is_include(&self) -> bool

fn is_incbin(&self) -> bool

fn incbin_fname(&self) -> &str

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) -> &str

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

fn include_once(&self) -> bool

fn is_call_macro_or_build_struct(&self) -> bool

fn is_function_definition(&self) -> bool

fn function_definition_name(&self) -> &str

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

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

fn is_crunched_section(&self) -> bool

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

fn crunched_section_kind(&self) -> &CrunchType

fn is_rorg(&self) -> bool

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

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

fn is_confined(&self) -> bool

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

fn is_switch(&self) -> bool

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

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

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

fn is_db(&self) -> bool

fn is_dw(&self) -> bool

fn is_str(&self) -> bool

fn include_is_standard_include(&self) -> bool

impl Locate for Token

type Output = LocatedToken

fn locate(self, span: Z80Span, size: usize) -> LocatedToken

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<Token> for Token

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl ReturnExpr for Token

fn return_expr(&self) -> Option<&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: &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 to_bytes_with_options( &self, option: EnvOptions ) -> Result<Vec<u8>, AssemblerError>

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

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