BOTTOM UP PARSING

Bottom-up parsing
 Goal of parser : build a derivation
 Top-down parser : build a derivation by working from
the start symbol towards the input.
 Builds parse tree from root to leaves
 Builds leftmost derivation
 Bottom-up parser : build a derivation by working from
the input back toward the start symbol
 Builds parse tree from leaves to root
 Builds reverse rightmost derivation
Bottom-up parsing
 The parser looks for a substring of the parse tree's
frontier...
 ...that matches the rhs of a production and
 ...whose reduction to the non-terminal on the lhs
represents on step along the reverse of a rightmost
derivation
 Such a substring is called a handle.
 Important:
 Not all substrings that match a rhs are handles.
Bottom-up parsing techniques
 Shift-reduce parsing
 Shift input symbols until a handle is found. Then,
reduce the substring to the non-terminal on the lhs of
the corresponding production.
 Operator-precedence parsing
 Based on shift-reduce parsing.
 Identifies handles based on precedence rules.
Example: Shift-reduce parsing
 Grammar:
1. S  S+S
2. S  S-S
3. S  (S)
4. S  a

Input to parse:
a1-(a2+a3)
Example: Shift-reduce parsing
 Grammar:
1. E  2E2
2. E  3E3
3. E  4

Input to parse:
32423
 Example: Shift-reduce parsing
STACK ACTION
$ Shift
Grammar:
$ id1 Reduce (rule 5)
1. S  E
2. E  E+E $E Shift
3. E  E*E
$E+ Shift
4. E  num
5. E  id $ E + num Reduce (rule 4)
$E+E Shift
$E+E* Shift
$ E + E * id2 Reduce (rule 5)
Input to parse:
id1 + num * id2 $E+E*E Reduce (rule 3)
$E+E Reduce (rule 2)

Handles: $E Reduce (rule 1)

underlined $S Accept
 Shift-Reduce parsing
 A shift-reduce parser has 4 actions:
 Shift -- next input symbol is shifted onto the stack
 Reduce -- handle is at top of stack
 pop handle
 push appropriate lhs
 Accept -- stop parsing & report success
 Error -- call error reporting/recovery routine
Shift-Reduce parsing
 How can we know when we have found a
handle?
 Analyze the grammar beforehand.
 Build tables
 Look ahead in the input
 LR(1) parsers recognize precisely those
languages in which one symbol of look-ahead is
enough to determine whether to reduce or shift.
 L : for left-to-right parse of the input
 R : for reverse rightmost derivation
 1: for one symbol of lookahead
How does it work?
 Read input, one token at a time
 Use stack to keep track of current state
 The state at the top of the stack summarizes the
information below.
 The stack contains information about what has been
parsed so far.
 Use parsing table to determine action based on
current state and look-ahead symbol.
 How do we build a parsing table?
LR parsing techniques
 SLR (not in the book)
 Simple LR parsing
 Easy to implement, not strong enough
 Uses LR(0) items
 Canonical LR
 Larger parser but powerful
 Uses LR(1) items
Bottom-up Parser Table
Construction
Overview
How to construct parsing table?
• Steps:
– Augment the given grammar.
– Draw Conical collection of LR(0) items.
– Number the production
– Create parsing table.
 Example 1
• S ->AB
• A -> a
• B -> b

• Step 1: Create Augmented Grammar

– S’->S
– S ->AB
– A -> a
– B -> b
 How to construct parsing
table?...
• Step 2: Call the closure
1
Accepted
S’->.S
S ->.AB S S’->S.
A ->.a
A
0
2 4
We haven't
considered S ->A.B B
B -> b S ->AB.
B because .
Is before A
a
3 5
b
A ->a. B -> b.
 Parsing Table
Action Goto
a b $ S A B
0 S3 1 2
1 accepted
2 S5 4
3 r2 r2 r2

4 r1 r1 r1

5 r3 r3 r3

1. S ->AB
2. A -> a Step 3
3. B -> b
 Example 2

Augmented Grammar:
Example 2: Solution
Example 2: Solution
 Example 3

Grammar

Parsing Table
 Example 3

Input: aabb$

Stack