Parsing expression grammar

From Wikipedia, the free encyclopedia

A parsing expression grammar, or PEG, is a type of analytic formal grammar that describes a formal language in terms of a set of rules for recognizing strings in the language. A parsing expression grammar essentially represents a recursive descent parser in a pure schematic form that expresses only syntax and is independent of the way an actual parser might be implemented or what it might be used for. Parsing expression grammars look similar to regular expressions or context-free grammars (CFG) in Backus-Naur form (BNF) notation, but have a different interpretation.

Unlike CFGs, PEGs cannot be ambiguous; if a string parses, it has exactly one valid parse tree. This suits PEGs well to parsing computer languages, but not natural languages.

Contents 1 Definition 1.1 Interpretation of parsing expressions 1.2 Examples 2 Implementing parsers from parsing expression grammars 3 Advantages 4 Disadvantages 4.1 Memory Consumption 4.2 Indirect Left Recursion 4.3 Subtle Grammatical Errors 4.4 Expressivity 4.5 Maturity 5 Implementations 6 See also 7 References 8 External links

[edit] Definition

Formally, a parsing expression grammar consists of:

• A finite set N of nonterminal symbols.
• A finite set Σ of terminal symbols that is disjoint from N.
• A finite set P of parsing rules.
• An expression e_S termed the starting expression.

Each parsing rule in P has the form A ← e, where A is a nonterminal symbol and e is a parsing expression. A parsing expression is a hierarchical expression similar to a regular expression, which is constructed in the following fashion:

1. An atomic parsing expression consists of:
   • any terminal symbol,
   • any nonterminal symbol, or
   • the empty string ε.
2. Given any existing parsing expressions e, e₁, and e₂, a new parsing expression can be constructed using the following operators:
   • Sequence: e₁ e₂
   • Ordered choice: e₁ / e₂
   • Zero-or-more: e*
   • One-or-more: e+
   • Optional: e?
   • And-predicate: &e
   • Not-predicate: !e

The fundamental difference between context-free grammars and parsing expression grammars is that the PEG's choice operator is ordered. If the first alternative succeeds, the second alternative is ignored. Thus ordered choice is not commutative, unlike textbook definitions of context-free grammars and regular expressions. Ordered choice is analogous to soft cut operators available in some logic programming languages.

The consequence is that if a CFG is transliterated directly to a PEG, any ambiguity in the former is resolved by deterministically picking one parse tree from the possible parses. By carefully choosing the order in which the grammar alternatives are specified, a programmer has a great deal of control over which parse tree is selected.

Like boolean context-free grammars, parsing expression grammars also add the and- and not- predicates. These facilitate further disambiguation, if reordering the alternatives cannot specify the exact parse tree desired.

[edit] Interpretation of parsing expressions

Each nonterminal in a parsing expression grammar essentially represents a parsing function in a recursive descent parser, and the corresponding parsing expression represents the "code" comprising the function. Each parsing function conceptually takes an input string as its argument, and yields one of the following results:

• success, in which the function may optionally move forward or "consume" one or more characters of the input string supplied to it, or
• failure, in which case no input is consumed.

A nonterminal may succeed without actually consuming any input, and this is considered an outcome distinct from failure.

An atomic parsing expression consisting of a single terminal succeeds if the first character of the input string matches that terminal, and in that case consumes the input character; otherwise the expression yields a failure result. An atomic parsing expression consisting of the empty string always trivially succeeds without consuming any input. An atomic parsing expression consisting of a nonterminal A represents a recursive call to the nonterminal-function A.

The sequence operator e₁ e₂ first invokes e₁, and if e₁ succeeds, subsequently invokes e₂ on the remainder of the input string left unconsumed by e₁, and returns the result. If either e₁ or e₂ fails, then the sequence expression e₁ e₂ fails.

The choice operator e₁ / e₂ first invokes e₁, and if e₁ succeeds, returns its result immediately. Otherwise, if e₁ fails, then the choice operator backtracks to the original input position at which it invoked e₁, but then calls e₂ instead, returning e₂'s result.

The zero-or-more, one-or-more, and optional operators consume zero or more, one or more, or zero or one consecutive repetitions of their sub-expression e, respectively. Unlike in context-free grammars and regular expressions, however, these operators always behave greedily, consuming as much input as possible and never backtracking. (Regular expressions start by matching greedily, but they backtrack and try shorter matches if they fail to match.) For example, the expression a* will always consume as many a's as are consecutively available in the input string, and the expression (a* a) will always fail because the first part (a*) will never leave any a's for the second part to match.

Finally, the and-predicate and not-predicate operators implement syntactic predicates. The expression &e invokes the sub-expression e, and then succeeds if e succeeds and fails if e fails, but in either case never consumes any input. Conversely, the expression !e succeeds if e fails and fails if e succeeds, again consuming no input in either case. Because these can use an arbitrarily complex sub-expression e to "look ahead" into the input string without actually consuming it, they provide a powerful syntactic lookahead and disambiguation facility.

[edit] Examples

This is a PEG that recognizes mathematical formulas that apply the basic four operations to non-negative integers.

Value ← [0-9]+ / '(' Expr ')'

Product ← Value (('*' / '/') Value)*

Sum ← Product (('+' / '-') Product)*

Expr ← Sum

In the above example, the terminal symbols are characters of text, represented by characters in single quotes, such as '(' and ')'. The range [0-9] is also a shortcut for ten characters, indicating any one of the digits 0 through 9. (This range syntax is the same as the syntax used by regular expressions.) The nonterminal symbols are the ones that expand to other rules: Value, Product, Sum, and Expr.

The examples below drop quotation marks in order to be easier to read. Lowercase letters are terminal symbols, while capital letters in italics are nonterminals. Actual PEG parsers would require the lowercase letters to be in quotes.

The parsing expression (a/b)* matches and consumes an arbitrary-length sequence of a's and b's. The rule S ← a S? b describes the simple context-free "matching language" . The following parsing expression grammar describes the classic non-context-free language :

S ← &(A c) a+ B !(a/b/c)

A ← a A? b

B ← b B? c

The following recursive rule matches standard C-style if/then/else statements in such a way that the optional "else" clause always binds to the innermost "if", because of the implicit prioritization of the '/' operator. (In a context-free grammar, this construct yields the classic dangling else ambiguity.)

S ← if C then S else S / if C then S

The parsing expression foo &(bar) matches and consumes the text "foo" but only if it is followed by the text "bar". The parsing expression foo !(bar) matches the text "foo" but only if it is not followed by the text "bar". The expression !(a+ b) a matches a single "a" but only if it is not the first in an arbitrarily-long sequence of a's followed by a b.

The following recursive rule matches Pascal-style nested comment syntax, (* which can (* nest *) like this *). The comment symbols appear in double quotes to distinguish them from PEG operators.

Begin ← "(*"

End ← "*)"

C ← Begin N* End

N ← C / (!Begin !End Z)

Z ← any single character

[edit] Implementing parsers from parsing expression grammars

Any parsing expression grammar can be converted directly into a recursive descent parser^{[citation needed]}. Due to the unlimited lookahead capability that the grammar formalism provides, however, the resulting parser could exhibit exponential time performance in the worst case.

By memoizing the results of intermediate parsing steps and ensuring that each parsing function is only invoked at most once at a given input position, however, it is possible to convert any parsing expression grammar into a packrat parser, which always runs in linear time at the cost of substantially greater storage space requirements.

A packrat parser^[1] is a form of parser similar to a recursive descent parser in construction, except that during the parsing process it memoizes the intermediate results of all invocations of the mutually recursive parsing functions. Because of this memoization, a packrat parser has the ability to parse many context-free grammars and any parsing expression grammar (including some that do not represent context-free languages) in linear time.

It is also possible to build LL parsers and LR parsers from parsing expression grammars, but the unlimited lookahead capability of the grammar formalism is lost in this case.

[edit] Advantages

PEGs make a good replacement for regular expressions, because they are strictly more powerful. For example, a regular expression inherently cannot find matched pairs of parentheses, because it is not recursive, but a PEG can.

Any PEG can be parsed in linear time by using a packrat parser, as described above.

Parsers for languages expressed as a CFG, such as LR parsers, require a separate tokenization step to be done first, which breaks up the input based on the location of spaces, punctuation, etc. The tokenization is necessary because of the way these parsers use lookahead to parse CFGs that meet certain requirements in linear time. PEGs do not require tokenization to be a separate step, and tokenization rules can be written in the same way as any other grammar rule.

Many CFGs contain inherent ambiguities, even when they're intended to describe unambiguous languages. The "dangling else" problem in C, C++, and Java is one example. These problems are often resolved by applying a rule outside of the grammar. In a PEG, these ambiguities never arise, because of prioritization.

[edit] Disadvantages

[edit] Memory Consumption

PEG parsing is typically carried out via packrat parsing, which uses memoization to eliminate redundant parsing steps. Packrat parsing requires storage proportional to the total input size, rather than the depth of the parse tree as with LR parsers. This is a significant difference in many domains: for example, hand-written source code has an effectively constant expression nesting depth independent of the length of the program -- expressions nested beyond a certain depth tend to get refactored.

For some grammars and some inputs, the depth of the parse tree can be proportional to the input size, so that in asymptotic the worst-case which does not distinguish these two metrics packrat parsing will appear to be no worse than an LR parser. This is similar to a situation which arises in graph algorithms: the Bellman-Ford algorithm and Floyd–Warshall algorithm appear to have the same running time (O( | V | ³)) if only the number of vertices is considered. However, a more accurate analysis which accounts for the number of edges as a separate parameter assigns the Bellman-Ford algorithm a time of O( | V | * | E | ), which is only quadratic in the size of the input (rather than cubic).

[edit] Indirect Left Recursion

PEGs cannot express left-recursive rules where a rule refers to itself without moving forward in the string. For example, in the arithmetic grammar above, it would be tempting to move some rules around so that the precedence order of products and sums could be expressed in one line:

Value   ← [0-9.]+ / '(' Expr ')'
Product ← Expr (('*' / '/') Expr)*
Sum     ← Expr (('+' / '-') Expr)*
Expr    ← Product / Sum / Value

The problem with this is that it says that to match an Expr, you need to first see if a Product matches there, and to match a Product, you need to first see if an Expr matches there. This is not possible.

However, left-recursive rules can always be rewritten to eliminate left-recursion. For example, a left-recursive rule can repeat a certain expression indefinitely, as in the CFG rule:

string-of-a ← string-of-a 'a' | 'a'

This can be rewritten in a PEG using the plus operator:

string-of-a ← 'a'+

With some modification, traditional packrat parsing can be made to support direct left recursion.^{[1] [2] [3]} However, the process of rewriting indirectly left-recursive rules is complex, especially when semantic actions are involved. Although theoretically possible no existing parser for PEGs currently supports indirect left-recursion, whereas all GLR parsers support left recursion.

[edit] Subtle Grammatical Errors

In order to express a grammar as a PEG, the grammar author must convert all instances of nondeterministic choice into prioritized choice. Unfortunately, this process is error prone, and often results in grammars which mis-parse certain inputs. An example and commentary can be found here.

[edit] Expressivity

Packrat parsers cannot parse some unambiguous grammars, such as the following (example taken from ^[4])

S ← 'x' S 'x' | 'x'

[edit] Maturity

PEGs are new and not widely implemented. In contrast, regular expressions and CFGs have been around for decades, the code to parse them has been extensively optimized, and many programmers are familiar with how to use them.

[edit] Implementations

• LPeg for Lua
• ppeg for Python (a port of LPeg)
• pyPEG for Python
• Kouprey for JavaScript
• Boost::Spirit V2 for C++
• Treetop for Ruby
• Perl6 native functionality
• pyparsing PEG parsing library in Python
• pijnu text parsing & processing tool in Python, based on PEG
• Neotoma for Erlang
• clj-peg for Clojure

[edit] See also

• Formal grammar
• Regular expressions
• Top-down parsing language
• Comparison of parser generators
• Parser combinators

[edit] References

1. ^ ^{a b} Ford, Bryan (September 2002). "Packrat Parsing: a Practical Linear-Time Algorithm with Backtracking". Massachusetts Institute of Technology. http://pdos.csail.mit.edu/~baford/packrat/thesis. Retrieved on 2007-07-27. 
2. ^ Alessandro Warth, James R. Douglass, Todd Millstein (January 2008) (PDF). Packrat Parsers Can Support Left Recursion. Viewpoints Research Institute. http://www.vpri.org/pdf/tr2007002_packrat.pdf. Retrieved on 2008-10-02. 
3. ^ Ruedi Steinmann (March 2009) (PDF). Handling Left Recursion in Packrat Parsers. http://n.ethz.ch/~ruediste/packrat.pdf. 
4. ^ Bryan Ford (2002) (PDF). Functional Pearl: Packrat Parsing: Simple, Powerful, Lazy, Linear Time. http://pdos.csail.mit.edu/~baford/packrat/icfp02/packrat-icfp02.pdf. 

• Medeiros, Sérgio; Ierusalimschy, Roberto (2008). "A parsing machine for PEGs". Proc. of the 2008 symposium on Dynamic languages: article #2, ACM. doi:10.1145/1408681.1408683. ISBN 978-1-60558-270-2. 

[edit] External links

• Parsing Expression Grammars: A Recognition-Based Syntactic Foundation (PDF slides)
• The Packrat Parsing and Parsing Expression Grammars Page
• Packrat Parsing: a Practical Linear-Time Algorithm with Backtracking
• The constructed language Lojban has a fairly large PEG grammar allowing unambiguous parsing of Lojban text.
• The Aurochs parser generator has an on-line parsing demo that displays the parse tree for any given grammar and input
• REBOL parse dialect is PEG-compatible
• Treetop is a PEG implemented in, and which generates Ruby code.