Struct Chunk 

pub struct Chunk {
    pub module_name: Rc<str>,
    pub codegen_location: Location,
    pub preallocate_stack_slots: u32,
    /* private fields */
}

A chunk of bytecode.

Fields

module_name: Rc<str>

The name of the module where the chunk is located.

codegen_location: Location

The location emitted for each quad-byte on calls to push.

preallocate_stack_slots: u32

How many stack slots to preallocate with nil values for variable lookups.

Implementations

impl Chunk

pub fn new(module_name: Rc<str>) -> Self

Constructs an empty chunk.

pub fn emit(&mut self, what: impl EncodeInstruction) -> usize

Pushes an encodable piece of data into the chunk. Returns where it’s located.

pub fn emit_number(&mut self, number: f64)

Pushes a number into the chunk.

pub fn emit_string(&mut self, string: &str)

Pushes a string into the chunk.

The string is padded with zeroes such that opcodes are aligned to four bytes.

pub fn patch(&mut self, position: usize, instruction: impl EncodeInstruction)

Patches the instruction at the given position.

pub unsafe fn read_instruction(&self, pc: &mut usize) -> (Opcode, Opr24)

Reads an instruction.

Safety

Assumes that pc is within the chunk’s bounds and that the opcode at pc is valid.

pub unsafe fn read_number(&self, pc: &mut usize) -> f64

Reads a number.

Safety

Assumes that pc is within the chunk’s bounds, skipping any checks.

pub unsafe fn read_string(&self, pc: &mut usize) -> &str

Reads a string.

Safety

This assumes the original string was encoded as proper UTF-8 (which it should have been considering the only way to write a string is to use a &str in the first place).

pub fn len(&self) -> usize

Returns the length of the chunk (in bytes).

pub fn is_empty(&self) -> bool

Returns whether the chunk is empty.

pub fn location(&self, pc: usize) -> Location

Returns the location (in file) of the program counter.

pub fn at_end(&self, pc: usize) -> bool

Returns whether the given program counter is at the end of the chunk.

Trait Implementations

impl Debug for Chunk

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

Formats the value using the given formatter.