Struct lox_lang::VM

pub struct VM { /* fields omitted */ }

The Lox virtual machine.

Example

let mut vm = VM::default();
vm.interpret("3 + 3 == 6"); // true

Implementations

impl VM

pub fn add_std_globals(&mut self)

pub fn add_arguments_instance(&mut self)

impl VM

pub fn alloc<T: Any>(&mut self, obj: T) -> Gc<T>

Allocate a garbage-collected value on the heap.

This method is how to obtain a Gc pointer (not exported from this crate and has no public constructor). Values allocated with this method will be owned (and eventually freed) by the VM. If the value lives until the VM goes out of scope, it will be freed in the VM's Drop implementation.

For a usage example, see NativeFun.

impl VM

pub fn buffer_output(&mut self, should_buffer: bool)

Print directly to stdout, or buffer output internally.

Pass true to this method to buffer print output internally. This output can then be accessed through this struct's Read implementation.

Pass false (the default mode) to sink all program output directly to Stdout.

Example

use std::io::Read;

let mut vm = lox_lang::VM::default();
vm.buffer_output(true);

vm.interpret("print nil == true;");

let mut buffer = String::new();
vm.read_to_string(&mut buffer).unwrap();
assert_eq!(buffer, "false\n");

vm.interpret("for (var a = 3; a < 12; a = a + 3) print a;");

buffer.clear();
vm.read_to_string(&mut buffer).unwrap();
assert_eq!(buffer, "3\n6\n9\n");

impl<'source> VM

pub fn interpret<T: AsRef<str> + 'source>(
    &mut self,
    source: T
) -> Result<(), Vec<Error>>

Compile and run Lox code from a source string.

Errors

Errors are returned in a Vec. This is because compilation (not runtime) is able to continue after error(s) are encountered.

pub fn define_global<T: ?Sized + ToString>(&mut self, name: &T, value: Value)

Define a global variable inside the runtime.

Since globals are late bound in Lox, functions that reference the provided name will see the provided value, even if they were declared in the runtime before calling this method.

Example

use std::io::Read;

let mut vm = lox_lang::VM::default();
vm.buffer_output(true);

vm.interpret("fun hello() { print world; }");
vm.define_global("world", "greetings, Earthling.".into());
vm.interpret("hello();");

let mut buffer = String::new();
vm.read_to_string(&mut buffer).unwrap();
assert_eq!(buffer, "greetings, Earthling.\n");

Trait Implementations

impl Default for VM

fn default() -> Self

The VM constructor.

Program output defaults to Stdout. To customize this behavior, see the buffer_output method.

impl Drop for VM

fn drop(&mut self)

Executes the destructor for this type.

impl Read for VM

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

Read all bytes until EOF in this source, placing them into buf.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.