1. Top-Down Parsing

2. Task Parsing (of course); but do it: Top-Down Easy and algorithmic Efficiently –Knowing (input) as little as possible –Marking errors as soon as possible

3. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num array [ num ptpt num ] of char $ type Lexical Analyzer ]oftypearray[simple

4. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num array [ num ptpt num ] of char $ type Lexical Analyzer ]oftypearray[simple array

5. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num [ num ptpt num ] of char $ type Lexical Analyzer ]oftypearray[simple array[

6. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num num ptpt num ] of char $ type Lexical Analyzer ]oftypearray[simple numptptnum array[num

7. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num ptpt num ] of char $ type Lexical Analyzer ]oftypearray[simple numptptnum array[numptpt

8. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num num ] of char $ type Lexical Analyzer ]oftypearray[simple numptptnum array[numptptnum

9. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num ] of char $ type Lexical Analyzer ]oftypearray[simple numptptnum array[numptptnum]

10. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num of char $ type Lexical Analyzer ]oftypearray[simple numptptnum array[numptptnum]of

11. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num char $ type Lexical Analyzer ]oftypearray[simple numptptnum simple char array[numptptnum]ofchar

12. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num $ type Lexical Analyzer ]oftypearray[simple numptptnum simple char array[numptptnum]ofchar

13. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num type Lex. An. ]oftypearray[simple numptptnum simple char array[numptptnum]ofchar $ (no more) $

14. Code procedure type; if … then match(array); match (‘[‘); simple; match(‘]‘); match(of); type else if … then match(‘^’); simple else if... then simple else error

15. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num ^ integer type Lexical Analyzer ^

16. Example type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num integer $ type Lexical Analyzer ^simple ^integer

17. match procedure match (t: token); begin if lookahead = t then looakahead := nexttoken (lexical analyzer) else error end

18. Solving ifs We said “that rule” because we know next input symbol (lookahead): type: array : ^ : rule 1: –any other : error will be detected later –integer, char, num : error detected now type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num rule 3 rule 2

19. Predictive Parsing Table PPT integercharnumarray^[of]$ type rule 1 rule 3rule 2 simple rule 4rule 5rule 6 PPT…terminal… ………… Non terminal…rule… …………

20. Generalizing type → simple | ^ simple | array [simple] of type simple → integer | char | num ptpt num Choose rule A → α when a (lookahead) can appear as first symbol derived from α α βa A B γ a A α = δ βa A FIRST (α) := { a Є Σ T / α ═> * a β } Still not complete!

21. Predictive Parsing Table PPT…a… …… A…A → α… …… PPT…terminal… …… Non terminal…rule… …… A → α with α≠ε to PPT [ A, FIRST(α) ]

22. FIRST FIRST (a) = { a } FIRST (A) = FIRST (α) FIRST (A α) = FIRST (A) FIRST (α) := { a Є Σ T / α ═> * a β } Still not complete! A→α Є P U

23. E → T E’ E’ → + T E’ | ab T → F T’ T’ → * F T’ | a F → ( E ) | n FIRST First (E) = First (TE’) = First (T) First(E’) = First ( +TE’) U First (ab) = {+, a } EE’TT’F +a+a First (T) = First (FT’) = First (F) First (T’) = First ( *FT’) U First (a) = { *, a } *a*a First (F) = { (, n } (n(n (n(n (n(n

24. E → T E’ E’ → + T E’ | ab T → F T’ T’ → * F T’ | a F → ( E ) | n FIRSTEE’TT’F +a+a *a*a (n(n (n(n (n(n A → α with α ≠ ε to T [ A, First (α) - {ε} ] (na*+)$ E E’ T T’ F E → T E’ TE’ E’ → + T E’ +TE’ E’ → ab ab T → FT’ FT’ T’ → * F T’ *FT’ T’ → a a F → ( E ) (E) F → n n

25. A bad example program →program id ; | program id ( par-list ) ; program Lexical Analyzer program id ; programid ;

26. A bad example: backtracking program Lexical Analyzer program id programid ( ; $ (no more) program →program id ; | program id ( par-list ) ; Ups!

27. A bad example: backtracking program Lexical Analyzer program id programid ( ; $ (no more) program →program id ; | program id ( par-list ) ;

28. A bad example: backtracking program Lexical Analyzer program id; $ (no more) program →program id ; | program id ( par-list ) ; ( param-list)

29. Not so bad: factorising program →program id R ; R → ( par-list ) | ε program Lexical Analyzer program id R programid ; ; ε $ (no more) $

30. Another bad example E → E + n | n E +n E +n E +n E n n+n+n+n

31. Another bad example E → E + n | n Lexical Analyzer E +n E $ n+n+n +n E $ n

32. Not so bad either: eliminating left recursion E → E + n | n E → n E’ E’ → + n E’ | ε E n E’ n+n+n + n +n ε $ $ Lexical Analyzer

33. FIRST FIRST (α) := { a Є Σ T / α ═> * a β } { ε } ∩ A=>*ε

34. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRST First (E) = First (TE’)First(E’) = {+, ε } EE’TT’F +ε+ε First (T) = First (FT’)First (T’) = { *, ε } *ε*ε First (F) = { (, n } (n(n (n(n (n(n

35. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n First ( E’F ) = {+, (, n} First ( E’T’F ) = {+, (, n}, * First ( E’T’T’ ) = {+, ε}, *

36. FIRST FIRST (a) = { a } FIRST (A) = FIRST (α) FIRST (A α) = (FIRST (A) – { ε }) FIRST (α) ε Є FIRST (X 1 X 2 … X p ) iff ε Є FIRST (X i ) i ∩ A=>*ε A FIRST (α) := { a Є Σ T / α ═> * a β } { ε } ∩ A=>*ε A→α Є P U

37. Remember program →program id R ; R → ( par-list ) | ε program Lexical Analyzer program id R programid ; ; ε $ (no more) $

38. Remember program →program id R ; R → ( par-list ) | ε program Lexical Analyzer program id R programid ; ε $ (no more) ERROR

39. Remember program →program id R ; R → ( par-list ) | ε program Lexical Analyzer program id R programid ; $ (no more) ERROR “Marking errors as soon as possible”

40. ε - rules Choose rule A → ε when a (lookahead) can appear following A in a sentential form FOLLOW (A) := { a Є Σ T / S ═> * α Aa β } { $ } ∩ S=>*αA … aA C αβ S BA C αβ S a … … … BA C αa S ε aA C αβ S... … B A C α S$ …

41. Follow Righthand sides: α A β with β ≠ ε add First(β)-{ε} to Follow (A) For every rule B → α A add Follow (B) to Follow (A) For every rule B → α A β with β ═> * ε add Follow (B) to Follow (A) Add $ to Follow (Start Symbol)

42. Follow 0. Add $ to Follow (Start symbol) Righthand sides: α A β with β ≠ ε add First(β)-{ε} to Follow (A) 2.For every rule B → α A or B → α A β with β ═> * ε add Follow (B) to Follow (A)

43. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0)$ 0) Add $ to Follow (Start Symbol)

44. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0) 1) T E’ + +TE’ 1)Righthand sides: α A β with β ≠ ε Add First(β)-{ε} to Follow (A) $ T E’ α A β As before

45. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0) 1) F T’ * * F T’ 1)Righthand sides: α A β with β ≠ ε Add First(β)-{ε} to Follow (A) $ F T’ α A β As before +

46. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0) 1) ( E ) * 1)Righthand sides: α A β with β ≠ ε Add First(β)-{ε} to Follow (A) $ ( E ) α A β + )

47. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0) 1) E → T E’ * 2) For every rule like B → α A or B → α A β with β ═> * ε Add Follow (B) to Follow (A) $ E → T E’ B → α A + ) 2) ) E → T E’ B → α A β

48. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0) 1) E’ → + T E’ * 2) For every rule like B → α A or B → α A β with β ═> * ε Add Follow (B) to Follow (A) $ E’ → + T E’ B → α A + ) 2) ) E’ → + T E’ B → α A β

49. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0) 1) T → F T’ * 2) Every rule B → α A or B → α A β with β ═> * ε Add Follow (B) to Follow (A) $ T → F T’ B → α A + ) 2) ) T → F T’ B → α A β

50. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0) 1) T’ → * F T’ * 2) Every rule B → α A or B → α A β with β ═> * ε Add Follow (B) to Follow (A) $ T’ → * F T’ B → α A + ) 2) ) T’ → * F T’ B → α A β

51. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0) 1) * 2) Every rule B → α A or B → α A β with β ═> * ε Add Follow (B) to Follow (A) + 2) $ )) $ )) $ ))

52. E → T E’ E’ → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n FOLLOW EE’TT’F 0) 1) * 2) Every rule B → α A or B → α A β with β ═> * ε Add Follow (B) to Follow (A) 2) $ )) $ )) + $ )) + $ )) + $ ))

53. Predictive Parsing Table Construction

54. FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n 1) A → α with α ≠ ε to T [ A, First (α) - {ε} ] FOLLOW EE’TT’F $)$) +$)+$) *+$)*+$) $)$) +$)+$) (n*+)$ E E’ T T’ F E → T E’ TE’

55. FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n 1) A → α with α ≠ ε to T [ A, First (α) - {ε} ] FOLLOW EE’TT’F $)$) +$)+$) *+$)*+$) $)$) +$)+$) (n*+)$ ETE’ E’ T T’ F E’ → + T E’ +TE’

56. FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n 1) A → α with α ≠ ε to T [ A, First (α) - {ε} ] FOLLOW EE’TT’F $)$) +$)+$) *+$)*+$) $)$) +$)+$) (n*+)$ ETE’ E’+TE’ T T’ F T → F T’ FT’

57. FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n 1) A → α with α ≠ ε to T [ A, First (α) - {ε} ] FOLLOW EE’TT’F $)$) +$)+$) *+$)*+$) $)$) +$)+$) (n*+)$ ETE’ E’+TE’ TFT’ T’ F T’ → * F T’ *FT’

58. FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n 1) A → α with α ≠ ε to T [ A, First (α) - {ε} ] FOLLOW EE’TT’F $)$) +$)+$) *+$)*+$) $)$) +$)+$) (n*+)$ ETE’ E’+TE’ TFT’ T’*FT’ F F → ( E ) (E)

59. FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n 1) A → α with α ≠ ε to T [ A, First (α) - {ε} ] FOLLOW EE’TT’F $)$) +$)+$) *+$)*+$) $)$) +$)+$) (n*+)$ ETE’ E’+TE’ TFT’ T’*FT’ F(E) F → n n

60. FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n 1) A → α with α ≠ ε to T [ A, First (α) - {ε} ] 2) A → ε or A → α with α ═> * ε to T [ A, Follow (A) ] FOLLOW EE’TT’F $)$) +$)+$) *+$)*+$) $)$) +$)+$) (n*+)$ ETE’ E’+TE’ TFT’ T’*FT’ F(E)n E → ε εε

61. FIRSTEE’TT’F +ε+ε *ε*ε (n(n (n(n (n(n 1) A → α with α ≠ ε to T [ A, First (α) - {ε} ] 2) A → ε or A → α with α ═> * ε to T [ A, Follow (A) ] FOLLOW EE’TT’F $)$) +$)+$) *+$)*+$) $)$) +$)+$) (n*+)$ ETE’ E’+TE’εε TFT’ T’*FT’ F(E)n T’ → ε εεε

62. (n*+)$ ETE’ E’+TE’εε TFT’ T’*FT’εεε F(E)n Procedure E; If lookahead in {‘(‘, n} then T ; E’ else error Procedure E’; If lookahead =‘+’ then match (‘+’); T; E’ else if lookahead in {‘)’, $} then nothing else error Procedure F; If lookahead = ‘(‘ then match (‘(‘) ; E; match (‘)’) else if lookahead = n then match (n) else error

63. (n*+)$ ETE’ E’+TE’εε TFT’ T’*FT’εεε F(E)n E L A n T E’ F T’ n + +TE’ n F T’ n * *F n n$ $ ε ε ε Recursive Descendent Predictive Parsing Example

64. (n*+)$ ETE’ E’+TE’εε TFT’ T’*FT’εεε F(E)n stack input output $En+n*n$n+n*n$E → TE’ $E’Tn+n*n$n+n*n$T → FT’ $E’T’Fn+n*n$n+n*n$F → n $E’T’nn+n*n$n+n*n$ $E’T’+n*n$+n*n$T’ → ε $E’+n*n$+n*n$E’ → +TE’ Predictive Parsing Example non recursive $E’T++n*n$+n*n$ $E’Tn*n$n*n$T → FT’ $E’T’Fn*n$n*n$ F → n $E’T’nn*n$n*n$ $E’T’*n$*n$T → *FT’ $E’T’F**n$*n$ $E’T’Fn$n$F → n $E’T’nn$n$ $E’T’$T’ → ε $E’$E’ → ε $$OK

65. Predictive Parsing Example non recursive output E → TE’ T → FT’ F → n T’ → ε E’ → +TE’ T → FT’ T → *FT’ F → n T’ → ε E’ → ε OK F → n

66. output E → TE’ T → FT’ F → n T’ → ε E’ → +TE’ Predictive Parsing Example non recursive T → FT’ T → *FT’ F → n T’ → ε E’ → ε OK E T E’ F T’ n +TE’ F T’ n *F n $ ε ε ε F → n LL(1) 1 lookahead input symbol Leftmost derivation Input from the left

67. A definitely bad example S → if c then S | if c then S else S | o S S ifcthenelseoifcthen o ifcthenSelseSifcthen S elseSifcthenSifcthenS oooo

68. A definitely bad example S → if c then S | if c then S else S | o ifcthenelseoifcthen o headache study pill have it YesNo Yes No () if c then if c then o else o

69. A definitely bad example S → if c then S | if c then S else S | o ifcthenelseoifcthen o headache pill have it Yes No Yes No () if c then if c then o else o study

70. ifoelse$ S R FIRSTSR else ε if o $ else FOLLOW SR A definitely bad example: ambiguous grammar 1:S → if c then S R 2:S → o 3:R → else S 4:R → ε $ else 12 43 4 Not LL(1)

71. Another definitely bad example S → P d | Q e P → a P c | b Q → a Q d | b S Pd b Pca Pca S Qe b Qda Qda a n b c n da n b d n e

72. Lexical Analyzer … b S → P d | Q e P → a P c | b Q → a Q d | b S Pd b Pca Pca S Qe b Qda Qda aa Another definitely bad example

73. S → P d | Q e P → a P c | b Q → a Q d | b First (P) = { a, b } First (Q) = { a, b } First (Pd) = { a, b } First (Qe) = { a, b } PPTabcde$ S PaPcb QaQdb Pd Another definitely bad example Pd Qe Not LL(1)

74. G ambiguous => not LL(1) G left recursive => not LL(1) G not left factorised => not LL(1) Grammars LL(1) ambiguous left recursive not left fact. LL(1) Grammars

75. The good case No left recursion No left factor problems No ambiguity And more Predictive parsing Only one symbol to decide : LL(1) grammars

76. A complete example

77. FIRSTSABCD +ε+ε *ε*ε (n(n (n(n (n(n S → ABCD | ABC A → + T E’ | ε T → F T’ T’ → * F T’ | ε F → ( E ) | n FOLLOW SABCD $)$) +$)+$) *+$)*+$) $)$) +$)+$) (n*+)$ STE’ A+TE’εε BFT’ C*FT’ D(E)n T’ → ε εεε