interpreterME.py

#this software is licenced under the GNU General Public License v3.0, for more information check: https://raw.githubusercontent.com/XFydro/x3/refs/heads/main/license.txt
#i will try to clean it up in future updates. -Raven
"""
Requirements:
__Python3.8+
__Pip(Latest Update for better experience)
__Internet Connection(for first run to download essentials like help files)
__Minimal Hardware resources:2GB Ram
__Patience because python is slow af :P
"""
from difflib import SequenceMatcher
import datetime, platform, uuid, getpass, socket, traceback, builtins, argparse, time, re, os, shlex, json, difflib, subprocess, importlib, random, math, struct
#import cProfile
REPL=0 #on default script mode.
VERSION=3.96 #version (For IDE and more)

def install_package(package, alias=None)->None:
    import sys
    try:
        module = importlib.import_module(package)
        if REPL==1:
            print(f"{package} is already installed.")
    except ImportError:        
        print(f"{package} not found. Installing...")
        subprocess.check_call([sys.executable, "-m", "pip", "install", package])
        try:
            module = importlib.import_module(package)
        except ImportError:
            print(f"ErrID14: Failed to import {package} after installation.")
            return None
    if alias:
        globals()[alias] = module
        print(f"Imported {package} as {alias}.")
    else:
        globals()[package] = module
try:
    import psutil
except ImportError:
    install_package("psutil")
try:
    import requests
except ImportError:
    install_package("requests")


try:
    class Error(Exception):
        pass
    class Interpreter:
        def __init__(self): 
            self.call_stack = []
            self.local_variables = {}
            self.REPL:int=REPL
            self.current_line:int=-1
            self.variables:dict = {} #variable dictionary
            self.functions:dict = {} #function dictionary
            self.current_function_name:str = None
            self.in_function_definition:bool = False #flag to indicate if the code is currently in a function definition
            self.CFE:bool = False #Current Function Execution.
            self.local:bool = False #local variable flag, used to indicate if a var is being declared locally or globally
            self.control_stack:list = [] #that if else and stuff, for basic control flow monitoring
            self.debug:bool = False #only used as a placeholder, replaced by the new BETTER debug system
            self.debuglog:list = [] #log() function list.
            self.output:str = None #output for functions like fetch, i will think of improving this.
            self.log_messages:list = [] #old log messages record, still works but deprecated
            self.loaded_files:list = [] #list of loaded files, to prevent recursion during file loading.
            self.execution_state:dict = {} #thought of removing this but it is still used in some control flow magic so ye.
            self.trystate:str = "False" #for checking whether the current block is in a try state or not. (had to make it a string because of setattr and getattr)
            self.return_flag:bool = False
            self.return_value:str = None
            self.loaderrorcount:int = 0 #load error count, used to track errors during file loading.
            self._math_ns={'math':math} 
            self._math_cache={}
            #Debug Init---
            self.ctrflwdebug:bool = False 
            self.prtdebug:bool = False
            self.mathdebug:bool = False
            self.filedebug:bool = False
            self.clramadebug:bool = False
            self.cmdhandlingdebug:bool = False
            self.reqdebug:bool=False
            self.conddebug:bool=False
            self.vardebug:bool=False
            #---
            #Rules Init--
            self.semo:bool=False #Script Execution Mode Only, this is used to prevent REPL from executing commands.
            self.disableprt:bool=False #Disable Print, to disable the print command, i forgot why i made this TwT #29.9.25-Raven.
            #---
            self.command_mapping:dict = { 
                'add': self.cmd_add,
                'a_file': self.cmd_append_file,           
                'call': self.cmd_call,
                'cls': self.cmd_clear,
                'create_dir': self.cmd_create_dir,
                'dec': self.cmd_dec,
                'def': self.cmd_def,
                'del': self.cmd_del,
                'del_file': self.cmd_delete_file,     
                'delete_dir': self.cmd_delete_dir,
                'dev.debug': self.dev,
                'div': self.cmd_div,
                'else': self.cmd_else,
                'end': self.cmd_end,
                'exit': self.cmd_exit,
                'fastmath': self.cmd_fastmath,
                'fetch': self.cmd_fetch,
                'flush': self.cmd_reworkedflush,
                'fncend': self.cmd_fncend,
                'goto': self.cmd_goto,
                'if': self.cmd_if,
                'inc': self.cmd_inc,
                'inp': self.cmd_inp,
                'load': self.load,
                'mod': self.cmd_mod,
                'mul': self.cmd_mul,
                'prt': self.cmd_prt,
                'reg': self.cmd_reg,
                'return': self.cmd_return,
                'r_file': self.cmd_read_file,
                'search_file': self.cmd_search_file,
                'setclientrule': self.setclientrule,
                'sqrt': self.cmd_sqrt,
                'sub': self.cmd_sub,
                'brute': self.cmd_brute,
                'wait': self.cmd_wait,
                'while': self.cmd_while,
                'w_file': self.cmd_create_file,
                '--info': self.info,
                '--help': self.help,
            }
            self.exceptional_commands:dict={
                "//",
                "",
                " ",
            }
            self.nibbits:dict = { #Renamed to nibbits because "nibbits" sounds cuter than "additional_parameters" :3 #29.9.25-Raven
                #misc inline functions, that can be used in commands by using the syntax ##function_name or ##function_name(args) or ##function_name:type:(args) for functions with arguments. (arguments must be enclosed in parentheses)
                "##interpreter:vars": lambda: list(self.variables.keys()),
                "##interpreter:funcs": lambda: list(getattr(self, "functions", {}).keys()),
                "##interpreter:memory": lambda: f"{round(psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024, 2)} MB" if 'psutil' in globals() else "[psutil module not available]",
                "##interpreter:platform": lambda: platform.platform(),
                "##interpreter:eval": lambda x="": eval(x) if x else None,

                "##random": lambda: random.random(),
                "##randint": lambda: random.randint(0, 100),
                "##timeseconds": lambda: time.time(),
                "##timestamp": lambda: int(time.time()),
                "##date": lambda: datetime.datetime.now().strftime("%Y-%m-%d"),
                "##time": lambda: datetime.datetime.now().strftime("%H:%M:%S"),
                "##datetime": lambda: datetime.datetime.now(),
                "##datetime:iso": lambda: datetime.datetime.now().isoformat(),
                "##datetime:utc": lambda: datetime.datetime.now(datetime.timezone.utc).isoformat(),
                
                "##REPL": lambda: self.REPL, 
                "##uuid": lambda: str(uuid.uuid4()),
                "##uuid:hex": lambda: uuid.uuid4().hex,
                "##user": lambda: getpass.getuser(),
                "##hostname": lambda: socket.gethostname(),
                "##platform": lambda: platform.system(),
                "##osversion": lambda: platform.version(),
                "##cwd": lambda: os.getcwd(),
                "##randbool": lambda: random.choice([True, False]),
                "##msec": lambda: int(time.time() * 1000),
                "##env": lambda key="": os.environ.get(key, "") if key else dict(os.environ),
                "##upper": lambda txt="": txt.upper(),
                "##lower": lambda txt="": txt.lower(),
                "##reverse": lambda txt="": txt[::-1],
                "##length": lambda txt="": len(txt),
                "##capitalize": lambda txt="": txt.capitalize(),
                "##pingreport": lambda host="8.8.8.8": os.system(f"ping -n 1 {host}" if os.name == "nt" else f"ping -c 1 {host}") == 0,
                "##ping": lambda host="8.8.8.8": (
                    lambda output: (
                        re.search(r'time[=<]?\s*([\d.]+)\s*ms', output).group(1)
                        if re.search(r'time[=<]?\s*([\d.]+)\s*ms', output) else "unreachable"
                    )
                )(
                    subprocess.getoutput(
                        f"ping -n 1 {host}" if platform.system().lower() == "windows"
                        else f"ping -c 1 {host}"
                    )
                ),
                "##fetch": lambda url="": requests.get(url).text if 'requests' in globals() else (_ for _ in ()).throw(Error("--ErrID102: Fetch not available")),
                "##fetch:json": lambda url="": requests.get(url).json() if 'requests' in globals() else (_ for _ in ()).throw(Error("--ErrID102: Fetch not available")),
                "##fetch:status": lambda url="": requests.get(url).status_code if 'requests' in globals() else (_ for _ in ()).throw(Error("--ErrID102: Fetch not available")),
                "##fetch:headers": lambda url="": requests.get(url).headers if 'requests' in globals() else (_ for _ in ()).throw(Error("--ErrID102: Fetch not available")),
                "##fetch:content": lambda url="": requests.get(url).content if 'requests' in globals() else (_ for _ in ()).throw(Error("--ErrID102: Fetch not available")),
                "##fetch:html": lambda url="": requests.get(url).text if 'requests' in globals() else (_ for _ in ()).throw(Error("--ErrID102: Fetch not available")),
                "##fetch:xml": lambda url="": requests.get(url).text if 'requests' in globals() else (_ for _ in ()).throw(Error("--ErrID102: Fetch not available")),
                "##rgb:channel": lambda s="000000 0": (
                    lambda parts: (
                        lambda hex_str, ch: int(hex_str[ch*2:ch*2+2], 16)
                    )(
                        (parts[0].strip('"').lstrip("#") + "000000")[:6],
                        max(0, min(2, int(parts[1])))
                    )
                    if len(parts) >= 2 else 0
                )(s.split()),
                "##rgb": lambda s="000000": (
                    lambda hex_str: (
                        int(hex_str[0:2], 16),
                        int(hex_str[2:4], 16),
                        int(hex_str[4:6], 16)
                    ) if len(hex_str) >= 6 else (0, 0, 0)
                )(s.strip('"').lstrip("#") + "000000"),

                "##readfile": lambda path="": open(path, "r").read() if os.path.exists(path) else "[File not found]",#returns entire file content as an single string


            }
        def raiseError(self, message):
            raise Error(message)
        def setclientrule(self, args):
            allowed=['REPL', 'semo','disableprt']
            newargs=args.split(" ")
            for i in range(0,len(newargs)):
                if newargs[i] in allowed:
                    if getattr(self, newargs[i], None) is not None:
                        setattr(self, newargs[i], True) if not getattr(self, newargs[i]) else setattr(self, newargs[i], False)
                        print(f"[DEBUG] Client rule '{newargs[i]}' set to {getattr(self, newargs[i])}.") if self.cmdhandlingdebug else None
                else:
                    self.raiseError(f"--ErrID106: Unknown client rule '{newargs[i]}'") if getattr(self, "trystate")=="False" else print(f"[WARNING] Unknown client rule '{newargs[i]}', ignored due to try block.")
                if newargs[i]=="reset":
                    # Reset all rules to default (i hope my lazy ahh wont forget updating this part everytime new rules are added) #12.8.25
                    self.semo = False
                    self.disableprt = False
                    print("[DEBUG] All client rules reset to default.") if self.cmdhandlingdebug else None
        def info(self):
            print(f'Running on version:{VERSION}')
            print(f'Developed by Raven Corvidae 07.2024-Present, under GNU GPLv3.0 license.')
        def help(self, command):
            print("Syntax and other information at Https://x3documentation.neocities.org/syntax")
        def comment_strip(self, s):
            return s.split('\\')[0]
        def load(self, filename: str) -> None:
            self.loaderrorcount = 0
            success_count = 0
            if filename in self.loaded_files:
                if self.filedebug:
                    print(f"[DEBUG-{self.filedebug}] File '{filename}' already loaded, skipping to prevent recursion.")
                return
            if self.filedebug:
                print(f"[DEBUG-{self.filedebug}] Starting to load file: {filename}")
            try:
                if not isinstance(filename, str):
                    raise TypeError(f"Expected filename as str, got {type(filename).__name__}.")
                if not os.path.isfile(filename):
                    raise FileNotFoundError(f"File '{filename}' does not exist.")
                if not os.access(filename, os.R_OK):
                    raise PermissionError(f"No read permission for file '{filename}'.")
                if self.filedebug:
                    print(f"[DEBUG-{self.filedebug}] Opening file: {filename}")
                try:
                    interpreter = self
                except Exception as e:
                    raise RuntimeError(f"Interpreter initialization failed: {e}")

                with open(filename, 'r', encoding='utf-8', errors='replace') as file:
                    for lineno, line in enumerate(file, 1):
                        line = line.strip()
                        if not line or line.startswith("//"):
                            continue
                        try:
                            interpreter.handle_command(line)
                            success_count += 1
                            if self.filedebug:
                                print(f"[Line {lineno}] Executed: {line}")
                        except Exception:
                            self.loaderrorcount += 1
                            if self.filedebug:
                                print(f"[Line {lineno}] Failed: {line}")
                            continue
                self.loaded_files.append(filename)
            except (FileNotFoundError, PermissionError, TypeError, RuntimeError) as critical:
                    print(f"[LOAD-CRITICAL] {critical}")

            except Exception as unknown:
                    print(f"[LOAD-UNKNOWN] Unexpected error:\n{unknown}")
                    if self.filedebug:
                        traceback.print_exc()
            finally:
                if self.filedebug:
                    print(f"[DEBUG-{self.filedebug}] Load complete.")
                    print(f" ├─ Successes: {success_count}")
                    print(f" └─ Failures: {self.loaderrorcount}")
        def cmd_del(self, args):
            """Deletes a variable or function.
               Usage: del var variable_name OR del func function_name"""
            parts = args.split(" ",)
            object_type = parts[0].strip().lower() if len(parts) > 0 else None
            name = parts[1].strip() if len(parts) > 1 else None
            if object_type == "var":
                if name in self.variables:
                    del self.variables[name]
                    if self.vardebug:
                        print(f"[DEBUG] Variable '{name}' deleted.")
                else:
                    self.loaderrorcount+=1;self.raiseError(f"--ErrID75: Variable '{name}' not defined.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Variable '{name}' not defined, ignored due to try block.")
            elif object_type == "func":
                if name in self.functions:
                    del self.functions[name]
                    if self.vardebug:
                        print(f"[DEBUG] Function '{name}' deleted.")
                else:
                    self.loaderrorcount+=1;self.raiseError(f"--ErrID76: Function '{name}' not defined.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Function '{name}' not defined, ignored due to try block.")
            else:
                self.loaderrorcount+=1;self.raiseError(f"--ErrID74: Unknown object type '{object_type}' for deletion.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Unknown object type '{object_type}' for deletion, ignored due to try block.")
        def log(self, message):
            if self.debug:
                print(f"[DEBUG]: {message}")
                self.debuglog.append(f"[DEBUG]: {message}")

        def cmd_clear(self, args):
            if args!="legacy":  
                os.system('cls' if os.name == 'nt' else 'clear')
            else:
                print("\n" * 100) #for terminals or non-tty outputs that dont support cls.
        def cmd_brute(self):
            """A bruteforce control flow command, that will execute the block until it encounters an end, regardless of errors."""
            self.trystate = "True"
            self.control_stack.append({"type": "try"})
            if self.ctrflwdebug:
                print(f"[DEBUG] Try pushed to stack.")

        def cmd_if(self, condition):
            """
            Evaluate an IF condition and push it to the control stack.
            """
            try:
                condition = self.replace_nibbits(condition)  # Replace any additional parameters like ##random, ##REPL, etc :3
                result = self.eval_condition(condition)  # Pass the full condition as a single string
            except ValueError as e:
                self.loaderrorcount+=1;self.raiseError(f"--ErrID77: Invalid IF condition '{condition}'. Details: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Invalid IF condition '{condition}'. Details: {e}, ignored due to try block.")
               
            self.control_stack.append({"type": "if", "executed": result, "has_else": False})
            if self.ctrflwdebug:
                print(f"[DEBUG] IF condition '{condition}' evaluated to {result}, pushed to stack.")

            if not result:
                if self.ctrflwdebug:
                    print("[DEBUG] Skipping subsequent commands inside this IF block.")
        def evaluate_math_expression(self, expression):
            # Replace variables in the expression
            try:
                return eval(expression, {"__builtins__": {}}, {})
            except Exception as e:
                print(f"[MATH ERROR] {e}")
                return "<MATH_ERROR>"

        def cmd_else(self):
            """
            Execute an ELSE block only if the preceding IF block was false.
            """
            if not self.control_stack:
                self.loaderrorcount+=1;self.raiseError("--ErrID78: ELSE without a matching IF.")if getattr(self, "trystate")=="False" else print(f"[WARNING] ELSE without a matching IF, ignored due to try block.")

            last_if = self.control_stack[-1]
            if last_if["type"] != "if":
                self.loaderrorcount+=1;self.raiseError("--ErrID78: ELSE without a matching IF.")if getattr(self, "trystate")=="False" else print(f"[WARNING] ELSE without a matching IF, ignored due to try block.")

            if last_if.get("has_else", False):
                self.loaderrorcount+=1;self.raiseError("--ErrID79: Multiple ELSE statements for the same IF.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Multiple ELSE statements for the same IF, ignored due to try block.")

            last_if["has_else"] = True
            last_if["executed"] = not last_if["executed"]
            if self.ctrflwdebug:
                if last_if["executed"]:
                    print("[DEBUG] ELSE block will execute.")
                else:
                    print("[DEBUG] Skipping ELSE block because IF condition was true.")
                
        def cmd_while(self, condition):
            """
            Implements a while-loop functionality with proper nested execution.
            Skips pushing a new while-loop if the last one is on the same line.
            """
            if (self.control_stack and 
                self.control_stack[-1]["type"] == "while" and 
                self.control_stack[-1]["start_line"] == self.current_line):
                if self.ctrflwdebug:
                    print(f"[DEBUG] Skipping duplicate WHILE on line {self.current_line}")
                return  

            if not self.should_execute():
                executed = False
            else:
                try:
                    executed = self.eval_condition(condition)

                except ValueError as e:
                    self.loaderrorcount+=1;self.raiseError(f"--ErrID90: Invalid WHILE condition '{condition}'. Details: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Invalid WHILE condition '{condition}'. Details: {e}, ignored due to try block.")


            self.control_stack.append({
                "type": "while",
                "condition": condition,
                "executed": executed,
                "start_line": self.current_line
            })

            if self.ctrflwdebug:
                print(f"[DEBUG] WHILE condition '{condition}' evaluated to {executed}, pushed to stack.")

        def cmd_end(self):
            """
            Handles 'end' for 'if', 'else', and 'while' blocks.
            For 'while', it only loops if it was executed and the condition is still true.
            """
            if not self.control_stack:
                self.loaderrorcount+=1;self.raiseError("--ErrID91: 'end' without matching control block.")if getattr(self, "trystate")=="False" else print(f"[WARNING] 'end' without matching control block, ignored due to try block.")

            block = self.control_stack.pop()
            debug = self.ctrflwdebug
            block_type = block.get("type")

            if debug:
                print(f"[DEBUG] END:")
                print(f"  popped -> {block}")
                print(f"  type   -> {block.get('type') if isinstance(block, dict) else type(block)}")
                print(f"  full stack -> {self.control_stack if hasattr(self, 'control_stack') else 'NO STACK FOUND'}")
            if block_type == "while":
                if block["executed"]:
                    try:
                        condition_still_true = self.eval_condition(self.replace_variables(block["condition"]))
                    except Exception as e:
                        self.loaderrorcount+=1;self.raiseError(f"--ErrID92: WHILE condition failed at END. Details: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] WHILE condition failed at END. Details: {e}, ignored due to try block.")

                    if condition_still_true:
                        if debug:
                            print(f"[DEBUG] Repeating WHILE: jumping to line {block['start_line']}")
                        self.control_stack.append(block)
                        self.current_line = block["start_line"] - 1
                        return
                    else:
                        if debug:
                            print(f"[DEBUG] Exiting WHILE loop")
                else:
                    if debug:
                        print(f"[DEBUG] Skipping WHILE block recheck (never executed)")

            elif block_type in ("if", "else"):
                if debug:
                    print(f"[DEBUG] Closing {block_type.upper()} block")
            elif block_type =="try":
                self.trystate="False"
                if debug:
                    print(f"[DEBUG] Closing TRY block")
            else:
                self.loaderrorcount+=1;self.raiseError(f"--ErrID93: Unknown control block type '{block_type}' during END.") if getattr(self, "trystate")=="False" else print(f"[WARNING] Unknown control block type '{block_type}' during END.") #just realised this will never be triggered TwT #29.8.25
        def should_execute(self):
            """
            Determine if the current block should execute based on active IF conditions.
            """
            
            if not self.control_stack:
                return True
            for block in reversed(self.control_stack):
                if ((block["type"] == "if" and not block["executed"]) or 
                    (block["type"] == "else" and not block["executed"])):
                    return False

            return True 

        def list_replacer(self, expr):
            """
            Replaces $list[index] patterns in an expression with the actual element.
            Keeps strings quoted so eval won't break.
            """
            pattern = re.compile(r"\$(\w+)\[(\d+)\]")

            def replacer(match):
                var_name, index = match.group(1), int(match.group(2))
                if var_name not in self.variables:
                    self.raiseError(f"--ErrID99: Variable '{var_name}' not defined")
                    return "None"
                value, vtype = self.variables[var_name]
                if vtype != "list":
                    self.raiseError(f"--ErrID100: Variable '{var_name}' is not a list")
                    return "None"
                try:
                    element = value[index]
                    return f'"{element}"' 
                except IndexError:
                    self.raiseError(f"--ErrID101: Index {index} out of range for list '{var_name}'")
                    return "None"
            return pattern.sub(replacer, expr)

        def replace_variables(self, text, quoted=None):
            if not self.should_execute():
                return text

            text = self.list_replacer(text)

            if self.vardebug:
                print(f"[DEBUG] Replacing variables in: {text}")

            def func_replacer(match):
                raw = match.group(1)
                if ":" in raw:
                    func_name, arg_str = raw.split(":", 1)
                    arg_str = arg_str.strip("()")
                    resolved_args = self.replace_variables(arg_str)
                    result = self.cmd_call(f"{func_name} {resolved_args}")
                    return str(result) if result is not None else ""
                return f"<INVALID:{raw}>"

            def var_replacer(match):
                var_name = match.group(1)

                if var_name in self.local_variables:
                    val = self.local_variables[var_name][0]
                elif var_name in self.variables:
                    val = self.variables[var_name][0]
                else:
                    self.raiseError(f"--ErrID94: Variable '{var_name}' not defined.")
                    return ""

                return str(val)

            if self.vardebug:
                print(f"[DEBUG] Final variable replacement in: {text}")
            text = re.sub(r"\$([a-zA-Z_][a-zA-Z0-9_]*)", var_replacer, text)
            text = re.sub(r"##([\w]+:\([^\)]*\))", func_replacer, text)
            return self.replace_nibbits(text)
        def eval_condition(self, condition_str):
            condition_str = self.replace_variables(condition_str, quoted=True)  # Replace variables in the condition
            condition_str = self.replace_nibbits(condition_str)  # Replace nibbits in the condition
            if self.conddebug:
                print(f"[DEBUG] Evaluating condition: {condition_str}")

            def debug(msg):
                if self.conddebug:
                    print(f"[DEBUG] {msg}")
            import ast
            import operator

            _ALLOWED_OPS = {
                ast.Add: operator.add,
                ast.Sub: operator.sub,
                ast.Mult: operator.mul,
                ast.Div: operator.truediv,
                ast.FloorDiv: operator.floordiv,
                ast.Mod: operator.mod,
                ast.Pow: operator.pow,
                ast.USub: operator.neg,
                ast.UAdd: operator.pos,
            }
            def safe_eval_math(expr):
                def _eval(node):
                    if isinstance(node, ast.Constant):
                        if isinstance(node.value, (int, float)):
                            return node.value
                        raise ValueError

                    if isinstance(node, ast.BinOp):
                        return _ALLOWED_OPS[type(node.op)](
                            _eval(node.left),
                            _eval(node.right)
                        )

                    if isinstance(node, ast.UnaryOp):
                        return _ALLOWED_OPS[type(node.op)](_eval(node.operand))

                    raise ValueError

                tree = ast.parse(expr, mode="eval")
                return _eval(tree.body)

            def get_value(token):
                token = token.strip()
                token_lower = token.lower()

                if token_lower in ("true", "false"):
                    val = token_lower == "true"
                    debug(f"Resolved boolean literal {token} -> {val}")
                    return val

                if (token.startswith('"') and token.endswith('"')) or \
                (token.startswith("'") and token.endswith("'")):
                    val = token[1:-1]
                    debug(f"Resolved literal string {token} -> {val!r}")
                    return val

                try:
                    val = safe_eval_math(token)
                    debug(f"Evaluated math expression {token} -> {val}")
                    return val
                except Exception:
                    pass

                try:
                    val = float(token) if "." in token else int(token)
                    debug(f"Parsed numeric literal {token} -> {val!r}")
                    return val
                except ValueError:
                    pass

                debug(f"Interpreting token {token} as string {token!r}")
                return token

            def compare_values(left, op, right):
                debug(f"Comparing {left!r} {op} {right!r}")
                if left is None or right is None:
                    return False
                try:
                    if isinstance(left, (int, float)) and isinstance(right, str):
                        right = float(right) if '.' in right else int(right)
                    elif isinstance(right, (int, float)) and isinstance(left, str):
                        left = float(left) if '.' in left else int(left)
                except:
                    return False

                if op == "==ic":
                    return str(left).lower() == str(right).lower()
                if op == "startswith":
                    return str(left).startswith(str(right))
                if op == "contains":
                    return str(right) in str(left)
                if op == "|+|":
                    return SequenceMatcher(None, str(left), str(right)).ratio() * 100

                return {
                    "==": left == right,
                    "!=": left != right,
                    ">": left > right,
                    "<": left < right,
                    ">=": left >= right,
                    "<=": left <= right
                }.get(op, False)

            def eval_simple(expr):
                expr = expr.strip()
                if expr.startswith("(") and expr.endswith(")"):
                    return self.eval_condition(expr[1:-1])

                ops = ["==ic", "|+|", ">=", "<=", "!=", "==", ">", "<", "startswith", "contains"]
                for op in ops:
                    parts = expr.split(op)
                    if len(parts) == 2:
                        left_raw = parts[0].strip()
                        right_raw = parts[1].strip()

                        left_val = get_value(left_raw)
                        right_val = get_value(right_raw)

                        result = compare_values(left_val, op, right_val)
                        debug(f"Result of {parts[0]} {op} {parts[1]} -> {result}")
                        return result

                val = get_value(expr)
                result = bool(val)
                debug(f"Truth value of {expr!r} -> {result}")
                return result

            def eval_and(term):
                factors = []
                buf = ""
                level = 0
                in_quotes = None
                i = 0
                while i < len(term):
                    ch = term[i]
                    if ch in "\"'":
                        if in_quotes is None:
                            in_quotes = ch
                        elif in_quotes == ch:
                            in_quotes = None
                    if ch == "(" and in_quotes is None:
                        level += 1
                    elif ch == ")" and in_quotes is None:
                        level -= 1
                    if term[i:i+3] == "and" and level == 0 and in_quotes is None:
                        factors.append(buf.strip())
                        buf = ""
                        i += 3
                        continue
                    buf += ch
                    i += 1
                factors.append(buf.strip())

                result = True
                for factor in factors:
                    if factor.startswith("!"):
                        res = not eval_simple(factor[1:])
                    else:
                        res = eval_simple(factor)
                    result = result and bool(res)
                    debug(f"AND so far -> {result}")
                    if not result:
                        break
                return result

            def split_or_blocks(condition_str):
                terms = []
                buf = ""
                level = 0
                in_quotes = None
                i = 0
                while i < len(condition_str):
                    ch = condition_str[i]
                    if ch in "\"'":
                        if in_quotes is None:
                            in_quotes = ch
                        elif in_quotes == ch:
                            in_quotes = None
                    if ch == "(" and not in_quotes:
                        level += 1
                    elif ch == ")" and not in_quotes:
                        level -= 1
                    if condition_str[i:i+2] == "or" and level == 0 and in_quotes is None:
                        terms.append(buf.strip())
                        buf = ""
                        i += 2
                        continue
                    buf += ch
                    i += 1
                terms.append(buf.strip())
                return terms

            final_result = False
            for term in split_or_blocks(condition_str):
                res = eval_and(term)
                debug(f"OR-term '{term}' -> {res}")
                final_result = final_result or res
                if final_result:
                    break
            debug(f"Final result of '{condition_str}' -> {final_result}")
            return final_result


        def cmd_prt(self, raw_args):
            """
            Enhanced print command with styled, formatted, and interactive output.
            """
            if not(self.disableprt):
                if not raw_args:
                    self.loaderrorcount+=1;self.raiseError("--ErrID37: No arguments provided for prt command.")if getattr(self, "trystate")=="False" else print(f"[WARNING] No arguments provided for prt command, ignored due to try block.")
                
                    return
                # Default settings
                settings = {
                    "color_code": "",
                    "alignment": None,
                    "delay": None,
                    "log_message": False,
                    "title": None,
                    "save_to_file": None,
                    "format_type": None,
                    "case": None,
                    "border": None,
                    "text_effect": None,
                }

                try:
                    # Preserve spaces inside quotes
                    args = raw_args[1:-1] if raw_args.startswith('"') and raw_args.endswith('"') else raw_args

                    # Parse settings using regex
                    settings_pattern = re.compile(r"(align|delay|title|tofile|format|case|border|effect|log)(?:=(\S+))?")
                    matches = settings_pattern.findall(args)
                    for key, value in matches:
                        settings[key] = float(value) if key == "delay" else value.lower()

                    # Remove settings from args
                    args = settings_pattern.sub("", args).strip().replace("  ", " ")

                    # Handle log flag
                    if "log" in args.split():
                        args = args.replace("log", "").strip()
                        settings["log_message"] = True

                    # Variable interpolation

                    # Apply case transformations
                    if settings["case"] == "upper":
                        args = args.upper()
                    elif settings["case"] == "lower":
                        args = args.lower()

                    # Apply text alignment
                    if settings["alignment"] == "center":
                        args = args.center(80)
                    elif settings["alignment"] == "right":
                        args = args.rjust(80)
                    elif settings["alignment"] == "left":
                        args = args.ljust(80)

                    # Add borders if specified
                    if settings["border"]:
                        border_char = settings["border"]
                        padding = 1  # space between text and border
                        content_line = f"{border_char}{' ' * padding}{args}{' ' * padding}{border_char}"
                        border_length = len(content_line)
                        
                        border_line = border_char * (border_length // len(border_char))
                        if len(border_line) < border_length:
                            border_line += border_char[:border_length - len(border_line)]  # fill the gap

                        args = f"{border_line}\n{content_line}\n{border_line}"

                    # Apply text effects
                    effect_map = {"bold": "\033[1m", "italic": "\033[3m"}
                    if settings["text_effect"] in effect_map:
                        args = f"{effect_map[settings['text_effect']]}{args}\033[0m"

                    # Update terminal title
                    if settings["title"]:
                        print(f"\033]0;{settings['title']}\a", end="")

                    # Format output
                    if settings["format_type"] == "json":
                        args = json.dumps({"message": args}, indent=4)
                    elif settings["format_type"] == "html":
                        args = f"<p>{args}</p>"

                    # Save output to file
                    if settings["save_to_file"]:
                        with open(settings["save_to_file"], "w") as file:
                            file.write(args + "\n")

                    # Log message if needed
                    if settings["log_message"]:
                        self.log_messages.append(args)
                    args = self.replace_nibbits(args)
                    args=self._decode_escapes(args)
                    # Handle output & animated printing with delay
                    if settings["delay"]:
                        import sys
                        for char in args:
                            sys.stdout.write(settings["color_code"] + char)
                            sys.stdout.flush()
                            time.sleep(settings["delay"])
                        print("\033[0m")  # Reset color
                    elif args.strip() == "output":
                        #print output in ut-8 encoding
                        print(self.output.encode('utf-8', errors='replace').decode('utf-8'))
                    else:
                        print(args.encode('utf-8', errors='replace').decode('utf-8'))
                    if self.prtdebug:
                        print("[DEBUG] Print Settings: ", settings)

                except ValueError as e:
                    self.loaderrorcount+=1;self.raiseError(f"--ErrID38: Value error in prt command. Details: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Value error in prt command. Details: {e}, ignored due to try block.")
                

                except Exception as e:
                    self.raiseError(f"[Uncategorized Error] : {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Uncategorized Error : {e}, ignored due to try block.")

                    
                        
        def _int_replacer(self, args):
            for i in range(len(args)):
                try:
                    expr = str(args[i]).strip()
                    if any(op in expr for op in ['+', '-', '*', '/']):
                        args[i] = int(eval(expr))
                    else:
                        args[i] = int(expr)
                except:
                    pass
            return args

        def _decode_escapes(self, text):
            """Turn escape sequences like \\n into actual newlines."""
            text = text.replace("\\r\\n", "\r\n")
            text = text.replace("\\n", "\n")
            text = text.replace("\\t", "\t")
            text = text.replace("\\r", "\r")
            return text
        def _split_list_literal(self, text):
            """
            Split a list literal safely, respecting quotes and nested brackets.
            Example:
            [1, 2, "Hello, world", [3,4]]
            -> ['1', '2', '"Hello, world"', '[3,4]']
            """
            items, buf = [], ""
            depth = 0
            in_quotes = None

            for ch in text:
                if ch in "\"'":
                    if in_quotes is None:
                        in_quotes = ch
                    elif in_quotes == ch:
                        in_quotes = None
                    buf += ch
                elif ch == "[" and not in_quotes:
                    depth += 1
                    buf += ch
                elif ch == "]" and not in_quotes:
                    depth -= 1
                    buf += ch
                elif ch == "," and depth == 0 and not in_quotes:
                    if buf.strip():
                        items.append(buf.strip())
                    buf = ""
                else:
                    buf += ch

            if buf.strip():
                items.append(buf.strip())

            return items



        def cmd_create_file(self, args):
            parts = shlex.split(args)
            if len(parts) < 2:
                self.loaderrorcount += 1
                self.raiseError("--ErrID50: Missing filename or content for create_file command.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Missing filename or content for create_file command, ignored due to try block.")
               
                return

            filename, content = parts[0], parts[1]
            content = self._decode_escapes(content)
            with open(filename, 'w', encoding='utf-8', errors='replace') as f:
                f.write(content)
            print(f"File '{filename}' created successfully.")

        def cmd_append_file(self, args):
            parts = shlex.split(args)
            if len(parts) < 2:
                self.loaderrorcount += 1
                self.raiseError("--ErrID55: Missing filename or content for append_file command.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Missing filename or content for append_file command, ignored due to try block.")
               
                return

            filename, content = parts[0], parts[1]
            content = self._decode_escapes(content)
            with open(filename, 'a', encoding='utf-8', errors='replace') as f:
                f.write(content)
            print(f"Content appended to file '{filename}' successfully.")


        def cmd_read_file(self, args):
            """
            Reads the content of a file and prints or stores it.
            Syntax: read_file filename [var_name]
            """
            parts = args.split()

            # Ensure the command has at least the required arguments
            if len(parts) < 2:
                self.loaderrorcount+=1;self.raiseError("--ErrID52: Missing filename or variable name for read_file command.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Missing filename or variable name for read_file command, ignored due to try block.")
               

                return

            filename = parts[0]

            # Check if the filename is a variable reference and not a quoted literal
            if filename in self.variables and not (filename.startswith('"') and filename.endswith('"')):
                filename = self.variables[filename][0]

            try:
                with open(filename, 'r', encoding='utf-8', errors='replace') as f:
                    content = f.read()

                var_name = parts[1]  # Store the content in the specified variable
                self.store_variable(var_name, content, "str")
                print(f"File content stored in variable '{var_name}'.")
            except FileNotFoundError:
                self.loaderrorcount+=1;self.raiseError(f"--ErrID53: File '{filename}' not found.")if getattr(self, "trystate")=="False" else print(f"[WARNING] File '{filename}' not found, ignored due to try block.")
               

            except Exception as e:
                self.raiseError(f"[Unrecognised Error] Failed to read file. Error: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Unrecognised Error: Failed to read file. Error: {e}, ignored due to try block.")

        def fetch_data_from_URL(self, url=None, timeout=20):
            install_package("requests")
            """Fetch data from a given URL or from a variable in Var_Reg."""
            if not url:
                self.loaderrorcount+=1;self.raiseError("--ErrID11: No URL or variable provided.")if getattr(self, "trystate")=="False" else print(f"[WARNING] No URL or variable provided, ignored due to try block.")
                self.output = None
               

                return

            if url in self.variables:
                url = self.variables[url]

            if not isinstance(url, str) or not url.strip():
                self.loaderrorcount+=1;self.raiseError("--ErrID12: Invalid URL or variable key provided.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Invalid URL or variable key provided, ignored due to try block.")
                self.output = None
               

                return

            try:
                response = requests.get(url, timeout=timeout)
                response.raise_for_status()
                self.output = response.text.strip()  # Store the fetched data, removing any trailing whitespace
                if self.reqdebug:
                    print(f"[DEBUG] Data fetched and stored in output: {self.output}")
            except requests.exceptions.RequestException as e:
                self.raiseError(f"[Unrecognised Error] Failed to fetch data from URL. Error: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Unrecognised Error: Failed to fetch data from URL. Error: {e}, ignored due to try block.")


        def store_variable(self, var_name, value, data_type, local=False):
            if local:
                target = self.local_variables
            else:
                target = self.variables
            if value == "output":
                value = self.output
            if data_type == "str" and isinstance(value, str):
                if (value.startswith('"') and value.endswith('"')) or \
                (value.startswith("'") and value.endswith("'")):
                    value = value[1:-1]
            if data_type == "list" and not isinstance(value, list):
                value = [value]

            target[var_name] = (value, data_type)
        def handle_command(self, command):
            """Processes commands, handles function definitions, and executes appropriately."""
            if self.REPL == 1 and self.semo == True and not(("semo" in command) and ("setclientrule" in command)):
                self.loaderrorcount+=1;self.raiseError("--ErrID72: Script Execution Mode Only (SEMO) is enabled. Cannot run commands.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Script Execution Mode Only (SEMO) is enabled. Cannot run commands, ignored due to try block.")
            if not command or command.startswith(("//", "\\")):
                return
            if "##" in command and not self.in_function_definition:
                command = self.replace_nibbits(command)
            if getattr(self, "in_function_definition", False):
                if command.strip().lower() == "fncend":
                    if self.cmdhandlingdebug:
                        print(f"[DEBUG] Ending function '{self.current_function_name}'")
                    self.command_mapping["fncend"]()
                    return
                else:
                    self.functions[self.current_function_name]["body"].append(command)
                    if self.cmdhandlingdebug:
                        print(f"[DEBUG] Added line to function '{self.current_function_name}': {command}")
                    return

            is_prt = command.startswith('prt ')
            if is_prt:
                parts = re.findall(r'\S+|\s+', command)
                cmd = 'prt'
                args = command[4:] 
            else:
                command = command.strip()
                parts = command.split()
                if not parts:  
                    return
                cmd = parts[0]
                args = ' '.join(parts[1:]).strip()

            if not is_prt and "//" in args:
                args = self.comment_strip(args)
            if cmd in ("if"):
                args=self.replace_variables(args, True)
            else:
                if not cmd == "while":
                    args = self.replace_variables(args)
                
            if not self.should_execute():
                control_flow_commands = {"else", "end", "while", "if","try"}
                if cmd in control_flow_commands:
                    if self.ctrflwdebug:
                        print(f"[DEBUG] Handling control command '{cmd}' even in inactive block")
                    if cmd in {"else", "end","try"}:
                        self.command_mapping[cmd]()
                    else:
                        self.command_mapping[cmd](args)
                else:
                    if self.cmdhandlingdebug:
                        print(f"[DEBUG] Skipping command '{command}' due to inactive block")
                return

            if cmd in self.command_mapping:
                if self.cmdhandlingdebug:
                    print(f"[DEBUG] Handling command: '{command}'")

                no_arg_commands = {"else", "end", "dev.custom", "flush", "--info", "reinit", "fncend", "try"}
                if cmd in no_arg_commands:
                    self.command_mapping[cmd]()
                else:
                    self.command_mapping[cmd](args)

                if self.cmdhandlingdebug:
                    print(f"[DEBUG] Command '{cmd}' executed with args: '{args}'")
            else:
                self.loaderrorcount+=1;self.raiseError(f"--ErrID73: Unrecognized command: {command}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Unrecognized command: {command}, ignored due to try block.")

        def dev(self, raw_args):
            """
            Enable or disable various debugging options dynamically.
            
            Usage:
            - dev controlflow  → Enables control flow debugging
            - dev print        → Enables print debugging
            - dev math         → Enables math debugging
            - dev file         → Enables file handling debugging
            - dev colorama     → Enables Colorama debugging
            - dev requests     → Enables requests debugging
            - dev condition    → Enables condition evaluation debugging
            - dev variable     → Enables variable handling debugging
            - dev command  → Enables Command handling debugging
            - dev None         → Disables all debugging options
            - dev All          → Enables all debugging options
            """
            
            #  Debugging options dictionary
            debug_options = {
                "controlflow": "ctrflwdebug",
                "print": "prtdebug",
                "math": "mathdebug",
                "file": "filedebug",
                "colorama": "clramadebug",
                "requests": "reqdebug",
                "command": "cmdhandlingdebug",
                "condition": "conddebug",
                "variable": "vardebug",
            }
            if not raw_args.strip():
                print("[SELF-DEBUG] Please provide a debug option (e.g., 'dev controlflow').")
                return
            args = raw_args.lower().split()
            if "all" in args or "none" in args:
                enable = "all" in args
                self.debug = enable
                for attr in debug_options.values():
                    setattr(self, attr, enable)
                print(f"[SELF-DEBUG] {'Enabled' if enable else 'Disabled'} all debugging options.")
                return
            enabled_any = False
            for dbg_option in args:
                if dbg_option in debug_options:
                    current = getattr(self, debug_options[dbg_option])
                    new_state = not current
                    setattr(self, debug_options[dbg_option], new_state)
                    print(f"[SELF-DEBUG] {'Enabled' if new_state else 'Disabled'} debugging for: {dbg_option}")
                    enabled_any = True
                else:
                    print(f"[SELF-DEBUG] Incorrect usage: Unknown debug option '{dbg_option}'.")
            if not enabled_any:
                print("[SELF-DEBUG] No valid debug options provided. Use 'dev All' to enable all.")
   
        def replace_nibbits(self, input_str):
            """
            Replaces ##key and ##key:(arg) additional parameters safely and completely.
            Handles:
                - ##key
                - ##key:with:colons
                - ##key:(argument)
                - ##key:with:colons:(argument)
            Renamed to replace_nibbits because "nibbits" sounds cuter than "additional_parameters" :3 #29.9.25-Raven
            """
            if not self.should_execute():
                return input_str
            if not isinstance(input_str, str):
                return input_str
            if not "##" in input_str:
                return input_str
            
            bracket_pattern = re.compile(r"(##[a-zA-Z_]\w*(?::[a-zA-Z_]\w+)*):\(([^()]*)\)")
            matches = bracket_pattern.findall(input_str)

            for full_key, arg in matches:
                func = self.nibbits.get(full_key)
                arg_value = arg
                if "$" in arg_value:
                    arg_value = self.replace_variables(arg_value)

                try:
                    if callable(func):
                        clean_arg = arg_value.strip()

                        # remove wrapping quotes if present
                        if (clean_arg.startswith('"') and clean_arg.endswith('"')) or \
                        (clean_arg.startswith("'") and clean_arg.endswith("'")):
                            clean_arg = clean_arg[1:-1]

                        result = str(func(clean_arg)) if clean_arg else str(func())
                        if result is None:
                            result = "None"
                    else:
                        #self.loaderrorcount+=1;self.raiseError(f"--ErrID38: Function '{full_key}' not defined.")
                        continue
                except AttributeError:
                    self.loaderrorcount+=1;self.raiseError(f"--ErrID95: Function '{full_key}' not defined.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Function '{full_key}' not defined, ignored due to try block.")
                   
                except TypeError:
                    self.loaderrorcount+=1;self.raiseError(f"--ErrID96: Function '{full_key}' called with incorrect arguments.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Function '{full_key}' called with incorrect arguments, ignored due to try block.")
                   
                except Exception as e:
                    if self.cmdhandlingdebug:
                        print(f"[DEBUG] Error calling function '{full_key}' with args '{arg_value}': {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Error calling function '{full_key}' with args '{arg_value}': {e}, ignored due to try block.")
                    if getattr(self, "trystate")=="True":
                        result = f"<CRITICAL ERROR>"
                    else:
                        self.loaderrorcount+=1;self.raiseError(f"--ErrID15: Error calling function '{full_key}' with args '{arg_value}': {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Error calling function '{full_key}' with args '{arg_value}': {e}, ignored due to try block.")

                input_str = input_str.replace(f"{full_key}:({arg})", result)

            for key in sorted(self.nibbits, key=len, reverse=True):
                func = self.nibbits[key]

                if re.search(rf"{re.escape(key)}:\(", input_str):
                    continue

                if key in input_str:
                    try:
                        result = str(func())
                        if result is None:
                            self.loaderrorcount+=1;self.raiseError(f"--ErrID97: Function '{key}' did not return a value.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Function '{key}' did not return a value, ignored due to try block.")
                    except Exception as e:
                        result = f"<CRITICAL ERROR: {e}>"

                    input_str = input_str.replace(key, result)

            return input_str

        def cmd_reg(self, raw_args):
            raw_args = self.replace_nibbits(raw_args)
            parts = raw_args.strip().split()
            var_type = parts[0]
            var_name = parts[1]
            var_value_raw = " ".join(parts[2:])
            if self.vardebug:
                print(f"[DEBUG] Parsed Variable '{var_name}' of type '{var_type}' with value '{var_value_raw}'")
            try:
                expr = self.replace_variables(var_value_raw)
                if self.mathdebug:
                    print(f"[DEBUG] Final expression to eval: '{expr}'")
                if var_type == "int":
                    final_value = int(eval(expr))
                elif var_type == "float":
                    final_value = float(eval(expr))
                elif var_type == "str":
                    try:
                        expr = expr.strip()

                        # Case 1: Proper quoted string → evaluate safely
                        if (expr.startswith('"') and expr.endswith('"')) or (expr.startswith("'") and expr.endswith("'")):
                            evaluated = eval(expr, {"__builtins__": {}}, {})
                            final_value = str(evaluated)

                        else:
                            # Case 2: Raw value → treat as literal string ALWAYS
                            final_value = str(expr)

                    except Exception as e:
                        if self.vardebug:
                            print(f"[DEBUG] String eval fallback for '{expr}' due to: {e}")
                        final_value = str(expr)
                elif var_type == "list":
                    if expr.startswith("[") and expr.endswith("]"):
                        inner = expr[1:-1].strip()
                        parts = self._split_list_literal(inner)
                        final_value = []
                        for p in parts:
                            try:
                                val = eval(p, {"__builtins__": {}}, {})
                            except Exception:
                                val = p 
                            final_value.append(val)
                    else:
                        final_value = [evaluated]
                elif var_type == "bool":
                    if isinstance(evaluated, bool):
                        final_value = evaluated
                    elif isinstance(evaluated, str):
                        final_value = evaluated.lower() in ("true", "1")
                    else:
                        final_value = bool(evaluated)
                else:
                    final_value = evaluated
            except Exception as e:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID84: Failed to evaluate variable '{var_name}': {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Failed to evaluate variable '{var_name}': {e}, ignored due to try block.")
            if self.vardebug:
                print(f"[DEBUG] Storing variable '{var_name}' = {final_value} (Type: {type(final_value).__name__}) "
                    f"in {'local' if self.in_function_definition else 'global'} scope")
            self.store_variable(var_name, final_value, var_type, local=self.local)
        def cmd_delete_file(self, args):
            """
            Deletes a specified file.
            Syntax: del_file filename
            """
            args = args.strip()
            filename = args
            try:
                os.remove(filename)
                print(f"File '{filename}' deleted successfully.")
            except FileNotFoundError:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID57: File '{filename}' not found.")if getattr(self, "trystate")=="False" else print(f"[WARNING] File '{filename}' not found, ignored due to try block.")

            except PermissionError:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID57P: Permission denied when deleting '{filename}'.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Permission denied when deleting '{filename}', ignored due to try block.")
                
            except Exception as e:
                self.raiseError(f"[Unrecognised Error] Failed to delete file '{filename}'. Error: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Unrecognised Error: Failed to delete file '{filename}'. Error: {e}, ignored due to try block.")

        def cmd_create_dir(self, args):
            """
            Creates a new directory.
            Syntax: create_dir directory_name
            """
            args = args.strip()
            directory_name = args
            try:
                os.makedirs(directory_name, exist_ok=True)
                print(f"Directory '{directory_name}' created successfully.")
            except PermissionError:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID58P: Permission denied when creating '{directory_name}'.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Permission denied when creating '{directory_name}', ignored due to try block.")

            except Exception as e:
                self.raiseError(f"[Unrecognised Error] Failed to create directory '{directory_name}'. Error: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Unrecognised Error: Failed to create directory '{directory_name}'. Error: {e}, ignored due to try block.")

        def cmd_delete_dir(self, args):
            """
            Deletes an empty directory.
            Syntax: delete_dir directory_name
            """
            args = args.strip()
            directory_name = args
            try:
                os.rmdir(directory_name)
                print(f"Directory '{directory_name}' deleted successfully.")
            except FileNotFoundError:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID60: Directory '{directory_name}' not found.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Directory '{directory_name}' not found, ignored due to try block.")

            except OSError:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID61: Directory '{directory_name}' is not empty.")if getattr(self, "trystate")=="False" else    print(f"[WARNING] Directory '{directory_name}' is not empty, ignored due to try block.")

            except PermissionError:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID60P: Permission denied when deleting '{directory_name}'.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Permission denied when deleting '{directory_name}', ignored due to try block.")

            except Exception as e:
                self.raiseError(f"[Unrecognised Error] Failed to delete directory '{directory_name}'. Error: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Unrecognised Error: Failed to delete directory '{directory_name}'. Error: {e}, ignored due to try block.")

        def cmd_search_file(self, args):
            """
            Searches for a keyword or pattern in a file.
            Syntax: search_file filename "keyword"
            Supports: variables, spaces in keywords, UTF-8 files
            """
            try:
                parts = shlex.split(args)  # handles quotes & spaces
                if len(parts) < 2:
                    self.loaderrorcount += 1
                    self.raiseError("--ErrID63: Missing filename or keyword for search_file command.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Missing filename or keyword for search_file command, ignored due to try block.")


                filename, keyword = parts[0], parts[1]
                with open(filename, 'r', encoding='utf-8', errors='replace') as f:
                    lines = f.readlines()

                results = [line.strip() for line in lines if keyword in line]
                if results:
                    print(f"Found {len(results)} matching line(s):")
                    for line in results:
                        print(line)
                else:
                    print(f"No matches found for '{keyword}' in '{filename}'.")
            except FileNotFoundError:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID64: File '{filename}' not found.")if getattr(self, "trystate")=="False" else print(f"[WARNING] File '{filename}' not found, ignored due to try block.")

            except Exception as e:
                self.raiseError(f"[Unrecognised Error] Failed to search file. Error: {e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Unrecognised Error: Failed to search file. Error: {e}, ignored due to try block.")

        def cmd_inp(self, raw_args):
            """
            inp command: Takes user input and stores it as a variable.
            Usage: inp var_name "prompt" [default]
            
            Parameters:
                var_name: Name of the variable to store
                prompt: Text to display when asking for input (in quotes)
                default: (optional) Default value if user enters nothing
            
            Examples:
                inp username "Enter your username"
                inp timeout "Enter timeout in seconds" 30
                inp retry "Retry on failure? (true/false)" false
            """
            try:
                # Check if raw_args is empty or whitespace
                if not raw_args.strip():
                    raise ValueError("No arguments provided")
                    
                # Properly split arguments using shlex (handles quotes correctly)
                args = shlex.split(raw_args)
                
                # Validate argument count
                if len(args) < 1:
                    raise ValueError("Missing arguments. Expected variable name.")
                    
                # Extract and validate arguments
                var_name = args[0]
                if not var_name.isidentifier():
                    raise ValueError(f"'{var_name}' is not a valid variable name")
                if len(args) >= 2:
                    prompt = args[1]
                    default = args[2] if len(args) > 2 else None
                else:
                    prompt = ""
                    default = None

                # Build and display the input prompt
                prompt_text = f"{prompt}"
                if default is not None:
                    prompt_text += f" [default: {default}]"
                prompt_text += ": "
                
                # Get user input
                user_input = input(prompt_text).strip()
                
                # Use default if input is empty and default exists
                if not user_input and default is not None:
                    user_input = default
                elif not user_input:
                    raise ValueError("No input provided and no default specified")
                    
                # Determine the type of input and convert if needed
                if user_input.lower() in ("true", "false"):
                    value = user_input.lower() == "true"
                    var_type = "bool"
                elif user_input.isdigit():
                    value = int(user_input)
                    var_type = "int"
                elif user_input.replace('.', '', 1).isdigit() and user_input.count('.') < 2:
                    value = float(user_input)
                    var_type = "float"
                else:
                    value = f'{user_input}'
                    var_type = "str"
                
                # Store or update the variable
                self.store_variable(var_name, value, var_type, local=self.local)

                
            except Exception as e:
                error_message = f"Error in inp command: {str(e)}"
                if self.control_stack and self.control_stack[-1]["type"] == "try":
                    self.control_stack[-1]["error"] = error_message
                else:
                    self.raiseError(f"[Unrecognised Error] {error_message}")if getattr(self, "trystate")=="False" else print(f"[WARNING] Unrecognised Error: {error_message}, ignored due to try block.")

        def cmd_fetch(self, args):
            if len(args) < 1:
                self.loaderrorcount+=1;self.raiseError("--ErrID3: Incorrect number of arguments for fetch command")if getattr(self, "trystate")=="False" else print(f"[WARNING] Incorrect number of arguments for fetch command, ignored due to try block.")
               
                return
            url = args[0]
            if url in self.variables:           
                self.fetch_data_from_URL(self.variables[url])
            else:
                self.fetch_data_from_URL(args)

        def cmd_exit(self, args=None):
            if args:
                print(f"[Exit]: {args}")
            if self.cmdhandlingdebug:    
                print("[DEBUG] Exiting")
            self.control_stack.clear()
            exit()
        def cmd_return(self, args):
            value = self.replace_variables(args.strip())

            if self.ctrflwdebug:
                print(f"[DEBUG] RETURN triggered with value: {value}")

            self.return_flag = True
            self.return_value = value

            # Clean control stack until function
            while self.control_stack:
                popped = self.control_stack.pop()
                if self.ctrflwdebug:
                    print(f"[DEBUG] RETURN cleanup popping: {popped}")
                if popped.get("type") == "function":
                    break
        def cmd_def(self, args):
            """
            Starts the definition of a new function with optional parameters.
            Syntax:
                def function_name [param1 param2 param3...]
            Example:
                def greet name
                prt "Hello, $name!"
                fncend
            """
            try:
                tokens = args.strip().split()

                #Validate function name
                if not tokens:
                    self.loaderrorcount+=1;self.raiseError("--ErrID103: Missing function name. Usage: def function_name [params]")if getattr(self, "trystate")=="False" else print(f"[WARNING] Missing function name. Usage: def function_name [params], ignored due to try block.")
                   
                    return

                function_name = tokens[0]
                if not function_name.isidentifier():
                    self.loaderrorcount+=1;self.raiseError(f"--ErrID4: Invalid function name '{function_name}'. Must be a valid identifier.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Invalid function name '{function_name}'. Must be a valid identifier, ignored due to try block.")
                   
                    return

                if function_name in self.functions:
                    self.loaderrorcount+=1;self.raiseError(f"--ErrID8: Function '{function_name}' is already defined.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Function '{function_name}' is already defined, ignored due to try block.")
                   
                    return

                #Capture parameters
                params = tokens[1:]  # Remaining tokens are parameters
                if self.ctrflwdebug:
                    print(f"[DEBUG] Defining function '{function_name}' with params: {params}")

                self.functions[function_name] = {
                    "params": params,
                    "body": []
                }

                self.current_function_name = function_name
                self.in_function_definition = True

            except Exception as e:
                self.raiseError(f"{e}")if getattr(self, "trystate")=="False" else print(f"[WARNING] {e}, ignored due to try block.")
               
                
        def cmd_fncend(self):
            """
            Marks the end of a function definition block.
            """
            if not getattr(self, "in_function_definition", False):
                self.loaderrorcount+=1;self.raiseError("--ErrID9: 'fncend' used outside of a function definition.")if getattr(self, "trystate")=="False" else print(f"[WARNING] 'fncend' used outside of a function definition, ignored due to try block.")
               
                return

            if self.ctrflwdebug:
                print(f"[DEBUG] Function '{self.current_function_name}' definition completed.")

            self.in_function_definition = False
            self.current_function_name = None
        
        def cmd_call(self, args):
            """
            Calls a previously defined function, passing arguments as needed.
            Syntax:
                call function_name [args...]
            """
            # SAVE current state
            self.call_stack.append({
                "variables": self.variables.copy(),
                "local_variables": self.local_variables.copy(),
                "local": self.local
            })
            self.local = True
            self.local_variables = {}

            def depth_split(s: str):
                parts = []
                buf = ""
                depth = 0
                in_string = False
                string_char = None

                for ch in s.strip():
                    if ch in ("'", '"'):
                        if not in_string:
                            in_string = True
                            string_char = ch
                        elif string_char == ch:
                            in_string = False
                            string_char = None
                        buf += ch
                        continue

                    if not in_string:
                        if ch in "[{(":
                            depth += 1
                            buf += ch
                        elif ch in "]})":
                            depth -= 1
                            buf += ch
                        elif ch.isspace() and depth == 0:
                            if buf:
                                parts.append(buf)
                                buf = ""
                        else:
                            buf += ch
                    else:
                        buf += ch

                if buf:
                    parts.append(buf)
                return parts

            self.local = True
            try:
                args = int(args)
            except:
                pass

            args = self.replace_nibbits(args)
            parts = depth_split(args)  
            parts = self._int_replacer(parts)

            if not parts:
                self.loaderrorcount += 1
                self.raiseError("--ErrID36: No function name specified in 'call'") if getattr(self, "trystate") == "False" else print(f"[WARNING] No function name specified in 'call', ignored due to try block.")
                return

            function_name = parts[0]
            if function_name not in self.functions:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID37: Function '{function_name}' not defined.") if getattr(self, "trystate") == "False" else print(f"[WARNING] Function '{function_name}' not defined, ignored due to try block.")
                return
            self.control_stack.append({
                "type": "function",
                "name": function_name
            })
            fnc = self.functions[function_name]
            fnc_params = fnc.get("params", [])
            fnc_body = fnc.get("body", [])
            passed_args = parts[1:]
            if len(passed_args) != len(fnc_params):
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID98: Function '{function_name}' expects {len(fnc_params)} args, got {len(passed_args)}") if getattr(self, "trystate") == "False" else print(f"[WARNING] Function '{function_name}' expects {len(fnc_params)} args, got {len(passed_args)}, ignored due to try block.")
                return
            self.local_variables = {}
            for param, value in zip(fnc_params, passed_args):
                self.store_variable(param, value, "str", local=True)
            if self.ctrflwdebug:
                print(f"[DEBUG] Calling function '{function_name}' with arguments: {dict(zip(fnc_params, passed_args))}")
            try:
                for command in fnc_body:
                    self.handle_command(command)
                    if self.return_flag:
                        break
                result = self.return_value
                self.return_flag = False
                self.return_value = None
                state = self.call_stack.pop()

                self.variables = state["variables"]
                self.local_variables = state["local_variables"]
                self.local = state["local"]
                return result
            except RecursionError:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID99: Maximum recursion depth exceeded in function '{function_name}'.") if getattr(self, "trystate") == "False" else print(f"[WARNING] Maximum recursion depth exceeded in function '{function_name}', ignored due to try block.")

        def cmd_switch(self, args):
            """Switch-case implementation."""
            if not args:
                self.loaderrorcount+=1;self.raiseError("--ErrID1: Incorrect number of arguments for switch command")if getattr(self, "trystate")=="False" else print(f"[WARNING] Incorrect number of arguments for switch command, ignored due to try block.")
               

            switch_var = args[0]
            if switch_var not in self.variables:
                self.loaderrorcount+=1;self.raiseError(f"--ErrID31: Variable '{switch_var}' not defined.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Variable '{switch_var}' not defined, ignored due to try block.")
               

            self.control_stack.append({"type": "switch", "variable": self.variables[switch_var][0], "executed": False})

        def cmd_case(self, args):
            """Case block in a switch."""
            if not self.control_stack or self.control_stack[-1]["type"] != "switch":
                self.loaderrorcount+=1;self.raiseError("--ErrID32: 'case' command outside of 'switch' block.")if getattr(self, "trystate")=="False" else print(f"[WARNING] 'case' command outside of 'switch' block, ignored due to try block.")
               

            case_value = args[0]
            current_switch = self.control_stack[-1]
            if not current_switch["executed"] and current_switch["variable"] == case_value:
                current_switch["executed"] = True
                self.handle_command(" ".join(args[1:]))

        def cmd_default(self, args):
            """Default block in a switch."""
            if not self.control_stack or self.control_stack[-1]["type"] != "switch":
                self.loaderrorcount+=1;self.raiseError("--ErrID33: 'default' command outside of 'switch' block.")if getattr(self, "trystate")=="False" else print(f"[WARNING] 'default' command outside of 'switch' block, ignored due to try block.")
               

            self.control_stack[-1]["default"] = args

        def cmd_inc(self, args):
            """Increment a registered integer variable."""
            if len(args) != 1:
                self.loaderrorcount+=1;self.raiseError("--ErrID03: INC requires exactly one argument (variable name).")if getattr(self, "trystate")=="False" else print(f"[WARNING] INC requires exactly one argument (variable name), ignored due to try block.")

            var_name = args[0]
            var_data = self.variables.get(var_name)
            if self.vardebug:
                print(f"[DEBUG] Attempting to increment variable '{var_name}' with data: {var_data}")
            if var_data and var_data[1] == "int":
                new_value = var_data[0] + 1
                self.variables[var_name] = (new_value, "int")
                self._math_ns[var_name]=new_value
                if self.ctrflwdebug:
                    print(f"[DEBUG] INC: {var_name} incremented to {new_value}")
            else:
                self.loaderrorcount+=1;self.raiseError(f"--ErrID34: Variable '{var_name}' is not defined or not an integer.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Variable '{var_name}' is not defined or not an integer, ignored due to try block.")

        def cmd_dec(self, args):
            """Decrement a registered integer variable."""
            if len(args) != 1:
                self.loaderrorcount+=1;self.raiseError("--ErrID03: DEC requires exactly one argument (variable name).")if getattr(self, "trystate")=="False" else print(f"[WARNING] DEC requires exactly one argument (variable name), ignored due to try block.")

            var_name = args[0]
            var_data = self.variables.get(var_name)

            if var_data and var_data[1] == "int":
                new_value = var_data[0] - 1
                self.variables[var_name] = (new_value, "int")
                self._math_ns[var_name]=new_value
                if self.ctrflwdebug:
                    print(f"[DEBUG] DEC: {var_name} decremented to {new_value}")
            else:
                self.loaderrorcount+=1;self.raiseError(f"--ErrID34: Variable '{var_name}' is not defined or not an integer.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Variable '{var_name}' is not defined or not an integer, ignored due to try block.")

        def cmd_wait(self, args):
            """Wait for a specified number of seconds."""
            try:
                duration = int(args)
                time.sleep(duration)
            except ValueError:
                self.loaderrorcount+=1;self.raiseError("--ErrID2: Duration must be an integer.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Duration must be an integer, ignored due to try block.")
               

        def cmd_add(self, args):
            self.perform_arithmetic_operation(args, operation="add")

        def cmd_sub(self, args):
            self.perform_arithmetic_operation(args, operation="sub")

        def cmd_mul(self, args):
            self.perform_arithmetic_operation(args, operation="mul")

        def cmd_div(self, args):
            self.perform_arithmetic_operation(args, operation="div")

        def cmd_mod(self, args):
            self.perform_arithmetic_operation(args, operation="mod")
        def cmd_pow(self, args):
            self.perform_arithmetic_operation(args, operation="pow")
        def cmd_inv_sqrt(self, args):
            self.perform_arithmetic_operation(args, operation="inv_sqrt")
        def cmd_sqrt(self, args):
            """
            Calculates the square root.
            Syntax: sqrt var_name value_or_variable
            Example:
                sqrt result 25
                sqrt result $a
            """
            try:
                parts = args.strip().split()

                if len(parts) != 2:
                    self.loaderrorcount += 1
                    return self.raiseError("--ErrID66: sqrt requires exactly 2 arguments.") \
                        if getattr(self, "trystate") == "False" \
                        else print("[WARNING] sqrt requires exactly 2 arguments, ignored due to try block.")

                out_name, value_token = parts

                # helper: fetch variable (local first)
                def get_var(name):
                    if name in self.local_variables:
                        return self.local_variables[name][0]
                    elif name in self.variables:
                        return self.variables[name][0]
                    else:
                        raise ValueError(f"Variable '{name}' not defined.")

                # --- resolve value ---
                if value_token.startswith("$"):
                    value = get_var(value_token[1:])
                else:
                    try:
                        value = float(value_token) if "." in value_token else int(value_token)
                    except ValueError:
                        raise ValueError(f"Invalid value '{value_token}'")

                # --- validate ---
                if not isinstance(value, (int, float)):
                    raise ValueError("Value must be numeric.")

                if value < 0:
                    raise ValueError("Square root of negative number.")

                # --- compute ---
                result = value ** 0.5

                # --- store ---
                self.store_variable(out_name, result, "float")

                if self.mathdebug:
                    print(f"[DEBUG] SQRT: sqrt({value}) = {result} -> stored in '{out_name}'")

            except Exception as e:
                self.loaderrorcount += 1
                self.raiseError(f"--ErrID66: Failed to calculate square root: {e}") \
                    if getattr(self, "trystate") == "False" \
                    else print(f"[WARNING] Failed to calculate square root: {e}, ignored due to try block.")
        def cmd_fastmath(self,a):
            """
            Syntax: fastmath var_name = expression
            """
            x,e=a.split('=',1);x=x.strip();e=e.strip();c=self._math_cache.get(e)or self._math_cache.setdefault(e,compile(e,'<fm>','eval'));r=eval(c,self._math_ns);self.variables[x]=[r,'float'if isinstance(r,float)else'int'];self._math_ns[x]=r

        def perform_arithmetic_operation(self, args, operation):
            try:
                args = shlex.split(args)

                if len(args) < 2:
                    raise ValueError(f"Syntax: {operation} <var_name> <operand(s)>")

                var_name = args[0]
                op1_token = args[1]
                op2_expr = " ".join(args[2:]) if len(args) > 2 else None
                def get_var(name):
                    if name in self.local_variables:
                        return self.local_variables[name][0]
                    elif name in self.variables:
                        return self.variables[name][0]
                    else:
                        raise ValueError(f"Variable '{name}' not defined.")
                if op1_token.startswith("$"):
                    operand1 = get_var(op1_token[1:])
                else:
                    operand1 = float(op1_token) if '.' in op1_token else int(op1_token)
                def substitute_vars(expr):
                    def replace_var(match):
                        varname = match.group(1)
                        return str(get_var(varname))
                    return re.sub(r'\$([a-zA-Z_]\w*)', replace_var, expr)
                if op2_expr:
                    op2_eval = substitute_vars(op2_expr)

                    if self.cmdhandlingdebug:
                        print(f"[DEBUG] Evaluating op2: '{op2_expr}' -> '{op2_eval}'")

                    operand2 = eval(op2_eval, {"__builtins__": {}})
                else:
                    operand2 = None
                def to_number(x):
                    return float(x) if isinstance(x, float) or '.' in str(x) else int(x)

                operand1 = to_number(operand1)
                if operand2 is not None:
                    operand2 = to_number(operand2)
                if operation == "add":
                    result = operand1 + operand2
                elif operation == "sub":
                    result = operand1 - operand2
                elif operation == "mul":
                    result = operand1 * operand2
                elif operation == "div":
                    if operand2 == 0:
                        raise ZeroDivisionError("Division by zero")
                    result = operand1 / operand2
                elif operation == "mod":
                    if operand2 == 0:
                        raise ZeroDivisionError("Modulo by zero")
                    result = operand1 % operand2
                elif operation == "pow":
                    result = operand1 ** operand2
                elif operation == "sqrt":
                    if operand1 < 0:
                        raise ValueError("Square root of negative number")
                    result = operand1 ** 0.5
                elif operation == "inv_sqrt":
                    if operand1 <= 0:
                        raise ValueError("Inverse square root of non-positive number")
                    result = 1 / (operand1 ** 0.5)
                else:
                    raise ValueError(f"Unknown operation '{operation}'.")

                result_type = "int" if isinstance(result, int) or result == int(result) else "float"
                self.store_variable(var_name, int(result) if result_type == "int" else result, result_type)

                if self.mathdebug:
                    if operand2 is not None:
                        print(f"[DEBUG] {operation.upper()}: {operand1} {operation} {operand2} = {result}")
                    else:
                        print(f"[DEBUG] {operation.upper()}: {operation}({operand1}) = {result}")

            except Exception as e:
                self.raiseError(f"[Unrecognised Error] {e}") \
                    if getattr(self, "trystate") == "False" \
                    else print(f"[WARNING] Unrecognised Error: {e}, ignored due to try block.")
        def try_convert(self, value):
            try:
                return float(value) if '.' in str(value) else int(value)
            except ValueError:
                return None

        def get_variable_value(self, var_name):
            if var_name in self.variables:
                return self.variables[var_name][0]  #  Return the stored value
            return var_name  #  Return the variable name itself if undefined
        def cmd_reworkedflush(self): #to bring back the interpreter to its initial state. 

            self.local_variables.clear()
            self.variables.clear()
            self.functions.clear()
            self.control_stack.clear()
            self.execution_state.clear()
            self.trystate = "False"
            self.return_flag = False
            self.return_value = None
            #Clean python state
            def flush_python_state():
                import gc
                gc.collect()
                for name in dir():
                    if not name.startswith('_'):
                        if name in globals():
                            del globals()[name]
            flush_python_state()
            import datetime, platform, uuid, getpass, socket, traceback, builtins, argparse, time, re, os, shlex, json, difflib, subprocess, importlib, random, math, struct
            if self.cmdhandlingdebug:
                print("[DEBUG] Interpreter state flushed.")
            
        def cmd_goto(self, line_number):
            """
            Moves execution to a specific line in the script file.(Script Execution Mode Only)
            """
            if self.REPL==0:
                try:
                    target_line = int(line_number)
                    if target_line < 1 or target_line > len(self.script_lines):
                        self.loaderrorcount+=1;self.raiseError(f"--ErrID75: Line {target_line} is out of range.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Line {target_line} is out of range, ignored due to try block.")
                        return
                    self.current_line = target_line - 1
                    if self.cmdhandlingdebug:
                        print(f"[DEBUG] Jumping to line {target_line}.")

                except ValueError:
                    self.loaderrorcount+=1;self.raiseError(f"--ErrID76: Invalid line number '{line_number}'. Must be an integer.")if getattr(self, "trystate")=="False" else print(f"[WARNING] Invalid line number '{line_number}'. Must be an integer, ignored due to try block.")
                   
                except Exception as e:
                    self.raiseError(f"[Unrecognised Error]: '{e}'")    if getattr(self, "trystate")=="False" else print(f"[WARNING] Unrecognised Error: '{e}', ignored due to try block.")
            else:
                print(f"[DEBUG] GOTO command is not available in REPL mode.")
    def main():
        try:
            parser = argparse.ArgumentParser(description="X3 Interpreter")
            parser.add_argument('-f', '--file', type=str, help='File to execute as a script')
            parser.add_argument('-d', '--debug', action='store_true', help='Enable debug mode')
            args = parser.parse_args()
            
            #uses debug mode if nessecary idk
            interpreter = Interpreter()

            # If a file is provided, read commands from the file
            if args.file:
                try:
                    with open(args.file, 'r', encoding="UTF-8", errors='replace') as script_file:
                        interpreter.script_lines = script_file.readlines()  # Store all lines in memory
                        interpreter.current_line = 0

                        while interpreter.current_line < len(interpreter.script_lines):
                            line = interpreter.script_lines[interpreter.current_line].strip()
                            interpreter.handle_command(line)
                            interpreter.current_line += 1  # Move to the next line unless `goto` changes it (i hope this doesnt breaks anything)

                except Exception as exc:
                    raise Error(f"[Unrecognised Error] Could not load {args.file} due to reason:{exc}")
                except (KeyboardInterrupt, EOFError):
                    print("\nExiting")
                    interpreter.control_stack.clear()


            else:
                global REPL
                REPL = 1
                interpreter.REPL = 1
                while True:
                    try:
                        user_input = input(">>")
                        interpreter.handle_command(user_input.strip())
                    except (KeyboardInterrupt, EOFError):
                        print("\nExiting.")
                        interpreter.control_stack.clear()
                        break
            if interpreter.control_stack:
                print("--ErrID102: Program ended with unclosed blocks:")
                for block in interpreter.control_stack:
                    print(" -", block["type"])

        except (KeyboardInterrupt, EOFError):
            print("\nExiting.")
            interpreter.control_stack.clear()

        except Exception as e:
            print(f"{e}")
    if __name__ == "__main__":
        main()
except (KeyboardInterrupt, EOFError):
    print("\nExiting")

except Exception as e:
    print(f"--ErrID16: {e},\nTerminating script.")
#Restarting Development - January/26