More lexer infrastructure for testing #52

src/mango/io/fortest/fromstr.rs

@@ -29,9 +29,9 @@ impl Reader for StringReader {
     fn matches(&mut self, subpattern: &str) -> ReaderResult {
         REXCACHE.with(|rl| {
             let mut rexlib = rl.borrow_mut();
-            let rex = rexlib.make_or_get(subpattern);
-            println!("{:?}", rex);
+            let regex = rexlib.make_or_get(subpattern);
+            println!("{:?}", regex);
         });
-        ReaderResult::NoMatch() // TODO
+        ReaderResult::EOF() // TODO
     }
 }

src/mango/io/typ.rs

@@ -13,7 +13,7 @@ pub trait Reader {
 
     /// Checks whether the code from the current position matches a regex pattern.
     ///
-    /// This has to eventually return EOF, after which it should not be called again.
+    /// This has to eventually return EOF, and keep returning EOF forever after that.
     fn matches(&mut self, subpattern: &str) -> ReaderResult;
 }
 

src/mango/io/util.rs

@@ -15,12 +15,17 @@ impl RegexCache {
         }
     }
 
-    pub fn make_or_get(&mut self, subpattern: &str) -> Result<&Regex, Error> {
+    pub fn make_or_get(&mut self, subpattern: &str) -> &Regex {
         if !self.cache.contains_key(subpattern) {
-            let regex = Regex::new(&format!("^ *{}", subpattern))?;
-            self.cache.insert(subpattern.to_owned(), regex);
+            match Regex::new(&format!("^ *{}", subpattern)) {
+                Err(err) => panic!(format!("Invalid regular expression while adding to library; this is a bug:\n{:?}", err)),
+                Ok(regex) => {
+                    self.cache.insert(subpattern.to_owned(), regex);
+                }
+            }
+
         }
-        Result::Ok(self.cache.get(subpattern).unwrap())
+        self.cache.get(subpattern).unwrap()
     }
 }
 

src/mango/lexing/code_lexer.rs

@@ -178,20 +178,18 @@ impl Lexer for CodeLexer {
                     return Token(Tokens::Operator(OperatorToken::from_str(&token).unwrap()));
                 }
                 // Grouping symbols
-                if let Match(_) = self.reader.borrow_mut().matches("(") {
+                if let Match(_) = self.reader.borrow_mut().matches(r"\(") {
                     return Token(Tokens::ParenthesisOpen(ParenthesisOpenToken::new()));
                 }
-                if let Match(_) = self.reader.borrow_mut().matches(")") {
+                if let Match(_) = self.reader.borrow_mut().matches(r"\)") {
                     return Token(Tokens::ParenthesisClose(ParenthesisCloseToken::new()));
                 }
 
-                // TODO: specify the unlexable word
                 let unknown_word = self.reader.borrow_mut().matches(" *[^\\s]+");
-                if let Match(word) = unknown_word {
-                    return Token(Tokens::Unlexable(UnlexableToken::new(word)));
-                } else {
-                    // todo: handle better someday
-                    panic!("Do not know how to proceed with parsing");
+                match unknown_word {
+                    Match(word) => return Token(Tokens::Unlexable(UnlexableToken::new(word))),
+                    NoMatch() => panic!("Do not know how to proceed with parsing"),
+                    EOF() => End,
                 }
             }
         }

src/mango/util/codeparts/operator.rs

@@ -30,7 +30,7 @@ impl Symbol {
 
     /// Generate an eager subpattern to match tokens, that can be composed in a regular expression.
     pub fn subpattern() -> &'static str {
-        r"(\+|\-|\*|\/)"
+        r"(\+|\-|\*|/)"
     }
 }