qubasic 0.6.1__tar.gz → 0.6.3__tar.gz

{qubasic-0.6.1 → qubasic-0.6.3}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.6.3 (2026-06-18)
+
+### Fixed
+- Colon-compound `@register` lines in LOCC mode now apply every gate. `@A H 0 : @A CX 0,1` (and the inherited form `@A H 0 : CX 0,1`) were captured as a single statement and mis-tokenized, so all but the first gate were silently dropped. The parser now splits them into per-statement parts with register inheritance, and the immediate-mode REPL path does the same.
+- `SAVE_EXPECT`, `SAVE_PROBS`, and `SAVE_AMPS` no longer overwrite their target variable with 0 at circuit-build time. The placeholder keeps any prior value, so a program that re-runs with the SAVE line still present can read the previous result during the build pass (the post-run extraction then fills in the fresh value).
+- `PRINT` honors `;` and `,` between multiple items: `PRINT "S ="; x` concatenates and `PRINT a, b` advances to the next 14-column zone. Separators inside quoted strings and inside call parentheses (`PRINT LEFT$(s$, 3)`) are no longer treated as item breaks.
+- `PRINT` variable substitution no longer rewrites identifiers inside quoted string literals, so a label such as `PRINT "value of S"` is emitted verbatim even when `S` is a defined variable.
+
+## 0.6.2 (2026-06-18)
+
+### Fixed
+- Changing the qubit count after a run (via `QUBITS n` or `POKE $D000`) now invalidates the cached statevector, so `MAP`, a `PEEK` of the qubit-state block, and `BLOCH` no longer reshape a stale statevector to the new qubit count and crash.
+
 ## 0.6.1 (2026-06-18)
 
 ### Fixed

{qubasic-0.6.1/qubasic.egg-info → qubasic-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.6.1
+Version: 0.6.3
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT

{qubasic-0.6.1 → qubasic-0.6.3}/pyproject.toml

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

{qubasic-0.6.1 → qubasic-0.6.3/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.6.1
+Version: 0.6.3
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT

{qubasic-0.6.1 → qubasic-0.6.3}/qubasic_core/__init__.py

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

{qubasic-0.6.1 → qubasic-0.6.3}/qubasic_core/control_flow.py

@@ -63,46 +63,86 @@ class ControlFlowMixin:
         self.variables[name] = val
         return True, ExecResult.ADVANCE
 
-    def _cf_print(self, stmt: str, run_vars: dict[str, Any],
-                  parsed: PrintStmt) -> tuple[bool, ExecOutcome]:
-        raw_expr = parsed.expr
-        text = self._substitute_vars(raw_expr.strip(), run_vars)
-        # Determine trailing separator: ; suppresses newline, , advances to tab
-        suppress_newline = raw_expr.rstrip().endswith(';')
-        tab_advance = raw_expr.rstrip().endswith(',')
-        if suppress_newline:
-            text = text.rstrip().removesuffix(';').rstrip()
-        elif tab_advance:
-            text = text.rstrip().removesuffix(',').rstrip()
-        # Evaluate SPC(n) and TAB(n) inline
-        def _replace_spc(m_spc):
-            n = int(self._eval_with_vars(m_spc.group(1), run_vars))
-            return ' ' * max(0, n)
-        def _replace_tab(m_tab):
-            n = int(self._eval_with_vars(m_tab.group(1), run_vars))
-            return ' ' * max(0, n)
-        text = re.sub(r'\bSPC\s*\(([^)]+)\)', _replace_spc, text, flags=re.IGNORECASE)
-        text = re.sub(r'\bTAB\s*\(([^)]+)\)', _replace_tab, text, flags=re.IGNORECASE)
-        # Evaluate the expression
-        if (text.startswith('"') and text.endswith('"')) or \
-           (text.startswith("'") and text.endswith("'")):
-            output = text[1:-1]
-        else:
+    @staticmethod
+    def _split_print_items(expr: str) -> list[tuple[str, str]]:
+        """Split a PRINT argument list into (item, trailing-separator) pairs.
+
+        ';' and ',' are recognized only at top level (outside quotes and
+        parentheses/brackets), so PRINT LEFT$(s$, 3) stays one item and a comma
+        inside a quoted literal is preserved. The separator recorded with each
+        item is the one that follows it; '' marks the final item / no trailing
+        separator.
+        """
+        items: list[tuple[str, str]] = []
+        buf = ''
+        depth = 0
+        quote: str | None = None
+        for ch in expr:
+            if quote:
+                buf += ch
+                if ch == quote:
+                    quote = None
+            elif ch in ('"', "'"):
+                quote = ch
+                buf += ch
+            elif ch in '([':
+                depth += 1
+                buf += ch
+            elif ch in ')]':
+                depth = max(0, depth - 1)
+                buf += ch
+            elif ch in ';,' and depth == 0:
+                items.append((buf.strip(), ch))
+                buf = ''
+            else:
+                buf += ch
+        if buf.strip():
+            items.append((buf.strip(), ''))
+        return items
+
+    def _eval_print_item(self, item: str, run_vars: dict[str, Any]) -> str:
+        """Evaluate a single PRINT item to its display string."""
+        item = item.strip()
+        if not item:
+            return ''
+        # Quoted literal: emit verbatim (no substitution, no SPC/TAB).
+        if (item[0] == '"' and item[-1] == '"') or (item[0] == "'" and item[-1] == "'"):
+            return item[1:-1]
+        text = self._substitute_vars(item, run_vars)
+
+        def _spaces(m):
             try:
-                ns = run_vars.as_dict() if hasattr(run_vars, 'as_dict') else dict(run_vars) if not isinstance(run_vars, dict) else run_vars
-                result = self._safe_eval(text, extra_ns=ns)
-                output = str(result)
+                return ' ' * max(0, int(self._eval_with_vars(m.group(1), run_vars)))
             except Exception:
-                output = text
-        # Output with separator behavior
-        if suppress_newline:
-            self.io.write(output)
-        elif tab_advance:
-            col = len(output) % 14
-            padding = 14 - col if col > 0 else 14
-            self.io.write(output + ' ' * padding)
+                return ''
+        text = re.sub(r'\bSPC\s*\(([^)]+)\)', _spaces, text, flags=re.IGNORECASE)
+        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
+
+    def _cf_print(self, stmt: str, run_vars: dict[str, Any],
+                  parsed: PrintStmt) -> tuple[bool, ExecOutcome]:
+        items = self._split_print_items(parsed.expr)
+        if not items:
+            self.io.writeln('')             # bare PRINT -> blank line
+            return True, ExecResult.ADVANCE
+        out = ''
+        for item, sep in items:
+            out += self._eval_print_item(item, run_vars)
+            if sep == ',':                  # advance to next 14-column zone
+                col = len(out) % 14
+                out += ' ' * (14 - col if col else 14)
+        # A trailing ';' or ',' suppresses the newline (cursor stays on line).
+        if items[-1][1] in (';', ','):
+            self.io.write(out)
         else:
-            self.io.writeln(output)
+            self.io.writeln(out)
         return True, ExecResult.ADVANCE
 
     def _cf_goto(self, stmt: str, sorted_lines: list[int],

{qubasic-0.6.1 → qubasic-0.6.3}/qubasic_core/engine_state.py

@@ -119,3 +119,17 @@ class Engine:
         self._circuit_cache = None
         self._pending_set_state = None
         self._poke_state_prep = {}
+
+    def _invalidate_run_state(self) -> None:
+        """Drop cached results that describe a now-stale configuration.
+
+        Called when the qubit count changes: last_sv, last_counts,
+        last_circuit, and the transpile cache all assume the previous
+        num_qubits, so reading them afterwards would mislabel (or, for
+        the reshape in _peek_qubit/_bloch_vector, crash) the state.
+        """
+        self.last_counts = None
+        self.last_sv = None
+        self.last_circuit = None
+        self._circuit_cache_key = None
+        self._circuit_cache = None

{qubasic-0.6.1 → qubasic-0.6.3}/qubasic_core/executor.py

@@ -328,20 +328,42 @@ class ExecutorMixin:
             set(self.subroutines.keys()) |
             set(self._custom_gates.keys())
         )
-        # Tokenize: split on word boundaries, preserving delimiters
-        tokens = re.split(r'(\b\w+\b)', stmt)
-        for i, tok in enumerate(tokens):
-            if not tok or not tok[0].isalpha():
-                continue
-            if tok in protected or tok.upper() in protected or tok.lower() in protected:
-                continue
-            if tok in merged:
-                # Don't expand record bases (dicts) — leave p in p.x intact so
-                # the expression evaluator can resolve the field.
-                if isinstance(merged[tok], dict):
+
+        def _sub_segment(seg: str) -> str:
+            # Tokenize: split on word boundaries, preserving delimiters
+            tokens = re.split(r'(\b\w+\b)', seg)
+            for i, tok in enumerate(tokens):
+                if not tok or not tok[0].isalpha():
+                    continue
+                if tok in protected or tok.upper() in protected or tok.lower() in protected:
                     continue
-                tokens[i] = str(merged[tok])
-        return ''.join(tokens)
+                if tok in merged:
+                    # Don't expand record bases (dicts) — leave p in p.x intact
+                    # so the expression evaluator can resolve the field.
+                    if isinstance(merged[tok], dict):
+                        continue
+                    tokens[i] = str(merged[tok])
+            return ''.join(tokens)
+
+        # Substitute only outside quoted string literals: a variable named in a
+        # PRINT label (PRINT "S ="; S) must survive verbatim inside the quotes.
+        out: list[str] = []
+        i, n = 0, len(stmt)
+        while i < n:
+            ch = stmt[i]
+            if ch in ('"', "'"):
+                j = i + 1
+                while j < n and stmt[j] != ch:
+                    j += 1
+                out.append(stmt[i:j + 1])           # quoted span, verbatim
+                i = j + 1
+            else:
+                j = i
+                while j < n and stmt[j] not in ('"', "'"):
+                    j += 1
+                out.append(_sub_segment(stmt[i:j]))  # unquoted span
+                i = j
+        return ''.join(out)
 
     def _expand_statement(self, stmt, _call_stack: set[str] | None = None):
         """Expand subroutines. Returns list of gate strings.
@@ -636,18 +658,24 @@ class ExecutorMixin:
 
         Uses the same _exec_line pipeline as cmd_run for consistency.
         """
-        # In LOCC mode, handle @register prefix via the numpy engine
-        if self.locc_mode and self.locc:
-            m = RE_AT_REG_LINE.match(line)
-            if m:
+        # In LOCC mode, handle @register prefix via the numpy engine. Split
+        # colon-compound @REG lines so each gate is applied (a single @REG line
+        # is just the one-part case); a bare @REG line keeps prior behavior.
+        if self.locc_mode and self.locc and line.strip().startswith('@'):
+            parts = self._split_colon_stmts(line) if ':' in line else [line.strip()]
+            for part in parts:
+                m = RE_AT_REG_LINE.match(part)
+                if not m:
+                    self.io.writeln(f"?BAD @register statement: {part}")
+                    continue
                 reg = m.group(1).upper()
                 gate_stmt = m.group(2).strip()
                 if reg not in self.locc.names:
                     self.io.writeln(f"?UNKNOWN REGISTER: {reg} (have {', '.join(self.locc.names)})")
                     return
                 self._locc_apply_gate(reg, gate_stmt)
-                self._locc_state()
-                return
+            self._locc_state()
+            return
         if line.strip().startswith('@'):
             self.io.writeln("?@register syntax requires LOCC mode (try: LOCC <n1> <n2>)")
             return

{qubasic-0.6.1 → qubasic-0.6.3}/qubasic_core/memory.py

@@ -103,7 +103,10 @@ class MemoryMixin:
         qubit, field = off // QUBIT_BLOCK, off % QUBIT_BLOCK
         if self.last_sv is None or qubit >= self.num_qubits:
             return 0.0
-        sv = np.ascontiguousarray(self.last_sv).ravel().reshape([2] * self.num_qubits)
+        sv_flat = np.ascontiguousarray(self.last_sv).ravel()
+        if sv_flat.size != 2 ** self.num_qubits:
+            return 0.0  # stale statevector from a different qubit count
+        sv = sv_flat.reshape([2] * self.num_qubits)
         ax = self.num_qubits - 1 - qubit
         t = np.moveaxis(sv, ax, 0)
         t0, t1 = t[0].flatten(), t[1].flatten()
@@ -155,7 +158,10 @@ class MemoryMixin:
             self._zero_page[a] = v
             return
         if a == 0xD000:
-            self.num_qubits = max(1, min(32, int(v)))
+            new_n = max(1, min(32, int(v)))
+            if new_n != self.num_qubits:
+                self._invalidate_run_state()
+            self.num_qubits = new_n
         elif a == 0xD001:
             self.shots = max(1, int(v))
         elif a == 0xD002:

{qubasic-0.6.1 → qubasic-0.6.3}/qubasic_core/parser.py

@@ -554,6 +554,14 @@ def parse_stmt(raw: str) -> Stmt:
 
     # ── @REG lines ────────────────────────────────────────────────
     if text.startswith('@'):
+        # A colon-compound @REG line (e.g. "@A H 0 : @A CX 0,1" or
+        # "@A H 0 : CX 0,1") must split into per-statement parts with
+        # @register inheritance; otherwise the whole tail is captured as one
+        # AtRegStmt.inner and the LOCC executor mis-tokenizes it.
+        if ':' in text:
+            parts = _split_colon_stmts(text)
+            if len(parts) > 1:
+                return CompoundStmt(raw=raw, parts=tuple(parts))
         m = RE_AT_REG_LINE.match(text)
         if m:
             return AtRegStmt(raw=raw, reg=m.group(1).upper(),

{qubasic-0.6.1 → qubasic-0.6.3}/qubasic_core/terminal.py

@@ -571,6 +571,8 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             from qubasic_core.errors import QBasicRangeError
             raise QBasicRangeError(f"RANGE: 1-{MAX_QUBITS}")
 
+        if n != self.num_qubits:
+            self._invalidate_run_state()
         self.num_qubits = n
         self.registers.clear()
         est = _estimate_gb(n)
@@ -1980,8 +1982,13 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
                     full_pauli[self.num_qubits - 1 - qubits[i]] = p
             op = SparsePauliOp(''.join(full_pauli))
             qc.save_expectation_value(op, list(range(self.num_qubits)), label=f'exp_{var}')
-            run_vars[var] = 0  # actual value available after simulation
-            self.variables[var] = 0
+            # Placeholder until the run fills the real value via
+            # _extract_save_results. Preserve any prior value instead of
+            # zeroing it, so a re-run that re-includes this SAVE line leaves
+            # earlier results readable to LET/PRINT during the build pass.
+            _prev = self.variables.get(var, 0)
+            run_vars[var] = _prev
+            self.variables[var] = _prev
         except Exception as e:
             self.io.writeln(f"?SAVE_EXPECT ERROR: {e}")
         return True
@@ -1996,8 +2003,9 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         var = m.group(2)
         try:
             qc.save_probabilities(qubits, label=f'prob_{var}')
-            run_vars[var] = 0
-            self.variables[var] = 0
+            _prev = self.variables.get(var, 0)   # preserve prior value (see SAVE_EXPECT)
+            run_vars[var] = _prev
+            self.variables[var] = _prev
         except Exception as e:
             self.io.writeln(f"?SAVE_PROBS ERROR: {e}")
         return True
@@ -2012,8 +2020,9 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         var = m.group(2)
         try:
             qc.save_amplitudes(indices, label=f'amp_{var}')
-            run_vars[var] = 0
-            self.variables[var] = 0
+            _prev = self.variables.get(var, 0)   # preserve prior value (see SAVE_EXPECT)
+            run_vars[var] = _prev
+            self.variables[var] = _prev
         except Exception as e:
             self.io.writeln(f"?SAVE_AMPS ERROR: {e}")
         return True

{qubasic-0.6.1 → qubasic-0.6.3}/tests/test_features.py

@@ -359,6 +359,42 @@ class TestMemoryMap(unittest.TestCase):
         self.assertEqual(ntype, 2)
         self.assertAlmostEqual(nparam, 0.1)
 
+    def test_qubit_count_change_invalidates_stale_state(self):
+        """Changing the qubit count after a run must not leave a stale last_sv
+        that MAP/PEEK/BLOCH then reshape to the wrong size and crash."""
+        import numpy as np
+
+        # Run a 1-qubit circuit so last_sv has size 2.
+        t = QBasicTerminal()
+        t.num_qubits = 1
+        t.process('10 H 0')
+        t.process('20 MEASURE')
+        capture(t.cmd_run)
+
+        # QUBITS grows the count: the size-2 statevector no longer applies.
+        capture(t.cmd_qubits, '2')
+        self.assertIsNone(t.last_sv)
+        self.assertIsNone(t._circuit_cache_key)
+        self.assertEqual(t._peek(0x0100), 0.0)   # would have crashed on reshape
+        capture(t.cmd_map)                        # MAP walks the qubit block
+        capture(t.cmd_bloch, '0')                 # BLOCH reshapes too
+
+        # The $D000 POKE path invalidates the same way.
+        t2 = QBasicTerminal()
+        t2.num_qubits = 1
+        t2.process('10 H 0')
+        t2.process('20 MEASURE')
+        capture(t2.cmd_run)
+        t2._poke(0xD000, 3)
+        self.assertIsNone(t2.last_sv)
+        self.assertEqual(t2._peek(0x0100), 0.0)
+
+        # Defensive guard: even a hand-set mismatched last_sv reads as 0, not a crash.
+        t3 = QBasicTerminal()
+        t3.num_qubits = 2
+        t3.last_sv = np.array([1.0, 0.0], dtype=complex)  # size 2, but 2 qubits
+        self.assertEqual(t3._peek(0x0100), 0.0)
+
     def test_sys(self):
         """SYS builtin BELL, SYS unmapped, SYS in program, SYS INSTALL."""
         # SYS 0xE000 BELL demo

{qubasic-0.6.1 → qubasic-0.6.3}/tests/test_qubasic.py

@@ -1432,6 +1432,92 @@ class TestAdditionalCoverage(unittest.TestCase):
         self.assertEqual(t4.last_counts.get('1', 0), 100)
 
 
+# ---------------------------------------------------------------------------
+# TestBugFixes063 — regressions fixed in 0.6.3
+# ---------------------------------------------------------------------------
+class TestBugFixes063(unittest.TestCase):
+    """Regression tests for the 0.6.3 fixes."""
+
+    def _ghz3(self):
+        v = np.zeros(8, dtype=complex)
+        v[0] = v[7] = 1 / np.sqrt(2)
+        return v
+
+    def test_locc_colon_compound_at_register(self):
+        """LOCC: colon-compound @REG lines apply every gate (explicit and inherited)."""
+        for line in ('@A H 0 : @A CX 0,1 : @A CX 0,2',   # explicit @A per clause
+                     '@A H 0 : CX 0,1 : CX 0,2'):         # @A inherited
+            t = QBasicTerminal()
+            t.locc = LOCCEngine([3], joint=True)
+            t.locc_mode = True
+            t.shots = 1
+            t.process(f'10 {line}', track_undo=False)
+            t.process('20 MEASURE', track_undo=False)
+            capture(t.cmd_run)
+            sv = np.ascontiguousarray(t.locc.sv).ravel()
+            fid = abs(np.vdot(self._ghz3(), sv)) ** 2
+            self.assertGreater(fid, 0.999, f"GHZ not built by: {line}")
+
+    def test_save_expect_preserved_across_rerun(self):
+        """SAVE_EXPECT keeps prior values on re-run instead of zeroing them."""
+        t = QBasicTerminal()
+        t.num_qubits = 2
+        t.shots = 64
+        t.process('10 H 0', track_undo=False)
+        t.process('20 CX 0,1', track_undo=False)
+        t.process('30 SAVE_EXPECT ZZ 0,1 -> zz', track_undo=False)
+        t.process('40 SAVE_EXPECT XX 0,1 -> xx', track_undo=False)
+        capture(t.cmd_run)
+        self.assertAlmostEqual(t.variables['zz'], 1.0, places=6)
+        self.assertAlmostEqual(t.variables['xx'], 1.0, places=6)
+        # A second run that still contains the SAVE lines must not zero zz/xx
+        # before the LET on line 50 reads them.
+        t.process('50 LET chsh = SQRT2 * (zz + xx)', track_undo=False)
+        capture(t.cmd_run)
+        self.assertAlmostEqual(t.variables['chsh'], 2 * math.sqrt(2), places=6)
+
+    def test_print_multi_item_separators(self):
+        """PRINT concatenates ';' items and tab-aligns ',' items."""
+        t = QBasicTerminal()
+        t.num_qubits = 1
+        t.variables['S'] = 2.8284271247
+        t.process('10 PRINT "S ="; S', track_undo=False)
+        _, out = capture(t.cmd_run)
+        self.assertIn('S =2.8284', out)
+
+        t2 = QBasicTerminal()
+        t2.num_qubits = 1
+        t2.process('10 PRINT "a", "b"', track_undo=False)
+        _, out2 = capture(t2.cmd_run)
+        line = next(l for l in out2.splitlines() if 'a' in l and 'b' in l)
+        self.assertGreaterEqual(line.index('b') - line.index('a'), 14)
+
+    def test_print_does_not_substitute_inside_quotes(self):
+        """A variable name inside a quoted PRINT literal is emitted verbatim."""
+        t = QBasicTerminal()
+        t.num_qubits = 1
+        t.variables['S'] = 99.0
+        t.process('10 PRINT "value of S here"', track_undo=False)
+        _, out = capture(t.cmd_run)
+        self.assertIn('value of S here', out)
+        self.assertNotIn('99', out)
+
+    def test_print_preserves_commas_in_quotes_and_calls(self):
+        """Top-level split skips commas inside quotes and inside call parens."""
+        t = QBasicTerminal()
+        t.num_qubits = 1
+        t.process('10 PRINT "x,y,z"', track_undo=False)
+        _, out = capture(t.cmd_run)
+        self.assertIn('x,y,z', out)
+
+        t2 = QBasicTerminal()
+        t2.num_qubits = 1
+        t2.process('10 LET name$ = "hello"', track_undo=False)
+        t2.process('20 PRINT LEFT$(name$, 3)', track_undo=False)
+        _, out2 = capture(t2.cmd_run)
+        self.assertIn('hel', out2)
+
+
 if __name__ == '__main__':
     if hasattr(sys.stdout, 'reconfigure'):
         sys.stdout.reconfigure(encoding='utf-8')