1. Chapter 6: Top-Down Parser1 Compiler Designs and Constructions Chapter 6: Top-Down Parser Objectives: Types of Parsers Backtracking Vs. Non-backtracking PDA Dr. Mohsen Chitsaz

2. Chapter 6: Top-Down Parser2 Definition: Alphabet: Set of Char (token) Language: Set of Token Sentence: a group of token Grammar: a set of (productions) that control the order of the occurrence of words Syntax: a set of rules Parser: software to check the syntax Parsing: Process of breaking down the lexemes

3. Chapter 6: Top-Down Parser3 Types of Parser Universal Parsing Method example: Cocke-Younger-Kasami Algorithm Can parse any grammar too inefficient to use in compiler production Top-Down Parsing Left most derivation Bottom-up Parsing Right most derivation

4. Chapter 6: Top-Down Parser4 Top-Down Parsing Non-backtracking Vs. Backtracking Large Plant Green Plant Recursive Descent Parsing (Predictive Parser) We execute a set of recursive procedures to process the input There is one procedure associated with each non-terminal of a grammar

5. Chapter 6: Top-Down Parser5 Example   ^id  array [ ] of integer  char  num.. num

6. Chapter 6: Top-Down Parser6 Procedure Match (T:token); Begin If LookaHead==T then LookaHead==NextToken Else Error(); End;

7. Chapter 6: Top-Down Parser7 Procedure Type( ); Begin If LookaHead in {integer, char, num} then Simple(); Else If LookaHead == ‘^’ then Begin Match (‘^’); Match (id); End Else If LookaHead == array then

8. Chapter 6: Top-Down Parser8 Begin Match (array); Match (‘[‘); Simple(); Match (‘]’); Match (of); Type(); End Else Error(); End;

9. Chapter 6: Top-Down Parser9 Procedure Simple(); Begin If LookaHead == integer then Match (integer) Else If LookaHead == char then Match (char) Else If LookaHead == num then Begin Match (num); Match (‘..’); Match (num); End Else Error(); End;

10. Chapter 6: Top-Down Parser10 Example   ^id  array [ ] of integer  char  num.. num

11. Chapter 6: Top-Down Parser11 Which production should we use? integer  ^id   integer  char Example

12. Chapter 6: Top-Down Parser12 First (simple) = {integer, char, num} First (^id) = {^} First (array [ ] of type = {array}) First (type) = {^, array, integer, char, num} Example

13. Chapter 6: Top-Down Parser13 Definition: A  ab First (A) = a A   A   First of  &  must be disjoint

14. Chapter 6: Top-Down Parser14 Push Down Automata (Non-recursive predictive Parsing)

15. Chapter 6: Top-Down Parser15 Push Down Automata (Non-recursive predictive Parsing) PDA = {Q, , H, , q0, Z, F} Q = finite set of States  = set of input alphabet H = set of stack symbols  = transition function (q, a, z) q0 = starting state Z = starting stack F = final states

16. Chapter 6: Top-Down Parser16 Operation on  state operation  change()  stay() stack operation  push()  pop()  replace()  none() input operation  advance()  retain()

17. Chapter 6: Top-Down Parser17 INPUT ()-| q1 A Push (A) State (S) Advance Pop State (S) Advance Reject q0 $ Push (A) State (S) Advance RejectAccept STARTSTART  = { (, ), -| } H = {A, $} q0 = {S} Z = {$} Example:

18. Chapter 6: Top-Down Parser18 If input is (())-| Stack Input $ (())-| $A ())-| $AA ))-| $A )-| $ -|

19. Chapter 6: Top-Down Parser19 Derivation Tree S  (S) |

20. Chapter 6: Top-Down Parser20 LL(1) Grammar (push down machine) Scan from Left (L), Leftmost derivation (L), Look a head 1 Token

21. Chapter 6: Top-Down Parser21 Definition: A production is called NULL if the RHS of that production is Ø A   A production is call NULLABLE if the RHS can be reduced to Ø B  A A  

22. Chapter 6: Top-Down Parser22 Example of LL(1) Grammar: 1- S  AbB-|First(AbB-|) ={a,e,g, } 2- S  dFirst(d) = {d} 3- A  C AbFirst(C Ab) = {a,e} 4- A  BFirst(B) = {g, } 5- B  gSdFirst(gSd) = {g} 6- B   First (Ø) = {} 7- C  aFirst (a) = {a} 8- C  edFirst (ed) = {e}

23. Chapter 6: Top-Down Parser23 First (  ) = {a|  =>*a  } Set of terminal symbols that occur at the beginning of string derived from 

24. Chapter 6: Top-Down Parser24 Follow (  )= Set of input symbols that can immediately follow  Follow (A) = {b} Follow (B) = {-|, b, d} 1 4 S --->AbB --->BbB 1 5 1 S --->AbB --->AbgSd --->AbgAbBd

25. Chapter 6: Top-Down Parser25 SELECT (A->  ) = {First (  ) If  = Ø; First (  ) U Follow (A)} SELECT (1) = {a,e,g} U Follow(A)={a, e, g,b} SELECT (2) = {d} SELECT (3) = {a,e} SELECT (4) = First(4) U Follow (A) = {g,b} SELECT (5) = {g} SELECT (6) = First(6) U Follow (B) = {-|,b,d} SELECT (7)={a} SELECT (8) = {e} SELECT (PREDICT):

26. Chapter 6: Top-Down Parser26 Is this grammar LL(1)? S SELECT (1)  SELECT (2) ={a,e,g,b}  {d}= Ø A SELECT (3)  SELECT (4) ={a,e}  {g,b}= Ø B SELECT (5)  SELECT (6) = {g}  {-|,b,d}= Ø C SELECT (7)  SELECT (8) = {a}  {e}= Ø Def: Grammar is LL(1), IIF production with the same LHS have disjoint prediction set.

27. Chapter 6: Top-Down Parser27 Creating the Table: Stack symbols=rows Input symbols=columns A  b  For row A, column b =REPLACE(  r ), ADVANCE A   For row A, column(selection set) =REPLACE (  r ), RETAIN A  b For row A, column b =POP, ADVANCE

28. Chapter 6: Top-Down Parser28 Row b, column b = POP, ADVANCE Row Δ, column -|=ACCEPT All other are ERROR Creating the Table:

29. Chapter 6: Top-Down Parser29 abgde-| S#1 #2#1Rej A#3#4 Rej#3Rej B #6#5#6Rej#6 C#7Rej #8Rej b Ad/PopRej d Ad/PRej Δ Accept Parsed Table

30. Chapter 6: Top-Down Parser30 1- Replace (Δ B b A), Retain 2- Pop, Advance 3- Replace (bAC), Retain 4- Replace (B), Retain 5- Replace (dS), Advance 6- Pop, Retain 7- Pop, Advance 8- Replace(d), Advance

31. Chapter 6: Top-Down Parser31 Input: b g d d -| StackInputProductionAction Sbgdd-|#1Replace (D BbA), Retain Δ BbA bgdd-|#4Replace(B), Retain Δ BbB bgdd-|#6Pop, Retain Δ Bb bgdd-|Pop, Advance Δ B gdd-|#5Replace (dS), Advance Δ dS dd-|#2Pop, Advance Δ d d-|Pop, Advance Δ -|Accept

32. Chapter 6: Top-Down Parser32 Parse Tree

33. Chapter 6: Top-Down Parser33 Recovery in a Top-Down Parser Advantage of TDP is efficient error recovery. Error: If Top of stack (token) is not the same as Look a Head (token) Recovery: Pop stack until Top: Synchronization Token (ST) ST: is a token that can end blocks of codes Read input symbol until current LookaHead symbol matches the symbol at the top of the stack or reaches the end of input If not end of input you are recovered

34. Chapter 6: Top-Down Parser34 LL(1) Grammars & Parser: facts: CFG Leftmost Parser Unambiguous O(n) Can be used for automatically generated parser

35. Chapter 6: Top-Down Parser35 Making Grammar: LL(1) 1-Remove Common Prefixed (Left Factor) S --> aBCdS --> aBD S --> aBD --> D --> Cd --> if then endif; --> if then else endif; --> if then --> endif; --> else endif;

36. Chapter 6: Top-Down Parser36 2-Remove Left Recursion:E E --> E + T E --> T T --> id A--> A  A-->B A-->A1 A2 A1-->B A2-->  A2 A2--> E-->E1E2 E1-->T E2-->+T E2 T-->id E2-->

37. Chapter 6: Top-Down Parser37 3-Remove Unreachable Products S-->aS -->a B-->S

38. Chapter 6: Top-Down Parser38 4-Corner Substitution S --> AB  B -->  1 B -->  2 B -->  3 S --> A  1  S --> A  2  S --> A  3  S --> a S --> AS A --> ab A --> cA S --> aB B --> B --> bS A --> ab A --> cA S --> cAS

39. Chapter 6: Top-Down Parser39 5-Singleton Substitution S-->  B  S-->  S'  S'--> B --> --> id: --> --> id:= ;

40. Chapter 6: Top-Down Parser40 Singleton Substitution - --> id: --> --> id:= ; - --> id: --> id:= ; --> id:= ; - --> id --> : --> := --> id :=

41. Chapter 6: Top-Down Parser41 Some Grammars Can Not be LL(1) *If _ Then _ Else If then If then else *S --> aBcS S --> aBcSeS B --> d S --> b

42. Chapter 6: Top-Down Parser42 Q-Grammar: A --> a  1 A --> b  1 A --> S-Grammar: A --> a  1 A --> b  2 A and S grammar are a LL(1) and we can make a push down Machine