move lexing/parsing logic into interp

src/interp.rs

@@ -68,6 +68,18 @@ pub struct Error {
     message: String,
 }
 
+impl From<lalrpop_util::ParseError<usize, crate::lexer::Token<'_>, crate::lexer::LexerError>>
+    for Error
+{
+    fn from(
+        err: lalrpop_util::ParseError<usize, crate::lexer::Token<'_>, crate::lexer::LexerError>,
+    ) -> Error {
+        Error {
+            message: format!("{:?}", err),
+        }
+    }
+}
+
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "{}", self.message)
@@ -132,6 +144,7 @@ enum NamedItem {
 pub struct State {
     scope: HashMap<String, NamedItem>,
     rand: rand::rngs::ThreadRng,
+    parser: crate::grammar::StmtsParser,
 }
 
 impl Default for State {
@@ -145,6 +158,7 @@ impl State {
         let mut s = State {
             scope: HashMap::new(),
             rand: rand::thread_rng(),
+            parser: crate::grammar::StmtsParser::new(),
         };
         for builtin in BUILTINS {
             s.scope
@@ -153,6 +167,35 @@ impl State {
         s
     }
 
+    pub fn run(&mut self, src: &str) -> Result<(), Error> {
+        let lexed = crate::lexer::tokens(src);
+        let stmts = self.parser.parse(lexed)?;
+        for stmt in stmts {
+            self.execute(&stmt)?;
+        }
+        Ok(())
+    }
+
+    pub fn run_repl(&mut self, src: &str) -> Result<(), Error> {
+        let lexed = crate::lexer::tokens(src);
+        let stmts = match self.parser.parse(lexed) {
+            Ok(stmts) => stmts,
+            Err(err) => {
+                let with_puts = format!("puts {}", src);
+                let lexed = crate::lexer::tokens(&with_puts);
+                if let Ok(stmts) = self.parser.parse(lexed) {
+                    stmts
+                } else {
+                    return Err(err.into());
+                }
+            }
+        };
+        for stmt in stmts {
+            self.execute(&stmt)?;
+        }
+        Ok(())
+    }
+
     pub fn autocomplete(&self, fragment: &str, at_beginning: bool) -> Vec<String> {
         let mut possibilities = Vec::new();
         for name in self.scope.keys() {

src/main.rs

@@ -1,31 +1,14 @@
-use matzo::grammar::StmtsParser;
 use matzo::interp::State;
-use matzo::lexer::tokens;
 
 fn matzo_version() -> String {
     format!("matzo (git {})", env!("VERGEN_GIT_SHA"))
 }
 
-fn run(src: &str) {
-    let lexed = tokens(src);
-    let stmts = StmtsParser::new().parse(lexed).unwrap();
-    let mut state = State::new();
-    for stmt in stmts {
-        if let Err(err) = state.execute(&stmt) {
-            eprintln!("error: {}", err);
-        }
-    }
-}
-
 fn run_repl() -> Result<(), Box<dyn std::error::Error>> {
     let mut rl = rustyline::Editor::<matzo::repl::Repl>::new();
     let state = std::rc::Rc::new(std::cell::RefCell::new(State::new()));
     rl.set_helper(Some(matzo::repl::Repl::new(state.clone())));
-    let parser = StmtsParser::new();
-    println!(
-        "{}",
-        ansi_term::Colour::Blue.bold().paint(matzo_version()),
-    );
+    println!("{}", ansi_term::Colour::Blue.bold().paint(matzo_version()),);
     println!("{}", ansi_term::Colour::Blue.paint("(work-in-progress)"),);
 
     loop {
@@ -35,35 +18,13 @@ fn run_repl() -> Result<(), Box<dyn std::error::Error>> {
             | Err(rustyline::error::ReadlineError::Interrupted) => return Ok(()),
             err => err?,
         };
-        let lexed = tokens(&line);
 
-        let stmts = match parser.parse(lexed) {
-            Ok(stmts) => stmts,
-            Err(err) => {
-                // for the REPL specifically, let's try adding a
-                // `puts` to see if that works
-                let added_puts = format!("puts {}", line);
-                let lexed = tokens(&added_puts);
-                match parser.parse(lexed) {
-                    Ok(stmts) => stmts,
-                    Err(_) => {
-                        // that didn't fix it, so report the
-                        // _original_ parse error, not the new one
-                        eprintln!("{}", ansi_term::Colour::Red.paint(format!("{:?}", err)),);
-                        continue;
-                    }
-                }
-            }
-        };
-
-        for stmt in stmts {
-            if let Err(err) = state.borrow_mut().execute(&stmt) {
-                eprintln!(
-                    "{} {}",
-                    ansi_term::Colour::Red.bold().paint("error:"),
-                    ansi_term::Colour::Red.paint(format!("{}", err)),
-                );
-            }
+        if let Err(err) = state.borrow_mut().run_repl(&line) {
+            eprintln!(
+                "{} {}",
+                ansi_term::Colour::Red.bold().paint("error:"),
+                ansi_term::Colour::Red.paint(format!("{}", err)),
+            );
         }
     }
 }
@@ -77,6 +38,12 @@ fn main() {
 
     for arg in args {
         let buf = std::fs::read_to_string(arg).unwrap();
-        run(&buf);
+        if let Err(err) = State::new().run(&buf) {
+            eprintln!(
+                "{} {}",
+                ansi_term::Colour::Red.bold().paint("error:"),
+                ansi_term::Colour::Red.paint(format!("{}", err)),
+            );
+        }
     }
 }