RegisterMap can now handle scopes.

Author: rbartlensky

luacompiler/build.rs

@@ -5,7 +5,8 @@ use lrlex::LexerBuilder;
 use lrpar::CTParserBuilder;
 
 fn main() -> Result<(), Box<std::error::Error>> {
-    let lex_rule_ids_map = CTParserBuilder::<u8>::new().process_file_in_src("lua5_3/lua5_3.y")?;
+    let lex_rule_ids_map =
+        CTParserBuilder::<u8>::new_with_storaget().process_file_in_src("lua5_3/lua5_3.y")?;
     LexerBuilder::new()
         .rule_ids_map(lex_rule_ids_map)
         .process_file_in_src("lua5_3/lua5_3.l")?;

luacompiler/src/lib/errors.rs

@@ -1,17 +1,17 @@
-use lrpar::{Node, ParseError};
+use lrpar::{LexParseError, Node, ParseError};
 use std::io;
 
 type ParseErr = (Option<Node<u8>>, Vec<ParseError<u8>>);
 
 #[derive(Debug)]
 pub enum CliError {
     Io(io::Error),
-    LexError(lrpar::LexParseError<u8>),
+    LexError(Vec<LexParseError<u8>>),
     ParseError(ParseErr),
 }
 
-impl From<lrpar::LexParseError<u8>> for CliError {
-    fn from(err: lrpar::LexParseError<u8>) -> CliError {
+impl From<Vec<LexParseError<u8>>> for CliError {
+    fn from(err: Vec<LexParseError<u8>>) -> CliError {
         CliError::LexError(err)
     }
 }

luacompiler/src/lib/irgen/mod.rs

@@ -77,7 +77,9 @@ impl<'a> LuaToIR<'a> {
     fn compile_variable(&self, node: &Node<u8>) -> &'a str {
         let name = LuaToIR::find_term(node, lua5_3_l::T_NAME);
         match name {
-            Some(Term { lexeme }) => self.pt.get_string(lexeme.start(), lexeme.end()),
+            Some(Term { lexeme }) => self
+                .pt
+                .get_string(lexeme.start(), lexeme.end().unwrap_or(lexeme.start())),
             _ => {
                 panic!("Must have assignments of form: var = expr!");
             }
@@ -105,7 +107,9 @@ impl<'a> LuaToIR<'a> {
                 }
             }
             Term { lexeme } => {
-                let value = self.pt.get_string(lexeme.start(), lexeme.end());
+                let value = self
+                    .pt
+                    .get_string(lexeme.start(), lexeme.end().unwrap_or(lexeme.start()));
                 match lexeme.tok_id() {
                     lua5_3_l::T_NUMERAL => {
                         let reg = self.reg_map.get_new_reg();

luacompiler/src/lib/irgen/register_map.rs

@@ -31,32 +31,58 @@ impl Lifetime {
 }
 
 /// Represents a structure that is used to map Lua variables to registers, and to keep
-/// track of their lifetimes. Each Lua file has its own register map.
+/// track of their lifetimes. Each Lua module has its own register map.
 pub struct RegisterMap<'a> {
     lifetimes: Vec<Lifetime>,
-    reg_map: HashMap<&'a str, usize>,
+    reg_maps: Vec<HashMap<&'a str, usize>>,
 }
 
 impl<'a> RegisterMap<'a> {
     pub fn new() -> RegisterMap<'a> {
         RegisterMap {
             lifetimes: vec![],
-            reg_map: HashMap::new(),
+            // the first map holds the variables of the module
+            reg_maps: vec![HashMap::new()],
         }
     }
 
-    /// Creates and returns a new register, whose lifetime begins from self.current_instr.
+    /// Pushes a new map of registers. All new registers will be allocated in the newly
+    /// created map.
+    pub fn push_scope(&mut self) {
+        self.reg_maps.push(HashMap::new());
+    }
+
+    /// Pops the last map of registers.
+    pub fn pop_scope(&mut self) {
+        self.reg_maps.pop();
+    }
+
+    /// Creates and returns a new register.
     pub fn get_new_reg(&mut self) -> usize {
         let lifetime = Lifetime::new(self.lifetimes.len());
         self.lifetimes.push(lifetime);
         self.lifetimes.len() - 1
     }
 
-    /// Get the register of <name>, or create it if it doesn't exist.
+    /// Creates a mapping between <name> and a newly created register.
+    pub fn create_reg(&mut self, name: &'a str) -> usize {
+        let reg = self.get_new_reg();
+        self.set_reg(name, reg);
+        reg
+    }
+
+    /// Get the register of <name>.
     pub fn get_reg(&mut self, name: &'a str) -> usize {
         let lifetimes = &mut self.lifetimes;
-        *self
-            .reg_map
+        for map in self.reg_maps[1..].iter().rev() {
+            if let Some(&reg) = map.get(name) {
+                return reg;
+            }
+        }
+        // In lua, if a variable is queried, but isn't in scope, a Nil is returned instead
+        // If none of the maps have a definition for <name> that means we have to define
+        // it ourselves in the map of the module (the first map in <reg_maps>).
+        *self.reg_maps[0]
             .entry(name)
             .and_modify(|reg| {
                 let len = lifetimes.len();
@@ -71,7 +97,7 @@ impl<'a> RegisterMap<'a> {
 
     /// Set the register of <name> to <reg>.
     pub fn set_reg(&mut self, name: &'a str, reg: usize) {
-        self.reg_map.insert(name, reg);
+        self.reg_maps.last_mut().unwrap().insert(name, reg);
     }
 
     /// Get the total number of registers that were needed.
@@ -98,17 +124,34 @@ mod tests {
     }
 
     #[test]
-    fn get_reg_correctly_maps_strings_to_registers() {
+    fn correctly_maps_strings_to_registers() {
         let mut rm = RegisterMap::new();
         // create a new register
         assert_eq!(rm.get_new_reg(), 0);
         // create a mapping
+        assert_eq!(rm.create_reg("foo"), 1);
+        assert_eq!(*rm.reg_maps[0].get("foo").unwrap(), 1);
         assert_eq!(rm.get_reg("foo"), 1);
-        assert_eq!(*rm.reg_map.get("foo").unwrap(), 1);
+        assert_eq!(*rm.reg_maps[0].get("foo").unwrap(), 1);
+        assert_eq!(rm.get_reg("bar"), 2);
+        assert_eq!(*rm.reg_maps[0].get("bar").unwrap(), 2);
+        // create a new scope in which we define another foo
+        rm.push_scope();
+        assert_eq!(rm.create_reg("foo"), 3);
+        assert_eq!(*rm.reg_maps[1].get("foo").unwrap(), 3);
+        assert_eq!(rm.get_reg("foo"), 3);
+        assert_eq!(*rm.reg_maps[1].get("foo").unwrap(), 3);
+        assert_eq!(rm.get_reg("bar"), 2);
+        assert_eq!(*rm.reg_maps[0].get("bar").unwrap(), 2);
+        assert!(rm.reg_maps[1].get("bar").is_none());
+        rm.pop_scope();
+        // pop the scope and query foo and bar again to check if they have the same values
         assert_eq!(rm.get_reg("foo"), 1);
-        assert_eq!(*rm.reg_map.get("foo").unwrap(), 1);
+        assert_eq!(*rm.reg_maps[0].get("foo").unwrap(), 1);
+        assert_eq!(rm.get_reg("bar"), 2);
+        assert_eq!(*rm.reg_maps[0].get("bar").unwrap(), 2);
         // test total number of registers created
-        assert_eq!(rm.reg_count(), 2);
+        assert_eq!(rm.reg_count(), 4);
     }
 
     #[test]
@@ -117,12 +160,30 @@ mod tests {
         let reg1 = rm.get_new_reg();
         assert_eq!(rm.lifetimes[reg1].0, 0);
         assert_eq!(rm.lifetimes[reg1].1, 1);
-        let reg2 = rm.get_reg("reg");
+        let reg2 = rm.create_reg("reg");
         assert_eq!(rm.lifetimes[reg2].0, 1);
         assert_eq!(rm.lifetimes[reg2].1, 2);
         rm.get_reg("reg");
         assert_eq!(rm.lifetimes[reg2].0, 1);
         assert_eq!(rm.lifetimes[reg2].1, 3);
-        assert_eq!(rm.reg_count(), 2);
+        rm.push_scope();
+        let reg3 = rm.create_reg("reg3");
+        rm.pop_scope();
+        assert_eq!(rm.lifetimes[reg3].0, 2);
+        assert_eq!(rm.lifetimes[reg3].1, 3);
+        assert_eq!(rm.reg_count(), 3);
+    }
+
+    #[test]
+    fn registers_are_retrieved_in_the_correct_order() {
+        let mut rm = RegisterMap::new();
+        for i in 0..3 {
+            rm.push_scope();
+            rm.create_reg("foo");
+        }
+        for i in 0..3 {
+            assert_eq!(rm.get_reg("foo"), 2 - i);
+            rm.pop_scope();
+        }
     }
 }

luacompiler/src/lib/mod.rs

@@ -47,8 +47,12 @@ impl LuaParseTree {
         {
             let lexerdef = lua5_3_l::lexerdef();
             let mut lexer = lexerdef.lexer(&mut pt.contents);
-            let tree = lua5_3_y::parse(&mut lexer)?;
-            pt.tree = tree;
+            let (tree, errs) = lua5_3_y::parse(&mut lexer);
+            if let Some(tree) = tree {
+                pt.tree = tree;
+            } else {
+                return Err(CliError::from(errs));
+            }
         }
         Ok(pt)
     }
@@ -65,8 +69,12 @@ impl LuaParseTree {
         {
             let lexerdef = lua5_3_l::lexerdef();
             let mut lexer = lexerdef.lexer(&mut pt.contents);
-            let tree = lua5_3_y::parse(&mut lexer)?;
-            pt.tree = tree;
+            let (tree, errs) = lua5_3_y::parse(&mut lexer);
+            if let Some(tree) = tree {
+                pt.tree = tree;
+            } else {
+                return Err(CliError::from(errs));
+            }
         }
         Ok(pt)
     }