vp2pydap 3.0.0__tar.gz

vp2pydap-3.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.3
+Name: vp2pydap
+Version: 3.0.0
+Summary: An implementation of a Varphi-to-DAP-compliant-Python compiler.
+Author: Varphi
+Author-email: Varphi <support@varphi-lang.com>
+Requires-Dist: vp2py>=3.0.0
+Requires-Dist: varphi-devkit>=3.0.0
+Requires-Dist: typer
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# The Varphi-to-PythonDAP Compiler
+This is the source code repository for a compiler that converts the [Varphi programming language](https://varphi-lang.com/) into a Debug Adapter Protocol (DAP) debugger written in Python.

vp2pydap-3.0.0/README.md

@@ -0,0 +1,2 @@
+# The Varphi-to-PythonDAP Compiler
+This is the source code repository for a compiler that converts the [Varphi programming language](https://varphi-lang.com/) into a Debug Adapter Protocol (DAP) debugger written in Python.

vp2pydap-3.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "vp2pydap"
+version = "3.0.0"
+description = "An implementation of a Varphi-to-DAP-compliant-Python compiler."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "vp2py>=3.0.0",
+    "varphi-devkit>=3.0.0",
+    "typer",
+]
+
+[[project.authors]]
+name = "Varphi"
+email = "support@varphi-lang.com"
+
+[project.scripts]
+vp2pydap = "vp2pydap.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "black",
+    "pytest",
+    "vermin",
+]

vp2pydap-3.0.0/pyproject.toml.orig

@@ -0,0 +1,28 @@
+[project]
+name = "vp2pydap"
+version = "3.0.0"
+description = "An implementation of a Varphi-to-DAP-compliant-Python compiler."
+readme = "README.md"
+authors = [
+    { name = "Varphi", email = "support@varphi-lang.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "vp2py>=3.0.0",
+    "varphi-devkit>=3.0.0",
+    "typer",
+]
+
+[project.scripts]
+vp2pydap = "vp2pydap.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "black",
+    "pytest",
+    "vermin"
+]

vp2pydap-3.0.0/src/vp2pydap/__init__.py

@@ -0,0 +1,3 @@
+from .compiler import VarphiToPythonDAPCompiler
+
+__all__ = ["VarphiToPythonDAPCompiler"]

vp2pydap-3.0.0/src/vp2pydap/cli.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+import typer
+
+
+def vp2pydap(
+    input_file: Path = typer.Argument(
+        ...,
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        resolve_path=True,
+        help="Path to input Varphi source file",
+    ),
+):
+    """
+    Compile a Varphi source code file to a Python Debug Adapter Protocol (DAP) server.
+
+    The output of this command is a Python script that, when run, listens
+    for DAP JSON-RPC messages on stdin/stdout.
+    """
+    from .compiler import VarphiToPythonDAPCompiler
+
+    compiler = VarphiToPythonDAPCompiler()
+    compiler.set_source_path(str(input_file))
+    source_code = input_file.read_text(encoding="utf-8")
+    compiled_code = compiler.compile(source_code)
+    typer.echo(compiled_code)
+
+
+def main():
+    typer.run(vp2pydap)
+
+
+if __name__ == "__main__":
+    main()

vp2pydap-3.0.0/src/vp2pydap/compiler.py

@@ -0,0 +1,111 @@
+import os
+from varphi_devkit import (
+    VarphiCompiler,
+    BuiltinSymbol,
+    Variable,
+    Direction,
+    Character,
+    ReadWriteTupleElement,
+)
+
+TEMPLATE = """\
+import argparse
+from vp2py.lib import State
+from varphi_devkit import BuiltinSymbol, Direction, Variable, Character, VarphiTransition
+from vp2pydap.lib import DAPServer
+
+# --- State Registry ---
+state_registry = {{
+{state_registry_entries}
+}}
+
+# --- Transition Definitions ---
+{instruction_definitions}
+
+# --- Runtime Setup ---
+initial_state = state_registry['{initial_state}']
+k = {num_tapes}
+ORIGINAL_SOURCE_PATH = "{original_source_path}"
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--tapes', nargs='*', help='Initial values for tapes', default=[])
+    args, unknown = parser.parse_known_args()
+    
+    input_tapes = args.tapes
+    while len(input_tapes) < k:
+        input_tapes.append("")
+
+    server = DAPServer(k, initial_state, state_registry, input_tapes, ORIGINAL_SOURCE_PATH)
+    server.run_event_loop()
+"""
+
+
+class VarphiToPythonDAPCompiler(VarphiCompiler):
+    _source_path: str
+
+    def __init__(self):
+        super().__init__()
+        self._source_path = "unknown.vp"
+
+    def set_source_path(self, path: str) -> None:
+        """
+        Sets the path of the source file being compiled.
+        This path is embedded into the generated debugger to support source mapping.
+        """
+        self._source_path = path
+
+    def _format_symbol(self, s: ReadWriteTupleElement) -> str:
+        if s == BuiltinSymbol.BLANK:
+            return "BuiltinSymbol.BLANK"
+        if isinstance(s, Variable):
+            return f"Variable({s.id})"
+        if isinstance(s, Character):
+            return f"Character({repr(s.value)})"
+        raise ValueError(f"Unknown symbol type: {type(s)}")
+
+    def _format_direction(self, d: Direction) -> str:
+        return f"Direction.{d.name}"
+
+    def _generate_compiled_program(self) -> str:
+        all_states = self.states
+
+        registry_entries = "\n".join(
+            f"    '{name}': State('{name}')," for name in all_states
+        )
+
+        instructions_code = []
+        for transitions in self.ir.values():
+            for t in transitions:
+                read_str = "(" + ", ".join(self._format_symbol(s) for s in t.read_symbols)
+                read_str += ",)" if len(t.read_symbols) == 1 else ")"
+
+                write_str = "(" + ", ".join(self._format_symbol(s) for s in t.write_symbols)
+                write_str += ",)" if len(t.write_symbols) == 1 else ")"
+
+                shift_str = "(" + ", ".join(self._format_direction(d) for d in t.shift_directions)
+                shift_str += ",)" if len(t.shift_directions) == 1 else ")"
+
+                code = (
+                    f"state_registry['{t.current_state}'].add_transition(\n"
+                    f"    VarphiTransition(\n"
+                    f"        current_state='{t.current_state}',\n"
+                    f"        read_symbols={read_str},\n"
+                    f"        next_state='{t.next_state}',\n"
+                    f"        write_symbols={write_str},\n"
+                    f"        shift_directions={shift_str},\n"
+                    f"        line_number={t.line_number}\n"
+                    f"    )\n"
+                    f")"
+                )
+                instructions_code.append(code)
+
+        sanitized_path = os.path.abspath(self._source_path).replace("\\", "\\\\")
+
+        return TEMPLATE.format(
+            state_registry_entries=registry_entries,
+            instruction_definitions="\n\n".join(instructions_code),
+            initial_state=self.initial_state,
+            num_tapes=self._tape_count,
+            original_source_path=sanitized_path,
+        )

vp2pydap-3.0.0/src/vp2pydap/lib/__init__.py

@@ -0,0 +1,3 @@
+from .debugger import DAPServer
+
+__all__ = ["DAPServer"]

vp2pydap-3.0.0/src/vp2pydap/lib/debugger.py

@@ -0,0 +1,419 @@
+from __future__ import annotations
+import sys
+import json
+import threading
+import queue
+import os
+import io
+from typing import Dict, Any, List, Optional
+from vp2py.lib import TuringMachine, State, Tape
+from varphi_devkit import BuiltinSymbol, Character
+
+
+class DAPStdout(io.TextIOBase):
+    """Redirects stdout to the VS Code Debug Console (Output category)."""
+    server: DAPServer
+    buffer: io.StringIO
+
+    def __init__(self, server_instance):
+        self.server = server_instance
+        self.buffer = io.StringIO()
+
+    def write(self, s: str):
+        if self.server:
+            self.server._send_event("output", {"category": "stdout", "output": s})
+        return len(s)
+
+
+class DAPStderr(io.TextIOBase):
+    """Redirects stderr to the VS Code Debug Console (Stderr category, usually red)."""
+    server: DAPServer
+    buffer: io.StringIO
+
+    def __init__(self, server_instance):
+        self.server = server_instance
+        self.buffer = io.StringIO()
+
+    def write(self, s: str):
+        if self.server:
+            self.server._send_event("output", {"category": "stderr", "output": s})
+        return len(s)
+
+
+class DAPServer:
+    tm: TuringMachine
+    breakpoints: dict[int, bool]
+    running: bool
+    step_granularity: Optional[str]
+    steps_count: int
+    input_queue: queue.Queue
+    original_source_path: str
+    blank_char: str
+
+    _seq: int = 0
+    _write_lock: threading.Lock
+
+    def __init__(
+        self,
+        k: int,
+        initial_state: State,
+        state_registry: dict[str, State],
+        input_tapes: List[str],
+        original_source_path: str,
+        blank_char: str = "_",
+    ):
+        self.original_source_path = os.path.abspath(original_source_path)
+        self._write_lock = threading.Lock()
+        self.blank_char = blank_char
+
+        parsed_tapes = []
+        for t_str in input_tapes:
+            parsed_tape = []
+            for char in t_str:
+                if char == self.blank_char:
+                    parsed_tape.append(BuiltinSymbol.BLANK)
+                else:
+                    parsed_tape.append(Character(char))
+            parsed_tapes.append(Tape(parsed_tape))
+
+        self.tm = TuringMachine(k, tuple(parsed_tapes), initial_state, state_registry)
+
+        self.breakpoints = {}
+        self.running = False
+        self.step_granularity = "instruction"
+        self.steps_count = 0
+
+        self.input_queue = queue.Queue()
+
+        # Redirect stdout and stderr to DAP console
+        sys.stdout = DAPStdout(self)
+        sys.stderr = DAPStderr(self)
+
+        self.reader_thread = threading.Thread(target=self._read_input_loop, daemon=True)
+        self.reader_thread.start()
+
+        # Initialize the machine view
+        try:
+            self.tm.peek()
+        except Exception:
+            # If peek fails immediately (e.g. invalid initial state), we catch it later or let it slide
+            pass
+
+    def _format_cell(self, val: Character | BuiltinSymbol) -> str:
+        return self.blank_char if val == BuiltinSymbol.BLANK else val.value
+
+    def _send_message(self, msg: Dict[str, Any]):
+        """Sends a DAP-compliant message to the real stdout."""
+        with self._write_lock:
+            self._seq += 1
+            msg["seq"] = self._seq
+            json_msg = json.dumps(msg)
+            encoded = json_msg.encode("utf-8")
+            # We write to __stdout__ because sys.stdout is redirected
+            sys.__stdout__.buffer.write(
+                f"Content-Length: {len(encoded)}\r\n\r\n".encode("utf-8")
+            )
+            sys.__stdout__.buffer.write(encoded)
+            sys.__stdout__.buffer.flush()
+
+    def _read_input_loop(self):
+        buffer = sys.stdin.buffer
+        while True:
+            try:
+                content_length = 0
+                while True:
+                    line = buffer.readline()
+                    if not line:
+                        return
+
+                    line_str = line.decode("utf-8").strip()
+                    if not line_str:
+                        break
+
+                    if line_str.startswith("Content-Length:"):
+                        content_length = int(line_str.split(":", 1)[1].strip())
+
+                if content_length > 0:
+                    content = buffer.read(content_length)
+                    self.input_queue.put(json.loads(content))
+            except Exception:
+                break
+
+    def run_event_loop(self):
+        while True:
+            try:
+                timeout = 0.0 if self.running else None
+                req = self.input_queue.get(timeout=timeout)
+                self._handle_request(req)
+            except queue.Empty:
+                pass
+
+            if self.running:
+                self._step_machine()
+
+    def _print_halt_report(self):
+        """Calculates statistics and prints the halt report to the Debug Console."""
+        total_space = sum(h.space_complexity() for h in self.tm.heads)
+        
+        report = []
+        report.append(f"HALTED at state '{self.tm.state.name}'")
+        report.append(f"Time taken: {self.steps_count} steps")
+        report.append(f"Space used: {total_space} cells")
+        report.append(f"Number of tapes: {len(self.tm.heads)}")
+
+        for i, tape in enumerate(self.tm.tapes):
+            tape_dict = tape._tape
+            if not tape_dict:
+                content = ""
+            else:
+                min_idx = min(tape_dict.keys())
+                max_idx = max(tape_dict.keys())
+                content = "".join(self._format_cell(tape_dict.get(k, BuiltinSymbol.BLANK)) for k in range(min_idx, max_idx + 1))
+            
+            report.append(f"Tape {i + 1}: {content.strip(self.blank_char)}")
+
+        # Join with newlines and print. This goes to DAPStdout -> VS Code Debug Console
+        print("\n" + "\n".join(report) + "\n")
+
+    def _step_machine(self):
+        # Check termination
+        if self.tm._next_transition is None:
+            self.running = False
+            self._print_halt_report()
+            self._send_event("terminated")
+            self._send_event("exited", {"exitCode": 0})
+            return
+
+        # Check breakpoints (unless single-stepping)
+        if self.step_granularity != "step":
+            current_line = self.tm._next_transition.line_number
+            if self.breakpoints.get(current_line, False):
+                self.running = False
+                self._send_event(
+                    "stopped",
+                    {"reason": "breakpoint", "threadId": 1, "allThreadsStopped": True},
+                )
+                return
+
+        # Execute step
+        try:
+            self.tm.step()
+            self.steps_count += 1
+            has_next = self.tm.peek()
+        except Exception as e:
+            self.running = False
+            # Print error to debug console
+            sys.stderr.write(f"\nRUNTIME ERROR: {str(e)}\n")
+            # Notify VS Code to pause on exception
+            self._send_event("stopped", {
+                "reason": "exception",
+                "description": "Paused on exception",
+                "text": str(e),
+                "threadId": 1
+            })
+            return
+
+        # Handle step pause
+        if self.step_granularity == "step":
+            self.running = False
+            self.step_granularity = None
+            reason = "step" if has_next else "pause"
+            self._send_event("stopped", {"reason": reason, "threadId": 1})
+
+    def _send_response(
+        self, req: Dict, success: bool, body: Any = None, message: str = None
+    ):
+        resp = {
+            "type": "response",
+            "request_seq": req["seq"],
+            "command": req["command"],
+            "success": success,
+        }
+        if body:
+            resp["body"] = body
+        if message:
+            resp["message"] = message
+        self._send_message(resp)
+
+    def _send_event(self, event: str, body: Any = None):
+        msg = {"type": "event", "event": event}
+        if body:
+            msg["body"] = body
+        self._send_message(msg)
+
+    def _handle_request(self, req: Dict[str, Any]):
+        try:
+            if req["type"] == "request":
+                cmd = req["command"]
+                handler = getattr(self, f"handle_{cmd}", None)
+                if handler:
+                    handler(req)
+                else:
+                    self._send_response(
+                        req, False, message=f"Command '{cmd}' not implemented"
+                    )
+        except Exception as e:
+            self._send_response(req, False, message=str(e))
+
+    # --- Handlers ---
+
+    def handle_initialize(self, req):
+        self._send_response(
+            req,
+            True,
+            {
+                "supportsConfigurationDoneRequest": True,
+                "supportsSetVariable": False,
+                "supportsValueFormattingOptions": False,
+                "supportsExceptionInfoRequest": True,
+            },
+        )
+        self._send_event("initialized")
+
+    def handle_launch(self, req):
+        self._send_response(req, True)
+
+    def handle_setBreakpoints(self, req):
+        lines = req["arguments"].get("lines", [])
+        self.breakpoints = {ln: True for ln in lines}
+        verified_bps = [{"verified": True, "line": ln} for ln in lines]
+        self._send_response(req, True, {"breakpoints": verified_bps})
+
+    def handle_configurationDone(self, req):
+        self._send_response(req, True)
+        self._send_event("stopped", {"reason": "entry", "threadId": 1})
+
+    def handle_threads(self, req):
+        self._send_response(req, True, {"threads": [{"id": 1, "name": "Main Thread"}]})
+
+    def handle_stackTrace(self, req):
+        if self.tm._next_transition:
+            line = self.tm._next_transition.line_number
+            name = f"State: {self.tm.state.name}"
+        else:
+            line = 0
+            name = f"HALTED (State: {self.tm.state.name})"
+
+        self._send_response(
+            req,
+            True,
+            {
+                "stackFrames": [
+                    {
+                        "id": 1,
+                        "name": name,
+                        "line": line,
+                        "column": 1,
+                        "source": {
+                            "name": os.path.basename(self.original_source_path),
+                            "path": self.original_source_path,
+                            "sourceReference": 0,
+                        },
+                        "presentationHint": "normal",
+                    }
+                ],
+                "totalFrames": 1,
+            },
+        )
+
+    def handle_scopes(self, req):
+        self._send_response(
+            req,
+            True,
+            {
+                "scopes": [
+                    {
+                        "name": "Machine State",
+                        "variablesReference": 1,
+                        "expensive": False,
+                    }
+                ]
+            },
+        )
+
+    def handle_variables(self, req):
+        vars_list = []
+
+        # Machine metrics
+        vars_list.append(
+            {
+                "name": "Current State",
+                "value": str(self.tm.state.name),
+                "type": "string",
+                "variablesReference": 0,
+            }
+        )
+        vars_list.append(
+            {
+                "name": "Time taken",
+                "value": str(self.steps_count),
+                "type": "integer",
+                "variablesReference": 0,
+            }
+        )
+
+        total_space = sum(h.space_complexity() for h in self.tm.heads)
+        vars_list.append(
+            {
+                "name": "Space used",
+                "value": str(total_space),
+                "type": "integer",
+                "variablesReference": 0,
+            }
+        )
+
+        # Tape visualizations
+        for i, head in enumerate(self.tm.heads):
+            center = head.index
+            raw_dict = head.tape._tape
+
+            left_ctx = "".join(
+                self._format_cell(raw_dict.get(x, BuiltinSymbol.BLANK)) for x in range(center - 5, center)
+            )
+            curr_val = self._format_cell(raw_dict.get(center, BuiltinSymbol.BLANK))
+            right_ctx = "".join(
+                self._format_cell(raw_dict.get(x, BuiltinSymbol.BLANK)) for x in range(center + 1, center + 6)
+            )
+
+            tape_display = f"{left_ctx}[{curr_val}]{right_ctx}"
+
+            vars_list.append(
+                {
+                    "name": f"Tape {i + 1}",
+                    "value": tape_display,
+                    "type": "string",
+                    "variablesReference": 0,
+                }
+            )
+
+        self._send_response(req, True, {"variables": vars_list})
+
+    def handle_next(self, req):
+        self.step_granularity = "step"
+        self.running = True
+        self._send_response(req, True)
+
+    def handle_stepIn(self, req):
+        self.handle_next(req)
+
+    def handle_continue(self, req):
+        self.step_granularity = None
+        self.running = True
+        self._send_response(req, True)
+
+    def handle_pause(self, req):
+        self.running = False
+        self._send_response(req, True)
+        self._send_event("stopped", {"reason": "pause", "threadId": 1})
+
+    def handle_disconnect(self, req):
+        self.running = False
+        self._send_response(req, True)
+        sys.exit(0)
+
+    def handle_exceptionInfo(self, req):
+        self._send_response(req, True, {
+            "exceptionId": "runtime_error",
+            "description": "An error occurred during execution",
+            "breakMode": "always"
+        })