added logging to builder trait and implemented for compiler and

assembler crates.

assembler/src/assembler/assembler.rs

@@ -8,7 +8,7 @@ use std::{
 
 use crate::assembler::{AssembleError, Token, expand_pseudo_ops, lexer, quick_hash};
 use crate::assembler::{Node, Parser, resolve_dependencies};
-use crate::util::logging::Logger;
+// use crate::util::logging::Logger;
 
 // pub fn new_assemble(path: &Path) {
 //     let program = Program::new();
@@ -144,7 +144,8 @@ impl Module {
     }
 
     pub fn build(path: PathBuf, program: ProgramRef) -> Result<Task, AssembleError> {
-        // Spawn a thread that creates the main function and executes the lexer and parser.
+        // Spawn a thread that creates the main function and executes the lexer and
+        // parser.
         let handle = thread::spawn(move || {
             let mut module =
                 Self::new(path.clone(), quick_hash(&path), Vec::new(), program.clone());

assembler/src/assembler/mod.rs

@@ -5,13 +5,16 @@ use std::{
     fmt, fs,
     hash::{DefaultHasher, Hash, Hasher},
     path::{Path, PathBuf},
-    sync::{Arc, Mutex, mpsc},
+    sync::{
+        Arc, Mutex,
+        mpsc::{self, Receiver, Sender},
+    },
     thread,
 };
 
-pub use common::logging::log;
 use common::{
     build::{BuildError, Builder},
+    logging::{LogReceiver, Logger},
     prelude::Instruction,
 };
 
@@ -20,7 +23,7 @@ use common::{
 pub mod macros;
 
 #[allow(clippy::module_inception)]
-pub mod assembler;
+// pub mod assembler;
 pub mod codegen;
 pub mod expand;
 pub mod lexer;
@@ -38,13 +41,13 @@ pub use self::{
     resolver::{create_sections, resolve_dependencies, resolve_symbols},
 };
 
-use crate::util::logging::{Entry, Logger};
-
 pub struct Assembler {
     src_path: PathBuf,
     result_tx: mpsc::Sender<Result<Vec<u8>, AssembleError>>,
     result_rx: Option<mpsc::Receiver<Result<Vec<u8>, AssembleError>>>,
     is_running: bool,
+
+    logs_rx: LogReceiver,
 }
 
 impl From<AssembleError> for BuildError {
@@ -56,6 +59,10 @@ impl From<AssembleError> for BuildError {
 impl Builder for Assembler {
     type Output = Vec<u8>;
 
+    fn logs(&self) -> Vec<String> {
+        self.logs_rx.logs()
+    }
+
     #[must_use]
     fn new(src_path: impl Into<PathBuf>) -> Self {
         let (tx, rx) = mpsc::channel();
@@ -64,6 +71,9 @@ impl Builder for Assembler {
             result_tx: tx,
             result_rx: Some(rx),
             is_running: false,
+
+            // for logging
+            logs_rx: LogReceiver::new(true),
         }
     }
 
@@ -75,9 +85,10 @@ impl Builder for Assembler {
 
         let src = self.src_path.clone();
         let tx = self.result_tx.clone();
+        let logger = self.logs_rx.logger();
 
         thread::spawn(move || {
-            if let Ok(res) = assemble(&src) {
+            if let Ok(res) = assemble(&src, &logger) {
                 let buffer: Vec<u8> = res
                     .iter()
                     .flat_map(|instruction| instruction.encode().to_be_bytes())
@@ -136,7 +147,7 @@ impl Builder for Assembler {
 
 impl Assembler {}
 
-fn assemble(src: &Path) -> Result<Vec<Instruction>, AssembleError> {
+fn assemble(src: &Path, logger: &Logger) -> Result<Vec<Instruction>, AssembleError> {
     let mut modules = HashSet::new();
     let mut program = Program::new();
 
@@ -146,18 +157,18 @@ fn assemble(src: &Path) -> Result<Vec<Instruction>, AssembleError> {
         return Ok(vec![]);
     }
 
-    prepare_dependency(src, &mut modules, &mut program)?;
+    prepare_dependency(src, &mut modules, &mut program, &logger)?;
 
     let mut nodes = program.nodes.clone();
 
     create_sections(&mut nodes)?;
     resolve_symbols(&mut nodes)?;
 
-    log("Generating assembly output...");
+    logger.info("Generating assembly output...");
 
     let instructions = codegen(nodes)?;
 
-    log("Compilation Successful");
+    logger.info("Compilation Successful");
     Ok(instructions)
 }
 
@@ -165,6 +176,7 @@ fn prepare_dependency(
     path: &Path,
     modules: &mut HashSet<u64>,
     program: &mut Program,
+    logger: &Logger,
 ) -> Result<(), AssembleError> {
     let filename = path
         .file_name()
@@ -172,7 +184,7 @@ fn prepare_dependency(
         .expect("Failed to get file name from path");
 
     if let Ok(path) = path.canonicalize() {
-        log(&format!(
+        logger.info(&format!(
             "{:20} {:20} [{}]",
             "Building",
             filename,
@@ -184,13 +196,13 @@ fn prepare_dependency(
         .map_err(|_| AssembleError::InvalidFile(path.to_path_buf()))?;
     let file_hash = quick_hash(path);
 
-    log(&format!("{:20} {:20}", "Tokenising", filename));
+    logger.info(&format!("{:20} {:20}", "Tokenising", filename));
     let tokens = lexer::lexer(src, file_hash)?;
 
-    log(&format!("{:20} {:20}", "Parsing", filename));
+    logger.info(&format!("{:20} {:20}", "Parsing", filename));
     let parsed = Parser::parse_nodes(tokens)?;
 
-    log(&format!("{:20} {:20}", "Resolving Deps", filename));
+    logger.info(&format!("{:20} {:20}", "Resolving Deps", filename));
     // Get the parent directory of the source file to use as the base directory
     let base_dir = path
         .parent()
@@ -200,7 +212,7 @@ fn prepare_dependency(
 
     let deps = Parser::get_dependencies(&nodes, path)?;
 
-    log(&format!("{:20} {:20}", "Expanding Pseudo-ops", filename));
+    logger.info(&format!("{:20} {:20}", "Expanding Pseudo-ops", filename));
 
     // add a section instruction
     nodes.insert(
@@ -215,7 +227,7 @@ fn prepare_dependency(
     program.add_module(nodes);
 
     for dep in deps {
-        log(&format!(
+        logger.info(&format!(
             "{:20} {:20}",
             "Including",
             dep.file_name()
@@ -225,7 +237,7 @@ fn prepare_dependency(
 
         let dep_hash = quick_hash(&dep);
         if modules.insert(dep_hash) {
-            prepare_dependency(dep.as_path(), modules, program)?;
+            prepare_dependency(dep.as_path(), modules, program, logger)?;
         }
     }
 

assembler/src/assembler/resolver.rs

@@ -6,11 +6,8 @@ use std::{
 
 use common::prelude::Register;
 
+use crate::assembler::model::{Module, Node, Opcode, Symbol, Token};
 use crate::assembler::quick_hash;
-use crate::assembler::{
-    log,
-    model::{Module, Node, Opcode, Symbol, Token},
-};
 use crate::{assembler::AssembleError, node};
 
 pub fn resolve_symbols(nodes: &mut [Node]) -> Result<(), AssembleError> {

assembler/src/util/logging.rs

@@ -2,18 +2,18 @@
 #![allow(unused)]
 use std::{fmt, sync::mpsc::Sender};
 
-pub struct Logger {}
+// pub struct Logger {}
 
-impl Logger {
-    pub const fn new() -> Self {
-        Self {}
-    }
+// impl Logger {
+//     pub const fn new() -> Self {
+//         Self {}
+//     }
 
-    pub fn log(&self, message: &str) {
-        _ = self;
-        println!("\x1b[32mINFO:\x1b[0m {message}");
-    }
-}
+//     pub fn log(&self, message: &str) {
+//         _ = self;
+//         println!("\x1b[32mINFO:\x1b[0m {message}");
+//     }
+// }
 
 // #[derive(Debug)]=
 // pub struct Logger {