break out the parser and compiler into their own libraries

Cargo.lock

@@ -241,6 +241,14 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
+[[package]]
+name = "compiler"
+version = "0.1.0"
+dependencies = [
+ "parser",
+ "quick-error",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -380,6 +388,15 @@ version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
 
+[[package]]
+name = "parser"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "quick-error",
+ "tokenizer",
+]
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
@@ -600,6 +617,8 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "clap",
+ "compiler",
+ "parser",
  "quick-error",
  "rust_decimal",
  "tokenizer",

Cargo.toml

@@ -19,6 +19,8 @@ clap = { version = "^4.5", features = ["derive"] }
 quick-error = { workspace = true }
 rust_decimal = { workspace = true }
 tokenizer = { path = "libs/tokenizer" }
+parser = { path = "libs/parser" }
+compiler = { path = "libs/compiler" }
 
 [dev-dependencies]
 anyhow = { version = "^1.0", features = ["backtrace"] }

libs/compiler/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "compiler"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+quick-error = { workspace = true }
+parser = { path = "../parser" }

libs/compiler/src/lib.rs

@@ -1,6 +1,7 @@
-use crate::parser::sys_call::SysCall;
-use crate::parser::tree_node::*;
-use crate::parser::Parser as ASTParser;
+use parser::Parser as ASTParser;
+use parser::sys_call::SysCall;
+use parser::tree_node::*;
+use quick_error::quick_error;
 use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::io::{BufWriter, Write};
@@ -8,7 +9,7 @@ use std::io::{BufWriter, Write};
 quick_error! {
     #[derive(Debug)]
     pub enum CompileError {
-        ParseError(err: crate::parser::ParseError) {
+        ParseError(err: parser::ParseError) {
             from()
             display("Parse error: {}", err)
         }
@@ -168,7 +169,7 @@ impl<'a> Compiler<'a> {
     }
 
     fn syscall_declaration_expression(&mut self, expr: SysCall) -> Result<(), CompileError> {
-        use crate::parser::sys_call::System;
+        use parser::sys_call::System;
         #[allow(clippy::collapsible_match)]
         match expr {
             SysCall::System(ref sys) => match sys {

libs/parser/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "parser"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+quick-error = { workspace = true }
+tokenizer = { path = "../tokenizer" }
+
+
+[dev-dependencies]
+anyhow = { version = "1" }

libs/parser/src/lib.rs

@@ -1,15 +1,23 @@
 pub mod sys_call;
 pub mod tree_node;
 
-use crate::boxed;
+use quick_error::quick_error;
 use std::io::SeekFrom;
 use sys_call::SysCall;
 use tokenizer::{
-    token::{Keyword, Symbol, Token, TokenType},
     Tokenizer, TokenizerBuffer, TokenizerError,
+    token::{Keyword, Symbol, Token, TokenType},
 };
 use tree_node::*;
 
+#[macro_export]
+/// A macro to create a boxed value.
+macro_rules! boxed {
+    ($e:expr) => {
+        Box::new($e)
+    };
+}
+
 quick_error! {
     #[derive(Debug)]
     pub enum ParseError {
@@ -164,7 +172,7 @@ impl Parser {
             TokenType::Keyword(e)
                 if matches_keyword!(e, Keyword::Enum, Keyword::If, Keyword::Else) =>
             {
-                return Err(ParseError::UnsupportedKeyword(current_token.clone()))
+                return Err(ParseError::UnsupportedKeyword(current_token.clone()));
             }
 
             // match declarations with a `let` keyword

src/main.rs

@@ -1,9 +1,6 @@
 #[macro_use]
 extern crate quick_error;
 
-mod compiler;
-mod parser;
-
 use clap::Parser;
 use compiler::Compiler;
 use parser::Parser as ASTParser;
@@ -14,14 +11,6 @@ use std::{
 };
 use tokenizer::{Tokenizer, TokenizerError};
 
-#[macro_export]
-/// A macro to create a boxed value.
-macro_rules! boxed {
-    ($e:expr) => {
-        Box::new($e)
-    };
-}
-
 quick_error! {
     #[derive(Debug)]
     enum StationlangError {
@@ -78,8 +67,8 @@ fn run_logic() -> Result<(), StationlangError> {
     let parser = ASTParser::new(tokenizer);
 
     let mut writer: BufWriter<Box<dyn Write>> = match args.output_file {
-        Some(output_file) => BufWriter::new(boxed!(File::create(output_file)?)),
-        None => BufWriter::new(boxed!(std::io::stdout())),
+        Some(output_file) => BufWriter::new(Box::new(File::create(output_file)?)),
+        None => BufWriter::new(Box::new(std::io::stdout())),
     };
 
     let compiler = Compiler::new(parser, &mut writer);