BasicInterpreter.py

from ExpressionInterpreter import ExpressionInterpreter
from FunctionDefinition import FunctionDefinition
from ValueType import ValueType
from re import split as re_split, search as re_search
from random import seed
from time import sleep

class BasicInterpreter:

    _ansi_colors = { 0: 0, 1: 4, 2: 1, 3: 5, 4: 2, 5: 6, 6: 3, 7: 7 }

    def __init__(self):
        self._program = []          # [(line_number, code)]
        self._line_index = {}       # line_number -> index in program
        self._pc = 0                # program counter
        self._num_variables = {}
        self._str_variables = {}
        self._functions = {}
        self._expr_interpreter = ExpressionInterpreter(self._num_variables, self._str_variables, self._functions)
        self._stop = False
        self._return_stack = []
        self._data_buffer = []
        self._data_buffer_index = 0
        self._restore_line_index = {}
        self._bright = False
        self._ink_color = 7
        self._paper_color = 0
        
    def load(self, stream):
        """
        stream: iterable de líneas (archivo, lista, etc.)
        """
        self._program = []
        self._line_index = {}
        self._data_buffer = []
        self._data_buffer_index = 0
        
        for raw_line in stream:
            raw_line = raw_line.strip()
            if not raw_line:
                continue

            number_str, code = raw_line.split(" ", 1)
            code_parts = re_split(r':(?=(?:[^"]*"[^"]*")*[^"]*$)', code)
            part_index = 0
            number = int(number_str)
            for code_part in code_parts:
                code_part = code_part.strip()
                if code_part.startswith("DATA"):
                    self.execute_data(number, code_part)
                elif code_part.startswith("REM"):
                    self._program.append((number, part_index, "REM"))
                    break
                else:
                    self._program.append((number, part_index, code_part))                
                    part_index += 1

        # ordenar por número de línea
        self._program.sort(key=lambda x: (x[0], x[1]))

        # crear índice rápido para GOTO
        for idx, (line_number, _, _) in enumerate(self._program):
            if not line_number in self._line_index:
                self._line_index[line_number] = idx

    def run(self, line=0):
        self._pc = 0 if line == 0 else self._line_index[line]
        self._stop = False
        self._return_stack = []
        self._data_buffer_index = 0

        try:
            while not self._stop and self._pc < len(self._program):
                line_number, _, code = self._program[self._pc]
                self.execute_sentence(code)
                self._pc += 1
            if self._stop:
                print("\r\nProgram stop")
            else:
                print("\r\nOK")
        except (ValueError, RuntimeError) as re:
            print(f"\r\nError: {re}\r\n\tat line {line_number} {code}")
        except KeyboardInterrupt:
            print("\r\nInterrupted program")
        finally:
            print("\x1b[0m",end="")

    def execute_sentence(self, code):
        code = code.strip()
        code_upper = code.upper()

        if code_upper.startswith("PRINT"):
            self.execute_print(code)

        elif code_upper.startswith("GO TO") or code_upper.startswith("GOTO"):
            self.execute_goto(code)

        elif code_upper.startswith("LET"):
            self.execute_let(code)

        elif code_upper.startswith("IF"):
            self.execute_if(code)

        elif code_upper.startswith("INPUT"):
            self.execute_input(code)

        elif code_upper.startswith("FOR"):
            self.execute_for(code)

        elif code_upper.startswith("NEXT"):
            self.execute_next(code)

        elif code_upper.startswith("REM"):
            self.execute_rem(code)

        elif code_upper.startswith("STOP"):
            self.execute_stop(code)

        elif code_upper.startswith("GO SUB") or code_upper.startswith("GOSUB"):
            self.execute_gosub(code)

        elif code_upper.startswith("RETURN"):
            self.execute_return(code)

        elif code_upper.startswith("READ"):
            self.execute_read(code)

        elif code_upper.startswith("RESTORE"):
            self.execute_restore(code)

        elif code_upper.startswith("RANDOMIZE"):
            self.execute_randomize(code)

        elif code_upper.startswith("DEF"):
            self.execute_def(code)

        elif code_upper.startswith("CLS"):
            self.execute_cls(code)

        elif code_upper.startswith("WAIT"):
            self.execute_wait(code)

        elif code_upper.startswith("INK"):
            self.execute_ink(code)

        elif code_upper.startswith("PAPER"):
            self.execute_paper(code)

        elif code_upper.startswith("BRIGHT"):
            self.execute_bright(code)

        elif code_upper.startswith("FLASH"):
            self.execute_flash(code)

        elif code_upper.startswith("DIM"):
            self.execute_dim(code)

        else:
            raise RuntimeError(f"Unknown keyword: {code}")

    def execute_print(self, code):
        if code == "PRINT":
            print()
            return

        _, rest = code.split(" ", 1)
        rest = rest.strip()
        args = re_split(r';(?=(?:[^"]*"[^"]*")*[^"]*$)', rest)

        for arg in args:
            if arg != "":
                value = self._expr_interpreter.evaluate(arg)
                if isinstance(value, (float, int)):
                    print(f"{value:g}", end="", flush=True)
                else:
                    print(value, end="", flush=True)

        if not code.endswith(";"):
            print(flush=True)

    def execute_goto(self, code):
        # GO TO 10
        parts = code.split()
        target_line = int(parts[-1])

        if target_line not in self._line_index:
            raise RuntimeError(f"Undefined line number {target_line}")

        # -1 porque el loop principal hará pc += 1
        self._pc = self._line_index[target_line] - 1

    def execute_let(self, code):
        _, rest = code.split(" ", 1)
        left, expr = rest.split("=", 1)

        left = left.strip()
        expr = expr.strip()
        
        match = re_search(r'\((.*?)\)', left)

        if match:
            indices_row = match.group(1)
            indices = [self._expr_interpreter.evaluate(index_row) for index_row in indices_row.strip().split(",")]
            var_name, _ = left.split("(", 1)
            item = self._str_variables[var_name.strip()]

            is_terminal = False
            for index in indices:
                temp = item[index-1]
                if isinstance(temp, list):
                    item = temp
                else:
                    is_terminal = True

            if is_terminal:
                item[indices[-1]-1] = self._expr_interpreter.evaluate(expr)
            else:
                for i, c in enumerate(self._expr_interpreter.evaluate(expr)):
                    item[i] = c

        else:
            self._assignVariable(left, expr)

    def _assignVariable(self, var_name, expression_value):
        value = self._expr_interpreter.evaluate(expression_value)
        if var_name.endswith("$"):
            if not isinstance(value, str):
                raise RuntimeError("Type mismatch. A string was expected.")
            self._str_variables[var_name] = value
        else:
            if not isinstance(value, (int, float)):
                raise RuntimeError("Type mismatch. A number was expected.")
            self._num_variables[var_name] = value

    def execute_if(self, code):

        _, rest = code.split(" ", 1)
        condition, then = rest.split(" THEN ", 1)
        if self._expr_interpreter.evaluate(condition.strip()) != 0:
            self.execute_sentence(then.strip())

    def execute_input(self, code):

        _, rest = code.split(" ", 1)
        chunks = re_split(r'[;,](?=(?:[^"]*"[^"]*")*[^"]*$)', rest)
        if len(chunks) > 2:
            raise ValueError("INPUT: Too much arguments")
        elif len(chunks) == 2:
            prompt = self._expr_interpreter.evaluate(chunks[0].strip())
            variable = chunks[1]
            value = input(prompt)
        else:
            variable = chunks[0]
            value = input("? ")
        variable = variable.strip()
        if variable.endswith("$"):
            self._str_variables[variable] = value
        else:
            self._num_variables[variable] = float(value)

    def execute_for(self, code):
        _, rest = code.split(" ", 1)
        loop_variable, rest = rest.split("=", 1)
        loop_init, rest = rest.strip().split("TO", 1)
        loop_variable = loop_variable.strip()
        
        if "STEP" in rest:
            loop_end, loop_step = rest.strip().split("STEP")
        else:
            loop_end = rest.strip()
            loop_step = "1"

        self._num_variables[loop_variable] = self._expr_interpreter.evaluate(loop_init.strip())
        self._num_variables[f"for_end_{loop_variable}"] = self._expr_interpreter.evaluate(loop_end.strip())
        self._num_variables[f"for_step_{loop_variable}"] = self._expr_interpreter.evaluate(loop_step.strip())
        self._num_variables[f"for_num_codeline_{loop_variable}"] = self._pc

        if self._num_variables[f"for_step_{loop_variable}"] == 0:
            raise ValueError("FOR STEP can not be 0.")

    def execute_next(self, code):

        _, loop_variable = code.split(" ", 1)
        
        step = self._num_variables[f"for_step_{loop_variable}"]
        self._num_variables[loop_variable] += step
        if (step > 0 and self._num_variables[loop_variable] <= self._num_variables[f"for_end_{loop_variable}"]) \
            or ( step < 0 and self._num_variables[loop_variable] >= self._num_variables[f"for_end_{loop_variable}"]):
            self._pc = self._num_variables[f"for_num_codeline_{loop_variable}"]

    def execute_rem(self, code):
        pass #Do nothing

    def execute_stop(self, code):
        self._stop = True

    def execute_gosub(self, code):
        self._return_stack.append(self._pc)
        parts = code.split()
        target_line = int(parts[-1])
        self._pc = self._line_index[target_line] - 1

    def execute_return(self, code):
        self._pc = self._return_stack.pop()

    def execute_data(self, line_number, code):
        if not line_number in self._restore_line_index:
            self._restore_line_index[line_number] = len(self._data_buffer)

        _, row_data = code.split(" ", 1)        
        for data_element in row_data.split(","):
            data_element = data_element.strip()
            self._data_buffer.append(data_element)

    def execute_read(self, code):
        _, params = code.split(" ", 1)
        var_names = params.split(",")
        for var_name in var_names:
            if self._data_buffer_index == len(self._data_buffer):
                raise RuntimeError("End of data")
            var_name = var_name.strip()            
            value = self._data_buffer[self._data_buffer_index]
            self._assignVariable(var_name, value)
            self._data_buffer_index += 1

    def execute_restore(self, code):
        items = code.split(" ")        
        self._data_buffer_index = self._restore_line_index[int(items[-1])] if len(items) > 1 else 0

    def execute_randomize(self, code):
        seed()

    def execute_def(self, code):
        _, function = code.split("FN")
        header, body = function.strip().split("=")
        name_raw, params_raw = header.strip().split("(")
        name = name_raw.strip()
        params = [p.strip() for p in params_raw.strip()[:-1].split(",")]
        return_type = ValueType.String if name[-1] == '$' else ValueType.Integer
        
        definition = FunctionDefinition(return_type, params, body.strip())
        self._functions[name] = definition

    def execute_cls(self, code):
        print("\x1b[2J\x1b[H", end="")

    def execute_wait(self, code):
        _, param = code.split(" ", 1)
        seconds = self._expr_interpreter.evaluate(param.strip())
        if not isinstance(seconds, (float, int)):
            raise ValueError("WAIT: Number expected as parameter")
        sleep(seconds)

    def _apply_ink_color(self):
        print(f"\x1b[{(90 if self._bright else 30) + BasicInterpreter._ansi_colors[self._ink_color]}m", end="")

    def execute_ink(self, code):
        _, param = code.split(" ", 1)
        self._ink_color = int(self._expr_interpreter.evaluate(param.strip()))   
        self._apply_ink_color()     

    def _apply_paper_color(self):
        print(f"\x1b[{(100 if self._bright else 40) + BasicInterpreter._ansi_colors[self._paper_color]}m", end="")

    def execute_paper(self, code):
        _, param = code.split(" ", 1)
        self._paper_color = int(self._expr_interpreter.evaluate(param.strip()))
        self._apply_paper_color()

    def execute_bright(self, code):
        _, param = code.split(" ", 1)
        value = int(self._expr_interpreter.evaluate(param.strip()))
        self._bright = value == 1
        self._apply_ink_color()
        self._apply_paper_color()
        
    def execute_flash(self, code):
        _, param = code.split(" ", 1)
        value = self._expr_interpreter.evaluate(param.strip())
        print(f"\x1b[{5 if value == 1 else 25}m", end="")
        
    def execute_dim(self, code):
        _, param = code.split(" ", 1)
        dim_name, dim_sizes_raw = param.split("(", 1)
        dim_name = dim_name.strip()
        dim_sizes = [self._expr_interpreter.evaluate(str_size) for str_size in dim_sizes_raw.strip()[:-1].split(",")]
        if dim_name[-1] == "$":
            self._str_variables[dim_name] = BasicInterpreter.create_multi_array(dim_sizes)

    @staticmethod
    def create_multi_array(sizes):
        if len(sizes) == 1:
            return [0] * sizes[0]
        else:
            return [BasicInterpreter.create_multi_array(sizes[1:]) for _ in range(sizes[0])]