varphi-devkit 1.4.0__tar.gz → 2.0.0__tar.gz

varphi_devkit-2.0.0/.github/workflows/pipeline.yml

@@ -0,0 +1,58 @@
+name: CI/CD
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Generate ANTLR Parser
+        run: uv run python scripts/build.py
+
+      - name: Run Pytest
+        run: uv run pytest
+
+  release:
+    name: Build & Publish
+    needs: test
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Generate ANTLR Parser
+        run: uv run python scripts/build.py
+
+      - name: Build Package
+        run: uv build
+
+      - name: Publish to PyPI
+        run: uv publish

varphi_devkit-2.0.0/.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+src/varphi_devkit/parser/*
+!src/varphi_devkit/parser/__init__.py

varphi_devkit-2.0.0/.python-version

@@ -0,0 +1 @@
+3.13

varphi_devkit-2.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: varphi-devkit
+Version: 2.0.0
+Summary: Development kit for the Varphi language
+Author-email: Hassan El-Sheikha <hassan.elsheikha@utoronto.ca>
+Requires-Python: >=3.13
+Requires-Dist: antlr4-python3-runtime>=4.13.2

varphi_devkit-2.0.0/grammar/Varphi.g4

@@ -0,0 +1,54 @@
+grammar Varphi;
+
+// ======================================================
+// PARSER RULES
+// ======================================================
+
+program : NEWLINE* transition (NEWLINE+ transition)* NEWLINE* EOF;
+
+transition : current_state=state_id read_symbols next_state=state_id write_symbols shift_directions;
+
+read_symbols : LPAREN symbol (COMMA symbol)* RPAREN;
+
+write_symbols : LPAREN symbol (COMMA symbol)* RPAREN;
+
+shift_directions : LPAREN direction (COMMA direction)* RPAREN;
+
+state_id : ID | ALPHANUM | LEFT_KW | RIGHT_KW | STAY_KW | BLANK_KW;
+
+// Updated: Symbol can now be a Variable instead of STAR
+symbol : ALPHANUM | BLANK_KW | VARIABLE;
+
+direction : LEFT_KW | RIGHT_KW | STAY_KW;
+
+// ======================================================
+// LEXER RULES
+// ======================================================
+
+LPAREN : '(';
+RPAREN : ')';
+COMMA  : ',';
+// STAR rule removed
+
+// New Lexer Rule for Variables (e.g., $x, $val_1)
+VARIABLE : '$' [a-zA-Z0-9_]+;
+
+// Keywords
+LEFT_KW  : 'LEFT';
+RIGHT_KW : 'RIGHT';
+STAY_KW  : 'STAY';
+BLANK_KW : 'BLANK';
+
+// ------------------------------------------------------
+// PRIORITY RULES
+// ------------------------------------------------------
+
+ALPHANUM : [a-zA-Z0-9];
+ID : [a-zA-Z0-9_]+;
+
+// ------------------------------------------------------
+
+COMMENT       : '//' ~[\r\n]* -> skip;
+MULTI_COMMENT : '/*' .*? '*/' -> skip;
+WS            : [ \t]+ -> skip;
+NEWLINE       : '\r'? '\n';

varphi_devkit-2.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "varphi-devkit"
+version = "2.0.0"
+description = "Development kit for the Varphi language"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "antlr4-python3-runtime>=4.13.2",
+]
+authors = [
+    { name = "Hassan El-Sheikha", email = "hassan.elsheikha@utoronto.ca" }
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[tool.hatch.build.targets.wheel.force-include]
+"src/varphi_devkit/parser" = "varphi_devkit/parser"
+
+[tool.hatch.build.targets.sdist.force-include]
+"src/varphi_devkit/parser" = "src/varphi_devkit/parser"
+
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+]

varphi_devkit-2.0.0/scripts/build.py

@@ -0,0 +1,69 @@
+import subprocess
+import sys
+import shutil
+import urllib.request
+import tempfile
+import os
+from pathlib import Path
+
+# Configuration
+ANTLR_DOWNLOAD_URL = "https://www.antlr.org/download/antlr-4.13.2-complete.jar"
+
+# Paths
+ROOT = Path(__file__).parent.parent
+GRAMMAR_FILE = ROOT / "grammar" / "Varphi.g4"
+# Using the path from your snippet:
+OUTPUT_DIR = ROOT / "src" / "varphi_devkit" / "parser"
+
+def check_java_installed():
+    if not shutil.which("java"):
+        print("Error: 'java' executable not found in PATH.")
+        print("Please install Java and ensure it is added to your environment variables.")
+        sys.exit(1)
+
+def generate_parser():
+    check_java_installed()
+
+    if not GRAMMAR_FILE.exists():
+        print(f"Error: Grammar file not found at {GRAMMAR_FILE}")
+        sys.exit(1)
+
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    (OUTPUT_DIR / "__init__.py").touch()
+
+    print(f"Downloading ANTLR jar to tempfile...")
+    
+    # Create a temp file. delete=False is required for Windows compatibility
+    # so we can close the file before Java tries to open it.
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".jar") as tmp_jar:
+        try:
+            # 1. Download
+            with urllib.request.urlopen(ANTLR_DOWNLOAD_URL) as response:
+                shutil.copyfileobj(response, tmp_jar)
+            
+            # Close the file handle so Java can read it
+            tmp_jar.close()
+
+            # 2. Run Java
+            cmd = [
+                "java",
+                "-jar", tmp_jar.name,
+                "-Dlanguage=Python3",
+                "-o", str(OUTPUT_DIR),
+                str(GRAMMAR_FILE)
+            ]
+            
+            print(f"Generating parser...")
+            subprocess.run(cmd, check=True)
+            print("Success. Parser generated in src/varphi_devkit/parser/")
+
+        except subprocess.CalledProcessError as e:
+            print("Error during ANTLR generation.")
+            sys.exit(e.returncode)
+        finally:
+            # 3. Cleanup: Delete the temp file manually
+            if os.path.exists(tmp_jar.name):
+                os.remove(tmp_jar.name)
+
+if __name__ == "__main__":
+    generate_parser()

varphi_devkit-2.0.0/src/varphi_devkit/__init__.py

@@ -0,0 +1,38 @@
+"""
+The Varphi Development Kit.
+
+A framework for building compilers, interpreters, and analysis tools for the Varphi language.
+This package handles the complexity of parsing, validation, and variable canonicalization, providing a
+convenient abstraction layer for implementing custom Varphi backends.
+
+**Core API:**
+- `VarphiCompiler`: The abstract base class you must subclass. Override `handle_transition` to process logic.
+- `VarphiTransition`: A validated, canonicalized representation of a single transition line.
+
+**Constants:**
+- `BLANK`, `LEFT`, `RIGHT`, `STAY`: Primitives for tape operations.
+
+**Exceptions:**
+- `VarphiSyntaxError`: Base class for rich error reporting with source code context.
+"""
+
+from .compiler import VarphiCompiler, VarphiTransition, BLANK, LEFT, RIGHT, STAY
+from .exceptions import (
+    VarphiSyntaxError,
+    VarphiTransitionInconsistentTapeCountError,
+    VarphiGlobalTapeCountError,
+    VarphiUndefinedVariableError,
+)
+
+__all__ = [
+    "VarphiCompiler",
+    "VarphiTransition",
+    "BLANK",
+    "LEFT",
+    "RIGHT",
+    "STAY",
+    "VarphiSyntaxError",
+    "VarphiTransitionInconsistentTapeCountError",
+    "VarphiGlobalTapeCountError",
+    "VarphiUndefinedVariableError",
+]

varphi_devkit-2.0.0/src/varphi_devkit/compiler.py

@@ -0,0 +1,185 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional
+from antlr4 import InputStream, CommonTokenStream, ParseTreeWalker
+
+from .parser import VarphiLexer
+from .parser import VarphiParser
+from .parser import VarphiListener
+
+from .exceptions import (
+    VarphiErrorListener,
+    VarphiTransitionInconsistentTapeCountError,
+    VarphiGlobalTapeCountError,
+    VarphiUndefinedVariableError,
+)
+
+BLANK = "_"
+LEFT = "LEFT"
+RIGHT = "RIGHT"
+STAY = "STAY"
+
+
+@dataclass(frozen=True)
+class VarphiTransition:
+    """
+    Represents a transition (a single line) in a Varphi program.
+    Attributes:
+        - current_state (str): String containing the name of the state the machine must be on to trigger this transition.
+        - read_symbols (tuple[str, ...]): Tuple of strings containing the values the heads must read to trigger this transition. Strings starting with $ are variables and are guaranteed to be ordered ($1, $2, ...). Otherwise, members may be BLANK or alphanumericals.
+        - next_state (str): The name of the next state to transition to when this transition is triggered.
+        - write_symbols (tuple[str, ...]): Tuple of strings containing the values the heads will write when this transition is triggered. Follows the same format as read_symbols, and variable names appearing here are guaranteed to appear in read_symbols.
+        - shift_directions (tuple[str, ...]): A tuple of strings containing the directions the heads will move in when this transition is triggered. Each element is guaranteed to be one of LEFT, RIGHT, or STAY
+        - line_number (int): The line number in the source code this transition corresponds to.
+    """
+
+    current_state: str
+    read_symbols: tuple[str, ...]
+    next_state: str
+    write_symbols: tuple[str, ...]
+    shift_directions: tuple[str, ...]
+    line_number: int
+
+
+class VarphiCompiler(VarphiListener, ABC):
+    """
+    An abstract Varphi compiler.
+
+    Concrete Varphi compiler implementations must subclass this class and implement the following methods:
+        - handle_transition(self, transition: VarphiTransition) -> None: Automatically called at compile-time on each transition in the Varphi program
+        - generate_compiled_program(self) -> str: Returns the compiled Varphi program after all transitions have been handled via handle_transition()
+    If __init__() is overridden to add additional attributes (e.g., the compiled program so far), then
+        - super().__init__() must be called
+        - compile(self, program: str) -> str must be overridden to reset the state, followed by a call to super().__init__()
+    """
+
+    _expected_tape_count: Optional[int]
+
+    def __init__(self):
+        """Initialize this compiler."""
+        self._expected_tape_count = None
+
+    @abstractmethod
+    def handle_transition(self, transition: VarphiTransition) -> None:
+        """Handle a single transition in a Varphi program."""
+        pass
+
+    @abstractmethod
+    def generate_compiled_program(self) -> str:
+        """Generate the compiled program after all transitions have been handled."""
+        pass
+
+    def compile(self, program: str) -> str:
+        """Compile a Varphi program."""
+        # Reset state (subclasses must do so for their own state too)
+        self._expected_tape_count = None
+
+        input_stream = InputStream(program)
+        error_listener = VarphiErrorListener()
+
+        lexer = VarphiLexer(input_stream)
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(error_listener)
+
+        token_stream = CommonTokenStream(lexer)
+        parser = VarphiParser(token_stream)
+        parser.removeErrorListeners()
+        parser.addErrorListener(error_listener)
+
+        tree = parser.program()
+        walker = ParseTreeWalker()
+        walker.walk(self, tree)
+
+        return self.generate_compiled_program()
+
+    def enterTransition(self, ctx: VarphiParser.TransitionContext) -> None:
+        """Extract information from a raw transition context, and delegate to handle_transition()."""
+        current_state = ctx.current_state.getText()
+        next_state = ctx.next_state.getText()
+
+        def extract_symbol(symbol_ctx) -> str:
+            """Given a symbol context, extract the corresponding symbol string."""
+            if symbol_ctx.VARIABLE():
+                return symbol_ctx.VARIABLE().getText()
+            if symbol_ctx.BLANK_KW():
+                return BLANK
+            if symbol_ctx.ALPHANUM():
+                return symbol_ctx.ALPHANUM().getText()
+            raise ValueError(f"Unknown symbol type: {symbol_ctx.getText()}")
+
+        def extract_direction(symbol_ctx) -> str:
+            """Given a direction context, extract the corresponding direction string."""
+            if symbol_ctx.LEFT_KW():
+                return LEFT
+            if symbol_ctx.RIGHT_KW():
+                return RIGHT
+            if symbol_ctx.STAY_KW():
+                return STAY
+            raise ValueError(f"Unknown direction: {symbol_ctx.getText()}")
+
+        read_ctx = ctx.read_symbols()
+        reads = tuple(extract_symbol(s) for s in read_ctx.symbol()) if read_ctx else ()
+
+        write_ctx = ctx.write_symbols()
+        writes = (
+            tuple(extract_symbol(s) for s in write_ctx.symbol()) if write_ctx else ()
+        )
+
+        shift_ctx = ctx.shift_directions()
+        shifts = (
+            tuple(extract_direction(d) for d in shift_ctx.direction())
+            if shift_ctx
+            else ()
+        )
+
+        # Check if the tuple-lengths of the transition are all the same
+        if len(writes) != len(reads) or len(shifts) != len(reads):
+            raise VarphiTransitionInconsistentTapeCountError(
+                ctx, len(reads), len(writes), len(shifts)
+            )
+
+        # Use the tuple lengths of the first transition as ground truth and make sure all other transitions are consistent
+        current_tape_count = len(reads)
+        if self._expected_tape_count is None:
+            self._expected_tape_count = current_tape_count
+        elif current_tape_count != self._expected_tape_count:
+            raise VarphiGlobalTapeCountError(
+                ctx, self._expected_tape_count, current_tape_count
+            )
+
+        # Map user variables to $1, $2, $3... based on appearance in the read tuple
+        # NOTE: This is just an optimization so that equivalent patterns ($x, $y) and ($y, $x) are easy call "equivalent"
+        variable_map = {}
+        next_var_id = 1
+        canonical_reads = []
+        for sym in reads:
+            if sym.startswith("$"):
+                # Check if we have already assigned an ID to this variable (e.g. read($x, $x))
+                if sym not in variable_map:
+                    variable_map[sym] = f"${next_var_id}"
+                    next_var_id += 1
+                canonical_reads.append(variable_map[sym])
+            else:
+                canonical_reads.append(sym)
+
+        # Map write variables to their canonical versions
+        canonical_writes = []
+        for i, sym in enumerate(writes):
+            if sym.startswith("$"):
+                if sym not in variable_map:
+                    # This variable is not defined in the read tuple
+                    specific_ctx = write_ctx.symbol(i)
+                    raise VarphiUndefinedVariableError(specific_ctx, sym)
+                canonical_writes.append(variable_map[sym])
+            else:
+                canonical_writes.append(sym)
+
+        transition = VarphiTransition(
+            current_state=current_state,
+            read_symbols=tuple(canonical_reads),
+            next_state=next_state,
+            write_symbols=tuple(canonical_writes),
+            shift_directions=shifts,
+            line_number=ctx.start.line,
+        )
+        self.handle_transition(transition)

varphi_devkit-2.0.0/src/varphi_devkit/exceptions.py

@@ -0,0 +1,130 @@
+from antlr4.error.ErrorListener import ErrorListener
+from antlr4 import Token
+
+RESET = "\033[0m"
+BOLD = "\033[1m"
+RED = "\033[91m"
+BLUE = "\033[34m"
+CYAN = "\033[96m"
+WHITE = "\033[97m"
+
+
+class VarphiSyntaxError(Exception):
+    """
+    Base exception class for all Varphi compilation errors.
+    Captures context (line, column, symbol).
+    """
+
+    def __init__(self, recognizer, offendingSymbol, line, column, msg):
+        self.recognizer = recognizer
+        self.offendingSymbol = offendingSymbol
+        self.line = line
+        self.column = column
+        self.msg = msg
+        super().__init__(msg)
+
+    def __str__(self) -> str:
+        # Start the error message with a bold red "error:" label
+        result = [f"\n{BOLD}{RED}error:{RESET} {BOLD}{WHITE}{self.msg}{RESET}"]
+        result.append(f"{BLUE}   -->{RESET} line {self.line}:{self.column + 1}")
+
+        # Attempt to retrieve the input stream to show the code snippet
+        stream = None
+        try:
+            # Try getting the stream from the recognizer (parser/lexer)
+            if self.recognizer:
+                temp_stream = self.recognizer.getInputStream()
+                if hasattr(temp_stream, "tokenSource"):
+                    stream = temp_stream.tokenSource.inputStream
+                else:
+                    stream = temp_stream
+
+            # If that fails, try getting it from the offending symbol (token)
+            elif self.offendingSymbol:
+                if hasattr(self.offendingSymbol, "getInputStream"):
+                    stream = self.offendingSymbol.getInputStream()
+                elif hasattr(self.offendingSymbol, "tokenSource"):
+                    stream = self.offendingSymbol.tokenSource.inputStream
+
+            # If we successfully found the stream, generate the code preview
+            if stream:
+                lines = str(stream).splitlines()
+                # Ensure the line number is valid within the source
+                if 0 <= self.line - 1 < len(lines):
+                    code_line = lines[self.line - 1]
+
+                    # Formatting constants for the "gutter"
+                    gutter_width = 4
+                    line_num_str = str(self.line)
+
+                    # Print the empty pipe above the code line
+                    result.append(f"{BLUE}{' ' * gutter_width} |{RESET}")
+
+                    # Print the actual line of code with the line number
+                    result.append(
+                        f"{BLUE}{line_num_str:>{gutter_width}} |{RESET} {code_line}"
+                    )
+
+                    # Calculate the length of the error squiggle (^)
+                    token_len = 1
+                    if self.offendingSymbol and isinstance(self.offendingSymbol, Token):
+                        start = self.offendingSymbol.start
+                        stop = self.offendingSymbol.stop
+                        if start is not None and stop is not None:
+                            token_len = stop - start + 1
+
+                    # Create the pointer line (e.g., "      |     ^~~~")
+                    padding = " " * self.column
+                    pointer = f"{BOLD}{RED}^{'~' * (token_len - 1)}{RESET}"
+                    result.append(
+                        f"{BLUE}{' ' * gutter_width} |{RESET} {padding}{pointer}"
+                    )
+
+        except Exception:
+            # Fallback: If anything fails during error generation, just return the basic message
+            pass
+
+        return "\n".join(result)
+
+
+class VarphiTransitionInconsistentTapeCountError(VarphiSyntaxError):
+    """Raised when a single transition has mismatched read/write/shift tuple lengths."""
+
+    def __init__(self, ctx, r_len, w_len, s_len):
+        msg = (
+            f"local tape count mismatch: read {r_len} symbols, "
+            f"but wrote {w_len} and shifted {s_len}"
+        )
+        super().__init__(None, ctx.start, ctx.start.line, ctx.start.column, msg)
+
+
+class VarphiGlobalTapeCountError(VarphiSyntaxError):
+    """Raised when a transition's tape count doesn't match the machine's global tape count."""
+
+    def __init__(self, ctx, expected, actual):
+        msg = (
+            f"global tape count mismatch: previous transitions used {expected} tapes, "
+            f"but this one uses {actual}"
+        )
+        super().__init__(None, ctx.start, ctx.start.line, ctx.start.column, msg)
+
+
+class VarphiUndefinedVariableError(VarphiSyntaxError):
+    """Raised when a variable is used in a write tuple without being defined in the read tuple."""
+
+    def __init__(self, ctx, variable_name):
+        msg = (
+            f"Undefined variable: '{variable_name}' is used in the write tuple "
+            f"but was not defined in the read tuple."
+        )
+        super().__init__(None, ctx.start, ctx.start.line, ctx.start.column, msg)
+
+
+class VarphiErrorListener(ErrorListener):
+    """Custom ANTLR ErrorListener that converts syntax errors into VarphiSyntaxErrors."""
+
+    def __init__(self):
+        super().__init__()
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        raise VarphiSyntaxError(recognizer, offendingSymbol, line, column, msg)

varphi_devkit-2.0.0/src/varphi_devkit/parser/Varphi.interp

@@ -0,0 +1,47 @@
+token literal names:
+null
+'('
+')'
+','
+null
+'LEFT'
+'RIGHT'
+'STAY'
+'BLANK'
+null
+null
+null
+null
+null
+null
+
+token symbolic names:
+null
+LPAREN
+RPAREN
+COMMA
+VARIABLE
+LEFT_KW
+RIGHT_KW
+STAY_KW
+BLANK_KW
+ALPHANUM
+ID
+COMMENT
+MULTI_COMMENT
+WS
+NEWLINE
+
+rule names:
+program
+transition
+read_symbols
+write_symbols
+shift_directions
+state_id
+symbol
+direction
+
+
+atn:
+[4, 1, 14, 88, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 1, 0, 5, 0, 18, 8, 0, 10, 0, 12, 0, 21, 9, 0, 1, 0, 1, 0, 4, 0, 25, 8, 0, 11, 0, 12, 0, 26, 1, 0, 5, 0, 30, 8, 0, 10, 0, 12, 0, 33, 9, 0, 1, 0, 5, 0, 36, 8, 0, 10, 0, 12, 0, 39, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 53, 8, 2, 10, 2, 12, 2, 56, 9, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 64, 8, 3, 10, 3, 12, 3, 67, 9, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 5, 4, 75, 8, 4, 10, 4, 12, 4, 78, 9, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 0, 0, 8, 0, 2, 4, 6, 8, 10, 12, 14, 0, 3, 1, 0, 5, 10, 2, 0, 4, 4, 8, 9, 1, 0, 5, 7, 86, 0, 19, 1, 0, 0, 0, 2, 42, 1, 0, 0, 0, 4, 48, 1, 0, 0, 0, 6, 59, 1, 0, 0, 0, 8, 70, 1, 0, 0, 0, 10, 81, 1, 0, 0, 0, 12, 83, 1, 0, 0, 0, 14, 85, 1, 0, 0, 0, 16, 18, 5, 14, 0, 0, 17, 16, 1, 0, 0, 0, 18, 21, 1, 0, 0, 0, 19, 17, 1, 0, 0, 0, 19, 20, 1, 0, 0, 0, 20, 22, 1, 0, 0, 0, 21, 19, 1, 0, 0, 0, 22, 31, 3, 2, 1, 0, 23, 25, 5, 14, 0, 0, 24, 23, 1, 0, 0, 0, 25, 26, 1, 0, 0, 0, 26, 24, 1, 0, 0, 0, 26, 27, 1, 0, 0, 0, 27, 28, 1, 0, 0, 0, 28, 30, 3, 2, 1, 0, 29, 24, 1, 0, 0, 0, 30, 33, 1, 0, 0, 0, 31, 29, 1, 0, 0, 0, 31, 32, 1, 0, 0, 0, 32, 37, 1, 0, 0, 0, 33, 31, 1, 0, 0, 0, 34, 36, 5, 14, 0, 0, 35, 34, 1, 0, 0, 0, 36, 39, 1, 0, 0, 0, 37, 35, 1, 0, 0, 0, 37, 38, 1, 0, 0, 0, 38, 40, 1, 0, 0, 0, 39, 37, 1, 0, 0, 0, 40, 41, 5, 0, 0, 1, 41, 1, 1, 0, 0, 0, 42, 43, 3, 10, 5, 0, 43, 44, 3, 4, 2, 0, 44, 45, 3, 10, 5, 0, 45, 46, 3, 6, 3, 0, 46, 47, 3, 8, 4, 0, 47, 3, 1, 0, 0, 0, 48, 49, 5, 1, 0, 0, 49, 54, 3, 12, 6, 0, 50, 51, 5, 3, 0, 0, 51, 53, 3, 12, 6, 0, 52, 50, 1, 0, 0, 0, 53, 56, 1, 0, 0, 0, 54, 52, 1, 0, 0, 0, 54, 55, 1, 0, 0, 0, 55, 57, 1, 0, 0, 0, 56, 54, 1, 0, 0, 0, 57, 58, 5, 2, 0, 0, 58, 5, 1, 0, 0, 0, 59, 60, 5, 1, 0, 0, 60, 65, 3, 12, 6, 0, 61, 62, 5, 3, 0, 0, 62, 64, 3, 12, 6, 0, 63, 61, 1, 0, 0, 0, 64, 67, 1, 0, 0, 0, 65, 63, 1, 0, 0, 0, 65, 66, 1, 0, 0, 0, 66, 68, 1, 0, 0, 0, 67, 65, 1, 0, 0, 0, 68, 69, 5, 2, 0, 0, 69, 7, 1, 0, 0, 0, 70, 71, 5, 1, 0, 0, 71, 76, 3, 14, 7, 0, 72, 73, 5, 3, 0, 0, 73, 75, 3, 14, 7, 0, 74, 72, 1, 0, 0, 0, 75, 78, 1, 0, 0, 0, 76, 74, 1, 0, 0, 0, 76, 77, 1, 0, 0, 0, 77, 79, 1, 0, 0, 0, 78, 76, 1, 0, 0, 0, 79, 80, 5, 2, 0, 0, 80, 9, 1, 0, 0, 0, 81, 82, 7, 0, 0, 0, 82, 11, 1, 0, 0, 0, 83, 84, 7, 1, 0, 0, 84, 13, 1, 0, 0, 0, 85, 86, 7, 2, 0, 0, 86, 15, 1, 0, 0, 0, 7, 19, 26, 31, 37, 54, 65, 76]

varphi_devkit-2.0.0/src/varphi_devkit/parser/Varphi.tokens

@@ -0,0 +1,21 @@
+LPAREN=1
+RPAREN=2
+COMMA=3
+VARIABLE=4
+LEFT_KW=5
+RIGHT_KW=6
+STAY_KW=7
+BLANK_KW=8
+ALPHANUM=9
+ID=10
+COMMENT=11
+MULTI_COMMENT=12
+WS=13
+NEWLINE=14
+'('=1
+')'=2
+','=3
+'LEFT'=5
+'RIGHT'=6
+'STAY'=7
+'BLANK'=8