1. Compiler Construction
Sohail Aslam
Lecture 20
compiler: Bottom-up Parsing

2. Bottom-up Parsing
Bottom-up parsing is more general than top-down parsing
Bottom-up parsers handle a large class of grammars.
Preferred method in practice
This is a note
compiler: Bottom-up Parsing

3. Bottom-up Parsing
Bottom-up parsing is more general than top-down parsing
Bottom-up parsers handle a large class of grammars.
Preferred method in practice
This is a note
compiler: Bottom-up Parsing

4. Bottom-up Parsing
Bottom-up parsing is more general than top-down parsing
Bottom-up parsers handle a large class of grammars.
Preferred method in practice
This is a note
compiler: Bottom-up Parsing

5. Bottom-up Parsing Also called LR parsing
L means that tokens are read left to right
R means that the parser constructs a rightmost derivation.

6. Bottom-up Parsing Also called LR parsing
L means that tokens are read left to right
R means that the parser constructs a rightmost derivation.

7. Bottom-up Parsing Also called LR parsing
L means that tokens are read left to right
R means that the parser constructs a rightmost derivation.

8. Bottom-up Parsing LR parsers donot need left-factored grammars
LR parsers can handle left-recursive grammars

9. Bottom-up Parsing LR parsers donot need left-factored grammars
LR parsers can handle left-recursive grammars

10. Bottom-up Parsing
LR parsing reduces a string to the start symbol by inverting productions.

11. Bottom-up Parsing A derivation consists of a series of rewrite steps
S  g0  g1  ...  gn-1  gn  sentence

12. Bottom-up Parsing S  g0  ...  gn  sentence
Each gi is a sentential form
if g contains only terminals, g is a sentence in L(G)
If g contains  1 nonterminals, g is a sentential form

13. Bottom-up Parsing S  g0  ...  gn  sentence
Each gi is a sentential form
if g contains only terminals, g is a sentence in L(G)
If g contains  1 nonterminals, g is a sentential form

14. Bottom-up Parsing S  g0  ...  gn  sentence
Each gi is a sentential form
if g contains only terminals, g is a sentence in L(G)
If g contains  1 nonterminals, g is a sentential form

15. Bottom-up Parsing
A bottom-up parser builds a derivation by working from input sentence back towards the start symbol S
S  g0  ...  gn  sentence

16. Bottom-up Parsing
Consider the grammar S → aABe A → Abc | b B → d

17. Bottom-up Parsing
The sentence abbcde can be reduced to S: abbcde aAbcde aAde aABe S

18. Bottom-up Parsing
The sentence abbcde can be reduced to S: abbcde aAbcde aAde aABe S

19. Bottom-up Parsing
The sentence abbcde can be reduced to S: abbcde aAbcde aAde aABe S

20. Bottom-up Parsing
The sentence abbcde can be reduced to S: abbcde aAbcde aAde aABe S

21. Bottom-up Parsing
The sentence abbcde can be reduced to S: abbcde aAbcde aAde aABe S

22. Bottom-up Parsing
These reductions, in fact, trace out the following right-most derivation in reverse: S  aABe  aAde  aAbcde  abbcde

23. S  aBy  agy  xy rm rm rm S
rule: B → g B a g x x y
Terminals only

24. Bottom-up Parsing
Consider the grammar
1. E → E + (E)
| int

25. Bottom-up Parsing Consider bottom-up parse of the string
int + (int) + (int)

26. int + (int) + (int)
int + (
int ) + (
int )

27. int + (int) + (int)
E + (int) + (int) E
int + (
int ) + (
int )

28. int + (int) + (int) E + (int) + (int) E + (E) + (int) E E int + ( int

29. int + (int) + (int) E + (int) + (int) E + (E) + (int) E + (int) E E E

30. int + (int) + (int) E + (int) + (int) E + (E) + (int) E + (int)

31. int + (int) + (int) E + (int) + (int) E + (E) + (int) E + (int)
A rightmost derivation in reverse
int + (int) + (int)
E + (int) + (int)
E + (E) + (int)
E + (int)
E + (E) E E E E E
int + (
int ) + (
int )

32. Bottom-up Parsing
An LR parser traces a rightmost derivation in reverse

33. Consequence Let abg be a step of a bottom-up parse
Assume that next reduction is A → b
Then g is a string of terminals!

34. Consequence Let abg be a step of a bottom-up parse
Assume that next reduction is A → b
Then g is a string of terminals!

35. Consequence Let abg be a step of a bottom-up parse
Assume that next reduction is A → b
Then g is a string of terminals!

36. Consequence
Why?
Because aAg → abg is a step in a rightmost derivation

37. Notation
Idea:
Split the string into two substrings

38. Notation
Right substring (a string of terminals) is as yet unexamined by parser
Left substring has terminals and non-terminals

39. Notation
Right substring (a string of terminals) is as yet unexamined by parser
Left substring has terminals and non-terminals

40. Notation The dividing point is marked by a ►
The ► is not part of the string
Initially, all input is unexamined: ►x1 x xn

41. Shift-Reduce Parsing 1. Shift 2. Reduce
Bottom-up parsing uses only two kinds of actions:
1. Shift 2. Reduce

42. Shift Move ► one place to the right
shifts a terminal to the left string
E + (► int)  E + (int ►)

43. Reduce
Apply an inverse production at the right end of the left string. If E → E + (E) is a production, then
E + ( E+(E)►)  E + ( E ►)

44. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

45. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

46. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

47. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

48. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

49. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

50. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

51. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

52. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

53. Shift-Reduce Example ►int + (int) + (int) $ shift
reduce E → int
E ► + (int) + (int) $
shift 3 times
E + (int ►) + (int) $
E + (E ►) + (int) $
E + (E) ► + (int) $
reduce E → E+(E)

54. Shift-Reduce Example E ► + (int) $ shift 3 times E + (int ►) $
reduce E → int
E + (E ►) $
shift
E + (E) ► $
red E → E+(E)
E ► $
accept