TatSu: PEG Parser Generator

5.18.0 · active · verified Sun Apr 12

TatSu is a Python library that takes a grammar defined in a variation of EBNF (Extended Backus–Naur Form) and generates a memoizing PEG (Parsing Expression Grammar) / Packrat parser. It is actively maintained with frequent minor releases, providing a powerful tool for creating custom parsers and Abstract Syntax Trees (ASTs). The current version is 5.18.0.

Warnings

breaking Python 3.10 and 3.11 are no longer officially supported as of v5.16.0. TatSu now requires Python >= 3.12. The GitHub README indicates a preference for Python >= 3.13.
Fix: Upgrade to Python 3.12 or newer. For older Python versions, consider using the `TatSu-LTS` fork.
breaking The `comments_re` and `eol_comments_re` attributes were removed from `ParserConfig` in v5.13.0. Use `comments` and `eol_comments` instead. Additionally, `re.MULTILINE` is no longer enabled by default for comment regexes; users must explicitly add `(?m)` if multi-line matching is needed.
Fix: Update `ParserConfig` (or grammar directives `@@comments` / `@@eol_comments`) to use `comments` and `eol_comments`. If multi-line matching is required, prepend `(?m)` to your regex pattern (e.g., `comments='(?m)/\*.*?\*/'`).
breaking The `FailedCut` exception and its associated logic were removed in v5.15.0. Code that explicitly catches or relies on this exception will break.
Fix: Remove any `try...except FailedCut` blocks. Review parsing logic that might have implicitly relied on `FailedCut` for control flow.
breaking Generated parsers from older TatSu versions (prior to v5.16.0, and especially prior to v5.0) may not be compatible with newer TatSu runtime libraries. Significant internal refactoring, particularly around `ParserConfig` and AST generation, occurred in recent major versions (e.g., v5.17.0).
Fix: It is strongly recommended to regenerate any existing parsers using the latest TatSu version to benefit from improved speed, layout, features, and ensure compatibility.
gotcha Rules and closures now return `list` objects instead of `tuple` objects in the generated AST. This changes the structural representation of the AST for rules that produce sequences or repetitions.
Fix: Adjust code that processes the AST to expect `list` instances where `tuple` was previously returned, for example, when iterating over children or checking types.

Install

pip install TatSu Install TatSu

Imports

compile
```
from tatsu import compile
```
Used to compile a grammar string into a callable parser.
parse
```
from tatsu import parse
```
Used to parse input directly with a grammar string, returning an AST.
ParserConfig
```
from tatsu.parserconfig import ParserConfig
```
For advanced configuration of the parser behavior.

Quickstart

This quickstart defines a simple calculator grammar and uses `tatsu.parse` to directly parse an input string, producing an Abstract Syntax Tree (AST). For complex parsing logic or evaluation, a custom 'semantics' class is typically passed to the parse function.

from tatsu import parse

grammar = r'''
    @@grammar::Calc
    start: expression $ ;
    expression: term (('+' | '-') term)* ;
    term: factor (('*' | '/') factor)* ;
    factor: NUMBER | '(' expression ')' ;
    NUMBER: /\d+/ ;
'''

input_text = '1 + 2 * (3 - 4)'

try:
    # Parse the input using the grammar
    ast = parse(grammar, input_text)
    print(f'Input: {input_text}')
    print(f'AST: {ast}')

    # Example with a simple calculation (requires a semantics class for evaluation)
    # For a full calculation example, typically a semantics class is used.
    # For this quickstart, we just show the parsing to AST.
except Exception as e:
    print(f'Error parsing: {e}')

view raw JSON →