Enum aluasm::LexerError

pub enum LexerError<'i> {
    UnknownSegment(Rule),
    LibNoName(Src<'i>),
    LibNoId(Src<'i>),
    RoutineNoName(Src<'i>),
    RoutineUnrecognized(Src<'i>),
    StatementNoInstruction(Src<'i>),
    StatementNoFlag(Src<'i>),
    OperatorMiscomposition(Src<'i>),
    FlagWithoutValue(Src<'i>),
    RegisterNoType(Src<'i>),
    RegisterNoName(Src<'i>),
    RegisterNameNonDecimal(Src<'i>, ParseIntError),
    RegisterNoIndex(Src<'i>),
    RegisterIndexNonDecimal(Src<'i>, ParseIntError, &'i str),
    RegisterUnknown(Src<'i>),
    CallWithoutLibName(Src<'i>),
    CallWithoutRoutineName(Src<'i>),
    OperandUnknown(Src<'i>, &'i str),
    LiteralNoData(Src<'i>),
    LiteralWrongDec(Src<'i>, &'i str, ParseIntError),
    LiteralWrongHex(Src<'i>, &'i str, Error),
    LiteralWrongOct(Src<'i>, &'i str, ParseIntError),
    LiteralWrongBin(Src<'i>, &'i str, ParseIntError),
    FloatNoWhole(Src<'i>),
    FloatNoFraction(Src<'i>),
    FloatWholeNotNumber(Src<'i>, ParseIntError),
    FloatFractionNotNumber(Src<'i>, ParseIntError),
    FloatExponentialNotNumber(Src<'i>, ParseIntError),
    LiteralUnknown(Src<'i>, Rule),
    ConstNoName(Src<'i>),
    ConstNoValue(Src<'i>),
    VarNoName(Src<'i>),
    VarNoType(Src<'i>),
    VarNoDescription(Src<'i>),
    VarWrongDescription(Src<'i>),
    VarTypeUnknown(String, Src<'i>),
    ProgramAbsent,
}

Variants

UnknownSegment

unknown program segment {0:?}

Tuple Fields of UnknownSegment

0: Rule

LibNoName

library statement {0:#} has no detectable name {0}

Tuple Fields of LibNoName

0: Src<'i>

LibNoId

library statement {0:#} has no detectable lib id {0}

Tuple Fields of LibNoId

0: Src<'i>

RoutineNoName

routine {0:#} has no detectable name {0}

Tuple Fields of RoutineNoName

0: Src<'i>

RoutineUnrecognized

routine {0:#} does not start with neither .MAIN or .ROUTINE {0}

Tuple Fields of RoutineUnrecognized

0: Src<'i>

StatementNoInstruction

label in {0:#} is not followed by an instruction {0}

Tuple Fields of StatementNoInstruction

0: Src<'i>

StatementNoFlag

mnemonic is followed by non-flag rules {0}

Tuple Fields of StatementNoFlag

0: Src<'i>

OperatorMiscomposition

operator {0:#} is not composed of mnemonic and flags {0}

Tuple Fields of OperatorMiscomposition

0: Src<'i>

FlagWithoutValue

flag without flag value {0}

Tuple Fields of FlagWithoutValue

0: Src<'i>

RegisterNoType

register operand contains no register type {0}

Tuple Fields of RegisterNoType

0: Src<'i>

RegisterNoName

register operand does not specify register name {0}

Tuple Fields of RegisterNoName

0: Src<'i>

RegisterNameNonDecimal

register name must be encoded as a decimal number {0} details: {1}

Tuple Fields of RegisterNameNonDecimal

0: Src<'i>1: ParseIntError

RegisterNoIndex

register operand does not specify register index {0}

Tuple Fields of RegisterNoIndex

0: Src<'i>

RegisterIndexNonDecimal

register index {2} is not a decimal number {0} details: {1}

Tuple Fields of RegisterIndexNonDecimal

0: Src<'i>1: ParseIntError2: &'i str

RegisterUnknown

unknown register type {0}

Tuple Fields of RegisterUnknown

0: Src<'i>

CallWithoutLibName

call statement without library name {0}

Tuple Fields of CallWithoutLibName

0: Src<'i>

CallWithoutRoutineName

call statement without routine name {0}

Tuple Fields of CallWithoutRoutineName

0: Src<'i>

OperandUnknown

unknown operand format {1} inside the statement {0:#} {0}

Tuple Fields of OperandUnknown

0: Src<'i>1: &'i str

LiteralNoData

literal contains no data {0}

Tuple Fields of LiteralNoData

0: Src<'i>

LiteralWrongDec

incorrect decimal literal {1} {0} details: {2}

Tuple Fields of LiteralWrongDec

0: Src<'i>1: &'i str2: ParseIntError

LiteralWrongHex

incorrect hex literal {1} {0} details: {2}

Tuple Fields of LiteralWrongHex

0: Src<'i>1: &'i str2: Error

LiteralWrongOct

incorrect oct literal {1} {0} details: {2}

Tuple Fields of LiteralWrongOct

0: Src<'i>1: &'i str2: ParseIntError

LiteralWrongBin

incorrect bin literal {1} {0} details: {2}

Tuple Fields of LiteralWrongBin

0: Src<'i>1: &'i str2: ParseIntError

FloatNoWhole

float literal contains no whole mantissa part {0}

Tuple Fields of FloatNoWhole

0: Src<'i>

FloatNoFraction

float literal contains no fractional mantissa part {0}

Tuple Fields of FloatNoFraction

0: Src<'i>

FloatWholeNotNumber

float literal mantissa whole part is not an integer {0} details: {1}

Tuple Fields of FloatWholeNotNumber

0: Src<'i>1: ParseIntError

FloatFractionNotNumber

float literal mantissa fraction part is not an integer {0} details: {1}

Tuple Fields of FloatFractionNotNumber

0: Src<'i>1: ParseIntError

FloatExponentialNotNumber

float literal exponential part is not an integer {0} details: {1}

Tuple Fields of FloatExponentialNotNumber

0: Src<'i>1: ParseIntError

LiteralUnknown

unknown type of literal {1:?} {0}

Tuple Fields of LiteralUnknown

0: Src<'i>1: Rule

ConstNoName

constant statement has no name {0}

Tuple Fields of ConstNoName

0: Src<'i>

ConstNoValue

constant statement has no value {0}

Tuple Fields of ConstNoValue

0: Src<'i>

VarNoName

input variable has no name {0}

Tuple Fields of VarNoName

0: Src<'i>

VarNoType

input variable has no type {0}

Tuple Fields of VarNoType

0: Src<'i>

VarNoDescription

input variable has no description {0}

Tuple Fields of VarNoDescription

0: Src<'i>

VarWrongDescription

input variable description is not a string literal {0}

Tuple Fields of VarWrongDescription

0: Src<'i>

VarTypeUnknown

unknown variable type {0} {1}

Tuple Fields of VarTypeUnknown

0: String1: Src<'i>

ProgramAbsent

unable to detect program code

Implementations

impl<'i> LexerError<'i>

pub fn errno(&self) -> u16

Trait Implementations

impl<'i> Clone for LexerError<'i>

fn clone(&self) -> LexerError<'i>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'i> Debug for LexerError<'i>

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

Formats the value using the given formatter.

impl<'i> Display for LexerError<'i>

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

Formats the value using the given formatter.

impl<'i> Error for LexerError<'i>

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

impl<'i> From<LexerError<'i>> for String

fn from(err: LexerError<'i>) -> Self

Performs the conversion.

impl<'i> From<LexerError<'i>> for MainError

fn from(err: LexerError<'i>) -> Self

Performs the conversion.