qubasic 0.10.0__tar.gz → 0.11.0__tar.gz

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

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.11.0 (2026-06-19)
+
+Convention-conformance and observability pass: make the language behave the way
+a Qiskit/Python/BASIC user already expects, and make hidden state legible. The
+quantum engine is unchanged.
+
+### Added
+- `STATUS` (and `STATUS JSON`): dumps every active mode (qubits, shots, method, device, seed, `OPTION BASE`, LOCC mode, noise, coupling/basis, pending `SET_STATE`/`SET_DENSITY`, bank) so behavior can be read instead of inferred.
+- Implicit `LET`: a bare assignment works without the keyword (`x = 5`, `s$ = "hi"`, `a(1) = 5`), as in every BASIC.
+- `FIX(x)` truncates toward zero, complementing `INT`.
+- Histograms print a `q(n-1) ... q1 q0` bit-order header and the JSON result carries a `bit_order` field, making the little-endian convention (qubit 0 = rightmost) explicit.
+
+### Changed
+- `INT(x)` floors toward negative infinity (`INT(-3.2)` = -4), matching QBASIC; use `FIX` for truncation toward zero.
+- Built-in constants (`PI`, `E`, `TAU`, `SQRT2`) are reserved: a same-named variable can no longer silently shadow them, and assigning one is an error.
+- `MEAS` without a target bit reports a clear error distinguishing it from `MEASURE` (mid-circuit measurement into a classical bit vs collapse into the histogram) instead of `UNKNOWN GATE`.
+
+## 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.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.10.0
+Version: 0.11.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -209,6 +209,8 @@ QUBITS 8             Set qubit count (1-32)
 SHOTS 2048           Set measurement shots
 METHOD statevector   Set simulation method
 METHOD GPU           Set simulation device
+STATUS               Show every active mode (qubits, method, LOCC, noise, ...)
+STATUS JSON          Same, as machine-readable JSON
 ```
 
 ### Simulation methods
@@ -220,17 +222,19 @@ Automatic selection: stabilizer for Clifford-only circuits, MPS for >28 qubits,
 
 ```
 LET angle = PI/4
-LET x = sin(angle) * 2
+x = sin(angle) * 2       LET is optional (x = 5 also works)
 10 RX angle, 0           Use in gate parameters
 VARS                     List all variables
 CLEAR x                  Remove a variable
 ```
 
+Functions and keywords are case-insensitive (`SQRT` and `sqrt` both work).
+
 ### Constants
-`PI`, `TAU`, `E`, `SQRT2`, `True`, `False`
+`PI`, `TAU`, `E`, `SQRT2`, `True`, `False` (reserved; not usable as variable names)
 
 ### Math functions
-`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int`, `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
+`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int` (floors), `fix` (truncates), `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
 
 ### Runtime functions
 `RND(x)` random, `TIMER` elapsed seconds, `FRE(0)` free RAM bytes, `POS(0)` cursor column, `PEEK(addr)` memory read, `USR(addr)` call routine
@@ -242,7 +246,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
@@ -364,6 +368,8 @@ DECOMPOSE                Gate count breakdown
 DENSITY                  Density matrix
 ```
 
+Bitstrings are little-endian: qubit 0 is the rightmost character. Histograms print a `q(n-1) ... q1 q0` header so the mapping is explicit.
+
 ### Screen modes
 ```
 SCREEN 0                 Text (default)

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

@@ -176,6 +176,8 @@ QUBITS 8             Set qubit count (1-32)
 SHOTS 2048           Set measurement shots
 METHOD statevector   Set simulation method
 METHOD GPU           Set simulation device
+STATUS               Show every active mode (qubits, method, LOCC, noise, ...)
+STATUS JSON          Same, as machine-readable JSON
 ```
 
 ### Simulation methods
@@ -187,17 +189,19 @@ Automatic selection: stabilizer for Clifford-only circuits, MPS for >28 qubits,
 
 ```
 LET angle = PI/4
-LET x = sin(angle) * 2
+x = sin(angle) * 2       LET is optional (x = 5 also works)
 10 RX angle, 0           Use in gate parameters
 VARS                     List all variables
 CLEAR x                  Remove a variable
 ```
 
+Functions and keywords are case-insensitive (`SQRT` and `sqrt` both work).
+
 ### Constants
-`PI`, `TAU`, `E`, `SQRT2`, `True`, `False`
+`PI`, `TAU`, `E`, `SQRT2`, `True`, `False` (reserved; not usable as variable names)
 
 ### Math functions
-`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int`, `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
+`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int` (floors), `fix` (truncates), `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
 
 ### Runtime functions
 `RND(x)` random, `TIMER` elapsed seconds, `FRE(0)` free RAM bytes, `POS(0)` cursor column, `PEEK(addr)` memory read, `USR(addr)` call routine
@@ -209,7 +213,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
@@ -331,6 +335,8 @@ DECOMPOSE                Gate count breakdown
 DENSITY                  Density matrix
 ```
 
+Bitstrings are little-endian: qubit 0 is the rightmost character. Histograms print a `q(n-1) ... q1 q0` header so the mapping is explicit.
+
 ### Screen modes
 ```
 SCREEN 0                 Text (default)

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.10.0
+Version: 0.11.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -209,6 +209,8 @@ QUBITS 8             Set qubit count (1-32)
 SHOTS 2048           Set measurement shots
 METHOD statevector   Set simulation method
 METHOD GPU           Set simulation device
+STATUS               Show every active mode (qubits, method, LOCC, noise, ...)
+STATUS JSON          Same, as machine-readable JSON
 ```
 
 ### Simulation methods
@@ -220,17 +222,19 @@ Automatic selection: stabilizer for Clifford-only circuits, MPS for >28 qubits,
 
 ```
 LET angle = PI/4
-LET x = sin(angle) * 2
+x = sin(angle) * 2       LET is optional (x = 5 also works)
 10 RX angle, 0           Use in gate parameters
 VARS                     List all variables
 CLEAR x                  Remove a variable
 ```
 
+Functions and keywords are case-insensitive (`SQRT` and `sqrt` both work).
+
 ### Constants
-`PI`, `TAU`, `E`, `SQRT2`, `True`, `False`
+`PI`, `TAU`, `E`, `SQRT2`, `True`, `False` (reserved; not usable as variable names)
 
 ### Math functions
-`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int`, `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
+`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int` (floors), `fix` (truncates), `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
 
 ### Runtime functions
 `RND(x)` random, `TIMER` elapsed seconds, `FRE(0)` free RAM bytes, `POS(0)` cursor column, `PEEK(addr)` memory read, `USR(addr)` call routine
@@ -242,7 +246,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
@@ -364,6 +368,8 @@ DECOMPOSE                Gate count breakdown
 DENSITY                  Density matrix
 ```
 
+Bitstrings are little-endian: qubit 0 is the rightmost character. Histograms print a `q(n-1) ... q1 q0` header so the mapping is explicit.
+
 ### Screen modes
 ```
 SCREEN 0                 Text (default)

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

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

{qubasic-0.10.0 → qubasic-0.11.0}/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,
@@ -73,6 +73,7 @@ class ControlFlowMixin:
     def _cf_let_array(self, stmt: str, run_vars: dict[str, Any],
                       parsed: LetArrayStmt) -> tuple[bool, ExecOutcome]:
         name, idx_expr, val_expr = parsed.name, parsed.index_expr, parsed.value_expr
+        self._assert_assignable(name)
         base = getattr(self, '_option_base', 0)
         val = self._eval_with_vars(val_expr, run_vars)
         parts = self._split_arg_list(idx_expr)
@@ -106,7 +107,21 @@ 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)
+        self._assert_assignable(name)
+        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 +182,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 +415,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.11.0}/qubasic_core/display.py

@@ -40,12 +40,33 @@ class DisplayMixin:
         Console(file=buf, highlight=False, force_terminal=force).print(*renderables)
         self.io.write(buf.getvalue())
 
+    def _bit_order_note(self, display: list) -> str | None:
+        """Human-facing reminder of which bit is which qubit.
+
+        Bitstrings are little-endian (qubit 0 is the rightmost character), the
+        most common source of off-by-reverse mistakes when reading a histogram.
+        When the result covers the whole register the positions are labelled
+        q(n-1) ... q1 q0; for a measured subset only the convention is shown.
+        """
+        if not display:
+            return None
+        nbits = len(display[0][0])
+        nq = getattr(self, 'num_qubits', nbits)
+        if nbits == nq and nbits <= 16:
+            labels = ' '.join(f'q{i}' for i in range(nbits - 1, -1, -1))
+            return f"  bit order  {labels}   (qubit 0 = rightmost)"
+        return "  bit order  qubit 0 = rightmost bit"
+
     def print_histogram(self, counts: dict[str, int]) -> None:
         """Measurement histogram with optional rich-table formatting."""
         total = sum(counts.values())
         sorted_counts = sorted(counts.items(), key=lambda x: -x[1])
         display = sorted_counts[:MAX_HISTOGRAM_STATES]
 
+        note = self._bit_order_note(display)
+        if note:
+            self.io.writeln(note)
+
         if _RICH:
             self._print_histogram_rich(display, sorted_counts, total)
         else:

{qubasic-0.10.0 → qubasic-0.11.0}/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().
 
@@ -105,7 +135,9 @@ class ExpressionMixin:
         '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,
+        # INT floors toward negative infinity, as in QBASIC (INT(-3.2) = -4).
+        # FIX truncates toward zero (FIX(-3.2) = -3) for the other convention.
+        'abs': abs, 'int': math.floor, 'fix': math.trunc, 'float': float,
         'min': min, 'max': max, 'round': round, 'len': len,
         'ceil': math.ceil, 'floor': math.floor,
     }
@@ -126,11 +158,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 +272,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 +343,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,10 +401,23 @@ 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))
 
+    # Built-in constant names that may not be used as variable/array names, so a
+    # value like E never silently shadows (or is shadowed by) the constant.
+    _RESERVED_CONST_NAMES = frozenset({'PI', 'TAU', 'E', 'SQRT2', 'TRUE', 'FALSE'})
+
+    def _assert_assignable(self, name: str) -> None:
+        """Reject assignment to a built-in constant name (case-insensitive)."""
+        if name.upper() in self._RESERVED_CONST_NAMES:
+            raise ValueError(
+                f"RESERVED: '{name}' is a built-in constant; choose another name")
+
     def _run_timer(self) -> float:
         """Return elapsed time since terminal start."""
         return time.time() - getattr(self, '_start_time', time.time())

{qubasic-0.10.0 → qubasic-0.11.0}/qubasic_core/parser.py

@@ -22,6 +22,7 @@ from qubasic_core.patterns import (
     RE_LPRINT, RE_SCREEN, RE_COLOR, RE_LOCATE,
     RE_ON_MEASURE, RE_ON_TIMER, RE_IMPORT, RE_CHAIN, RE_MERGE,
     RE_LET_STR, RE_DIM_MULTI, RE_MEASURE_BASIS, RE_SYNDROME,
+    RE_IMPLICIT_ASSIGN,
 )
 from qubasic_core.statements import (
     Stmt, RawStmt, GateStmt, RemStmt, MeasureStmt, EndStmt, ReturnStmt,
@@ -578,6 +579,15 @@ def parse_stmt(raw: str) -> Stmt:
         if len(parts) > 1:
             return CompoundStmt(raw=raw, parts=tuple(parts))
 
+    # ── Implicit LET (assignment without the LET keyword) ──────────
+    # A line whose lvalue is followed by a single '=' is an assignment, even
+    # when it collides with a gate name (X = 5 is "assign X", not the X gate).
+    # Tried before gate dispatch so bare assignment works as in every BASIC.
+    if RE_IMPLICIT_ASSIGN.match(text):
+        result = _handle_let(f"LET {text}", raw)
+        if result is not None:
+            return result
+
     # ── Gate application ────────────────────────────────────────────
     canonical = GATE_ALIASES.get(first_word, first_word)
     if canonical in GATE_TABLE:

{qubasic-0.10.0 → qubasic-0.11.0}/qubasic_core/patterns.py

@@ -102,6 +102,11 @@ RE_ON_MEASURE = re.compile(r'ON\s+MEASURE\s+GOSUB\s+(\d+)', re.IGNORECASE)
 RE_ON_TIMER = re.compile(r'ON\s+TIMER\s*\((\d+)\)\s+GOSUB\s+(\d+)', re.IGNORECASE)
 RE_DIM_MULTI = re.compile(r'DIM\s+(\w+)\((\d+(?:\s*,\s*\d+)*)\)', re.IGNORECASE)
 RE_LET_STR = re.compile(r'LET\s+(\w+\$)\s*=\s*(.*)', re.IGNORECASE)
+# Implicit LET: an assignment written without the LET keyword (x = 5, s$ = "hi",
+# a(1) = 5, p.x = 3). Anchored lvalue followed by a single '=' that is not part
+# of '==' / '<=' / '>=' / '!=' / '<>'. Routed through the LET handlers.
+RE_IMPLICIT_ASSIGN = re.compile(
+    r'[A-Za-z_]\w*\$?(?:\.\w+)?(?:\([^)]*\))?\s*=(?!=)', re.IGNORECASE)
 
 __all__ = [
     "RE_LINE_NUM",
@@ -185,4 +190,5 @@ __all__ = [
     "RE_ON_TIMER",
     "RE_DIM_MULTI",
     "RE_LET_STR",
+    "RE_IMPLICIT_ASSIGN",
 ]

{qubasic-0.10.0 → qubasic-0.11.0}/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.11.0}/qubasic_core/terminal.py

@@ -508,6 +508,7 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         'LIST': 'cmd_list', 'QUBITS': 'cmd_qubits', 'SHOTS': 'cmd_shots',
         'METHOD': 'cmd_method', 'DEF': 'cmd_def', 'REG': 'cmd_reg',
         'LET': 'cmd_let', 'STATE': 'cmd_state', 'BLOCH': 'cmd_bloch',
+        'STATUS': 'cmd_status',
         'DEMO': 'cmd_demo', 'DELETE': 'cmd_delete', 'RENUM': 'cmd_renum',
         'SAVE': 'cmd_save', 'LOAD': 'cmd_load', 'SWEEP': 'cmd_sweep',
         'INCLUDE': 'cmd_include', 'EXPORT': 'cmd_export',
@@ -593,6 +594,17 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             except Exception as e:
                 self.io.writeln(f"?ERROR: {e}")
         else:
+            # Implicit LET: a bare assignment (x = 5, s$ = "hi") routed to the
+            # LET handler so it works without the keyword, as in every BASIC.
+            from qubasic_core.patterns import RE_IMPLICIT_ASSIGN
+            if RE_IMPLICIT_ASSIGN.match(line.strip()):
+                try:
+                    self.cmd_let(line.strip())
+                except QBasicError as e:
+                    self.io.writeln(f"?{e.message}")
+                except Exception as e:
+                    self.io.writeln(f"?ERROR: {e}")
+                return
             # Try as immediate gate / subroutine
             try:
                 self.run_immediate(line)
@@ -1044,9 +1056,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 +1069,22 @@ 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))
+        self._assert_assignable(name)
+        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)
@@ -1070,6 +1093,78 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
                 rec[field] = val
         self.io.writeln(f"{name} = {val}")
 
+    def _status_dict(self) -> dict:
+        """Snapshot every active mode that silently changes how a line behaves.
+
+        Returned as plain JSON-serializable values so a caller can read context
+        instead of inferring it from prior commands.
+        """
+        cmap = getattr(self, '_coupling_map', None)
+        return {
+            'qubits': self.num_qubits,
+            'shots': self.shots,
+            'method': self.sim_method,
+            'device': self.sim_device,
+            'seed': getattr(self, '_seed', None),
+            'bit_order': 'little-endian (qubit 0 = rightmost bit)',
+            'option_base': getattr(self, '_option_base', 0),
+            'locc_mode': bool(getattr(self, 'locc_mode', False)),
+            'locc_registers': (list(self.locc.names)
+                               if getattr(self, 'locc_mode', False) and getattr(self, 'locc', None)
+                               else []),
+            'noise_active': getattr(self, '_noise_model', None) is not None,
+            'noise_spec': getattr(self, '_noise_spec', None),
+            'coupling_map': ([list(e) for e in cmap] if cmap else None),
+            'basis_gates': getattr(self, '_basis_gates', None),
+            'pending_set_state': getattr(self, '_pending_set_state', None) is not None,
+            'pending_set_density': getattr(self, '_pending_set_density', None) is not None,
+            'screen_mode': getattr(self, '_screen_mode', 0),
+            'trace_mode': bool(getattr(self, '_trace_mode', False)),
+            'bank': getattr(self, '_current_slot', 0),
+            'program_lines': len(self.program),
+            'variables': len(self.variables),
+            'arrays': len(self.arrays),
+            'subroutines': len(self.subroutines),
+            'custom_gates': sorted(self._custom_gates.keys()),
+        }
+
+    def cmd_status(self, rest: str = '') -> None:
+        """STATUS [JSON] — show every active mode (qubits, method, LOCC, noise,
+        OPTION BASE, pending state injections, bank, ...) so behavior is readable
+        rather than inferred. STATUS JSON emits the same data as JSON."""
+        d = self._status_dict()
+        if rest.strip().upper() == 'JSON':
+            import json
+            self.io.writeln(json.dumps(d, indent=2, default=str))
+            return
+        w = self.io.writeln
+        w("  QUBASIC status")
+        w(f"    qubits       {d['qubits']}    shots {d['shots']}    "
+          f"method {d['method']}    device {d['device']}")
+        w(f"    seed         {d['seed']}")
+        w(f"    bit order    {d['bit_order']}")
+        w(f"    option base  {d['option_base']}")
+        if d['locc_mode']:
+            w(f"    LOCC mode    on    registers {d['locc_registers']}")
+        w(f"    noise        {('on  ' + str(d['noise_spec'])) if d['noise_active'] else 'off'}")
+        if d['coupling_map']:
+            w(f"    coupling     {d['coupling_map']}")
+        if d['basis_gates']:
+            w(f"    basis gates  {d['basis_gates']}")
+        if d['pending_set_state']:
+            w("    pending      SET_STATE applies on next RUN")
+        if d['pending_set_density']:
+            w("    pending      SET_DENSITY applies on next RUN")
+        if d['screen_mode']:
+            w(f"    screen mode  {d['screen_mode']}")
+        if d['trace_mode']:
+            w("    trace        on")
+        w(f"    bank         {d['bank']}")
+        w(f"    program      {d['program_lines']} lines, {d['variables']} vars, "
+          f"{d['arrays']} arrays, {d['subroutines']} subs")
+        if d['custom_gates']:
+            w(f"    custom gates {d['custom_gates']}")
+
     # cmd_defs, cmd_regs, cmd_vars provided by ProgramMgmtMixin.
 
     # ── Run ───────────────────────────────────────────────────────────
@@ -1490,6 +1585,8 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             'counts': self.last_counts or {},
             'num_qubits': self.num_qubits,
             'shots': self.shots,
+            # Bitstrings are little-endian: the rightmost character is qubit 0.
+            'bit_order': 'little-endian (qubit 0 = rightmost bit)',
         }
         uvars = {k: v for k, v in self.variables.items()
                  if not k.startswith('_') and isinstance(v, (int, float, str, bool))}
@@ -1750,6 +1847,14 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         """
         m = RE_MEAS.match(stmt)
         if not m:
+            # Bare MEAS (no "-> bit") is the classic confusion with MEASURE:
+            # MEAS is a mid-circuit measurement that must name a classical bit,
+            # MEASURE collapses qubits into the result histogram.
+            if re.match(r'MEAS\b', stmt, re.IGNORECASE):
+                raise ValueError(
+                    "MEAS needs a target bit: MEAS <qubit> -> <bit> "
+                    "(mid-circuit measurement used by IF). To collapse qubits "
+                    "into the result histogram, use MEASURE <qubit>.")
             return False
         qubit = int(self._eval_with_vars(m.group(1), run_vars))
         var = m.group(2)
@@ -2097,7 +2202,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.11.0}/tests/test_qubasic.py

@@ -1948,6 +1948,137 @@ 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)'), -4.0)   # BASIC INT floors
+        self.assertEqual(self.t.eval_expr('FIX(-3.2)'), -3.0)   # FIX truncates toward zero
+
+    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)', {})
+
+
+class TestConventionAndStateRegressions(unittest.TestCase):
+    """Convention-conformance and hidden-state fixes: INT floors, implicit LET,
+    MEAS/MEASURE disambiguation, reserved constants, STATUS, bit-order labels."""
+
+    def setUp(self):
+        self.t = QBasicTerminal()
+        self.t.num_qubits = 2
+
+    def test_int_floors_fix_truncates(self):
+        self.assertEqual(self.t.eval_expr('INT(-3.2)'), -4.0)
+        self.assertEqual(self.t.eval_expr('INT(3.7)'), 3.0)
+        self.assertEqual(self.t.eval_expr('FIX(-3.2)'), -3.0)
+        self.assertEqual(self.t.eval_expr('FIX(3.7)'), 3.0)
+
+    def test_implicit_let_parses_as_assignment(self):
+        from qubasic_core.parser import parse_stmt
+        from qubasic_core.statements import LetStmt, LetStrStmt, LetArrayStmt
+        self.assertIsInstance(parse_stmt('x = 5'), LetStmt)
+        self.assertIsInstance(parse_stmt('s$ = "hi"'), LetStrStmt)
+        self.assertIsInstance(parse_stmt('a(1) = 5'), LetArrayStmt)
+        # '==' is a comparison, never an implicit assignment.
+        self.assertNotIsInstance(parse_stmt('x == 5'), LetStmt)
+
+    def test_implicit_let_runs(self):
+        t = QBasicTerminal(); t.num_qubits = 1
+        t.program = {10: 'x = 5', 20: 's$ = "ok"', 30: 'y = x + 1'}
+        capture(t.cmd_run)
+        self.assertEqual(t.variables['x'], 5.0)
+        self.assertEqual(t.variables['s$'], 'ok')
+        self.assertEqual(t.variables['y'], 6.0)
+
+    def test_meas_bare_form_errors_measure_does_not(self):
+        # MEAS without a target bit raises a helpful error...
+        with self.assertRaises(ValueError):
+            self.t._try_exec_meas('MEAS 0', None, {})
+        # ...while MEASURE is a different statement and is left untouched here.
+        self.assertFalse(self.t._try_exec_meas('MEASURE 0', None, {}))
+
+    def test_reserved_constants_not_assignable(self):
+        for name in ('E', 'e', 'PI', 'pi', 'TAU', 'SQRT2'):
+            with self.assertRaises(ValueError):
+                self.t._assert_assignable(name)
+        self.t._assert_assignable('x')      # ordinary names are fine
+        self.t._assert_assignable('e1')
+
+    def test_status_dict_reports_modes(self):
+        t = QBasicTerminal(); t.num_qubits = 3; t.shots = 128
+        d = t._status_dict()
+        self.assertEqual(d['qubits'], 3)
+        self.assertEqual(d['shots'], 128)
+        self.assertIn('rightmost', d['bit_order'])
+        self.assertFalse(d['noise_active'])
+        self.assertIn('option_base', d)
+
+    def test_bit_order_label_and_result(self):
+        t = QBasicTerminal(); t.num_qubits = 3
+        note = t._bit_order_note([('001', 5)])
+        self.assertIn('q2 q1 q0', note)
+        self.assertIn('rightmost', note)
+        self.assertIn('bit_order', t.result())
+
+
 if __name__ == '__main__':
     if hasattr(sys.stdout, 'reconfigure'):
         sys.stdout.reconfigure(encoding='utf-8')