works

rust2/src/main.rs

@@ -1,8 +1,29 @@
-#![feature(allocator_api)]
+#![feature(allocator_api, let_else)]
 #![warn(rust_2018_idioms)]
 
+use bumpalo::Bump;
+use std::{env, fs, process};
+
+mod naive_interpreter;
 mod parse;
 
 fn main() {
-    println!("Hello, world!");
+    let Some(path) = env::args().nth(1) else {
+        eprintln!("error: Provide a path as input.");
+        process::exit(1);
+    };
+
+    let file = fs::read_to_string(path).unwrap_or_else(|err| {
+        eprintln!("error: Failed to read file: {err}");
+        process::exit(1);
+    });
+
+    let ast_alloc = Bump::new();
+
+    let parsed = parse::parse(&ast_alloc, file.bytes()).unwrap_or_else(|_| {
+        eprintln!("Failed to parse brainfuck code.");
+        process::exit(1);
+    });
+
+    naive_interpreter::run(&parsed);
 }

rust2/src/naive_interpreter.rs

@@ -0,0 +1,55 @@
+use crate::parse::Instr;
+use std::io::{Read, Write};
+use std::num::Wrapping;
+
+const MEM_SIZE: usize = 32_000;
+
+type Memory = [Wrapping<u8>; MEM_SIZE];
+
+pub fn run(instrs: &[Instr<'_>]) {
+    let mut mem = [Wrapping(0u8); MEM_SIZE];
+    let mut ptr = 0;
+
+    execute(&mut mem, &mut ptr, instrs);
+}
+
+fn execute(mem: &mut Memory, ptr: &mut usize, instrs: &[Instr<'_>]) {
+    for instr in instrs {
+        match instr {
+            Instr::Add => {
+                mem[*ptr] += 1;
+            }
+            Instr::Sub => {
+                mem[*ptr] -= 1;
+            }
+            Instr::Right => {
+                *ptr += 1;
+                if *ptr >= MEM_SIZE {
+                    *ptr = 0;
+                }
+            }
+            Instr::Left => {
+                if *ptr == 0 {
+                    *ptr = MEM_SIZE - 1;
+                } else {
+                    *ptr -= 1;
+                }
+            }
+            Instr::Out => {
+                let char = mem[*ptr].0 as char;
+                print!("{char}",);
+                std::io::stdout().flush().unwrap();
+            }
+            Instr::In => {
+                let mut buf = [0; 1];
+                std::io::stdin().read_exact(&mut buf).unwrap();
+                mem[*ptr] = Wrapping(buf[0]);
+            }
+            Instr::Loop(body) => {
+                while mem[*ptr] != Wrapping(0) {
+                    execute(mem, ptr, body);
+                }
+            }
+        }
+    }
+}

rust2/src/parse.rs

@@ -1,6 +1,6 @@
 use bumpalo::Bump;
 
-type Instrs<'ast> = Vec<Instr<'ast>, &'ast Bump>;
+pub type Instrs<'ast> = Vec<Instr<'ast>, &'ast Bump>;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Instr<'ast> {
@@ -43,7 +43,7 @@ where
     Ok(instrs)
 }
 
-pub fn parse_loop<'ast, I>(
+fn parse_loop<'ast, I>(
     alloc: &'ast Bump,
     src: &mut I,
     depth: u16,