Crate lovm2

lovm2 is a library for building your own programming language in the blink of an eye. It offers you easy to use constructs to generate bytecode for its virtual machine.

Features

• Dynamic typing
• Generate bytecode using a High-Level Intermediate Representation
• Define own instructions as Interrupts
• Extend your programs with Rust: lovm2 extend
• Standard library included: lovm2_std
• Python bindings: pylovm2

Examples

Add this line to your Cargo.toml:

lovm2 = "0.4.8"

Projects

• lol - a lisp language
• quasicode - the best language around

Generating Bytecode

use lovm2::create_vm_with_std;
use lovm2::prelude::*;

let mut module = ModuleBuilder::new();

// a module needs a code object called `main`
// if you want to make it runnable
let main_hir = module.entry();

// set the local variable n to 10
main_hir.step(Assign::local(&lv2_var!(n), 10));

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

// 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 = create_vm_with_std();
vm.add_main_module(module).expect("load error");
vm.run().expect("run error");

Modules

code	Runnable bytecode objects
error	Error values for compilation and runtime
extend	lovm2::extend bundles functionality for writing lovm2 extensions using Rust. You can either statically import functions or produce a shared object that can be loaded at runtime.
gen	Tools for generating bytecode
module	Generic protocol for module like objects
prelude	Important structs, enums and constants for using lovm2 as library
util	Helper functionality for solving small tasks
value	Representation and operations for lovm2 values
vm	Runs modules and maintains program state

Macros

lv2_access	Creates an Access expression
lv2_call	Creates a Call expression
lv2_dict	Creates a dict Initialize expression using Expr as items
lv2_list	Creates a list Initialize expression using Expr as items
lv2_var	Creates a Variable from a rust identifier

Structs

Variable

A thin wrapper around an identifier name.

Enums

Instruction

Definition of the bytecode

Functions

create_vm_with_std

Create a new instance with standard functions already imported