qubasic 0.1.0__py3-none-any.whl

qbasic_core/expression.py

@@ -0,0 +1,228 @@
+"""QBASIC expression evaluation — safe AST-based evaluator."""
+
+from __future__ import annotations
+
+import re
+import math
+import ast
+import time
+import random
+import operator
+from typing import Any
+
+
+class ExpressionMixin:
+    """AST-based safe expression evaluation. No eval().
+
+    Requires: TerminalProtocol — uses self.variables, self.arrays.
+    """
+
+    _SAFE_FUNCS = {
+        'sin': math.sin, 'cos': math.cos, 'tan': math.tan,
+        'asin': math.asin, 'acos': math.acos, 'atan': math.atan,
+        'atan2': math.atan2,
+        'sqrt': math.sqrt, 'log': math.log, 'exp': math.exp,
+        'abs': abs, 'int': int, 'float': float,
+        'min': min, 'max': max, 'round': round, 'len': len,
+        'ceil': math.ceil, 'floor': math.floor,
+    }
+    _SAFE_CONSTS = {
+        'PI': math.pi, 'pi': math.pi,
+        'TAU': math.tau, 'tau': math.tau,
+        'E': math.e, 'e': math.e,
+        'SQRT2': math.sqrt(2), 'sqrt2': math.sqrt(2),
+        'True': True, 'False': False,
+    }
+    _AST_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,
+        ast.Not: operator.not_,
+        ast.Eq: operator.eq, ast.NotEq: operator.ne,
+        ast.Lt: operator.lt, ast.LtE: operator.le,
+        ast.Gt: operator.gt, ast.GtE: operator.ge,
+        ast.And: lambda a, b: a and b,
+        ast.Or: lambda a, b: a or b,
+        ast.BitAnd: operator.and_,
+        ast.BitOr: operator.or_,
+        ast.BitXor: operator.xor,
+        ast.Invert: operator.invert,
+    }
+
+    def _ast_eval(self, node: ast.AST, ns: dict[str, Any]) -> Any:
+        """Recursively evaluate an AST node against a safe namespace."""
+        if isinstance(node, ast.Expression):
+            return self._ast_eval(node.body, ns)
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, (int, float, complex, str)):
+                return node.value
+            raise ValueError(f"UNSUPPORTED CONSTANT: {node.value!r}")
+        if isinstance(node, ast.Name):
+            if node.id in ns:
+                return ns[node.id]
+            raise ValueError(f"UNDEFINED: {node.id}")
+        if isinstance(node, ast.UnaryOp):
+            op = self._AST_OPS.get(type(node.op))
+            if op is None:
+                raise ValueError(f"UNSUPPORTED OP: {type(node.op).__name__}")
+            return op(self._ast_eval(node.operand, ns))
+        if isinstance(node, ast.BinOp):
+            op = self._AST_OPS.get(type(node.op))
+            if op is None:
+                raise ValueError(f"UNSUPPORTED OP: {type(node.op).__name__}")
+            return op(self._ast_eval(node.left, ns), self._ast_eval(node.right, ns))
+        if isinstance(node, ast.BoolOp):
+            op = self._AST_OPS.get(type(node.op))
+            if op is None:
+                raise ValueError(f"UNSUPPORTED OP: {type(node.op).__name__}")
+            result = self._ast_eval(node.values[0], ns)
+            for val in node.values[1:]:
+                result = op(result, self._ast_eval(val, ns))
+            return result
+        if isinstance(node, ast.Compare):
+            left = self._ast_eval(node.left, ns)
+            for op_node, comparator in zip(node.ops, node.comparators):
+                op = self._AST_OPS.get(type(op_node))
+                if op is None:
+                    raise ValueError(f"UNSUPPORTED OP: {type(op_node).__name__}")
+                right = self._ast_eval(comparator, ns)
+                if not op(left, right):
+                    return False
+                left = right
+            return True
+        if isinstance(node, ast.Call):
+            if not isinstance(node.func, ast.Name):
+                raise ValueError("ONLY SIMPLE FUNCTION CALLS ALLOWED")
+            fname = node.func.id
+            func = ns.get(fname)
+            if not callable(func):
+                raise ValueError(f"NOT A FUNCTION: {fname}")
+            args = [self._ast_eval(a, ns) for a in node.args]
+            return func(*args)
+        if isinstance(node, ast.IfExp):
+            if self._ast_eval(node.test, ns):
+                return self._ast_eval(node.body, ns)
+            return self._ast_eval(node.orelse, ns)
+        if isinstance(node, ast.Subscript):
+            if isinstance(node.value, ast.Name):
+                name = node.value.id
+                idx = int(self._ast_eval(node.slice, ns))
+                if name in self.arrays:
+                    return self.arrays[name][idx]
+            raise ValueError("UNSUPPORTED SUBSCRIPT")
+        raise ValueError(f"UNSUPPORTED EXPRESSION: {ast.dump(node)}")
+
+    def _safe_eval(self, expr: Any, extra_ns: dict[str, Any] | None = None) -> Any:
+        """Evaluate expression using AST walking — no eval()."""
+        ns = {**self._SAFE_CONSTS, **self._SAFE_FUNCS, **self.variables}
+        if extra_ns:
+            ns.update(extra_ns)
+        for aname, adata in self.arrays.items():
+            ns[aname] = lambda i, d=adata: d[int(i)]
+        # Instance-specific functions
+        ns['RND'] = lambda x=0: random.random()
+        ns['TIMER'] = getattr(self, '_run_timer', time.time)()
+        ns['POS'] = lambda x=0: 0
+        if hasattr(self, '_peek'):
+            ns['PEEK'] = lambda addr: self._peek(addr)
+        if hasattr(self, '_usr_fn'):
+            ns['USR'] = lambda addr: self._usr_fn(addr)
+        if hasattr(self, '_eof'):
+            ns['EOF'] = lambda h: self._eof(h)
+        if hasattr(self, '_get_string_ns'):
+            ns.update(self._get_string_ns())
+        if hasattr(self, '_user_fns'):
+            for fname, fdef in self._user_fns.items():
+                fn_params = fdef['params']
+                fn_body = fdef['body']
+                ns[fname] = lambda *args, p=fn_params, b=fn_body: self._call_user_fn_expr(p, b, args)
+            # Also register without FN prefix and in lowercase for flexible invocation
+            for fname, fdef in self._user_fns.items():
+                fn_params = fdef['params']
+                fn_body = fdef['body']
+                fn = lambda *args, p=fn_params, b=fn_body: self._call_user_fn_expr(p, b, args)
+                # Strip FN prefix if present, add as both upper and lower
+                short = fname[2:] if fname.upper().startswith('FN') else fname
+                ns[short] = fn
+                ns[short.lower()] = fn
+                ns[short.upper()] = fn
+        try:
+            import psutil
+            ns['FRE'] = lambda x=0: psutil.virtual_memory().available
+        except ImportError:
+            ns['FRE'] = lambda x=0: 0
+        # Add Python-safe aliases for all $-suffixed keys in namespace
+        for k, v in list(ns.items()):
+            if '$' in k:
+                ns[k.replace('$', '_S_')] = v
+        # Hex/bin prefix support
+        expr_str = str(expr).strip()
+        expr_str = re.sub(r'&H([0-9A-Fa-f]+)', r'0x\1', expr_str)
+        expr_str = re.sub(r'&B([01]+)', r'0b\1', expr_str)
+        # Normalize FN prefix: "FN square(x)" -> "square(x)"
+        expr_str = re.sub(r'\bFN\s+(\w+)', r'\1', expr_str, flags=re.IGNORECASE)
+        # Normalize $ in identifiers for Python AST compatibility
+        expr_str = re.sub(r'(\w+)\$', r'\1_S_', expr_str)
+        if not expr_str:
+            raise ValueError("EMPTY EXPRESSION")
+        try:
+            tree = ast.parse(expr_str, mode='eval')
+        except SyntaxError as e:
+            raise ValueError(f"SYNTAX ERROR: {e}") from None
+        return self._ast_eval(tree, ns)
+
+    def _parse_matrix(self, text: str) -> list[Any]:
+        """Parse a matrix literal like [[1,0],[0,1]] using AST — no eval()."""
+        ns = {**self._SAFE_CONSTS, **self._SAFE_FUNCS, 'j': 1j, 'im': 1j}
+        try:
+            tree = ast.parse(text.strip(), mode='eval')
+        except SyntaxError as e:
+            raise ValueError(f"MATRIX SYNTAX ERROR: {e}") from None
+        return self._ast_eval_matrix(tree.body, ns)
+
+    def _ast_eval_matrix(self, node: ast.AST, ns: dict[str, Any]) -> Any:
+        """Evaluate an AST node that should resolve to a nested list of numbers."""
+        if isinstance(node, ast.List):
+            return [self._ast_eval_matrix(elt, ns) for elt in node.elts]
+        return complex(self._ast_eval(node, ns))
+
+    def eval_expr(self, expr: str) -> float:
+        """Evaluate a mathematical expression with variables."""
+        try:
+            return float(self._safe_eval(expr))
+        except ValueError:
+            raise
+        except Exception:
+            raise ValueError(f"CANNOT EVALUATE: {expr}")
+
+    def _eval_with_vars(self, expr: str, run_vars: dict[str, Any]) -> float:
+        """Evaluate expression with runtime variables."""
+        return float(self._safe_eval(expr, extra_ns=run_vars))
+
+    def _eval_condition(self, cond: str, run_vars: dict[str, Any]) -> bool:
+        """Evaluate a boolean condition."""
+        cond = cond.replace('<>', '!=').replace('><', '!=')
+        cond = re.sub(r'\bAND\b', ' and ', cond, flags=re.IGNORECASE)
+        cond = re.sub(r'\bOR\b', ' or ', cond, flags=re.IGNORECASE)
+        cond = re.sub(r'\bNOT\b', ' not ', cond, flags=re.IGNORECASE)
+        cond = re.sub(r'\bXOR\b', ' ^ ', cond, flags=re.IGNORECASE)
+        return bool(self._safe_eval(cond, extra_ns=run_vars))
+
+    def _run_timer(self) -> float:
+        """Return elapsed time since terminal start."""
+        return time.time() - getattr(self, '_start_time', time.time())
+
+    def _call_user_fn_expr(self, params: list[str], body: str, args: tuple) -> float:
+        """Call a DEF FN function from within expression evaluation."""
+        if len(args) < len(params):
+            missing = params[len(args):]
+            raise ValueError(
+                f"DEF FN requires {len(params)} argument(s), got {len(args)}; "
+                f"missing: {', '.join(missing)}"
+            )
+        ns: dict[str, Any] = {}
+        for i, pname in enumerate(params):
+            ns[pname] = args[i]
+        return float(self._safe_eval(body, extra_ns=ns))

qbasic_core/file_io.py

@@ -0,0 +1,457 @@
+"""QBASIC file I/O mixin — SAVE, LOAD, INCLUDE, DIR, EXPORT, CSV, OPEN/CLOSE/PRINT#/INPUT#/EOF/LPRINT."""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+
+import numpy as np
+
+from qbasic_core.engine import (
+    GATE_TABLE,
+    MAX_INCLUDE_DEPTH,
+    RE_OPEN, RE_CLOSE, RE_PRINT_FILE, RE_INPUT_FILE, RE_LPRINT,
+)
+
+
+class FileIOMixin:
+    """File I/O commands for QBasicTerminal.
+
+    Requires: TerminalProtocol — uses self.program, self.num_qubits, self.shots,
+    self.sim_method, self.sim_device, self._custom_gates, self.subroutines,
+    self.registers, self.variables, self.last_counts, self.last_circuit,
+    self._include_depth, self._sanitize_path(), self.cmd_new(), self.process().
+    """
+
+    def cmd_save(self, rest: str) -> None:
+        """SAVE <filename> — write program, config, and definitions to a .qb file."""
+        if not rest:
+            self.io.writeln("?USAGE: SAVE <filename>")
+            return
+        try:
+            path = self._sanitize_path(rest)
+        except ValueError as e:
+            self.io.writeln(f"?SAVE ERROR: {e}")
+            return
+        checked = self._check_agent_path(path, "SAVE")
+        if checked is None:
+            return
+        path = checked
+        if not path.endswith('.qb'):
+            path += '.qb'
+        try:
+            with open(path, 'w', encoding='utf-8') as f:
+                # Save config
+                f.write(f"QUBITS {self.num_qubits}\n")
+                f.write(f"SHOTS {self.shots}\n")
+                if self.sim_method != 'automatic':
+                    f.write(f"METHOD {self.sim_method}\n")
+                if self.sim_device != 'CPU':
+                    f.write(f"METHOD {self.sim_device}\n")
+                # Save custom gates as executable UNITARY commands
+                for name, matrix in self._custom_gates.items():
+                    rows = matrix.tolist()
+                    mat_str = '[' + ','.join(
+                        '[' + ','.join(str(v) for v in row) + ']'
+                        for row in rows
+                    ) + ']'
+                    f.write(f"UNITARY {name} = {mat_str}\n")
+                # Save subroutines
+                for name, sub in self.subroutines.items():
+                    if isinstance(sub, list):
+                        f.write(f"DEF {name} = {' : '.join(sub)}\n")
+                    else:
+                        params = f"({', '.join(sub['params'])})" if sub['params'] else ""
+                        f.write(f"DEF {name}{params} = {' : '.join(sub['body'])}\n")
+                # Save registers
+                for name, (start, size) in self.registers.items():
+                    f.write(f"REG {name} {size}\n")
+                # Save variables
+                for name, val in self.variables.items():
+                    f.write(f"LET {name} = {val}\n")
+                # Save program
+                for num in sorted(self.program.keys()):
+                    f.write(f"{num} {self.program[num]}\n")
+            self.io.writeln(f"SAVED {len(self.program)} lines to {path}")
+        except Exception as e:
+            self.io.writeln(f"?SAVE ERROR: {e}")
+
+    def cmd_load(self, rest: str) -> None:
+        """LOAD <filename> — clear state and load a .qb program file."""
+        if not rest:
+            self.io.writeln("?USAGE: LOAD <filename>")
+            return
+        try:
+            path = self._sanitize_path(rest)
+        except ValueError as e:
+            self.io.writeln(f"?LOAD ERROR: {e}")
+            return
+        if os.path.isdir(path):
+            self.io.writeln(f"?{path} is a directory, not a file")
+            return
+        if not path.endswith('.qb') and not os.path.isfile(path):
+            path += '.qb'
+        if not os.path.isfile(path):
+            self.io.writeln(f"?FILE NOT FOUND: {path}")
+            return
+        try:
+            prev_qubits = self.num_qubits
+            prev_shots = self.shots
+            self.cmd_new(silent=True)
+            with open(path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.rstrip('\n\r')
+                    if line and not line.startswith('#'):
+                        self.process(line, track_undo=False)
+            self.io.writeln(f"LOADED {path} ({len(self.program)} lines)")
+            if self.num_qubits != prev_qubits:
+                self.io.writeln(f"  (QUBITS changed: {prev_qubits} -> {self.num_qubits})")
+            if self.shots != prev_shots:
+                self.io.writeln(f"  (SHOTS changed: {prev_shots} -> {self.shots})")
+        except Exception as e:
+            self.io.writeln(f"?LOAD ERROR: {e}")
+
+    def cmd_include(self, rest: str) -> None:
+        """INCLUDE file.qb — merge another program's lines into current.
+
+        Depth-limited to MAX_INCLUDE_DEPTH to prevent infinite recursion.
+        Cycle detection via _include_stack prevents A->B->A loops.
+        SAVE, LOAD, and INCLUDE are blocked inside included files so that
+        an included script cannot write arbitrary files or recurse further
+        without the user's direct interaction.
+        """
+        if self._include_depth >= MAX_INCLUDE_DEPTH:
+            self.io.writeln(f"?INCLUDE DEPTH LIMIT ({MAX_INCLUDE_DEPTH}) — possible recursion")
+            return
+        try:
+            path = self._sanitize_path(rest)
+        except ValueError as e:
+            self.io.writeln(f"?INCLUDE ERROR: {e}")
+            return
+        if not path.endswith('.qb') and not os.path.isfile(path):
+            path += '.qb'
+        if not os.path.isfile(path):
+            self.io.writeln(f"?FILE NOT FOUND: {path}")
+            return
+        resolved = os.path.realpath(path)
+        if resolved in self._include_stack:
+            self.io.writeln(f"?INCLUDE CYCLE: {path} already in include chain")
+            return
+        count = 0
+        self._include_depth += 1
+        self._include_stack.append(resolved)
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.rstrip('\n\r')
+                    if not line or line.startswith('#'):
+                        continue
+                    # Block file-writing commands inside includes
+                    first_word = line.split(None, 1)[0].upper() if line.strip() else ''
+                    if first_word in ('SAVE', 'LOAD', 'EXPORT', 'CSV'):
+                        self.io.writeln(f"  ?BLOCKED IN INCLUDE: {first_word}")
+                        continue
+                    self.process(line, track_undo=False)
+                    count += 1
+        finally:
+            self._include_stack.pop()
+            self._include_depth -= 1
+        self.io.writeln(f"INCLUDED {path} ({count} lines)")
+
+    def cmd_import(self, rest: str) -> None:
+        """IMPORT "file.qb" — load subroutine definitions with namespace prefix.
+
+        DEFs in the imported file are prefixed with the module name.
+        E.g., IMPORT "math.qb" makes DEF ROT available as MATH.ROT.
+        """
+        from qbasic_core.engine import RE_IMPORT
+        m = RE_IMPORT.match(f"IMPORT {rest}") if not rest.startswith('IMPORT') else RE_IMPORT.match(rest)
+        path = rest.strip().strip('"').strip("'")
+        if not path:
+            self.io.writeln('?USAGE: IMPORT "filename"')
+            return
+        try:
+            path = self._sanitize_path(path)
+        except ValueError as e:
+            self.io.writeln(f"?IMPORT ERROR: {e}")
+            return
+        if not path.endswith('.qb') and not os.path.isfile(path):
+            path += '.qb'
+        if not os.path.isfile(path):
+            self.io.writeln(f"?FILE NOT FOUND: {path}")
+            return
+        # Module name from filename (without extension)
+        mod_name = os.path.splitext(os.path.basename(path))[0].upper()
+        # Parse the file for DEF statements
+        import_count = 0
+        with open(path, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.rstrip('\n\r').strip()
+                if not line or line.startswith('#'):
+                    continue
+                # Look for DEF name = body
+                upper = line.upper()
+                if upper.startswith('DEF ') and '=' in line and not upper.startswith('DEF BEGIN'):
+                    from qbasic_core.engine import RE_DEF_SINGLE
+                    dm = RE_DEF_SINGLE.match(line[4:].strip())
+                    if dm:
+                        name = dm.group(1).upper()
+                        params = [p.strip() for p in dm.group(2).split(',')] if dm.group(2) else []
+                        body = [s.strip() for s in dm.group(3).split(':') if s.strip()]
+                        qualified = f"{mod_name}.{name}"
+                        self.subroutines[qualified] = {'body': body, 'params': params}
+                        import_count += 1
+        self.io.writeln(f"IMPORTED {mod_name} ({import_count} definitions from {path})")
+
+    def cmd_dir(self, rest: str = '') -> None:
+        """List .qb files in current or specified directory."""
+        if rest.strip():
+            path = self._sanitize_path(rest)
+        else:
+            path = '.'
+        try:
+            files = [f for f in os.listdir(path) if f.endswith('.qb')]
+            if files:
+                for f in sorted(files):
+                    size = os.path.getsize(os.path.join(path, f))
+                    self.io.writeln(f"  {f:<30} {size:>6} bytes")
+            else:
+                self.io.writeln("  No .qb files found")
+        except Exception as e:
+            self.io.writeln(f"?DIR ERROR: {e}")
+
+    def cmd_export(self, rest: str) -> None:
+        """EXPORT [filename] — export circuit as OpenQASM 3.0."""
+        if self.last_circuit is None:
+            self.io.writeln("?NO CIRCUIT — RUN first")
+            return
+        qasm = None
+        errors = []
+        try:
+            from qiskit.qasm3 import dumps
+            qasm = dumps(self.last_circuit)
+        except Exception as e:
+            errors.append(str(e))
+        if qasm is None:
+            self.io.writeln("?EXPORT: OpenQASM export not available.")
+            for err in errors:
+                self.io.writeln(f"  {err}")
+            return
+        if rest.strip():
+            try:
+                path = self._sanitize_path(rest)
+            except ValueError as e:
+                self.io.writeln(f"?EXPORT ERROR: {e}")
+                return
+            checked = self._check_agent_path(path, "EXPORT")
+            if checked is None:
+                return
+            path = checked
+            if os.path.exists(path):
+                self.io.writeln(f"  (overwriting {path})")
+            with open(path, 'w', encoding='utf-8') as f:
+                f.write(qasm)
+            self.io.writeln(f"EXPORTED to {path} (OpenQASM 3.0)")
+        else:
+            self.io.writeln(qasm)
+
+    def cmd_csv(self, rest: str) -> None:
+        """CSV [filename] — export last results to CSV."""
+        if self.last_counts is None:
+            self.io.writeln("?NO RESULTS — RUN first")
+            return
+        total = sum(self.last_counts.values())
+        lines = ["state,count,probability"]
+        for state, count in sorted(self.last_counts.items(), key=lambda x: -x[1]):
+            lines.append(f"{state},{count},{count/total:.6f}")
+        if rest.strip():
+            try:
+                path = self._sanitize_path(rest)
+            except ValueError as e:
+                self.io.writeln(f"?CSV ERROR: {e}")
+                return
+            checked = self._check_agent_path(path, "CSV")
+            if checked is None:
+                return
+            path = checked
+            if os.path.exists(path):
+                self.io.writeln(f"  (overwriting {path})")
+            with open(path, 'w', encoding='utf-8') as f:
+                f.write('\n'.join(lines) + '\n')
+            self.io.writeln(f"EXPORTED {len(self.last_counts)} states to {path}")
+        else:
+            for line in lines[:20]:
+                self.io.writeln(f"  {line}")
+            if len(lines) > 20:
+                self.io.writeln(f"  ... ({len(lines)-20} more)")
+
+    # ── File handles: OPEN, CLOSE, PRINT#, INPUT#, EOF, LPRINT ────────
+
+    def _init_file_handles(self) -> None:
+        self._file_handles: dict[int, Any] = {}
+        self._lprint_path: str | None = None
+
+    def _check_agent_path(self, path: str, cmd: str) -> str | None:
+        """In agent mode, restrict paths to cwd. Returns resolved path or None on error.
+
+        Uses pathlib is_relative_to for safe containment check instead of
+        string prefix matching, which can be bypassed via symlinks or
+        crafted path components that share a common prefix string.
+        """
+        if not self.agent_mode:
+            return path
+        from pathlib import Path
+        resolved = Path(os.path.realpath(os.path.join(os.getcwd(), path)))
+        cwd_real = Path(os.path.realpath(os.getcwd()))
+        if not resolved.is_relative_to(cwd_real):
+            self.io.writeln(f"?{cmd} BLOCKED: path escapes working directory in agent mode")
+            return None
+        return str(resolved)
+
+    def cmd_open(self, rest: str) -> None:
+        """OPEN file FOR INPUT|OUTPUT|APPEND AS #n [ENCODING "enc"]"""
+        m = RE_OPEN.match(f"OPEN {rest}")
+        if not m:
+            self.io.writeln('?USAGE: OPEN "file" FOR INPUT|OUTPUT|APPEND AS #n [ENCODING "enc"]')
+            return
+        path, mode_str, handle = m.group(1).strip(), m.group(2).upper(), int(m.group(3))
+        encoding = m.group(4).strip() if m.group(4) else 'utf-8'
+        try:
+            path = self._sanitize_path(path)
+        except ValueError as e:
+            self.io.writeln(f"?OPEN ERROR: {e}")
+            return
+        checked = self._check_agent_path(path, "OPEN")
+        if checked is None:
+            return
+        path = checked
+        mode_map = {'INPUT': 'r', 'OUTPUT': 'w', 'APPEND': 'a', 'RANDOM': 'r+'}
+        mode = mode_map.get(mode_str, 'r')
+        try:
+            if encoding.lower() == 'binary':
+                bin_mode = mode + 'b'
+                if mode_str == 'RANDOM' and not os.path.isfile(path):
+                    open(path, 'wb').close()
+                if mode_str == 'RANDOM' and os.path.isfile(path):
+                    self.io.writeln(f"  (opening existing file {path} for random access)")
+                self._file_handles[handle] = open(path, bin_mode)
+            else:
+                if mode_str == 'RANDOM' and not os.path.isfile(path):
+                    open(path, 'w', encoding=encoding).close()
+                if mode_str == 'RANDOM' and os.path.isfile(path):
+                    self.io.writeln(f"  (opening existing file {path} for random access)")
+                self._file_handles[handle] = open(path, mode, encoding=encoding)
+            self.io.writeln(f"OPENED #{handle} ({path}, {mode_str})")
+        except Exception as e:
+            self.io.writeln(f"?OPEN ERROR: {e}")
+
+    def cmd_close(self, rest: str) -> None:
+        """CLOSE #n — close a file handle."""
+        m = RE_CLOSE.match(f"CLOSE {rest}")
+        if not m:
+            self.io.writeln("?USAGE: CLOSE #n")
+            return
+        handle = int(m.group(1))
+        if handle in self._file_handles:
+            self._file_handles[handle].close()
+            del self._file_handles[handle]
+            self.io.writeln(f"CLOSED #{handle}")
+        else:
+            self.io.writeln(f"?HANDLE #{handle} NOT OPEN")
+
+    def _exec_print_file(self, stmt: str, run_vars: dict[str, Any]) -> bool:
+        """Handle PRINT #n, data during execution."""
+        m = RE_PRINT_FILE.match(stmt)
+        if not m:
+            return False
+        handle = int(m.group(1))
+        data = m.group(2).strip()
+        if handle not in self._file_handles:
+            self.io.writeln(f"?HANDLE #{handle} NOT OPEN")
+            return True
+        f = self._file_handles[handle]
+        fmode = getattr(f, 'mode', '')
+        if fmode.startswith('r') and '+' not in fmode:
+            self.io.writeln(f"?HANDLE #{handle} NOT OPEN FOR WRITING")
+            return True
+        # Evaluate data
+        if (data.startswith('"') and data.endswith('"')):
+            f.write(data[1:-1] + '\n')
+        else:
+            try:
+                val = self._eval_with_vars(data, run_vars) if run_vars else self.eval_expr(data)
+                f.write(str(val) + '\n')
+            except Exception:
+                f.write(data + '\n')
+        f.flush()
+        return True
+
+    def _exec_input_file(self, stmt: str, run_vars: dict[str, Any]) -> bool:
+        """Handle INPUT #n, var during execution."""
+        m = RE_INPUT_FILE.match(stmt)
+        if not m:
+            return False
+        handle = int(m.group(1))
+        var = m.group(2)
+        if handle not in self._file_handles:
+            self.io.writeln(f"?HANDLE #{handle} NOT OPEN")
+            return True
+        f = self._file_handles[handle]
+        fmode = getattr(f, 'mode', '')
+        if fmode.startswith(('w', 'a')) and '+' not in fmode:
+            self.io.writeln(f"?HANDLE #{handle} NOT OPEN FOR READING")
+            return True
+        line = f.readline()
+        if not line:
+            run_vars[var] = 0
+            self.variables[var] = 0
+        else:
+            line = line.strip()
+            if var.endswith('$'):
+                run_vars[var] = line
+                self.variables[var] = line
+            else:
+                try:
+                    val = float(line) if '.' in line else int(line)
+                except ValueError:
+                    val = line
+                run_vars[var] = val
+                self.variables[var] = val
+        return True
+
+    def _exec_lprint(self, stmt: str, run_vars: dict[str, Any]) -> bool:
+        """Handle LPRINT data — output to log file or stderr."""
+        m = RE_LPRINT.match(stmt)
+        if not m:
+            return False
+        data = m.group(1).strip()
+        if (data.startswith('"') and data.endswith('"')):
+            text = data[1:-1]
+        else:
+            try:
+                text = str(self._eval_with_vars(data, run_vars) if run_vars else self.eval_expr(data))
+            except Exception:
+                text = data
+        if self._lprint_path:
+            with open(self._lprint_path, 'a', encoding='utf-8') as f:
+                f.write(text + '\n')
+        else:
+            print(text, file=sys.stderr)
+        return True
+
+    def _eof(self, handle: float) -> float:
+        """EOF(n) — return 1 if at end of file, 0 otherwise."""
+        h = int(handle)
+        if h not in self._file_handles:
+            return 1.0
+        f = self._file_handles[h]
+        pos = f.tell()
+        try:
+            ch = f.read(1)
+            if not ch:
+                return 1.0
+            f.seek(pos)
+        except (UnicodeDecodeError, Exception):
+            return 1.0
+        return 0.0