Enum LocatedTokenInner

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

Variants

Align(LocatedExpr, Option<LocatedExpr>)

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

AssemblerControl(LocatedAssemblerControlCommand)

Assign

Fields

label: Z80Span

expr: LocatedExpr

op: Option<BinaryOperation>

Bank(Option<LocatedExpr>)

Bankset(LocatedExpr)

Basic(Option<Vec<Z80Span>>, Option<Vec<LocatedExpr>>, Z80Span)

Break

Breakpoint

Breakpoints are quite biased toward Ace-Dl representation

Fields

address: Option<LocatedExpr>

type: Option<RemuBreakPointType>

access: Option<RemuBreakPointAccessMode>

run: Option<RemuBreakPointRunMode>

mask: Option<LocatedExpr>

size: Option<LocatedExpr>

value: Option<LocatedExpr>

value_mask: Option<LocatedExpr>

condition: Option<LocatedExpr>

name: Option<LocatedExpr>

BuildCpr

BuildSna(Option<SnapshotVersion>)

Charset(CharsetFormat)

Comment(Z80Span)

Confined(LocatedListing)

CrunchedSection(CrunchType, LocatedListing)

Defb(Vec<LocatedExpr>)

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

Defw(Vec<LocatedExpr>)

End

Equ

Fields

label: Z80Span

expr: LocatedExpr

Export(Vec<Z80Span>)

Fail(Option<Vec<FormattedExpr>>)

Field

Fields

label: Z80Span

expr: LocatedExpr

For

Fields

label: Z80Span

start: LocatedExpr

stop: LocatedExpr

step: Option<LocatedExpr>

listing: LocatedListing

Function(Z80Span, Vec<Z80Span>, LocatedListing)

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

Incbin

Fields

fname: LocatedExpr

offset: Option<LocatedExpr>

length: Option<LocatedExpr>

extended_offset: Option<LocatedExpr>

off: bool

transformation: BinaryTransformation

Include(LocatedExpr, Option<Z80Span>, bool)

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

Label(Z80Span)

Let(Z80Span, Expr)

Limit(LocatedExpr)

List

Macro

Fields

name: Z80Span

params: Vec<Z80Span>

content: Z80Span

flavor: AssemblerFlavor

MacroCall(Z80Span, Vec<LocatedMacroParam>)

Name, Parameters, FullSpan

Map(LocatedExpr)

Module(Z80Span, LocatedListing)

MultiPop(Vec<LocatedDataAccess>)

MultiPush(Vec<LocatedDataAccess>)

Next

Fields

label: Z80Span

source: Z80Span

expr: Option<LocatedExpr>

NoExport(Vec<Z80Span>)

NoList

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

Org

Fields

val1: LocatedExpr

val2: Option<LocatedExpr>

Pause

Print(Vec<FormattedExpr>)

Protect(LocatedExpr, LocatedExpr)

Range(Z80Span, LocatedExpr, LocatedExpr)

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

RepeatUntil(LocatedExpr, LocatedListing)

Return(LocatedExpr)

Rorg(LocatedExpr, LocatedListing)

Run(LocatedExpr, Option<LocatedExpr>)

Save

Fields

filename: LocatedExpr

address: Option<LocatedExpr>

size: Option<LocatedExpr>

save_type: Option<SaveType>

dsk_filename: Option<LocatedExpr>

side: Option<LocatedExpr>

Section(Z80Span)

SetN

Fields

label: Z80Span

source: Z80Span

expr: Option<LocatedExpr>

Skip(LocatedExpr)

SnaInit(LocatedExpr)

SnaSet(SnapshotFlag, FlagValue)

StableTicker(StableTickerAction<Z80Span>)

StartingIndex

Fields

start: Option<LocatedExpr>

step: Option<LocatedExpr>

Str(Vec<LocatedExpr>)

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

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

Undef(Z80Span)

WaitNops(LocatedExpr)

WarningWrapper(Box<Self>, String)

While(LocatedExpr, LocatedListing)

Implementations

impl LocatedTokenInner

pub fn new_opcode( mne: Mnemonic, arg1: Option<LocatedDataAccess>, arg2: Option<LocatedDataAccess>, ) -> Self

pub fn into_located_token_direct(self) -> LocatedToken

pub fn into_located_token_at(self, span: InnerZ80Span) -> LocatedToken

pub fn into_located_token_between( self, start_checkpoint: &<InnerZ80Span as Stream>::Checkpoint, i: InnerZ80Span, ) -> LocatedToken

start: checkpoint for the start of the token stop: checkpoint for the stop of the token i: stream after parse: is copied

Trait Implementations

impl Debug for LocatedTokenInner

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

Formats the value using the given formatter.

impl ListingElement for LocatedTokenInner

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

type AssemblerControlCommand = LocatedAssemblerControlCommand

type DataAccess = LocatedDataAccess

type Expr = LocatedExpr

type MacroParam = LocatedMacroParam

type TestKind = LocatedTestKind

fn is_run(&self) -> bool

fn is_save(&self) -> bool

fn is_breakpoint(&self) -> bool

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

fn equ_symbol(&self) -> &str

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

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

fn assign_symbol(&self) -> &str

fn module_name(&self) -> &str

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

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

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

fn iterate_counter_name(&self) -> &str

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

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

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

fn assign_value(&self) -> &Self::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) -> &Self::Expr

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

fn is_print(&self) -> bool

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 repeat_until_condition(&self) -> &Self::Expr

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 if_nb_tests(&self) -> usize

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

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

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

fn incbin_transformation(&self) -> &BinaryTransformation

fn include_fname(&self) -> &Self::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) -> &Self::Expr

fn data_exprs(&self) -> &[Self::Expr]

fn is_warning(&self) -> bool

fn warning_token(&self) -> &Self

fn warning_message(&self) -> &str

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

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

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

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

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

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

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

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

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

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

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

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

fn is_confined(&self) -> bool

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

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

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

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

fn assembler_control_command(&self) -> &Self::AssemblerControlCommand

fn defer_listing_output(&self) -> bool

fn include_is_standard_include(&self) -> bool

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

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

fn macro_flavor(&self) -> AssemblerFlavor

fn is_opcode(&self) -> bool

fn starts_with_label(&self) -> bool

impl ParsingStateVerified for LocatedTokenInner

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

impl PartialEq for LocatedTokenInner

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

impl StructuralPartialEq for LocatedTokenInner