Crate lovm2

lovm2 is a lightweight virtual machine with a focus on simplicity and extendability.

Features

• dynamic typing
• generate bytecode using highlevel intermediate representation
• call into shared objects: lovm2_extend
• python bindings: pylovm2
• define own callbacks for interrupts

Example

use lovm2::prelude::*;
use lovm2::vm::Vm;

fn main() {
    let mut main_hir = HIR::new();

    // set the local variable n to 10
    main_hir.push(Assign::local(var!(n), 10));

    // `print` is a builtin function. the `var!` macro
    // ensures that the given identifier is not confused
    // with a string.
    main_hir.push(Call::new("print").arg(var!(n)).arg("Hello World"));
    // ... this is equivalent to the developer-friendly version:
    main_hir.push(call!(print, n, "Hello World"));

    let mut module = ModuleBuilder::new();

    // a module needs a code object called `main`
    // if you want to make it runnable
    module.add("main").hir(main_hir);

    // consumes the `ModuleBuilder` and transforms
    // it into a `Module`
    let module = module.build().unwrap();
    println!("{:#?}", module);

    // load the module and run it
    let mut vm = Vm::new();
    vm.load_and_import_all(module).expect("load error");
    vm.run().expect("run error");
}

Re-exports

pub use self::hir::prelude;

Modules

bytecode	definition of the bytecode
code	runnable bytecode objects
context	vm state
frame
hir	highlevel intermediate representation
module	collections of runnable objects
util
value
var
vm

Macros

access
call
co_dict
co_list
define_code
var

Attribute Macros

lovm2_builtin

used for generating wrappers of statically linked functions to be called from lovm2