pub struct Chunk { /* private fields */ }Expand description
An assembled sequence of instructions with its constant pool.
Cloning a chunk is a deep copy of both vectors; it is cheap relative to
execution and lets a compiled program be run many times. A chunk carries no
interpreter state — that lives in the Vm — so the same chunk can
be executed concurrently by separate VMs.
Implementations§
Source§impl Chunk
impl Chunk
Sourcepub fn new() -> Self
pub fn new() -> Self
Create an empty chunk with no instructions, no constants, and a zero-width register file.
§Examples
use bvm_lang::Chunk;
let chunk = Chunk::new();
assert!(chunk.is_empty());
assert_eq!(chunk.registers(), 0);Sourcepub fn emit(&mut self, op: Op) -> Addr
pub fn emit(&mut self, op: Op) -> Addr
Append an instruction and return its address.
The returned Addr is where the instruction sits in the code array —
the same value a branch uses as its target, and the argument
patch takes to rewrite this slot later. Returning an
Addr lets an emitted address feed straight back into a Jump/patch
without a cast. Emitting widens the register file to include every
register the instruction names.
§Examples
use bvm_lang::{Chunk, Op};
let mut chunk = Chunk::new();
let first = chunk.emit(Op::LoadInt { dst: 0, val: 41 });
assert_eq!(first, 0);
// Naming register 0 sized the file to one slot.
assert_eq!(chunk.registers(), 1);Sourcepub fn constant(&mut self, value: Value) -> Option<u16>
pub fn constant(&mut self, value: Value) -> Option<u16>
Add value to the constant pool and return its index for
LoadConst.
Constants are not deduplicated; adding the same value twice yields two slots. This keeps the builder allocation-light and predictable — a compiler that wants interning can layer it on top.
§Errors
Returns None if the pool already holds u16::MAX + 1 constants, the
most a Const index can address. A single function body
reaching 65 536 distinct constants is pathological, so callers typically
treat this as unreachable rather than a runtime path.
§Examples
use bvm_lang::{Chunk, Op, Value};
let mut chunk = Chunk::new();
let k = chunk.constant(Value::float(3.5)).expect("pool has room");
chunk.emit(Op::LoadConst { dst: 0, index: k });Sourcepub fn patch(&mut self, addr: Addr, op: Op) -> bool
pub fn patch(&mut self, addr: Addr, op: Op) -> bool
Overwrite the instruction at addr, typically to fill in a branch target
that was not known when the instruction was first emitted.
Returns true if addr was a valid slot and the rewrite happened, and
false if it was out of range. Rewriting can change which registers the
chunk touches, so the register file is re-derived from scratch to stay
exact.
§Examples
use bvm_lang::{Chunk, Op};
let mut chunk = Chunk::new();
// Emit a forward branch whose target is not yet known.
let jump = chunk.emit(Op::Jump { target: 0 });
chunk.emit(Op::LoadInt { dst: 0, val: 1 }); // skipped by the jump
let landing = chunk.emit(Op::Halt); // where the jump should land
// Now patch the branch to skip the load. `landing` is already an `Addr`.
assert!(chunk.patch(jump, Op::Jump { target: landing }));Trait Implementations§
Source§impl<'de> Deserialize<'de> for Chunk
Available on crate feature serde only.
impl<'de> Deserialize<'de> for Chunk
serde only.