Struct customasm::AssemblerState

pub struct AssemblerState {
    pub cpudef: Option<CpuDef>,
    pub labels: LabelManager,
    pub parsed_instrs: Vec<ParsedInstruction>,
    pub parsed_exprs: Vec<ParsedExpression>,
    pub bankdefs: Vec<BankDef>,
    pub blocks: Vec<Bank>,
    pub cur_bank: usize,
    pub cur_block: usize,
}

Fields

cpudef: Option<CpuDef>

labels: LabelManager

parsed_instrs: Vec<ParsedInstruction>

parsed_exprs: Vec<ParsedExpression>

bankdefs: Vec<BankDef>

blocks: Vec<Bank>

cur_bank: usize

cur_block: usize

Methods

impl AssemblerState

pub fn new() -> AssemblerState

pub fn process_file<S>(
    &mut self,
    report: RcReport,
    fileserver: &dyn FileServer,
    filename: S
) -> Result<(), ()> where
    S: Into<String>, 

pub fn wrapup(&mut self, report: RcReport) -> Result<(), ()>

pub fn get_binary_output(&self) -> BinaryBlock

pub fn get_symbol_output(&self) -> String

impl AssemblerState

pub fn check_cpudef_active(
    &self,
    report: RcReport,
    span: &Span
) -> Result<(), ()>

pub fn get_cur_context(&self) -> ExpressionContext

pub fn find_bankdef(&self, name: &str) -> Option<usize>

pub fn check_bank_overlap(&self, report: RcReport)

pub fn get_cur_address(
    &self,
    report: RcReport,
    span: &Span
) -> Result<usize, ()>

pub fn check_valid_address(
    &self,
    report: RcReport,
    block_index: usize,
    addr: usize,
    span: &Span
) -> Result<(), ()>

pub fn output_bits_until_aligned(
    &mut self,
    report: RcReport,
    multiple_of: usize,
    report_span: &Span,
    output_span: Option<&Span>
) -> Result<(), ()>

pub fn output_bit(
    &mut self,
    report: RcReport,
    bit: bool,
    skipping: bool,
    report_span: &Span,
    output_span: Option<&Span>
) -> Result<(), ()>

pub fn output_zero_bits(
    &mut self,
    report: RcReport,
    num: usize,
    skipping: bool,
    report_span: &Span,
    output_span: Option<&Span>
) -> Result<(), ()>

pub fn mark_label(&mut self, addr: usize, output_span: &Span)

pub fn resolve_instrs(&mut self, report: RcReport) -> Result<(), ()>

pub fn resolve_exprs(&mut self, report: RcReport) -> Result<(), ()>

pub fn check_expr_constraint(
    &self,
    report: RcReport,
    value: &ExpressionValue,
    typ: &RuleParameterType,
    span: &Span
) -> Result<(), ()>

pub fn output_parsed_instr(
    &mut self,
    report: RcReport,
    instr: &mut ParsedInstruction
) -> Result<(), ()>

pub fn output_parsed_expr(
    &mut self,
    report: RcReport,
    expr: &ParsedExpression
) -> Result<(), ()>

pub fn expr_eval(
    &self,
    report: RcReport,
    ctx: &ExpressionContext,
    expr: &Expression,
    eval_ctx: &mut ExpressionEvalContext
) -> Result<ExpressionValue, ()>