Move content of instructions (loops and functions) to the Instruction…

… struct instead of the InstructionType struct

Cargo.toml

@@ -1,9 +1,13 @@
 [package]
-name = "brainfuck"
+name = "fuckbrainfuck"
 version = "0.1.0"
 edition = "2021"
 authors = ["Sellig6792 <[email protected]>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[[bin]]
+name = "fbf"
+path = "src/main.rs"
+
 [dependencies]
 rand = "0.8.5"

src/ast/instructions.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub enum InstructionType {
     Increment,
     Decrement,
@@ -11,32 +11,41 @@ pub enum InstructionType {
     Input,
     Output,
 
-    Loop {
-        instructions: Vec<Instruction>,
-    },
+    Loop,
 
-    Function {
-        instructions: Vec<Instruction>,
-    },
+    Function,
     CallFunction,
 
     MoveLeftScope,
     MoveRightScope,
 
     Random,
-
-    #[default]
-    Default,
 }
 
-#[derive(Clone, Default)]
+#[derive(Clone)]
 pub struct Instruction {
     pub instruction: InstructionType,
+    content: Option<Vec<Instruction>>,
 }
 
 impl Instruction {
-    pub fn new(instruction: InstructionType) -> Instruction {
-        Instruction { instruction }
+    pub fn new(instruction: InstructionType, content: Option<Vec<Instruction>>) -> Instruction {
+        Instruction {
+            instruction,
+            content,
+        }
+    }
+    pub fn get_content(&self) -> Vec<Instruction> {
+        match &self.content {
+            Some(content) => content.clone(),
+            None => panic!("Instruction has no content"),
+        }
+    }
+    pub fn get_content_ref(&self) -> &Vec<Instruction> {
+        match &self.content {
+            Some(content) => content,
+            None => panic!("Instruction has no content"),
+        }
     }
 }
 
@@ -52,21 +61,15 @@ impl fmt::Display for Instruction {
             InstructionType::Input => write!(f, "Input"),
             InstructionType::Output => write!(f, "Output"),
 
-            InstructionType::Loop { instructions } => {
-                write!(f, "Loop{:?}", instructions)
-            }
+            InstructionType::Loop => write!(f, "Loop{:?}", self.get_content_ref()),
 
-            InstructionType::Function { instructions } => {
-                write!(f, "Function{:?}", instructions)
-            }
+            InstructionType::Function => write!(f, "Function{:?}", self.get_content_ref()),
             InstructionType::CallFunction => write!(f, "CallFunction"),
 
             InstructionType::MoveLeftScope => write!(f, "MoveLeftScope"),
             InstructionType::MoveRightScope => write!(f, "MoveRightScope"),
 
             InstructionType::Random => write!(f, "Random"),
-
-            InstructionType::Default => write!(f, "Default"),
         }
     }
 }

src/ast/parser.rs

@@ -1,5 +1,4 @@
-use crate::ast::instructions::Instruction;
-use crate::ast::instructions::InstructionType::*;
+use crate::ast::instructions::{Instruction, InstructionType};
 
 pub struct Parser {
     program: String,
@@ -23,7 +22,7 @@ impl Parser {
 
     fn _parse(&self, index: Option<usize>, stop_char: Option<char>) -> (Vec<Instruction>, usize) {
         let mut index = index.unwrap_or(0);
-        let mut instructions = Vec::new();
+        let mut instructions = vec![];
 
         while index < self.program.len() {
             let char = match self.program.chars().nth(index) {
@@ -35,37 +34,33 @@ impl Parser {
             }
 
             match char {
-                '+' => instructions.push(Instruction::new(Increment)),
-                '-' => instructions.push(Instruction::new(Decrement)),
+                '+' => instructions.push(Instruction::new(InstructionType::Increment, None)),
+                '-' => instructions.push(Instruction::new(InstructionType::Decrement, None)),
 
-                '<' => instructions.push(Instruction::new(MoveLeft)),
-                '>' => instructions.push(Instruction::new(MoveRight)),
+                '<' => instructions.push(Instruction::new(InstructionType::MoveLeft, None)),
+                '>' => instructions.push(Instruction::new(InstructionType::MoveRight, None)),
 
-                '.' => instructions.push(Instruction::new(Output)),
-                ',' => instructions.push(Instruction::new(Input)),
+                '.' => instructions.push(Instruction::new(InstructionType::Output, None)),
+                ',' => instructions.push(Instruction::new(InstructionType::Input, None)),
 
                 '[' => {
                     let (loop_instructions, new_index) = self._parse(Some(index + 1), Some(']'));
-                    instructions.push(Instruction::new(Loop {
-                        instructions: loop_instructions,
-                    }));
+                    instructions.push(Instruction::new(InstructionType::Loop, Some(loop_instructions)));
                     index = new_index;
                 }
                 '{' => {
                     let (function_instructions, new_index) =
                         self._parse(Some(index + 1), Some('}'));
-                    instructions.push(Instruction::new(Function {
-                        instructions: function_instructions,
-                    }));
+                    instructions.push(Instruction::new(InstructionType::Function, Some(function_instructions)));
                     index = new_index;
                 }
 
-                '=' => instructions.push(Instruction::new(CallFunction)),
+                '=' => instructions.push(Instruction::new(InstructionType::CallFunction, None)),
 
-                '?' => instructions.push(Instruction::new(Random)),
+                '?' => instructions.push(Instruction::new(InstructionType::Random, None)),
 
-                '´' => instructions.push(Instruction::new(MoveLeftScope)),
-                '`' => instructions.push(Instruction::new(MoveRightScope)),
+                '´' => instructions.push(Instruction::new(InstructionType::MoveLeftScope, None)),
+                '`' => instructions.push(Instruction::new(InstructionType::MoveRightScope, None)),
 
                 ':' => {
                     // The end of the comment is ';'

src/evaluation/evaluator.rs

@@ -26,19 +26,15 @@ impl Evaluator {
 
             memory_pointer: 0,
 
-            input: Vec::new(),
-            output_buffer: Vec::new(),
+            input: vec![],
+            output_buffer: vec![],
         }
     }
 
-    pub fn evaluate(&mut self, loop_: Option<InstructionType>, show_output: Option<bool>) {
-        let instructions = if loop_.is_some() {
-            match loop_.unwrap() {
-                InstructionType::Loop { instructions } => instructions,
-                _ => panic!("Invalid instruction type"),
-            }
-        } else {
-            self.program.clone()
+    pub fn evaluate(&mut self, container_to_execute: Option<Instruction>, show_output: Option<bool>) {
+        let instructions = match container_to_execute {
+            Some(container) => container.get_content(),
+            None => self.program.clone(),
         };
 
         for instruction in instructions.iter() {
@@ -88,43 +84,31 @@ impl Evaluator {
                         .push(self.scopes[self.scope_pointer].memory[self.memory_pointer]);
                 }
 
-                InstructionType::Loop { ref instructions } => {
+                InstructionType::Loop  => {
                     while self.scopes[self.scope_pointer].memory[self.memory_pointer] != 0 {
                         self.evaluate(
-                            Some(InstructionType::Loop {
-                                instructions: instructions.clone(),
-                            }),
-                            Some(false),
-                        );
+                            Some(instruction.clone()),
+                            Some(false)
+                        )
                     }
                 }
-                InstructionType::Function { ref instructions } => {
+                InstructionType::Function => {
                     self.scopes[self.scope_pointer].function_memory[self.memory_pointer] =
-                        Instruction::new(InstructionType::Function {
-                            instructions: instructions.clone(),
-                        });
+                        Instruction::new(
+                            InstructionType::Function,
+                            Some(instruction.get_content())
+                        );
                 }
 
                 InstructionType::CallFunction => {
-                    match self.scopes[self.scope_pointer].function_memory[self.memory_pointer]
-                        .instruction
-                        .clone()
-                    {
-                        InstructionType::Function { ref instructions } => {
-                            self.scopes.push(Scope::new());
-                            self.scope_pointer = self.scopes.len() - 1;
-                            self.evaluate(
-                                Some(InstructionType::Loop {
-                                    instructions: instructions.clone(),
-                                }),
-                                Some(false),
-                            );
-                            self.scopes.pop();
-                            self.scope_pointer -= 1;
-                        }
-                        InstructionType::Default => (),
-                        _ => panic!("Invalid instruction type in function memory"),
-                    }
+                    self.scopes.push(Scope::new());
+                    self.scope_pointer += 1;
+                    self.evaluate(
+                        Some(self.scopes[self.scope_pointer - 1].function_memory[self.memory_pointer].clone()),
+                        Some(false)
+                    );
+                    self.scopes.pop();
+                    self.scope_pointer -= 1;
                 }
 
                 InstructionType::MoveLeftScope => {
@@ -166,8 +150,6 @@ impl Evaluator {
                         }
                     }
                 }
-
-                InstructionType::Default => (),
             }
         }
 

src/evaluation/scope.rs

@@ -1,4 +1,4 @@
-use crate::ast::instructions::Instruction;
+use crate::ast::instructions::{Instruction, InstructionType};
 
 #[derive(Debug)]
 pub struct Scope {
@@ -8,9 +8,9 @@ pub struct Scope {
 
 impl Scope {
     pub fn new() -> Scope {
-        let mut function_memory_vec = Vec::new();
+        let mut function_memory_vec = vec![];
         for _ in 0..30000 {
-            function_memory_vec.push(Instruction::default());
+            function_memory_vec.push(Instruction::new(InstructionType::Function, Some(vec![])));
         }
 
         Scope {