Struct RuntimeProgram 

pub struct RuntimeProgram { /* private fields */ }

A loaded, ready-to-run program image with owned runtime state.

Produced by load_program from .cdlb bytes. Self::run executes it exactly as the full candela binary runs a freshly compiled program, and Self::call invokes an exported function by name. Registers and heap pools stay resident between calls, so state one call establishes is visible to the next.

Implementations

impl RuntimeProgram

pub fn native_functions(&self) -> usize

How many of the program’s functions run as machine code on this machine: zero when its artifact carries none this machine runs.

pub fn run(&mut self)

Runs the program’s main to completion.

A runtime error prints its report and ends the process, matching the full candela <file.cdl> path exactly. A host that wants the error as a value instead runs this inside collect_diagnostic.

pub fn call(&mut self, name: &str, args: &[Value]) -> Result<Value, CallError>

Invokes the exported function name with args, returning its value (or Value::Null for a function that returns nothing).

The call runs the trampoline the compiler emitted for the function at build time, against the resident register and heap state, so globals a previous call or main established remain visible. Arguments are checked against the declared parameter types before anything runs.

Errors

Returns a CallError if the artifact exports no such function, if the arguments disagree with the declared signature, or if the call raises a runtime error.

pub fn collect(&mut self, budget: u32) -> bool

Does up to about budget units of garbage collection while the program is idle, and answers whether no collection work is left.

Call it between calls into the program, where the host would otherwise wait, such as between frames. It carries on a collection already under way, or begins one when the heap has grown enough since the last; on a heap that has not, it does nothing and answers true. A unit is about one object traced or one freed slot, never a length of time, so the same calls do the same work on every machine. collect(u32::MAX) runs a whole collection. Beginning a collection reads every root at once whatever the budget.

Once a host has called this, allocations leave more of the work to it and begin a collection themselves only when the heap has grown further.

pub fn gc_stats(&self) -> GcStats

What the collector has done over this program’s heap, and how large the heap is. See GcStats.

pub fn exports(&self) -> impl Iterator<Item = &str>

The names of every function this artifact exports, in no particular order.