Module -2

Role of Parser- Parse Tree - Elimination of Ambiguity – Top Down Parsing - Recursive Descent Parsing -

LL (1) Grammars – Shift Reduce Parsers- Operator Precedence Parsing

Role of Parser
Role of parser
Token Parsetre
Source Lexical Parse e
front end
IR
Parser
tree Rest of
progra analyzer
m Get next
token

Symbol table

• Parser obtains a string of token from the lexical analyzer and reports syntax
error if any otherwise generates syntax tree.
• There are two types of parser:
1. Top-down parser
2. Bottom-up parser
 Syntax Error Handling

Common programming errors can occur at many different levels.

Lexical errors include misspellings of identifiers, keywords, or operators e.g., the use of an identifer
elipseSize instead of ellipseSize and missing quotes around text intended as a string.
Syntactic errors include misplaced semicolons or extra or missing braces;
that is, \{" or \}."
As another example, in C or Java, the appearance of a case statement without an enclosing switch is a
syntactic error (however, this situation is usually allowed by the parser and caught later in the
processing, as the compiler attempts to generate code).
Semantic errors include type mismatches between operators and operands,
e.g., the return of a value in a Java method with result type void.
Logical errors can be anything from incorrect reasoning on the part of the programmer to the use in a
C program of the assignment operator = instead of the comparison operator ==. The program
containing = may be well formed; however, it may not reflect the programmer's intent.
The error handler in a parser has goals that are simple to state but challenging to realize:

Report the presence of errors clearly and accurately.

Recover from each error quickly enough to detect subsequent errors.
Add minimal overhead to the processing of correct programs.
 Error-Recovery Strategies
Once an error is detected, how should the parser recover?
Although no strategy has proven itself universally acceptable, a few methods
have broad applicability.
The simplest approach is for the parser to quit with an informative error
message when it detects the first error. Additional errors are often uncovered
if the parser can restore itself to a state where processing of the input can
continue with reasonable hopes that the further processing will provide
meaningful diagnostic information.
 Global correction

The parser considers the program in hand as a whole and tries to figure out what the
program is intended to do and tries to find out a closest match for it, which is error-free.

When an erroneous input (statement) X is fed, it creates a parse tree for some closest error-
free statement Y.

This may allow the parser to make minimal changes in the source code, but due to the
complexity (time and space) of this strategy, it has not been implemented in practice yet.
Types of Grammar
• Regular Grammar (Type 3)
• Context-free Grammar (Type 2)
• Context-sensitivity Grammar (Type 1)
• Phrase-Structured Grammar (Type 0)
Context free grammar
Context free grammar
• A context free grammar (CFG) is a 4-tuple <VN, VT, S, S> where,
VN is finite set of non terminals,
VT is disjoint finite set of terminals,
S is an element of and it’s a start symbol,
P is a finite set formulas of the form where and
 Nonterminal symbol:
 The name of syntax category of a language, e.g., noun, verb, etc.
 The It is written as a single capital letter, or as a name enclosed between < … >, e.g., A
or <Noun>
<Noun Phrase> → <Article><Noun>
<Article> → a | an | the
<Noun> → boy | apple
Context free grammar
• A context free grammar (CFG) is a 4-tuple <VN, VT, S, S> where,
VN is finite set of non terminals,
VT is disjoint finite set of terminals,
S is an element of and it’s a start symbol,
P is a finite set formulas of the form where and
 Terminal symbol:
 A symbol in the alphabet.
 It is denoted by lower case letter and punctuation marks used in language.

<Noun Phrase> → <Article><Noun>

<Article> → a | an | the
<Noun> → boy | apple
Context free grammar
• A context free grammar (CFG) is a 4-tuple <VN, VT, S, S> where,
VN is finite set of non terminals,
VT is disjoint finite set of terminals,
S is an element of and it’s a start symbol,
P is a finite set formulas of the form where and
 Start symbol:
 First nonterminal symbol of the grammar is called start symbol.

<Noun Phrase> → <Article><Noun>

<Article> → a | an | the
<Noun> → boy | apple
Context free grammar
• A context free grammar (CFG) is a 4-tuple <VN, VT, S, S> where,
VN is finite set of non terminals,
VT is disjoint finite set of terminals,
S is an element of and it’s a start symbol,
P is a finite set formulas of the form where and
 Production:
 A production, also called a rewriting rule, is a rule of grammar. It has the form of
A nonterminal symbol → String of terminal and nonterminal symbols

<Noun Phrase> → <Article><Noun>

<Article> → a | an | the
<Noun> → boy | apple
Example: Grammar
Write terminals, non terminals, start symbol, and productions for following
grammar.
E  E O E| (E) | -E | id
O+|-|*|/ |↑

Non terminals: E, O Terminals: id + - * / ↑ ( )

Start symbol: E
Productions: E  E O E| (E) | -E | id
O+|-|*|/ |↑
Derivation & Ambiguity
Derivation
• Derivation is used to find whether the string belongs to a given grammar or not.
• Types of derivations are:
1. Leftmost derivation
2. Rightmost derivation
Leftmost derivation
• A derivation of a string in a grammar is a left most derivation if at every step
the left most non terminal is replaced.
• Grammar: SS+S | S-S | S*S | S/S | a Output string: a*a-a

S S
S-S Parse tree represents the

S*S-S
structure of derivation S - S

a*S-S S * S a
a*a-S

a*a-a a a
Leftmost Derivation Parse tree
Rightmost derivation
• A derivation of a string in a grammar is a right most derivation if at every step
the right most non terminal is replaced.
• It is all called canonical derivation.
• Grammar: SS+S | S-S | S*S | S/S | a Output string: a*a-a

S S
S*S
S * S
S*S-S

S*S-a a S S
-
S*a-a
a a
a*a-a
Rightmost Derivation Parse Tree
Exercise: Derivation
1. Perform leftmost derivation and draw parse tree.

A0A | 𝜖
SA1B

B0B | 1B | 𝜖
Output string: 1001
2. Perform leftmost derivation and draw parse tree.
S0S1 | 01 Output string: 000111
3. Perform rightmost derivation and draw parse tree.
EE+E | E*E | id | (E) | -E
Output string: id + id * id
Ambiguous grammar
Ambiguity
• Ambiguity, is a word, phrase, or statement which contains more than one
meaning.

A long thin piece of potato

Chip

A small piece of silicon

Ambiguity
• In formal language grammar, ambiguity would arise if identical string can occur
on the RHS of two or more productions.
• Grammar:
Replaced by
or ?

• can be derived from either N1 or N2

Ambiguous grammar
• Ambiguous grammar is one that produces more than one leftmost or more then
one rightmost derivation for the same sentence.
• Grammar: SS+S | S*S | (S) | a Output string: a+a*a

S S
S S
S*S S * S S+S S + S
S+S*S a+S
S + S a a S * S
a+S*S a+S*S
a+a*S a a a+a*S a a
a+a*a a+a*a
• Here, Two leftmost derivation for string a+a*a is possible hence, above grammar
is ambiguous.
Exercise: Ambiguous Grammar

1. S aS | Sa | 𝜖 (output string: aaaa)

Check Ambiguity in following grammars:

2. S aSbS | bSaS | 𝜖 (output string: abab)

3. S SS+ | SS* | a (output string: aa+a*)
4. <exp> → <exp> + <term> | <term>
<term> → <term> * <letter> | <letter>
<letter> → a|b|c|…|z (output string: a+b*c)
5. Prove that the CFG with productions: S  a | Sa | bSS | SSb | SbS is ambiguous
(Hint: consider output string yourself)
Left recursion & Left factoring
Left recursion
• A grammar is said to be left recursive if it has a non terminal such that there is
a derivation for some string
Algorithm to eliminate left recursion
1. Arrange the non terminals in some order
2. For do begin
for do begin
replace each production of the form
by the productions ,
where are all the current productions;
end
eliminate the immediate left recursion among the - productions
end
Left recursion elimination

 𝜖
Examples: Left recursion elimination
EE+T | T
ETE’
E’+TE’ | ε
TT*F | F
TFT’
T’*FT’ | ε
XX%Y | Z
XZX’
X’%YX’ | ε
Exercise: Left recursion
1. AAbd | Aa | a
BBe | b
2. AAB | AC | a | b
3. SA | B
AABC | Acd | a | aa
BBee | b
4. ExpExp+term | Exp-term | term
Left factoring
Left factoring is a grammar transformation that is useful for producing a grammar
suitable for predictive parsing.
Algorithm to left factor a grammar
Input: Grammar G
Output: An equivalent left factored grammar.
Method:
For each non terminal A find the longest prefix common to two or more of its
alternatives. If , i.e., there is a non trivial common prefix, replace all the productions
where represents all alternatives that do not begin with by

Here A' is new non terminal. Repeatedly apply this transformation until no two
alternatives for a non-terminal have a common prefix.
Left factoring elimination

| δ
Example: Left factoring elimination
SaAB | aCD
SaS’
S’AB | CD
A xByA | xByAzA | a

A xByAA’ | a
A’ Є | zA
A aAB | aA |a

A’AB | A | 𝜖
AaA’

A’AA’’ | 𝜖
A’’B | 𝜖
Exercise
1. SiEtS | iEtSeS | a
2. A ad | a | ab | abc | x
Parsing
Parsing
• Parsing is a technique that takes input string and produces output either a parse
tree if string is valid sentence of grammar, or an error message indicating that
string is not a valid.
• Types of parsing are:
1. Top down parsing: In top down parsing parser build parse tree from top to
bottom.
2. Bottom up parsing: Bottom up parser starts from leaves and work up to the
root.
Classification of parsing methods
Parsing

Top down Bottom up parsing (Shift

parsing reduce)
Back tracking Operator
precedence
Parsing without
backtracking LR parsing
(predictive
parsing) SLR
LL(1)
CLR
Recursiv
e LALR
descent
Backtracking
• In backtracking, expansion of nonterminal symbol we choose one alternative
and if any mismatch occurs then we try another alternative.
• Grammar: S cAd Input string: cad
A ab | a

S S S

c A d c A d c A d
Make prediction Make prediction

a b Backtrack a Parsing done

Exercise
1. E 5+T | 3-T
T V | V*V | V+V
V a | b
String: 3-a+b
Parsing Methods
Parsing

Top down Bottom up parsing (Shift

parsing reduce)
Back tracking Operator
precedence
Parsing without
backtracking LR parsing
(predictive
parsing) SLR
LL(1)
CLR
Recursiv
e LALR
descent
LL(1) parser (predictive parser)
• LL(1) is non recursive top down parser.
1. First L indicates input is scanned from left to right.
2. The second L means it uses leftmost derivation for input string
3. 1 means it uses only input symbol to predict the parsing process.

a + b $ INPUT

X
Y Predictiv
e parsing OUTPUT
Z
Stack program
$

Parsing table
M
LL(1) parsing (predictive parsing)
Steps to construct LL(1) parser
1. Remove left recursion / Perform left factoring (if any).
2. Compute FIRST and FOLLOW of non terminals.
3. Construct predictive parsing table.
4. Parse the input string using parsing table.
Rules to compute first of non terminal
1. If and is terminal, add to .

3. If is nonterminal and is a production, then place in if for some , a is in , and 𝜖

2. If , add to .

is in all of that is . If 𝜖 is in for all then add 𝜖 to .

Everything in is surely in If does not derive 𝜖, then we do nothing more to ,
but if , then we add and so on.
Rules to compute FOLLOW of non terminal

2. If then everything in except for 𝜖 is placed in

1. Place S is start symbol)

3. If there is a production or a production where contains then everything in

How to apply rules to find FOLLOW of non terminal?

𝜖 𝜖
Rules to construct predictive parsing table
1. For each production of the grammar, do steps 2 and 3.
2. For each terminal in , Add to .
3. If is in , Add to for each terminal in . If is in , and is in , add to .
4. Make each undefined entry of M be error.
Example-1: LL(1) parsing
SaBa
NT First
BbB | ϵ S {a}
Step 1: Not required
B {b,𝜖}
Step 2: Compute FIRST
First(S) S  a B a
Rule 1
SaBa A  add to
FIRST(S)={
a}
First(B)
BbB B𝜖
B  b B B  𝜖
A  Rule 1
A 
add to Rule 2
,𝜖}
FIRST(B)={ add to
b
Example-1: LL(1) parsing
SaBa
NT First Follow

BbB | ϵ S {a} {$}

Step 2: Compute FOLLOW B {b,𝜖} {a}

Follow(S)
Rule 1: Place $ in FOLLOW(S)
Follow(S)={ $ }

Follow(B)
SaBaS a B a
BbB
 Rule 2 B  b B
Rule 3
A  B First( A  B Follow(A)=follow(B)

Follow(B)={ a }
Example-1: LL(1) parsing
SaBa
NT First Follow
S {a} {$}
BbB | ϵ
B {b,𝜖} {a}
Step 3: Prepare predictive parsing table
NT Input Symbol
a b $
S SaBa
B

Rule: 2
SaBa A
a = first()
a=FIRST(aBa)={ a } M[A,a] = A

M[S,a]=SaBa
Example-1: LL(1) parsing
SaBa
NT First Follow
S {a} {$}
BbB | ϵ
B {b,𝜖} {a}
Step 3: Prepare predictive parsing table
NT Input Symbol
a b $
S SaBa
B BbB

Rule: 2
BbB A
a = first()
a=FIRST(bB)={ b } M[A,a] = A

M[B,b]=BbB
Example-1: LL(1) parsing
SaBa
NT First Follow
S {a} {$}
BbB | ϵ
B {b,𝜖} {a}
Step 3: Prepare predictive parsing table
NT Input Symbol
a b $
S SaBa Error Error
B Bϵ BbB Error

Rule: 3
Bϵ A
b = follow(A)

M[B,a]=B𝜖
b=FOLLOW(B)={ a } M[A,b] = A
Example-2: LL(1) parsing
SaB | ϵ

BbC | ϵ
CcS | ϵ
Step 1: Not required NT First
S { a, 𝜖 }
Step 2: Compute FIRST B {b,𝜖}
First(S) C {c,𝜖}

SaB S𝜖
S  a B S  𝜖
Rule 1 Rule 2
A  A 
add to add to

FIRST(S)={ a , 𝜖 }
Example-2: LL(1) parsing
SaB | ϵ

BbC | ϵ
CcS | ϵ
Step 1: Not required NT First
S { a, 𝜖 }
Step 2: Compute FIRST B {b,𝜖}
First(B) C {c,𝜖}

BbC B𝜖
B  b C B  𝜖
Rule 1 Rule 2
A  A 
add to add to

FIRST(B)={ b , 𝜖 }
Example-2: LL(1) parsing
SaB | ϵ

BbC | ϵ
CcS | ϵ
Step 1: Not required NT First
S { a, 𝜖 }
Step 2: Compute FIRST B {b,𝜖}
First(C) C {c,𝜖}

CcS C𝜖
C  c S C  𝜖
Rule 1 Rule 2
A  A 
add to add to

FIRST(B)={ c , 𝜖 }
Example-2: LL(1) parsing
Step 2: Compute FOLLOW
Follow(S) Rule 1: Place $ in FOLLOW(S)
Follow(S)={ $ }

CcS SaB | ϵ

C  c S BbC | ϵ
Rule 3
A  B Follow(A)=follow(B) CcS | ϵ
Follow(S)=Follow(C) ={$}
NT First Follow
S {a,𝜖} {$}
B {b,𝜖} {$}
C {c,𝜖} {$}
BbC B  b C
Rule 3 SaB
S  a B
Rule 3
A  B Follow(A)=follow(B) A  B Follow(A)=follow(B)
Follow(C)=Follow(B) ={$} Follow(B)=Follow(S)={$}
Example-2: LL(1) parsing
SaB | ϵ NT First Follow
S {a,𝜖} {$}
BbC | ϵ B {b,𝜖} {$}
CcS | ϵ C {c,𝜖} {$}
Step 3: Prepare predictive parsing table
N Input Symbol
T
a b c $

S SaB
B
C

Rule: 2
SaB A
a = first()
a=FIRST(aB)={ a } M[A,a] = A
M[S,a]=SaB
Example-2: LL(1) parsing
SaB | ϵ NT First Follow
S {a} {$}
BbC | ϵ B {b,𝜖} {$}
CcS | ϵ C {c,𝜖} {$}
Step 3: Prepare predictive parsing table
N Input Symbol
T
a b c $

S SaB S𝜖
B
C

Rule: 3
S𝜖 A
b = follow(A)
b=FOLLOW(S)={ $ } M[A,b] = A
M[S,$]=S𝜖
Example-2: LL(1) parsing
SaB | ϵ NT First Follow
S {a} {$}
BbC | ϵ B {b,𝜖} {$}
CcS | ϵ C {c,𝜖} {$}
Step 3: Prepare predictive parsing table
N Input Symbol
T
a b c $

S SaB S𝜖
B BbC
C

Rule: 2
BbC A
a = first()
a=FIRST(bC)={ b } M[A,a] = A
M[B,b]=BbC
Example-2: LL(1) parsing
SaB | ϵ NT First Follow
S {a} {$}
BbC | ϵ B {b,𝜖} {$}
CcS | ϵ C {c,𝜖} {$}
Step 3: Prepare predictive parsing table
N Input Symbol
T
a b c $

S SaB S𝜖
B BbC B𝜖
C

Rule: 3
B𝜖 A
b = follow(A)
b=FOLLOW(B)={ $ } M[A,b] = A
M[B,$]=B𝜖
Example-2: LL(1) parsing
SaB | ϵ NT First Follow
S {a} {$}
BbC | ϵ B {b,𝜖} {$}
CcS | ϵ C {c,𝜖} {$}
Step 3: Prepare predictive parsing table
N Input Symbol
T
a b c $

S SaB S𝜖
B BbC B𝜖
C CcS
Rule: 2
CcS A
a = first()
a=FIRST(cS)={ c } M[A,a] = A
M[C,c]=CcS
Example-2: LL(1) parsing
SaB | ϵ NT First Follow
S {a} {$}
BbC | ϵ B {b,𝜖} {$}
CcS | ϵ C {c,𝜖} {$}
Step 3: Prepare predictive parsing table
N Input Symbol
T
a b c $

S SaB Error Error S𝜖

B Error BbB Error B𝜖
C Error Error CcS C𝜖
Rule: 3
C𝜖 A
b = follow(A)
b=FOLLOW(C)={ $ } M[A,b] = A
M[C,$]=C𝜖
Example-3: LL(1) parsing
EE+T | T
TT*F | F
F(E) | id
Step 1: Remove left recursion
ETE’
E’+TE’ | ϵ
TFT’
T’*FT’ | ϵ
F(E) | id
Example-3: LL(1) parsing
Step 2: Compute FIRST ETE’
First(E) E  T E’ Rule 3
E’+TE’ | ϵ
First(A)=First(Y
A Y1 Y2
ETE’ 
1)
TFT’
= {(,
FIRST(E)=FIRST(T)
id }
T’*FT’ | ϵ
NT First
EF(E){ (,id
| id}
First(T) T  F T’ Rule 3
First(A)=First(Y
E’
A  Y1 Y2
TFT’ 1)
= {(,
T { (,id }
FIRST(T)=FIRST(F) T’
id }
F { (,id }
First(F) F  ( E ) F  id
F(E) A  Rule 1 Fid A  Rule 1
add to add to
FIRST(F)={ ,
( id }
Example-3: LL(1) parsing
Step 2: Compute FIRST ETE’

First(E’) E’+TE’ | ϵ
E’+TE’ TFT’
E’  + T E’ Rule 1
add to T’*FT’ | ϵ
A  NT First
EF(E){ (,id }
{ +, 𝜖 }
| id
E’
T { (,id }
E’𝜖
T’
E’  Rule 2 F { (,id }
A  add to

FIRST(E’)={ + , 𝜖 }
Example-3: LL(1) parsing
Step 2: Compute FIRST ETE’

First(T’) E’+TE’ | ϵ
T’*FT’ TFT’
T’  * F T’ Rule 1
add to T’*FT’ | ϵ
A  NT First
EF(E){ (,id }
{ +, 𝜖 }
| id
E’
T { (,id }
T’𝜖
T’ { *, 𝜖 }
T’  Rule 2 F { (,id }
A  add to

FIRST(T’)={ *, 𝜖 }
Example-3: LL(1) parsing
Step 2: Compute FOLLOW ETE’

FOLLOW(E) E’+TE’ | ϵ
Rule 1: Place $ in FOLLOW(E) TFT’

F(E) NT First T’*FT’ |ϵ

Follow
F(E)
E { (,id }| id { $,) }
E’ { +, 𝜖 }
F  ( E ) Rule 2 T { (,id }
{ *, 𝜖 }
A  B
T’
F { (,id }

FOLLOW(E)={ $, ) }
Example-3: LL(1) parsing
ETE’
Step 2: Compute FOLLOW
E’+TE’ | ϵ
FOLLOW(E’) TFT’
ETE’
NT First T’*FT’ |ϵ
Follow
E  T E’ F(E)
Rule 3 E { (,id }| id { $,) }
{ +, 𝜖 } { $,) }
A  B
E’
T { (,id }
T’ { *, 𝜖 }
E’+TE’ F { (,id }
E’  +T E’ Rule 3
A  B

FOLLOW(E’)={ $,) }
Example-3: LL(1) parsing
Step 2: Compute FOLLOW ETE’

FOLLOW(T) E’+TE’ | ϵ
TFT’
ETE’
NT First T’*FT’ |ϵ
Follow
E  T E’ F(E)
Rule 2 E { (,id }| id { $,) }
{ +, 𝜖 } { $,) }
A  B
E’
T { (,id }
T’ { *, 𝜖 }
F { (,id }
E  T E’ Rule 3
A  B

FOLLOW(T)={ +, $, )
Example-3: LL(1) parsing
Step 2: Compute FOLLOW ETE’

FOLLOW(T) E’+TE’ | ϵ
TFT’
E’+TE’
NT First T’*FT’ |ϵ
Follow
E’  + T E’ F(E)
Rule 2 E { (,id }| id { $,) }
{ +, 𝜖 } { $,) }
A  B
E’
T { (,id } { +,$,) }
T’ { *, 𝜖 }
F { (,id }
E’  + T E’ Rule 3
A  B

FOLLOW(T)={ +, $, ) }
Example-3: LL(1) parsing
Step 2: Compute FOLLOW ETE’

FOLLOW(T’) E’+TE’ | ϵ
TFT’
TFT’
NT First T’*FT’ |ϵ
Follow
T  F T’ F(E)
Rule 3 E { (,id }| id { $,) }
{ +, 𝜖 } { $,) }
A  B
E’
T { (,id } { +,$,) }
T’*FT’ T’ { *, 𝜖 } { +,$,) }
F { (,id }
T’  *F T’ Rule 3
A  B

FOLLOW(T’)={+ $,) }
Example-3: LL(1) parsing
Step 2: Compute FOLLOW ETE’

FOLLOW(F) E’+TE’ | ϵ
TFT’
TFT’
NT First T’*FT’ |ϵ
Follow
T  F T’ F(E)
Rule 2 E { (,id }| id { $,) }
{ +, 𝜖 } { $,) }
A  B
E’
T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id }
T  F T’ Rule 3
A  B

FOLLOW(F)={ *, + ,$ , )
Example-3: LL(1) parsing
Step 2: Compute FOLLOW ETE’

FOLLOW(F) E’+TE’ | ϵ
TFT’
T’*FT’
NT First T’*FT’ |ϵ
Follow
T’  * F T’ F(E)
Rule 2 E { (,id }| id { $,) }
{ +, 𝜖 } { $,) }
A  B
E’
T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
T’  * F T’ Rule 3
A  B

FOLLOW(F)={ *,+,$, ) }
Example-3: LL(1) parsing
Step 3: Construct predictive parsing table ETE’

NT Input Symbol E’+TE’ | ϵ

TFT’
id + * ( ) $
E ETE’ ETE’ T’*FT’ | ϵ
E’ NT First F(E)
Follow
| id
T E { (,id } { $,) }
T’ E’ { +, 𝜖 } { $,) }
F T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
ETE’ Rule: 2
A
a=FIRST(TE’)={ (,id } a = first()
M[A,a] = A
M[E,(]=ETE’
M[E,id]=ETE’
Example-3: LL(1) parsing
Step 3: Construct predictive parsing table ETE’

NT Input Symbol E’+TE’ | ϵ

TFT’
id + * ( ) $
E ETE’ ETE’ T’*FT’ | ϵ
E’ NT First F(E)
Follow
E’+TE’
| id
T E { (,id } { $,) }
T’ E’ { +, 𝜖 } { $,) }
F T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
Rule: 2
E’+TE’ A
a = first()
a=FIRST(+TE’)={ + } M[A,a] = A

M[E’,+]=E’+TE’
Example-3: LL(1) parsing
Step 3: Construct predictive parsing table ETE’

NT Input Symbol E’+TE’ | ϵ

TFT’
id + * ( ) $
E ETE’ ETE’ T’*FT’ | ϵ
E’ NT First F(E)
Follow
E’+TE’ E’𝜖 E’𝜖
| id
T E { (,id } { $,) }
T’ E’ { +, 𝜖 } { $,) }
F T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
E’𝜖 Rule: 3
A
b=FOLLOW(E’)={ $,) } b = follow(A)
M[A,b] = A
M[E’,$]=E’𝜖
M[E’,)]=E’𝜖
Example-3: LL(1) parsing
Step 3: Construct predictive parsing table ETE’

NT Input Symbol E’+TE’ | ϵ

TFT’
id + * ( ) $
E ETE’ ETE’ T’*FT’ | ϵ
E’ NT First F(E)
Follow
E’+TE’ E’𝜖 E’𝜖
| id
T TFT’ TFT’ E { (,id } { $,) }
T’ E’ { +, 𝜖 } { $,) }
F T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
TFT’ Rule: 2
A
a=FIRST(FT’)={ (,id } a = first()
M[A,a] = A
M[T,(]=TFT’
M[T,id]=TFT’
Example-3: LL(1) parsing
Step 3: Construct predictive parsing table ETE’

NT Input Symbol E’+TE’ | ϵ

TFT’
id + * ( ) $
E ETE’ ETE’ T’*FT’ | ϵ
E’ NT First F(E)
Follow
E’+TE’ E’𝜖 E’𝜖
| id
T TFT’ TFT’ E { (,id } { $,) }
T’ T’*FT’ E’ { +, 𝜖 } { $,) }
F T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
Rule: 2
T’*FT’ A
a = first()
a=FIRST(*FT’)={ * } M[A,a] = A

M[T’,*]=T’*FT’
Example-3: LL(1) parsing
Step 3: Construct predictive parsing table ETE’
NT Input Symbol
E’+TE’ | ϵ
id + * ( ) $ TFT’
E ETE’ ETE’
T’*FT’ | ϵ
E’ E’+TE’ E’𝜖 E’𝜖
NT First F(E)
Follow
T TFT’ TFT’ | id
E { (,id } { $,) }
{ +, 𝜖 }
T’ T’𝜖 T’*FT’ T’𝜖 T’𝜖
E’ { $,) }
F
T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
T’𝜖
F { (,id } {*,+,$,)}
b=FOLLOW(T’)={ +,$,) } Rule: 3
A
M[T’,+]=T’𝜖 b = follow(A)
M[A,b] = A
M[T’,$]=T’𝜖
M[T’,)]=T’𝜖
Example-3: LL(1) parsing
Step 3: Construct predictive parsing table ETE’

NT Input Symbol E’+TE’ | ϵ

TFT’
id + * ( ) $
E ETE’ ETE’ T’*FT’ | ϵ
E’ NT First F(E)
Follow
E’+TE’ E’𝜖 E’𝜖
| id
T TFT’ TFT’ E { (,id } { $,) }
T’ T’𝜖 T’*FT’ T’𝜖 T’𝜖 E’ { +, 𝜖 } { $,) }
F F(E) T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
Rule: 2
A
F(E) a = first()
M[A,a] = A
a=FIRST((E))={ ( }
M[F,(]=F(E)
Example-3: LL(1) parsing
Step 3: Construct predictive parsing table ETE’

NT Input Symbol E’+TE’ | ϵ

TFT’
id + * ( ) $
E ETE’ ETE’ T’*FT’ | ϵ
E’ NT First F(E)
Follow
E’+TE’ E’𝜖 E’𝜖
| id
T TFT’ TFT’ E { (,id } { $,) }
T’ T’𝜖 T’*FT’ T’𝜖 T’𝜖 E’ { +, 𝜖 } { $,) }
F Fid F(E) T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
Rule: 2
A
Fid a = first()
M[A,a] = A
a=FIRST(id)={ id }
M[F,id]=Fid
Example-3: LL(1) parsing
• Step 4: Make each undefined entry of table be Error
NT Input Symbol
id + * ( ) $
E ETE’ Error Error ETE’ Error Error
E’ Error E’+TE’ Error Error E’𝜖 E’𝜖
T TFT’ Error Error TFT’ Error Error
T’ Error T’𝜖 T’*FT’ Error T’𝜖 T’𝜖
F Fid Error Error F(E) Error Error
Example-3: LL(1) parsing
Step 4: Parse the string : id + id * id $ NT Input Symbol
id + * ( ) $
STACK INPUT OUTPUT
E ETE’ Error Error ETE’ Error Error
E$ id+id*id$
E’ Error E’+TE’ Error Error E’𝜖 E’𝜖
TE’$ id+id*id$ ETE’
T TFT’ Error Error TFT’ Error Error
FT’E’$ id+id*id$ TFT’
T’ Error T’𝜖 T’*FT’ Error T’𝜖 T’𝜖
idT’E’$ id+id*id$ Fid
F Fid Error Error F(E) Error Error
T’E’$ +id*id$
E’$ +id*id$ T’𝜖
+TE’$ +id*id$ E’+TE’
TE’$ id*id$ FT’E’$ id$
FT’E’$ id*id$ TFT’ idT’E’$ id$ Fid
idT’E’$ id*id$ Fid T’E’$ $
T’E’$ *id$ E’$ $ T’𝜖
*FT’E’$ *id$ T*FT’ $ $ E’𝜖
Parsing methods
Parsing

Top down Bottom up parsing (Shift

parsing reduce)
Back tracking Operator
precedence
Parsing without
backtracking LR parsing
(predictive
parsing) SLR
LL(1)
CLR
Recursiv
e LALR
descent
Recursive descent parsing
• A top down parsing that executes a set of recursive procedure to process the
input without backtracking is called recursive descent parser.
• There is a procedure for each non terminal in the grammar.
• Consider RHS of any production rule as definition of the procedure.
• As it reads expected input symbol, it advances input pointer to next position.
Example: Recursive
Procedure T descent parsing
Proceduce Match(token
Procedure E {
t)
{ If lookahead=’*’
{
If { If lookahead=t
lookahead=num
{ Match(‘*’); lookahead=next_token
If ;
Match(num); lookahead=num Else
T(); {
} Error();
Else Match(num); }
Error(); Procedure Error
If lookahead=$ T(); {
{ } Print(“Error”);
Declare Else }
success;
} Error();

T* numT| 𝜖
Else
Error(); }
Enum T
} Else
3 * 4 $ Succes NULL
} s
Example: Recursive
Procedure T descent parsing Proceduce
Procedure E { Match(token t)
{ If lookahead=’*’ {
If { If
lookahead=num lookahead=t
{ Match(‘*’);
If lookahead=next_toke
Match(num); lookahead=num n;
T(); { Else
}
Else Match(num); Error();
Error(); Procedure Error
}
If lookahead=$ T(); {
{ } Print(“Error”);
Declare Else }
success;
} Error();

T* numT| 𝜖
Else
Error(); }
Enum T
} Else
3 * 4 $ Succes NULL
3 4 * $
} s Error
Parsing Methods
Parsing

Top down Bottom up parsing (Shift

parsing reduce)
Back tracking Operator
precedence
Parsing without
backtracking LR parsing
(predictive Parsing)
SLR
LL(1)
CLR
Recursive
descent LALR
Handle & Handle pruning
• Handle: A “handle” of a string is a substring of the string that matches the right
side of a production, and whose reduction to the non terminal of the
production is one step along the reverse of rightmost derivation.
• Handle pruning: The process of discovering a handle and reducing it to
appropriate left hand side non terminal is known as handle pruning.
EE+E
EE*E String: id1+id2*id3
Eid
Right sentential form Handle Production
Rightmost Derivation
id1+id2*id3 id1 Eid
E
E+id2*id3 id2 Eid
E+E
E+E*id3 id3 Eid
E+E*E
E+E*id3 E+E*E E*E EE*E
E+E E+E EE+E
E+id2*id3
E
id1+id2*id3
Shift reduce parser
• The shift reduce parser performs following basic operations:
1. Shift: Moving of the symbols from input buffer onto the stack, this action is
called shift.
2. Reduce: If handle appears on the top of the stack then reduction of it by
appropriate rule is done. This action is called reduce action.
3. Accept: If stack contains start symbol only and input buffer is empty at the
same time then that action is called accept.
4. Error: A situation in which parser cannot either shift or reduce the symbols, it
cannot even perform accept action then it is called error action.
Example: Shift reduce parser
Grammar: Stack Input Buffer Action
EE+T | T $ id+id*id$ Shift
TT*F | F $id +id*id$ Reduce Fid
Fid $F +id*id$ Reduce TF
String: id+id*id $T +id*id$ Reduce ET
$E +id*id$ Shift
$E+ id*id$ Shift
$E+id *id$ Reduce Fid
$E+F *id$ Reduce TF
$E+T *id$ Shift
$E+T* id$ Shift
$E+T*id $ Reduce Fid
$E+T*F $ Reduce TT*F
$E+T $ Reduce EE+T
$E $ Accept
Viable Prefix
• The set of prefixes of right sentential forms that can appear on the stack of a
shift-reduce parser are called viable prefixes.
Parsing Methods
Parsing

Top down Bottom up parsing (Shift

parsing reduce)
Back tracking Operator
precedence
Parsing without
backtracking LR parsing
(predictive Parsing)
SLR
LL(1)
CLR
Recursiv
e LALR
descent
Operator precedence parsing
• Operator Grammar: A Grammar in which there is no Є in RHS of any production
or no adjacent non terminals is called operator grammar.
• Example: E EAE | (E) | id
A + | * | -
• Above grammar is not operator grammar because right side EAE has
consecutive non terminals.
• In operator precedence parsing we define following disjoint relations:
Relation Meaning
a<.b a “yields precedence to” b
a=b a “has the same precedence as” b
a.>b a “takes precedence over” b
Precedence & associativity of operators
Operator Precedence Associative
↑ 1 right
*, / 2 left
+, - 3 left
Steps of operator precedence parsing
1. Find Leading and trailing of non terminal
2. Establish relation
3. Creation of table
4. Parse the string
Leading & Trailing
Leading:- Leading of a non terminal is the first terminal or operator in production
of that non terminal.
Trailing:- Trailing of a non terminal is the last terminal or operator in production
of that non terminal.
Example: EE+T | T
TT*F | F
Fid
Non terminal Leading Trailing
E {+,*,id} {+,*,id}
T {*,id} {*,id}
F {id} {id}
Rules to establish a relation
1. For a = b, , where is or a single non terminal [e.g : (E)]
2. a <.b [e.g : +T]
3. a .>b [e.g : E+]
4. $ <. Leading (start symbol)
5. Trailing (start symbol) .> $
Example: Operator precedence parsing
Step 1: Find Leading & Trailing of NT
E E +T| T
Nonterminal Leading Trailing
T T *F| F
E {+,*,id} {+,*,id} F id
T {*,id} {*,id}
F {id} {id}

Step 2: Establish Relation Step3: Creation of Table

+ * id $
1. a <.b + .
> <. <. .
>
* .
> .
> <. .
>
id .
> .
> .
>
$ <. <. <.
Example: Operator precedence parsing
Step 1: Find Leading & Trailing of NT
E E+ T| T
Nonterminal Leading Trailing
T T* F| F
E {+,*,id} {+,*,id} F id
T {*,id} {*,id}
F {id} {id}

Step2: Establish Relation Step3: Creation of Table

+ * id $
1. a .>b + .
> <. <. .
>
* .
> .
> <. .
>
id .
> .
> .
>
$ <. <. <.
Example: Operator precedence parsing
Step 1: Find Leading & Trailing of NT
E E+ T| T
Nonterminal Leading Trailing
T T* F| F
E {+,*,id} {+,*,id} F id
T {*,id} {*,id}
F {id} {id}

Step 2: Establish Relation Step 3: Creation of Table

+ * id $
1. $<. Leading (start symbol) + .
> <. <. .
>
2. $ <. * .
> .
> <. .
>
3. Trailing (start symbol) .> $ id .
> .
> .
>
$ <. <. <.
Example: Operator precedence parsing
Step 4: Parse the string using precedence table
Assign precedence operator between terminals
String: id+id*id + * id $
+ .
> <. <. .
>
$ id+id*id $
* .
> .
> <. .
>
$ < id+id*id$
.
id .
> .
> .
>
$ < id > +id*id$
. . $ < .
< .
<.

$ <. id .> + <. id*id$

$ <. id .> + <. id .> *id$
$ <. id .> + <. id .> *<. id$
$ <. id .> + <. id .> *<. id .> $
Example: Operator precedence parsing
Step 4: Parse the string using precedence table
1. Scan the input string until first .> is encountered.
2. Scan backward until <. is encountered.
3. The handle is string between <. and .>
$ <. Id .> + <. Id .> * <. Id .> $ Handle id is obtained between <. and .>
Reduce this by Fid
$ F + <. Id .> * <. Id .> $ Handle id is obtained between <. and .>
Reduce this by Fid
$ F + F * <. Id .> $ Handle id is obtained between <. and .>
Reduce this by Fid
$F+F*F$ Perform appropriate reductions of all nonterminals.
$E+T*F$ Remove all non terminals.
$ + * $ Place relation between operators
$ <. + <. * >$ The * operator is surrounded by <. and .>. This
indicates * becomes handle so reduce by TT*F.
$ <. + >$ + becomes handle. Hence reduce by EE+T.

$ $ Parsing Done
Operator precedence function
Algorithm for constructing precedence functions
1. Create functions and for each that is terminal or .
2. Partition the symbols in as many as groups possible, in such a way that and are in the same
group if .
3. Create a directed graph whose nodes are in the groups, next for each symbols do:
a) if , place an edge from the group of to the group of
b) if , place an edge from the group of to the group of
4. If the constructed graph has a cycle then no precedence functions exist. When there are no
cycles collect the length of the longest paths from the groups of and respectively.
Operator precedence function
1. Create functions fa and ga for each a that is terminal or $. E E+T | T
T T*F | F
F id

f+ f* fid f$

g+ g* gid g$
Operator precedence function
• Partition the
. symbols in as many as groups possible, in such a way that fa and gb
are in the same group if a = b.
+ * id $
+ .
> <. <. .
>
gid fid
* .
> .
> <. .
>
id .
> .
> .
>
$ <. <. <.
f* g*

g+ f+

f$ g$
Operator precedence function
3. if a <· b, place an edge from the group of g b to the group of fa
if a ·> b, place an edge from the group of f a to the group of gb

g
+ * id $
+ .
> <. <. .
>
gid fid
f * .
> .
> <. .
>
id .
> .
> .
>
f* g* $ <. <. <.

g+ f+
f+ .> g+ f+  g+
f* .> g+ f*  g+
fid .> g+ fid  g+
f$ g$ f$ <. g+ f$  g+
Operator precedence function
3. if a <· b, place an edge from the group of g b to the group of fa
if a ·> b, place an edge from the group of f a to the group of gb

g
+ * id $
+ .
> <. <. .
>
gid fid
f * .
> .
> <. .
>
id .
> .
> .
>
f* g* $ <. <. <.

g+ f+
f+ <. g* f+  g*
f* .> g* f*  g*
fid .> g* fid  g*
f$ g$ f$ <. g* f$  g*
Operator precedence function
3. if a <· b, place an edge from the group of g b to the group of fa
if a ·> b, place an edge from the group of f a to the group of gb

g
+ * id $
+ .
> <. <. .
>
gid fid
f * .
> .
> <. .
>
id .
> .
> .
>
f* g* $ <. <. <.

g+ f+
f+ <. gid f+  gid
f* <. gid f*  gid
f$ <. gid f$  gid
f$ g$
Operator precedence function
3. if a <· b, place an edge from the group of g b to the group of fa
if a ·> b, place an edge from the group of f a to the group of gb

g
+ * id $
+ .
> <. <. .
>
gid fid
f * .
> .
> <. .
>
id .
> .
> .
>
f* g* $ <. <. <.

g+ f+
f+ <. g$ f+  g$
f* <. g$ f*  g$
fid <. g$ fid  g$
f$ g$
Operator precedence function
+ * id $
f 2
gid fid g

f* g* 4. If the constructed graph

has a cycle then no
precedence functions
g+ f+ exist. When there are no
cycles collect the length of
the longest paths from the
f$ g$
groups of fa and gb
respectively.
Operator precedence function
+ * id $
f 2
gid fid
g 1

f* g*

g+ f+

f$ g$
Operator precedence function
+ * id $
f 2 4
gid fid
g 1

f* g*

g+ f+

f$ g$
Operator precedence function
+ * id $
f 2 4
gid fid
g 1 3

f* g*

g+ f+

f$ g$
Operator precedence function
+ * id $
f 2 4 4
gid fid
g 1 3

f* g*

g+ f+

f$ g$
Operator precedence function
+ * id $
f 2 4 4
gid fid
g 1 3 5

f* g*

g+ f+

f$ g$
Operator precedence function
+ * id $
f 2 4 4 0
gid fid
g 1 3 5 0

f* g*

g+ f+

f$ g$
Parsing Methods
Parsin
g

Top down Bottom up parsing (Shift

parsing reduce)
Back tracking Operator
precedence
Parsing without
backtracking LR parsing
(predictive Parsing)
SLR
LL(1)
CLR
Recursi
ve LALR

descen
t
LR parser
• LR parsing is most efficient method of bottom up parsing which can be used to parse large
class of context free grammar.
• The technique is called LR(k) parsing:
1. The “L” is for left to right scanning of input symbol,
2. The “R” for constructing right most derivation in reverse,
3. The “k” for the number of input symbols of look ahead that are used in making parsing
decision. a + b $ INPUT

X
Y LR parsing
program OUTPUT
Z
$

Parsing Table
Action Goto
Parsing Methods
Parsin
g

Top down Bottom up parsing (Shift

parsing reduce)
Back tracking Operator
precedence
Parsing without
backtracking LR parsing
(predictive
parsing) SLR
LL(1)
CLR
Recursi
ve LALR

descen
t
Computation of closure & go to function
X Xb
Closure(I):
.
X X b
Goto(I,X)
.
X X b
Steps to construct SLR parser
1. Construct Canonical set of LR(0) items
2. Construct SLR parsing table
3. Parse the input string
Example: SLR(1)- simple LR
S  AA
A  aA | S AA . 5
S’ S. 𝑰𝟏 A a . A
b 𝐺𝑜𝑡𝑜(𝐼2, 𝐴)
𝑰𝟐
𝐺𝑜𝑡𝑜(𝐼 0,𝑆) A. aA 3

S A . A A. b
S’.S
A. aA
S. AA
A. b A b. 4
A. aA
A. b
3 A aA . 6 LR(0) item set
Augmented
grammar A a . A
A. aA A a . A
A. b A. aA 3
A b. 4

A. b

A b. 4
Rules to construct SLR parsing table
1. Construct , the collection of sets of LR(0) items for
2. Stateis constructed from . The parsing actions for state are determined as
follow :
a) If is in and GOTO , then set to “shift j”. Here a must be terminal.
b) If is in , then set to “reduce A ” for all a in ; here A may not be S’.
c) If is in , then set action to “accept”.
3. The goto transitions for state i are constructed for all non terminals A using the
4. All entries not defined by rules 2 and 3 are made error.
Example: SLR(1)- simple LR
S AA . 5
S’ S. 𝑰𝟏 A a .
𝑰𝟐 𝐺𝑜𝑡𝑜(𝐼2, 𝐴) A
𝑰𝟎 𝐺𝑜𝑡𝑜(𝐼 0,𝑆) ) S A . ,2 𝑎 )
A. aA 3

, 𝐴 𝐼 Action Go to
S’. S 𝐼( 0 AA. aA 𝑡𝑜 ( A. b

S. AA 𝑡𝑜 𝐺𝑜 Item
set
a b $ S A
𝑜
A. aA 𝐺
A. b A b.
𝐺𝑜 𝐺𝑜𝑡𝑜(𝐼2,𝑏) ) 4
0 S3 S4 1 2
,3 𝐴
(𝑜 𝐼
A. b 1 Accept
𝑡𝑜 A aA .
(𝐼 𝑡
3 6
2 S3 S4 5
0 , A a . 𝐺𝑜
𝑎) A 3 S3 S4 6
𝐺𝑜𝑡𝑜(𝐼 0,𝑏) A. aA 𝐺𝑜𝑡𝑜(𝐼 3 ,𝑎) A a. 4 R3 R3 R3
A
A b. 4 A. b 𝐺𝑜 A. aA 3
5 R1
𝑡𝑜 A. b 6 R2 R2 R2
S  AA (𝐼
3,
A  aA | 𝑏)
A b. 4
b
Parsing Methods
Parsin
g

Top down Bottom up parsing (Shift

parsing reduce)
Back tracking Operator
precedence
Parsing without
backtracking LR parsing
(predictive Parsing)
SLR
LL(1)
CLR
Recursi
ve LALR

descen
How to calculate look ahead?
How to calculate look ahead?
SCC S’  . S , $
C cC | d A  . X ,
Closure(I)
S’.S,$
$
S.CC, c|d
S  . C C , $
C.cC,c|d A  . X ,
C.d,
Example: CLR(1)- canonical LR
5 S AA. , 6
, 𝐴 ) A aA.,$ 9
S’ S.,
𝑰𝟏 $ A a.A,$
𝑡𝑜 ( 𝐼6 6

𝑎)
$
𝑰 𝟐 𝐺𝑜𝑡𝑜(𝐼2, 𝐴)
A. aA, 𝐺𝑜 𝐼 6 , 𝑎 ) A a.A,$
𝑜 𝑡𝑜 (

𝐼2,
𝑰𝟎 𝐺𝑜𝑡𝑜(𝐼 0,𝑆) 𝐴) S A.A, $A. b,
𝐺𝑜 𝑡𝑜 ( 𝐼 𝐺 A. aA,
$A. b,

𝑡𝑜 (
S’.S, 0𝐼 , $A.aA, $ 6 , 𝑏) A $
$ ( $ b. ,S
𝐺𝑜
S.AA,$ 𝑡𝑜 A. b, A b. ,
7 7

A.aA, a| 𝑜 )
𝐺 $ 𝐺𝑜𝑡𝑜(𝐼2,𝑏) $
b
A.b, a| ,3 𝐴 8

b ( 𝐼 A aA.,a| LR(1) item

𝑡𝑜
𝐺𝑜

Augment 3
b set
ed Aa.A, a| 𝐺𝑜
𝑡𝑜 (

3
grammar b
𝐺𝑜𝑡𝑜(𝐼 0,𝑏) A.aA ,a|b𝐺𝑜𝑡𝑜(𝐼 3 ,𝑎)A a.A , a|b
𝐼0,

A. b, a| A.aA , a|
𝐺 𝑜
𝑎)

A b., a|b 4 b b
𝑡𝑜 A.b , a|b
S  AA ( 𝐼3
A  aA | , 𝑏 A b., a|
)
b 4 b
Example: CLR(1)- canonical LR
5 S AA. , 6
, 𝐴 ) A aA.,$ 9
S’ S.,
𝑰𝟏 $ A a.A,$
𝑡𝑜 ( 𝐼6 6

𝑎)
$
𝑰 𝟐 𝐺𝑜𝑡𝑜(𝐼2, 𝐴)
A. aA, 𝐺𝑜 𝐼 6 , 𝑎 ) A a.A,$
𝑜 𝑡𝑜 (

𝐼2,
𝑰𝟎 𝐺𝑜𝑡𝑜(𝐼 0,𝑆) 𝐴) S A.A, $A. b,
𝐺𝑜 𝑡𝑜 ( 𝐼 𝐺 A. aA,
$A. b,

𝑡𝑜 (
S’.S, 0𝐼 , $A.aA, $ 6 , 𝑏) A $
$ ( $ b. ,S
𝐺𝑜
S.AA,$ 𝑡𝑜 A. b, A
7 7

A.aA, a| 𝑜 ) Item Action Go to

𝐺 $ 𝐺𝑜𝑡𝑜(𝐼2,𝑏) b. ,S
b
A.b, a| ,3 𝐴 8
set
a b $ S A
b (𝑜 𝐼 A aA.,a|
𝑡
𝐺𝑜

3
b 0 S3 S4 1 2
Aa.A, a| 𝐺𝑜 1 Accept
𝑡𝑜 (

3
b 2 S6 S7 5
𝐺𝑜𝑡𝑜(𝐼 0,𝑏) A.aA ,a|b𝐺𝑜𝑡𝑜(𝐼 3 ,𝑎)A a.A , a|b
𝐼0,

3 S3 S4 8
A. b, a| A.aA , a|
𝐺 𝑜 4 R3 R3
𝑎)

A b., a|b 4 b b
𝑡𝑜 A.b , a|b 5 R1
S  AA ( 𝐼3 6 S6 S7 9
A  aA | , 𝑏 A b., a| 7 R3
) 8 R2 R2
b 4 b 9 R2
Parsing Methods
Parsin
g

Top down Bottom up parsing (Shift

parsing reduce)
Back tracking Operator
precedence
Parsing without
backtracking LR parsing
(predictive Parsing)
SLR
LL(1)
CLR
Recursi
ve LALR

descen
t
Example: LALR(1)- look ahead LR
, 𝐴)
5 S AA. , 6 A aA.,$ 9
S’ S.,
𝑰𝟏 $ A a.A,$ ( 𝐼 6
𝐺𝑜 𝑡𝑜
6

𝑎)
$
𝑰𝟐 𝐺𝑜𝑡𝑜(𝐼2, 𝐴) A. aA,
( 𝐼 6 , 𝑎 ) A a.A,$
𝑡 𝑜

𝐼2,
𝑰𝟎 𝐺𝑜𝑡𝑜(𝐼 0,𝑆) ) $A. b, 𝐺𝑜 A. aA,
,0 𝐴 S A.A, 𝐺𝑜 𝑡𝑜 ( 𝐼 $A. b,

𝑡𝑜 (
S’.S, $
$ 6 , 𝑏) A b. , $
$ ( 𝐼 A.aA, $

𝐺𝑜
S.AA,$ 𝑡𝑜 $A. b, A b. ,
7 7

A.aA, a| 𝑜 )
𝐺 $ 𝐺𝑜𝑡𝑜(𝐼2,𝑏) $
b
A.b, a| ,3 𝐴 8
36 CLR
b (𝑜 𝐼 A aA.,a|
Aa.A, a|b|$
𝑡
𝐺𝑜

3
b
Aa.A, a| 𝐺𝑜 A.aA , a|b|$
𝑡𝑜 (

3
b A. b, a|b|$
𝐺𝑜𝑡𝑜(𝐼 0,𝑏) A.aA ,a|b𝐺𝑜𝑡𝑜(𝐼 3 ,𝑎)A a.A , a|b
𝐼0,

A. b, a| A.aA , a|
𝐺 𝑜
𝑎)

47
A b., a|b 4 b b
𝑡𝑜 A.b , a|b A b., a|b|$
S  AA (𝐼
3,
A  aA | 𝑏) A b., a| 89
A aA.,a|b|
b 4 b $
Example: LALR(1)- look ahead LR

Item Action Go to
set
a b $ S A
Item Action Go to
0 S3 S4 1 2 set a b $ S A
1 Accept
2 S6 S7 5 0 S36 S47 1 2
3 S3 S4 8 1 Accept
4 R3 R3 2 S36 S47 5
36 S36 S47 89
5 R1 47 R3 R3 R3
6 S6 S7 9 5 R1
7 R3 89 R2 R2 R2
8 R2 R2
9 R2
CLR Parsing Table LALR Parsing Table