qubasic 0.10.0__tar.gz → 0.10.1__tar.gz

{qubasic-0.10.0 → qubasic-0.10.1}/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.10.1 (2026-06-19)
+
+Expression, string, and PRINT fixes in the classic-BASIC layer. The quantum
+engine is unchanged.
+
+### Fixed
+- Math functions resolve in any case: `SQRT`, `SIN`, `ABS`, `INT`, ... now work as well as their lowercase spellings, matching the rest of the language. Runtime and string functions (`RND`, `LEFT$`, ...) are likewise case-insensitive.
+- `AND`, `OR`, `NOT`, `XOR`, and `<>` work in every expression context (`LET`, `PRINT`, gate parameters), not only in `IF` conditions. `AND`/`OR`/`XOR` are bitwise on integers (`6 AND 3` = 2) while preserving operator precedence below comparison, so `IF a > b AND c > d` still groups correctly; `NOT` is logical.
+- String variables are fully usable: `LET s$ = "foo" + "bar"`, `LET t$ = LEFT$(s$, 3)`, and other computed strings store their real value in both immediate and program mode, instead of being mistaken for a quoted literal or forced through `float()`.
+- `PRINT` surfaces evaluation errors instead of silently printing the unevaluated source text. Assigning a string to a numeric variable reports a `TYPE MISMATCH` rather than crashing on a float conversion.
+
 ## 0.10.0 (2026-06-19)
 
 Completes the frontier set: fault-tolerant QEC extras and a compilation/resources

{qubasic-0.10.0/qubasic.egg-info → qubasic-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.10.0
+Version: 0.10.1
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -242,7 +242,7 @@ CLEAR x                  Remove a variable
 Arithmetic: `+`, `-`, `*`, `/`, `//`, `%`, `**`
 Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=`
 Logical: `AND`, `OR`, `NOT`, `XOR`
-Bitwise: `AND`, `OR`, `XOR`, `NOT` (on integers)
+Bitwise: `AND`, `OR`, `XOR` on integers (`6 AND 3` = 2); `NOT` is logical
 Hex/binary literals: `&HFF`, `&B10110`
 
 ## Arrays

{qubasic-0.10.0 → qubasic-0.10.1}/README.md

@@ -209,7 +209,7 @@ CLEAR x                  Remove a variable
 Arithmetic: `+`, `-`, `*`, `/`, `//`, `%`, `**`
 Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=`
 Logical: `AND`, `OR`, `NOT`, `XOR`
-Bitwise: `AND`, `OR`, `XOR`, `NOT` (on integers)
+Bitwise: `AND`, `OR`, `XOR` on integers (`6 AND 3` = 2); `NOT` is logical
 Hex/binary literals: `&HFF`, `&B10110`
 
 ## Arrays

{qubasic-0.10.0 → qubasic-0.10.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qubasic"
-version = "0.10.0"
+version = "0.10.1"
 description = "Quantum BASIC Interactive Terminal"
 readme = "README.md"
 requires-python = ">=3.10"

{qubasic-0.10.0 → qubasic-0.10.1/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.10.0
+Version: 0.10.1
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -242,7 +242,7 @@ CLEAR x                  Remove a variable
 Arithmetic: `+`, `-`, `*`, `/`, `//`, `%`, `**`
 Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=`
 Logical: `AND`, `OR`, `NOT`, `XOR`
-Bitwise: `AND`, `OR`, `XOR`, `NOT` (on integers)
+Bitwise: `AND`, `OR`, `XOR` on integers (`6 AND 3` = 2); `NOT` is logical
 Hex/binary literals: `&HFF`, `&B10110`
 
 ## Arrays

{qubasic-0.10.0 → qubasic-0.10.1}/qubasic_core/__init__.py

@@ -28,7 +28,7 @@ __all__ = [
     'GATE_TABLE', 'GATE_ALIASES',
 ]
 
-__version__ = '0.10.0'
+__version__ = '0.10.1'
 
 def __getattr__(name):
     """Lazy import heavy modules on first access."""

{qubasic-0.10.0 → qubasic-0.10.1}/qubasic_core/control_flow.py

@@ -12,7 +12,7 @@ from qubasic_core.engine import ExecResult, ExecOutcome
 from qubasic_core.parser import parse_stmt
 from qubasic_core.statements import (
     RawStmt, RemStmt, MeasureStmt, EndStmt, ReturnStmt, WendStmt,
-    LetArrayStmt, LetStmt, PrintStmt, GotoStmt, GosubStmt,
+    LetArrayStmt, LetStmt, LetStrStmt, PrintStmt, GotoStmt, GosubStmt,
     ForStmt, NextStmt, WhileStmt, IfThenStmt,
     DataStmt, ReadStmt, OnGotoStmt, OnGosubStmt,
     SelectCaseStmt, CaseStmt, EndSelectStmt, ElseStmt, EndIfStmt,
@@ -106,7 +106,20 @@ class ControlFlowMixin:
     def _cf_let_var(self, stmt: str, run_vars: dict[str, Any],
                     parsed: LetStmt) -> tuple[bool, ExecOutcome]:
         name, expr = parsed.name, parsed.expr
-        val = self._eval_with_vars(expr, run_vars)
+        raw = self._safe_eval(expr, extra_ns=run_vars)
+        if isinstance(raw, str):
+            raise RuntimeError(
+                f"TYPE MISMATCH: '{name}' is numeric; use '{name}$' for strings")
+        val = float(raw)
+        run_vars[name] = val
+        self.variables[name] = val
+        return True, ExecResult.ADVANCE
+
+    def _cf_let_str(self, stmt: str, run_vars: dict[str, Any],
+                    parsed: LetStrStmt) -> tuple[bool, ExecOutcome]:
+        """LET v$ = <expr> — assign a string (or number) to a string variable."""
+        name, expr = parsed.name, parsed.expr
+        val = self._eval_string_expr(expr, run_vars)
         run_vars[name] = val
         self.variables[name] = val
         return True, ExecResult.ADVANCE
@@ -167,12 +180,12 @@ class ControlFlowMixin:
         text = re.sub(r'\bTAB\s*\(([^)]+)\)', _spaces, text, flags=re.IGNORECASE)
         if not text.strip():
             return text                      # standalone SPC/TAB -> whitespace
-        try:
-            ns = run_vars.as_dict() if hasattr(run_vars, 'as_dict') else (
-                run_vars if isinstance(run_vars, dict) else dict(run_vars))
-            return str(self._safe_eval(text, extra_ns=ns))
-        except Exception:
-            return text
+        ns = run_vars.as_dict() if hasattr(run_vars, 'as_dict') else (
+            run_vars if isinstance(run_vars, dict) else dict(run_vars))
+        # Surface evaluation errors instead of silently printing the raw source
+        # text (which used to turn PRINT SQRT(9) into the literal "SQRT(9)" and
+        # an undefined variable into its own name).
+        return str(self._safe_eval(text, extra_ns=ns))
 
     def _cf_print(self, stmt: str, run_vars: dict[str, Any],
                   parsed: PrintStmt) -> tuple[bool, ExecOutcome]:
@@ -400,6 +413,7 @@ class ControlFlowMixin:
         WendStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_wend(rv, ls, sl, ip),
         LetArrayStmt:    lambda s, st, p, ls, sl, ip, rv, ef: s._cf_let_array(st, rv, p),
         LetStmt:         lambda s, st, p, ls, sl, ip, rv, ef: s._cf_let_var(st, rv, p),
+        LetStrStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_let_str(st, rv, p),
         PrintStmt:       lambda s, st, p, ls, sl, ip, rv, ef: s._cf_print(st, rv, p),
         GotoStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_goto(st, sl, p),
         GosubStmt:       lambda s, st, p, ls, sl, ip, rv, ef: s._cf_gosub(st, sl, ip, p),

{qubasic-0.10.0 → qubasic-0.10.1}/qubasic_core/expression.py

@@ -94,6 +94,36 @@ def _rewrite_logical_outside_strings(cond: str) -> str:
     return ''.join(parts)
 
 
+def _as_int(x: Any) -> int:
+    """Coerce a BASIC value to int for bitwise AND/OR/XOR.
+
+    QBasic rounds non-integers; truth values and non-numerics fold to 1/0 so
+    ``(a > 0) AND (b > 0)`` works the same as ``6 AND 3``.
+    """
+    if isinstance(x, bool):
+        return int(x)
+    if isinstance(x, int):
+        return x
+    if isinstance(x, float):
+        return int(round(x))
+    return 1 if x else 0
+
+
+def _basic_and(a: Any, b: Any) -> int:
+    """BASIC AND — bitwise on integers, and correct for truth values
+    (1 & 1 == 1, 1 & 0 == 0). Parsed from ``and`` so precedence stays below
+    comparison: ``a > b AND c > d`` groups as ``(a>b) AND (c>d)``."""
+    return _as_int(a) & _as_int(b)
+
+
+def _basic_or(a: Any, b: Any) -> int:
+    return _as_int(a) | _as_int(b)
+
+
+def _basic_xor(a: Any, b: Any) -> int:
+    return _as_int(a) ^ _as_int(b)
+
+
 class ExpressionMixin:
     """AST-based safe expression evaluation. No eval().
 
@@ -126,11 +156,14 @@ class ExpressionMixin:
         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,
+        # AND/OR/XOR are BASIC's bitwise-logical operators (6 AND 3 == 2),
+        # robust to float operands; NOT stays logical so IF NOT flag works
+        # with 0/1 truth values.
+        ast.And: _basic_and,
+        ast.Or: _basic_or,
+        ast.BitAnd: _basic_and,
+        ast.BitOr: _basic_or,
+        ast.BitXor: _basic_xor,
         ast.Invert: operator.invert,
     }
 
@@ -237,6 +270,13 @@ class ExpressionMixin:
             ns['FRE'] = lambda x=0: psutil.virtual_memory().available
         except ImportError:
             ns['FRE'] = lambda x=0: 0
+        # BASIC is case-insensitive for built-in functions and constants, so
+        # register upper- and lower-case aliases for every builtin (SQRT and
+        # sqrt, RND and rnd, LEFT$ and left$). Variables are merged with their
+        # own case in _safe_eval and shadow these.
+        for _name in list(ns.keys()):
+            ns.setdefault(_name.upper(), ns[_name])
+            ns.setdefault(_name.lower(), ns[_name])
         self._base_ns = ns
         return ns
 
@@ -301,9 +341,17 @@ class ExpressionMixin:
         expr_str = str(expr).strip()
         # Normalize FN prefix: "FN square(x)" -> "square(x)"
         expr_str = re.sub(r'\bFN\s+(\w+)\s*\(', r'\1(', expr_str, flags=re.IGNORECASE)
+        # Rewrite BASIC logical/relational operators (AND, OR, NOT, XOR, <>) to
+        # the Python forms the AST understands, only outside quoted strings.
+        # Applied to every expression (LET, PRINT, gate params), not just IF
+        # conditions, so the documented operators work everywhere.
+        expr_str = _rewrite_logical_outside_strings(expr_str)
         # Rewrite numeric literals (&H, &B, $hex addresses) and the string
         # sigil, each only outside quoted string literals.
         expr_str = _replace_dollar_outside_strings(expr_str)
+        # The operator rewrite can pad a leading token (NOT x -> " not x"); strip
+        # so ast.parse(mode='eval') does not reject it as an unexpected indent.
+        expr_str = expr_str.strip()
         if not expr_str:
             raise ValueError("EMPTY EXPRESSION")
         try:
@@ -351,8 +399,11 @@ class ExpressionMixin:
         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 = _rewrite_logical_outside_strings(cond)
+        """Evaluate a boolean condition.
+
+        The operator rewrite (AND/OR/NOT/XOR/<>) now happens inside _safe_eval,
+        so conditions and ordinary expressions share one consistent path.
+        """
         return bool(self._safe_eval(cond, extra_ns=run_vars))
 
     def _run_timer(self) -> float:

{qubasic-0.10.0 → qubasic-0.10.1}/qubasic_core/strings.py

@@ -84,21 +84,19 @@ class StringMixin:
                 ns[k] = v
         return ns
 
-    def _eval_string_expr(self, expr: str) -> str | float:
-        """Evaluate an expression that might return a string."""
+    def _eval_string_expr(self, expr: str, run_vars: dict[str, Any] | None = None) -> str | float:
+        """Evaluate an expression that may return a string or a number.
+
+        Uses the shared AST evaluator so concatenation (``"a" + "b"``), string
+        functions (``LEFT$(s$, 3)``), and string variables resolve to their real
+        values. A multi-part expression like ``"a" + "b"`` is no longer mistaken
+        for a single quoted literal, and a string result is no longer forced
+        through float(). Errors surface instead of silently returning the source.
+        """
         expr = expr.strip()
-        # Quoted string literal
-        if (expr.startswith('"') and expr.endswith('"')) or \
-           (expr.startswith("'") and expr.endswith("'")):
-            return expr[1:-1]
-        # String variable
-        if expr in self.variables and isinstance(self.variables[expr], str):
-            return self.variables[expr]
-        # Try numeric
-        try:
-            return self.eval_expr(expr)
-        except Exception:
-            return expr
+        if run_vars is not None:
+            return self._safe_eval(expr, extra_ns=run_vars)
+        return self._safe_eval(expr)
 
     def cmd_let_str(self, name: str, expr: str) -> None:
         """Assign a string value to a string variable."""

{qubasic-0.10.0 → qubasic-0.10.1}/qubasic_core/terminal.py

@@ -1044,9 +1044,10 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
 
     def cmd_let(self, rest: str) -> None:
         """LET <var> = <expr> — assign a computed value to a variable.
-        Supports record fields (LET p.x = 3.14) and array elements
-        (LET a(0) = PI, LET m(i, j) = x), matching the in-program LET."""
-        from qubasic_core.patterns import RE_LET_ARRAY
+        Supports string variables (LET s$ = "hi"), record fields (LET p.x = 3.14)
+        and array elements (LET a(0) = PI, LET m(i, j) = x), matching the
+        in-program LET."""
+        from qubasic_core.patterns import RE_LET_ARRAY, RE_LET_STR
         am = RE_LET_ARRAY.match(f"LET {rest}")
         if am:
             from qubasic_core.statements import LetArrayStmt
@@ -1056,12 +1057,21 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             self._cf_let_array(f"LET {rest}", self.variables, parsed)
             self.io.writeln(f"{name}({idx_expr.strip()}) = {self.eval_expr(val_expr)}")
             return
+        sm = RE_LET_STR.match(f"LET {rest}")
+        if sm:
+            self.cmd_let_str(sm.group(1), sm.group(2))
+            return
         m = re.match(r'(\w+(?:\.\w+)?)\s*=\s*(.*)', rest)
         if not m:
             self.io.writeln("?USAGE: LET <var> = <expr>")
             return
         name = m.group(1)
-        val = self.eval_expr(m.group(2))
+        raw = self._safe_eval(m.group(2))
+        if isinstance(raw, str):
+            self.io.writeln(
+                f"?TYPE MISMATCH: '{name}' is numeric — use '{name}$' for strings")
+            return
+        val = float(raw)
         self.variables[name] = val
         if '.' in name:  # mirror into the record dict for LIST VARS
             base, field = name.split('.', 1)
@@ -2097,7 +2107,7 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         if not m:
             return False
         name = m.group(1)
-        val = self._eval_string_expr(m.group(2))
+        val = self._eval_string_expr(m.group(2), run_vars)
         run_vars[name] = val
         self.variables[name] = val
         return True

{qubasic-0.10.0 → qubasic-0.10.1}/tests/test_qubasic.py

@@ -1948,6 +1948,74 @@ class TestResources(unittest.TestCase):
         self.assertIsNotNone(t.last_counts)
 
 
+class TestExpressionStringRegressions(unittest.TestCase):
+    """Regression coverage for the expression/string/PRINT fixes:
+    case-insensitive functions, bitwise/logical operators in every expression
+    context, string-variable assignment, and PRINT surfacing errors."""
+
+    def setUp(self):
+        self.t = QBasicTerminal()
+        self.t.num_qubits = 1
+
+    def test_math_functions_case_insensitive(self):
+        # Uppercase now resolves as well as lowercase, and they agree.
+        self.assertAlmostEqual(self.t.eval_expr('SQRT(2)'), math.sqrt(2))
+        self.assertAlmostEqual(self.t.eval_expr('SQRT(2)'), self.t.eval_expr('sqrt(2)'))
+        self.assertAlmostEqual(self.t.eval_expr('SIN(0)'), 0.0)
+        self.assertEqual(self.t.eval_expr('ABS(-5)'), 5.0)
+        self.assertEqual(self.t.eval_expr('INT(-3.2)'), self.t.eval_expr('int(-3.2)'))
+
+    def test_rnd_case_insensitive(self):
+        for expr in ('RND(1)', 'rnd(1)'):
+            v = self.t.eval_expr(expr)
+            self.assertTrue(0.0 <= v < 1.0)
+
+    def test_bitwise_logical_operators_in_expressions(self):
+        # AND/OR/XOR work in ordinary expressions (not just IF) and are bitwise.
+        self.assertEqual(self.t.eval_expr('6 AND 3'), 2.0)
+        self.assertEqual(self.t.eval_expr('5 OR 2'), 7.0)
+        self.assertEqual(self.t.eval_expr('5 XOR 3'), 6.0)
+        # <> works as an expression operator.
+        self.assertTrue(self.t._safe_eval('3 <> 4'))
+        self.assertFalse(self.t._safe_eval('3 <> 3'))
+
+    def test_logical_operator_precedence_preserved(self):
+        # AND must bind below comparison: a > b AND c > d groups correctly.
+        self.assertTrue(self.t._eval_condition('3 > 2 AND 5 > 1', {}))
+        self.assertFalse(self.t._eval_condition('3 > 5 AND 5 > 1', {}))
+        self.assertTrue(self.t._eval_condition('1 > 5 OR 5 > 1', {}))
+        self.assertTrue(self.t._eval_condition('NOT 0', {}))
+        self.assertFalse(self.t._eval_condition('NOT 1', {}))
+
+    def test_string_assignment_program_mode(self):
+        t = QBasicTerminal(); t.num_qubits = 1
+        t.program = {10: 'LET s$ = "foo" + "bar"',
+                     20: 'LET t$ = LEFT$("hello", 3)',
+                     30: 'LET u$ = MID$("hello", 2)'}
+        capture(t.cmd_run)
+        self.assertEqual(t.variables['s$'], 'foobar')
+        self.assertEqual(t.variables['t$'], 'hel')
+        self.assertEqual(t.variables['u$'], 'ello')
+
+    def test_string_assignment_immediate_mode(self):
+        capture(self.t.cmd_let, 's$ = "hi"')
+        self.assertEqual(self.t.variables['s$'], 'hi')
+        capture(self.t.cmd_let, 'g$ = "foo" + "bar"')
+        self.assertEqual(self.t.variables['g$'], 'foobar')
+
+    def test_numeric_var_rejects_string(self):
+        _, out = capture(self.t.cmd_let, 'n = "hi"')
+        self.assertIn('TYPE MISMATCH', out)
+        self.assertNotIn('n', self.t.variables)
+
+    def test_print_surfaces_errors_no_masking(self):
+        # A valid (now case-insensitive) call evaluates instead of printing source.
+        self.assertEqual(self.t._eval_print_item('SQRT(9)', {}), '3.0')
+        # A genuine error is raised, not silently printed as raw text.
+        with self.assertRaises(Exception):
+            self.t._eval_print_item('GARBAGEFUNC(3)', {})
+
+
 if __name__ == '__main__':
     if hasattr(sys.stdout, 'reconfigure'):
         sys.stdout.reconfigure(encoding='utf-8')