Simple Machine Code Interpreter

interpreter.py

#!/usr/bin/env python3
"""
Simple Machine Code Interpreter
Supports a minimal instruction set:
    1: LOAD reg, value   -> Load immediate value into register
    2: ADD reg1, reg2    -> reg1 = reg1 + reg2
    3: SUB reg1, reg2    -> reg1 = reg1 - reg2
    4: STORE reg, addr   -> Store register value into memory
    5: LOADM reg, addr   -> Load value from memory into register
    6: PRINT reg         -> Print register value
    0: HALT              -> Stop execution
"""

# Define constants for opcodes
LOAD   = 1
ADD    = 2
SUB    = 3
STORE  = 4
LOADM  = 5
PRINT  = 6
HALT   = 0

class SimpleCPU:
    def __init__(self, memory_size=256):
        self.registers = [0] * 4  # Four general-purpose registers R0-R3
        self.memory = [0] * memory_size
        self.pc = 0  # Program counter
        self.running = True

    def fetch(self, program):
        """Fetch next instruction from program."""
        if self.pc >= len(program):
            self.running = False
            return None
        instr = program[self.pc]
        self.pc += 1
        return instr

    def execute(self, instr, program):
        """Execute a single instruction."""
        if instr is None:
            return

        opcode = instr[0]

        if opcode == LOAD:
            reg, value = instr[1], instr[2]
            self.registers[reg] = value

        elif opcode == ADD:
            reg1, reg2 = instr[1], instr[2]
            self.registers[reg1] += self.registers[reg2]

        elif opcode == SUB:
            reg1, reg2 = instr[1], instr[2]
            self.registers[reg1] -= self.registers[reg2]

        elif opcode == STORE:
            reg, addr = instr[1], instr[2]
            if 0 <= addr < len(self.memory):
                self.memory[addr] = self.registers[reg]
            else:
                raise ValueError("Memory address out of range")

        elif opcode == LOADM:
            reg, addr = instr[1], instr[2]
            if 0 <= addr < len(self.memory):
                self.registers[reg] = self.memory[addr]
            else:
                raise ValueError("Memory address out of range")

        elif opcode == PRINT:
            reg = instr[1]
            print(f"R{reg} = {self.registers[reg]}")

        elif opcode == HALT:
            self.running = False

        else:
            raise ValueError(f"Unknown opcode: {opcode}")

    def run(self, program):
        """Run the program."""
        while self.running:
            instr = self.fetch(program)
            self.execute(instr, program)


if __name__ == "__main__":
    # In more realistic interpreter, you read bytearray and try to decode instruction from bytes on the stream. This part is missing here.
    
    # Example program: R0 = 5, R1 = 10, R0 = R0 + R1, print R0
    program = [
        (LOAD, 0, 5),       # R0 = 5
        (LOAD, 1, 10),      # R1 = 10
        (ADD, 0, 1),        # R0 = R0 + R1
        (PRINT, 0),         # Print R0
        (STORE, 0, 20),     # Store R0 into memory[20]
        (LOADM, 2, 20),     # Load memory[20] into R2
        (PRINT, 2),         # Print R2
        (HALT,)             # Stop
    ]

    cpu = SimpleCPU()
    cpu.run(program)