Pertemuan 8-9 Bottom-Up Parsing

1. Pertemuan 8-9Bottom-Up Parsing Matakuliah : T0522 / Teknik Kompilasi Tahun : 2005 Versi : 1/6

2. Learning Outcomes Pada akhir pertemuan ini, diharapkan mahasiswa akan mampu : • Mahasiswa dapat mendemonstrasikan prinsip kerja botton up parsing (C3) • Mahasiswa dapat mendemonstrasikan pembuatan tabel LR parsing (C3)

3. Outline Materi • Definisi bottom-up parsing • Shift reduce parsing • Implementasi dengan stack • Operator precedence parsing • LR-parsing • algoritma LR parsing • Konstruksi LR parse table

4. Contents • Introduction of Bottom-Up Parsing • Handles of String • Stack Implementation of Shift-Reduce Parsing • Conflict During Shift-Reduce Parsing • LR Parsers • LR(k) Parsers • Constructing SLR (Simple LR) Parser • Constructing LR Parsing Table • LALR Parsing Table • Using Ambiguous Grammars

5. Introduction of Bottom-Up Parser • Bottom-Up Parser • Also called shift-reduce parser • Construct a parse tree for an input string beginning at the leaves and working up toward the root • Reducing a string w to the start symbol S • At each reduction step, a particular substring RHS of production is replaced with by the symbol on LHS • e.g. • S → aABe A → Abc | b B → d • process w = abbcde • Then abbcde → aAbcde → aAde → aABe → S (reduction steps) • S → aABe → aAde → aAbcde → abbcde (rightmost derivation)

6. Handles of String (1/2) • Handles of a string • A substring that matches the right side of a production and whose reduction to the non-terminal on LHS presents one step along the reverse of a right derivation • Formally, handle of a right sentential form γ is a production A → β and a position of γ where the string β may be found and replaced by A to produce the previous right sentential form in a rightmost derivation of γ • e.g. From the above example abbcde is a right sentential form whose handle is A → b and aAbcde has a handle A → Abc and so on. • If a grammar is unambiguous, there exist only one handle for every right sentential form

7. Handles of String (2/2) • Ambiguous Grammar Case • Example 1) E → E + E E → E * E E → (E) E → id • Example 1 has two different rightmost derivations of the same string id + id * id • implies that some of the right sentential form has more than one handle • e.g E → id and E → E + E are handles from E + E * id

8. Stack Implementation of Shift-Reduce Parsing • Shift • Next input symbol is shifted onto the top of the stack • Reduce • A handle on the stack is replaced by the corresponding non-terminal (A handle always appears on the top of the stack) • Accept • Announce the successful completion

9. Conflict During Shift-Reduce Parsing • Shift/Reduce conflict • Cannot decide shift or reduce • Reduce/Reduce conflict • Cannot decide which production to use for reduce • e.g. • stmt → if expr then stmt | if expr then stmt else stmt | other stack has a handle "if expr them stmt"  : shift/reduce conflict

10. Input tape Stack LR(k) Parsers • Concept • left to right scan and rightmost derivation with k lookahead symbols LRParsing Program output Action/Goto Table Parsing Table

11. Constructing SLR (Simple LR) parser (1/9) • Viable Prefix • A prefix of a right sentential form that does not continue past the rightmost handle of that sentential form. It always appears the top of the stack of the shift-reduce parser • LR(0) item of G • A production of G with a dot at some position of the RHS • e.g. A → XYZ ⇒ A → ·XYZ , A → X·YZ , A → XY·Z , A → XYZ· • Central idea of SLR • construct a DFA that recognize viable prefixed. The state of the DFA consists of a set of items

12. Constructing SLR (Simple LR) parser (2/9) • Three operations for construction • Augmenting a grammar • Add S' → S to indicate the parser when it should stop and accept • closure operation • Suppose I is a set of items for G, then closure(I) 〓 ① every item in I is added to closure(I) ② If A → α·Bβ ∈ closure(I) ＆ B → γ exists, then add B → ·γ to cloasure(I) • e.g.   • E' → E, E → E + T | T, T → T * F | F, F → (E) | id • Start with I = { E' → ·E}, then closure(I) = { E' → ·E,  E → ·E + T, E →·T, T → ·T * F, T → ·F, F → · (E) F → ·id } • kernel items (dots are not at the left end) vs. non-kernel items

13. Constructing SLR (Simple LR) parser (3/9) • Three operations for construction • goto operation • Suppose I be a set of items and X be a grammar symbol, then goto(I, X) = the closure of the set of all items [A → αX·β] such that A → α·Xβ ∈ I • e.g. Suppose I = { E' → E·, E → E·+ T}, then goto(I, +) 〓 { E → E + ·T, T → ·T * F, T → ·F, F → · (E), F → ·id }

14. Constructing SLR (Simple LR) parser (4/9) • Draw state diagram for the following augmented grammar • e.g.   • E' → E , E → E + T | T, T → T * F | F, F → (E) | id I0 I10 I7 ( TT*F· TT*·FF· (E)F·id I4 E`·EE·E+TE·TT·T*FT·FF· (E)F·id F I11 F(E) · I2 T ET·TT·*F * F ) I3 I8 TF· ( EE·+TF(E·) id E I5 I1 F E`E.EE.+T Fid· I4 + I6 F(·E)E·E+TE·TT·T*FT.FF· (E)F·id E EE+·TT·T*FT·FF· (E)F·id id I6 id + ( F I9 EE+T· TT·*F I3 T ( * I7

15. Constructing SLR (Simple LR) parser (5/9) • SLR Parsing table • ① Build a DFA from the given grammar • ② Find follow(A) ∀nonterminal • ③ determine parsing actions for each I • a) if [A → α․aβ]∈Ii and goto(Ii, a) = Ij then set action[i,a] = shift j(Sj) • b) if [A → α·] ∈Ii     then set action[i, a] = reduce A → α ∀a in FOLLOW(A) except A = S' • c) if [S' → S·] ∈Ii then set action[i, $] = accept • ④ For all nonterminal A • if goto(Ii, A) = Ij then set goto[i, A] = j

16. Constructing SLR (Simple LR) parser (6/9) • SLR Parsing table • ⑤ For all other entries are made "error" • ⑥ Initial state is one containing [S' → S·] • e.g     • 1) E → E + T2) E → T3) T → T * F, 4) T →  F5) F → (E)6) F →  id • FOLLOW(E) = { +, $, )}FOLLOW(T) = {*,+,$,)}FOLLOW(F) = {*,+,$,)}

17. Constructing SLR (Simple LR) parser (7/9) • Executing a parser with the parsing table • configuration • (S0X0S1X1 … XmSm, aiai+1…am$) = (stack content, unexpended input) • Resulting configuration after action[Sm, ai] • i) = Sj (shift and goto state j) (S0X0S1X1 … XmSmaiS, ai+1…an$) • ii) = rp (reduce A → β) (S0X0S1X1 … Xm-rSm-rAS, aiai+1…an$) where S = goto[Sm-r, A] and r = • iii) accept (parsing is completed) • iv) error (error recovery is needed)

18. Constructing SLR (Simple LR) parser (8/9) • Executing a parser with the parsing table

19. I2 SL·=RRL· I0 S`·SS·L=RS·RL·*RL·idR·L L = I6 SL=·RR·LL·*RL·id Constructing SLR (Simple LR) parser (9/9) • A grammar that is not ambiguous, not SLR(1) • S → L = R , S → R , L → * R , L → id , R → L Then, FOLLOW(R)  = FLLOW(S) = FOLLOW(L) = { = } • Action[2, =] → Shift or Reduce • Because SLR is not powerful enough to remember sufficient left context to decide next action on "="

20. Constructing LR Parsing Table (1/3) • Central idea • In SLR, reduction of A → α is determined by looking to see if a comes after α while LR sees if βAa is allowed • Redefinition of items to include a terminal symbol [A → α·β, a] • The lookahead symbol a has no effect when β ≠ ε • a ∈ FOLLOW(A) • How to find the collection of sets of valid items

21. Constructing LR Parsing Table (2/3) • Closure(I) • if [A → α·Bβ, a] ∈ I, for each B → γ in G' add [ B → ·γ, FIRST(βα)] to I repeat until no more production is added. • goto[I, x] • if [A → α·Xβ, a] ∈ I, create J with [A → αX·β, a], and find closure(J)

22. Constructing LR Parsing Table (3/3) • Example • S' → S, S → CC, C → cC | d I8 I4 CcC·, c/d Cd·, c/d I3 C d I0 Cc·C, c/dC·cC, c/dC·d, c/d S`·S, $ S·CC, $C·cC, c/dC·d, c/d c c C I2 S SC·C, $C·cC, $C·d, $ C I5 I1 S`S, $ c I6 Cc·C, $C·cC, $C·d, $ C d I5 I7 <LR(1) Parsing Table > SCC·, $ Cd·, $ I9 c CcC·, $ <LR(1) Finite State Diagram>