Added loop execution to interpreter

src/config/mod.rs

@@ -10,21 +10,7 @@ use toml;
 
 #[derive(Default, Deserialize)]
 pub struct Config {
-    verbosity: Verbosity,
-}
-
-impl Config {
-    pub fn new() -> Config {
-        Config {
-            verbosity: Default::default(),
-        }
-    }
-
-    pub fn set_verbosity(mut self, verbosity: Verbosity) -> Self {
-        self.verbosity = verbosity;
-
-        self
-    }
+    pub verbosity: Verbosity,
 }
 
 pub static CONFIG_FILE_PATH: &'static str = "~/.config/bRainSuck/config.toml";

src/interpreter/ast.rs

@@ -1,4 +1,4 @@
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Token {
     Inc,
     Dec,

src/interpreter/mod.rs

@@ -22,27 +22,55 @@ impl Interpreter {
         }
     }
 
+    fn process_token(&mut self, token: Token) -> Result<(), ProgramError> {
+        match token {
+            Token::Inc => self.data[self.pointer] += 1,
+            Token::Dec => self.data[self.pointer] -= 1,
+            Token::MoveLeft => self.pointer -= 1,
+            Token::MoveRight => self.pointer += 1,
+            Token::Print => {
+                let current_byte = self.data[self.pointer];
+
+                let character = current_byte as char;
+
+                self.io.print(character);
+            }
+            Token::Read => {
+                let character = self.io.read();
+
+                self.data[self.pointer] = character as u8;
+            }
+            Token::Loop(loop_tokens) => {
+                if let Err(err) = self.run_loop(loop_tokens) {
+                    return Err(err);
+                }
+            }
+        };
+
+        Ok(())
+    }
+
     // TODO: see if we need to expose a non-mutable API
     pub fn run(&mut self, tokens: parser::ParseResult) -> Result<(), ProgramError> {
         for token in tokens {
-            match token {
-                Token::Inc => self.data[self.pointer] += 1,
-                Token::Dec => self.data[self.pointer] -= 1,
-                Token::MoveLeft => self.pointer -= 1,
-                Token::MoveRight => self.pointer += 1,
-                Token::Print => {
-                    let current_byte = self.data[self.pointer];
+            if let Err(err) = self.process_token(token) {
+                return Err(err);
+            }
+        }
 
-                    let character = current_byte as char;
+        Ok(())
+    }
 
-                    self.io.print(character);
-                }
-                Token::Read => {
-                    let character = self.io.read();
+    fn run_loop(&mut self, loop_tokens: Vec<Token>) -> Result<(), ProgramError> {
+        loop {
+            if self.data[self.pointer] == 0 {
+                break;
+            }
 
-                    self.data[self.pointer] = character as u8;
+            for token in loop_tokens.clone() {
+                if let Err(err) = self.process_token(token) {
+                    return Err(err);
                 }
-                Token::Loop(loop_tokens) => todo!(),
             }
         }
 

src/log.rs

@@ -0,0 +1,13 @@
+use crate::config::{verbosity::Verbosity, Config};
+
+pub struct Logger {
+    verbosity: Verbosity,
+}
+
+impl Logger {
+    pub fn new_for(config: Config) -> Logger {
+        Logger {
+            verbosity: config.verbosity,
+        }
+    }
+}

src/main.rs

@@ -5,6 +5,7 @@ use clap::Parser;
 mod cli;
 mod config;
 mod interpreter;
+mod log;
 
 fn main() {
     let args = cli::CommandLineArgs::parse();
@@ -16,9 +17,11 @@ fn main() {
         },
     };
 
+    let logger = log::Logger::new_for(config);
+
     let parser = interpreter::parser::Parser::new();
 
-    let tokens = match parser.parse("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.--++->+++++<-->>>>++.".into()) {
+    let tokens = match parser.parse(",.".into()) {
         Ok(tokens) => tokens,
         Err(err) => {
             eprintln!("{}", err);