This is about a topic of compiler design, LR and SLR parsing algorithm and LR grammar, Canonical collection and Item, Conflict in LR parsing shift reduce. Classification of Bottom up parsing.

1. Presentation On
“SR Parsing and SLR Basics”
1

2. 2
SR PARSING

3. Shift-Reduce (SR) parsing
• A shift-reduce parser is a class of efficient, table-driven bottom-
up parsing methods for computer languages and other
notations formally defined by a grammar.
3

4. 4
• The parsing methods most commonly used for parsing
programming languages, LR parsing and its variations, are
shift-reduce methods.
• All shift-reduce parsers have similar outward effects, in the
incremental order in which they build a parse tree or call
specific output actions
Shift-Reduce (SR) parsing

5. Basic steps
A shift-reduce parser works by doing some combination of Shift steps
and Reduce steps, hence the name.
A Shift step advances in the input stream by one symbol. That shifted symbol
becomes a new single-node parse tree.
A Reduce step applies a completed grammar rule to some of the recent parse
trees, joining them together as one tree with a new root symbol.
5

6. Actions of SR parsing
A shift-reduce parser has just four canonical actions:
 Shift  This involves moving of symbols from input buffer onto the stack.
 Reduce  If the handle appears on top of the stack then, its reduction by
using appropriate production rule is done i.e. RHS of production rule is
popped out of stack and LHS of production rule is pushed onto the stack.
6

7. Cont …
 Accept  If only start symbol is present in the stack and the input buffer is
empty then, the parsing action is called accept. When accept action is
obtained, it is means successful parsing is done.
 Error  This is the situation in which the parser can neither perform shift
action nor reduce action and not even accept action.
7

8. Conflicts
There are two kinds of conflicts that can occur in an SR parsing table.
 A shift-reduce conflict occurs in a state that requests both a shift action and a
reduce action.
 A reduce-reduce conflict occurs in a state that requests two or more different
reduce actions.
8

9. Example
Consider the grammar
S –> S + S
S –> S * S
S –> id
Perform Shift Reduce parsing for input string “id + id + id”.
9

10. Parsing Table
10

11. 11
SLR BASICS

12. LR Parser
The LR parser is a
• non-recursive
• shift-reduce
• bottom-up parser
It uses a wide class of context-free grammar which makes it the most
efficient syntax analysis technique.
12

13. 13
LR parsers are also known as LR(k) parsers Where
o L = left-to-right scanning of the input stream;
o R = the construction of right-most derivation in reverse
o and k denotes the number of look-ahead symbols to make decisions.

14. 14
Types of LR parser
2.LR(1) – Simple LR Parser(SLR)
3.LALR(1) – Look-Ahead LR Parser
1.LR(0) parser
4.Canonical LR (1) PARSER

15. SLR(1) – Simple LR Parser:
15
– Works on complete set of LR(1) Grammar
– Generates large table and large number of states
– Slow construction

16. SLR(1) parser
• SLR (1) refers to simple LR Parsing. It is same as LR(0) parsing.
• The only difference is in the parsing table.
• To construct SLR (1) parsing table, we use canonical collection of LR
(0) item.
• In the SLR (1) parsing, we place the reduce move only in the follow of
left hand side.
16

17. Item of LR(0)
• An LR(0) item of a grammar G is a production of G, a dot at the some
position of the right side.
Example:
A → aBb
Possible LR(0) Items:
A →.aBb
A → a.Bb
A → aB.b
A → aBb.
(four different possibility)
17

18. Cont.…
• Sets of LR(0) items will be the states of ‘action’ and ‘goto’ table of the
SLR parser.
• A collection of sets of LR(0) items (the canonical LR(0) collection) is
the basis for constructing SLR parsers.
18

19. 19
Augmented Grammar:
G’ is G with a new production rule E’→E where E’ is the new starting symbol
EXAMPLE
E’ → E
E  E+T
E  T
T  T*F
T  F
F  ( E )
F  id

20. 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
add d t l (I) ed to closure(I).
20

21. Example
Grammar : I= {E’ →.E}
E’ → E
E  E+T
E  T
T  T*F
T  F
F  ( E )
F  id
closure({E’ →.E}) =
E’ →.E
E →.E+T
E →.T
T →.T*F
T →.F
F →.(E)
F →.id
21

22. Goto Function
If I is a set of items and X ∈ (VnU VT ), then, goto(I, X) is the closure of
the set of all items A → αX. β such that A → α. Xβ is in I.
If I is a set of items valid for a prefix α of a right-sentential form,
then, Goto(I, X) is valid for the prefix αX
22

23. 23
Goto(I, X) represents the transition of the automaton
from state I and input X.
GOTO(I=state ,X=input)

24. 24
Grammar :
E′ → E
E → E + T
E → T
T → T ∗ F
T → F
F → (E)
F → id
I2
E → E+.T
T → .T ∗ F
T → . F
F → .(E)
F → . id
I0
E →.E+T
E →.T
T →.T*F
T →.F
F →.(E)
F →.id
I1
E′ → E. ,
E → E. +T
Example
GOTO(I0,E) GOTO(I1,+)

25. Example
If I1 = {E′ → E. , E → E. +T}, then:
goto(I1,+) = closure({E → E+.T}),
is the set:
E → E+.T
T → .T ∗ F
T → . F
F → .(E)
F → . id
Grammar :
E′ → E
E → E + T
E → T
T → T ∗ F
T → F
F → (E)
F → id
25

26. Canonical Collection
Algorithm. Canonical Collection for an Augmented Grammar G′
1. Initially, C = {closure({S′ →. S})};
2. For each set of items I in C and each Grammar symbol X
If goto(I, X) ≠ ∅ and Goto(I, X) /∈ C, then add Goto(I, X) to C;
3. Go to step 2 if new items have been added, otherwise stop
26

27. Example
Grammer :
S → E
E → E + T | T
T → T * F | F
F → id
27

28. S’  .E
E  .E+T
E  .T
T  .T*F
T  .F
F  .id
S’  E.
E  E.+T
E  E+.T
T  .T*F
T  .F
F  .id
E  T.
T  T.*F
T  T*.F
F  .id
E  E+T.
T  T.*f
T  T*F.
T  F.
F  id.
Canonical Collection
28
E
T
F
id
+
*
T
*
F
id
id
F
I0
I1
I5
I7
I8
I6
I4
I2
I3

29. Table Construction Rules
α, β = any string of terminals and/or non‐terminals
X, S’, S = non‐terminals
(When dot is in middle)
1. if [A ‐‐> α.aβ] ε Ii and read on ‘a’ produces Ij then ACTION [i , a] = SHIFT j.
2. if [A ‐‐> α.Xβ] ε Ii and read on ‘X’ produces Ij then GOTO [i , X] = j.
29

30. Cont..
(When dot is at end)
3. if [A ‐‐> α.] ε Ii then ACTION [i , a] = REDUCE on A ‐> α for all a ε FOLLOW(A).
4. if [S’ ‐‐> S.] ε Ii then ACTION [i , $] = ACCEPT.
30

31. Parsing Table
31

32. 32
Thanks to all