Struct dynasm::State

pub struct State<'a> {
    pub stmts: &'a mut Vec<Stmt>,
    pub target: &'a str,
    pub file_data: &'a mut DynasmData,
}

This struct contains all non-parsing state that dynasm! requires while parsing and compiling

Fields

stmts: &'a mut Vec<Stmt>

target: &'a str

file_data: &'a mut DynasmData

Trait Implementations

impl<'_> AssembleX64 for State<'_>

fn compile_instruction(
    &mut self,
    arch: &Archx64,
    instruction: InstructionX64
) -> Result<(), Error>

Turn an expression into binary format. May error when dynamic data is present at bad locations such as memory address scaling.

fn build_instruction(
    &mut self,
    _: &Archx64,
    _: InstructionX64
) -> Result<(), Error> where
    Self: BasicExprBuilder, 

Create an instruction composed from dynamic data. Only available when the type is also capable of building new composite expressions.

impl<'_> AssembleX86 for State<'_>

fn compile_instruction(
    &mut self,
    arch: &Archx86,
    instruction: InstructionX86
) -> Result<(), Error>

Turn an expression into binary format. May error when dynamic data is present at bad locations such as memory address scaling.

fn build_instruction(
    &mut self,
    _: &Archx86,
    _: InstructionX86
) -> Result<(), Error> where
    Self: BasicExprBuilder, 

Create an instruction composed from dynamic data. Only available when the type is also capable of building new composite expressions.

impl<'_> BasicExprBuilder for State<'_>

A simple implementation of a BasicExprBuilder.

It can not combine any expressions, pushes statements into a Vec and emits errors onto standard error directly.

fn push(&mut self, stmt: Stmt)

Append a new statement.

fn emit_error_at(&mut self, _: ErrorSpan, args: Arguments)

Emits the error message on stderr.

fn bit_or(&mut self, _: Expr, _: Value) -> Option<Expr>

a | b

fn bit_and(&mut self, _: Expr, _: Value) -> Option<Expr>

a & b

fn bit_xor(&mut self, _: Expr, _: Value) -> Option<Expr>

a ^ b

fn add(&mut self, _: Expr, _: Value) -> Option<Expr>

a + b

fn mul(&mut self, _: Expr, _: Value) -> Option<Expr>

a * b

fn neg(&mut self, _: Expr) -> Option<Expr>

!a

fn log2(&mut self, _: Expr) -> Option<Expr>

Log2, mostly used to encode scalings.

fn mask_shift(&mut self, _: Expr, _: u64, _: i8) -> Option<Expr>

(val & mask) << shift