0% found this document useful (0 votes)
35 views32 pages

lr2 LR - 0 Parsing

This document discusses LR parsing which is a bottom-up parsing technique. It explains the concepts of items, configurations, closure, successor configurations and how these are used to construct the parsing table through the sets-of-items algorithm.

Uploaded by

Sita kumar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
35 views32 pages

lr2 LR - 0 Parsing

This document discusses LR parsing which is a bottom-up parsing technique. It explains the concepts of items, configurations, closure, successor configurations and how these are used to construct the parsing table through the sets-of-items algorithm.

Uploaded by

Sita kumar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 32

LR2: LR(0) Parsing

LR Parsing
CMPT 379: Compilers
Instructor: Anoop Sarkar
anoopsarkar.github.io/compilers-class
Top-Down vs. Bottom Up
Grammar: S ® A B Input String: ccbca
A®c|e
B ® cbB | ca

Top-Down/leftmost Bottom-Up/rightmost
S Þ AB S®AB ccbca Ü Acbca A®c
Þ cB A®c Ü AcbB B®ca
Þ ccbB B®cbB Ü AB B®cbB
Þ ccbca B®ca ÜS S®AB
2
Rightmost derivation for
id + id * id rightmost derivation step

E®E+E E Þrm E * E
E®E*E Þrm E * id
Þrm E + E * id
E®(E)
Þrm E + id * id
E®-E reduce with E ® id
Þrm id + id * id
E ® id shift

E Þ*rm E ‘+’ E ‘*’ id


3
LR parsing overview
• Start from terminal symbols, search for a path to the start symbol
• Apply shift and reduce actions (postpone decisions when possible)
• LR parsing:
• L: left to right parsing
• R: rightmost derivation (in reverse or bottom-up)

• LR(0) ® SLR(1) ® LR(1) ® LALR(1)


• 0 or 1 or k lookahead symbols

4
S Þ*rm 00S11
Actions in Shift-Reduce Parsing 00S11 Þrm 000111
Grammar: a = 00
• Shift S®0S1 w = 01
• add terminal to parse stack, advance input S®01 b = 11

• Reduce
• If aw is on the stack, a,w Î (N U T)* and A® w, and there is a b Î T* such
that S Þ*rm aAb Þrm awb then we can reduce aw to aA on the stack (called
pruning the handle w)
• aw is a viable prefix
• Error 0S1 Þrm 00S11 S Þrm 0S1
Grammar: a=e
• Accept a=0
S®0S1 w = 0S1
w = 0S1
S®01 b=e
b=1
5
Questions
• When to shift/reduce?
• What are valid handles?
• Ambiguity: Shift/reduce conflict
• If reducing, using which production?
• Ambiguity: Reduce/reduce conflict

6
Table-based Shift Reduce Parsing
LR Parsing
• Table-based parser
• Creates rightmost derivation (in reverse)
• Works with left- and right- recursive context-free grammars

• Data structures:
• Stack of states/symbols {s}
• Action table: action[s, a]; a Î T
• Goto table: goto[s, X]; X Î N

8
Action S5: shift to state 5 Goto
Action/Goto Table
Productions * ( ) id $ T F
1 T®F
0 S5 S8 2 1
2 T ® T*F
3 F ® id 1 R1 R1 R1 R1 R1
4 F ® (T) 2 S3 Acc!
3 S5 S8 4
R1: reduce using rule 1
4 R2 R2 R2 R2 R2
5 S5 S8 6 1
6 S3 S7
7 R4 R4 R4 R4 R4
8 R3 R3 R3 R3 R3 9
Trace “(id)*id”
Productions Stack Input Action/Goto
1 T®F 0 is the 0 ( id ) * id $ Shift S5
2 T ® T*F start state
05 id ) * id $ Shift S8
3 F ® id
058 ) * id $ Reduce 3 F®id,
4 F ® (T) pop 8, goto [5,F]=1
* ( ) id $ T F 051 ) * id $ Reduce 1 T® F,
0 S5 S8 2 1 pop 1, goto [5,T]=6
1 R1 R1 R1 R1 R1 056 ) * id $ Shift S7
2 S3 A 0567 * id $ Reduce 4 F® (T),
3 S5 S8 4
pop 7 6 5, goto [0,F]=1
4 R2 R2 R2 R2 R2
01 * id $ Reduce 1 T ® F
5 S5 S8 6 1
6 S3 S7
pop 1, goto [0,T]=2
7 R4 R4 R4 R4 R4
10
8 R3 R3 R3 R3 R3
Trace “(id)*id”
Productions Stack Input Action/Goto
1 T®F
01 * id $ Reduce 1 T®F,
2 T ® T*F
pop 1, goto [0,T]=2
3 F ® id 02 * id $ Shift S3
4 F ® (T) 023 id $ Shift S8
* ( ) id $ T F 0238 $ Reduce 3 F®id,
0 S5 S8 2 1 pop 8, goto [3,F]=4
1 R1 R1 R1 R1 R1 0234 $ Reduce 2 T®T * F
2 S3 A pop 4 3 2, goto [0,T]=2
3 S5 S8 4
02 $ Accept
4 R2 R2 R2 R2 R2
5 S5 S8 6 1
6 S3 S7
7 R4 R4 R4 R4 R4
11
8 R3 R3 R3 R3 R3
Tracing LR: action[s, a]
• case shift u:
• push state u
• read new a
• case reduce r:
• lookup production r: X ® Y1..Yk;
• pop k states, find state u
• push goto[u, X]
• case accept: done
• no entry in action table: error
12
Algorithm to build the Action/Goto table
Configuration set
• Each set is a parser state
• We use the notion of a dotted rule or item:
T®T*•F
• The dot is before F, so we predict all rules with F as the left-hand side
T®T*•F
F®•(T)
F ® • id
• This creates a configuration set (or item set)
• Like NFA-to-DFA conversion

14
Closure
Closure property:
• If T ® X1 … Xi • Xi+1 … Xn is in set, and Xi+1 is a nonterminal, then
Xi+1 ® • Y1 … Ym is in the set as well for all productions Xi+1 ® Y1 … Ym
• Compute as fixed point
• The closure property creates a configuration set (item set) from a
dotted rule (item).

15
Starting Configuration
• Augment Grammar with S’
• Add production S’ ® S
• Initial configuration set is
closure(S’ ® • S)

16
Example: I = closure(S’ ® • T)

S’ ® T
T®F|T*F
F ® id | ( T )

17
Example: I = closure(S’ ® • T)

S’ ® • T
T®•T*F S’ ® T
T®F|T*F
T®•F
F ® id | ( T )
F ® • id
F®•(T)

18
Successor(I, X)
Informally: “move by symbol X”
1. move dot to the right in all items where dot is before X
2. remove all other items
(viable prefixes only!)

3. compute closure

19
Successor Example
I = {S’ ® • T, S’ ® T
T ® • F, T®F|T*F
T ® • T * F, F ® id | ( T )
F ® • id,
F®•(T)}
Compute Successor(I, ‘(‘)
{ F ® ( • T ), T ® • F, T ® • T * F,
F ® • id, F ® • ( T ) }
20
Sets-of-Items Construction
Family of configuration sets
function items(G’)
C = { closure({S’ ® • S}) };
do foreach I Î C do
foreach X Î (N È T) do
C = C È { Successor(I, X) };
while C changes;

21
Productions Reduce 1
F
1 T®F F 1: T ® F •
2 T ® T*F
3 F ® id $ Accept Reduce 2
4 F ® (T)
2: S’ ® T • 4: T ® T * F •
T®T•*F
0: S’ ® • T T Reduce 3
id * F
T®•F 8: F ® id •
T®•T*F 3: T ® T * • F id
F ® • id F ® • id id
F®•(T) F®•(T) ( 5: F ® ( • T )
T®•F
7: F ® ( T ) • ) * T®•T*F
( Reduce 4 F ® • id
6: F ® ( T • ) T F®•(T)
T®T•*F
(
22
Productions Reduce 1
F
1 T®F F 1: T ® F •
2 T ® T*F
3 F ® id
$ Accept Reduce 2
4 F ® (T)
2: S’ ® T • 4: T ® T * F •
T®T•*F
0: S’ ® • T T Reduce 3
id * F
T®•F 8: F ® id •
* ( ) T ®$ • TT* F F
id 3: T ® T * • F id
0 S5 F ® • id2 1
S8
F ® • id id
1 R1 R1 R1 R1 F ®R1• ( T ) F®•(T) ( 5: F ® ( • T )
2 S3 A
3 S5 S8 4 T®•F
4 R2 R2 R2 R2 R2
7: F ® ( T ) • ) * T®•T*F
5 S5 (
S8 6 1
Reduce 4 F ® • id
6: F ® ( T • ) T
6 S3 S7 F®•(T)
7 R4 R4 R4 R4 R4 T®T•*F
8 R3 R3 R3 R3 R3 (
23
LR(0) Construction
1. Construct F = {I0, I1, …In}
2. a) if {A ® a•} Î Ii and A != S’
then action[i, _] := reduce A ® a
b) if {S’ ® S•} Î Ii
then action[i,$] := accept
c) if {A ® a•ab} Î Ii and Successor(Ii,a) = Ij
then action[i,a] := shift j
3. if Successor(Ii,A) = Ij then goto[i,A] := j

24
LR(0) Construction (cont’d)
4. All entries not defined are errors
5. Make sure I0 is the initial state

• Note: LR(0) always reduces if


{A ® a•} Î Ii, no lookahead
• Shift and reduce items can’t be in the same configuration set
• Accepting state doesn’t count as reduce item
• At most one reduce item per set

25
Set-of-items with Epsilon rules
1: S ® AaAb S’ ® •S S S’ ® S•
2: S ® BbBa S ® •AaAb
3: A ® e S ® •BbBa
B S ® B•bBa
4: B ® e A ® e•
B ® e•
S ® Bb•Ba
S ® A•aAb b
A B ® e•
a S ® Aa•Ab B
A ® e• S ® BbB•a
S ® AaA•b A a
S ® BbBa•
b S ® AaAb• 26
No conflict R/R conflict
No conflict
Set-of-items with Epsilon rules
1: S ® AaAb S’ ® •S S S’ ® S•
2: S ® BbBa S ® •AaAb
3: A ® e S ® •BbBa
B S ® B•bBa
4: B ® e A ® e• R3
B ® e• R4
S ® Bb•Ba
S ® A•aAb b
A B ® e• R4
a S ® Aa•Ab B
A ® e• R3 S ® BbB•a
S ® AaA•b A a
S ® BbBa•
b S ® AaAb• 27
LR(0) conflicts:

S’ ® T 1: F ® id •
F ® id • = T
T®F
T®T*F Shift/reduce conflict
T ® id
1: F ® id •
F ® id | ( T )
T ® id •
F ® id = T ;
Reduce/Reduce conflict

Need more lookahead: SLR(1)


28
Viable Prefixes
• γ is a viable prefix if there is some ω such that γ|ω is a state of a shift-reduce parser
stack γ|ω rest of input
• Important fact: A viable prefix is a prefix of a handle
• An LR(0) item [X® a • b] says that
• a is on top of the stack (a is a suffix of γ)
• The parser is looking for an X
• Expects to find input string derived from b

• We can recognize viable prefixes via a NFA (DFA)


• States of NFA are LR(0) items
• States of DFA are sets of LR(0) items

29
LR(0) Grammars
• An LR(0) grammar is a CFG such that the LR(0) construction produces
a table without conflicts (a deterministic pushdown automata)
• S Þ*rm aAb Þrm awb and A ® w then we can prune the handle w
• pruning the handle means we can reduce aw to aA on the stack

• Every viable prefix aw can be recognized using the DFA built by the
LR(0) construction

30
LR(0) Grammars
• Once we have a viable prefix on the stack, we can prune the handle and then
restart the DFA to obtain another viable prefix, and so on ...
• In LR(0) pruning the handle can be done without any look-ahead
• this means that in the rightmost derivation,
• S Þ*rm aAb Þrm awb we reduce using a unique rule A ® w without ambiguity, and without
looking at b

• No ambiguous context-free grammar can be LR(0)

LR(0) Grammars Ì Context-free Grammars


31
Parsing - Roadmap
• Parser:
• decision procedure: builds a parse tree
• Top-down vs. bottom-up
• LL(1) – Deterministic Parsing
• recursive-descent
• table-driven
• LR(k) – Deterministic Parsing
• LR(0), SLR(1), LR(1), LALR(1)
• Parsing arbitrary CFGs – Polynomial time parsing

32

You might also like