Lecture 07 08 syntax analysis-4

SYNTAX ANALYSIS
OR
PARSING
Lecture 07-08

BOTTOM-UP PARSING
• A bottom-up parser creates the parse tree of the
given input starting from leaves towards the root
• A bottom-up parser tries to find the right-most
derivation of the given input in the reverse order.
S  ...  (the right-most derivation of )
 (the bottom-up parser finds the right-most
derivation in the reverse order)
IffatAnjum,Lecturer,BRACUniversity

RIGHTMOST DERIVATION

RIGHTMOST DERIVATION IN REVERSE

RIGHTMOST DERIVATION IN REVERSE
LR parsing corresponds to rightmost derivation in reverse

• A reduction step replaces a specific substring
(matching the body of a production)
• Reduction is the opposite of derivation
• Bottom up parsing is a process of reducing a string 
to the start symbol S of the grammar
REDUCTION

HANDLE
• Informally, a handle is a substring (in the parsing string)
that matches the right side of a production rule.
– But not every substring matches the right side of a
production rule is handle
• A handle of a right sentential form  ( ) is a
production rule A   and a position of 
where the string  may be found and replaced by A to
produce the previous right-sentential form in a rightmost
derivation  .
S  A  

HANDLE PRUNING
• A right-most derivation in reverse can be obtained by
handle-pruning.
rm rm rm rm rm
S=0  1  2  ...  n-1  n= 
input string
• Start from n, find a handle Ann in n,
and replace n in by An to getn-1.
• Then find a handle An-1n-1 in n-1,
and replace n-1 in by An-1 to getn-2.
• Repeat this, until we reach S.
n-th right-sentential form

SHIFT-REDUCE PARSING
• Bottom-up parsing is also known as shift-reduce
parsing because its two main actions are shift and
reduce.
• data structures: input-string and stack
• Operations
– At each shift action, the current symbol in the input
string is pushed to a stack.
– At each reduction step, the symbols at the top of the
stack (this symbol sequence is the right side of a
production) will replaced by the non-terminal at the left
side of that production.
– Accept: Announce successful completion of parsing
– Error: Discover a syntax error and call error recovery

SHIFT REDUCE PARSING
S  a T R e
T  T b c | b
R  d
Remaining input: abbcde
Rightmost derivation:
S  a T R e
 a T d e
 a T b c d e
 a b b c d e

S  a T R e
T  T b c | b
R  d
a b
Shift a, Shift b
Remaining input: bcde
S  a T R e
 a T d e
 a T b c d e
 a b b c d e

S  a T R e
T  T b c | b
R  d
a b
Shift a, Shift b
Reduce T  b


T
Remaining input: bcde
S  a T R e
 a T d e
 a T b c d e
 a b b c d e

S  a T R e
T  T b c | b
R  d
a b
Shift a, Shift b
Reduce T  b
Shift b, Shift c


 T
b c
Remaining input: de
S  a T R e
 a T d e
 a T b c d e
 a b b c d e

S  a T R e
T  T b c | b
R  d
a b
Shift a, Shift b
Reduce T  b
Shift b, Shift c
Reduce T  T b c




T
b c
T
Remaining input: de
S  a T R e
 a T d e
 a T b c d e
 a b b c d e

S  a T R e
T  T b c | b
R  d
a b
Shift a, Shift b
Reduce T  b
Shift b, Shift c
Reduce T  T b c
Shift d





T
b c
T
d
Remaining input: e
S  a T R e
 a T d e
 a T b c d e
 a b b c d e

S  a T R e
T  T b c | b
R  d
a b
Shift a, Shift b
Reduce T  b
Shift b, Shift c
Reduce T  T b c
Shift d
Reduce R  d






T
b c
T
d
R
Remaining input: e
S  a T R e
 a T d e
 a T b c d e
 a b b c d e

S  a T R e
T  T b c | b
R  d
a b
Shift a, Shift b
Reduce T  b
Shift b, Shift c
Reduce T  T b c
Shift d
Reduce R  d
Shift e







T
b c
T
d
R
e
Remaining input:
S  a T R e
 a T d e
 a T b c d e
 a b b c d e

S  a T R e
T  T b c | b
R  d
a b
Shift a, Shift b
Reduce T  b
Shift b, Shift c
Reduce T  T b c
Shift d
Reduce R  d
Shift e
Reduce S  a T R e








T
b c
T
d
R
e
S
Remaining input:
S  a T R e
 a T d e
 a T b c d e
 a b b c d e

EXAMPLE SHIFT-REDUCE PARSING
Consider the grammar:
Stack Input Action
$ id1 + id2$ shift
$id1 + id2$ reduce 6
$F + id2$ reduce 4
$T + id2$ reduce 2
$E + id2$ shift
$E + id2$ shift
$E + id2 reduce 6
$E + F reduce 4
$E + T reduce 1
$E accept

• Handle will always appear on Top of stack, never
inside
• Possible forms of two successive steps in any
rightmost derivation
• CASE 1:
S
A
B
   y z
S * Az  Byz 
yz
rm rm rm
STACK
$
INPUT
yz$
After Reducing the handle
$B yz$
Shifting from Input
$By z$
Reduce the handle
$A z$

• Case 2:
S
A
y z
B
  x
S * BxAz  Bxyz 
xyz
rm rm rm
STACK
$
$B
$Bxy
$BxA
INPUT
xyz$
After Reducing the handle
xyz$
Shifting from Input
z$
Reducing the handle
z$

CONFLICTS DURING SHIFT-REDUCE PARSING
• There are context-free grammars for which shift-reduce parsers
cannot be used.
• Stack contents and the next input symbol may not decide action:
– shift/reduce conflict: Whether make a shift
operation or a reduction.
– reduce/reduce conflict: The parser cannot
decide which of several reductions to make.
• If a shift-reduce parser cannot be used for a grammar, that grammar is
called as non-LR(k) grammar.
k lookheadleft to right
scanning
right-most
derivation
• An ambiguous grammar can never be a LR grammar.

SHIFT-REDUCE CONFLICT IN AMBIGUOUS
GRAMMAR
stmt  if expr then stmt
| if expr then stmt else stmt
| other
STACK INPUT
….if expr then stmt else….$
 We can’t decide whether to shift or reduce?

REDUCE-REDUCE CONFLICT IN AMBIGUOUS
GRAMMAR
1. stmt  id(parameter_list)
2. stmt  expr:=expr
3. parameter_list  parameter_list, parameter
4. parameter_list  parameter
5. parameter_list  id
6. expr  id(expr_list)
7. expr  id
8. expr_list  expr_list, expr
9. expr_list  expr
STACK INPUT
….id ( id , id ) …$
 We can’t decide which production will be used to
reduce id?

SHIFT-REDUCE PARSERS
There are two main categories of shift-reduce parsers
1. Operator-Precedence Parser
– simple, but only a small class of grammars.
CFG
LR
LALR
SLR
2. LR-Parsers
– covers wide range of grammars.
• SLR – simple LR parser
• LR – most general LR parser
• LALR – intermediate LR parser (lookhead LR parser)
– SLR, LR and LALR work same, only their parsing tables are different.

LR PARSERS
LR parsing is attractive because:
– LR parsing is most general non-backtracking shift-reduce
parsing,
yet it is still efficient.
– The class of grammars that can be parsed using LR methods is
a proper superset of the class of grammars that can be parsed
with predictive parsers.
LL(1)-Grammars  LR(1)-Grammars
– An LR-parser can detect a syntactic error as soon as it is
possible to do so a left-to-right scan of the input.
– LR parsers can be constructed to recognize virtually all
programming language constructs for which CFG grammars
canbe written
Drawback of LR method:
– Too much work to construct LR parser by hand
• Fortunately tools (LR parsers generators) are available

LL VS. LR
 LR (shift reduce) is more powerful than LL
(predictive parsing)
 Can detect a syntactic error as soon as possible.
 LR is difficult to do by hand (unlike LL)

LR PARSING ALGORITHM
Sm
Xm
Sm-1
Xm-1
.
.
S1
X1
S0
a1 ... ai ... an $
Action Table
terminals and $
Goto Table
non-terminal
s
t
a
t
e
s
four different
actions
s
t each item is
a a state number
t
e
s
LR Parsing Algorithm
input
stack
output

A CONFIGURATION OF LR PARSING
ALGORITHM
• A configuration of a LR parsing is:
( So X1 S1 ... Xm Sm, ai ai+1 ... an $ )
Stack Rest of Input
• Sm and ai decides the parser action by consulting the
parsing action table. (Initial Stack contains just So
)
• A configuration of a LR parsing represents the right sentential
form:
X1 ... Xm ai ai+1 ... an $

ACTIONS OF A LR-PARSER
1. shift s -- shifts the next input symbol and the state s onto the stack
( So X1 S1 ... Xm Sm, ai ai+1 ... an $ )€ ( So X1 S1 ... Xm Sm ai s, ai+1 ... an $ )
2. reduce A (or rN where N is a production number)
– pop 2|| (=r) items from the stack;
– then push Aand s where s=goto[sm-r,A]
( So X1 S1 ... Xm Sm, ai ai+1 ... an $ )€ ( So X1 S1 ... Xm-r Sm-r A s, ai ... an $ )
– Output is the reducing production reduce A
2. Accept – Parsing successfully completed
3. Error -- Parser detected an error (an empty entry in the action table)

Reduce Action
• pop 2||(=r) items fromthe stack; let us assume that
 = Y1Y2...Yr
• then push Aand s where s=goto[sm-r,A]
( So X1 S1 ... Xm-r Sm-r Y1 Sm-r ...Yr Sm, ai ai+1 ... an $ )
€ ( So X1 S1 ... Xm-r Sm-r A s, ai ... an $ )
• In fact, Y1Y2...Yris a handle.
X1 ... Xm-r A ai ... an $ c X1 ... Xm Y1...Yr ai ai+1 ... an $

LR PARSER STACK(S)

CONSTRUCTING SLR PARSING TABLES –
LR(0) ITEM
• An item indicates how much of a production we have seen at a
given point in the parsing process
• For Example the item A  X  YZ
– We have already seen on the input a string derivable from X
– We hope to see a string derivable from YZ
• For Example the item A   XYZ
– We hope to see a string derivable from XYZ
• For Example the item A  XYZ 
– We have already seen on the input a string derivable from XYZ
– It is possibly time to reduce XYZ to A
• Special Case:
Rule: A   yields only one item
A  

CONSTRUCTING SLR PARSING TABLES
• A collection of sets of LR(0) items (the canonical
LR(0) collection) is the basisfor constructing
SLR parsers.
• Canonical LR(0) collection provides the basis of
constructing a DFA called LR(0) automaton
– This DFA is used to make parsing decisions
• Each state of LR(0) automaton represents a set of
items in the canonical LR(0) collection
• To construct the canonical LR(0) collection for a
grammar
– Augmented Grammar
– CLOSURE function
– GOTO function

CONSTRUCTING SLR PARSING TABLES –
LR(0) ITEM
• An LR(0) item of a grammar G is a production of G a dot at the
some position of the right side.
• Ex: A  aBb Possible LR(0) Items: A   aBb
(four different possibility) A  a  Bb
A  aB  b
A  aBb 
• Sets of LR(0) items will be the states of action and goto table of
the SLR parser.
– States represent sets of “items”
• LR parser makes shift-reduce decision by maintaining states to
keep track of where we are in a parsing process

GRAMMAR AUGMENTATION

THE CLOSURE OPERATION
• If I is a set of LR(0) items for a grammar G, then
closure(I) is the set of LR(0) items constructed from I
by the two rules:
1. Initially, every LR(0) item in I is added to closure(I).
2. If A  .B is in closure(I) and
B is a production rule of G;
then B. will be in the closure(I).
We will apply this rule until no more new LR(0)
items can be added to closure(I).

THE CLOSURE OPERATION -- EXAMPLE
E'  E closure({E'  .E}) =
E  E+T { E'  E kernel
items
E  T E  E+T
T  T*F E  T
T  F T  T*F
F  (E) T  F
F  id F  (E)
F  id }

GOTO OPERATION
• If I is a set of LR(0) items and X is a grammar symbol (terminal
or non-terminal), then GOTO(I,X) is defined as follows:
– If A   X in I
then every item in closure({A  X  }) willbe in
GOTO(I,X).
Example:
E   T,I ={ E’   E, E   E+T,
T   T*F,T   F,
F   (E), F   id }
 T, T   T*F, T   F,
GOTO(I,E) = { E’  E  , E  E  +T }
GOTO(I,T) = { E  T  , T  T  *F }
GOTO(I,F) = {T  F  }
GOTO(I,() = { F  ( E), E   E+T, E 
F   (E), F   id }
GOTO(I,id) = { F  id  }

CONSTRUCTION OF THE CANONICAL LR(0)
COLLECTION (CC)
• To create the SLR parsing tables for a grammar G, we will
create the canonical LR(0) collection of the grammar G’.
• Algorithm:
C is { closure({S'  S}) }
repeat the followings until no more set of LR(0) items
can be added to C.
for each I in C and each grammar symbol X
if GOTO(I,X) is not empty and not in C
add GOTO(I,X) to C
• GOTO function is a DFA on the sets in C.

THE CANONICAL LR(0) COLLECTION --
EXAMPLE
I0: E’  .E
E  .E+T
I1: E’  E.
E  E.+T
I6: E  E+.T
T  .T*F
I9: E  E+T.
T  T.*F
E  .T T  .F
T  .T*F
T  .F
I2: E  T.
T  T.*F
F  .(E)
F  .id
I10: T  T*F.
F  .(E)
F  .id I3: T  F. I7: T  T*.F
F  .(E)
I11: F  (E).
I4: F  (.E)
E  .E+T
F  .id
E  .T
T  .T*F
I8: F  (E.)
E  E.+T
T  .F
F  .(E)
F  .id
I5: F  id.

TRANSITION DIAGRAM (DFA) OF GOTO
FUNCTION
I0 I1
I2
I3
I6
I7
I8
to I2
to I3
to I4
I9
to I3
I10
to I4
to I5
I11
to I6
to I7
id to I4
to I5
(
F
*
E
E T
T
)
+
F
T
F
(
I4
id
I5
id
(
*
F
(
id
+

CONSTRUCTING SLR PARSING TABLE
(OF AN AUGUMENTED GRAMMAR G’)
1. Construct the canonical collection of sets of LR(0)
items for G’. C{I0,...,In}
2. Create the parsing action table as follows:
 If a is a terminal, A.a in Ii and goto(Ii,a)=Ij then
action[i,a] is shift j.
 If A. is in Ii , then action[i,a] is reduce A
for all a in FOLLOW(A) where AS’.
 If S’S. is in Ii , then action[i,$] is accept.
 If any conflicting actions generated by these rules, the
grammar is not SLR(1).
3. Create the parsing goto table
 for all non-terminals A,
 if goto(Ii,A)=Ij then goto[i,A]=j
4. All entries not defined by (2) and (3) are errors.
5. Initial state of the parser containsS’.S

PARSING TABLES OF EXPRESSION GRAMMAR
state id + * ( ) $ E T F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
11 r5 r5 r5 r5
Action Table Goto Table

(SLR) PARSING TABLES FOR EXPRESSION
GRAMMAR
state id + * ( ) $ E T F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
11 r5 r5 r5 r5
Action Table Goto Table
Key to Notation
S4=“Shift input symbol
and push state 4”
R5= “Reduce by rule 5”
Acc=Accept
(blank)=Syntax Error

EXAMPLE LR PARSE: (ID+ID)*ID

ACTIONS OF A (S)LR-PARSER -- EXAMPLE
stack
0
input
id*id+id$
action
shift 5
output
0id5 *id+id$ reduce by Fid Fid
0F3
0T2
0T2*7
*id+id$
*id+id
$
id+id
$
reduce by TF
shift 7
shift 5
TF
0T2*7id5 +id$ reduce by Fid Fid
0T2*7F10 +id$ reduce by TT*F TT*F
0T2
0E1
0E1+6
0E1+6id5
+id$
+i
d$
id$
$
reduce by ET
shift 6
shift 5
reduce by Fid
ET
Fid
0E1+6F3 $ reduce by TF TF
0E1+6T9
0E1
$
$
reduce by EE+T
accept
EE+
T

LR PARSING ALGORITHM

SLR GRAMMAR: REVIEW
 An LR parser using SLR parsing tables for a
grammar G is called as the SLR parser for G.
 If a grammar G has an SLR parsing table, it is
called SLR grammar (or SLR grammar in short).
 Every SLR grammar is unambiguous, but every
unambiguous grammar is not a SLR grammar.
 If the SLR parsing table of a grammar G has a
conflict, we say that that grammar is not SLR
grammar.

CONFLICT EXAMPLE

CONFLICT EXAMPLE2

CONFLICT

Any Questions ?

Lecture 07 08 syntax analysis-4

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Lecture 07 08 syntax analysis-4 (20)

More from Iffat Anjum (16)

Recently uploaded (20)

Lecture 07 08 syntax analysis-4