LR Parsing

This last topic of the semester was devoted to pointing out one other major trend in compiling, so that you won't be caught by surprise if asked about it or if you read about it:  bottom up parsing (also known as LR parsing):

• LR grammars capture all of the deterministic grammars (grammars that can be parsed without the need to resort to backtracking, that is, backing up to try other rules when one rule fails.
• LR grammars are "stronger" than LL grammars in that every LL grammar is also an LR grammar, but not every LR grammar is an LL grammar.
• LR grammars are more natural, because they allow left recursion and therefore do not need to resort to the odd rules found in LL grammars that include something like <expression_tail> as a nonterminal.

The major difference between the parsing techniques between LL and LR grammars is that LR grammars must be used for bottom up parsing whereas LL grammars are used for top-down parsing.

• At any point in the parse, the parser looks for a right hand side of a rule in the grammar among the symbols that have evolved from the parse so far.
• There might be many right hand sides of rules among these symbols.
• Given one token of lookahead, an LR parser must be able to determine which of these right hand sides is the right one (none of them may be).
• The action of the LR parser is to (1) reduce the symbols in a right hand side of a rule to its left hand side if that's the right thing to do, or (2) shift the lookahead token onto the list (stack) of symbols being considered as right hand sides and make the next token the lookahead token.
• When all right hand sides have been reduced, the result is <system_goal>

How does this change the compiler?  The only thing different is the parser portion, because LL and LR are parsing techniques.  The scanner remains the same, and the semantic analyzer remains largely the same.  If the same grammars are used for both LL and LR parsing, the same parse tree will result from either parser given the same input string.

A final note is that LR parsing is so detailed and complex to manage that it virtually cannot be done by hand.  Instead, parser tools, such as yacc, bison, and occs are used to generate LR parsers.

An Example

Grammar 2

1.  <expression> --> <expression> + <term>
2.  <expression> --> <expression> - <term>
3.  <expression> --> <term>
4.  <term> --> <term> * <factor>
5.  <term> --> <term> / <factor>
6.  <term> --> <factor>
7.  <factor> --> <factor> ^ <primary>
8.  <factor> --> <primary>
9.  <primary> --> identifier
10. <primary> --> integer_literal
11. <primary> --> ( <expression> )

This grammar is LR(1).  That is, strings in the language of this grammar can be parsed bottom up using one token of lookahead with no backtracking.  Try parsing the string 3 + a * b.