Struct BytecodeExecutor 

pub struct BytecodeExecutor { /* private fields */ }

Bytecode executor for compiling and running Shape programs.

Core stdlib is loaded via prelude injection (AST inlining) rather than bytecode merging.

Implementations

impl BytecodeExecutor

pub fn new() -> Self

Create a new executor

pub fn register_extension(&mut self, module: ModuleExports)

Register an external/user extension module (e.g. loaded from a .so plugin). It will be available in all subsequent executions. Bundled Shape sources are kept for legacy virtual-module imports.

pub fn module_schemas(&self) -> Vec<ParsedModuleSchema>

Return all currently registered extension/extension module schemas.

pub fn enable_bytecode_cache(&mut self) -> bool

Enable bytecode caching. Compiled programs will be stored as .shapec files and reused on subsequent runs if the source hasn’t changed. Returns false if the cache directory could not be created.

pub fn set_interrupt(&mut self, flag: Arc<AtomicU8>)

Set the interrupt flag (shared with Ctrl+C handler).

pub fn set_dependency_paths(&mut self, paths: HashMap<String, PathBuf>)

Set resolved dependency paths from shape.toml [dependencies].

These are mirrored into the module loader so import resolution matches runtime behavior.

pub fn set_native_resolution_context( &mut self, resolutions: NativeResolutionSet, root_package_key: Option<String>, )

Install the package-scoped native library resolutions for the current host.

pub fn clear_native_resolution_context(&mut self)

Clear any previously configured native resolution context.

impl BytecodeExecutor

pub fn resume_snapshot( &self, engine: &mut ShapeEngine, vm_snapshot: VmSnapshot, bytecode: BytecodeProgram, ) -> Result<ProgramExecutorResult>

Resume execution from a snapshot

pub fn compile_program_for_inspection( &mut self, engine: &mut ShapeEngine, program: &Program, ) -> Result<BytecodeProgram>

Compile a program with the same pipeline as execution, but do not run it.

The returned bytecode includes tooling artifacts such as expanded_function_defs for comptime inspection.

pub fn recompile_and_resume( &mut self, engine: &mut ShapeEngine, vm_snapshot: VmSnapshot, old_bytecode: BytecodeProgram, program: &Program, ) -> Result<ProgramExecutorResult>

Recompile source and resume from a snapshot.

Compiles the new program to bytecode, finds the snapshot() call position in both old and new bytecodes, adjusts the VM snapshot’s instruction pointer, then resumes execution from the snapshot point using the new bytecode.

impl BytecodeExecutor

pub fn set_module_loader(&mut self, loader: ModuleLoader)

Set a module loader for resolving file-based imports.

When set, imports that don’t match virtual modules will be resolved by the module loader, compiled to bytecode, and merged into the program.

pub fn module_loader_mut(&mut self) -> Option<&mut ModuleLoader>

Get a mutable reference to the module loader (if set).

pub fn resolve_file_imports_with_context( &mut self, program: &Program, context_dir: Option<&Path>, )

Pre-resolve file-based imports from a program using the module loader.

For each import in the program that doesn’t already have a virtual module, the module loader resolves and loads the module graph. Loaded modules are tracked so the unified compile pass can include them.

Call this before compile_program_impl to enable file-based import resolution.

pub fn resolve_file_imports(&mut self, program: &Program)

Backward-compatible wrapper without importer context.

pub fn resolve_file_imports_from_source( &mut self, source: &str, context_dir: Option<&Path>, )

Parse source and pre-resolve file-based imports.

pub fn create_program_from_imports( module_binding_registry: &Arc<RwLock<ModuleBindingRegistry>>, ) -> Result<Program>

Create a Program from imported functions in ModuleBindingRegistry

Trait Implementations

impl Default for BytecodeExecutor

fn default() -> Self

Returns the “default value” for a type.

impl ExpressionEvaluator for BytecodeExecutor

fn eval_statements( &self, stmts: &[Statement], ctx: &mut ExecutionContext, ) -> Result<ValueWord>

Evaluate a slice of statements and return the result.

fn eval_expr( &self, expr: &Expr, ctx: &mut ExecutionContext, ) -> Result<ValueWord>

Evaluate a single expression and return the result.

impl ProgramExecutor for BytecodeExecutor

fn execute_program( &mut self, engine: &mut ShapeEngine, program: &Program, ) -> Result<ProgramExecutorResult>