1 / 22

Pertemuan 8-9 Bottom-Up Parsing

Pertemuan 8-9 Bottom-Up Parsing. Matakuliah : T0522 / Teknik Kompilasi Tahun : 2005 Versi : 1/6. Learning Outcomes. Pada akhir pertemuan ini, diharapkan mahasiswa akan mampu : Mahasiswa dapat mendemonstrasikan prinsip kerja botton up parsing (C3)

wayne-kirk
Download Presentation

Pertemuan 8-9 Bottom-Up Parsing

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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>

More Related