sexprs-vm 0.0.5

sexprs is a minimal lisp dialect to evaluate written in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use std::collections::VecDeque;
use std::fmt::Debug;

use sexprs_data_structures::{Symbol, Value};
use sexprs_util::try_result;
use unique_pointer::UniquePointer;

use crate::{
    Context, Result, Sym, SymTable,
    SymbolTable,
};

#[derive(Clone)]
pub struct VirtualMachine<'c> {
    pub symbols: SymbolTable<'c>,
    stack: VecDeque<UniquePointer<Context<'c>>>,
}

impl<'c> Debug for VirtualMachine<'c> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(
            f,
            "VirtualMachine {{
    symbols: {:#?},
    stack_size: {:#?}
}}",
            &self.symbols,
            self.stack.len()
        )
    }
}

impl<'c> VirtualMachine<'c> {
    pub fn new() -> VirtualMachine<'c> {
        let vm = VirtualMachine {
            symbols: SymbolTable::new(),
            stack: VecDeque::new(),
        };
        vm
    }

    pub fn setq(&mut self, symbol: Symbol<'c>, value: Value<'c>) -> Result<Value<'c>> {
        let context = self.push_context();
        let previous = try_result!(self.symbols.set_global(context, &symbol, &Sym::Value(value)));
        self.update_symbols();
        Ok(previous)
    }
    pub fn symbols(&self) -> SymTable<'c> {
        self.symbols.locals.clone()
    }

    pub(crate) fn push_context(&mut self) -> UniquePointer<Context<'c>> {
        let context = UniquePointer::<Context<'c>>::from(Context::new(
            UniquePointer::read_only(self),
            self.symbols.clone(),
        ));
        self.stack.push_front(context.clone());
        context
    }

    pub(crate) fn last_context(&self) -> Option<&UniquePointer<Context<'c>>> {
        self.stack.front()
    }

    pub(crate) fn update_symbols(&mut self) {
        if let Some(context) = self.last_context() {
            self.symbols.extend(context.symbols.clone());
        }
    }

    pub fn eval_string(&mut self, string: &'c str) -> Result<Value<'c>> {
        let value = try_result!(self.push_context().eval_string(string));
        self.update_symbols();
        Ok(value)
    }

    pub fn eval(&mut self, item: Value<'c>) -> Result<Value<'c>> {
        let value = try_result!(self.push_context().eval(item));
        self.update_symbols();
        Ok(value)
    }

    pub fn eval_symbol_function(
        &mut self,
        sym: &Symbol<'c>,
        list: Value<'c>,
    ) -> Result<Value<'c>> {
        let value = try_result!(self
            .push_context()
            .eval_symbol_function(sym, list));
        self.update_symbols();
        Ok(value)
    }
}