easy_lang.py

import math
import os
import platform
import random
import re
import shutil
import subprocess
import sys
import time
from datetime import date, datetime

# ================= PRETTY ERROR SYSTEM =======================

RED = "\033[31m"
YELLOW = "\033[33m"
CYAN = "\033[36m"
RESET = "\033[0m"
BOLD = "\033[1m"


def pretty_error(
    error_type, message, file_path, line, col, source_lines=None, file_source_map=None
):
    """
    Just pretty errors with some carets
    """

    header = f"{RED}{BOLD}{error_type}:{RESET} {message}"

    source_lines = file_source_map.get(file_path, [])

    if file_source_map is not None:
        source_lines = file_source_map.get(file_path, source_lines or [])
    elif source_lines is None:
        source_lines = []

    # Bounds check
    if not source_lines or line < 1 or line > len(source_lines):
        return header + f"\nFile: {file_path}\nLine: {line}, Column: {col}"

    output = [header, ""]

    start = max(1, line - 1)
    end = min(len(source_lines), line + 1)

    for ln in range(start, end + 1):
        prefix = f"{CYAN}{ln:4d}|{RESET} "
        text = source_lines[ln - 1].rstrip("\n")
        output.append(prefix + text)

        if ln == line:
            raw_line = source_lines[line - 1].rstrip("\n")
            display_line = raw_line.replace("\t", "    ")
            caret_position = len(display_line[: col - 1])
            caret = " " * caret_position

            output.append("     " + CYAN + caret + "^" + RESET)

    output.append(f"\nFile: {file_path}, line {line}, column {col}")

    if file_source_map and "__stack__" in file_source_map:
        output.append("\nImport stack:")
        for fp in file_source_map["__stack__"]:
            output.append("  → " + fp)

    return "\n".join(output)


# ================= LEXER =======================

token_specification = [
    ("MCOMMENT", r"\$\$[\s\S]*?\$\$"),
    ("COMMENT", r"\$(?!\$)[^\n]*"),
    ("LBRACK", r"\["),
    ("RBRACK", r"\]"),
    ("LBRACE", r"\{"),
    ("RBRACE", r"\}"),
    ("DOT", r"\."),
    ("LPAREN", r"\("),
    ("RPAREN", r"\)"),
    ("COLON", r":"),
    ("STRING", r'"[^"]*"'),
    ("NUMBER", r"\d+(\.\d+)?"),
    ("GTE", r">="),
    ("LTE", r"<="),
    ("EQ", r"=="),
    ("NEQ", r"!="),
    ("GT", r">"),
    ("LT", r"<"),
    ("MATCH", r"match\b"),
    ("OTHERWISE", r"otherwise\b"),
    ("CLASS", r"class\b"),
    ("METHOD", r"method\b"),
    ("WHEN", r"when\b"),
    ("CREATED", r"created\b"),
    ("SELF", r"self\b"),
    ("MAKE", r"make\b"),
    ("PLUSASSIGN", r"\+="),
    ("MINUSASSIGN", r"-="),
    ("MULASSIGN", r"\*="),
    ("DIVASSIGN", r"/="),
    ("MODASSIGN", r"%="),
    ("ASSIGN", r"be\b|="),
    ("NOTEQUALS", r"not equals\b"),
    ("NOT", r"not\b"),
    ("EQUALS", r"equals\b"),
    ("DEFINE", r"define\b"),
    ("RETURN", r"return\b"),
    ("BRING", r"bring\b"),
    ("COMMA", r","),
    ("OPEN", r"open\b"),
    ("CLOSE", r"close\b"),
    ("READLINE", r"readline\b"),
    ("WRITELINE", r"writeline\b"),
    ("FOR", r"for\b"),
    ("AS", r"as\b"),
    ("INTO", r"into\b"),
    ("WITH", r"with\b"),
    ("WRITE", r"write\b"),
    ("APPEND", r"append\b"),
    ("AND", r"and\b"),
    ("OR", r"or\b"),
    ("PLUS", r"plus\b"),
    ("MINUS", r"minus\b"),
    ("LESS", r"less\b"),
    ("GREATER", r"greater\b"),
    ("MUL", r"mul\b"),
    ("DIV", r"div\b"),
    ("FDIV", r"\/\/"),
    ("MOD", r"modulus\b"),
    ("EXPO", r"expo\b"),
    ("POWOP", r"\*\*"),
    ("PERCENT", r"%"),
    ("REPEAT", r"repeat\b"),
    ("WHILE", r"while\b"),
    ("FROM", r"from\b"),
    ("TO", r"to\b"),
    ("DO", r"do\b"),
    ("LET", r"let\b"),
    ("CONSTANT", r"constant\b"),
    ("SO", r"so\b"),
    ("PRINT", r"print\b"),
    ("READ", r"read\b"),
    ("INT", r"int\b"),
    ("FLOAT", r"float\b"),
    ("TEXT", r"text\b"),
    ("BOOLEAN", r"boolean\b"),
    ("NULL", r"null\b"),
    ("TRUE", r"true\b"),
    ("FALSE", r"false\b"),
    ("IF", r"if\b"),
    ("THEN", r"then\b"),
    ("ELSE", r"else\b"),
    ("ELSEIF", r"else\s+if\b"),
    ("CONTINUE", r"continue\b"),
    ("BREAK", r"break\b"),
    ("TRY", r"try\b"),
    ("HANDLE", r"handle\b"),
    ("OP", r"[+\-*/]"),
    ("ID", r"[A-Za-z_]\w*"),
    ("SKIP", r"[ \t]+"),
    ("NEWLINE", r"\n"),
    ("MISMATCH", r"."),
]

tok_regex = "|".join(f"(?P<{name}>{pattern})" for name, pattern in token_specification)
_tok_re = re.compile(tok_regex)


def lexer(code):
    """
    Good Lexer
    """
    tokens = []

    line = 1
    col = 1
    pos = 0
    length = len(code)

    while pos < length:
        match = _tok_re.match(code, pos)
        if not match:
            bad_char = code[pos]
            raise SyntaxError(("Unexpected character", bad_char, line, col))

        kind = match.lastgroup
        value = match.group(0)

        token_line = line
        token_col = col

        pos = match.end(0)

        newline_count = value.count("\n")
        if newline_count == 0:
            col += len(value)
        else:
            line += newline_count
            last_nl = value.rfind("\n")
            col = len(value) - last_nl

        if kind in ("SKIP", "COMMENT", "MCOMMENT", "NEWLINE"):
            continue

        if kind == "MISMATCH":
            raise SyntaxError(("Unexpected character", value, token_line, token_col))

        tokens.append((kind, value, token_line, token_col))

    return tokens


# ================= PARSER =======================


class Parser:
    def __init__(self, tokens, file_path="<stdin>"):
        self.tokens = tokens
        self.pos = 0
        self.seen_non_import = False
        self.file_path = file_path

    def error(self, message, token=None):
        if token is None:
            token = self.peek()
        if token is None:
            raise SyntaxError((message, "", 1, 1, self.file_path))
        kind, value, line, col = token
        if message.startswith("PRINT takes only one argument") and kind == "RBRACK":
            message = (
                "Unexpected ']' after print. "
                "\nHint: remove this ']' or wrap the whole if-body in [ ... ]."
            )
        raise SyntaxError((message, value, line, col, self.file_path))

    def peek(self):
        if self.pos < len(self.tokens):
            return self.tokens[self.pos]
        return None

    def define_const(self, name, value):
        self.scopes[-1][name] = value
        self.const_scopes[-1].add(name)

    def consume(self, expected_type=None):
        if self.pos < len(self.tokens):
            kind, value, line_num, col_num = self.tokens[self.pos]
            if expected_type is None or kind == expected_type:
                self.pos += 1
                return kind, value, line_num, col_num
            else:
                if expected_type == "ID" and kind in (
                    "INT",
                    "FLOAT",
                    "TEXT",
                    "BOOLEAN",
                    "TRUE",
                    "FALSE",
                    "IF",
                    "ELSE",
                    "ELSEIF",
                    "LET",
                    "SO",
                    "READ",
                    "REPEAT",
                    "WHILE",
                    "FROM",
                    "TO",
                    "DO",
                    "PRINT",
                    "AND",
                    "OR",
                    "PLUS",
                    "MINUS",
                    "LESS",
                    "GREATER",
                    "MUL",
                    "DIV",
                    "MOD",
                    "EXPO",
                    "ASSIGN",
                    "NULL",
                    "CONSTANT",
                ):
                    self.error(
                        f"Invalid identifier: '{value}' is a reserved keyword; choose a different variable name",
                        (kind, value, line_num, col_num),
                    )
                self.error(
                    f"Expected {expected_type}, got {kind} ('{value}')",
                    (kind, value, line_num, col_num),
                )
        self.error("Unexpected end of input", None)

    def parse(self):
        statements = []
        while self.peek():
            statements.append(self.parse_statement())
        return statements

    def parse_statement(self):
        token = self.peek()
        if token is None:
            self.error("Unexpected end of input")
        kind, value, line_num, col_num = token

        if kind == "SELF":
            self.seen_non_import = True
            expr = self.parse_expression()
            if self.peek() and self.peek()[0] == "ASSIGN":
                if expr[0] == "prop":
                    _, self_obj, field_name, line, col = expr
                    self.consume("ASSIGN")
                    value_expr = self.parse_expression()
                    return ("self_assign", field_name, value_expr, line, col)
                else:
                    self.error("Invalid self assignment", self.peek())
            else:
                e_line, e_col = expr[-2], expr[-1]
                return ("expr", expr, e_line, e_col)

        # Expression statement
        elif kind in ("ID", "NOT", "LPAREN", "NUMBER", "STRING", "TRUE", "FALSE", "LBRACK", "LBRACE"):
            self.seen_non_import = True
            if kind == "ID":
                next_pos = self.pos + 1
                if next_pos < len(self.tokens):
                    next_token_kind = self.tokens[next_pos][0]
                    if next_token_kind == "ASSIGN":
                        _, var_name, line, col = self.consume("ID")
                        self.consume("ASSIGN")
                        expr = self.parse_expression()
                        return ("assign", var_name, expr, line, col)
                    elif next_token_kind == "DOT":
                        _, obj_name, line, col = self.consume("ID")
                        self.consume("DOT")
                        _, field_name, _, _ = self.consume("ID")
                        if self.peek() and self.peek()[0] == "ASSIGN":
                            self.consume("ASSIGN")
                            expr = self.parse_expression()
                            return ("obj_field_assign", obj_name, field_name, expr, line, col)
                        else:
                            self.pos -= 3
                            expr = self.parse_expression()
                            e_line, e_col = expr[-2], expr[-1]
                            return ("expr", expr, e_line, e_col)
                    elif next_token_kind == "LBRACK":
                        _, _, stmt_line, stmt_col = self.consume("ID")
                        var_name = value
                        self.consume("LBRACK")
                        start_expr = None
                        stop_expr = None
                        step_expr = None
                        is_slice = False
                        if self.peek() and self.peek()[0] == "COLON":
                            is_slice = True
                            self.consume("COLON")
                            if self.peek() and self.peek()[0] not in ("COLON", "RBRACK"):
                                stop_expr = self.parse_expression()
                        else:
                            first_expr = self.parse_expression()
                            if self.peek() and self.peek()[0] == "COLON":
                                is_slice = True
                                start_expr = first_expr
                                self.consume("COLON")
                                if self.peek() and self.peek()[0] not in ("COLON", "RBRACK"):
                                    stop_expr = self.parse_expression()
                                if self.peek() and self.peek()[0] == "COLON":
                                    self.consume("COLON")
                                    if self.peek() and self.peek()[0] != "RBRACK":
                                        step_expr = self.parse_expression()
                            else:
                                start_expr = first_expr
                        self.consume("RBRACK")
                        if self.peek() and self.peek()[0] == "ASSIGN":
                            self.consume("ASSIGN")
                            expr = self.parse_expression()
                            if is_slice:
                                return ("assign_slice", var_name, start_expr, stop_expr, step_expr, expr, stmt_line, stmt_col)
                            else:
                                return ("assign_index", var_name, start_expr, expr, stmt_line, stmt_col)
                        else:
                            self.error("Expected '=' after indexed variable", token)

                    elif next_token_kind in ("PLUSASSIGN", "MINUSASSIGN", "MULASSIGN", "DIVASSIGN", "MODASSIGN"):
                        _, var_name, _, _ = self.consume("ID")
                        op_kind, op_val, op_line, op_col = self.consume()
                        expr = self.parse_expression()
                        
                        op_map = {
                            "PLUSASSIGN": "plus",
                            "MINUSASSIGN": "minus",
                            "MULASSIGN": "mul",
                            "DIVASSIGN": "div",
                            "MODASSIGN": "%",
                        }
                        op = op_map[op_kind]
                        
                        binary_expr = ("binop", op, ("var", var_name, op_line, op_col), expr, op_line, op_col)
                        return ("assign", var_name, binary_expr, op_line, op_col)

        elif kind == "LET":
            self.seen_non_import = True
            return self.parse_assignment()

        elif kind == "CONSTANT":
            self.seen_non_import = True
            return self.parse_constant()

        elif kind == "PRINT":
            self.seen_non_import = True
            return self.parse_print()

        elif kind == "BRING":
            if self.seen_non_import:
                self.error(
                    "'bring' statements must appear at the top of the file", token
                )
            return self.parse_bring()

        elif kind == "READ":
            self.seen_non_import = True
            return self.parse_read()

        elif kind == "OPEN":
            self.seen_non_import = True
            return self.parse_open()

        elif kind == "CLOSE":
            self.seen_non_import = True
            return self.parse_close()

        elif kind == "READLINE":
            self.seen_non_import = True
            return self.parse_readline()

        elif kind == "WRITELINE":
            self.seen_non_import = True
            return self.parse_writeline()

        elif kind == "IF":
            self.seen_non_import = True
            return self.parse_if()

        elif kind == "REPEAT":
            self.seen_non_import = True
            return self.parse_loop()
        
        elif kind == "CLASS":
            self.seen_non_import = True
            return self.parse_class()
        
        elif kind == "MAKE":
            self.seen_non_import = True
            return self.parse_make()

        elif kind == "DEFINE":
            self.seen_non_import = True
            next_pos = self.pos + 1
            if next_pos < len(self.tokens):
                next_kind = self.tokens[next_pos][0]
                if next_kind == "CLASS":
                    return self.parse_class()
                elif next_kind == "METHOD":
                    return self.parse_method()
                else:
                    return self.parse_function()
            else:
                return self.parse_function()

        elif kind == "RETURN":
            self.seen_non_import = True
            return self.parse_return()

        elif kind == "CONTINUE":
            _, _, line, col = self.consume()
            return ("continue", line, col)

        elif kind == "BREAK":
            _, _, line, col = self.consume()
            return ("break", line, col)

        elif kind == "TRY":
            self.seen_non_import = True
            return self.parse_try()
        
        elif kind == "MATCH":
            self.seen_non_import = True
            return self.parse_match()

        else:
            self.error(f"Unexpected statement: {kind} '{value}'", token)

    def parse_class(self):
        _, _, line, col = self.consume("DEFINE")
        _, _, _, _ = self.consume("CLASS")
        _, class_name, _, _ = self.consume("ID")
        
        parent_class = None
        if self.peek() and self.peek()[0] == "FROM":
            self.consume("FROM")
            _, parent_class, _, _ = self.consume("ID")
        
        self.consume("COLON")
        body = self.parse_block()
        
        methods = {}
        fields = {}
        
        for stmt in body:
            if stmt[0] == "assign":
                _, field_name, expr, _, _ = stmt
                fields[field_name] = expr
            elif stmt[0] == "func":
                _, method_name, params, method_body, _, _ = stmt
                methods[method_name] = (params, method_body)
        
        return ("class_def", class_name, parent_class, fields, methods, line, col)

    def parse_make(self):
        _, _, line, col = self.consume("MAKE")
        _, var_name, _, _ = self.consume("ID")
        self.consume("ASSIGN")
        _, class_name, _, _ = self.consume("ID")       
        args = []
        kwargs = {}        
        if self.peek() and self.peek()[0] == "LPAREN":
            self.consume("LPAREN")
            if self.peek() and self.peek()[0] != "RPAREN":
                while True:
                    if (
                        self.peek()[0] == "ID"
                        and self.pos + 1 < len(self.tokens)
                        and self.tokens[self.pos + 1][0] == "COLON"
                    ):
                        _, key, _, _ = self.consume("ID")
                        self.consume("COLON")
                        val_expr = self.parse_expression()
                        kwargs[key] = val_expr
                    else:
                        args.append(self.parse_expression())
                    if self.peek() and self.peek()[0] == "COMMA":
                        self.consume("COMMA")
                        continue
                    break
            self.consume("RPAREN")
        
        return ("make_object", var_name, class_name, args, kwargs, line, col)
    
    def parse_method(self):
        _, _, line, col = self.consume("DEFINE")
        _, _, _, _ = self.consume("METHOD")
        _, name, _, _ = self.consume("ID")
        self.consume("LPAREN")
        params = []
        if self.peek() and self.peek()[0] != "RPAREN":
            while True:
                _, pname, _, _ = self.consume("ID")
                params.append(pname)
                if self.peek() and self.peek()[0] == "COMMA":
                    self.consume("COMMA")
                    continue
                break
        self.consume("RPAREN")
        self.consume("COLON")
        self.consume("DO")
        body = self.parse_block()
        return ("func", name, params, body, line, col)

    def parse_try(self):
        _, _, line, col = self.consume("TRY")
        if self.peek() and self.peek()[0] == "LBRACK":
            try_block = self.parse_block()
        else:
            try_block = [self.parse_statement()]
        if not self.peek() or self.peek()[0] != "HANDLE":
            self.error("Expected 'handle' after try block")

        self.consume("HANDLE")

        error_var = None
        if self.peek() and self.peek()[0] == "ID":
            _, error_var, _, _ = self.consume("ID")
        if self.peek() and self.peek()[0] == "LBRACK":
            handle_block = self.parse_block()
        else:
            handle_block = [self.parse_statement()]

        return ("try_handle", try_block, handle_block, error_var, line, col)

    def parse_assignment(self):
        _, _, line, col = self.consume("LET")
        _, var_name, _, _ = self.consume("ID")
        self.consume("ASSIGN")
        expr = self.parse_expression()
        next_token = self.peek()
        if next_token and next_token[2] == line:
            self.error("Unexpected token after expression in assignment", next_token)
        return ("assign", var_name, expr, line, col)

    def parse_constant(self):
        _, _, line, col = self.consume("CONSTANT")
        _, var_name, _, _ = self.consume("ID")
        self.consume("ASSIGN")  # matches both 'be' and '='
        expr = self.parse_expression()
        next_token = self.peek()
        if next_token and next_token[2] == line:
            self.error(
                "Unexpected token after expression in constant definition", next_token
            )
        return ("const", var_name, expr, line, col)

    def parse_print(self):
        _, _, line, col = self.consume("PRINT")
        expr = self.parse_expression()
        if expr is None:
            self.error("Invalid expression in print", self.peek())
        args = [expr]
        while self.peek() and self.peek()[0] == "COMMA":
            self.consume("COMMA")
            expr = self.parse_expression()
            if expr is None:
                self.error("Invalid expression in print", self.peek())
            args.append(expr)

        return ("print", args, line, col)

    def parse_read(self):
        _, _, line, col = self.consume("READ")
        next_token = self.peek()
        if not next_token:
            self.error("Expected type or variable after 'read'")
        next_kind, next_value, next_line, next_col = next_token
        if next_kind in ("INT", "FLOAT", "TEXT", "BOOLEAN"):
            type_kind = self.consume()[0].lower()
            _, var_name, _, _ = self.consume("ID")
            return ("read", var_name, type_kind, line, col)
        elif next_kind == "ID":
            _, var_name, _, _ = self.consume("ID")
            return ("read", var_name, "text", line, col)
        else:
            self.error(
                f"Expected type or variable after 'read', got {next_kind} '{next_value}'",
                next_token,
            )

    def parse_function(self):
        _, _, line, col = self.consume("DEFINE")
        _, name, _, _ = self.consume("ID")
        self.consume("LPAREN")
        params = []
        if self.peek() and self.peek()[0] != "RPAREN":
            while True:
                _, pname, _, _ = self.consume("ID")
                params.append(pname)
                if self.peek() and self.peek()[0] == "COMMA":
                    self.consume("COMMA")
                    continue
                break
        self.consume("RPAREN")
        self.consume("COLON")
        self.consume("DO")
        body = self.parse_block()
        return ("func", name, params, body, line, col)

    def parse_function_literal(self):
        _, _, line, col = self.consume("DEFINE")
        name = None
        self.consume("LPAREN")
        params = []
        if self.peek() and self.peek()[0] != "RPAREN":
            while True:
                _, pname, _, _ = self.consume("ID")
                params.append(pname)
                if self.peek() and self.peek()[0] == "COMMA":
                    self.consume("COMMA")
                    continue
                break
        self.consume("RPAREN")
        self.consume("COLON")
        self.consume("DO")
        body = self.parse_block()

        return ("func_literal", params, body, line, col)

    def parse_return(self):
        _, _, line, col = self.consume("RETURN")
        next_token = self.peek()
        if not next_token or next_token[0] in ("RBRACK", "ELSE", "ELSEIF"):
            expr = ("null", None, line, col)
        else:
            expr = self.parse_expression()
        return ("return", expr, line, col)

    def parse_bring(self):
        _, _, line, col = self.consume("BRING")
        token = self.peek()
        if not token:
            self.error("Expected module path or name after 'bring'")
        kind, val, tline, tcol = token
        path = None
        if kind == "STRING":
            self.consume("STRING")
            path = val[1:-1]
        elif kind == "ID":
            parts = []
            _, id_val, _, _ = self.consume("ID")
            parts.append(id_val)
            while self.peek() and self.peek()[0] == "DOT":
                self.consume("DOT")
                if self.peek() and self.peek()[0] == "ID":
                    _, next_part, _, _ = self.consume("ID")
                    parts.append(next_part)
                else:
                    bad = self.peek()
                    if bad:
                        self.error(
                            f"Invalid module filename after '.', got {bad[0]} '{bad[1]}'",
                            bad,
                        )
                    else:
                        self.error("Invalid module filename after '.'")
            path = ".".join(parts)
        else:
            self.error(
                f"Expected module path or name after 'bring', got {kind} '{val}'", token
            )
        alias = None
        if self.peek() and self.peek()[0] == "AS":
            self.consume("AS")
            _, alias, _, _ = self.consume("ID")
        else:
            alias = os.path.splitext(os.path.basename(path))[0]
        return ("import", path, alias, line, col)
    
    def parse_match(self):
        match_token = self.consume("MATCH")
        _, _, match_line, match_col = match_token
        value_expr = self.parse_expression()
        self.consume("WITH")
        self.consume("LBRACK")
        when_clauses = []
        iteration = 0
        while self.peek() and self.peek()[0] == "WHEN":
            iteration += 1
            # print(f"DEBUG: START WHEN clause #{iteration}, pos={self.pos}")
            self.consume("WHEN")
            # print(f"DEBUG: After consume WHEN, pos={self.pos}")
            token = self.peek()
            # print(f"DEBUG: Token after WHEN: {token}")
            if token[0] in ("NUMBER", "STRING", "TRUE", "FALSE", "ID"):
                kind, val, line, col = token
                self.consume()
                # print(f"DEBUG: Consumed match value, pos={self.pos}")
                if kind == "NUMBER":
                    match_values = [("number", float(val) if "." in val else int(val), line, col)]
                elif kind == "STRING":
                    match_values = [("string", val[1:-1], line, col)]
                elif kind == "TRUE":
                    match_values = [("boolean", True, line, col)]
                elif kind == "FALSE":
                    match_values = [("boolean", False, line, col)]
                elif kind == "ID":
                    match_values = [("var", val, line, col)]
            else:
                self.error(f"Expected match value, got {token[0]}")
            # print(f"DEBUG: Before OR loop, pos={self.pos}, peek={self.peek()}")
            while self.peek() and self.peek()[0] == "OR":
                # print(f"DEBUG: In OR loop, pos={self.pos}")
                self.consume("OR")
                token = self.peek()
                if token[0] in ("NUMBER", "STRING", "TRUE", "FALSE", "ID"):
                    kind, val, line, col = token
                    self.consume()
                    if kind == "NUMBER":
                        match_values.append(("number", float(val) if "." in val else int(val), line, col))
                    elif kind == "STRING":
                        match_values.append(("string", val[1:-1], line, col))
                    elif kind == "TRUE":
                        match_values.append(("boolean", True, line, col))
                    elif kind == "FALSE":
                        match_values.append(("boolean", False, line, col))
                    elif kind == "ID":
                        match_values.append(("var", val, line, col))
                else:
                    self.error(f"Expected match value after OR, got {token[0]}")
            # print(f"DEBUG: Before consume THEN, pos={self.pos}, peek={self.peek()}")
            self.consume("THEN")
            # print(f"DEBUG: After consume THEN, pos={self.pos}, peek={self.peek()}")
            if self.peek() and self.peek()[0] == "LBRACK":
                # print(f"DEBUG: Calling parse_block(), pos={self.pos}")
                body = self.parse_block()
                # print(f"DEBUG: Returned from parse_block(), pos={self.pos}, body length={len(body)}")
                if not body:
                    self.error("Block cannot be empty")
            else:
                # print("DEBUG: NOT calling parse_block, calling parse_statement instead")
                body = [self.parse_statement()]
            when_clauses.append(("when_case", match_values, body))
            # print(f"DEBUG: END WHEN clause #{iteration}, pos={self.pos}, peek={self.peek()}")
        # print(f"DEBUG: Exited WHEN loop, pos={self.pos}, peek={self.peek()}")
        otherwise_body = None
        if self.peek() and self.peek()[0] == "OTHERWISE":
            self.consume("OTHERWISE")
            if self.peek() and self.peek()[0] == "LBRACK":
                otherwise_body = self.parse_block()
                if not otherwise_body:
                    self.error("Block cannot be empty")
            else:
                otherwise_body = [self.parse_statement()]
        self.consume("RBRACK")
        
        return ("match_stmt", value_expr, when_clauses, otherwise_body, match_line, match_col)


    def parse_if(self):
        _, _, line, col = self.consume("IF")
        condition = self.parse_logic_condition()
        self.consume("THEN")

        if self.peek() and self.peek()[0] == "LBRACK":
            then_branch = self.parse_block()
            if not then_branch:
                self.error("Block cannot be empty")
        else:
            then_branch = [self.parse_statement()]

        else_branch = None
        if self.peek() and self.peek()[0] == "ELSEIF":
            else_branch = [self.parse_elseif()]
        elif self.peek() and self.peek()[0] == "ELSE":
            self.consume("ELSE")
            if self.peek() and self.peek()[0] == "LBRACK":
                else_branch = self.parse_block()
                if not else_branch:
                    self.error("Block cannot be empty")
            else:
                else_branch = [self.parse_statement()]

        return ("if", condition, then_branch, else_branch, line, col)

    def parse_elseif(self):
        _, _, line, col = self.consume("ELSEIF")
        condition = self.parse_logic_condition()
        self.consume("THEN")

        if self.peek() and self.peek()[0] == "LBRACK":
            then_branch = self.parse_block()
        else:
            then_branch = [self.parse_statement()]

        else_branch = None
        if self.peek() and self.peek()[0] == "ELSEIF":
            else_branch = [self.parse_elseif()]
        elif self.peek() and self.peek()[0] == "ELSE":
            self.consume("ELSE")
            if self.peek() and self.peek()[0] == "LBRACK":
                else_branch = self.parse_block()
            else:
                else_branch = [self.parse_statement()]

        return ("if", condition, then_branch, else_branch, line, col)

    def parse_loop(self):
        _, _, line, col = self.consume("REPEAT")
        loop_token = self.peek()
        if not loop_token:
            self.error("Expected 'while' or 'from' after 'repeat'")
        loop_kind, loop_val, loop_line, loop_col = loop_token

        if loop_kind == "WHILE":
            self.consume("WHILE")
            condition = self.parse_logic_condition()
            self.consume("COLON")
            self.consume("DO")
            block = self.parse_block()
            if not block:
                self.error("Block cannot be empty", loop_token)
            return ("while", condition, block, line, col)

        elif loop_kind == "FROM":
            self.consume("FROM")
            _, loop_var, _, _ = self.consume("ID")
            self.consume("ASSIGN")
            start = self.parse_expression()
            self.consume("TO")
            end = self.parse_expression()
            self.consume("COLON")
            self.consume("DO")
            block = self.parse_block()
            if not block:
                self.error("Block cannot be empty", loop_token)
            return ("for", loop_var, start, end, block, line, col)

        elif loop_kind == "ID":
            _, loop_var, _, _ = self.consume("ID")
            next_tok = self.peek()
            if not next_tok or next_tok[0] != "FROM":
                self.error("Expected 'from' after loop variable in 'repeat'", next_tok)
            self.consume("FROM")
            container_expr = self.parse_expression()
            self.consume("COLON")
            self.consume("DO")
            block = self.parse_block()
            if not block:
                self.error("Block cannot be empty", loop_token)
            return ("for_each", loop_var, container_expr, block, line, col)
        else:
            self.error(
                f"Expected 'while' or 'from' after 'repeat', got {loop_kind} '{loop_val}'",
                loop_token,
            )

    def parse_block(self):
        stmts = []
        self.consume("LBRACK")
        while self.peek() and self.peek()[0] != "RBRACK":
            stmts.append(self.parse_statement())
        if self.peek() is not None and self.peek()[0] == "RBRACK":
            self.consume("RBRACK")
        else:
            bad = self.peek()
            if bad:
                self.error(f"Expected ']' to close block, got {bad[0]} '{bad[1]}'", bad)
            else:
                self.error("Expected ']' to close block")
        return stmts

    # ----- File I/O parsing -----
    def parse_open(self):
        _, _, line, col = self.consume("OPEN")
        token = self.peek()
        if not token:
            self.error("Expected file path string after 'open'")
        kind, val, tline, tcol = token
        if kind != "STRING":
            self.error(
                f"Expected file path string after 'open', got {kind} '{val}'", token
            )
        self.consume("STRING")
        path = val[1:-1]
        mode = "r"
        handle = None
        if self.peek() and self.peek()[0] == "AS":
            self.consume("AS")
            _, handle, _, _ = self.consume("ID")
        else:
            self.error("Expected 'as <handle>' after open path", token)
        if self.peek() and self.peek()[0] == "FOR":
            self.consume("FOR")
            mode_kind = self.peek()[0]
            if mode_kind == "READ":
                self.consume("READ")
                mode = "r"
            elif mode_kind == "WRITE":
                self.consume("WRITE")
                mode = "w"
            elif mode_kind == "APPEND":
                self.consume("APPEND")
                mode = "a"
            else:
                self.error("Unknown file mode after 'for'", self.peek())
        return ("open", path, handle, mode, line, col)

    def parse_close(self):
        _, _, line, col = self.consume("CLOSE")
        _, handle, _, _ = self.consume("ID")
        return ("close", handle, line, col)

    def parse_readline(self):
        _, _, line, col = self.consume("READLINE")
        _, handle, _, _ = self.consume("ID")
        if self.peek() and self.peek()[0] == "INTO":
            self.consume("INTO")
            _, varname, _, _ = self.consume("ID")
            return ("readline", handle, varname, line, col)
        else:
            self.error("Expected 'into <var>' after 'readline <handle>'")

    def parse_writeline(self):
        _, _, line, col = self.consume("WRITELINE")
        _, handle, _, _ = self.consume("ID")
        if self.peek() and self.peek()[0] == "WITH":
            self.consume("WITH")
            expr = self.parse_expression()
            return ("writeline", handle, expr, line, col)
        else:
            self.error("Expected 'with <expression>' after 'writeline <handle>'")

    # ----- Expressions -----

    def parse_expression(self):
        return self.parse_logic_condition()

    def parse_addition(self):
        left = self.parse_term()
        while True:
            pk = self.peek()
            if not pk:
                break
            kind, val, line, col = pk
            if kind == "OP" and val in ("+", "-"):
                self.consume()
                right = self.parse_term()
                left = ("binop", val, left, right, line, col)
            elif kind == "PLUS":
                self.consume()
                right = self.parse_term()
                left = ("binop", "plus", left, right, line, col)
            elif kind == "MINUS":
                self.consume()
                right = self.parse_term()
                left = ("binop", "minus", left, right, line, col)
            else:
                break
        return left

    def parse_term(self):
        return self.parse_multiplicative()

    def parse_exponent(self):
        left = self.parse_factor()
        while True:
            pk = self.peek()
            if not pk:
                break
            kind, val, line, col = pk
            if kind == "POWOP" or kind == "EXPO":
                self.consume()
                right = self.parse_factor()
                left = ("binop", "**", left, right, line, col)
            else:
                break
        return left

    def parse_multiplicative(self):
        left = self.parse_exponent()
        while True:
            pk = self.peek()
            if not pk:
                break
            kind, val, line, col = pk
            if kind == "OP" and val in ("*", "/"):
                self.consume()
                right = self.parse_factor()
                left = ("binop", val, left, right, line, col)
            elif kind == "MUL":
                self.consume()
                right = self.parse_factor()
                left = ("binop", "mul", left, right, line, col)
            elif kind == "DIV":
                self.consume()
                right = self.parse_factor()
                left = ("binop", "div", left, right, line, col)
            elif kind == "FDIV":
                self.consume()
                right = self.parse_factor()
                left = ("binop", "//", left, right, line, col)
            elif kind == "PERCENT" or kind == "MOD":
                self.consume()
                right = self.parse_exponent()
                left = ("binop", "%", left, right, line, col)
            else:
                break
        return left

    def parse_factor(self):
        pk = self.peek()
        if not pk:
            self.error("Unexpected end of input in expression")
        kind, value, line_num, col_num = pk

        # Unary minus
        if kind == "OP" and value == "-":
            self.consume("OP")
            expr = self.parse_factor()
            return ("neg", expr, line_num, col_num)

        # NOT
        if kind == "NOT":
            self.consume("NOT")
            expr = self.parse_factor()
            return ("logicnot", expr, line_num, col_num)

        if kind == "NUMBER":
            self.consume("NUMBER")
            if "." in value:
                return ("number", float(value), line_num, col_num)
            else:
                return ("number", int(value), line_num, col_num)

        elif kind == "STRING":
            self.consume("STRING")
            node = ("string", value[1:-1], line_num, col_num)
            while True:
                pk2 = self.peek()
                if not pk2:
                    break
                kind2, val2, m_line, m_col = pk2
                
                if kind2 == "DOT":
                    self.consume("DOT")
                    next_token = self.peek()
                    if not next_token:
                        self.error("Expected identifier after '.'")
                    kind3, attr_name, a_line, a_col = next_token
                    self.consume()
                    
                    if self.peek() and self.peek()[0] == "LPAREN":
                        self.consume("LPAREN")
                        args = []
                        kwargs = {}
                        if self.peek() and self.peek()[0] != "RPAREN":
                            while True:
                                if (
                                    self.peek()[0] == "ID"
                                    and self.pos + 1 < len(self.tokens)
                                    and self.tokens[self.pos + 1][0] == "COLON"
                                ):
                                    _, key, _, _ = self.consume("ID")
                                    self.consume("COLON")
                                    val_expr = self.parse_expression()
                                    kwargs[key] = val_expr
                                else:
                                    args.append(self.parse_expression())
                                if self.peek() and self.peek()[0] == "COMMA":
                                    self.consume("COMMA")
                                    continue
                                break
                        self.consume("RPAREN")
                        node = ("method", node, attr_name, args, kwargs, a_line, a_col)
                    else:
                        node = ("prop", node, attr_name, a_line, a_col)
                    continue
                break
            
            return node

        elif kind == "NULL":
            self.consume("NULL")
            return ("null", None, line_num, col_num)

        elif kind == "TRUE":
            self.consume("TRUE")
            return ("boolean", True, line_num, col_num)

        elif kind == "FALSE":
            self.consume("FALSE")
            return ("boolean", False, line_num, col_num)

        elif kind == "LBRACK":
            # List literal: [a, b, c]
            self.consume("LBRACK")
            items = []
            while self.peek() and self.peek()[0] != "RBRACK":
                items.append(self.parse_expression())
                if self.peek() and self.peek()[0] == "COMMA":
                    self.consume("COMMA")
            self.consume("RBRACK")
            return ("list", items, line_num, col_num)

        elif kind == "LBRACE":
            # Dict literal: { key: value, ... }
            self.consume("LBRACE")
            pairs = []
            while self.peek() and self.peek()[0] != "RBRACE":
                pk2 = self.peek()
                if not pk2:
                    self.error("Unexpected end of input in dict literal")
                pk_kind, pk_val, pk_line, pk_col = pk2
                if pk_kind == "STRING":
                    self.consume("STRING")
                    key = pk_val[1:-1]
                elif pk_kind == "NUMBER":
                    self.consume("NUMBER")
                    key = float(pk_val) if "." in pk_val else int(pk_val)
                elif pk_kind == "ID":
                    self.consume("ID")
                    key = pk_val
                else:
                    self.error(f"Invalid dictionary key: {pk_kind} '{pk_val}'", pk2)
                self.consume("COLON")
                val_expr = self.parse_expression()
                pairs.append((key, val_expr))
                if self.peek() and self.peek()[0] == "COMMA":
                    self.consume("COMMA")
            self.consume("RBRACE")
            return ("dict", pairs, line_num, col_num)

        elif kind == "DEFINE":
            return self.parse_function_literal()
        
        elif kind == "SELF":
            _, _, line, col = self.consume("SELF")
            node = ("self_expr", line, col)
            while True:
                pk2 = self.peek()
                if not pk2:
                    break
                kind2, val2, m_line, m_col = pk2
                
                if kind2 == "DOT":
                    self.consume("DOT")
                    nexttoken = self.peek()
                    if not nexttoken:
                        self.error("Expected identifier after '.'")
                    kind3, attr_name, a_line, a_col = nexttoken
                    self.consume()
                    if self.peek() and self.peek()[0] == "LPAREN":
                        self.consume("LPAREN")
                        args = []
                        kwargs = {}
                        if self.peek() and self.peek()[0] != "RPAREN":
                            while True:
                                if (
                                    self.peek()[0] == "ID"
                                    and self.pos + 1 < len(self.tokens)
                                    and self.tokens[self.pos + 1][0] == "COLON"
                                ):
                                    _, key, _, _ = self.consume("ID")
                                    self.consume("COLON")
                                    val_expr = self.parse_expression()
                                    kwargs[key] = val_expr
                                else:
                                    args.append(self.parse_expression())
                                if self.peek() and self.peek()[0] == "COMMA":
                                    self.consume("COMMA")
                                    continue
                                break
                        self.consume("RPAREN")
                        node = ("method", node, attr_name, args, kwargs, a_line, a_col)
                    else:
                        node = ("prop", node, attr_name, a_line, a_col)
                    continue
                break
            
            return node

        elif kind == "ID":
            _, name, line, col = self.consume("ID")
            node = ("var", name, line, col)

            while True:
                pk2 = self.peek()
                if not pk2:
                    break
                kind2, val2, m_line, m_col = pk2

                if kind2 == "LBRACK":
                    self.consume("LBRACK")
                    start_expr = None
                    stop_expr = None
                    step_expr = None
                    if self.peek() and self.peek()[0] != "COLON":
                        start_expr = self.parse_expression()
                    if self.peek() and self.peek()[0] == "COLON":
                        self.consume("COLON")
                        if self.peek() and self.peek()[0] != "COLON" and self.peek()[0] != "RBRACK":
                            stop_expr = self.parse_expression()
                        if self.peek() and self.peek()[0] == "COLON":
                            self.consume("COLON")
                            if self.peek() and self.peek()[0] != "RBRACK":
                                step_expr = self.parse_expression()
                        self.consume("RBRACK")
                        node = ("slice", node, start_expr, stop_expr, step_expr, m_line, m_col)
                    else:
                        self.consume("RBRACK")
                        node = ("index", node, start_expr, m_line, m_col)
                    continue

                if kind2 == "DOT":
                    self.consume("DOT")
                    next_token = self.peek()
                    if not next_token:
                        self.error("Expected identifier after '.'")
                    kind3, attr_name, a_line, a_col = next_token
                    self.consume()

                    if self.peek() and self.peek()[0] == "LPAREN":
                        self.consume("LPAREN")
                        args = []
                        kwargs = {}
                        if self.peek() and self.peek()[0] != "RPAREN":
                            while True:
                                if (
                                    self.peek()[0] == "ID"
                                    and self.pos + 1 < len(self.tokens)
                                    and self.tokens[self.pos + 1][0] == "COLON"
                                ):
                                    _, key, _, _ = self.consume("ID")
                                    self.consume("COLON")
                                    val_expr = self.parse_expression()
                                    kwargs[key] = val_expr
                                else:
                                    args.append(self.parse_expression())
                                if self.peek() and self.peek()[0] == "COMMA":
                                    self.consume("COMMA")
                                    continue
                                break
                        self.consume("RPAREN")
                        node = ("method", node, attr_name, args, kwargs, a_line, a_col)
                    else:
                        node = ("prop", node, attr_name, a_line, a_col)
                    continue

                if kind2 == "LPAREN":
                    self.consume("LPAREN")
                    args = []
                    kwargs = {}
                    if self.peek() and self.peek()[0] != "RPAREN":
                        while True:
                            if (
                                self.peek()[0] == "ID"
                                and self.pos + 1 < len(self.tokens)
                                and self.tokens[self.pos + 1][0] == "COLON"
                            ):
                                _, key, _, _ = self.consume("ID")
                                self.consume("COLON")
                                val_expr = self.parse_expression()
                                kwargs[key] = val_expr
                            else:
                                args.append(self.parse_expression())
                            if self.peek() and self.peek()[0] == "COMMA":
                                self.consume("COMMA")
                                continue
                            break
                    self.consume("RPAREN")
                    node = ("call", node, args, kwargs, m_line, m_col)
                    continue

                break

            return node

        elif kind == "LPAREN":
            self.consume("LPAREN")
            pk2 = self.peek()
            if pk2 and pk2[0] == "DEFINE":
                func_node = self.parse_function_literal()
                self.consume("RPAREN")
                return func_node
            expr = self.parse_expression()
            self.consume("RPAREN")
            return expr

        else:
            self.error(f"Unexpected term: {kind} '{value}'", pk)

    def parse_logic_condition(self):
        pk = self.peek()
        if pk and pk[0] == "NOT":
            _, _, line, col = self.consume("NOT")
            cond = self.parse_logic_condition()
            return ("logicnot", cond, line, col)

        node = self.parse_comparison()
        while self.peek() and self.peek()[0] in ["AND", "OR"]:
            log_kind, log_op, line, col = self.consume()
            right = self.parse_comparison()
            node = ("logicop", log_kind.lower(), node, right, line, col)
        return node

    def parse_comparison(self):
        left = self.parse_addition()
        pk = self.peek()
        if not pk:
            return left

        kind, val, line, col = pk

        # if kind == 'NOT':
        #     if self.pos + 1 < len(self.tokens) and self.tokens[self.pos+1][0] in ('EQUALS', 'EQ') == 'NULL':
        #         self.consume('NOT')
        #         self.consume(self.tokens[self.pos][0])
        #         right = self.parse_addition()
        #         return ('compare', '!=', left, right, line, col)

        if kind in (
            "LESS",
            "GREATER",
            "EQUALS",
            "NOTEQUALS",
            "GTE",
            "LTE",
            "EQ",
            "NEQ",
            "GT",
            "LT",
        ):
            op_kind, op, line, col = self.consume()
            right = self.parse_addition()
            mapping = {
                "LESS": "<",
                "GREATER": ">",
                "EQUALS": "==",
                "EQ": "==",
                "NOTEQUALS": "!=",
                "NEQ": "!=",
                "GTE": ">=",
                "LTE": "<=",
                "GT": ">",
                "LT": "<",
            }

            return ("compare", mapping[op_kind], left, right, line, col)
        return left


# ================= CONTROL FLOW EXCEPTIONS =======================


class ContinueException(Exception):
    pass


class BreakException(Exception):
    pass


class _ReturnException(Exception):
    def __init__(self, value):
        self.value = value


# ================= INTERPRETER =======================


class Interpreter:
    def __init__(self, main_file_path=None):
        self.scopes = [{}]
        self.const_scopes = [set()]
        self.files = {}
        self.functions = {}
        self.classes = {}
        self.objects = {}
        self.module_cache = {}
        self.brought_paths = set()

        # for error reporting
        self.current_line = 1
        self.current_col = 1
        self.source_lines = []
        self.main_file_path = main_file_path or "<stdin>"
        self.file_stack = [self.main_file_path]
        self.file_source_map = {self.main_file_path: self.source_lines}

        if main_file_path:
            self.main_file_dir = os.path.dirname(os.path.abspath(main_file_path))
        else:
            self.main_file_dir = os.getcwd()

        # Module search paths
        self.module_search_paths = self._get_default_search_paths()

        def el_substring(s, start, length):
            if not isinstance(s, str):
                return ""
            if not isinstance(start, int) or not isinstance(length, int):
                return ""
            if start < 0:
                start = 0
            if length < 0:
                return ""
            end = start + length
            return s[start:end]

        def el_char_at(s, index):
            if not isinstance(s, str) or not isinstance(index, int):
                return ""
            if index < 0 or index >= len(s):
                return ""
            return s[index]

        # built-in functions
        self.builtins = {
            # math
            "_primitive_sin": lambda x: math.sin(x),
            "_primitive_cos": lambda x: math.cos(x),
            "_primitive_tan": lambda x: math.tan(x),
            "_primitive_sqrt": lambda x: math.sqrt(x),
            "_primitive_pow": lambda x, y: math.pow(x, y),
            "_primitive_floor": lambda x: math.floor(x),
            "_primitive_ceil": lambda x: math.ceil(x),
            "_primitive_abs": lambda x: abs(x),
            # logarithms/exponentials
            "_primitive_log": lambda x: math.log(x),
            "_primitive_log10": lambda x: math.log10(x),
            "_primitive_exp": lambda x: math.exp(x),
            # inverse trig and hyperbolic
            "_primitive_asin": lambda x: math.asin(x),
            "_primitive_acos": lambda x: math.acos(x),
            "_primitive_atan": lambda x: math.atan(x),
            "_primitive_atan2": lambda y, x: math.atan2(y, x),
            "_primitive_asinh": lambda x: math.asinh(x),
            "_primitive_acosh": lambda x: math.acosh(x),
            "_primitive_atanh": lambda x: math.atanh(x),
            "_primitive_sinh": lambda x: math.sinh(x),
            "_primitive_cosh": lambda x: math.cosh(x),
            "_primitive_tanh": lambda x: math.tanh(x),
            "_primitive_hypot": lambda *args: math.hypot(*args),
            "_primitive_degrees": lambda x: math.degrees(x),
            "_primitive_radians": lambda x: math.radians(x),
            # RNG control
            "_primitive_seed": lambda n: random.seed(int(n)),
            # rounding
            "_primitive_round": lambda x, ndigits=None: round(x)
            if ndigits is None
            else round(x, int(ndigits)),
            # random utilities
            "_primitive_random": lambda: random.random(),
            "_primitive_randint": lambda a, b: random.randint(int(a), int(b)),
            # conversions
            "str": lambda x: str(x),
            "int": lambda x: int(x),
            "float": lambda x: float(x),
            # length for strings/lists/dicts
            "_primitive_len": lambda x: len(x),
            # string utilities
            "_primitive_upper": lambda s: s.upper(),
            "_primitive_lower": lambda s: s.lower(),
            "_primitive_strip": lambda s: s.strip(),
            "_primitive_split": lambda s, sep=None: s.split(sep)
            if sep is not None
            else s.split(),
            "_primitive_substring": el_substring,
            "_primitive_char_at": el_char_at,
            # join: join(separator, list)
            "_primitive_join": lambda sep, lst: sep.join([str(i) for i in lst]),
            "_primitive_contains": lambda s, sub: sub in s,
            # range inclusive: range(start, end)
            "range": lambda a, b: list(range(int(a), int(b) + 1)),
            # time utilities
            "_primitive_sleep": lambda s: time.sleep(float(s)),
            "_primitive_timestamp": lambda: time.time(),
            # datetime utilities
            "_primitive_now_datetime": lambda: datetime.now(),
            "_primitive_today_date": lambda: date.today(),
            # ---- system primitives ----
            "_sys_args_primitive": lambda: list(sys.argv),
            "_sys_env_primitive": lambda: dict(os.environ),
            "_sys_getenv_primitive": lambda k, default=None: os.environ.get(
                str(k), default
            ),
            "_sys_setenv_primitive": lambda k, v: os.environ.__setitem__(str(k), str(v))
            or None,
            "_sys_cwd_primitive": lambda: os.getcwd(),
            "_sys_chdir_primitive": lambda path: os.chdir(path) or None,
            "_sys_exit_primitive": lambda code=0: sys.exit(int(code)),
            "_sys_exec_primitive": lambda cmd, args=None: subprocess.run(
                [cmd] + (args or []),
                capture_output=True,
                text=True,
                shell=False,
                check=False,
            ),
            "_sys_platform_primitive": lambda: platform.system(),
            "_sys_which_primitive": lambda cmd: shutil.which(cmd),
        }
        self.global_vars = self.scopes[0]

    @property
    def variables(self):
        return self.scopes[-1]

    def _interpolate_string(self, s, line, col):
        result = []
        i = 0
        n = len(s)
        while i < n:
            ch = s[i]
            if ch == "{":
                if i + 1 < n and s[i + 1] == "{":
                    result.append("{")
                    i += 2
                    continue
                j = i + 1
                expr_text = []
                while j < n:
                    if s[j] == "}":
                        break
                    if s[j] == "{" and j + 1 < n and s[j + 1] == "{":
                        expr_text.append("{")
                        j += 2
                        continue
                    expr_text.append(s[j])
                    j += 1
                if j >= n:
                    self.runtime_error(
                        "Unclosed '{' in interpolated string",
                        (self.file_stack[-1], line, col),
                    )
                inner = "".join(expr_text).strip()
                if not inner:
                    self.runtime_error(
                        "Empty {} in interpolated string",
                        (self.file_stack[-1], line, col),
                    )
                tokens = lexer(inner)
                parser = Parser(tokens, self.file_stack[-1])
                expr_ast = parser.parse_expression()
                value = self.eval_expr(expr_ast)
                result.append("" if value is None else str(value))
                i = j + 1
            elif ch == "}" and i + 1 < n and s[i + 1] == "}":
                result.append("}")
                i += 2
            else:
                result.append(ch)
                i += 1
        return "".join(result)

    def _wrap_python_module(self, module):
        """
        Convert a Python module/object into an ELANG-accessible namespace (dict).
        Methods and attributes become callable or readable from ELANG.
        """
        ns = {}

        for name in dir(module):
            if name.startswith("_"):
                continue

            attr = getattr(module, name)

            if callable(attr):

                def make_wrapper(a):
                    return lambda *args: a(*args)

                ns[name] = make_wrapper(attr)
            else:
                ns[name] = attr

        ns["__pyobj__"] = module
        return ns

    def runtime_error(self, message, value=""):
        """Helper to raise structured runtime errors with location."""
        raise RuntimeError(
            (message, self.current_file, self.current_line, self.current_col)
        )

    def push_scope(self, initial=None):
        if initial is None:
            initial = {}
        self.scopes.append(initial)
        self.const_scopes.append(set())
        return initial

    def pop_scope(self):
        if len(self.scopes) == 1:
            self.runtime_error("Cannot pop global scope")
        self.const_scopes.pop()
        return self.scopes.pop()

    def get_var(self, name):
        for scope in reversed(self.scopes):
            if name in scope:
                return scope[name]
        self.runtime_error(f"Variable '{name}' not found")

    def _call_function(self, fname, args):
        if fname not in self.functions:
            self.runtime_error(f"Function '{fname}' not defined in module")
        params, body = self.functions[fname]
        if len(args) != len(params):
            self.runtime_error(
                f"Function '{fname}' expected {len(params)} args, got {len(args)}"
            )
        local_vars = dict(zip(params, args))
        self.push_scope(local_vars)
        try:
            ret = None
            for stmt in body:
                try:
                    self.execute_node(stmt)
                except _ReturnException as re:
                    ret = re.value
                    break
            return ret
        finally:
            self.pop_scope()

    def load_module(self, filepath):
        candidates = self._resolve_module_path(filepath)
        actual_path = None
        for candidate in candidates:
            if os.path.exists(candidate):
                actual_path = candidate
                break

        if not actual_path:
            self.runtime_error(
                f"Module file not found: {filepath} (tried: {', '.join(candidates)})"
            )

        abs_path = os.path.abspath(actual_path)
        if abs_path in self.module_cache:
            return self.module_cache[abs_path]

        try:
            with open(abs_path, "r", encoding="utf-8") as f:
                source = f.read()
        except Exception as e:
            self.runtime_error(f"Failed to read module file {abs_path}: {e}")

        source_lines = source.splitlines()
        self.file_source_map[actual_path] = source_lines

        self.file_stack.append(actual_path)
        self.file_source_map["__stack__"] = self.file_stack[:]

        try:
            tokens = lexer(source)
            parser = Parser(tokens, actual_path)
            ast = parser.parse()

            mod_interp = Interpreter(main_file_path=actual_path)
            mod_interp.source_lines = source_lines
            mod_interp.file_stack = self.file_stack[:] + [actual_path]
            mod_interp.file_source_map = self.file_source_map
            mod_interp.builtins = self.builtins
            mod_interp.interpret(ast)

        finally:
            self.file_stack.pop()
            self.file_source_map["__stack__"] = self.file_stack[:]

        namespace = {}
        for k, v in mod_interp.scopes[0].items():
            namespace[k] = v

        for fname in mod_interp.functions.keys():

            def make_wrapper(fnm, mod_interpreter):
                def wrapper(*args):
                    try:
                        return mod_interpreter._call_function(fnm, args)
                    except RuntimeError as re:
                        raise re
                    except TypeError as te:
                        raise RuntimeError(
                            (
                                f"Module function '{fnm}' called with wrong arguments: {te}",
                                "",
                                1,
                                1,
                            )
                        )
                    except Exception as e:
                        raise RuntimeError(
                            (f"Error in module function '{fnm}': {e}", "", 1, 1)
                        )

                return wrapper

            namespace[fname] = make_wrapper(fname, mod_interp)

        self.module_cache[abs_path] = namespace
        return namespace

    def _get_default_search_paths(self):
        paths = []
        paths.append(self.main_file_dir)
        paths.append(os.getcwd())

        elang_path = os.environ.get("ELANGPATH")
        if elang_path:
            for path in elang_path.split(os.pathsep):
                if path.strip():
                    paths.append(path.strip())

        home_dir = os.path.expanduser("~")
        paths.append(os.path.join(home_dir, ".elang", "modules"))
        paths.append(os.path.join(home_dir, "elang_modules"))

        interpreter_dir = os.path.dirname(os.path.abspath(__file__))
        paths.append(os.path.join(interpreter_dir, "modules"))
        paths.append(os.path.join(interpreter_dir, "lib"))

        if os.name == "nt":
            program_files = os.environ.get("PROGRAMFILES", "C:\\Program Files")
            paths.append(os.path.join(program_files, "EasyLang", "modules"))
        else:
            paths.append("/usr/local/lib/elang/modules")
            paths.append("/usr/lib/elang/modules")

        seen = set()
        unique_paths = []
        for path in paths:
            abs_path = os.path.abspath(path)
            if abs_path not in seen and os.path.exists(abs_path):
                seen.add(abs_path)
                unique_paths.append(abs_path)

        return unique_paths

    def add_search_path(self, path):
        abs_path = os.path.abspath(path)
        if os.path.exists(abs_path) and abs_path not in self.module_search_paths:
            self.module_search_paths.insert(0, abs_path)

    def _resolve_module_path(self, filepath):
        candidates = []
        if os.path.isabs(filepath):
            candidates.append(filepath)
            if not filepath.endswith((".elang", ".elangh")):
                candidates.append(filepath + ".elangh")
                candidates.append(filepath + ".elang")
        else:
            for search_path in self.module_search_paths:
                candidate = os.path.join(search_path, filepath)
                candidates.append(candidate)
                if not filepath.endswith((".elang", ".elangh")):
                    candidates.append(candidate + ".elangh")
                    candidates.append(candidate + ".elang")

                modules_candidate = os.path.join(search_path, "modules", filepath)
                candidates.append(modules_candidate)
                if not filepath.endswith((".elang", ".elangh")):
                    candidates.append(modules_candidate + ".elangh")
                    candidates.append(modules_candidate + ".elang")
        return candidates

    def set_var(self, name, value, local=True):
        if local:
            if name in self.const_scopes[-1]:
                self.runtime_error(f"Cannot assign to constant '{name}'")
            self.scopes[-1][name] = value
        else:
            if name in self.const_scopes[0]:
                self.runtime_error(f"Cannot assign to constant '{name}'")
            self.scopes[0][name] = value

    def define_const(self, name, value, local=True):
        if local:
            self.scopes[-1][name] = value
            self.const_scopes[-1].add(name)
        else:
            self.scopes[0][name] = value
            self.const_scopes[0].add(name)

    def interpret(self, ast):
        for node in ast:
            try:
                self.execute_node(node)
            except _ReturnException:
                # Top level return = stops executing the script
                return

    def execute_node(self, node):
        node_type = node[0]
        if len(node) >= 3:
            self.current_line = node[-2]
            self.current_col = node[-1]
            self.current_file = self.file_stack[-1]

        if node_type == "assign":
            _, var_name, expr, _, _ = node
            value = self.eval_expr(expr)
            if var_name == "self":
                self.runtime_error("Cannot assign to 'self' directly")
            self.set_var(var_name, value)

        elif node_type == "self_assign":
            _, field_name, value_expr, line, col = node
            self.current_line, self.current_col = line, col
            value = self.eval_expr(value_expr)            
            self_obj = None
            for scope in reversed(self.scopes):
                if "self" in scope:
                    self_obj = scope["self"]
                    break
            if self_obj is None or not isinstance(self_obj, dict):
                self.runtime_error("'self' is not available in this context")

            self_obj[field_name] = value

        elif node_type == "assign_index":
            _, var_name, idx_expr, value_expr, _, _ = node
            container = self.get_var(var_name)
            idx = self.eval_expr(idx_expr)
            value = self.eval_expr(value_expr)
            if isinstance(container, list):
                if not isinstance(idx, int):
                    self.runtime_error(
                        f"List index must be integer, got {type(idx).__name__}"
                    )
                if idx < 0 or idx >= len(container):
                    self.runtime_error(f"List index out of range: {idx}")
                container[idx] = value
            elif isinstance(container, dict):
                container[idx] = value
            else:
                self.runtime_error(
                    f"Cannot assign to index of type {type(container).__name__} for variable '{var_name}'"
                )

        elif node_type == "assign_slice":
            _, var_name, start_expr, stop_expr, step_expr, value_expr, _, _ = node
            container = self.get_var(var_name)
            value = self.eval_expr(value_expr)
            start = self.eval_expr(start_expr) if start_expr else None
            stop = self.eval_expr(stop_expr) if stop_expr else None
            step = self.eval_expr(step_expr) if step_expr else None
            if not isinstance(container, list):
                self.runtime_error(f"Slice assignment only works on lists, got {type(container).__name__}")
            if start is not None and not isinstance(start, int):
                self.runtime_error(f"Slice start must be integer, got {type(start).__name__}")
            if stop is not None and not isinstance(stop, int):
                self.runtime_error(f"Slice stop must be integer, got {type(stop).__name__}")
            if step is not None and not isinstance(step, int):
                self.runtime_error(f"Slice step must be integer, got {type(step).__name__}")
            if step is not None and step == 0:
                self.runtime_error("Slice step cannot be zero")
            if isinstance(value, str):
                value = list(value)
            elif not isinstance(value, list):
                self.runtime_error(f"Right side of slice assignment must be list or string, got {type(value).__name__}")
            if step is None or step == 1:
                container[start:stop] = value
            else:
                indices = list(range(len(container)))[start:stop:step]
                if len(indices) != len(value):
                    self.runtime_error(
                        f"Stepped slice assignment: {len(indices)} positions but {len(value)} values provided"
                    )
                for idx, val in zip(indices, value):
                    container[idx] = val

        elif node_type == "const":
            _, name, expr, line, col = node
            self.current_line, self.current_col = line, col
            value = self.eval_expr(expr)
            if name in self.const_scopes[-1]:
                self.runtime_error(
                    f"Constant '{name}' is already defined in this scope"
                )
            self.define_const(name, value, local=True)

        elif node_type == "print":
            _, args, _, _ = node
            out = ""
            for i, a in enumerate(args):
                v = self.eval_expr(a)
                if v is None:
                    v = "Null"
                if isinstance(v, float):
                    v = f"{v:.2f}"
                v = str(v)

                if i > 0 and not out.endswith(" "):
                    out += " "
                out += v
            print(out)

        elif node_type == "open":
            _, path, handle, mode, _, _ = node
            try:
                if mode == "r":
                    f = open(path, "r", encoding="utf-8")
                elif mode == "w":
                    f = open(path, "w", encoding="utf-8")
                elif mode == "a":
                    f = open(path, "a", encoding="utf-8")
                else:
                    self.runtime_error(f"Unknown file mode: {mode}")
            except Exception as e:
                self.runtime_error(f"Failed to open file {path}: {e}")
            self.files[handle] = f

        elif node_type == "class_def":
            _, class_name, parent_class, fields, methods, _, _ = node
            self.classes[class_name] = {
                "parent": parent_class,
                "fields": fields,
                "methods": methods,
            }

        elif node_type == "make_object":
            _, var_name, class_name, args, kwargs, _, _ = node
            eval_args = [self.eval_expr(a) for a in args]
            eval_kwargs = {k: self.eval_expr(v) for k, v in kwargs.items()}           
            if class_name not in self.classes:
                self.runtime_error(f"Class '{class_name}' not defined")            
            class_def = self.classes[class_name]            
            instance = {
                "__class__": class_name,
                "__parent__": class_def["parent"],
            }
            # Initialize fields with defaults
            for field_name, field_expr in class_def["fields"].items():
                instance[field_name] = self.eval_expr(field_expr)              
            if "when_created" in class_def["methods"]:
                params, body = class_def["methods"]["when_created"]
                if len(eval_args) != len(params):
                    self.runtime_error(
                        f"Constructor '{class_name}' expected {len(params)} args, got {len(args)}"
                    )                
                local_vars = {"self": instance}
                for p, v in zip(params, eval_args):
                    local_vars[p] = v                
                self.push_scope(local_vars)
                try:
                    for stmt in body:
                        self.execute_node(stmt)
                finally:
                    self.pop_scope()
            
            self.set_var(var_name, instance)

        elif node_type == "obj_field_assign":
            _, obj_name, field_name, expr, _, _ = node
            obj = self.get_var(obj_name)
            value = self.eval_expr(expr)
            
            if not isinstance(obj, dict):
                self.runtime_error(f"Cannot assign field to non-object type {type(obj).__name__}")
            
            obj[field_name] = value

        elif node_type == "func":
            _, name, params, body, _, _ = node
            self.functions[name] = (params, body)

            def make_func_wrapper(fname, params, body, interpreter):
                def wrapper(*args):
                    if len(args) != len(params):
                        interpreter.runtime_error(
                            f"Function '{fname}' expected {len(params)} args, got {len(args)}"
                        )
                    local_vars = dict(zip(params, args))
                    interpreter.push_scope(local_vars)
                    try:
                        ret = None
                        for stmt in body:
                            try:
                                interpreter.execute_node(stmt)
                            except _ReturnException as re:
                                ret = re.value
                                break
                        return ret
                    finally:
                        interpreter.pop_scope()

                return wrapper

            self.set_var(name, make_func_wrapper(name, params, body, self))

        elif node_type == "return":
            _, expr, _, _ = node
            val = self.eval_expr(expr)
            raise _ReturnException(val)

        elif node_type == "continue":
            raise ContinueException()

        elif node_type == "break":
            raise BreakException()

        elif node_type == "expr":
            _, expr, _, _ = node
            self.eval_expr(expr)

        elif node_type == "try_handle":
            _, try_block, handle_block, error_var, _, _ = node
            try:
                for stmt in try_block:
                    self.execute_node(stmt)
            except RuntimeError as e:
                error_msg = e.args[0] if e.args else str(e)
                if isinstance(error_msg, tuple):
                    error_msg = error_msg[0] if error_msg else str(e)
                if error_var:
                    self.set_var(error_var, str(error_msg), local=True)
                for stmt in handle_block:
                    self.execute_node(stmt)
            except Exception as e:
                error_msg = str(e)
                if error_var:
                    self.set_var(error_var, error_msg, local=True)
                for stmt in handle_block:
                    self.execute_node(stmt)

        elif node_type == "match_stmt":
            _, value_expr, when_clauses, otherwise_body, line, col = node
            self.current_line, self.current_col = line, col
            value_to_match = self.eval_expr(value_expr)
            matched = False
            for _, case_exprs, body in when_clauses:
                for case_expr in case_exprs:
                    case_value = self.eval_expr(case_expr)
                    if value_to_match == case_value:
                        for stmt in body:
                            self.execute_node(stmt)
                        matched = True
                        break
                if matched:
                    break
            if not matched and otherwise_body is not None:
                for stmt in otherwise_body:
                    self.execute_node(stmt)

        elif node_type == "import":
            _, path_or_name, alias, _, _ = node
            # --- 1. TRY PYTHON MODULE FIRST ---
            try:
                import importlib

                py_mod = importlib.import_module(path_or_name)
                ns = self._wrap_python_module(py_mod)
                self.set_var(alias, ns)
                return
            except ModuleNotFoundError:
                pass

            # --- 2. FALLBACK TO ELANG MODULE ---
            candidates = self._resolve_module_path(path_or_name)
            actual_path = None
            for candidate in candidates:
                if os.path.exists(candidate):
                    actual_path = candidate
                    break

            if not actual_path:
                self.runtime_error(f"Module file not found: {path_or_name}")

            abs_candidate = os.path.abspath(actual_path)
            if abs_candidate in self.brought_paths:
                self.runtime_error(f"Module already brought: {actual_path}")

            ns = self.load_module(actual_path)
            self.set_var(alias, ns)
            self.brought_paths.add(abs_candidate)

        elif node_type == "close":
            _, handle, _, _ = node
            if handle not in self.files:
                self.runtime_error(f"File handle '{handle}' is not open")
            try:
                self.files[handle].close()
            finally:
                del self.files[handle]

        elif node_type == "writeline":
            _, handle, expr, _, _ = node
            if handle not in self.files:
                self.runtime_error(f"File handle '{handle}' is not open")
            val = self.eval_expr(expr)
            try:
                self.files[handle].write(str(val) + "\n")
                self.files[handle].flush()
            except Exception as e:
                self.runtime_error(f"Failed to write to file handle '{handle}': {e}")

        elif node_type == "readline":
            _, handle, varname, _, _ = node
            if handle not in self.files:
                self.runtime_error(f"File handle '{handle}' is not open")
            try:
                line = self.files[handle].readline()
            except Exception as e:
                self.runtime_error(f"Failed to read from file handle '{handle}': {e}")
            if line == "":
                value = ""
            else:
                value = line.rstrip("\n")
            self.set_var(varname, value)

        elif node_type == "read":
            _, var_name, type_name, _, _ = node
            raw = input(f"Enter value for {var_name}: ")
            if type_name == "boolean":
                v = raw.strip().lower()
                if v in ("true", "1", "yes", "t"):
                    value = True
                elif v in ("false", "0", "no", "f"):
                    value = False
                else:
                    self.runtime_error(
                        f"Input value for {var_name} is not a valid boolean"
                    )
            elif type_name == "int":
                try:
                    value = int(raw.strip())
                except ValueError:
                    self.runtime_error(
                        f"Input value for {var_name} is not a valid integer"
                    )
            elif type_name == "float":
                try:
                    value = float(raw.strip())
                except ValueError:
                    self.runtime_error(
                        f"Input value for {var_name} is not a valid float"
                    )
            else:
                value = raw
            self.set_var(var_name, value)

        elif node_type == "if":
            _, condition, then_branch, else_branch, _, _ = node
            cond = self.eval_expr(condition)

            self.push_scope()
            try:
                if cond:
                    for stmt in then_branch:
                        self.execute_node(stmt)
                elif else_branch:
                    for stmt in else_branch:
                        self.execute_node(stmt)
            finally:
                self.pop_scope()

        elif node_type == "while":
            _, condition, block, _, _ = node

            self.push_scope()
            try:
                while self.eval_expr(condition):
                    try:
                        for stmt in block:
                            self.execute_node(stmt)
                    except ContinueException:
                        continue
                    except BreakException:
                        break
            finally:
                self.pop_scope()

        elif node_type == "for":
            _, loop_var, start_expr, end_expr, block, _, _ = node
            start = self.eval_expr(start_expr)
            end = self.eval_expr(end_expr)

            i = start
            while i <= end:
                self.set_var(loop_var, i)
                try:
                    for stmt in block:
                        self.execute_node(stmt)
                except ContinueException:
                    i += 1
                    continue
                except BreakException:
                    break
                i += 1

        elif node_type == "for_each":
            _, loop_var, container_expr, block, _, _ = node
            value = self.eval_expr(container_expr)

            if not isinstance(value, (list, str, dict)):
                self.runtime_error(
                    f"repeat {loop_var} from expects a list, string, or dictionary, got ({type(value).__name__})"
                )

            if isinstance(value, list):
                iterable = value
            elif isinstance(value, str):
                iterable = list(value)
            else:
                iterable = list(value.keys())

            self.push_scope()
            try:
                for elem in iterable:
                    self.set_var(loop_var, elem)
                    try:
                        for stmt in block:
                            self.execute_node(stmt)
                    except ContinueException:
                        continue
                    except BreakException:
                        break
            finally:
                self.pop_scope()

        # elif node_type == 'Null':
        # return None

        else:
            self.runtime_error(f"Unknown node type: {node_type}")

    def capture_current_scope(self):
        return self.scopes[-1].copy() if self.scopes else {}

    def eval_expr(self, expr):
        if expr is None:
            self.runtime_error("Internal error: AST expression is None")
        etype = expr[0]

        if etype == "number":
            return expr[1]

        elif etype == "string":
            raw = expr[1]
            line, col = expr[2], expr[3]
            return self._interpolate_string(raw, line, col)

        elif etype == "boolean":
            return expr[1]

        elif etype == "null":
            return None

        elif etype == "neg":
            _, subexpr, line, col = expr
            self.current_line, self.current_col = line, col
            val = self.eval_expr(subexpr)
            if isinstance(val, (int, float)):
                return -val
            else:
                self.runtime_error(
                    f"Unary '-' requires numeric operand, got {type(val).__name__}"
                )

        elif etype == "var":
            _, name, line, col = expr
            self.current_line, self.current_col = line, col
            try:
                return self.get_var(name)
            except RuntimeError:
                if name in self.builtins:
                    return self.builtins[name]
                self.runtime_error(f"Variable '{name}' not found")

        elif etype == "list":
            _, items, line, col = expr
            self.current_line, self.current_col = line, col
            return [self.eval_expr(item) for item in items]

        elif etype == "dict":
            _, pairs, line, col = expr
            self.current_line, self.current_col = line, col
            result = {}
            for key, val_expr in pairs:
                val = self.eval_expr(val_expr)
                result[key] = val
            return result

        elif etype == "index":
            _, container_expr, idx_expr, line, col = expr
            self.current_line, self.current_col = line, col
            container = self.eval_expr(container_expr)
            idx = self.eval_expr(idx_expr)
            if container is None:
                self.runtime_error("Cannot index object of type NoneType")
            if isinstance(container, list):
                if not isinstance(idx, int):
                    self.runtime_error(
                        f"List index must be integer, got {type(idx).__name__}"
                    )
                try:
                    return container[idx]
                except IndexError:
                    self.runtime_error(f"List index out of range: {idx}")
            if isinstance(container, dict):
                if idx in container:
                    return container[idx]
                self.runtime_error(f"Key not found in dictionary: {idx}")
            self.runtime_error(
                f"Cannot index object of type {type(container).__name__}"
            )

        elif etype == "slice":
            _, container_expr, start_expr, stop_expr, step_expr, line, col = expr
            self.current_line, self.current_col = line, col
            container = self.eval_expr(container_expr)
            start = self.eval_expr(start_expr) if start_expr else None
            stop = self.eval_expr(stop_expr) if stop_expr else None
            step = self.eval_expr(step_expr) if step_expr else None
            if not isinstance(container, (list, str)):
                self.runtime_error(
                    f"Cannot slice object of type {type(container).__name__}. "
                    f"Slicing works on lists and strings only."
                )
            if start is not None and not isinstance(start, int):
                self.runtime_error(f"Slice start must be integer, got {type(start).__name__}")
            if stop is not None and not isinstance(stop, int):
                self.runtime_error(f"Slice stop must be integer, got {type(stop).__name__}")
            if step is not None and not isinstance(step, int):
                self.runtime_error(f"Slice step must be integer, got {type(step).__name__}")
            if step == 0:
                self.runtime_error("Slice step cannot be zero")
            try:
                return container[start:stop:step]
            except Exception as e:
                self.runtime_error(f"Slicing error: {e}")

        elif etype == "method":
            _, obj_expr, meth, args_exprs, kwargs_exprs, line, col = expr
            self.current_line, self.current_col = line, col
            obj = self.eval_expr(obj_expr)
            args = [self.eval_expr(a) for a in args_exprs]
            kwargs = {k: self.eval_expr(v) for k, v in kwargs_exprs.items()}
            if isinstance(obj, str):
                if meth == "len":
                    if len(args) != 0:
                        self.runtime_error("len() takes no arguments")
                    return len(obj)
                elif meth == "length":
                    if len(args) != 0:
                        self.runtime_error("length() takes no arguments")
                    return len(obj)
                elif meth == "upper":
                    if len(args) != 0:
                        self.runtime_error("upper() takes no arguments")
                    return obj.upper()
                elif meth == "lower":
                    if len(args) != 0:
                        self.runtime_error("lower() takes no arguments")
                    return obj.lower()
                elif meth == "strip":
                    if len(args) != 0:
                        self.runtime_error("strip() takes no arguments")
                    return obj.strip()
                elif meth == "split":
                    if len(args) == 0:
                        return obj.split()
                    elif len(args) == 1:
                        return obj.split(str(args[0]))
                    else:
                        self.runtime_error("split() takes at most 1 argument")
                elif meth == "contains":
                    if len(args) != 1:
                        self.runtime_error("contains() takes exactly 1 argument")
                    return str(args[0]) in obj
                elif meth == "substring":
                    if len(args) < 2:
                        self.runtime_error("substring() requires 2 arguments: start and length")
                    start = int(args[0])
                    length = int(args[1])
                    if start < 0:
                        start = 0
                    if length < 0:
                        return ""
                    end = start + length
                    return obj[start:end]
                elif meth == "char_at":
                    if len(args) != 1:
                        self.runtime_error("char_at() takes exactly 1 argument")
                    idx = int(args[0])
                    if idx < 0 or idx >= len(obj):
                        return ""
                    return obj[idx]
                elif meth == "starts_with":
                    if len(args) != 1:
                        self.runtime_error("starts_with() takes exactly 1 argument")
                    return obj.startswith(str(args[0]))
                elif meth == "ends_with":
                    if len(args) != 1:
                        self.runtime_error("ends_with() takes exactly 1 argument")
                    return obj.endswith(str(args[0]))
                elif meth == "replace":
                    if len(args) != 2:
                        self.runtime_error("replace() takes exactly 2 arguments: old and new")
                    old = str(args[0])
                    new = str(args[1])
                    return obj.replace(old, new)
                else:
                    self.runtime_error(f"Unknown string method: {meth}")

            if isinstance(obj, list):
                if meth == "push":
                    if len(args) != 1:
                        self.runtime_error("push() takes exactly one argument")
                    obj.append(args[0])
                    return obj
                elif meth == "pop":
                    if len(args) != 0:
                        self.runtime_error("pop() takes no arguments")
                    if not obj:
                        self.runtime_error("pop() from empty list")
                    return obj.pop()
                elif meth == "length":
                    if len(args) != 0:
                        self.runtime_error("length() takes no arguments")
                    return len(obj)
                else:
                    self.runtime_error(f"Unknown list method: {meth}")

            if "__class__" in obj:
                class_name = obj["__class__"]
                if class_name in self.classes:
                    class_def = self.classes[class_name]
                    if meth in class_def["methods"]:
                        params, body = class_def["methods"][meth]
                        
                        if len(args) != len(params):
                            self.runtime_error(
                                f"Method '{meth}' expected {len(params)} args, got {len(args)}"
                            )                       
                        local_vars = {"self": obj}
                        for p, v in zip(params, args):
                            local_vars[p] = v                        
                        self.push_scope(local_vars)
                        ret = None
                        try:
                            for stmt in body:
                                try:
                                    self.execute_node(stmt)
                                except _ReturnException as re:
                                    ret = re.value
                                    break
                        finally:
                            self.pop_scope()
                        return ret
                    else:
                        self.runtime_error(f"Class '{class_name}' has no method '{meth}'")

            if isinstance(obj, dict) and "__pyobj__" in obj:
                pyobj = obj["__pyobj__"]
                if hasattr(pyobj, meth):
                    attr = getattr(pyobj, meth)
                    if callable(attr):
                        try:
                            return attr(*args, **kwargs)
                        except Exception as e:
                            self.runtime_error(f"Python error in {meth}(): {e}")
                    return attr
                if meth in obj:
                    v = obj[meth]
                    if callable(v):
                        return v(*args)
                    return v
                self.runtime_error(f"Python module has no attribute '{meth}'")

            if isinstance(obj, dict):
                if meth == "keys":
                    if len(args) != 0:
                        self.runtime_error("keys() takes no arguments")
                    return list(obj.keys())
                elif meth == "values":
                    if len(args) != 0:
                        self.runtime_error("values() takes no arguments")
                    return list(obj.values())
                elif meth == "has":
                    if len(args) != 1:
                        self.runtime_error("has() takes exactly one argument")
                    return args[0] in obj
                elif meth == "length":
                    if len(args) != 0:
                        self.runtime_error("length() takes no arguments")
                    return len(obj)
                if meth in obj:
                    value = obj[meth]
                    if isinstance(value, dict) and value.get("inlinefunc"):
                        params = value["params"]
                        body = value["body"]
                        saved_env = value["env"]
                        if len(args) != len(params):
                            self.runtime_error(
                                f"Inline function '{meth}' expected {len(params)} args, got {len(args)}"
                            )
                        local_vars = saved_env.copy()
                        for p, v in zip(params, args):
                            local_vars[p] = v
                        self.push_scope(local_vars)
                        ret = None
                        try:
                            for stmt in body:
                                try:
                                    self.execute_node(stmt)
                                except _ReturnException as re:
                                    ret = re.value
                                    break
                        finally:
                            self.pop_scope()
                        return ret
                    if callable(value):
                        try:
                            return value(*args)
                        except Exception as e:
                            self.runtime_error(
                                f"Error calling dict-stored function '{meth}': {e}"
                            )
                    if len(args) == 0:
                        return value
                    self.runtime_error(f"Cannot call non-callable dict entry '{meth}'")
                self.runtime_error(f"Unknown dict method: {meth}")

            if hasattr(obj, meth):
                attr = getattr(obj, meth)
                if callable(attr):
                    try:
                        return attr(*args, **kwargs)
                    except Exception as e:
                        self.runtime_error(f"Python error in {meth}(): {e}")
                return attr

            self.runtime_error(
                f"Object of type {type(obj).__name__} has no method '{meth}'"
            )

        elif etype == "self_expr":
            try:
                return self.get_var("self")
            except RuntimeError:
                self.runtime_error("'self' is not available in this context")

        elif etype == "func_literal":
            _, params, body, line, col = expr
            env = self.capture_current_scope()
            return {
                "inlinefunc": True,
                "params": params,
                "body": body,
                "line": line,
                "col": col,
                "env": env,
            }

        elif etype == "call":
            _, callexpr, args_exprs, kwargs_exprs, line, col = expr
            self.current_line, self.current_col = line, col

            func = self.eval_expr(callexpr)
            # print("DEBUG func value:", func)
            args = [self.eval_expr(a) for a in args_exprs]
            kwargs = {k: self.eval_expr(v) for k, v in kwargs_exprs.items()}

            # callee_name = None
            # if (
            #     isinstance(func, tuple)
            #     and len(func) == 2
            #     and func[0] == "named_function"
            # ):
            #     callee_name = func[1]

            # if callee_name is not None and callee_name in self.builtins:
            #     try:
            #         return self.builtins[callee_name](*args, **kwargs)
            #     except TypeError as te:
            #         self.runtime_error(f"Builtin '{callee_name}' called with wrong arguments: {te}")
            #     except Exception as e:
            #         self.runtime_error(f"Error in builtin '{callee_name}': {e}")

            # if callee_name is not None and callee_name in self.functions:
            #     params, body = self.functions[callee_name]
            #     if len(args) != len(params):
            #         self.runtime_error(
            #             f"Function '{callee_name}' expected {len(params)} args, got {len(args)}"
            #         )
            #     local_vars = dict(zip(params, args))
            #     self.push_scope(local_vars)
            #     try:
            #         ret = None
            #         for stmt in body:
            #             try:
            #                 self.execute_node(stmt)
            #             except _ReturnException as re:
            #                 ret = re.value
            #                 break
            #         return ret
            #     finally:
            #         self.pop_scope()

            if isinstance(func, dict) and func.get("inlinefunc"):
                params = func["params"]
                body = func["body"]
                saved_env = func["env"]
                if len(args) != len(params):
                    self.runtime_error(
                        f"Inline function expected {len(params)} args, got {len(args)}"
                    )
                local_vars = saved_env.copy()
                for p, v in zip(params, args):
                    local_vars[p] = v
                self.push_scope(local_vars)
                ret = None
                try:
                    for stmt in body:
                        try:
                            self.execute_node(stmt)
                        except _ReturnException as re:
                            ret = re.value
                            break
                finally:
                    self.pop_scope()
                return ret

            if callable(func):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    self.runtime_error(f"Error calling function: {e}")

            # if callee_name is not None:
            #     self.runtime_error(f"Function '{callee_name}' not defined")
            # else:
            #     self.runtime_error("Cannot call non-callable value")
            self.runtime_error("Cannot call non-callable value")

        elif etype == "prop":
            _, obj_expr, prop_name, line, col = expr
            self.current_line, self.current_col = line, col
            obj = self.eval_expr(obj_expr)

            if isinstance(obj, dict) and "__class__" in obj:
                if prop_name in obj:
                    return obj[prop_name]
                self.runtime_error(f"Object has no property '{prop_name}'")

            if isinstance(obj, dict):
                if prop_name in obj:
                    return obj[prop_name]
                self.runtime_error(f"Property '{prop_name}' not found in dictionary")

            if hasattr(obj, prop_name):
                return getattr(obj, prop_name)

            self.runtime_error(
                f"Object of type {type(obj).__name__} has no property '{prop_name}'"
            )

        elif etype == "binop":
            _, op, left_expr, right_expr, line, col = expr
            self.current_line, self.current_col = line, col
            left = self.eval_expr(left_expr)
            right = self.eval_expr(right_expr)

            if op == "and":
                if isinstance(left, bool) and isinstance(right, bool):
                    return left and right
                else:
                    self.runtime_error(
                        f"Cannot apply 'and' between {type(left).__name__} and {type(right).__name__} - use 'plus' for addition"
                    )

            elif op == "or":
                if isinstance(left, bool) and isinstance(right, bool):
                    return left or right
                else:
                    self.runtime_error(
                        f"Cannot apply 'or' between {type(left).__name__} and {type(right).__name__} - use 'plus' for addition"
                    )

            elif op in ("plus", "+"):
                if isinstance(left, (int, float)) and isinstance(right, (int, float)):
                    return left + right
                elif isinstance(left, str) and isinstance(right, str):
                    return left + right
                elif isinstance(left, list) and isinstance(right, list):
                    return left + right
                elif (isinstance(left, str) and isinstance(right, (int, float))) or (
                    isinstance(left, (int, float)) and isinstance(right, str)
                ):
                    return str(left) + str(right)
                else:
                    self.runtime_error(
                        f"Cannot add {type(left).__name__} and {type(right).__name__}"
                    )

            elif op in ("minus", "-"):
                if isinstance(left, (int, float)) and isinstance(right, (int, float)):
                    return left - right
                else:
                    self.runtime_error(
                        f"Cannot subtract {type(right).__name__} from {type(left).__name__}"
                    )

            elif op in ("mul", "*"):
                if isinstance(left, (int, float)) and isinstance(right, (int, float)):
                    return left * right
                elif isinstance(left, str) and isinstance(right, int):
                    return left * right
                elif isinstance(left, int) and isinstance(right, str):
                    return right * left
                else:
                    self.runtime_error(
                        f"Cannot multiply {type(left).__name__} and {type(right).__name__}"
                    )

            elif op in ("div", "/"):
                if isinstance(left, (int, float)) and isinstance(right, (int, float)):
                    if right == 0:
                        self.runtime_error("Division by zero")
                    return left / right
                    # else:
                    # return left / right
                else:
                    self.runtime_error(
                        f"Cannot divide {type(left).__name__} by {type(right).__name__}"
                    )

            elif op == "//":
                if isinstance(left, (int, float)) and isinstance(right, (int, float)):
                    if right == 0:
                        self.runtime_error("Division by zero")
                    return left // right
                else:
                    self.runtime_error(
                        f"Cannot apply '//' between {type(left).__name__} and {type(right).__name__}"
                    )

            elif op == "%":
                if isinstance(left, (int, float)) and isinstance(right, (int, float)):
                    if right == 0:
                        self.runtime_error("Modulo by zero")
                    return left % right
                else:
                    self.runtime_error(
                        f"Cannot apply '%' to {type(left).__name__} and {type(right).__name__}"
                    )
            elif op == "**":
                if isinstance(left, (int, float)) and isinstance(right, (int, float)):
                    return left**right
                else:
                    self.runtime_error(
                        f"Cannot apply '**' to {type(left).__name__} and {type(right).__name__}"
                    )

            else:
                self.runtime_error(f"Unknown operator: {op}")

        elif etype == "compare":
            _, op, left_expr, right_expr, line, col = expr
            self.current_line, self.current_col = line, col
            left = self.eval_expr(left_expr)
            right = self.eval_expr(right_expr)

            if left is None or right is None:
                if op == "==":
                    return left is right
                elif op == "!=":
                    return left is not right
                else:
                    self.runtime_error(
                        f"Cannot compare using '{op}' when one side is NULL;"
                    )

            if (
                (isinstance(left, (int, float)) and isinstance(right, (int, float)))
                or (isinstance(left, str) and isinstance(right, str))
                or (isinstance(left, bool) and isinstance(right, bool))
            ):
                if op == "<":
                    return left < right
                elif op == ">":
                    return left > right
                elif op == "==":
                    return left == right
                elif op == "!=":
                    return left != right
                elif op == "<=":
                    return left <= right
                elif op == ">=":
                    return left >= right
                else:
                    self.runtime_error(f"Unknown comparison operator: {op}")
            else:
                self.runtime_error(
                    f"Cannot compare {type(left).__name__} and {type(right).__name__}"
                )

        elif etype == "logicop":
            _, op, left_expr, right_expr, line, col = expr
            self.current_line, self.current_col = line, col
            left = self.eval_expr(left_expr)
            right = self.eval_expr(right_expr)
            if isinstance(left, bool) and isinstance(right, bool):
                if op == "and":
                    return left and right
                elif op == "or":
                    return left or right
                else:
                    self.runtime_error(f"Unknown logical operator: {op}")
            else:
                self.runtime_error(
                    f"Cannot apply '{op}' between {type(left).__name__} and {type(right).__name__} - both must be boolean"
                )

        elif etype == "logicnot":
            _, subexpr, line, col = expr
            self.current_line, self.current_col = line, col
            cond = self.eval_expr(subexpr)
            if isinstance(cond, bool):
                return not cond
            else:
                self.runtime_error(
                    f"Cannot apply 'not' to {type(cond).__name__} - must be boolean"
                )

        else:
            self.runtime_error(f"Unknown expression type: {etype}")

    def run_loop(self, condition, block):
        while self.eval_expr(condition):
            try:
                for stmt in block:
                    self.execute_node(stmt)
            except ContinueException:
                continue
            except BreakException:
                break

    def run_for(self, var, start_expr, end_expr, block):
        i = self.eval_expr(start_expr)
        target = self.eval_expr(end_expr)
        while i < target:
            self.set_var(var, i)
            try:
                for stmt in block:
                    self.execute_node(stmt)
            except ContinueException:
                i += 1
                continue
            except BreakException:
                break
            i += 1

    def _to_boolean(self, value):
        if isinstance(value, bool):
            return value
        elif isinstance(value, (int, float)):
            return value != 0
        elif isinstance(value, str):
            return len(value) > 0
        else:
            self.runtime_error(f"Cannot convert {type(value).__name__} to boolean")


# ================= ENTRYPOINT =======================


def run_file(path):
    with open(path, encoding="utf-8") as f:
        source = f.read()

    source_lines = source.splitlines()

    interpreter = Interpreter(main_file_path=path)
    interpreter.source_lines = source_lines
    interpreter.file_source_map[path] = source_lines

    try:
        tokens = lexer(source)
        parser = Parser(tokens, path)
        # print("Tokens:", tokens)
        ast = parser.parse()
        # print("AST:", ast)
        interpreter.interpret(ast)

    except SyntaxError as e:
        data = e.args[0] if e.args else ("Syntax error", "", 1, 1, path)
        if isinstance(data, tuple):
            if len(data) >= 5:
                msg, value, line, col, file_path = data
            elif len(data) == 4:
                msg, value, line, col = data
                file_path = interpreter.file_stack[-1]
            else:
                msg = str(data)
                value = ""
                line = col = 1
                file_path = interpreter.file_stack[-1]
        else:
            msg = str(data)
            value = ""
            line = col = 1
            file_path = interpreter.file_stack[-1]

        full_msg = f"{msg}"
        if value and f"'{value}'" not in msg:
            full_msg += f" (got '{value}')"

        print(
            pretty_error(
                "SyntaxError",
                full_msg,
                file_path,
                line,
                col,
                interpreter.source_lines,
                interpreter.file_source_map,
            )
        )
        return

    except RuntimeError as e:
        data = (
            e.args[0]
            if e.args
            else ("Runtime error", "", 1, 1, interpreter.file_stack[-1])
        )
        if isinstance(data, tuple):
            if len(data) == 4:
                msg, file_or_value, line, col = data
                if file_or_value:
                    file_path = file_or_value
                else:
                    file_path = interpreter.file_stack[-1]
            elif len(data) >= 5:
                msg, value, line, col, file_path = data
            else:
                msg = str(data)
                file_path = interpreter.file_stack[-1]
                line = col = 1
        else:
            msg = str(data)
            file_path = interpreter.file_stack[-1]
            line = col = 1

        full_msg = msg
        # if value and f"'{value}'" not in msg:
        # full_msg += f" (got '{value}')"

        print(
            pretty_error(
                "RuntimeError",
                full_msg,
                file_path,
                line,
                col,
                interpreter.source_lines,
                interpreter.file_source_map,
            )
        )
        return