Struct State 

pub struct State<'a> {

    pub registers: &'a mut Vec<Data>,
    pub fns: &'a mut Vec<Function>,
    pub structs: &'a mut Vec<Struct>,
    pub enums: &'a mut Vec<EnumType>,
    pub pools: &'a mut Pools,
    pub instr_src: &'a mut Vec<InstrSrc>,
    pub fn_registers: &'a mut Vec<Vec<u16>>,
    pub dyn_libs: &'a mut Vec<Dynamiclib>,
    pub allocated_arg_count: &'a mut usize,
    pub allocated_call_depth: &'a mut usize,
    pub const_registers: &'a mut FxHashMap<Data, u16>,
    pub free_registers: &'a mut Vec<u16>,
    pub sources: &'a mut Vec<Source>,
    pub reserved_registers: FxHashSet<u16>,
    pub namespace: &'a mut Namespace,
}

Fields

registers: &'a mut Vec<Data>

fns: &'a mut Vec<Function>

structs: &'a mut Vec<Struct>

enums: &'a mut Vec<EnumType>

pools: &'a mut Pools

instr_src: &'a mut Vec<InstrSrc>

fn_registers: &'a mut Vec<Vec<u16>>

dyn_libs: &'a mut Vec<Dynamiclib>

allocated_arg_count: &'a mut usize

allocated_call_depth: &'a mut usize

const_registers: &'a mut FxHashMap<Data, u16>

free_registers: &'a mut Vec<u16>

sources: &'a mut Vec<Source>

reserved_registers: FxHashSet<u16>

namespace: &'a mut Namespace

Implementations

impl State<'_>

pub fn free_reg(&mut self, id: u16, v: &[Variable])

Marks a register as free, allowing it to later be reused by alloc_reg. The register is marked as free iff:

• the register isn’t tied to any variable
• the register isn’t a constant register
• the register isn’t reserved in reserved_registers
• the register isn’t already marked as free

pub fn alloc_reg(&mut self) -> u16

Allocates a register. It free_registers isn’t empty, it will reuse the latest one. Else, it will allocate a new one.

pub fn alloc_reg_tgt(&mut self, tgt_id: Option<u16>) -> u16

Allocates a register, reusing tgt_id if it holds some register id. If tgt_id == None, it calls alloc_reg().

pub fn free_scope_registers( &mut self, regs_before: u16, scope_instrs: &[Instr], v: &[Variable], )

Frees registers that are written by instructions in scope_instrs.

pub fn free_loop_scope_registers( &mut self, regs_before: u16, scope_instrs: &[Instr], v: &[Variable], )

Similar to free_scope_registers, but also frees CloneArray template registers. Only call this after a loop ends.

pub fn add_to_src(&mut self, ctx: Ctx, output: &[Instr], span: Span)

Associates the last instruction in output with span and adds the InstrSrc to instr_src. This allows runtime errors to be traced back to span in the source code.