Lecture10 syntax analysis_6

Syntax Analysis V
Lecture 10
Syntax Analysis V
Bottom-Up Parsing

Viable Prefixes
• α is a viable prefix of a given grammar if:
– There is a such that αw is a right sentential form
• α | ω is a state of the shift-reduce parser
• As long as the parser has viable prefixes on the stack no• As long as the parser has viable prefixes on the stack no
parser error has been seen
• The set of viable prefixes is a regular language (not
obvious)
• Construct an automaton that accepts viable prefixes

LR(0) Items
• An LR(0) item of a grammar G is a production of G with a
special symbol “.” at some position of the right side
• • Thus production AXYZ gives four LR(0) items
A .XYZ
A X.YZ
A XY.ZA XY.Z
A XYZ.
• An item indicates how much of a production has been seen at
a point in the process of parsing
– Symbols on the left of “.” are already on the stack s
– Symbols on the right of “.” are expected in the input
• The only item for X ɛ is X .

Viable Prefixes and LR(0) Items
• Consider the input: (int)
E T + E | T
T int * T | int | (E)
• Then (E | ) is a state of a shift-reduce parse
• (E is a prefix of the rhs of T (E)
– Will be reduced after the next shift
• Item T (E.) says that so far we have seen (E of
this production and hope to see )

• The stack may have many prefixes of rhs’s
– Prefix1 Prefix2 . . . Prefixn-1Prefixn
• • Let Prefixi be a prefix of the rhs of Xi αi
– Prefixi will eventually reduce to Xi– Prefixi will eventually reduce to Xi
– The missing part of αi-1 starts with Xi
– i.e. there is a Xi-1 Prefixi-1 Xi β for some β
• Recursively, Prefixk+1…Prefixn eventually
reduces to the missing part of αk

• Consider the string (int * int):
– (int *|int) is a state of a shift-reduce parse
• “(” is a prefix of the rhs of T (E)
• “ɛ” is a prefix of the rhs of E T
• “int *” is a prefix of the rhs of T int * T
• The “stack of items”
– T (.E) says, we have seen “(” of T (E)
– E .T says, we have seen of E T
– T int * .T says, we have seen int * of T int * T

Recognizing Viable Prefixes
• Therefore, we have to build the finite automata that
recognizes this sequence of partial rhs’s of productions
• Algorithm:
1. Add a dummy production S’ S to G
2. The NFA states are the items of G2. The NFA states are the items of G
– Including the extra production
3. For item E α.Xβ add transition
– E α.X β X E α X. β
4. For item E α.Xβ and production X γ add
– E α.Xβ ɛ X .γ
5. Every state is an accepting state
6. Start state is S’ .S

Recognizing Viable Prefixes
• Given the grammar:
S’ E
E T + E | T
T int * T | int | (E)
Create an NFA to recognize viable prefixes

Recognizing Viable Prefix
S' .E
S' E.
E
E .T+Eɛ
T
T .(E)
ɛ
E T.+E E T+.E
+
ɛ
ɛ
T (.E)
(
T (E.)
E
ɛ
ɛ
T (E).
)
E
ɛ
T int.
ɛ
S' .E
E .T
E T.
T .int
ɛ
T .int*T
ɛ
ɛ
ɛ E T+E.
ɛ
T int.
int
T int.*Tint
T int*.T
*
T int*T.T
ɛ ɛ
ɛ
T

NFA to DFA – Subset Construction
S .E
E .T
S E.
E
E T.
E T.+ET
T int.*Tint
E T+.E
E .T
E .T+E
T .(E)
T .int*T
T .int
+
T
int
E T+E.
E
T (.E)
E .T
E .T+E
(
T
(
E .T
E .T+E
T .(E)
T .int*T
T .int
T int.*T
T int.
int
T int*.T
T .(E)
T .int*T
T .int
*
int
E .T+E
T .(E)
T .int*T
T .int
T
T int*T.
T
T (E.)
T (E).
E
)
((

Valid Items
• The states of the DFA are:
– canonical collections of LR(0) items
• Item X β.γ is valid for a viable prefix αβ if
– S’ *αXω αβγω by a right-most derivation
• After parsing αβ, the valid items are the possible tops of
the stack of items
• An item I is valid for a viable prefix α if the DFA
recognizing viable prefixes terminates on input α in a
state S containing I

• The items in S describe what the top of the
item stack might be after reading input α
• An item is often valid for many prefixes
Valid Items
• An item is often valid for many prefixes
– Example: The item T (.E) is valid for prefixes
• (, ((, (((, ((((, . . .

NFA to DFA – Subset Construction
S .E
E .T
S E.
E
E T.
E T.+ET
T int.*Tint
E T+.E
E .T
E .T+E
T .(E)
T .int*T
T .int
+
T
int
E T+E.
E
T (.E)
E .T
E .T+E
(
T
(
Start
state
E .T
E .T+E
T .(E)
T .int*T
T .int
T int.*T
T int.
int
T int*.T
T .(E)
T .int*T
T .int
*
int
E .T+E
T .(E)
T .int*T
T .int
T
T int*T.
T
T (E.)
T (E).
E
)
((

LR(0) Parsing
• Assume
– stack contains α
– next input token is t
– DFA on input α terminates in state s
• Reduce by X β if• Reduce by X β if
– s contains item X β.
• Shift if
– s contains item X β.tω
– Equivalent to saying s has a transition labeled t

LR(0) Parsing - Conflicts
• LR(0) has a reduce/reduce conflict if:
– Any state has two reduce items:
– X β. and Y ω.
• LR(0) has a shift/reduce conflict if:• LR(0) has a shift/reduce conflict if:
– Any state has a reduce item and a shift item:
– X β. and Y ω.tδ
• SLR improves on LR(0) shift/reduce heuristics
– Fewer states have conflicts

Shift Reduce Conflicts
S .E
E .T
S E.
E
E T.
E T.+ET
T int.*Tint
E T+.E
E .T
E .T+E
T .(E)
T .int*T
T .int
+
T
int
E T+E.
E
T (.E)
E .T
E .T+E
(
T
Shift-Reduce conflicts
Either Can be reduced by E T
Or can be shifted for i/p : +
E .T
E .T+E
T .(E)
T .int*T
T .int
T int.*T
T int.
int
T int*.T
T .(E)
T .int*T
T .int
*
int
E .T+E
T .(E)
T .int*T
T .int
T
T int*T.
T
T (E.)
T (E).
E
)
((

Countermeasure
• SLR = Simple LR
• Improve on LR(0) shift/reduce heuristics
– Fewer states have conflicts

SLR Parsing
• Assume
– stack contains α
– next input token is t
– DFA on input α terminates in state s
• Reduce by X β if• Reduce by X β if
– s contains item X β.
– t ϵ Follow (X)
• Shift if
– s contains item X β.tω
– Equivalent to saying s has a transition labeled t

• If there are conflicts under these rules, the
grammar is not SLR
• The rules amount to a heuristic for detecting
SLR Parsing
• The rules amount to a heuristic for detecting
handle
– The SLR grammars are those where the heuristics
detect exactly the handle

Shift Reduce Conflicts
S .E
E .T
S E.
E
E T.
E T.+ET
T int.*Tint
E T+.E
E .T
E .T+E
T .(E)
T .int*T
T .int
+
T
int
E T+E.
E
T (.E)
E .T
E .T+E
(
T
Follow(E) = {$,)}
Follow(T) = {$,),+}
E .T
E .T+E
T .(E)
T .int*T
T .int
T int.*T
T int.
int
T int*.T
T .(E)
T .int*T
T .int
*
int
E .T+E
T .(E)
T .int*T
T .int
T
T int*T.
T
T (E.)
T (E).
E
)
((

SLR Parsing Algorithm
1. Let M be DFA for viable prefixes of G
2. Let |x1…xn$ be initial configuration
3. Repeat until configuration is S|$
1. Let α|ω be current configuration
2. Run M on current stack α2. Run M on current stack α
3. If M rejects α, report parsing error
1. Stack α is not a viable prefix
4. If M accepts α with items I, let u be next input
1. Shift if X β.uγ ϵ I
2. Reduce if X β. ϵ I and u ϵ Follow(X)
3. Report parsing error if neither applies

SLR Parsing - Improvements
• Note that Step 3.3 is redundant
• If there is a conflict in the last step, grammar is not
SLR(k)
• Lots of grammars are not SLR• Lots of grammars are not SLR
– Including all ambiguous grammars
• We can parse more grammars by using precedence
declarations
– Instructions for resolving conflicts

SLR Parsing
• Consider the ambiguous grammar:
– E E + E | E * E | (E) | int
• The DFA for this grammar contains a state
with the following items:with the following items:
– E E * E. and E E. + E
– There is a shift/reduce conflict
• Declaring “* has higher precedence than +”
resolves this conflict in favor of reducing

SLR Parsing Example
S .E
E .T
S E.
E
E T.
E T.+ET
T int.*Tint
E T+.E
E .T
E .T+E
T .(E)
T .int*T
T .int
+
T
int
E T+E.
E
T (.E)
E .T
E .T+E
(
T
1
2 5
7
6
8
E .T
E .T+E
T .(E)
T .int*T
T .int
T int.*T
T int.
int
T int*.T
T .(E)
T .int*T
T .int
*
int
E .T+E
T .(E)
T .int*T
T .int
T
T int*T.
T
T (E.)
T (E).
E
)
((
1
3
4
10
911

Lecture10 syntax analysis_6

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Lecture10 syntax analysis_6 (20)

More from Mahesh Kumar Chelimilla (13)

Recently uploaded (20)

Lecture10 syntax analysis_6