Struct Vm 

pub struct Vm {
    pub load_paths: Vec<String>,
    /* private fields */
}

VM structure containing hooks and loaded modules

Fields

load_paths: Vec<String>

List of directories for module lookup.

Implementations

impl Vm

pub fn new() -> Vm

Create a new instance.

pub fn add_load_path(&mut self, path: String)

Add a directory for module lookup.

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

Call a function by name with given arguments.

pub fn context_mut(&mut self) -> &mut Context

Get a mutable reference to the current Context

pub fn add_function<T>( &mut self, key: T, co: Rc<dyn CallProtocol>, ) -> Result<(), Lovm2Error>

where T: Into<Variable>,

Add a new function by name to the virtual machine.

pub fn add_module<T>( &mut self, module: T, namespaced: bool, ) -> Result<(), Lovm2Error>

where T: Into<Module>,

Add the module and all of its slots to scope.

pub fn add_module_by_name( &mut self, name: &str, relative_to: Option<String>, namespaced: bool, ) -> Result<(), Lovm2Error>

Lookup a module name in load_paths and add it to the context. relative_to is expected to be an absolute path to the imported module.

pub fn add_main_module<T>(&mut self, module: T) -> Result<(), Lovm2Error>

where T: Into<Module>,

Add the module and all of its slots to scope.

pub fn run_object(&mut self, co: &dyn CallProtocol) -> Result<Value, Lovm2Error>

A wrapper for run_bytecode that handles pushing and popping stack frames.

pub fn run(&mut self) -> Result<Value, Lovm2Error>

Start the execution at ENTRY_POINT.

pub fn run_bytecode( &mut self, co: &CodeObject, offset: usize, ) -> Result<(), Lovm2Error>

implementation of lovm2 bytecode behavior

Note: This function does not push a stack frame and could therefore mess up local variables if not handled correctly. See Vm::run_object.

pub fn set_import_hook<T>(&mut self, hook: T)

where T: Fn(Option<&str>, &str) -> Result<Option<String>, Lovm2Error> + 'static,

Register a new callback function that is used for patching function names.

pub fn set_load_hook<T>(&mut self, hook: T)

where T: Fn(&LoadRequest) -> Result<Option<Module>, Lovm2Error> + 'static,

Register a new callback function that is used for resolving dependencies at runtime.

pub fn set_interrupt<T>(&mut self, n: u16, func: T) -> Result<(), Lovm2Error>

where T: Fn(&mut Vm) -> Result<(), Lovm2Error> + 'static,

Gegister a new callback function on interrupt n.