6-Practice Problems - LL(1) parser-16-05-2023.pptx

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

Step 2: Compute FIRST
First(E)
ETE’
First(T)
TFT’
First(F)
F(E) Fid
ETE’
E’+TE’ | ϵ
TFT’
T’*FT’ | ϵ
F(E) | id
E  T E’
A  Y1 Y2
Rule 3
First(A)=First(Y1)
T  F T’
A  Y1 Y2
Rule 3
First(A)=First(Y1)
FIRST(E)=FIRST(T)
FIRST(T)=FIRST(F)
F  ( E )
A  𝛼
F  id
A  𝛼
Rule 1
add 𝛼 to 𝐹𝐼𝑅𝑆𝑇(𝐴)
Rule 1
FIRST(F)={ ( , id }
NT First
E { (,id }
E’
T { (,id }
T’
F { (,id }
= {(, id }
= {(, id }

First(E’)
E’+TE’
E’𝜖
A  𝛼
E’  𝜖
A  𝜖
Rule 1
Rule 2
add 𝜖 to 𝐹𝐼𝑅𝑆𝑇(𝐴)
FIRST(E’)={ + , 𝜖 }
E’  + T E’
NT First
E { (,id }
E’ { +, 𝜖 }
T { (,id }
T’
F { (,id }
ETE’
E’+TE’ | ϵ
TFT’
T’*FT’ | ϵ
F(E) | id

First(T’)
T’*FT’
T’𝜖
A  𝛼
T’  𝜖
A  𝜖
Rule 1
Rule 2
add 𝜖 to 𝐹𝐼𝑅𝑆𝑇(𝐴)
FIRST(T’)={ * , 𝜖 }
T’  * F T’
NT First
E { (,id }
E’ { +, 𝜖 }
T { (,id }
T’ { *, 𝜖 }
F { (,id }
ETE’
E’+TE’ | ϵ
TFT’
T’*FT’ | ϵ
F(E) | id

Step 2: Compute FOLLOW
FOLLOW(E)
F(E) NT First Follow
E { (,id } { $,) }
E’ { +, 𝜖 }
T { (,id }
T’ { *, 𝜖 }
F { (,id }
Rule 1: Place $ in FOLLOW(E)
FOLLOW(E)={ $,
F  ( E )
A  𝛂 B 𝛃
Rule 2
) }
ETE’
E’+TE’ | ϵ
TFT’
T’*FT’ | ϵ
F(E) | id

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

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

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

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

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

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

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

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

E’𝜖
b=FOLLOW(E’)={ $,) }
M[E’,$]=E’𝜖
M[E’,)]=E’𝜖
NT Input Symbol
id + * ( ) $
E’ E’+TE’ E’𝜖 E’𝜖
T
T’
F
Rule: 3
A 𝛼
b = follow(A)
M[A,b] = A 𝛼
NT First Follow
E { (,id } { $,) }
E’ { +, 𝜖 } { $,) }
T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
ETE’
E’+TE’ | ϵ
TFT’
T’*FT’ | ϵ
F(E) | id

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

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

T’𝜖
b=FOLLOW(T’)={ +,$,) }
M[T’,+]=T’𝜖
M[T’,$]=T’𝜖
M[T’,)]=T’𝜖
NT Input Symbol
id + * ( ) $
T’ T’𝜖 T’*FT’ T’𝜖 T’𝜖
F
Rule: 3
A 𝛼
b = follow(A)
M[A,b] = A 𝛼
NT First Follow
E { (,id } { $,) }
E’ { +, 𝜖 } { $,) }
T { (,id } { +,$,) }
T’ { *, 𝜖 } { +,$,) }
F { (,id } {*,+,$,)}
ETE’
E’+TE’ | ϵ
TFT’
T’*FT’ | ϵ
F(E) | id

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

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

• 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

Step 4: Parse the string : id + id * id $
STACK INPUT OUTPUT
E$ id+id*id$
TE’$ id+id*id$ ETE’
FT’E’$ id+id*id$ TFT’
idT’E’$ id+id*id$ Fid
T’E’$ +id*id$
+TE’$ +id*id$ E’+TE’
E’$ +id*id$ T’𝜖
idT’E’$ id$ Fid
TE’$ id*id$
T’E’$ $
FT’E’$ id*id$ TFT’
E’$ $ T’𝜖
FT’E’$ id$
$ $ E’𝜖
*FT’E’$ *id$ T*FT’
T’E’$ *id$
idT’E’$ id*id$ Fid
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

Parsing methods
Parsing
Top down parsing Bottom up parsing (Shift reduce)
Back tracking
Parsing without
backtracking (predictive
parsing)
LR parsing
Operator precedence
LALR
CLR
SLR
Recursive
descent
LL(1)

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 descent parsing
Procedure E
{
If lookahead=num
{
Match(num);
T();
}
Else
Error();
If lookahead=$
{
Declare success;
}
Else
Error();
}
Procedure T
{
If lookahead=’*’
{
Match(‘*’);
If lookahead=num
{
Match(num);
T();
}
Else
Error();
}
Else
NULL
}
Proceduce Match(token t)
{
If lookahead=t
lookahead=next_token;
Else
Error();
}
Procedure Error
{
Print(“Error”);
}
E
T
3 * 4 $
num T
num
* T| 𝜖
Success

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

Parsing Methods
Parsing
Top down parsing Bottom up parsing (Shift reduce)
Back tracking
Parsing without
backtracking (predictive
Parsing)
LR parsing
Operator precedence
LALR
CLR
SLR
Recursive
descent
LL(1)

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
Eid
String: id1+id2*id3
Right sentential form Handle Production
id1+id2*id3 id1 Eid
E+id2*id3 id2 Eid
E+E*id3 id3 Eid
E+E*E E*E EE*E
E+E E+E EE+E
E
Rightmost Derivation
E
E+E
E+E*E
E+E*id3
E+id2*id3
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
Stack Input Buffer Action
$ id+id*id$ Shift
$id +id*id$ Reduce Fid
$F +id*id$ Reduce TF
$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
Grammar:
EE+T | T
TT*F | F
Fid
String: id+id*id

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.

6-Practice Problems - LL(1) parser-16-05-2023.pptx

More Related Content

What's hot (20)

Similar to 6-Practice Problems - LL(1) parser-16-05-2023.pptx (20)

More from venkatapranaykumarGa (13)

Recently uploaded (20)

6-Practice Problems - LL(1) parser-16-05-2023.pptx