Refactor BrainFuck interpreter to use a Registers class for state management; introduce Lua interpreter with basic structure and register handling.

src/brainfuck/__brainfuck.py

@@ -1,6 +1,6 @@
 from sys import stdin, stdout
 from os import PathLike
-from interpreter import Interpreter, opcode
+from interpreter import Interpreter, Registers, opcode
 from pathlib import Path
 
 
@@ -32,48 +32,62 @@ class BrainFuckByteCodeCompiler:
         )
 
 
+class BrainFuckRegisters(Registers):
+    def __init__(self) -> None:
+        super().__init__()
+        self.memory_pointer: int = 0
+
+
 class BrainFuckInterpreter(Interpreter):
+    def __init__(self, bits=8, memsize=None) -> None:
+        super().__init__(bits, memsize)
+        self._registers: BrainFuckRegisters = BrainFuckRegisters()
+
+    def load_program(self, program: bytearray) -> None:
+        super().load_program(program)
+        self._registers.memory_pointer = len(program) + 1
+
     @opcode(BrainFuckByteCode[">"])
     def forward(self):
-        self._memory_pointer += 1
+        self._registers.memory_pointer += 1
 
     @opcode(BrainFuckByteCode["<"])
     def backward(self):
-        self._memory_pointer -= 1
+        self._registers.memory_pointer -= 1
 
     @opcode(BrainFuckByteCode["+"])
     def increment(self):
-        val = self._memory[self._memory_pointer]
-        self._memory[self._memory_pointer] = (val + 1) % 256
+        val = self._memory[self._registers.memory_pointer]
+        self._memory[self._registers.memory_pointer] = (val + 1) % 256
 
     @opcode(BrainFuckByteCode["-"])
     def decrement(self):
-        val = self._memory[self._memory_pointer]
-        self._memory[self._memory_pointer] = (val - 1) & 255
+        val = self._memory[self._registers.memory_pointer]
+        self._memory[self._registers.memory_pointer] = (val - 1) & 255
 
     @opcode(BrainFuckByteCode["."])
-    def io_in(self):
-        stdout.write(chr(self._memory[self._memory_pointer]))
+    def io_out(self):
+        stdout.write(chr(self._memory[self._registers.memory_pointer]))
 
     @opcode(BrainFuckByteCode[","])
-    def io_out(self):
+    def io_in(self):
         stdout.flush()
-        self._memory[self._memory_pointer] = ord(stdin.read(1))
+        self._memory[self._registers.memory_pointer] = ord(stdin.read(1))
 
     @opcode(BrainFuckByteCode["["])
     def loop_start(self):
         # Ignore opcode if mem_pointer == 0
-        if self._memory[self._memory_pointer] > 0:
+        if self._memory[self._registers.memory_pointer] > 0:
             pass
-        elif self._memory[self._memory_pointer] == 0:
-            self._program_counter = self.findNext() - 1
+        elif self._memory[self._registers.memory_pointer] == 0:
+            self._registers.program_counter = self.findNext() - 1
 
     @opcode(BrainFuckByteCode["]"])
     def start_end(self):
-        self._program_counter = self.findNext(-1)
+        self._registers.program_counter = self.findNext(-1)
 
     def findNext(self, incrementValue: int = 1) -> int:
-        search_pointer = self._program_counter + incrementValue
+        search_pointer = self._registers.program_counter + incrementValue
         bracket_counter = 1
         while bracket_counter != 0:
             opcode = self._memory[search_pointer]