Enum cpclib_asm::parser::LocatedToken

pub enum LocatedToken {
    Standard {
        token: Token,
        span: Z80Span,
    },
    Confined(LocatedListing, Z80Span),
    Defb(Vec<LocatedExpr>, Z80Span),
    Defw(Vec<LocatedExpr>, Z80Span),
    CrunchedSection(CrunchType, LocatedListing, Z80Span),
    Str(Vec<LocatedExpr>, Z80Span),
    For {
        label: Z80Span,
        start: LocatedExpr,
        stop: LocatedExpr,
        step: Option<LocatedExpr>,
        listing: LocatedListing,
        span: Z80Span,
    },
    Function(Z80Span, Vec<Z80Span>, LocatedListing, Z80Span),
    Include(Z80Span, Option<Z80Span>, bool, Z80Span),
    Incbin {
        fname: Z80Span,
        offset: Option<LocatedExpr>,
        length: Option<LocatedExpr>,
        extended_offset: Option<LocatedExpr>,
        off: bool,
        transformation: BinaryTransformation,
        span: Z80Span,
    },
    If(Vec<(LocatedTestKind, LocatedListing)>, Option<LocatedListing>, Z80Span),
    Label(Z80Span),
    Macro {
        name: Z80Span,
        params: Vec<Z80Span>,
        content: Z80Span,
        span: Z80Span,
    },
    MacroCall(Z80Span, Vec<LocatedMacroParam>, Z80Span),
    Module(Z80Span, LocatedListing, Z80Span),
    Repeat(LocatedExpr, LocatedListing, Option<Z80Span>, Option<LocatedExpr>, Z80Span),
    Iterate(Z80Span, Either<Vec<LocatedExpr>, LocatedExpr>, LocatedListing, Z80Span),
    RepeatUntil(LocatedExpr, LocatedListing, Z80Span),
    Rorg(LocatedExpr, LocatedListing, Z80Span),
    Struct(Z80Span, Vec<(Z80Span, LocatedToken)>, Z80Span),
    Switch(LocatedExpr, Vec<(LocatedExpr, LocatedListing, bool)>, Option<LocatedListing>, Z80Span),
    WarningWrapper(Box<LocatedToken>, String),
    While(LocatedExpr, LocatedListing, Z80Span),
}

Add span information for a Token. This hierarchy is a mirror of the original token one

Variants

Standard

Fields

token: Token

The original token without any span information

span: Z80Span

The span that correspond to the token

A token without any listing embedding

Confined(LocatedListing, Z80Span)

Defb(Vec<LocatedExpr>, Z80Span)

Defw(Vec<LocatedExpr>, Z80Span)

CrunchedSection(CrunchType, LocatedListing, Z80Span)

Str(Vec<LocatedExpr>, Z80Span)

For

Fields

label: Z80Span

start: LocatedExpr

stop: LocatedExpr

step: Option<LocatedExpr>

listing: LocatedListing

span: Z80Span

Function(Z80Span, Vec<Z80Span>, LocatedListing, Z80Span)

Include(Z80Span, Option<Z80Span>, bool, Z80Span)

Incbin

Fields

fname: Z80Span

offset: Option<LocatedExpr>

length: Option<LocatedExpr>

extended_offset: Option<LocatedExpr>

off: bool

transformation: BinaryTransformation

span: Z80Span

If(Vec<(LocatedTestKind, LocatedListing)>, Option<LocatedListing>, Z80Span)

Label(Z80Span)

Macro

Fields

name: Z80Span

params: Vec<Z80Span>

content: Z80Span

span: Z80Span

MacroCall(Z80Span, Vec<LocatedMacroParam>, Z80Span)

Name, Parameters, FullSpan

Module(Z80Span, LocatedListing, Z80Span)

Repeat(LocatedExpr, LocatedListing, Option<Z80Span>, Option<LocatedExpr>, Z80Span)

Iterate(Z80Span, Either<Vec<LocatedExpr>, LocatedExpr>, LocatedListing, Z80Span)

RepeatUntil(LocatedExpr, LocatedListing, Z80Span)

Rorg(LocatedExpr, LocatedListing, Z80Span)

Struct(Z80Span, Vec<(Z80Span, LocatedToken)>, Z80Span)

Name, Parameters, FullSpan

Switch(LocatedExpr, Vec<(LocatedExpr, LocatedListing, bool)>, Option<LocatedListing>, Z80Span)

WarningWrapper(Box<LocatedToken>, String)

While(LocatedExpr, LocatedListing, Z80Span)

Implementations

impl LocatedToken

pub fn token(&self) -> Result<&Token, ()>

We can obtain a token only for “standard ones”. Those that rely on listing need to be handled differently

pub fn context(&self) -> &ParserContext

impl LocatedToken

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

Transform the located token in a raw token. Warning, this is quite costly when strings or vec are involved

pub fn parse_token(_value: &str) -> Result<(), String>

Trait Implementations

impl Clone for LocatedToken

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 LocatedToken

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

Formats the value using the given formatter.

impl Display for LocatedToken

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

Formats the value using the given formatter.

impl ListingElement for LocatedToken

type Expr = LocatedExpr

type MacroParam = LocatedMacroParam

type TestKind = LocatedTestKind

fn is_equ(&self) -> bool

fn equ_symbol(&self) -> &str

fn equ_value(&self) -> &Expr

fn is_warning(&self) -> bool

fn warning_token(&self) -> &Self

fn warning_message(&self) -> &str

fn is_module(&self) -> bool

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

fn module_name(&self) -> &str

fn is_while(&self) -> bool

fn while_expr(&self) -> &Self::Expr

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

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

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

fn rorg_expr(&self) -> &Self::Expr

fn is_iterate(&self) -> bool

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

fn iterate_counter_name(&self) -> &str

fn iterate_values(&self) -> Either<&Vec<Self::Expr>, &Self::Expr>

fn is_for(&self) -> bool

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

fn for_label(&self) -> &str

fn for_start(&self) -> &Self::Expr

fn for_stop(&self) -> &Self::Expr

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

fn is_repeat_until(&self) -> bool

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

fn repeat_until_condition(&self) -> &Self::Expr

fn is_repeat(&self) -> bool

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

fn repeat_count(&self) -> &Self::Expr

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

fn repeat_counter_start(&self) -> Option<&Self::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) -> &[Self::MacroParam]

fn is_if(&self) -> bool

fn if_nb_tests(&self) -> usize

fn if_test(&self, idx: usize) -> (&Self::TestKind, &[Self])

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

fn is_include(&self) -> bool

fn is_incbin(&self) -> bool

fn incbin_fname(&self) -> &str

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

fn incbin_length(&self) -> Option<&Self::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) -> &[Self]

fn is_crunched_section(&self) -> bool

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

fn crunched_section_kind(&self) -> &CrunchType

fn is_confined(&self) -> bool

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

fn is_switch(&self) -> bool

fn switch_expr(&self) -> &Self::Expr

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

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

fn is_db(&self) -> bool

fn is_dw(&self) -> bool

fn is_str(&self) -> bool

fn include_is_standard_include(&self) -> bool

impl MayHaveSpan for LocatedToken

fn span(&self) -> &Z80Span

Get the span of the current token

fn has_span(&self) -> bool

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

impl ParsingStateVerified for LocatedToken

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

impl PartialEq<LocatedToken> for LocatedToken

fn eq(&self, other: &LocatedToken) -> 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 LocatedToken

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

impl ToSimpleToken for LocatedToken

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

Convert the token in its simplest form

impl TokenExt for LocatedToken

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

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

Unroll the tokens when it represents a loop

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

Generate the listing of opcodes for directives that embed bytes

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 LocatedToken

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

Make all the necessary for the given token

impl Eq for LocatedToken

impl StructuralEq for LocatedToken

impl StructuralPartialEq for LocatedToken