re2vp 1.0.0__tar.gz

re2vp-1.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.3
+Name: re2vp
+Version: 1.0.0
+Summary: Add your description here
+Author: Varphi
+Author-email: Varphi <support@varphi-lang.com>
+Requires-Dist: greenery>=4.2.2
+Requires-Dist: vp2py>=3.0.3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+

re2vp-1.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "re2vp"
+version = "1.0.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "greenery>=4.2.2",
+    "vp2py>=3.0.3",
+]
+
+[[project.authors]]
+name = "Varphi"
+email = "support@varphi-lang.com"
+
+[project.scripts]
+re2vp = "re2vp.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "black>=26.5.1",
+    "pillow>=12.3.0",
+    "pyinstaller>=6.22.2",
+    "pytest>=9.1.1",
+    "requests>=2.34.2",
+    "vermin>=1.8.0",
+]

re2vp-1.0.0/pyproject.toml.orig

@@ -0,0 +1,30 @@
+[project]
+name = "re2vp"
+version = "1.0.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "Varphi", email = "support@varphi-lang.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "greenery>=4.2.2",
+    "vp2py>=3.0.3",
+]
+
+[project.scripts]
+re2vp = "re2vp.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "black>=26.5.1",
+    "pillow>=12.3.0",
+    "pyinstaller>=6.22.2",
+    "pytest>=9.1.1",
+    "requests>=2.34.2",
+    "vermin>=1.8.0",
+]

re2vp-1.0.0/src/re2vp/__init__.py

@@ -0,0 +1,7 @@
+from .utils import compile_regex_to_varphi
+
+__version__ = "v1.0.0"
+
+__all__ = [
+    "compile_regex_to_varphi"
+]

re2vp-1.0.0/src/re2vp/cli.py

@@ -0,0 +1,136 @@
+import sys
+import io
+import time
+from typing import Optional
+from pathlib import Path
+import typer
+from vp2py import VarphiToPythonCompiler
+from .utils import compile_regex_to_varphi
+
+app = typer.Typer(add_completion=False)
+
+class MultiLineTapeBuffer:
+    def __init__(self, payload: str):
+        self.step = 0
+        self.payload = payload
+        
+    def readline(self, *args, **kwargs) -> str:
+        if self.step == 0:  # The tape count
+            self.step += 1
+            return "1\n"
+        elif self.step == 1:  # The first tape content
+            self.step += 1
+            return self.payload + "\n"
+        return ""
+        
+    def isatty(self) -> bool:
+        return False
+
+def timed_step(name: str, verbose: bool, func, *args, **kwargs):
+    """Helper to cleanly run a step, print verbose logs, and measure execution time."""
+    if verbose:
+        typer.echo(f"{name}...", err=True)
+    t0 = time.perf_counter()
+    result = func(*args, **kwargs)
+    t1 = time.perf_counter()
+    if verbose:
+        typer.echo(f"      Done in {t1 - t0:.4f} seconds.\n", err=True)
+    return result
+
+@app.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+    help="Compile a regex to Varphi, and optionally execute it against a payload."
+)
+def re2vp_command(
+    ctx: typer.Context,
+    regex: Optional[str] = typer.Argument(None, help="The regular expression."),
+    search: bool = typer.Option(False, "--search", "-s", help="Execute search mode against a payload."),
+    file: Optional[Path] = typer.Option(None, "--file", "-f", exists=True, dir_okay=False, help="Payload file."),
+    debug: bool = typer.Option(False, "--debug", help="Enable verbose step-by-step logging."),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Print execution steps and timings."),
+):
+    """re2vp: Regex to Varphi Compiler."""
+    
+    # Input resolution
+    if search and not regex:
+        typer.echo("Error: When using --search, the regex must be provided as an argument.", err=True)
+        raise typer.Exit(code=1)
+
+    source_regex = regex if regex else sys.stdin.read().strip()
+    if not source_regex:
+        typer.echo("Error: No regex provided.", err=True)
+        raise typer.Exit(code=1)
+
+    search_payload = None
+    if search:
+        search_payload = file.read_text(encoding="utf-8") if file else sys.stdin.read()
+        if not search_payload.strip():
+            typer.echo("Error: Search payload cannot be empty.", err=True)
+            raise typer.Exit(code=1)
+
+    # Compile regex to vp
+    try:
+        vp_source = timed_step("[1/3] Compiling Regex to Varphi IR", verbose, compile_regex_to_varphi, source_regex)
+    except Exception as e:
+        typer.echo(f"Regex compilation error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    # If compile-only mode, output and exit
+    if not search:
+        typer.echo(vp_source)
+        return
+
+    # Compile vp to py
+    try:
+        compiler = VarphiToPythonCompiler()
+        py_code = timed_step("[2/3] Compiling Varphi IR to Python", verbose, compiler.compile, vp_source)
+    except Exception as e:
+        typer.echo(f"Error while compiling Varphi to Python: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    # Run the py
+    execution_globals = {"__name__": "__main__", "__file__": "<re2vp_execution>", "__builtins__": __builtins__}
+    original_stdin, original_stdout, original_argv = sys.stdin, sys.stdout, sys.argv
+    captured_stdout = io.StringIO()
+
+    try:
+        # We will replace stdin with our own buffer
+        # We do this so we can send in an entire payload (which may include newlines) on one tape
+        # If we don't do this, then the tape content will get cut off at the first newline
+        sys.stdin = MultiLineTapeBuffer(search_payload)
+        sys.stdout = captured_stdout
+        sys.argv = ["re2vp-run"] + (["--debug"] if debug else [])
+        
+        if verbose:
+            typer.echo("[3/3] Executing Varphi Machine...", err=True)
+        t0 = time.perf_counter()
+        
+        exec(py_code, execution_globals)
+        
+    except SystemExit:
+        pass
+    except Exception as e:
+        typer.echo(f"Runtime Error: {e}", err=True)
+        raise typer.Exit(code=1)
+    finally:
+        sys.stdin, sys.stdout, sys.argv = original_stdin, original_stdout, original_argv
+        if verbose:
+            typer.echo(f"      Done in {time.perf_counter() - t0:.4f} seconds.\n", err=True)
+
+    # Evaluate result
+    output = captured_stdout.getvalue().strip()
+    if output:
+        final_state = output.splitlines()[-1].strip()
+        typer.echo(final_state, err=True)
+        raise typer.Exit(code=0 if final_state == "ACCEPT" else 1)
+    
+    typer.echo("Error: No output generated by Varphi runtime.", err=True)
+    raise typer.Exit(code=1)
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

re2vp-1.0.0/src/re2vp/utils.py

@@ -0,0 +1,70 @@
+from greenery import parse
+
+def compile_regex_to_varphi(regex_str: str) -> str:
+    """Compiles a standard regular expression string into Varphi source code."""
+    # Strip ^ and $ since greenery isn't compatible with them
+    if regex_str.startswith("^"):
+        regex_str = regex_str[1:]
+    if regex_str.endswith("$"):
+        regex_str = regex_str[:-1]
+
+    # Parse the regex and compute the DFA
+    dfa = parse(regex_str).to_fsm()
+
+    lines = [
+        f"// --- Varphi Regex Machine ---",
+        f"// Pattern: {regex_str}",
+        f"// States: {len(dfa.states)}",
+        ""
+    ]
+
+    # We need a clean naming convention because greenery uses complex objects/tuples for state IDs
+    normalized_states = {}
+    next_state_number = 0
+
+    # Go through the DFA's routing table
+    for current_state, paths in dfa.map.items():
+        # Register the current state if we haven't seen it yet
+        if current_state not in normalized_states:
+            normalized_states[current_state] = f"q{next_state_number}"
+            next_state_number += 1
+            
+        has_wildcard = False
+        # At first, it's assumed that if no concrete rule of this state matches, we go to REJECT
+        fallback_target = "REJECT"
+        for charclass, next_state in paths.items():
+            # Register destination states dynamically as we encounter them
+            if next_state not in normalized_states:
+                normalized_states[next_state] = f"q{next_state_number}"
+                next_state_number += 1
+
+            # In greenery, wildcards/fallbacks are represented by negated character classes
+            if charclass.negated:
+                has_wildcard = True
+                # So if we match anything other than a concrete rule now, go to this state since it is now the fallback
+                fallback_target = normalized_states[next_state]
+            else:
+                # Positive character class: extract every literal character inside it
+                for char in charclass.get_chars():
+                    # Instead of using the characters, just use the ascii code to avoid issues with special characters
+                    safe_sym = str(ord(char))
+                    lines.append(f"{normalized_states[current_state]} ({safe_sym}) {normalized_states[next_state]} ({safe_sym}) (RIGHT)")
+
+        # We need special transitions for if we hit the end of string while on this state
+        if current_state in dfa.finals:
+            # If we hit BLANK in a valid final (accepting) state, the payload is accepted
+            lines.append(f"{normalized_states[current_state]} (BLANK) ACCEPT (BLANK) (STAY)")
+        else:
+            # If we hit BLANK in a non-final state, the payload terminated too early
+            lines.append(f"{normalized_states[current_state]} (BLANK) REJECT (BLANK) (STAY)")
+
+        if has_wildcard:
+            # The DFA defined a valid path for "anything else", so use a Varphi variable to route there
+            lines.append(f"{normalized_states[current_state]} ($anythingElse) {fallback_target} ($anythingElse) (RIGHT)")
+        else:
+            # The DFA has no wildcard, so any unrecognized character is an instant failure
+            lines.append(f"{normalized_states[current_state]} ($anythingElse) REJECT ($anythingElse) (STAY)")
+        
+        lines.append("") # Empty line for readability between state blocks
+
+    return "\n".join(lines)