Lecture 7 BottomUp Parsing II Joey Paquet 2000

Lecture 7 Bottom-Up Parsing II Joey Paquet, 2000, 2002, 2008, 2012 1

Part I Canonical LR and LALR Parsing Tables Joey Paquet, 2000, 2002, 2008, 2012 2

Problems with SLR Parsers • The SLR parser breaks down when – Shift-reduce conflict: it cannot decide whether to shift or reduce S if E then S | if E then S else S – Reduce-reduce conflict: A given configuration implies more than one Z S S E=E possible reduction, e. g. S id State 3 : S id FOLLOW(S) = {$} E E + id V[id] E id FOLLOW(E) = {$, +, =} E id Joey Paquet, 2000, 2002, 2008, 2012 3

Canonical LR Parsers • Problem: the FOLLOW set is not discriminating enough • For example, the previous example problem is not without solution: – if the next token is either + or =, reduce id to E – if the next token is $, reduce id to S • Solution: use lookahead (FIRST) sets in the items generation process to eliminate ambiguities Joey Paquet, 2000, 2002, 2008, 2012 4

Canonical LR Parsers State 0 : V[ ] State 1 : V[S] State 2 : V[E] State 3 : V[id] State 4 : V[E=] [Z S: {$}] [S id: {$}] [S E=E: {$}] [E E+id: {=}] [E E+id: {+}] [E id: {+}] [Z S : {$}] : [Z S: {$}] [S E=E: {$}] [E E+id: {=, +}] [E id]: {=, +}] [S id: {$}] : V[S] : V[E] : V[id] State 1 State 2 State 3 : [Z S : {$}] : accept Final State [S E = E: {$}] [E E +id: {=, +}] [E id ]: {=, +}] [S id : {$}] [S E= E: {$}] [E E+id: {+}] [E id: {+}] : [S E =E: {$}] [E E +id: {=, +}] : [E id : {=, +}] [S id : {$}] : [S E= E: {$}] [E E+id: {+, $}] [E id: {+, $}] : V[E=] : V[E+] : : : V[E=E] : V[E=id] State 4 State 5 handle (r 4) handle (r 2) State 6 State 7 Joey Paquet, 2000, 2002, 2008, 2012 5

Canonical LR Parsers State 5 : [E E+ id: {=, +}] V[E+] State 6 : [S E=E : {$}] V[E=E] [E E +id: {+, $}] State 7 : [E id : {+, $}] V[E=id] State 8 : [E E+id : {=, +}] V[E+id] State 9 : [E E+ id: {+, $}] V[E=E+] State 10 : [E E+id : {+, $}] V[E=E+id] : [E E+ id: {=, +}] : V[E+id] State 8 : [S E=E : {$}] : [E E +id: {+, $}] : V[E=E+] : [E id : {+, $}] : handle (r 1) State 9 handle (r 4) : [E E+id : {=, +}] : handle (r 3) : [E E+ id: {+, $}] : V[E=E+id] State 10 : [E E+id : {+, $}] : handle (r 3) Joey Paquet, 2000, 2002, 2008, 2012 6

CLR Parsing Table state 0 action id = + goto $ s 3 1 s 4 s 5 3 r 4 4 s 7 5 s 8 1 2 r 2 s 9 r 1 7 r 4 8 Z S 1 S E=E 2 S id 3 E E + id 4 E id 6 6 10 E acc 2 9 S 0 r 3 s 10 r 3 Joey Paquet, 2000, 2002, 2008, 2012 7

LALR • Problem: CLR generates more states than SLR, e. g. for a typical programming language, the SLR table has hundreds of states whereas a CLR table has thousands of states • Solution: merge similar states Joey Paquet, 2000, 2002, 2008, 2012 8

LALR State 0: {[Z S: {$}], [S id: {$}], [S E=E: {$}], [E E+id: {=, +}], [E id]: {=, +}]} State 1: {[Z S : {$}]} State 2: {[S E =E: {$}], [E E +id: {=, +}]} State 3: {[E id : {=, +}], [S id : {$}]} State 4: {[S E= E: {$}], [E E+id: {+, $}], [E id: {+, $}]} State 5: {[E E+ id: {=, +, $}]} State 6: {[S E=E : {$}], [E E +id: {+, $}]} State 7: {[E id : {+, $}]} State 8: {[E E+id : {=, +, $}]} Joey Paquet, 2000, 2002, 2008, 2012 10

LALR Parsing Table action stat e id 0 s 3 = + 1 goto $ E 1 2 acc 2 s 4 s 5 3 r 4 4 s 7 5 s 8 r 2 Z S 2 S E=E 3 S id 4 E E + id 5 E id 6 6 s 5 r 1 7 r 4 r 3 8 S 1 r 3 Joey Paquet, 2000, 2002, 2008, 2012 11

Part II Error Recovery in LR Parsing Joey Paquet, 2000, 2002, 2008, 2012 12

Error Recovery in LR Parsers • An error is detected when the parser consults the action table and finds an empty entry • Each empty entry potentially represents a different and specific syntax error • If we come onto an empty entry on the goto table, it means that there is an error in the table itself Joey Paquet, 2000, 2002, 2008, 2012 13

Error Recovery in LR Parsers on. Error() 1. pop() until a state s is on top and s has at least one entry in the goto table under non-terminal N 2. S is the set of states in the goto table for s 3. T is the set of terminals for which the elements of S have a shift or accept entry in the action table 4. lookahead = next. Token() until lookahead x is in T 5. push the N corresponding to x and its corresponding state in S 6. resume parse • Example: in many PLs, statements end with a “; ” – if an error is found, the stack is popped until we get V[<statement>] on top – next. Token() until the next “; ” is found – resume parse Joey Paquet, 2000, 2002, 2008, 2012 14

Error Recovery in LR Parsers state action goto 1 E E+T 2 E T id + * ( ) $ E T F 0 s 5 e 1 s 4 e 1 e 0 1 2 3 1 e 2 s 6 ee e 2 e 3 acc 3 T T*F 2 e 2 r 2 s 7 e 2 r 2 4 T F 3 e 2 r 4 r 4 5 F (E) 4 s 5 e 1 s 4 e 1 e 0 5 e 2 r 6 r 6 6 F id 6 s 5 e 4 s 4 e 0 7 s 5 e 5 s 4 e 5 e 0 8 e 2 r 1 s 7 e 2 s 11 e 0 9 e 2 r 1 s 7 e 2 r 1 10 e 2 r 3 r 3 11 e 2 r 5 r 5 8 2 3 9 3 10 Joey Paquet, 2000, 2002, 2008, 2012 15

Error Recovery in LR Parsers stack input action e 0 unexpected end of program 1 0 id)id*id)$ shift 5 e 1 missing operand 2 0 id 5 )id*id)$ reduce (F id) e 2 missing operator 3 0 F 3 )id*id)$ reduce (T F) e 3 mismatched parenthesis 4 0 T 2 )id*id)$ reduce (E T) e 4 missing term 5 0 E 1 )id*id)$ e 3 e 5 factor expected 6 0 T 2 *id)$ shift 7 e 6 + or ) expected 7 0 T 2*7 id)$ shift 5 ee parser error 8 0 T 2*7 id 5 )$ reduce (F id) 9 0 T 2*7 F 10 )$ reduce (T T * F) 1 E E+T 10 0 T 2 )$ reduce (E T) 2 E T 11 0 E 1 )$ e 3 3 T T*F 12 0 E 1 $ accept 4 T F 5 F (E) 6 F id Joey Paquet, 2000, 2002, 2008, 2012 16

Part III General Comments Joey Paquet, 2000, 2002, 2008, 2012 17

Compiler-Compilers • For real-life programming languages, construction of the table is extremely laborious and error-prone (several thousands of states) • Table construction follows strictly defined rules that can be implemented as a program called a parser generator • Yacc (Yet Another Compiler-Compiler) generates a LALR(1) parser code and table • Grammar is given in input in (near) BNF • Detects conflicts and resolves some conflicts automatically • Requires a minimal number of changes to the grammar • Each right hand side is associated with a custom semantic action to generate the symbol table and code Joey Paquet, 2000, 2002, 2008, 2012 18

Which Parser to Use? • We have seen – – recursive descent predictive table-driven predictive SLR, CLR, LALR Compiler-compiler • For real-life languages, the recursive descent parser lacks maintainability • The need for changing the grammar is a disadvantage • Code generation and error detection is more difficult and less accurate in top-down parsers • Most compilers are now implemented using the LR method, using compiler-compilers • Other more recent ones are generating top-down parsing methods (e. g. Java. CC) Joey Paquet, 2000, 2002, 2008, 2012 19