qubasic 0.1.0__py3-none-any.whl

qbasic_core/program_mgmt.py

@@ -0,0 +1,369 @@
+"""QBASIC program management — AUTO, EDIT, COPY, MOVE, FIND, REPLACE, slots, CHECKSUM, CHAIN, MERGE, LIST+."""
+
+from __future__ import annotations
+
+import os
+import re
+import hashlib
+from typing import Any
+
+from qbasic_core.engine import RE_CHAIN, RE_MERGE, RE_DEF_BEGIN
+
+
+class ProgramMgmtMixin:
+    """Program management commands for QBasicTerminal.
+
+    Requires: TerminalProtocol — uses self.program, self.variables,
+    self.num_qubits, self.shots, self.process(), self.cmd_new(),
+    self._sanitize_path().
+    """
+
+    def _init_program_mgmt(self) -> None:
+        self._program_slots: dict[int, dict[int, str]] = {}
+        self._current_slot: int = 0
+        self._auto_mode: bool = False
+        self._auto_line: int = 10
+        self._auto_step: int = 10
+
+    # ── AUTO ───────────────────────────────────────────────────────────
+
+    def cmd_auto(self, rest: str = '') -> None:
+        """AUTO [start][, step] — auto-generate line numbers."""
+        parts = rest.replace(',', ' ').split()
+        if parts:
+            self._auto_line = int(parts[0])
+        if len(parts) > 1:
+            self._auto_step = int(parts[1])
+        self._auto_mode = True
+        self.io.writeln(f"AUTO {self._auto_line}, {self._auto_step} — type . to stop")
+        while self._auto_mode:
+            try:
+                line = self.io.read_line(f'{self._auto_line} ').rstrip()
+                if line == '.':
+                    self._auto_mode = False
+                    break
+                if line:
+                    self.process(f'{self._auto_line} {line}')
+                self._auto_line += self._auto_step
+            except (KeyboardInterrupt, EOFError):
+                self._auto_mode = False
+                self.io.writeln('')
+                break
+
+    # ── EDIT ───────────────────────────────────────────────────────────
+
+    def cmd_edit(self, rest: str) -> None:
+        """EDIT <line> — edit a specific line."""
+        if not rest.strip():
+            self.io.writeln("?USAGE: EDIT <line>")
+            return
+        num = int(rest.strip())
+        if num not in self.program:
+            self.io.writeln(f"?LINE {num} NOT FOUND")
+            return
+        current = self.program[num]
+        self.io.writeln(f"  {num} {current}")
+        try:
+            new_content = self.io.read_line(f'{num} ').rstrip()
+            if new_content:
+                self.program[num] = new_content
+                self.io.writeln(f"  UPDATED {num}")
+            else:
+                self.io.writeln("  (unchanged)")
+        except (KeyboardInterrupt, EOFError):
+            self.io.writeln("\n  (cancelled)")
+
+    # ── LIST enhancements ──────────────────────────────────────────────
+
+    def cmd_list_subs(self) -> None:
+        """LIST SUBS — list all SUB/FUNCTION definitions."""
+        found = False
+        for ln in sorted(self.program.keys()):
+            stmt = self.program[ln].strip().upper()
+            if stmt.startswith('SUB ') or stmt.startswith('FUNCTION '):
+                self.io.writeln(f"  {ln:5d}  {self.program[ln]}")
+                found = True
+        if self.subroutines:
+            for name, sub in self.subroutines.items():
+                if isinstance(sub, dict):
+                    params = f"({', '.join(sub['params'])})" if sub['params'] else ""
+                    self.io.writeln(f"  DEF  {name}{params} ({len(sub['body'])} gates)")
+                found = True
+        if not found:
+            self.io.writeln("  No subroutines defined")
+
+    def cmd_list_vars(self) -> None:
+        """LIST VARS — alias for VARS with types."""
+        if not self.variables:
+            self.io.writeln("  No variables")
+            return
+        for name, val in sorted(self.variables.items()):
+            typ = type(val).__name__
+            self.io.writeln(f"  {name} = {val}  ({typ})")
+
+    def cmd_list_arrays(self) -> None:
+        """LIST ARRAYS — list all arrays with sizes."""
+        if not self.arrays:
+            self.io.writeln("  No arrays")
+            return
+        for name, data in sorted(self.arrays.items()):
+            if isinstance(data, list):
+                self.io.writeln(f"  {name}({len(data)}) = {data[:5]}{'...' if len(data) > 5 else ''}")
+            elif isinstance(data, dict):
+                self.io.writeln(f"  {name}({len(data)} dims)")
+
+    # ── Program slots (BANK) ──────────────────────────────────────────
+
+    def cmd_bank(self, rest: str) -> None:
+        """BANK <n> — switch to program slot n."""
+        if not rest.strip():
+            self.io.writeln(f"  Current slot: {self._current_slot}")
+            self.io.writeln(f"  Slots in use: {sorted(self._program_slots.keys())}")
+            return
+        slot = int(rest.strip())
+        # Save current
+        self._program_slots[self._current_slot] = dict(self.program)
+        # Load target
+        self._current_slot = slot
+        if slot in self._program_slots:
+            self.program = dict(self._program_slots[slot])
+            self.io.writeln(f"BANK {slot} ({len(self.program)} lines)")
+        else:
+            self.program = {}
+            self.io.writeln(f"BANK {slot} (empty)")
+
+    # ── COPY / MOVE ────────────────────────────────────────────────────
+
+    def cmd_copy(self, rest: str) -> None:
+        """COPY <start>-<end> TO <dest> — copy line range."""
+        m = self._parse_range_to(rest)
+        if not m:
+            self.io.writeln("?USAGE: COPY <start>-<end> TO <dest>")
+            return
+        start, end, dest = m
+        offset = dest - start
+        for ln in sorted(self.program.keys()):
+            if start <= ln <= end:
+                self.program[ln + offset] = self.program[ln]
+        self.io.writeln(f"COPIED {start}-{end} TO {dest}-{end + offset}")
+
+    def cmd_move(self, rest: str) -> None:
+        """MOVE <start>-<end> TO <dest> — move line range."""
+        m = self._parse_range_to(rest)
+        if not m:
+            self.io.writeln("?USAGE: MOVE <start>-<end> TO <dest>")
+            return
+        start, end, dest = m
+        offset = dest - start
+        lines = {ln: self.program[ln] for ln in sorted(self.program.keys())
+                 if start <= ln <= end}
+        for ln in lines:
+            del self.program[ln]
+        for ln, stmt in lines.items():
+            self.program[ln + offset] = stmt
+        self.io.writeln(f"MOVED {start}-{end} TO {dest}-{end + offset}")
+
+    @staticmethod
+    def _parse_range_to(rest: str) -> tuple[int, int, int] | None:
+        m = re.match(r'(\d+)\s*-\s*(\d+)\s+TO\s+(\d+)', rest, re.IGNORECASE)
+        if not m:
+            return None
+        return int(m.group(1)), int(m.group(2)), int(m.group(3))
+
+    # ── FIND / REPLACE ─────────────────────────────────────────────────
+
+    def cmd_find(self, rest: str) -> None:
+        """FIND "text" — search program lines."""
+        text = rest.strip().strip('"').strip("'")
+        if not text:
+            self.io.writeln("?USAGE: FIND \"text\"")
+            return
+        found = 0
+        for ln in sorted(self.program.keys()):
+            if text.upper() in self.program[ln].upper():
+                self.io.writeln(f"  {ln:5d}  {self.program[ln]}")
+                found += 1
+        self.io.writeln(f"  {found} match(es)")
+
+    def cmd_replace(self, rest: str) -> None:
+        """REPLACE "old" WITH "new" — find and replace in program."""
+        m = re.match(r'"([^"]+)"\s+WITH\s+"([^"]*)"', rest, re.IGNORECASE)
+        if not m:
+            self.io.writeln('?USAGE: REPLACE "old" WITH "new"')
+            return
+        old, new = m.group(1), m.group(2)
+        count = 0
+        for ln in sorted(self.program.keys()):
+            if old in self.program[ln]:
+                self.program[ln] = self.program[ln].replace(old, new)
+                self.io.writeln(f"  {ln:5d}  {self.program[ln]}")
+                count += 1
+        self.io.writeln(f"  {count} replacement(s)")
+
+    # ── CHECKSUM ───────────────────────────────────────────────────────
+
+    def cmd_checksum(self) -> None:
+        """CHECKSUM — hash of program listing for verification."""
+        if not self.program:
+            self.io.writeln("?EMPTY PROGRAM")
+            return
+        content = '\n'.join(f'{ln} {self.program[ln]}'
+                           for ln in sorted(self.program.keys()))
+        h = hashlib.md5(content.encode()).hexdigest()[:8].upper()
+        self.io.writeln(f"CHECKSUM: {h} ({len(self.program)} lines)")
+
+    # ── CHAIN / MERGE ──────────────────────────────────────────────────
+
+    @staticmethod
+    def _load_lines_with_defs(lines: list[str], process_fn) -> int:
+        """Iterate stripped lines, handling DEF BEGIN...DEF END blocks.
+
+        Skips blank lines and # comments. For each DEF BEGIN block, collects
+        the body lines and calls process_fn with a synthesized single-line DEF
+        command. For all other lines, calls process_fn directly.
+
+        Returns the count of logical lines/blocks processed (excluding skips).
+        """
+        count = 0
+        i = 0
+        while i < len(lines):
+            line = lines[i].strip()
+            if not line or line.startswith('#'):
+                i += 1
+                continue
+            if re.match(r'DEF\s+BEGIN\s+', line, re.IGNORECASE):
+                dm = RE_DEF_BEGIN.match(line)
+                if dm:
+                    name = dm.group(1).upper()
+                    params = [p.strip() for p in dm.group(2).split(',')] if dm.group(2) else []
+                    body = []
+                    i += 1
+                    while i < len(lines):
+                        bl = lines[i].strip()
+                        if bl.upper() in ('DEF END', 'END'):
+                            break
+                        if bl and not bl.startswith('#'):
+                            body.append(bl)
+                        i += 1
+                    body_str = ' : '.join(body)
+                    param_str = f"({', '.join(params)})" if params else ""
+                    process_fn(f"DEF {name}{param_str} = {body_str}")
+                    count += 1
+            else:
+                process_fn(line)
+                count += 1
+            i += 1
+        return count
+
+    def cmd_chain(self, rest: str) -> None:
+        """CHAIN "file" — load and run a program, preserving variables."""
+        m = RE_CHAIN.match(f"CHAIN {rest}")
+        if not m:
+            self.io.writeln('?USAGE: CHAIN "filename"')
+            return
+        path = m.group(1).strip()
+        try:
+            path = self._sanitize_path(path)
+        except ValueError as e:
+            self.io.writeln(f"?CHAIN ERROR: {e}")
+            return
+        if not path.endswith('.qb'):
+            path += '.qb'
+        if not os.path.isfile(path):
+            self.io.writeln(f"?FILE NOT FOUND: {path}")
+            return
+        saved_vars = dict(self.variables)
+        self.program.clear()
+        with open(path, 'r', encoding='utf-8') as f:
+            lines = [l.rstrip('\n\r') for l in f.readlines()]
+        self._load_lines_with_defs(
+            lines, lambda line: self.process(line, track_undo=False))
+        self.variables.update(saved_vars)
+        self.io.writeln(f"CHAINED {path}")
+        if self.program:
+            self.cmd_run()
+
+    def cmd_merge(self, rest: str) -> None:
+        """MERGE "file" — merge lines from another file without clearing."""
+        m = RE_MERGE.match(f"MERGE {rest}")
+        if not m:
+            self.io.writeln('?USAGE: MERGE "filename"')
+            return
+        path = m.group(1).strip()
+        try:
+            path = self._sanitize_path(path)
+        except ValueError as e:
+            self.io.writeln(f"?MERGE ERROR: {e}")
+            return
+        if not path.endswith('.qb'):
+            path += '.qb'
+        if not os.path.isfile(path):
+            self.io.writeln(f"?FILE NOT FOUND: {path}")
+            return
+        with open(path, 'r', encoding='utf-8') as f:
+            lines = [l.rstrip('\n\r') for l in f.readlines()]
+        count = self._load_lines_with_defs(
+            lines, lambda line: self.process(line, track_undo=False))
+        self.io.writeln(f"MERGED {path} ({count} lines)")
+
+    # ── Introspection ─────────────────────────────────────────────────
+
+    def cmd_defs(self) -> None:
+        """List all defined subroutines."""
+        found = False
+        if self.subroutines:
+            for name, sub in self.subroutines.items():
+                if isinstance(sub, list):
+                    self.io.writeln(f"  {name} = {' : '.join(sub)}")
+                else:
+                    params = f"({', '.join(sub['params'])})" if sub['params'] else ""
+                    self.io.writeln(f"  {name}{params} = {' : '.join(sub['body'])}")
+                found = True
+        # Also show SUB/FUNCTION blocks in the program
+        from qbasic_core.engine import RE_SUB, RE_FUNCTION
+        for ln in sorted(self.program.keys()):
+            stmt = self.program[ln].strip()
+            m = RE_SUB.match(stmt)
+            if m:
+                self.io.writeln(f"  SUB {m.group(1).upper()}({m.group(2) or ''}) at line {ln}")
+                found = True
+            m = RE_FUNCTION.match(stmt)
+            if m:
+                self.io.writeln(f"  FUNCTION {m.group(1).upper()}({m.group(2) or ''}) at line {ln}")
+                found = True
+        if not found:
+            self.io.writeln("NO SUBROUTINES DEFINED")
+
+    def cmd_regs(self) -> None:
+        """List all named registers with their qubit ranges."""
+        if not self.registers:
+            self.io.writeln("NO REGISTERS DEFINED")
+            return
+        for name, (start, size) in self.registers.items():
+            self.io.writeln(f"  {name}[0:{size}] -> qubits {start}-{start+size-1}")
+
+    def cmd_vars(self) -> None:
+        """List all variables and their current values."""
+        if not self.variables:
+            self.io.writeln("NO VARIABLES SET")
+            return
+        for name, val in self.variables.items():
+            self.io.writeln(f"  {name} = {val}")
+
+    def cmd_clear(self, rest: str) -> None:
+        """CLEAR var — remove a variable. CLEAR ARRAYS — clear all arrays."""
+        name = rest.strip()
+        if not name:
+            self.io.writeln("?USAGE: CLEAR <var> or CLEAR ARRAYS")
+            return
+        if name.upper() == 'ARRAYS':
+            self.arrays.clear()
+            self.io.writeln("ARRAYS CLEARED")
+        elif name in self.variables:
+            del self.variables[name]
+            self.io.writeln(f"CLEARED {name}")
+        elif name in self.arrays:
+            del self.arrays[name]
+            self.io.writeln(f"CLEARED array {name}")
+        else:
+            self.io.writeln(f"?{name} NOT FOUND")

qbasic_core/protocol.py

@@ -0,0 +1,77 @@
+"""Mixin contract — documents what QBasicTerminal provides to its mixins.
+
+Mixins (ExpressionMixin, DisplayMixin, LOCCMixin, ControlFlowMixin, DemoMixin)
+rely on attributes and methods defined on QBasicTerminal.  This Protocol
+formalizes that contract so that type checkers and future refactors can verify
+it is not broken.
+
+Usage:
+    from qbasic_core.protocol import TerminalProtocol
+
+Mixins should document ``Requires: TerminalProtocol`` in their class docstring.
+QBasicTerminal implicitly satisfies this protocol by construction.
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from typing import Any, Protocol, runtime_checkable
+
+import numpy as np
+
+
+@runtime_checkable
+class TerminalProtocol(Protocol):
+    """Attributes and methods that mixins expect on the host terminal."""
+
+    # ── State ──────────────────────────────────────────────────────────
+
+    program: dict[int, str]
+    num_qubits: int
+    shots: int
+    subroutines: dict[str, Any]
+    registers: OrderedDict[str, tuple[int, int]]
+    variables: dict[str, Any]
+    arrays: dict[str, list[float]]
+    last_counts: dict[str, int] | None
+    last_sv: np.ndarray | None
+    last_circuit: Any | None
+    step_mode: bool
+    sim_method: str
+    sim_device: str
+    locc: Any | None
+    locc_mode: bool
+
+    _undo_stack: list[dict[int, str]]
+    _gosub_stack: list[int]
+    _custom_gates: dict[str, np.ndarray]
+    _noise_model: Any | None
+    _max_iterations: int
+    _include_depth: int
+    _parsed: dict[int, Any]
+    _circuit_cache_key: Any | None
+    _circuit_cache: Any | None
+    io: Any  # IOPort
+
+    # ── Methods mixins call on the host ────────────────────────────────
+
+    def _get_parsed(self, line_num: int) -> Any: ...
+    def eval_expr(self, expr: str) -> float: ...
+    def _safe_eval(self, expr: str, extra_ns: dict[str, Any] | None = None) -> Any: ...
+    def _eval_with_vars(self, expr: str, run_vars: dict[str, Any]) -> float: ...
+    def _eval_condition(self, cond: str, run_vars: dict[str, Any]) -> bool: ...
+    def _gate_info(self, name: str) -> tuple[int, int] | None: ...
+    def _resolve_qubit(self, arg: str) -> int: ...
+    def _substitute_vars(self, stmt: str, run_vars: dict[str, Any]) -> str: ...
+    def _expand_statement(self, stmt: str) -> list[str]: ...
+    def _tokenize_gate(self, stmt: str) -> list[str]: ...
+    def _parse_syndrome(self, stmt: str, run_vars: dict[str, Any]) -> tuple[str, list[int], str] | None: ...
+    def _split_colon_stmts(self, stmt: str) -> list[str]: ...
+    def _print_statevector(self, sv: np.ndarray, n_qubits: int | None = None) -> None: ...
+    def _print_bloch_single(self, sv: np.ndarray, qubit: int, n_qubits: int | None = None) -> None: ...
+    def print_histogram(self, counts: dict[str, int]) -> None: ...
+    def cmd_new(self, *, silent: bool = False) -> None: ...
+    def cmd_run(self) -> None: ...
+    def cmd_list(self, rest: str = '') -> None: ...
+    def cmd_locc(self, rest: str) -> None: ...
+    def process(self, line: str) -> None: ...

qbasic_core/scope.py

@@ -0,0 +1,74 @@
+"""QBASIC variable scope — unified layered scope model."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class Scope:
+    """Layered variable scope: persistent + runtime.
+
+    Reads check runtime first, then persistent.
+    Writes mirror to both for backward compatibility with code
+    that reads self.variables directly.
+    """
+
+    def __init__(self, persistent: dict[str, Any]):
+        self._persistent = persistent
+        self._runtime: dict[str, Any] = {}
+
+    def get(self, name: str, default: Any = None) -> Any:
+        if name in self._runtime:
+            return self._runtime[name]
+        return self._persistent.get(name, default)
+
+    def __contains__(self, name: str) -> bool:
+        return name in self._runtime or name in self._persistent
+
+    def __getitem__(self, name: str) -> Any:
+        if name in self._runtime:
+            return self._runtime[name]
+        return self._persistent[name]
+
+    def __setitem__(self, name: str, value: Any) -> None:
+        self._runtime[name] = value
+        self._persistent[name] = value
+
+    def keys(self):
+        return set(self._persistent.keys()) | set(self._runtime.keys())
+
+    def items(self):
+        merged = {**self._persistent, **self._runtime}
+        return merged.items()
+
+    def values(self):
+        merged = {**self._persistent, **self._runtime}
+        return merged.values()
+
+    def update(self, other):
+        if isinstance(other, dict):
+            for k, v in other.items():
+                self[k] = v
+        elif isinstance(other, Scope):
+            for k, v in other.items():
+                self[k] = v
+
+    def as_dict(self) -> dict[str, Any]:
+        """Merged view for expression evaluation."""
+        return {**self._persistent, **self._runtime}
+
+    def __delitem__(self, name: str) -> None:
+        self._runtime.pop(name, None)
+        self._persistent.pop(name, None)
+
+    def pop(self, name: str, *default):
+        # Check runtime first, then persistent, before falling back to default.
+        if name in self._runtime:
+            val = self._runtime.pop(name)
+            self._persistent.pop(name, None)
+            return val
+        if name in self._persistent:
+            return self._persistent.pop(name)
+        if default:
+            return default[0]
+        raise KeyError(name)

qbasic_core/screen.py

@@ -0,0 +1,115 @@
+"""QBASIC screen control — SCREEN, COLOR, CLS, LOCATE, PLAY, prompt."""
+
+from __future__ import annotations
+
+import sys
+
+
+class ScreenMixin:
+    """Screen control commands for QBasicTerminal.
+
+    Requires: TerminalProtocol — uses self._screen_mode, self.last_counts,
+    self.last_sv, self.last_circuit, self.print_histogram(),
+    self._print_statevector(), self._print_bloch_single(),
+    self.cmd_density(), self.cmd_circuit().
+    """
+
+    def _init_screen(self) -> None:
+        self._color_fg: str = ''
+        self._color_bg: str = ''
+        self._prompt: str = '] '
+
+    def cmd_screen(self, rest: str) -> None:
+        """SCREEN mode — set display mode.
+        0=text  1=histogram  2=statevector  3=Bloch  4=density  5=circuit"""
+        if not rest.strip():
+            names = {0: 'text', 1: 'histogram', 2: 'statevector',
+                     3: 'Bloch', 4: 'density', 5: 'circuit'}
+            self.io.writeln(f"SCREEN = {self._screen_mode} ({names.get(self._screen_mode, '?')})")
+            return
+        mode = int(rest.strip())
+        if mode < 0 or mode > 5:
+            self.io.writeln("?SCREEN 0-5")
+            return
+        self._screen_mode = mode
+        names = {0: 'text', 1: 'histogram', 2: 'statevector',
+                 3: 'Bloch', 4: 'density', 5: 'circuit'}
+        self.io.writeln(f"SCREEN {mode} ({names[mode]})")
+
+    def _auto_display(self) -> None:
+        """Display results using current SCREEN mode after RUN."""
+        mode = self._screen_mode
+        if mode <= 1:
+            return  # text/histogram mode: histogram already shown by cmd_run
+        if mode == 2:
+            if self.last_sv is not None:
+                self._print_statevector(self.last_sv)
+        elif mode == 3:
+            if self.last_sv is not None:
+                from qbasic_core.engine import MAX_BLOCH_DISPLAY
+                for q in range(min(self.num_qubits, MAX_BLOCH_DISPLAY)):
+                    self._print_bloch_single(self.last_sv, q)
+                    self.io.writeln('')
+        elif mode == 4:
+            self.cmd_density()
+        elif mode == 5:
+            self.cmd_circuit()
+
+    def cmd_color(self, rest: str) -> None:
+        """COLOR foreground[, background] — set terminal colors."""
+        from qbasic_core.engine import RE_COLOR
+        m = RE_COLOR.match(f"COLOR {rest}")
+        if not m:
+            self.io.writeln("?USAGE: COLOR <fg>[, <bg>]")
+            return
+        self._color_fg = m.group(1).lower()
+        self._color_bg = m.group(2).lower() if m.group(2) else ''
+        # Apply via ANSI if Rich is not available
+        colors = {
+            'black': 30, 'red': 31, 'green': 32, 'yellow': 33,
+            'blue': 34, 'magenta': 35, 'cyan': 36, 'white': 37,
+        }
+        fg_code = colors.get(self._color_fg, 37)
+        if self._color_bg:
+            bg_code = colors.get(self._color_bg, 40) + 10
+            self.io.write(f"\033[{fg_code};{bg_code}m")
+        else:
+            self.io.write(f"\033[{fg_code}m")
+        self.io.writeln(f"COLOR {self._color_fg}" + (f", {self._color_bg}" if self._color_bg else ""))
+
+    def cmd_cls(self) -> None:
+        """CLS — clear screen."""
+        self.io.write('\033[2J\033[H')
+
+    def cmd_locate(self, rest: str) -> None:
+        """LOCATE row, col — position cursor."""
+        from qbasic_core.engine import RE_LOCATE
+        m = RE_LOCATE.match(f"LOCATE {rest}")
+        if not m:
+            self.io.writeln("?USAGE: LOCATE <row>, <col>")
+            return
+        row, col = int(m.group(1)), int(m.group(2))
+        self.io.write(f"\033[{row};{col}H")
+
+    def cmd_play(self, rest: str = '') -> None:
+        """PLAY — terminal bell/beep."""
+        count = 1
+        if rest.strip():
+            try:
+                count = int(rest.strip())
+            except ValueError:
+                pass
+        for _ in range(count):
+            self.io.write('\a')
+
+    def cmd_prompt(self, rest: str) -> None:
+        """PROMPT <string> — set the REPL prompt."""
+        if not rest.strip():
+            self.io.writeln(f"PROMPT = {self._prompt!r}")
+            return
+        text = rest.strip()
+        if (text.startswith('"') and text.endswith('"')) or \
+           (text.startswith("'") and text.endswith("'")):
+            text = text[1:-1]
+        self._prompt = text
+        self.io.writeln(f"PROMPT = {self._prompt!r}")