Struct VM

pub struct VM { /* private fields */ }

mJS virtual machine

Implementations

impl VM

pub fn create() -> VM

Create new VM

Examples found in repository

examples/basic.rs (line 2)

fn main() {
  let mut vm = mjs_sys::VM::create();

  let val = vm.exec(b"1 / 2\0").unwrap();
  if val.is_number() {
    println!("Result: {}", val.as_double().unwrap());
  }

  let val2 = vm.exec(b"\"foobar\"\0").unwrap();
  if val2.is_string() {
    println!("Result: {}", val2.as_str().unwrap().unwrap());
  }

  // Call JS function from Rust
  let mut js_function = vm
    .exec(
      b"
  function foobar(x) {
  return 42 + x;
  }
  foobar
  \0",
    )
    .unwrap();

  if js_function.is_function() {
    let this = None;
    let x = vm.make_number(10.);
    let args = &[&x];
    let res = js_function.call(this, args).unwrap();
    if res.is_number() {
      println!("Result: {}", res.as_double().unwrap());
    }
  }

  // Call Rust function from JS
  fn rust_function(mjs: *mut mjs_sys::mjs) {
    let mut vm = mjs_sys::VM::from_inner(mjs);
    let x = vm.arg(0).unwrap().as_int().unwrap();
    println!("JS -> Rust: {}", x);
  }

  let js_function = vm.make_foreign(rust_function as _);
  vm.global().set(b"rust", js_function).unwrap();
  vm.exec(b"rust(42)\0").unwrap();

  vm.destroy();
}

pub fn destroy(self)

Destroy VM

Examples found in repository

examples/basic.rs (line 47)

fn main() {
  let mut vm = mjs_sys::VM::create();

  let val = vm.exec(b"1 / 2\0").unwrap();
  if val.is_number() {
    println!("Result: {}", val.as_double().unwrap());
  }

  let val2 = vm.exec(b"\"foobar\"\0").unwrap();
  if val2.is_string() {
    println!("Result: {}", val2.as_str().unwrap().unwrap());
  }

  // Call JS function from Rust
  let mut js_function = vm
    .exec(
      b"
  function foobar(x) {
  return 42 + x;
  }
  foobar
  \0",
    )
    .unwrap();

  if js_function.is_function() {
    let this = None;
    let x = vm.make_number(10.);
    let args = &[&x];
    let res = js_function.call(this, args).unwrap();
    if res.is_number() {
      println!("Result: {}", res.as_double().unwrap());
    }
  }

  // Call Rust function from JS
  fn rust_function(mjs: *mut mjs_sys::mjs) {
    let mut vm = mjs_sys::VM::from_inner(mjs);
    let x = vm.arg(0).unwrap().as_int().unwrap();
    println!("JS -> Rust: {}", x);
  }

  let js_function = vm.make_foreign(rust_function as _);
  vm.global().set(b"rust", js_function).unwrap();
  vm.exec(b"rust(42)\0").unwrap();

  vm.destroy();
}

pub fn from_inner(mjs: *mut mjs) -> VM

Create a VM from an existing instance

Examples found in repository

examples/basic.rs (line 38)

  fn rust_function(mjs: *mut mjs_sys::mjs) {
    let mut vm = mjs_sys::VM::from_inner(mjs);
    let x = vm.arg(0).unwrap().as_int().unwrap();
    println!("JS -> Rust: {}", x);
  }

pub fn exec(&mut self, source: &[u8]) -> Result<Val, JSError<'_>>

Execute code. source should be null terminated.

Examples found in repository

examples/basic.rs (line 4)

fn main() {
  let mut vm = mjs_sys::VM::create();

  let val = vm.exec(b"1 / 2\0").unwrap();
  if val.is_number() {
    println!("Result: {}", val.as_double().unwrap());
  }

  let val2 = vm.exec(b"\"foobar\"\0").unwrap();
  if val2.is_string() {
    println!("Result: {}", val2.as_str().unwrap().unwrap());
  }

  // Call JS function from Rust
  let mut js_function = vm
    .exec(
      b"
  function foobar(x) {
  return 42 + x;
  }
  foobar
  \0",
    )
    .unwrap();

  if js_function.is_function() {
    let this = None;
    let x = vm.make_number(10.);
    let args = &[&x];
    let res = js_function.call(this, args).unwrap();
    if res.is_number() {
      println!("Result: {}", res.as_double().unwrap());
    }
  }

  // Call Rust function from JS
  fn rust_function(mjs: *mut mjs_sys::mjs) {
    let mut vm = mjs_sys::VM::from_inner(mjs);
    let x = vm.arg(0).unwrap().as_int().unwrap();
    println!("JS -> Rust: {}", x);
  }

  let js_function = vm.make_foreign(rust_function as _);
  vm.global().set(b"rust", js_function).unwrap();
  vm.exec(b"rust(42)\0").unwrap();

  vm.destroy();
}

pub fn global(&mut self) -> Val

Return the VM global

Examples found in repository

examples/basic.rs (line 44)

fn main() {
  let mut vm = mjs_sys::VM::create();

  let val = vm.exec(b"1 / 2\0").unwrap();
  if val.is_number() {
    println!("Result: {}", val.as_double().unwrap());
  }

  let val2 = vm.exec(b"\"foobar\"\0").unwrap();
  if val2.is_string() {
    println!("Result: {}", val2.as_str().unwrap().unwrap());
  }

  // Call JS function from Rust
  let mut js_function = vm
    .exec(
      b"
  function foobar(x) {
  return 42 + x;
  }
  foobar
  \0",
    )
    .unwrap();

  if js_function.is_function() {
    let this = None;
    let x = vm.make_number(10.);
    let args = &[&x];
    let res = js_function.call(this, args).unwrap();
    if res.is_number() {
      println!("Result: {}", res.as_double().unwrap());
    }
  }

  // Call Rust function from JS
  fn rust_function(mjs: *mut mjs_sys::mjs) {
    let mut vm = mjs_sys::VM::from_inner(mjs);
    let x = vm.arg(0).unwrap().as_int().unwrap();
    println!("JS -> Rust: {}", x);
  }

  let js_function = vm.make_foreign(rust_function as _);
  vm.global().set(b"rust", js_function).unwrap();
  vm.exec(b"rust(42)\0").unwrap();

  vm.destroy();
}

pub fn this(&mut self) -> Val

Return scope’s this

pub fn nargs(&mut self) -> i32

In a function, return the number of arguments.

pub fn arg(&mut self, i: i32) -> Option<Val>

Return argument i

Examples found in repository

examples/basic.rs (line 39)

  fn rust_function(mjs: *mut mjs_sys::mjs) {
    let mut vm = mjs_sys::VM::from_inner(mjs);
    let x = vm.arg(0).unwrap().as_int().unwrap();
    println!("JS -> Rust: {}", x);
  }

pub fn make_undefined(&mut self) -> Val

Create a JS undefined value

pub fn make_foreign(&mut self, f: *mut c_void) -> Val

Create a JS value that wraps a native pointer

Examples found in repository

examples/basic.rs (line 43)

fn main() {
  let mut vm = mjs_sys::VM::create();

  let val = vm.exec(b"1 / 2\0").unwrap();
  if val.is_number() {
    println!("Result: {}", val.as_double().unwrap());
  }

  let val2 = vm.exec(b"\"foobar\"\0").unwrap();
  if val2.is_string() {
    println!("Result: {}", val2.as_str().unwrap().unwrap());
  }

  // Call JS function from Rust
  let mut js_function = vm
    .exec(
      b"
  function foobar(x) {
  return 42 + x;
  }
  foobar
  \0",
    )
    .unwrap();

  if js_function.is_function() {
    let this = None;
    let x = vm.make_number(10.);
    let args = &[&x];
    let res = js_function.call(this, args).unwrap();
    if res.is_number() {
      println!("Result: {}", res.as_double().unwrap());
    }
  }

  // Call Rust function from JS
  fn rust_function(mjs: *mut mjs_sys::mjs) {
    let mut vm = mjs_sys::VM::from_inner(mjs);
    let x = vm.arg(0).unwrap().as_int().unwrap();
    println!("JS -> Rust: {}", x);
  }

  let js_function = vm.make_foreign(rust_function as _);
  vm.global().set(b"rust", js_function).unwrap();
  vm.exec(b"rust(42)\0").unwrap();

  vm.destroy();
}

pub fn make_number(&mut self, number: f64) -> Val

Create a JS number

Examples found in repository

examples/basic.rs (line 28)

fn main() {
  let mut vm = mjs_sys::VM::create();

  let val = vm.exec(b"1 / 2\0").unwrap();
  if val.is_number() {
    println!("Result: {}", val.as_double().unwrap());
  }

  let val2 = vm.exec(b"\"foobar\"\0").unwrap();
  if val2.is_string() {
    println!("Result: {}", val2.as_str().unwrap().unwrap());
  }

  // Call JS function from Rust
  let mut js_function = vm
    .exec(
      b"
  function foobar(x) {
  return 42 + x;
  }
  foobar
  \0",
    )
    .unwrap();

  if js_function.is_function() {
    let this = None;
    let x = vm.make_number(10.);
    let args = &[&x];
    let res = js_function.call(this, args).unwrap();
    if res.is_number() {
      println!("Result: {}", res.as_double().unwrap());
    }
  }

  // Call Rust function from JS
  fn rust_function(mjs: *mut mjs_sys::mjs) {
    let mut vm = mjs_sys::VM::from_inner(mjs);
    let x = vm.arg(0).unwrap().as_int().unwrap();
    println!("JS -> Rust: {}", x);
  }

  let js_function = vm.make_foreign(rust_function as _);
  vm.global().set(b"rust", js_function).unwrap();
  vm.exec(b"rust(42)\0").unwrap();

  vm.destroy();
}

pub fn make_boolean(&mut self, b: bool) -> Val

Create a JS bool

pub fn make_object(&mut self) -> Val

Create a JS object

pub fn make_string(&mut self, bytes: &'static [u8]) -> Result<Val, JSError<'_>>

Create a JS string. Bytes don’t need to be null terminated. Content of the string is not copied.

pub fn make_string_copy(&mut self, bytes: &[u8]) -> Result<Val, JSError<'_>>

Create a JS string. Bytes don’t need to be null terminated. Content of the string is copied.

Trait Implementations

impl Clone for VM

fn clone(&self) -> VM

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.