Introduction
Parsers, Interpreters and Compilers are becoming more and more into the reach of the normal programmer. In the very beginning, such tools were hand crafted. Then came the time of the parser and compiler generators (e.g., YACC (popular UNIX parser generator) or ANTLR), and currently we experience the integration of grammars and parsers directly into a host language. boost::spirit
, for example, is integrated into C++ as a library which comes with a domain specific sublanguage (using operator overloading and expression templates). Perl 6 goes even a step further and makes grammars part of the language. These tools help you very much but they still require quite a lot of knowledge about the underlying theoretical framework.
This is the first part of a series of articles which explains the most basic concepts and practices to cope with parsing and compiling. It uses toy programming languages and their interpreters to expose the concepts. For each toy language, sample programs are presented. These samples are handwritten, but in a style which shows how the task could be automated. This introduction into language processing addresses newbies as well as more experienced programmers. The former get enough explanatory text, the latter C++ code samples which show how language processing can be done with minimal baggage. The whole article series strives for minimality both in theory and in implementation.
Steps for building an interpreter
Let's take a command line calculator for arithmetic formulas as an introductory example. The following excerpt shows a sample session, where lines starting with '>>' indicate program output.
Pi=3.1415926535
>> Pi= 3.1415926535
Area=Pi*r^2
>> Area= 0
r=3
>> Area= 28.2743338815
>> r= 3
To implement this, the calculator program must accomplish the following tasks:
Task 
Sketch of Solution 
It must recognize the structure and the components of the input line which consists of arithmetical expressions, assignments and formula names. Errors must be reported in a user friendly, informative way. 
This is done by a process called parsing. The effort done for parsing pays off in the quality of the error messages for syntax errors and in the error recovery. A poorly designed parser will produce follow errors after the first error or will not be able to continue parsing at all after the first error. 
It must evaluate the arithmetic formula and store the result in a map which associates the formula name with the value of the expression. Furthermore, it must store the formula expression itself in order to recalculate the formula when a component changes its value by another evaluation. 
Evaluation of an expression or statement to a result value can only be done after successful parsing. Evaluation may either be executed directly during parsing or it may be deferred until the parsing process has constructed an appropriate intermediate "database" and finally has generated efficient "code" for the execution by a real or virtual processor. 
It must cope with runtime errors like divide by zero or taking the root of a negative number. 
Handling of runtime errors is done by the runtime system. The amount of runtime error handling is a tradeoff between efficiency and convenience and must be adapted to the expectations of the target user group. 
Parsing and Grammars
Parsing is the process of associating a hierarchical structure with a source text. A programmer, who indents her source text appropriately (e.g., she indents the body of loops), does a simple form of parsing. Parsing is the first task in language processing and one of the most important ones, because it guides all the later steps of a translation system. The formal framework for parsing is set by a grammar which describes the source language. A grammar consists of a set of rules, which taken together associates a unique tree structure with any correct input text. Grammars are divided into different classes according to their expressiveness. On the lowest level are grammars for regular expressions. These grammars cannot describe recursively nested constructs as they are needed to express, for example, the fact that a statement has other statements as its components. The grammar class commonly used to describe programming languages is called "context free". Each rule of a context free grammar has the form R: a b c  d ;
where R
is the name of the rule (also called a Nonterminal), :
separates the rule name from the right hand side of the rule and where a b c d
and so on are either terminals or names of further rules (Nonterminals), and 
is used to separate alternatives. This is further explained in the following table:
Notion 
Samples 
Meaning 
Terminal 
'for' [azAZ][09]+; 
Describes a string of the input directly. It is common practice to use a subset of the notation which is used in regular expressions for describing terminals. The only difference is the notation for strings. In context free grammars, we write e.g., 'for', where we would write just for in a regular expression. 
Quantifiers 
? * + 
Same meaning as in regular expressions. These three quantifiers are sufficient. 
Alternative 
 
Same meaning as in regular expressions. 
Grouping 
( ... ) 
Same meaning as in regular expressions. 
Nonterminal Rule 
EnclosedDigits: [09]+  '(' EnclosedDigits ')' ; 
EnclosedDigits in the sample is a Nonterminal. In this sample, it is both the name of a rule and used on the right hand side of the rule. For each Nonterminal used somewhere in a grammar rule, there must be exactly one corresponding rule. 
The following sample context free grammar rule describes a string of digits enclosed in an arbitrary number of parentheses:
EnclosedDigits: [09]+  '(' EnclosedDigits ')' ;
This grammar rule associates the input string ((123)))
with the following parse tree:
EnclosedDigits
'(' EnclosedDigits ')'
'(' EnclosedDigits ')'
'123'
In the coming samples, we will use the following linear form as a tree notation:
EnclosedDigits< '(' EnclosedDigits< '(' EnclosedDigits<123> ')' > ')' >
Interestingly, the rule EnclosedDigits:
matches the complete input string ((123))
from the first to the last character, and it also matches inner parts like (123)
and 123
. This is possible because of the recursive nature of context free grammars. When a grammar is used to recognize an input string, we say that we use the grammar for parsing. A grammar can also be used to generate strings of the language by a process called substitution. Substitution takes place on the right hand side of the so called start rule. Substitution means replacing a Nonterminal by one of the alternatives on the right side of the rule for the replaced Nonterminal. By repeated substitutions on the right hand side of the start rule, we can generate all input strings which belong to the language described by the grammar. This shall be shown with the following sample start rule:
Expression: Expression '+' Expression  '(' Expression ')'  [09]+ ;
The following table shows one possible substitution history:
Before Substitution 
Step Description 
After Substitution 
Parse Tree 
Expression 
Substitute by first alternative of Expression rule 
Expression
'+'
Expression 
Expression<
Expression
'+'
Expression
> 
Expression
'+'
Expression 
Substitute marked Nonterminal by second alternative of Expression rule 
Expression
'+'
'(' Expression ')' 
Expression<
Expression
'+'
Expression<
'(' Expression ')'
>
> 
Expression
'+'
'(' Expression ')' 
Substitute marked Nonterminal by '1001' (using [09]+ alternative) 
'1001'
'+'
'(' Expression ')'

Expression<
Expression<'1001'>
'+'
Expression<
'(' Expression ')'
>
> 
'1001'
'+'
'(' Expression ')' 
Replace marked Nonterminal by '37' (using [09]+ alternative) 
'1001'
'+'
'(' '37' ')'

Expression<
Expression<'1001'>
'+'
Expression<
'('
Expression<'37'>
')'
>
> 
The resulting generated language string is 1001+(37)
. Note that the order of substitutions  whether you first substitute a Nonterminal occurring on the very right side or on the left side  is not specified by a context free grammar. A parser therefore needs not only a context free grammar to do its job, it needs also a parsing strategy, which is nothing else than a builtin rule telling which of the possible substitutions is carried out first. Common parsing strategies are LL and LR. Both parser types read the input from left to right, which is the reason for the first L in LL and LR. An LL parser always substitutes the leftmost Nonterminal first, whereas an LR parser substitutes the rightmost Nonterminal first. Typically, LL and LR parsers do not accept the same grammar rules. An LL parser is not happy with left recursive rules whereas an LR parser is not happy with right recursive rules, this is exemplified by the following sample grammar rule:
Parsing Strategy 
Grammar 
Comment 
LL 
Digits: [09] Digits? ; 
Match first a terminal, then recurse. 
LR 
Digits: Digits? [09] ; 
Recurse, then match terminal. 
The LR  grammar Digits: Digits? [09]
is left recursive, because its right hand side has the rule name as its first symbol. Fortunately, it is not difficult to rewrite an LR grammar into an LL grammar and vice versa, as we will see later.
Expressiveness of Context Free Grammars
Many import properties of existing programming languages can either not be expressed with a context free grammar or are tedious to describe. Consider a language with procedures where the procedure name must both occur at the beginning and at the end:
Proc: 'proc' Name Parameters Body Name ';' ;
There is no way to describe that the Name at the beginning must be the same as the Name at the end. Take as another example a length limitation, e.g., the rule that an identifier cannot exceed 32 characters. While it is possible to describe this with a context free grammar rule, it either requires a lot of writing or the addition of a new quantifier (e.g.: [azAZ]{1,32}). It turns out in many cases that it is preferable to check for the violation of a restriction after successful parsing rather than trying to express the restriction within the grammar. Generally speaking, a grammar for a programming language accepts always a superset of the legal constructs. The real strength of context free grammars is the proper description of hierarchical relations as shown by the following examples of grammars for simple arithmetic expressions. This is a poorly chosen grammar for expressions:
expr0: expr0 ('+''') expr0  expr0 ('*''/') expr0  [09]+ ;
This grammar does not express the fact that the precedence of '+' is not the same as that of '*'. The following is a much better grammar for expressions:
expr1: mul_expr  expr1 ('+''') mul_expr ;
mul_expr: [09]+  mul_expr ('*''/') [09]+ ;
The source text 2*3+5
could be parsed by expr0
into the following tree:
expr0<
expr0<'2'>
'*'
expr0< expr0<'3'> '+' expr0<'5'> >
>
whereas expr1
would result in this tree:
expr1<
expr1<mul_expr<'2'> '*' '3' >
'+'
mul_expr<'5'>
>
Only the second tree reflects the precedence of the '+' and '*' operators. By the way, the grammar rule for expr1
is suitable for an LR parser, but not for an LL parser.
The Peril of Ambiguity
A grammar is ambiguous if a source text can be parsed into two different parse trees depending on the order of substitutions. The above sample expr0: expr0 ('+''') expr0  expr0 ('*''/') expr0  [09]+ ;
is ambiguous because the source text 2*3+5
can be parsed into both of the following trees:
expr0<expr0<'2'> '*' expr0< expr0<'3'> '+' expr0<'5'> > >
expr0<expr0<expr0<'2'> '*' expr0<'3'> > '+' expr0<'5'> >
depending on the substitution order. Ambiguity defeats the main purpose of grammars, namely the association of a source text with a unique hierarchical structure. Whether ambiguity of a grammar really results in different hierarchical structures not only depends on the grammar but also on the parsing strategy.
Recursive Descent Parsing
Recursive descent parsing is the most simple and intuitive parsing method. It is an LL parsing method and therefore reads the input from left to right (the first L in LL) and traverses the grammar from left to right (the second L in LL). The name recursive descent is due to the fact that this parsing method uses a function for every grammar rule. The function for the start rule must parse the complete source. It does this by providing a function body, which implements the right hand side of the start rule in the following way:
 in case of alternatives, it tries all the promising alternatives by executing the corresponding code for the alternative until one of them succeeds (matches the input text)
 in case of a sequence of grammar symbols (tokens or Nonterminals), it executes the corresponding code for each symbol in the sequence until one of them fails or otherwise the code for the whole sequence succeeds.
Note that the implementation of a recursive descent parser sometimes requires backtracking. Backtracking means that you go back to a previous state of the computation. If, for example, the first part of the chosen alternative is successfully matched against the input text and then a mismatch occurs, we must set back the source position to the position before we entered the alternative and choose another alternative. Let's show this with a sample implementation. The rules:
EnclosedDigits: Digits  '(' EnclosedDigits ')' ;
Digits: [09] Digits? ;
could be implemented by the following parsing procedures which merely test whether the input matches the grammar rules:
typedef const unsigned char* Iterator;
bool MatchesDigits(Iterator& it) {
return (*it>='0' && *it<='9'?(++it,true):false) && (MatchesDigits(it),true); }
bool MatchesEnclosedDigits(Iterator& it) {
Iterator itSave= it;
return
MatchesDigits(it)  ( (itSave=it,
(*it=='('?(++it,true):false) && MatchesEnclosedDigits(it) && (*it==')'?(++it,true):false) )
(it=itSave,false)
);
}
The start grammar function MatchesEnclosedDigits
takes an iterator (e.g., character pointer) as input and either returns true
, in which case it sets the iterator to the position just behind the recognized text, or it returns false
, in which case it leaves the iterator unchanged. The close relationship between grammar rules and corresponding parsing functions make it obvious that a recursive descent parser cannot work with grammar rules like:
Digits: Digits? [09] ;
because this would result in infinite recursion. Many grammars coming with language specifications are written for LR parsers (the well known YACC tool requires an LR grammar). But it is quite easy to rewrite an LR grammar into an LL grammar.
Parsing Expression Grammars (PEGs)
The idea behind the so called parsing expression grammar (PEG) formalism [1] is a "procedural interpretation" of context free grammars. A PEG grammar can be "executed" using the grammar and a source string as input. The result of the execution is either a match of the input string, in which case the parsing position is at the end of the recognized part, or otherwise the result is "doesn't match", in which case the input position remains unchanged. This statement is not only true for the grammar as a whole, but for each grammar rule. The PEG formalism is nothing else than a mapping of common practices in recursive descent parsing to grammars. It consists of the following grammar elements:
PEG construct 
Notation 
Operational Meaning 
Sequence 
e_{1} e_{2} 
Match input against e_{1} moving the input position behind the input part described by e_{1}, then match from new input position against e_{2}. If the match fails for either e_{1} or e_{2}, the input position is restored to the position before entering the Sequence and the result is fail, otherwise the input position is moved behind the recognized Sequence and the result is success. 
Prioritized choice between Alternatives 
e_{1} / e_{2} 
Match input against e_{1} moving the input position behind the input part described by e_{1}. If the match fails, restore the input position and match against e_{2}. If the match fails again, restore to the position before entering the Alternative and the result is fail. Otherwise, if one of the alternatives succeeds, the input position is moved behind the source part which is recognized by the chosen alternative and the result is success. 
Greedy Option 
e? 
Match input against e, moving the input position behind the recognized part in case of success. If the match fails, restore the input position, but the result is in any case success. 
Greedy zero or more occurrences 
e* 
Interpret it like an unlimited number of e? e? e? e? ... 
Greedy one or more occurrences 
e+ 
Interpret it like e e? e? e? ... 
Peek predicate 
&e 
Match the input against e without changing the input position (the input position remains the same whether the match succeeds or fails). The result is success if it matches, otherwise it is fail. 
Not predicate 
!e 
Match the input against e without changing the input position (the input position remains the same whether the match succeeds or fails). The result is fail if it matches, otherwise it is success. 
Advance predicate 
. 
Increase the input position by one. The result is success. 
The following table shows the effect of PEG grammar constructs on sample input strings. The 
character indicates the input position:
PEG construct 
Input 
Match Position 
Match Result 
S: 'for' ; 
for 
for 
true 
S: 'for' ; 
former 
former 
true 
S: 'for' ; 
afor 
afor 
false 
S: 'for' 'all' ; 
forall men 
forall men 
true 
S: 'former' / 'for' ; 
for 
for 
true 
S: 'former' / 'for' ; 
former 
former 
true 
S: 'for' / 'former' ; 
for 
for 
true 
S: 'for' / 'former' ; 
former 
former 
true 
S: 'for'?'mer' ; 
former 
former 
true 
S: 'for'?'mer' ; 
mer 
mer 
true 
S: 'for'?'former' ; 
former 
former 
false 
S: [09]* ; 
1903.535 
1903.535 
true 
S: [az .]+'.*'? ; 
ifi.go.* 
ifi.go.* 
true 
S: 'for' &'(' ; 
for( 
for( 
true 
S: 'for' &'(' ; 
for[ 
for[ 
false 
S: 'for' !'(' ; 
for[ 
for[ 
true 
S: 'for' !'(' ; 
for( 
for( 
false 
PEG versus regular expressions
Since PEGs cover context free grammars, they are more powerful than regular expressions. The most important difference between Parsing Expression Grammars and regular expressions is the fact that the former supports recursive definitions, the latter not. But simple non recursive situations often require shorter regular expression patterns as can be shown for an email address recognizer.
Regular expression as email address recognizer:
[AZaz09._%]+@[AZaz09._%]+\.[AZaz]{2,4}
Incorrect PEG rule as email address recognizer:
EMail: [AZaz09._%]+'@'[AZaz09._%]+'.'[AZaz]{2,4} ;
Correct PEG rules as email address recognizer:
EMailChar: [AZaz09._%];
EMailSuffix: [AZaz]{2,4} !EMailChar ;
EMail: EMailChar+
'@'
([AZaz09_%] '.'!EMailSuffix)+
'.'
EmailSuffix ;
The correct PEG email address recognizer is more complicated than the regular expression email address recognizer and uses implicit backtracking (in !EMailSuffix
). When we parse the legal email address marc.bloom@blo.blo.uk with the PEG rule EMail: [AZaz09._%]+'@'[AZaz09._%]+'.'[AZaz]{2,4} ;
, we will fail, because blo.blo.uk will be recognized by the greedy rule component [AZaz09._%]+
, so that there will be no input character left for '.'[AZaz]{2,4}
. The regular expression pattern does not have this problem, because the input string blo.blo.uk will be wisely shared between the two parts of the regular expression [AZaz09._%]+\.[AZaz]{2,4}
. Fortunately, it turns out that such intricate backtracking (as used in the correct PEG rule) is seldom necessary for parsing.
Procedural and template implementations of PEG elements
An ideal C/C++ PEG implementation is both close to a PEG grammar and runtime efficient. This can be achieved both with normal "C" code as well as with C++ templates. C++ templates prove to be more flexible, whereas normal Ccode has the advantage of making less trouble in case of programmer errors, because error messages for templates are still difficult to decode. The rule S: 'C' ;
has the following procedural implementation:
typedef const unsigned char* Iterator;
inline bool Char(Iterator& p,int c) { return *p==c?(++p,true) : false;}
bool S(Iterator& it){return Char(it,'C');}
and the following template implementation:
template<int CHARVALUE>
struct Char{
template<typename It>
static bool Matches(It& p) { return *p==CHARVALUE?(++p,true):false;}
};
struct S{
typedef Char<'C'> rule;
template<typename It>
static bool Matches(It& p) { return rule::Matches(p); }
};
The following table sketches the procedural and template implementations of all the PEG constructs:
PEG notation 
procedural implementation 
template implementation 
[azAZ09] 
In ( p, 'a', 'z',
'A', 'Z', '0', '9' ) 
In<'a', 'z', 'A', 'Z',
'0', '9'>::Matches(p) 
[:;/] 
OneOfChars ( p, ':', ';', '/' ) 
OneOfChars<':', ';',
'/'>::Matches(p) 
'for' 
String ( p,'f','o','r' ) 
String<'f', 'o',
'r'>::Matches(p) 
e_{1} e_{2} 
( pSave=p, e1(p) && e1(p) )
( p=pSave, false ) 
And<e1,e2>::Matches(p) 
e_{1} / e_{2} 
( pSave=p, e1(p))
 ( p=pSave, e2(p) )
 ( p=pSave, false ) 
Or<e1,e2>::Matches(p) 
e? 
e ( p ) ; return true; 
Option<e>::Matches(p) 
e* 
while ( e(p) ) {} return true; 
OptRepeat<e>::Matches(p) 
e+ 
if ( !e(p) ) {return false;}
while ( e(p) ) {} return true; 
PlusRepeat<e>::Matches(p) 
e{LOW,HIGH} 
pSave=p; int i;
for ( i=0; i<=HIGH; i++ ) {
if ( !e(p) ) { break; }
}
return i>=LOW ? true:
( p=pSave,false ); 
For<LOW,HIGH>::Matches(p) 
&e 
( pSave=p, e(p) )
?( p=pSave,true ):
( p=pSave, false ) 
Peek<e>::Matches(p) 
!e 
( pSave=p, e(p) )
? ( p=pSave,false ) :
( p=pSave,true ) 
Not<e>::Matches(p) 
. 
++p 
Advance<1>::Matches(p) 
Note, that the constructs .
and e{LOW,HIGH}
are not part of the originally proposed PEG elements, but are added by me. Applied to the email PEG recognizer rules, we get the following template implementation:
bool MatchesEMail(openend_iterator& it)
{
using namespace peg_templ;
C c;
typedef In<'A','Z','a','z'> Alpha;
typedef In<'A','Z','a','z','0','9'> Alnum;
typedef Or<Alnum,OneOfChars<'.','_','%',''> > EMailChar;
typedef And<For<2,4,Alpha >,Not<EMailChar > > EMailSuffix;
typedef And<
PlusRepeat<EMailChar>,
Char<'@'>,
PlusRepeat<Or< Or<Alnum,OneOfChars<'_','%',''> >,
And<Char<'.'>,Not<EMailSuffix> >
>
>,
Char<'.'>,
EMailSuffix
> EMail;
return EMail::Matches(it,&c);
}
Note that EMail::Matches(it,&c)
has two parameters (contrary to the table above). The first is an iterator, the second a pointer to the parsing context. This parsing context is necessary, if one wants to carry out some action during parsing.
Input Iterators
The parser reads the source for parsing. Storage medium, encoding, and end of input indicators can be different for various sources. In most cases, the storage medium is a file or a character string. The character encoding is either ASCII, UTF8 or one of the many other Unicode encodings. The end of input can be detected either by the presence of a special terminator or by comparison against an end of input pointer.
Checking each input position against the end of input is in most cases not necessary. Most grammars expect only a subset of the possible input characters. If we know that the input is terminated by a special character, say '\0', we can use a start rule like: S: TopRule '\0';
.
If we use a template parameter Iterator
, we can cope with all the mentioned possibilities by providing a sensible iterator implementation. Our PEG implementation uses only the following iterator operations:
PEG iterator operation 
Meaning 
int iterator::operator*()const 
Returns the current character value. In case of an iterator for an input range, it returns a negative value when at the end of range. 
iterator& iterator::operator++() 
Increments the input position. In case of an iterator for an input range, it does not increment the input position when at the end of the input range. 
The following table shows two sample models for input iterators:
container/iterator characterization 
iterator implementation 
character buffer with special termination character (e.g.: '\0'). 
typedef const unsigned
char* peg_openend_iterator; 
character buffer with end of input pointer. 
struct peg_begend_iterator{
peg_begend_iterator(const
char* p=0,const char* pEnd=0)
:m_p((const unsigned char*)p),
m_pEnd((const unsigned
char*)pEnd){}
int operator*()const{
return m_p==m_pEnd?
(INT_MIN+1):*m_p;
}
peg_begend_iterator&
operator++(){
if(m_p<m_pEnd)++m_p;
return *this;
}
unsigned const char* m_p;
unsigned const char* m_pEnd;
}; 
Why performance matters
The parser of a C++ compiler spends less then 20% of the compilation time with parsing. But there are many applications for parsing without sophisticated postprocessing where speed really matters. Examples are autocompletion support for development environments, preprocessing of C/C++ source files, extraction of items from large XML files.
There are two main sources of inefficiencies in parsing:
 backtracking
 runtime costs of unnecessary abstractions
In recursive descent parsing, backtracking can be avoided by rewriting the grammar in a way that avoids alternatives with the same beginning. This technique is known as left factorization and will be shown in one of the next articles of this series. In LR parsing (LALR parsing to be precise) as used by YACC (the UNIX parser generator), backtracking is avoided by the internal use of a stack for symbols which wait for further processing. It is well known that hand written recursive descent parsers using optimized grammars and tools like YACC are the best performers. But for the casual user, handwritten parsers as well as compiler generation tools are not ideal, the former because they require too much work, the latter, because they generate in most cases impenetrable and hard to maintain code. With Parsing Expression Grammars, the picture could change, because PEGs combine the easy to understand recursive descent technique with the possibility of an efficient implementation which is very close to the original grammar. I therefore compared the runtime efficiency of three PEG implementations and of a handoptimized parser. I took a grammar for arithmetical expressions as a test case, because such a grammar can be written in a way which requires no backtracking. All the tested parsers had to parse the expression 132*( firstOccurance + x2*( 1001/N55 )+19 )
, which was repeated until it filled a buffer of 1000000 characters. The following table gives the results.
Implementation technique 
CPU usage VC++ 7.0 
CPU usage GCC 3.3.1 
procedural PEG implementation 
0.17 seconds 
0.03 seconds 
templated PEG implementation 
0.211 seconds 
0.041 seconds 
begEnd templated PEG implementation 
0.32 seconds 
0.09 seconds 
hand optimized PEG implementation 
0.06 seconds 
0.03 seconds 
The results show that the templated and procedural PEG implementations come very close to the handoptimized parser. They also show that using an iterator which always checks for the end of input condition has its price.
Points of interest
The term Parsing Expression Grammars was coined by Bryan Ford [1]. He also pointed out that this kind of recursive descent parsing with backtracking is common practice. He showed that only very few rules are needed to define a powerful framework for parsing. Instead of relying on grammar transformations which eliminate alternatives having the same beginning (so called left factorization), he invented a parser, which memorizes already taken paths and achieves linear parsing time for any PEG grammar (the packrat parser).
An important advantage of PEGs comes from the fact that a separate scanner is not necessary. When parsing with a scanner, one divides the parsing task in a low level part called scanning, and in a high level part, proper parsing. A scanner typically skips white space and comments and reads items like numbers, operators and identifiers, and returns an integer value to indicate what it has found. A scanner reduces the necessity to backtrack in some cases. On the other hand, it introduces a new level of abstraction which was never necessary from a theoretical point of view, and it can cause problems because of the lack of context information. A typical example is the closing angle bracket of template instantiations (the >
symbol). You get a compiler error if you close two template instantiations at once using >>
(one must use > >
instead), because the scanner recognizes >>
as a shift operator, a problem which does not arise if you do not use a scanner. Interestingly, Christoper Diggins [2], who presented his YARD parser on this site, does not mention the work of Bryan Ford, but uses exactly the PEG ideas including scannerless parsing. This is certainly due to the fact that these ideas lie in the air.
History
 2005 April: initial version.
 2005 April: corrections to chapter PEG versus regular expressions (thanks to Gary Feldman).
References
 Parsing Expression Grammars, Bryan Ford, MIT, January 2004 [^]
 A Regular Expression Tokenizer using the YARD Parser, Christopher Diggins, December 2004 [^]