move REPL and filerunner in to piper crate, and implement --use-vm flag

Cargo.toml

@@ -3,9 +3,7 @@ resolver = "2"
 
 members = [
     "crates/interpreter",
-    "crates/repl",
     "crates/piper",
-    "crates/filerunner",
     "crates/piperfmt",
     "crates/son_of_anton",
 ]

crates/piper/Cargo.toml

@@ -4,8 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-repl = { path = "../repl/" }
-filerunner = { path = "../filerunner/" }
+interpreter = { path = "../interpreter" }
 clap = { version = "4.5.11", features = ["derive"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }

crates/piper/src/args.rs

@@ -5,6 +5,9 @@ use clap::{Parser, Subcommand};
 pub struct PiperArgs {
     #[command(subcommand)]
     pub command: PiperCommands,
+
+    #[arg(long, global = true)]
+    pub use_vm: bool,
 }
 
 #[derive(Subcommand)]

crates/piper/src/filerunner.rs

@@ -0,0 +1,48 @@
+use std::fs;
+
+use interpreter::{
+    eval::{self, objects::Environment, EvaledProgram},
+    parser::{ParsedProgram, Parser},
+};
+
+pub fn execute_file(filename: &str) -> Result<(), std::io::Error> {
+    let file_content = fs::read_to_string(filename)?;
+    let execution_scope = &mut Environment::new_env_reference();
+    let evaluated_output = eval::eval(&file_content, execution_scope);
+    handle_output(evaluated_output);
+
+    Ok(())
+}
+
+pub fn parse_file(filename: &str) -> Result<(), std::io::Error> {
+    let file_content = fs::read_to_string(filename)?;
+    let mut parser = Parser::new(&file_content);
+
+    let parsed_program = parser.parse_program();
+    match parsed_program {
+        ParsedProgram::ValidProgram(_) => println!("Program contained no errors"),
+        ParsedProgram::InvalidProgram(parse_errors) => {
+            eprintln!("Found parse errors:");
+            parse_errors.into_iter().for_each(|error| {
+                eprintln!("{error}");
+            });
+        }
+    }
+
+    Ok(())
+}
+
+fn handle_output(evaluated_output: EvaledProgram) {
+    match evaluated_output {
+        EvaledProgram::Valid(object) => println!("{object}"),
+        EvaledProgram::ParseError(parse_errors) => {
+            eprintln!("Found parse errors:");
+            parse_errors.into_iter().for_each(|error| {
+                eprintln!("{error}");
+            });
+        }
+        EvaledProgram::EvalError(runtime_error) => {
+            eprintln!("Runtime error: {runtime_error}")
+        }
+    }
+}

crates/piper/src/lib.rs

@@ -2,7 +2,9 @@ use args::{PiperArgs, PiperCommands};
 use clap::Parser;
 use tracing_subscriber::FmtSubscriber;
 
-mod args;
+pub mod args;
+mod filerunner;
+mod repl;
 
 pub fn setup_logging() {
     let subscriber = FmtSubscriber::builder()
@@ -14,7 +16,7 @@ pub fn setup_logging() {
 pub fn execute_piper() -> Result<(), std::io::Error> {
     let cli = PiperArgs::parse();
     match &cli.command {
-        PiperCommands::Repl => repl::execute_repl()?,
+        PiperCommands::Repl => repl::execute_repl(&cli)?,
         PiperCommands::Run { filename } => filerunner::execute_file(filename)?,
         PiperCommands::Check { filename } => filerunner::parse_file(filename)?,
     }

crates/piper/src/repl.rs

@@ -0,0 +1,70 @@
+use std::io::{stdin, stdout, Write};
+
+use interpreter::{
+    compiler::Compiler,
+    eval::{self, objects::Environment, EvaledProgram},
+    parser::{ParsedProgram, Parser},
+    vm::VirtualMachine,
+};
+
+use crate::args::PiperArgs;
+
+pub fn execute_repl(args: &PiperArgs) -> Result<(), std::io::Error> {
+    println!("Welcome to piperscript, try and write some code:");
+    let repl_scope = &mut Environment::new_env_reference();
+
+    loop {
+        let mut buffer = String::new();
+
+        print!("> ");
+        stdout().flush()?;
+
+        match stdin().read_line(&mut buffer) {
+            Ok(_) => {
+                let input = buffer.trim_end();
+
+                if args.use_vm {
+                    let mut parser = Parser::new(input);
+                    match parser.parse_program() {
+                        ParsedProgram::ValidProgram(ast) => {
+                            let mut compiler: Compiler = Compiler::default();
+                            compiler.compile(ast);
+                            let bytecode = compiler.bytecode();
+
+                            let mut vm = VirtualMachine::new(bytecode);
+                            vm.run().unwrap();
+
+                            let stack_elem = vm.stack_top();
+                            println!("{stack_elem}");
+                        }
+                        ParsedProgram::InvalidProgram(errors) => {
+                            eprintln!("Found parse errors:");
+                            errors.into_iter().for_each(|error| {
+                                eprintln!("{error}");
+                            });
+                        }
+                    }
+                } else {
+                    let evaluated_output = eval::eval(input, repl_scope);
+                    handle_output(evaluated_output);
+                }
+            }
+            Err(_) => panic!(),
+        }
+    }
+}
+
+fn handle_output(evaluated_output: EvaledProgram) {
+    match evaluated_output {
+        EvaledProgram::Valid(object) => println!("{object}"),
+        EvaledProgram::ParseError(parse_errors) => {
+            eprintln!("Found parse errors:");
+            parse_errors.into_iter().for_each(|error| {
+                eprintln!("{error}");
+            });
+        }
+        EvaledProgram::EvalError(runtime_error) => {
+            eprintln!("Runtime error: {runtime_error}")
+        }
+    }
+}