Enum Expr 

pub enum Expr {
    RelativeDelta(i8),
    Value(i32),
    Float(OrderedFloat<f64>),
    Char(char),
    Bool(bool),
    String(SmolStr),
    Label(SmolStr),
    List(Vec<Expr>),
    PrefixedLabel(LabelPrefix, SmolStr),
    Paren(Box<Expr>),
    UnaryFunction(UnaryFunction, Box<Expr>),
    UnaryOperation(UnaryOperation, Box<Expr>),
    UnaryTokenOperation(UnaryTokenOperation, Box<Token>),
    BinaryFunction(BinaryFunction, Box<Expr>, Box<Expr>),
    BinaryOperation(BinaryOperation, Box<Expr>, Box<Expr>),
    AnyFunction(SmolStr, Vec<Expr>),
    Rnd,
}

Expression nodes.

Variants

RelativeDelta(i8)

Only used for disassembled code

Value(i32)

32 bits integer value (should be able to include any integer value manipulated by the assember.

Float(OrderedFloat<f64>)

Char(char)

Char

Bool(bool)

Boolean

String(SmolStr)

String (for db directive)

Label(SmolStr)

Label

List(Vec<Expr>)

List of expression

PrefixedLabel(LabelPrefix, SmolStr)

Label with a prefix

Paren(Box<Expr>)

UnaryFunction(UnaryFunction, Box<Expr>)

UnaryOperation(UnaryOperation, Box<Expr>)

UnaryTokenOperation(UnaryTokenOperation, Box<Token>)

BinaryFunction(BinaryFunction, Box<Expr>, Box<Expr>)

BinaryOperation(BinaryOperation, Box<Expr>, Box<Expr>)

AnyFunction(SmolStr, Vec<Expr>)

Function supposely coded by the user

Rnd

Random value

Implementations

impl Expr

pub fn to_simplified_string(&self) -> String

impl Expr

pub fn do_apply_macro_labels_modification(s: &mut String, seed: usize)

pub fn neg(self) -> Expr

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Display for Expr

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

Formats the value using the given formatter.

impl ExprElement for Expr

fn is_context_independant(&self) -> bool

Check if it is necessary to read within a symbol table

fn fix_relative_value(&mut self)

When disassembling an instruction with relative expressions, the contained value needs to be transformed as an absolute value

type ResultExpr = Expr

type Token = Token

fn to_expr(&self) -> Cow<'_, Expr>

fn is_negated(&self) -> bool

fn is_relative(&self) -> bool

fn relative_delta(&self) -> i8

fn neg(&self) -> Expr

fn add<E>(&self, v: E) -> Expr

where E: Into<Expr>,

fn not(&self) -> <Expr as ExprElement>::ResultExpr

fn is_value(&self) -> bool

fn value(&self) -> i32

fn is_char(&self) -> bool

fn char(&self) -> char

fn is_bool(&self) -> bool

fn bool(&self) -> bool

fn is_string(&self) -> bool

fn string(&self) -> &str

fn is_float(&self) -> bool

fn float(&self) -> OrderedFloat<f64>

fn is_list(&self) -> bool

fn list(&self) -> &[Expr]

fn is_label(&self) -> bool

fn label(&self) -> &str

fn is_token_operation(&self) -> bool

fn token_operation(&self) -> &UnaryTokenOperation

fn token(&self) -> &<Expr as ExprElement>::Token

fn is_prefix_label(&self) -> bool

fn prefix(&self) -> &LabelPrefix

fn is_binary_operation(&self) -> bool

fn binary_operation(&self) -> BinaryOperation

fn is_unary_operation(&self) -> bool

fn unary_operation(&self) -> UnaryOperation

fn is_unary_function(&self) -> bool

fn unary_function(&self) -> UnaryFunction

fn is_binary_function(&self) -> bool

fn binary_function(&self) -> BinaryFunction

fn is_paren(&self) -> bool

fn is_rnd(&self) -> bool

fn is_any_function(&self) -> bool

fn function_name(&self) -> &str

fn function_args(&self) -> &[Expr]

fn arg1(&self) -> &Expr

fn arg2(&self) -> &Expr

fn is_label_value(&self, label: &str) -> bool

impl ExprEvaluationExt for Expr

fn symbols_used(&self) -> Vec<&str>

XXX Be sure it is well synchronized with LocatedExpr

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

Resolve the expression base on the env context

fn eval(&self) -> Result<ExprResult, AssemblerError>

Simple evaluation without context => can only evaluate number based operations.

impl From<&str> for Expr

fn from(src: &str) -> Expr

Converts to this type from the input type.

impl From<Expr> for DataAccess

fn from(exp: Expr) -> DataAccess

Converts to this type from the input type.

impl From<Expr> for FormattedExpr

fn from(e: Expr) -> FormattedExpr

Converts to this type from the input type.

impl From<LocatedExpr> for Expr

fn from(val: LocatedExpr) -> Self

Converts to this type from the input type.

impl From<i16> for Expr

fn from(src: i16) -> Expr

Converts to this type from the input type.

impl From<i32> for Expr

fn from(src: i32) -> Expr

Converts to this type from the input type.

impl From<i8> for Expr

fn from(src: i8) -> Expr

Converts to this type from the input type.

impl From<u16> for Expr

fn from(src: u16) -> Expr

Converts to this type from the input type.

impl From<u32> for Expr

fn from(src: u32) -> Expr

Converts to this type from the input type.

impl From<u8> for Expr

fn from(src: u8) -> Expr

Converts to this type from the input type.

impl From<usize> for Expr

fn from(src: usize) -> Expr

Converts to this type from the input type.

impl Hash for Expr

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 MayHaveSpan for Expr

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

fn has_span(&self) -> bool

fn span(&self) -> &Z80Span

impl PartialEq for Expr

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

fn to_orgams_string(&self) -> Result<Cow<'_, str>, ToOrgamsError>

impl Eq for Expr

impl StructuralPartialEq for Expr