Improved interpreter

Author: Naapperas

src/cli.rs

@@ -5,9 +5,12 @@ use clap::Parser;
 #[command(version, about, long_about = None)]
 pub struct CommandLineArgs {
     /// The path of the configuration file.
-    #[arg(short, long, default_value_t = crate::config::CONFIG_FILE_PATH.to_string())]
+    #[arg(short('c'), long("config"), default_value_t = crate::config::CONFIG_FILE_PATH.to_string())]
     pub config: String,
 
     /// The path of the source file to interpret.
     pub input: String,
+
+    #[arg(short('p'), long("print-program"))]
+    pub print_program: Option<bool>,
 }

src/interpreter/ast.rs

@@ -28,21 +28,21 @@ pub enum Token {
 impl fmt::Display for Token {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Inc => write!(f, "Inc"),
-            Self::Dec => write!(f, "Dec"),
-            Self::MoveRight => write!(f, "MoveRght"),
-            Self::MoveLeft => write!(f, "MoveLeft"),
+            Self::Inc => write!(f, "+"),
+            Self::Dec => write!(f, "-"),
+            Self::MoveRight => write!(f, ">"),
+            Self::MoveLeft => write!(f, "<"),
             Self::Loop(vec) => {
-                write!(f, "Loop[")?;
+                write!(f, "[")?;
 
                 for ele in vec {
-                    write!(f, "{},", ele)?;
+                    write!(f, "{}", ele)?;
                 }
 
                 return write!(f, "]");
             }
-            Self::Print => write!(f, "Print"),
-            Self::Read => write!(f, "Read"),
+            Self::Print => write!(f, "."),
+            Self::Read => write!(f, ","),
         }
     }
 }

src/interpreter/mod.rs

@@ -15,15 +15,21 @@ pub enum ProgramError {
     IOError,
 
     /// Error when performing illegal operation
-    IllegalOperation 
+    IllegalOperation { instruction: Token, pointer: usize },
 }
 
 impl fmt::Display for ProgramError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             ProgramError::OutOfBounds => write!(f, "Attempted to move pointer past end of buffer"),
             ProgramError::IOError => write!(f, "Error when attempting to perform IO operation"),
-            ProgramError::IllegalOperation => write!(f, "Operation is illegal")
+            ProgramError::IllegalOperation {
+                instruction,
+                pointer,
+            } => write!(
+                f,
+                "Operation is illegal: {instruction} at pointer address {pointer}"
+            ),
         }
     }
 }
@@ -34,18 +40,18 @@ const BUFFER_SIZE: usize = 30000;
 /// Buffer used internally by the interpreter.
 ///
 /// This struct exists for the sole purpose of exploiting **interior mutability**, allowing [Interpreter] objects to expose an immutable API.
-struct ArrayBuffer {
+struct Tape {
     /// The data held in the buffer.
     data: [u8; BUFFER_SIZE],
 
     /// A pointer to the *current location* in the buffer.
     pointer: usize,
 }
 
-impl ArrayBuffer {
+impl Tape {
     /// Creates a new empty [ArrayBuffer] with all elements set to 0 which points to the byte at position 0.
     fn new() -> Self {
-        ArrayBuffer {
+        Tape {
             data: [0; BUFFER_SIZE],
             pointer: 0,
         }
@@ -68,12 +74,14 @@ impl ArrayBuffer {
 
     /// Increments by 1 the value currently pointed at in the buffer
     fn inc(&mut self) {
-        self.data[self.pointer] += 1;
+        self.data[self.pointer] = self.data[self.pointer].wrapping_add(1);
+        // self.data[self.pointer] += 1;
     }
 
     /// Decrements by 1 the value currently pointed at in the buffer
     fn dec(&mut self) {
-        self.data[self.pointer] -= 1;
+        self.data[self.pointer] = self.data[self.pointer].wrapping_sub(1);
+        // self.data[self.pointer] -= 1;
     }
 
     /// Moves the pointer one position to the left.
@@ -92,7 +100,7 @@ pub struct Interpreter {
     /// The data used by the interpreter.
     ///
     /// This is stored behind a [RefCell] so we can expose an immutable API.
-    data: RefCell<ArrayBuffer>,
+    tape: RefCell<Tape>,
 
     /// Object that abstracts I/O operations away from interpreter objects.
     io: IO,
@@ -102,7 +110,7 @@ impl Interpreter {
     /// Creates a new [Interpreter] object with a empty [buffer](ArrayBuffer).
     pub fn new() -> Self {
         Interpreter {
-            data: RefCell::new(ArrayBuffer::new()),
+            tape: RefCell::new(Tape::new()),
             io: IO::new(),
         }
     }
@@ -111,39 +119,35 @@ impl Interpreter {
     fn process_token(&self, token: Token) -> Result<(), ProgramError> {
         match token {
             Token::Inc => {
-                self.data.borrow_mut().inc();
+                self.tape.borrow_mut().inc();
             }
             Token::Dec => {
-                if self.data.borrow().get() == 0 {
-                    return Err(ProgramError::IllegalOperation);
-                }
-                
-                self.data.borrow_mut().dec();
+                self.tape.borrow_mut().dec();
             }
             Token::MoveLeft => {
-                if self.data.borrow().pointer() == 0 {
+                if self.tape.borrow().pointer() == 0 {
                     return Err(ProgramError::OutOfBounds);
                 }
 
-                self.data.borrow_mut().pointer_left();
+                self.tape.borrow_mut().pointer_left();
             }
             Token::MoveRight => {
-                if self.data.borrow().pointer() == BUFFER_SIZE - 1 {
+                if self.tape.borrow().pointer() == BUFFER_SIZE - 1 {
                     return Err(ProgramError::OutOfBounds);
                 }
 
-                self.data.borrow_mut().pointer_right();
+                self.tape.borrow_mut().pointer_right();
             }
             Token::Print => {
-                let current_byte = self.data.borrow().get();
+                let current_byte = self.tape.borrow().get();
 
                 let character = current_byte as char;
 
                 self.io.print(character);
             }
             Token::Read => match self.io.read() {
                 None => return Err(ProgramError::IOError),
-                Some(character) => self.data.borrow_mut().set(character as u8),
+                Some(character) => self.tape.borrow_mut().set(character as u8),
             },
             Token::Loop(loop_tokens) => self.run_loop(loop_tokens)?,
         };
@@ -163,7 +167,8 @@ impl Interpreter {
     /// Specialized function used to run loops.
     fn run_loop(&self, loop_tokens: Vec<Token>) -> Result<(), ProgramError> {
         loop {
-            if self.data.borrow().get() == 0 {
+            // if 0 at the beginning of loop, skip it
+            if self.tape.borrow().get() == 0 {
                 break;
             }
 

src/log.rs

@@ -37,9 +37,4 @@ impl<'a> Logger<'a> {
     _log!(high, VerbosityLevel::High);
 
     _log!(medium, VerbosityLevel::High | VerbosityLevel::Medium);
-
-    _log!(
-        low,
-        VerbosityLevel::High | VerbosityLevel::Medium | VerbosityLevel::Low
-    );
 }

src/main.rs

@@ -34,13 +34,23 @@ fn main() {
         }
     };
 
-    logger.medium("Running Brainfuck program");
+    let print_program = args.print_program.unwrap_or(false);
 
-    let interpreter = interpreter::Interpreter::new();
+    if print_program {
+        let mut string = String::new();
+        for i in tokens {
+            string = format!("{}{}", string, i);
+        }
+        print!("{}", string)
+    } else {
+        logger.medium("Running Brainfuck program");
+
+        let interpreter = interpreter::Interpreter::new();
 
-    if let Err(err) = interpreter.run(tokens) {
-        logger.high(format!("Error while running Brainfuck code: {}", err));
+        if let Err(err) = interpreter.run(tokens) {
+            logger.high(format!("Error while running Brainfuck code: {}", err));
 
-        exit(3);
+            exit(3);
+        }
     }
 }