Bottom-Up Syntax Analysis

# Bottom-Up Syntax Analysis

Télécharger la présentation

## Bottom-Up Syntax Analysis

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Bottom-Up Syntax Analysis Mooly Sagiv http://www.cs.tau.ac.il/~msagiv/courses/wcc11-12.html Textbook:Modern Compiler Design Chapter 2.2.5 (modified)

2. Pushdown automata Deterministic Report an error as soon as the input is not a prefix of a valid program Not usable for all context free grammars context free grammar tokens parser Efficient Parsers cup “Ambiguity errors” parse tree

3. Top-Down (Predictive Parsing) LL Construct parse tree in a top-down matter Find the leftmost derivation For every non-terminal and token predict the next production Bottom-Up LR Construct parse tree in a bottom-up manner Find the rightmost derivation in a reverse order For every potential right hand side and token decide when a production is found Kinds of Parsers

4. Input A context free grammar A stream of tokens Output A syntax tree or error Method Construct parse tree in a bottom-up manner Find the rightmost derivation in (reversed order) For every potential right hand side and token decide when a production is found Report an error as soon as the input is not a prefix of valid program Bottom-Up Syntax Analysis

5. Pushdown automata Bottom-up parsing (informal) Non-deterministic bottom-up parsing Deterministic bottom-up parsing Interesting non LR grammars Plan

6. Pushdown Automaton input u t w \$ V control parser-table \$ stack

7. stack tree input \$ i + i \$ stack tree input + i \$ i\$ i Informal Example(1) S  E\$E  T | E + TT i|(E) shift

8. stack tree input T\$ T + i \$ i i Informal Example(2) S  E\$E  T | E+TT i|( E) stack tree input i\$ + i \$ reduceT i

9. T stack tree input E E\$ + i \$ T i i Informal Example(3) S  E\$E  T | E+TT i | ( E) stack tree input T\$ + i \$ reduce E  T

10. E stack tree input +E\$ E i \$ T T i i + Informal Example(4) S  E\$E  T| E+TT i|(E) stack tree input E\$ + i \$ shift

11. E stack tree input E i+E\$ \$ T T + i i i + Informal Example(5) S  E\$E  T| E+TT i|(E) stack tree input +E\$ i \$ shift

12. stack tree input E T+E\$ \$ T T T i i + + i i Informal Example(6) S  E\$E  T| E+TT i|(E) stack tree input E i+E\$ \$ reduce T i

13. stack tree input E \$ E\$ E T T T i i i + + Informal Example(7) S  E\$E  T| E+TT i|(E) stack tree input E \$ T T+E\$ reduce E E+T i

14. stack tree input E \$E \$ E T T T i i i + + Informal Example(8) S  E\$E  T| E+TT i|(E) stack tree input E \$ E\$ E T shift i

15. T i + Informal Example(9) S  E\$E  T| E+TT i|(E) stack tree input E \$ \$E \$ E T i reduce S  E\$

16. Informal Example reduce S  E\$ reduce E  E+T reduce T i reduce E  T reduce T  i

17. The Problem • Deciding between shift and reduce

18. stack tree input E \$ E\$ E T T T i i i + + Informal Example(7) S  E\$ E  T | E+T T i| (E) stack tree input E \$ T T+E\$ reduce E E + T i

19. E E T T E i i i + + Informal Example(7’) S  E\$ E  T | E+T T i|( E) stack tree input E \$ T T+E\$ reduce E  T stack tree input \$ E+E\$ 

20. still need to be matched already matched regularexpression input input T· expecting to match  already matched  Bottom-UP LR(0) Items

21. S  E\$ E  T E  E+ T T i T (E)

22. stack input 6: E E+T 1: S E\$ i + i \$ Formal Example(1) S  E\$ E  T | E+TT i| (E) stack input 1: S E\$ i + i \$ -move 6

23. stack stack input input 4: E T 6: E E+T 1: S E\$ 6: E E+T 1: S E\$ i + i \$ i + i \$ Formal Example(2) S  E\$ E  T | E+T T i|(E) -move 4

24. stack stack input input 10: T  i 4: E T 6: E E+T 1: S E\$ 4: ET 6: E E+T 1: S E\$ i + i \$ i + i \$ Formal Example(3) S  E\$ E  T | E+TT i |(E) -move 10

25. stack input 11: T i 10: T  i 4: E T 6: E E+T 1: S E\$ + i \$ Formal Example(4) S  E\$ E  T | E+T T i|(E) stack input 10: T  i 4: E T 6: E E+T 1: S E\$ i + i \$ shift 11

26. stack input 5: E  T 4: E T 6: E E+T 1: S E\$ + i \$ Formal Example(5) S  E\$ E T | E+ TT i|(E) stack input 11: T i 10: T  i 4: E T 6: E E+T 1: S E\$ + i \$ reduce T i

27. stack stack input input 7: E  E+T 6: E E+T 1: S E\$ 5: E  T 4: E T 6: E E+T 1: S E\$ + i \$ + i \$ Formal Example(6) S  E\$ E  T | E+ T T i|(E) reduce E  T

28. stack stack input input 8: E  E+T 7: E  E+T 6: E E+T 1: S E\$ 7: E  E+T 6: E E+T 1: S E\$ i \$ + i \$ Formal Example(7) S  E\$ E  T| E+TT i| (E) shift 8

29. stack input 10: T i 8: E  E+T 7: E  E+T 6: E E+T 1: S E\$ i \$ stack input 8: E  E+T 7: E  E+T 6: E E+T 1: S E\$ i \$ Formal Example(8) S  E\$ E  T | E+T T i| (E) -move 10

30. stack input 11: T i  10: T i 8: E  E+T 7: E  E+T 6: E E+T 1: S E\$ stack input \$ 10: T i 8: E  E+T 7: E  E+T 6: E E+T 1: S E\$ i \$ Formal Example(9) S  E\$ E  T | E+T T i| (E) shift 11

31. stack input 9: E  E+T  8: E  E+T 7: E  E+T 6: E E+T 1: S E\$ \$ Formal Example(10) S  E\$ E  T| E+ T T i|( E) stack input 11: T i  10: T i 8: E  E+T 7: E  E+T 6: E E+T 1: S E\$ \$ reduce T i

32. stack input 2: S E \$ 1: S E\$ \$ Formal Example(11) S  E\$ E  T | E+T T i|(E) stack input 9: E  E+T  8: E  E+T 7: E  E+T 6: E E+T 1: S E\$ \$ reduce E  E+T

33. stack input 3: S E \$  2: S E \$ 1: S E\$ Formal Example(12) S  E\$ E  T |E+TT i| (E) stack input 2: S E \$ 1: S E\$ \$ shift 3

34. Formal Example(13) S  E\$ E  T | E+T T i|(E) stack input 3: S E \$  2: S E \$ 1: S E\$ reduce S  E\$

35. But how can this be done efficiently? Deterministic Pushdown Automaton

36. 3 2 1 Handles • Identify the leftmost node (nonterminal) that has not been constructed but all whose children have been constructed input t1 t2 t4 t5 t6 t7 t8

37. Identifying Handles • Create a deteteministic finite state automaton over grammar symbols • Sets of LR(0) items • Accepting states identify handles • Use automaton to build parser tables • reduce For items A on every token • shift For itemsA  t on token t • When conflicts occur the grammar is not LR(0) • When no conflicts occur use a DPDA which pushes states on the stack

38. A Trivial Example • S  A B \$ • A  a • B  a

39. S  E\$ E  T E  E+ T T i T (E)

40. 1 1: S E\$ 4: E T 6: E E +T 10: T i 12: T  (E) 2: S E \$ 7: E E +T 0 T 6 E 5: E T \$ i 2 5 3: S E \$  11: T i + ( i 7 13: T (E) 4: E T 6: E E +T 10: T i 12: T  (E) 3 8: E E +T 10: T i 12: T  (E) ( i ( E T 8 + 14: T (E ) 7: E E +T 9: E E +T  ) 4 15: T (E)  9

41. Example Control Table

42. input stack shift 5 0(\$) i + i \$

43. stack input 5 (i) 0 (\$) reduceT i + i \$

44. stack input 6 (T) 0 (\$) + i \$ reduce E  T

45. stack input shift 3 1(E) 0 (\$) + i \$

46. stack input shift 5 3 (+) 1(E) 0 (\$) i \$

47. stack input 5 (i) 3 (+) 1(E) 0(\$) reduce T i \$

48. input stack reduce E  E+T 4 (T) 3 (+) 1(E) 0(\$) \$

49. stack input 1 (E) 0 (\$) \$ shift 2

50. stack input 2 (\$) 1 (E) 0 (\$) accept