about summary refs log tree commit diff
path: root/users/tazjin/rlox/src/bytecode/vm.rs
blob: fd91cd7be6273e38f1649c25dba5974291eb73e5 (plain) (blame)
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
use super::chunk;
use super::errors::*;
use super::opcode::OpCode;
use super::value::Value;

pub struct VM {
    chunk: chunk::Chunk,

    // TODO(tazjin): Accessing array elements constantly is not ideal,
    // lets see if something clever can be done with iterators.
    ip: usize,

    stack: Vec<Value>,
}

impl VM {
    fn push(&mut self, value: Value) {
        self.stack.push(value)
    }

    fn pop(&mut self) -> Value {
        self.stack.pop().expect("fatal error: stack empty!")
    }
}

macro_rules! binary_op {
    ( $vm:ident, $op:tt ) => {{
        let a = $vm.pop();
        let b = $vm.pop();
        $vm.push(a $op b);
    }}
}

impl VM {
    fn run(&mut self) -> LoxResult<()> {
        loop {
            let op = &self.chunk.code[self.ip];

            #[cfg(feature = "disassemble")]
            chunk::disassemble_instruction(&self.chunk, self.ip);

            self.ip += 1;

            match op {
                OpCode::OpReturn => {
                    println!("{:?}", self.pop());
                    return Ok(());
                }

                OpCode::OpConstant(idx) => {
                    let c = *self.chunk.constant(*idx);
                    self.push(c);
                }

                OpCode::OpNegate => {
                    let v = self.pop();
                    self.push(-v)
                }

                OpCode::OpAdd => binary_op!(self, +),
                OpCode::OpSubtract => binary_op!(self, -),
                OpCode::OpMultiply => binary_op!(self, *),
                OpCode::OpDivide => binary_op!(self, /),
            }
        }
    }
}

pub fn interpret(chunk: chunk::Chunk) -> LoxResult<()> {
    let mut vm = VM {
        chunk,
        ip: 0,
        stack: vec![],
    };

    vm.run()
}