1. 1 Nonrecursive Predictive Parsing  It is possible to build a nonrecursive predictive parser  This is done by maintaining an explicit stack

2. 2 Nonrecursive Predictive Parsing  It is possible to build a nonrecursive predictive parser  This is done by maintaining an explicit stack

3. 3 Table-driven Parsers  The nonrecursive LL(1) parser looks up the production to apply by looking up a parsing table

4. 4 Table-driven Parsers LL(1) table:  One dimension for current non-terminal to expand  One dimension for next token  Table entry contains one production

5. 5 Table-driven Parsers LL(1) table:  One dimension for current non-terminal to expand  One dimension for next token  Table entry contains one production

6. 6 Table-driven Parsers LL(1) table:  One dimension for current non-terminal to expand  One dimension for next token  Table entry contains one production

7. 7 Consider the expression grammar 1E → T E' 2E' → + T E' 3 |  4T → F T' 5T' → * F T' 6 |  7F → ( E ) 8 | id

8. 8 Predictive Parsing Table id +*()$ EE → TE' E'E' → +TE' E' →  TT → FT' T' T' →  T → *FT' T' →  FF → idF → (E ) Rows for current non-terminal to expand Columns for next token

9. 9 Predictive Parsing Table id +*()$ EE → TE' E'E' → +TE' E' →  TT → FT' T' T' →  T → *FT' T' →  FF → idF → (E ) Table entries are productions Blank entries are errors

10. 10 Predictive Parsers  The predictive parser uses an explicit stack to keep track of pending non- terminals  It can thus be implemented without recursion.

11. 11 Predictive Parsers  The predictive parser uses an explicit stack to keep track of pending non- terminals  It can thus be implemented without recursion.

12. 12 Predictive Parsers a + b$ Predictive parser stack X Y Z $ Parsing table M input output

13. 13 LL(1) Parsing Algorithm  The input buffer contains the string to be parsed; $ is the end-of-input marker  The stack contains a sequence of grammar symbols

14. 14 LL(1) Parsing Algorithm  Initially, the stack contains the start symbol of the grammar on the top of $.

15. 15 LL(1) Parsing Algorithm The parser is controlled by a program that behaves as follows:

16. 16 LL(1) Parsing Algorithm  The program considers X, the symbol on top of the stack, and a, the current input symbol.

17. 17 LL(1) Parsing Algorithm  These two symbols, X and a determine the action of the parser.  There are three possibilities.

18. 18 LL(1) Parsing Algorithm  These two symbols, X and a determine the action of the parser.  There are three possibilities.

19. 19 LL(1) Parsing Algorithm 1. X  a  $, the parser halts and annouces successful completion.

20. 20 LL(1) Parsing Algorithm 2. X  a  $ the parser pops X off the stack and advances input pointer to next input symbol

21. 21 LL(1) Parsing Algorithm 3. If X is a nonterminal, the program consults entry M [ X, a ] of parsing table M.

22. 22 LL(1) Parsing Algorithm If the entry is a production M [ X, a ] = { X → UVW } the parser replaces X on top of the stack by WVU (with U on top).

23. 23 LL(1) Parsing Algorithm As output, the parser just prints the production used: X → UVW However, any other code could be executed here.

24. 24 LL(1) Parsing Algorithm If M [ X, a ] =error, the parser calls an error recovery routine

25. 25 LL(1) Parsing Algorithm Example: Let’s parse the input string id+id  id using the nonrecursive LL(1) parser

26. 26 id E +  $ $ stack Parsing Table M

27. 27 Predictive Parsing Table id +*()$ EE → TE' E'E' → +TE' E' →  TT → FT' T' T' →  T → *FT' T' →  FF → idF → (E )

28. Compiler Construction Sohail Aslam Lecture 17

29. 29 id E +  $ $ stack Parsing Table M E → TE'

30. 30 id+  $ $ stack Parsing Table M T → T E' FT'

31. 31 T' id+  $ $ stack Parsing Table M → E' F F id

32. 32 T' id+  $ $ stack Parsing Table M E' id

33. 33 T' +id  $ $ stack Parsing Table M → E' T'  id

34. 34 +id  $ $ stack Parsing Table M → E' + id E' T

35. 35 +id  $ $ stack Parsing Table M E' + id T

36. 36 StackInputOuput $E$E id+id  id$ $E' T id+id  id$ E → TE' $E' T' F id+id  id$ T → FT' $E'T' id id+id  id$ F → id $E' T' +id  id$ $E' +id  id$T' →  $E' T + +id  id$ E' → +TE'

37. 37 StackInputOuput $E' T id  id$ $E' T' F id  id$ T → FT' $E' T' id id  id$ F → id $E' T'  id$ $E' T' F  id$T →  FT' $E' T' Fid$ $E'T' idid$F → id

38. 38 StackInputOuput $E' T'$ $E'$ T' →  $$ E' → 

39. 39 LL(1) Parsing Algorithm  Note that productions output are tracing out a lefmost derivation  The grammar symbols on the stack make up left- sentential forms

40. 40 LL(1) Parsing Algorithm  Note that productions output are tracing out a lefmost derivation  The grammar symbols on the stack make up left- sentential forms

41. 41 LL(1) Table Construction  Top-down parsing expands a parse tree from the start symbol to the leaves  Always expand the leftmost non-terminal

42. 42 LL(1) Table Construction  Top-down parsing expands a parse tree from the start symbol to the leaves  Always expand the leftmost non-terminal

43. 43 id+id  id E T E' F id T'  E' T + and so on....

44. 44 E T E' F id T'  E' T + The leaves at any point form a string  A 

45. 45 E T E' F id T'  E' T +  only contains terminals

46. 46 E T E' F id T'  + E' T id + id  id  b  input string is  b  The prefix  matches Next token is b

47. 47 LL(1) Table Construction  Consider the state S →   A  with b the next token and we are trying to match  b   There are two possibilities

48. 48 LL(1) Table Construction  Consider the state S →   A  with b the next token and we are trying to match  b   There are two possibilities

49. 49 LL(1) Table Construction 1.b belongs to an expansion of A Any A →  can be used if b can start a string derived from 

50. 50 LL(1) Table Construction 1.b belongs to an expansion of A Any A →  can be used if b can start a string derived from 

51. 51 LL(1) Table Construction In this case we say that b  FIRST(  )

52. 52 LL(1) Table Construction 2.b does not belong to an expansion of A Expansion of A is empty, i.e., A →  and b belongs an expansion of , e.g., b 

53. 53 LL(1) Table Construction 2.b does not belong to an expansion of A Expansion of A is empty, i.e., A →  and b belongs an expansion of , e.g., b 

54. 54 LL(1) Table Construction which means that b can appear after A in a derivation of the form S →   Ab 

55. 55 LL(1) Table Construction We say that b  FOLLOW(A)

56. 56 LL(1) Table Construction Any A →  can be used if  expands to  We say that   FIRST(A) in this case

57. 57 Computing FIRST Sets Definition FIRST(X) = { b | X →  ba }  {  | X →   }