First working state

src/brainfuck/__brainfuck.py

@@ -0,0 +1,106 @@
+from sys import stdin, stdout
+from os import PathLike
+from enterpreter import Enterpreter, opcode
+
+
+BrainFuckByteCode = {
+    ">": 1,
+    "<": 2,
+    "+": 3,
+    "-": 4,
+    ".": 5,
+    ",": 6,
+    "[": 7,
+    "]": 8,
+}
+
+
+class BrainFuckByteCodeCompiler:
+    def load_file(self, file: PathLike):
+        self.source_file: PathLike = file
+        self.load(bytearray(Path(file).read_bytes()))
+
+    def load(self, data: bytearray):
+        self.source_data: bytearray = data
+
+    def compile(self) -> bytearray:
+        # whitespace_b = whitespace.encode()
+        valid_b = set(ord(s) for s in BrainFuckByteCode.keys())
+        self.source_data = bytearray(b for b in self.source_data if b in valid_b)
+
+        out = bytearray()
+        for byte in self.source_data:
+            out.append(BrainFuckByteCode[chr(byte)])
+        return out
+
+
+class BrainFuckEnterpreter(Enterpreter):
+    @opcode(BrainFuckByteCode[">"])
+    def a_(self):
+        self._memory_pointer += 1
+
+    @opcode(BrainFuckByteCode["<"])
+    def b_(self):
+        self._memory_pointer -= 1
+
+    @opcode(BrainFuckByteCode["+"])
+    def c_(self):
+        val = self._memory[self._memory_pointer]
+        self._memory[self._memory_pointer] = (val + 1) % 256
+
+    @opcode(BrainFuckByteCode["-"])
+    def d_(self):
+        val = self._memory[self._memory_pointer]
+        self._memory[self._memory_pointer] = (val - 1) & 255
+
+    @opcode(BrainFuckByteCode["."])
+    def e_(self):
+        stdout.write(chr(self._memory[self._memory_pointer]))
+
+    @opcode(BrainFuckByteCode[","])
+    def f_(self):
+        stdout.flush()
+        self._memory[self._memory_pointer] = ord(stdin.read(1))
+
+    @opcode(BrainFuckByteCode["["])
+    def g_(self):
+        # Ignore opcode if mem_pointer == 0
+        if self._memory[self._memory_pointer] > 0:
+            pass
+        elif self._memory[self._memory_pointer] == 0:
+            self._program_counter = self.findNext() - 1
+
+    @opcode(BrainFuckByteCode["]"])
+    def h_(self):
+        self._program_counter = self.findNext(-1)
+
+    def findNext(self, incrementValue: int = 1) -> int:
+        search_pointer = self._program_counter + incrementValue
+        bracket_counter = 1
+        while bracket_counter != 0:
+            opcode = self._memory[search_pointer]
+            if opcode == BrainFuckByteCode["["]:
+                bracket_counter += incrementValue
+            elif opcode == BrainFuckByteCode["]"]:
+                bracket_counter -= incrementValue
+            search_pointer += incrementValue
+        return search_pointer
+
+
+def bf(program_path: PathLike, bits=8, mem=2**8) -> BrainFuckEnterpreter:
+    bf_c = BrainFuckByteCodeCompiler()
+    bf_c.load_file(program_path)
+    program = bf_c.compile()
+
+    bf_e = BrainFuckEnterpreter(bits=bits, memsize=mem)
+    bf_e.load_program(program)
+    bf_e.run()
+
+    return bf_e
+
+
+if __name__ == "__main__":
+    from pathlib import Path
+
+    bf(Path("examples", "HelloWorld.bf"))
+    bf(Path("examples", "GameOfLife.bf"), bits=16, mem=2**16)