1 Syntax Analysis Part II Chapter 4 COP5621 Compiler Construction Copyright Robert van Engelen, Florida State University, 2005.

Slides:



Advertisements
Similar presentations
Lesson 8 CDT301 – Compiler Theory, Spring 2011 Teacher: Linus Källberg.
Advertisements

Compiler Designs and Constructions
CH4.1 CSE244 SLR Parsing Aggelos Kiayias Computer Science & Engineering Department The University of Connecticut 371 Fairfield Road, Box U-155 Storrs,
Review: LR(k) parsers a1 … a2 … an $ LR parsing program Action goto Sm xm … s1 x1 s0 output input stack Parsing table.
1 May 22, May 22, 2015May 22, 2015May 22, 2015 Azusa, CA Sheldon X. Liang Ph. D. Computer Science at Azusa Pacific University Azusa Pacific University,
LR Parsing Table Costruction
6/12/2015Prof. Hilfinger CS164 Lecture 111 Bottom-Up Parsing Lecture (From slides by G. Necula & R. Bodik)
1 Chapter 5: Bottom-Up Parsing (Shift-Reduce). 2 - attempts to construct a parse tree for an input string beginning at the leaves (the bottom) and working.
Pertemuan 12, 13, 14 Bottom-Up Parsing
By Neng-Fa Zhou Syntax Analysis lexical analyzer syntax analyzer semantic analyzer source program tokens parse tree parser tree.
1 CMPSC 160 Translation of Programming Languages Fall 2002 slides derived from Tevfik Bultan, Keith Cooper, and Linda Torczon Lecture-Module #10 Parsing.
Lecture #8, Feb. 7, 2007 Shift-reduce parsing,
Bottom Up Parsing.
Chapter 4-2 Chang Chi-Chung Bottom-Up Parsing LR methods (Left-to-right, Rightmost derivation)  LR(0), SLR, Canonical LR = LR(1), LALR Other.
1 Bottom-up parsing Goal of parser : build a derivation –top-down parser : build a derivation by working from the start symbol towards the input. builds.
Bottom-up parsing Goal of parser : build a derivation
1 Introduction to Bottom Up Parser By Debi Prasad Behera, Lecturer, Dept of CSEA, Silicon Institute of Technology, Bhubaneswar.
LALR Parsing Canonical sets of LR(1) items
 an efficient Bottom-up parser for a large and useful class of context-free grammars.  the “ L ” stands for left-to-right scan of the input; the “ R.
Joey Paquet, 2000, 2002, 2012, Lecture 6 Bottom-Up Parsing.
410/510 1 of 21 Week 2 – Lecture 1 Bottom Up (Shift reduce, LR parsing) SLR, LR(0) parsing SLR parsing table Compiler Construction.
Bottom-Up Parsing CS308 Compiler Theory1. 2 Bottom-Up Parsing A bottom-up parser creates the parse tree of the given input starting from leaves towards.
lec04-bottomupparser April 23, 2017 Bottom-Up Parsing
CS 321 Programming Languages and Compilers Bottom Up Parsing.
 an efficient Bottom-up parser for a large and useful class of context-free grammars.  the “ L ” stands for left-to-right scan of the input; the “ R.
1 Compiler Construction Syntax Analysis Top-down parsing.
Syntactic Analysis Natawut Nupairoj, Ph.D. Department of Computer Engineering Chulalongkorn University.
1 LR Parsers  The most powerful shift-reduce parsing (yet efficient) is: LR(k) parsing. LR(k) parsing. left to right right-most k lookhead scanning derivation.
BİL 744 Derleyici Gerçekleştirimi (Compiler Design)1 Bottom-Up Parsing A bottom-up parser creates the parse tree of the given input starting from leaves.
Chapter 3-3 Chang Chi-Chung Bottom-Up Parsing LR methods (Left-to-right, Rightmost derivation)  LR(0), SLR, Canonical LR = LR(1), LALR 
Lesson 9 CDT301 – Compiler Theory, Spring 2011 Teacher: Linus Källberg.
Chapter 5: Bottom-Up Parsing (Shift-Reduce)
Syntax Analysis - LR(0) Parsing Compiler Design Lecture (02/04/98) Computer Science Rensselaer Polytechnic.
–Exercise: construct the SLR parsing table for grammar: S->L=R, S->R L->*R L->id R->L –The grammar can have shift/reduce conflict or reduce/reduce conflict.
1 Compiler Construction Syntax Analysis Top-down parsing.
Announcements/Reading
Bernd Fischer RW713: Compiler and Software Language Engineering.
Bottom Up Parsing CS 671 January 31, CS 671 – Spring Where Are We? Finished Top-Down Parsing Starting Bottom-Up Parsing Lexical Analysis.
Three kinds of bottom-up LR parser SLR “Simple LR” –most restrictions on eligible grammars –built quite directly from items as just shown LR “Canonical.
CS412/413 Introduction to Compilers and Translators Spring ’99 Lecture 6: LR grammars and automatic parser generators.
1 Syntax Analysis Part II Chapter 4 COP5621 Compiler Construction Copyright Robert van Engelen, Florida State University, 2007.
Lecture 5: LR Parsing CS 540 George Mason University.
Compilers: Bottom-up/6 1 Compiler Structures Objective – –describe bottom-up (LR) parsing using shift- reduce and parse tables – –explain how LR.
CS 404Ahmed Ezzat 1 CS 404 Introduction to Compiler Design Lecture Ahmed Ezzat.
Bottom-up parsing. Bottom-up parsing builds a parse tree from the leaves (terminals) to the start symbol int E T * TE+ T (4) (2) (3) (5) (1) int*+ E 
1 Chapter 6 Bottom-Up Parsing. 2 Bottom-up Parsing A bottom-up parsing corresponds to the construction of a parse tree for an input tokens beginning at.
Conflicts in Simple LR parsers A SLR Parser does not use any lookahead The SLR parsing method fails if knowing the stack’s top state and next input token.
Chapter 8. LR Syntactic Analysis Sung-Dong Kim, Dept. of Computer Engineering, Hansung University.
LR Parsing. LR Parsers The most powerful shift-reduce parsing (yet efficient) is: LR(k) parsing. left to right right-mostk lookhead scanning derivation(k.
S YNTAX A NALYSIS O R P ARSING Lecture 08. B OTTOM -U P P ARSING A bottom-up parser creates the parse tree of the given input starting from leaves towards.
Lec04-bottomupparser 4/13/2018 LR Parsing.
Compiler design Bottom-up parsing Concepts
Bottom-Up Parsing.
The role of parser Lexical Analyzer Parser Rest of Front End Symbol
lec04-bottomupparser June 6, 2018 Bottom-Up Parsing
UNIT - 3 SYNTAX ANALYSIS - II
Compiler Construction
Compiler design Bottom-up parsing: Canonical LR and LALR
Fall Compiler Principles Lecture 4: Parsing part 3
LALR Parsing Canonical sets of LR(1) items
Bottom-Up Syntax Analysis
Syntax Analysis Part II
Subject Name:COMPILER DESIGN Subject Code:10CS63
Compilers Principles, Techniques, & Tools Taught by Jing Zhang
Chapter 4. Syntax Analysis (2)
Compiler SLR Parser.
Announcements HW2 due on Tuesday Fall 18 CSCI 4430, A Milanova.
Chapter 4. Syntax Analysis (2)
Chap. 3 BOTTOM-UP PARSING
Compiler design Bottom-up parsing: Canonical LR and LALR
Presentation transcript:

1 Syntax Analysis Part II Chapter 4 COP5621 Compiler Construction Copyright Robert van Engelen, Florida State University, 2005

2 Bottom-Up Parsing LR methods (Left-to-right, Reftmost derivation) –SLR, Canonical LR, LALR Other special cases: –Shift-reduce parsing –Operator-precedence parsing

3 Operator-Precedence Parsing Special case of shift-reduce parsing We will not further discuss (you can skip textbook section 4.6)

4 Shift-Reduce Parsing Grammar: S  a A B e A  A b c | b B  d Shift-reduce corresponds to a rightmost derivation: S  rm a A B e  rm a A d e  rm a A b c d e  rm a b b c d e Reducing a sentence: a b b c d e a A b c d e a A d e a A B e S S a b b c d e A A B A A B A A A These match production’s right-hand sides

5 Handles Handle Grammar: S  a A B e A  A b c | b B  d A handle is a substring of grammar symbols in a right-sentential form that matches a right-hand side of a production NOT a handle, because further reductions will fail (result is not a sentential form) a b b c d e a A b c d e a A A e … ? a b b c d e a A b c d e a A d e a A B e S

6 Stack Implementation of Shift-Reduce Parsing Stack $ $id $E $E+ $E+id $E+E $E+E* $E+E*id $E+E*E $E+E $E Input id+id*id$ +id*id$ +id*id$ id*id$ *id$ *id$ id$ $ $ $ $ Action shift reduce E  id shift shift reduce E  id shift (or reduce?) shift reduce E  id reduce E  E * E reduce E  E + E accept Grammar: E  E + E E  E * E E  ( E ) E  id Find handles to reduce How to resolve conflicts?

7 Conflicts Shift-reduce and reduce-reduce conflicts are caused by –The limitations of the LR parsing method (even when the grammar is unambiguous) –Ambiguity of the grammar

8 Shift-Reduce Parsing: Shift-Reduce Conflicts Stack $… $…if E then S Input …$ else…$ Action … shift or reduce? Ambiguous grammar: S  if E then S | if E then S else S | other Resolve in favor of shift, so else matches closest if

9 Shift-Reduce Parsing: Reduce-Reduce Conflicts Stack $ $a Input aa$ a$ Action shift reduce A  a or B  a ? Grammar: C  A B A  a B  a Resolve in favor of reduce A  a, otherwise we’re stuck!

10 LR(k) Parsers: Use a DFA for Shift/Reduce Decisions start a A C B a Grammar: S  C C  A B A  a B  a State I 0 : S  C C  A B A  a State I 1 : S  C State I 2 : C  AB B  a State I 3 : A  a State I 4 : C  A B State I 5 : B  a goto(I 0,C) goto(I 0,a) goto(I 0,A) goto(I 2,a) goto(I 2,B) Can only reduce A  a (not B  a)

11 DFA for Shift/Reduce Decisions Stack $ 0 $ 0 $ 0 a 3 $ 0 A 2 $ 0 A 2 a 5 $ 0 A 2 B 4 $ 0 C 1 $ 0 S 1 Input aa$ aa$ a$ a$ $ $ $ $ Action start in state 0 shift (and goto state 3) reduce A  a (goto 2) shift (goto 5) reduce B  a (goto 4) reduce C  AB (goto 1) reduce S  C accept Grammar: S  C C  A B A  a B  a The states of the DFA are used to determine if a handle is on top of the stack State I 0 : S  C C  A B A  a State I 3 : A  a goto(I 0,a)

12 Model of an LR Parser a1a1 a2a2 …aiai …anan $ LR Parsing Program (driver) actiongoto smsm XmXm s m-1 X m-1 … s0s0 output stack input DFA shift reduce accept error

13 LR Parsing (s 0 X 1 s 1 X 2 s 2 … X m s m, a i a i+1 … a n $) stackinput Configuration ( = LR parser state): If action[s m,a i ] = shift s, then push a i, push s, and advance input: (s 0 X 1 s 1 X 2 s 2 … X m s m a i s, a i+1 … a n $) If action[s m,a i ] = reduce A   and goto[s m-r,A] = s with r=|  | then pop 2r symbols, push A, and push s: (s 0 X 1 s 1 X 2 s 2 … X m-r s m-r A s, a i a i+1 … a n $) If action[s m,a i ] = accept, then stop If action[s m,a i ] = error, then attempt recovery

14 Example LR Parse Table Grammar: 1. E  E + T 2. E  T 3. T  T * F 4. T  F 5. F  ( E ) 6. F  id s5s4 s6acc r2s7r2 r4 s5s4 r6 s5s4 s5s4 s6s11 r1s7r1 r3 r5 id+*()$ ETF Shift & goto 5 Reduce by production #1 actiongoto state

15 Example LR Parsing Stack $ 0 $ 0 id 5 $ 0 F 3 $ 0 T 2 $ 0 T 2 * 7 $ 0 T 2 * 7 id 5 $ 0 T 2 * 7 F 10 $ 0 T 2 $ 0 E 1 $ 0 E $ 0 E id 5 $ 0 E F 3 $ 0 E T 9 $ 0 E 1 Input id*id+id$ *id+id$ *id+id$ *id+id$ id+id$ +id$ +id$ +id$ +id$ id$ $ $ $ $ Action shift 5 reduce 6 goto 3 reduce 4 goto 2 shift 7 shift 5 reduce 6 goto 10 reduce 3 goto 2 reduce 2 goto 1 shift 6 shift 5 reduce 6 goto 3 reduce 4 goto 9 reduce 1 goto 1 accept Grammar: 1. E  E + T 2. E  T 3. T  T * F 4. T  F 5. F  ( E ) 6. F  id

16 SLR Grammars SLR (Simple LR): a simple extension of LR(0) shift-reduce parsing SLR eliminates some conflicts by populating the parsing table with reductions A  on symbols in FOLLOW(A) S  E E  id + E E  id State I 0 : S  E E  id + E E  id State I 2 : E  id+ E E  id goto(I 0,id)goto(I 3,+) FOLLOW(E)={$} thus reduce on $ Shift on +

17 SLR Parsing Table s2 acc s3r3 s2 r2 id+$ E S  E 2. E  id + E 3. E  id FOLLOW(E)={$} thus reduce on $ Shift on + Reductions do not fill entire rows Otherwise the same as LR(0)

18 SLR Parsing An LR(0) state is a set of LR(0) items An LR(0) item is a production with a (dot) in the right-hand side Build the LR(0) DFA by –Closure operation to construct LR(0) items –Goto operation to determine transitions Construct the SLR parsing table from the DFA LR parser program uses the SLR parsing table to determine shift/reduce operations

19 Constructing SLR Parsing Tables 1.Augment the grammar with S’  S 2.Construct the set C={I 0,I 1,…,I n } of LR(0) items 3.If [A a  ]  I i and goto(I i,a)=I j then set action[i,a]=shift j 4.If [A  ]  I i then set action[i,a]=reduce A  for all a  FOLLOW(A) (apply only if A  S’) 5.If [S’  S] is in I i then set action[i,$]=accept 6.If goto(I i,A)=I j then set goto[i,A]=j 7.Repeat 3-6 until no more entries added 8.The initial state i is the I i holding item [S’ S]

20 LR(0) Items of a Grammar An LR(0) item of a grammar G is a production of G with a at some position of the right-hand side Thus, a production A  X Y Z has four items: [A  X Y Z] [A  X Y Z] [A  X Y Z] [A  X Y Z ] Note that production A   has one item [A  ]

21 Constructing the set of LR(0) Items of a Grammar 1.The grammar is augmented with a new start symbol S’ and production S’  S 2.Initially, set C = closure({[S’ S]}) (this is the start state of the DFA) 3.For each set of items I  C and each grammar symbol X  (N  T) such that goto(I,X)  C and goto(I,X)  , add the set of items goto(I,X) to C 4.Repeat 3 until no more sets can be added to C

22 The Closure Operation for LR(0) Items 1.Start with closure(I) = I 2.If [A B  ]  closure(I) then for each production B  in the grammar, add the item [B   ] to I if not already in I 3.Repeat 2 until no new items can be added

23 The Closure Operation (Example) Grammar: E  E + T | T T  T * F | F F  ( E ) F  id { [E’  E] } closure({[E’  E]}) = { [E’  E] [E  E + T] [E  T] } { [E’  E] [E  E + T] [E  T] [T  T * F] [T  F] } { [E’  E] [E  E + T] [E  T] [T  T * F] [T  F] [F  ( E )] [F  id] } Add [E   ] Add [T   ] Add [F   ]

24 The Goto Operation for LR(0) Items 1.For each item [A X  ]  I, add the set of items closure({[A  X  ]}) to goto(I,X) if not already there 2.Repeat step 1 until no more items can be added to goto(I,X) 3.Intuitively, goto(I,X) is the set of items that are valid for the viable prefix  X when I is the set of items that are valid for 

25 The Goto Operation (Example 1) Suppose I = Then goto(I,E) = closure({[E’  E, E  E + T]}) = { [E’  E ] [E  E + T] } Grammar: E  E + T | T T  T * F | F F  ( E ) F  id { [E’  E] [E  E + T] [E  T] [T  T * F] [T  F] [F  ( E )] [F  id] }

26 The Goto Operation (Example 2) Suppose I = { [E’  E ], [E  E + T] } Then goto(I,+) = closure({[E  E + T]}) = { [E  E + T] [T  T * F] [T  F] [F  ( E )] [F  id] } Grammar: E  E + T | T T  T * F | F F  ( E ) F  id

27 Example SLR Grammar and LR(0) Items Augmented grammar: 1. C’  C 2. C  A B 3. A  a 4. B  a State I 0 : C’  C C  A B A  a State I 1 : C’  C State I 2 : C  AB B  a State I 3 : A  a State I 4 : C  A B State I 5 : B  a goto(I 0,C) goto(I 0,a) goto(I 0,A) goto(I 2,a) goto(I 2,B) I 0 = closure({[C’  C]}) I 1 = goto(I 0,C) = closure({[C’  C]}) … start final

28 Example SLR Parsing Table s3 acc s5 r3 r2 r4 a$ CAB 12 4 State I 0 : C’  C C  A B A  a State I 1 : C’  C State I 2 : C  AB B  a State I 3 : A  a State I 4 : C  A B State I 5 : B  a start a A C B a Grammar: 1. C’  C 2. C  A B 3. A  a 4. B  a

29 SLR and Ambiguity Every SLR grammar is unambiguous, but not every unambiguous grammar is SLR Consider for example the unambiguous grammar S  L = R | R L  * R | id R  L I 0 : S’  S S  L=R S  R L  *R L  id R  L I 1 : S’  S I 2 : S  L=R R  L I 3 : S  R I 4 : L  *R R  L L  *R L  id I 5 : L  id I 6 : S  L=R R  L L  *R L  id I 7 : L  *R I 8 : R  L I 9 : S  L=R action[2,=]=s6 action[2,=]=r5 no Has no SLR parsing table

30 LR(1) Grammars SLR too simple LR(1) parsing uses lookahead to avoid unnecessary conflicts in parsing table LR(1) item = LR(0) item + lookahead LR(0) item: [A   ] LR(1) item: [A  , a]

31 I 2 : S  L=R R  L action[2,=]=s6 Should not reduce, because no right-sentential form begins with R= split R  LS  L=R SLR Versus LR(1) Split the SLR states by adding LR(1) lookahead Unambiguous grammar S  L = R | R L  * R | id R  L

32 LR(1) Items An LR(1) item [A  , a] contains a lookahead terminal a, meaning  already on top of the stack, expect to see  a For items of the form [A , a] the lookahead a is used to reduce A  only if the next input is a For items of the form [A  , a] with  the lookahead has no effect

33 The Closure Operation for LR(1) Items 1.Start with closure(I) = I 2.If [A B , a]  closure(I) then for each production B  in the grammar and each terminal b  FIRST(  a), add the item [B  , b] to I if not already in I 3.Repeat 2 until no new items can be added

34 The Goto Operation for LR(1) Items 1.For each item [A X , a]  I, add the set of items closure({[A  X , a]}) to goto(I,X) if not already there 2.Repeat step 1 until no more items can be added to goto(I,X)

35 Constructing the set of LR(1) Items of a Grammar 1.Augment the grammar with a new start symbol S’ and production S’  S 2.Initially, set C = closure({[S’ S, $]}) (this is the start state of the DFA) 3.For each set of items I  C and each grammar symbol X  (N  T) such that goto(I,X)  C and goto(I,X)  , add the set of items goto(I,X) to C 4.Repeat 3 until no more sets can be added to C

36 Example Grammar and LR(1) Items Unambiguous LR(1) grammar: S  L = R | R L  * R | id R  L Augment with S’  S LR(1) items (next slide)

37 [S’  S,$] goto(I 0,S)=I 1 [S  L=R,$] goto(I 0,L)=I 2 [S  R,$] goto(I 0,R)=I 3 [L  *R,=/$] goto(I 0,*)=I 4 [L  id,=/$] goto(I 0,id)=I 5 [R  L,$] goto(I 0,L)=I 2 [S’  S,$] [S  L=R,$] goto(I 0,=)=I 6 [R  L,$] [S  R,$] [L  *R,=/$] goto(I 4,R)=I 7 [R  L,=/$] goto(I 4,L)=I 8 [L  *R,=/$] goto(I 4,*)=I 4 [L  id,=/$] goto(I 4,id)=I 5 [L  id,=/$] [S  L=R,$] goto(I 6,R)=I 4 [R  L,$] goto(I 6,L)=I 10 [L  *R,$] goto(I 6,*)=I 11 [L  id,$] goto(I 6,id)=I 12 [L  *R,=/$] [R  L,=/$] [S  L=R,$] [R  L,$] [L  *R,$] goto(I 11,R)=I 13 [R  L,$] goto(I 11,L)=I 10 [L  *R,$] goto(I 11,*)=I 11 [L  id,$] goto(I 11,id)=I 12 [L  id,$] [L  *R,$] I0:I0: I1:I1: I2:I2: I3:I3: I4:I4: I5:I5: I6:I6: I7:I7: I8:I8: I9:I9: I 10 : I 12 : I 11 : I 13 :

38 Constructing Canonical LR(1) Parsing Tables 1.Augment the grammar with S’  S 2.Construct the set C={I 0,I 1,…,I n } of LR(1) items 3.If [A a , b]  I i and goto(I i,a)=I j then set action[i,a]=shift j 4.If [A , a]  I i then set action[i,a]=reduce A  (apply only if A  S’) 5.If [S’  S, $] is in I i then set action[i,$]=accept 6.If goto(I i,A)=I j then set goto[i,A]=j 7.Repeat 3-6 until no more entries added 8.The initial state i is the I i holding item [S’ S,$]

39 Example LR(1) Parsing Table s5s4 acc s6r6 r3 s5s4 r5 s12s11 r4 r6 r2 r6 s12s11 r5 r4 id*=$ SLR Grammar: 1. S’  S 2. S  L = R 3. S  R 4. L  * R 5. L  id 6. R  L

40 LALR(1) Grammars LR(1) parsing tables have many states LALR(1) parsing (Look-Ahead LR) combines LR(1) states to reduce table size Less powerful than LR(1) –Will not introduce shift-reduce conflicts, because shifts do not use lookaheads –May introduce reduce-reduce conflicts, but seldom do so for grammars of programming languages

41 Constructing LALR(1) Parsing Tables 1.Construct sets of LR(1) items 2.Combine LR(1) sets with sets of items that share the same first part [L  *R,=] [R  L,=] [L  *R,=] [L  id,=] [L  *R,$] [R  L,$] [L  *R,$] [L  id,$] I4:I4: I 11 : [L  *R,=/$] [R  L,=/$] [L  *R,=/$] [L  id,=/$] Shorthand for two items in the same set

42 Example LALR(1) Grammar Unambiguous LR(1) grammar: S  L = R | R L  * R | id R  L Augment with S’  S LALR(1) items (next slide)

43 [S’  S,$] goto(I 0,S)=I 1 [S  L=R,$] goto(I 0,L)=I 2 [S  R,$] goto(I 0,R)=I 3 [L  *R,=] goto(I 0,*)=I 4 [L  id,=] goto(I 0,id)=I 5 [R  L,$] goto(I 0,L)=I 2 [S’  S,$] [S  L=R,$] goto(I 0,=)=I 6 [R  L,$] [S  R,$] [L  *R,=/$] goto(I 4,R)=I 7 [R  L,=/$] goto(I 4,L)=I 9 [L  *R,=/$] goto(I 4,*)=I 4 [L  id,=/$] goto(I 4,id)=I 5 [L  id,=/$] [S  L=R,$] goto(I 6,R)=I 8 [R  L,$] goto(I 6,L)=I 9 [L  *R,$] goto(I 6,*)=I 4 [L  id,$] goto(I 6,id)=I 5 [L  *R,=/$] [S  L=R,$] [R  L,=/$] I0:I0: I1:I1: I2:I2: I3:I3: I4:I4: I5:I5: I6:I6: I7:I7: I8:I8: I9:I9: Shorthand for two items [R  L,=] [R  L,$]

44 Example LALR(1) Parsing Table s5s4 acc s6r6 r3 s5s4 r5 s5s4 r4 r2 r6 id*=$ SLR Grammar: 1. S’  S 2. S  L = R 3. S  R 4. L  * R 5. L  id 6. R  L

45 LL, SLR, LR, LALR Summary LL parse tables computed using FIRST/FOLLOW –Nonterminals  terminals  productions –Computed using FIRST/FOLLOW LR parsing tables computed using closure/goto –LR states  terminals  shift/reduce actions –LR states  terminals  goto state transitions A grammar is –LL(1) if its LL(1) parse table has no conflicts –SLR if its SLR parse table has no conflicts –LALR(1) if its LALR(1) parse table has no conflicts –LR(1) if its LR(1) parse table has no conflicts

46 LL, SLR, LR, LALR Grammars LL(1) LR(1) LR(0) SLR LALR(1)

47 Dealing with Ambiguous Grammars 1. S’  E 2. E  E + E 3. E  id s2 s3acc r3 s2 s3/r2r2 id+$ E 1 4 Shift/reduce conflict: action[4,+] = shift 4 action[4,+] = reduce E  E + E When reducing on +: yields left associativity (id+id)+id When shifting on +: yields right associativity id+(id+id) $ 0 E E 4 id+id+id$ +id$ $ 0 … … stackinput

48 Using Associativity and Precedence to Resolve Conflicts Left-associative operators: reduce Right-associative operators: shift Operator of higher precedence on stack: reduce Operator of lower precedence on stack: shift S’  E E  E + E E  E * E E  id $ 0 E 1 * 3 E 5 id*id+id$ +id$ $ 0 … … stackinput reduce E  E * E

49 Error Detection in LR Parsing Canonical LR parser uses full LR(1) parse tables and will never make a single reduction before recognizing the error when a syntax error occurs on the input SLR and LALR may still reduce when a syntax error occurs on the input, but will never shift the erroneous input symbol

50 Error Recovery in LR Parsing Panic mode –Pop until state with a goto on a nonterminal A is found, where A represents a major programming construct –Discard input symbols until one is found in the FOLLOW set of A Phrase-level recovery –Implement error routines for every error entry in table Error productions –Pop until state has error production, then shift on stack –Discard input until symbol that allows parsing to continue