LR(1) & LALR PARSER

Prepared By:
NITIN GOYAL - 04CS1026

JITENDRA BINDAL - 04CS1027

INTRODUCTION

The LALR ( Look Ahead-LR ) parsing

technique is between SLR and Canonical LR, both
in terms of power of parsing grammars and ease
of implementation. This method is often used in
practice because the tables obtained by it are
considerably smaller than the Canonical LR tables,
yet most common syntactic constructs of
programming languages can be expressed
conveniently by an LALR grammar. The same is
almost true for SLR grammars, but there are a few
constructs that can not be handled by SLR techniques.
CONSTRUCTING LALR PARSING
TABLES
A core is a set of LR (0) (SLR) items for the
grammar, and an LR (1) (Canonical LR) grammar may
produce more than two sets of items with the same
core.
The core does not contain any look ahead information.
Example: Let s1 and s2 are two states in a Canonical
LR grammar.

S1 – {C ->c.C, c/d; C -> .cC, c/d; C -> .d, c/d}

S2 – {C ->c.C, $; C -> .cC, $; C -> .d, $}

These two states have the same core consisting of only

the production rules without any look ahead
information.
CONSTRUCTION IDEA:
1. Construct the set of LR (1) items.
2. Merge the sets with common core together
as one set, if no conflict (shift-shift or
shift-reduce) arises.
3. If a conflict arises it implies that the
grammar is not LALR.
4. The parsing table is constructed from the
collection of merged sets of items using
the same algorithm for LR (1) parsing.
ALGORITHM:
 Input: An augmented grammar G’.
 Output: The LALR parsing table
actions and goto for G’.
Method:
1. Construct C= {I0, I1, I2,…, In}, the collection of sets
of LR(1) items.
2. For each core present in among the set of LR(1)
items , find all sets having the core, and replace
these sets by their union.
3. Parsing action table is constructed as for Canonical
LR.
4. The goto table is constructed by taking the union of
all sets of items having the same core. If J is the
union of one or more sets of LR (1) items, that is,
J=I1 U I2 U … U Ik, then the cores of goto(I1,X),
goto(I2,X),…, goto(Ik, X) are the same as all of them
have same core. Let K be the union of all sets of
items having same core as goto(I1, X). Then
goto(J,X)=K.
EXAMPLE
GRAMMAR:
1. S’ -> S

2. S -> CC

3. C -> cC

4. C -> d
SET OF ITEMS:

I0 : S’ -> .S, $ I4: C -> d., c /d

S -> .CC, $ I5: S -> CC., $
C -> .c C, c /d
C -> .d, c /d I6: C -> c.C, $
C -> .cC, $
I1: S’ -> S., $ C -> .d, $
I2: S -> C.C, $ I7: C -> d., $
C -> .Cc, $
C -> .d, $ I8: C -> cC., c /d

I3: C -> c. C, c /d I9: C -> cC., $

C -> .Cc, c /d
C -> .d, c /d
The goto graph:
CANONICAL PARSING TABLE
LALR PARSER
Merge the Cores:
 3 & 6

 4 & 7

 8 & 9
LALR PARSING TABLE
SHIFT-REDUCE CONFLICT
COMPARISON OF LR (1) AND LALR:
1. If LR (1) has shift-reduce conflict then
LALR will also have it.
2. If LR (1) does not have shift-reduce conflict
LALR will also not have it.
3. Any shift-reduce conflict which can be
removed by LR (1) can also be removed by
LALR.
4. For cases where there are no common
cores SLR and LALR produce same parsing
tables.
SHIFT-REDUCE CONFLICT
LR(1) Parser-
How Does a shift-Reduce conflict arises?
IA : { E->α..βc, F->γ. } & FOLLOW(F)={β}
For Eg. I3 : {E->L.=R , R-> L. } &
Follow(E)={=}
For Solving this Problem by LALR Parser:
 IA={E->α.βc,ω1 ; F->γ.,δ1}

 IB={E->α.βc,ω2 ; F->γ.,δ2}
 IAB={E->α.βc,ω1|ω2 ; F->γ.,δ1|δ2}
SHIFT-REDUCE CONFLICT
COMPARISON OF SLR AND LALR:
1. If SLR has shift-reduce conflict then LALR may or may
not remove it.
2. SLR and LALR tables for a grammar always have
same number of states.

Hence, LALR parsing is the most suitable for

parsing general programming languages.The table
size is quite small as compared to LR (1) , and by
carefully designing the grammar it can be made free
of conflicts. For example, in a language like Pascal
LALR table will have few hundred states, but a
Canonical LR will have thousands of states. So it is
more convenient to use an LALR parsing.
REDUCE-REDUCE CONFLICT
The Reduce-Reduce conflicts still
might just remain .This claim may be
better comprehended if we take the
example of the following grammar:
 I ={ A->γ1.,δ1 ; ->γ2.,δ2}
A
If δ1≠δ2 then NO reduce-reduce conflict.
(mutual exclusive sets)
 I ={ A->γ1.,δ1 ; ->γ2.,δ2}
A
 I ={ A->γ1.,δ3 ; B->γ2.,δ4}
B
 I ={ A->γ1.,δ1|δ3 ; B->γ2.,δ2|δ4}
AB
Conflicts arises when δ1=δ4 or δ2=δ3.
Example of R-R Conflict
 S'-> S
 S -> aAd
 S -> bBd
 S -> aBe
 S -> bAe
 A -> c
 B -> c
Generating the LR (1) items for the
above grammar
 I0 : S’-> .S , $
 S-> . aAd, $
 S-> . bBd, $
 S-> . aBe, $
 S-> . bAe, $
 I1: S’-> S ., $
 I2: S-> a . Ad, $
 S-> a . Be, $
 A-> .c, d
 B->.c, e
 I3: S-> b . Bd, $
 S-> b . Ae, $
 A->.c, e
 B->.c,d
 I4: S->aA.d, $
Generating the LR (1) items for the
above grammar
 I5: S-> aB.e,$
 I6: A->c. , d ; B->c. , e
 I7: S->bB.d, $
 I8: S->bA.e, $
 I9: B->c. ,d ; A->c. , e
 I10: S->aAd. , $
 I11: S->aBe., $
 I12: S->bBd., $
 I13: S->aBe., $

 The underlined items are of our interest. We see that

when we make the Parsing table for LR (1), we will
get something like this…
The LR (1) Parsing Table
The LALR Parsing table

LR(1) Parsing table on reduction to the LALR parsing table

Conclusion
 So, we find that the LALR gains reduce-reduce
conflict whereas the corresponding LR (1)
counterpart was void of it. This is a proof
enough that LALR is less potent than LR (1).
 But, since we have already proved that the
LALR is void of shift-reduce conflicts (given that
the corresponding LR(1) is devoid of the
same), whereas SLR (or LR (0)) is not
necessarily void of shift-reduce conflict, the
LALR grammar is more potent than the SLR
grammar
Conclusion
SHIFT-REDUCE CONFLICT present in

SLR
 (Some of them are solved in….)

LR (1)
 (All those solved are preserved in…)

LALR
So, we have answered all the queries on
LALR that we raised intuitively.
Visit:

http://www.facweb.iitkgp.ernet.in/~niloy/COURSE/Autumn2006/Compi
ler/main.html#Lecture