added opcode, compiler, vm ,repl support for let statements with global assignments

Author: nishant-sachdeva

src/compiler/compiler.rs

@@ -1,11 +1,14 @@
 use crate::{
-    interpreter::evaluate::object_system::*,
-    virtual_machine::bytecode::{
-        OpCode,
-        make_bytecode,
-        get_raw_instruction,
-        Instruction,
-        opcode_lookup,
+    interpreter::{evaluate::object_system::*},
+    virtual_machine::{
+        bytecode::{
+            OpCode,
+            make_bytecode,
+            get_raw_instruction,
+            Instruction,
+            opcode_lookup,
+        },
+        symbol_table::SymbolTable,
     },
     interpreter::ast,
 };
@@ -28,6 +31,7 @@ pub struct Compiler {
     pub raw_assembly: RawAssembly,
     pub last_instruction: EmittedInstruction,
     pub previous_instruction: EmittedInstruction,
+    pub symbol_table: SymbolTable,
 }
 
 impl Compiler {
@@ -42,6 +46,7 @@ impl Compiler {
                 opcode: None,
                 position: 0,
             },
+            symbol_table: SymbolTable::new(),
         }
     }
 
@@ -89,6 +94,12 @@ impl Compiler {
                     Ok(_) => (),
                     Err(e) => return Err(e)
                 };
+
+                let symbol = match self.symbol_table.define(let_statement.name.value.clone()) {
+                    Ok(symbol) => symbol,
+                    Err(e) => return Err(e),
+                };
+                let _ = self.emit(OpCode::OpSetGlobal, vec![symbol.index as usize]);
             }
             _ => return Err(format!("Statement type not supported: {:?}", statement)),
         }
@@ -98,6 +109,17 @@ impl Compiler {
 
     fn compile_expression(&mut self, expression: &ast::Expression) -> Result<(), String> {
         match expression {
+            ast::Expression::Identifier(identifier) => {
+                let symbol = match self.symbol_table.resolve(identifier.value.clone()) {
+                    Ok(symbol) => symbol,
+                    Err(e) => return Err(e),
+                };
+
+                let _ = match self.emit(OpCode::OpGetGlobal, vec![symbol.index as usize]) {
+                    Ok(_) => (),
+                    Err(e) => return Err(e),
+                };
+            }
             ast::Expression::IfExpression(if_expr) => {
                 let _ = match self.compile_expression(&if_expr.condition) {
                     Ok(_) => (),

src/lib.rs

@@ -13,7 +13,7 @@ use interpreter::{
     lexer,
 };
 
-use compiler::compiler::Compiler;
+use compiler::compiler::{Compiler};
 use virtual_machine::virtual_machine::VirtualMachine;
 
 use std::fs;
@@ -45,7 +45,9 @@ fn run_code(input: &str, env: Option<&mut environment::Environment>) -> object_s
     result
 }
 
-pub fn compile_and_run(input: &str) -> object_system::Object {
+pub fn compile_and_run(
+    input: &str,
+) -> object_system::Object {
     let lexer = lexer::Lexer::new(input.to_string());
     let mut parser = parser::Parser::new(lexer);
 
@@ -109,21 +111,23 @@ pub fn compile_and_run(input: &str) -> object_system::Object {
 }
 
 pub fn start_compiler_repl() {
+    let mut input = String::new();
     loop {
         // read input
         println!(">>");
-        let mut input = String::new();
-        match std::io::stdin().read_line(&mut input) {
+        let mut command = String::new();
+        match std::io::stdin().read_line(&mut command) {
             Ok(_) => {},
-            Err(e) => println!("Error reading input: {}", e),
+            Err(e) => println!("Error reading command: {}", e),
         }
 
-        // if input is "quit", break
-        if input.trim() == "quit" {
+        // if command is "quit", break
+        if command.trim() == "quit" {
             break;
         }
 
-        // run code
+        input = input + &command;
+
         let result = compile_and_run(&input);
 
         // print result

src/virtual_machine.rs

@@ -1,2 +1,3 @@
 pub mod bytecode;
 pub mod virtual_machine;
+pub mod symbol_table;

src/virtual_machine/bytecode.rs

@@ -193,6 +193,8 @@ pub fn opcode_lookup(opcode: usize) -> Result<OpCode, String> {
         14 => Ok(OpCode::OpJumpNotTruthy),
         15 => Ok(OpCode::OpJump),
         16 => Ok(OpCode::OpNull),
+        17 => Ok(OpCode::OpSetGlobal),
+        18 => Ok(OpCode::OpGetGlobal),
         _ => Err(format!("Opcode {} not found", opcode)),
     }
 }

src/virtual_machine/symbol_table.rs

@@ -0,0 +1,91 @@
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+
+pub type SymbolScope = String;
+
+lazy_static! {
+    static ref GLOBAL_SCOPE: SymbolScope = String::from("GLOBAL");
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Symbol {
+    pub name: String,
+    pub scope: SymbolScope,
+    pub index: i32
+}
+
+#[derive(Debug, Clone)]
+pub struct SymbolTable {
+    pub store: HashMap<String, Symbol>,
+    pub number_of_definitions: i32
+}
+
+impl SymbolTable {
+    pub fn new() -> Self {
+        SymbolTable {
+            store: HashMap::new(),
+            number_of_definitions: 0
+        }
+    }
+
+    pub fn define(&mut self, symbol_name: String) -> Result<Symbol, String> {
+        let symbol = Symbol {
+            name: symbol_name.clone(),
+            scope: GLOBAL_SCOPE.clone(),
+            index: self.number_of_definitions
+        };
+
+        self.store.insert(symbol_name, symbol.clone());
+        self.number_of_definitions += 1;
+        
+        return Ok(symbol)
+    }
+
+    pub fn resolve(&mut self, symbol_name: String) -> Result<Symbol, String> {
+        match self.store.get(&symbol_name) {
+            Some(symbol) => Ok(symbol.clone()),
+            None => Err(format!("Symbol {} not found", symbol_name))
+        }
+    }
+}
+
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_define_symbols() {
+        let expected = HashMap::from(
+            [
+                ("a" , Symbol{name: "a".to_string(), scope: GLOBAL_SCOPE.clone(), index: 0}),
+                ("b" , Symbol{name: "b".to_string(), scope: GLOBAL_SCOPE.clone(), index: 1}),
+            ]
+        );
+
+        let mut global = SymbolTable::new();
+
+        let a = global.define("a".to_string()).unwrap();
+
+        assert!(a == expected["a"]);
+
+        let b = global.define("b".to_string()).unwrap();
+
+        assert!(b == expected["b"]);
+    }
+
+    #[test]
+    fn test_resolve_symbol() {
+        let mut global = SymbolTable::new();
+        global.define("a".to_string()).unwrap();
+        global.define("b".to_string()).unwrap();
+
+        let expected = vec![
+            Symbol{name: "a".to_string(), scope: GLOBAL_SCOPE.clone(), index: 0},
+            Symbol{name: "b".to_string(), scope: GLOBAL_SCOPE.clone(), index: 1},
+        ];
+
+        for sym in expected {
+            let result = global.resolve(sym.name.clone()).unwrap();
+            assert!(result == sym);
+        }
+    }
+}

src/virtual_machine/virtual_machine.rs

@@ -7,6 +7,7 @@ use crate::virtual_machine::bytecode::{
 };
 
 pub const STACK_SIZE: usize = 2048;
+pub const GLOBALS_SIZE: usize = 65536;
 
 pub struct VmStack {
     pub stack: Vec<Object>,
@@ -59,15 +60,31 @@ impl VmStack {
     }
 }
 
+pub struct VmGlobals {
+    pub store: Vec<Object>,
+    pub number_of_definitions: usize,
+}
+
+impl VmGlobals {
+    pub fn new() -> Self {
+        VmGlobals {
+            store: vec![object_system::Object::Null; GLOBALS_SIZE],
+            number_of_definitions: 0,
+        }
+    }
+}
+
 pub struct VirtualMachine {
     pub stack: VmStack,
+    pub globals: VmGlobals,
     pub assembly: RawAssembly,
 }
 
 impl VirtualMachine {
     pub fn new(assembly: RawAssembly) -> Self {
         VirtualMachine {
             stack: VmStack::new(),
+            globals: VmGlobals::new(),
             assembly,
         }
     }
@@ -89,6 +106,27 @@ impl VirtualMachine {
             instruction_pointer += 2;
 
             match opcode {
+                OpCode::OpSetGlobal => {
+                    let global_index = self.assembly.instructions[instruction_pointer..instruction_pointer+4].parse::<usize>().unwrap();
+                    instruction_pointer += 4;
+
+                    self.globals.store[global_index] = match self.stack.stack_pop() {
+                        Ok(object) => object,
+                        Err(e) => return Err(e),
+                    };
+                    self.globals.number_of_definitions += 1;
+                }
+                OpCode::OpGetGlobal => {
+                    let global_index = self.assembly.instructions[instruction_pointer..instruction_pointer+4].parse::<usize>().unwrap();
+                    instruction_pointer += 4;
+
+                    match self.stack.push_constant(
+                        self.globals.store[global_index].clone()
+                    ) {
+                        Ok(_) => (),
+                        Err(e) => return Err(e),
+                    }
+                }
                 OpCode::OpConstant => {
                     let const_index = self.assembly.instructions[instruction_pointer..instruction_pointer+4].parse::<usize>().unwrap();
                     instruction_pointer += 4;
@@ -182,7 +220,6 @@ impl VirtualMachine {
                         Err(e) => return Err(e),
                     }
                 },
-                _ => return Err(format!("Opcode not supported: {:?}", opcode)),         
             }
         }
 
@@ -842,4 +879,29 @@ mod tests {
         ];
         run_vm_tests(inputs);
     }
+
+    #[test]
+    fn test_global_let_statements() {
+        let inputs = vec![
+            VirtualMachineTest {
+                input: String::from("let one = 1; one;"),
+                expected_stack: vec![
+                    Object::Integer(Integer { value: 1 }),
+                ],
+            },
+            VirtualMachineTest {
+                input: String::from("let one = 1; let two = 2; one + two;"),
+                expected_stack: vec![
+                    Object::Integer(Integer { value: 3 }),
+                ],
+            },
+            VirtualMachineTest {
+                input: String::from("let one = 1; let two = one + one; one + two;"),
+                expected_stack: vec![
+                    Object::Integer(Integer { value: 3 }),
+                ],
+            }
+        ];
+        run_vm_tests(inputs);
+    }
 }