LL(1)

PARSER
MODEL OF COMPILER FRONT 2
END
Front End

Syntax analysis

Also called parsing , where

generates parse tree
PARSING 3

When the parser starts constructing

Where bottom-up parsing starts
the parse tree from the start symbol
with the input symbols and tries to
and then tries to transform the start
construct the parse tree up to the
symbol to the input, it is called top-
start symbol.
down parsing.
TOP DOWN PERSER 4

Predictive parser is a recursive

descent parser, which has the
capability to predict which production
is to be used to replace the input
string. The predictive parser does not
suffer from backtracking.
PREDICTIVE PARSER 5

 Predictive parsing uses a stack

and a parsing table to parse
the input and generate a parse
tree.

 Both the stack and the input

contains an end symbol $to
denote that the stack is empty
and the input is consumed.

 The parser refers to the parsing

table to take any decision on
the input and stack element
combination.
LL(1) PARSER 6

 An LL parser is called an LL(k)

parser if it uses k tokens of look
ahead when parsing a sentence.

 LL grammars, particularly LL(1)

grammars, as parsers are easy to
construct, and many computer
languages are designed to be LL(1)
for this reason.

 The 1 stands for using one input

symbol of look ahead at each step
to make parsing action decision.
CONTINUE… 7
LL(k) parsers must predict which production replace a non-terminal with as soon as they see
the non-terminal. The basic LL algorithm starts with a stack containing [ S, $] (top to bottom)
and does whichever of the following is applicable until done:
 If the top of the stack is a non-terminal, replace the top of the stack with one of the
productions for that non-terminal, using the next k input symbols to decide which one
(without moving the input cursor), and continue.
 If the top of the stack is a terminal, read the next input token. If it is the same terminal,
pop the stack and continue. Otherwise, the parse has failed and the algorithm finishes.
 If the stack is empty, the parse has succeeded and the algorithm finishes. (We assume
that there is a unique EOF-marker $ at the end of the input.)

So look ahead meaning is - looking at input tokens without moving the input cursor.
PRIME REQUIREMENT OF LL(1) 8

 The grammar must be -

 no left factoring
 no left recursion

 FIRST() & FOLLOW()

 Parsing Table
 Stack Implementation
 Parse Tree
 9

STEP: LEFT FACTORING

LEFT FACTORING 10
 A grammar is said to be left factored when it is of the form –
A -> αβ1 | αβ2 | αβ3 | …… | αβn | γ
 The productions start with the same terminal (or set of terminals).
 When the choice between two alternative A-productions is not clear, we
may be able to rewrite the productions to defer the decision until
enough of the input has been seen to make the right choice.

For the grammar

A -> αβ1 | αβ2 | αβ3 | …… | αβn | γ

The equivalent left factored grammar will be –

A -> αA’ | γ
A’ -> β1 | β2 | β3 | …… | βn
CONTINUE… 11

 For example :
the input string is - aab & grammar is
S ->aAb|aA|ab
A ->bAc|ab
After removing left factoring -
S ->aA’
A’ ->Ab|A|b
A ->ab|bAc
 12

STEP: LEFT RECURSION

 13

RECURSION
RECURSION:

The process in which a function calls itself directly or indirectly is called

recursion and the corresponding function is called as recursive function.

TYPES OF RECURSION

LEFT RECURSION RIGHT RECURSION

 14

Left Recursion Right Recursion

For grammar: For grammar:

A -> A | β A ->  A| β
A
A  A
A   A

A   A
β 
A

This parse tree generate β  * This parse tree

generate  * β
Right recursion- 15

 A production of grammar is said to have right

recursion if the right most variable
RHS is same as variable of its LHS. e.g. A -> 
A| β

 A grammar containing a production having right

recursion is called as a right recursive grammar.

 Right recursion does not create any problem for the

top down parsers.

 Therefore, there is no need of eliminating right

recursion from the grammar.
Left recursion- 16
 A production of grammar is said to have left
recursion if the leftmost variable of its RHS is
same as variable of its LHS. e.g. A -> A | β
 A grammar containing a production having
left recursion is called as a left recursive
grammar.
 Left recursion is eliminated because top
down parsing method can not handle left
recursive grammar.
Left Recursion 17
A grammar is left recursive if it has a nonterminal A such that there
is a derivation
A -> A | β for some string .
Immediate/direct left recursion:
A production is immediately left recursive if its left hand side and the
head of its right hand side are the same symbol, e.g. A ->A  ,
where α is  sequence of non terminals and terminals.
Indirect left recursion:
Indirect left recursion occurs when the definition of left recursion is
satisfied via several substitutions. It entails a set of rules following
the pattern
. A → Br
B → Cs
C → At
Here, starting with a, we can derive A -> Atsr
Elimination of Left-Recursion 18
 Suppose the grammar were
A  A | 

How could the parser decide how many times to use the
production A  A before using the production A -->  ?

 Left recursion in a production may be removed by transforming

the grammar in the following way.
Replace
A  A | 
With
A  A'
A'  A' | 
EXAMPLE OF IMMEDIATE LEFT RECURSION: 19

Consider the left recursive grammar

EE+T|T Now the grammar is

E  T E'
TT*F|F
E'  + T E' | 
F  (E) | id T  F T'
Apply the transformation to E:
T'  * F T' | 
E  T E'
E'  + T E' |  F  (E) | id

Then apply the transformation to T:

T  F T'
T'  * F T' | 
Continue… 20

The case of several immediate left recursive  -productions.

Assume that the set of all  -productions has the form
A → A 1 | A 2 | · · · | A m | β1 | β2| · · · | βn

Represents all the  -productions of the grammar, and no βi

begins with A, then we can replace these  -productions by

A →β1A′ | β2A′| · · · | βnA′

A′ → 1A′ | 2A′ | · · · | mA′ | 
 21
Example:
Consider the left recursive grammar
S → SX | SSb| XS | a

X → Xb | Sa Now the grammar is

S → XSS′ | aS′
Apply the transformation to S: S′
→ XS′ | SbS′ | ε
S → XSS′ | aS′
X→
S′ → XS′ | SbS′ | ε SaX′
Apply the transformation to X: X′ → bX′ | ε

X → SaX′
X′ → bX′ | ε
Example of elimination indirect left 22
recursion:

S A A | 0
A S S | 1
Considering the ordering S, A, we get:
S A A | 0
A S | 0S | 1

And removing immediate left recursion, we get

S A A | 0
A 0S A′ | 1A′
A′  ε | AS A′
 23

STEP:FIRST & FOLLOW

Why using FIRST and FOLLOW: 24

During parsing FIRST and FOLLOW help us to

choose which production to apply , based on the next input
signal.

We know that we need of backtracking in syntax analysis, which

is really a complex process to implement. There can be easier
way to sort out this problem by using FIRST AND FOLLOW.
If the compiler would have come to know in advance, that what
is the “first character of the string produced when a production
rule is applied”, and comparing it to the current character or
token in the input string it sees, it can wisely take decision on
which production rule to apply .
FOLLOW is used only if the current non terminal can derive ε .
 25
Rules of FIRST

FIRST always find out the terminal symbol from the

grammar. When we check out FIRST for any symbol
then if we find any terminal symbol in first place then
we take it. And not to see the next symbol.
If a grammar is
A → a then FIRST ( A )={ a }
 If a grammar is
A → a B then FIRST ( A )={ a }
 26
Rules of FIRST

 If a grammar is
A → aB ǀ ε then FIRST ( A )={ a, ε }
 If a grammar is
A → BcD ǀ ε
B → eD ǀ ( A )
Here B is non terminal. So, we check the transition of
B and find the FIRST of A.
then FIRST ( A )={ e,( , ε }
 27
Rules of FOLLOW
For doing FOLLOW operation we need FIRST operation mostly. In
FOLLOW we use a $ sign for the start symbol. FOLLOW always
check the right portion of the symbol.
If a grammar is
A → BAc ; A is start symbol.
Here firstly check if the selected symbol stays in right side of the
grammar. We see that c is right in A.
then FOLLOW (A) = {c , $ }
 28

Rules of FOLLOW

 If a grammar is
A → BA’

A' →*Bc
Here we see that there is nothing at the right side of A' . So
FOLLOW ( A' )= FOLLOW ( A )= { $ }
Because A' follows the start symbol.
 29

Rules of FOLLOW

 If a grammar is
A → BC
B → Td
C →*D ǀ ε
When we want to find FOLLOW (B),we see that B follows by C .
Now put the FIRST( C) in the there.
FIRST(C)={*, ε }.
But when the value is € it follows the parents symbol. So
FOLLOW(B)={*,$ }
 30
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E
F -> (E)|id
E’

T’

F
 31
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id }
F -> (E)|id
E'

T'

F
 32
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id }
F -> (E)|id
E' {+,ε}

T'

F
 33
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id }
F -> (E)|id
E' {+,ε}

T { id , ( }

T'

F
 34
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id }
F -> (E)|id
E' {+,ε}

T { id , ( }

T' {*,ε }

F
 35
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id }
F -> (E)|id
E' {+,ε}

T { id , ( }

T' {*,ε}

F { id , ( }
 36
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id } {$,)}
F -> (E)|id
E' {+,ε}

T { id , ( }

T' {*,ε}

F { id , ( }
 37
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id } {$,)}
F -> (E)|id
E' {+,ε} {$,)}

T { id , ( }

T' {*,ε }

F { id , ( }
 38
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id } {$,)}
F -> (E)|id
E' {+,ε} {$,)}

T { id , ( } { $ , ) ,+ }

T' {*,ε }

F { id , ( }
 39
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id } {$,)}
F -> (E)|id
E' {+,ε} {$,)}

T { id , ( } { $ , ) ,+ }

T' {*,ε} {$,),+}

F { id , ( }
 40
Example of FIRST and FOLLOW

GRAMMAR:
E -> TE'
E'-> +TE'|ε Symbol FIRST FOLLOW
T -> FT'
T' -> *FT'|ε E { ( , id } {$,)}
F -> (E)|id
E' {+,ε} {$,)}

T { id , ( } { $ , ) ,+ }

T' {*,ε } {$,),+}

F { id , ( } {$,),+,*}
 41

STEP: PARSING TABLE

 42

Example of LL(1) grammar

E -> TE’
E’ -> +TE’|ε
T -> FT’
T’ -> *FT’|ε
F -> (E)|id
 43
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
TABLE E’
T
T’
F
 44
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E ->
TE’
TABLE
E’
T
T’
F
 45
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E -> E ->
TE’ TE’
TABLE
E’
T
T’
F
 46
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E -> E ->
TE’ TE’
TABLE
E’->
E’
+TE’
T
T’
 47
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E -> E ->
TE’ TE’
TABLE
E’-> E’ -> E’ ->
E’
+TE’ ε ε
T
T’
 48
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E -> E ->
TE’ TE’
TABLE
E’-> E’ -> E’ ->
E’
+TE’ ε ε
T ->
T
FT’
 49
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E -> E ->
TE’ TE’
TABLE
E’-> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
 50
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E -> E ->
TE’ TE’
TABLE
E’-> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
 51
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E -> E ->
TE’ TE’
TABLE
E’-> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
 52
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E -> E ->
TE’ TE’
TABLE
E’-> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
 53
Production Symbol FOLLOW
E -> TE’ { ( , id } {$,)}

E’ -> +TE’| {+,ε} {$,)}

ε
TABLE:
T -> FT’ { ( , id } {+,$,)}
FIRST & FOLLOW
T’ -> *FT’|ε {*, ε} {+,$,)}

F -> (E)|id { ( , id } { *, + , $ , ) }

Non
Termin INPUT SYMBOLS
al

TABLE: id + * ( ) $
PARSING E
E -> E ->
TE’ TE’
TABLE
E’-> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
 5
4
Continue…
Non
INPUT SYMBOLS
Terminal

id + * ( ) $
E E -> TE’ E -> TE’
E’->
E’ E’ -> ε E’ -> ε
+TE’
T T -> FT’ T -> FT’
T’ ->
T’ T’ -> ε T’ -> ε T’ -> ε
*FT’
F TABLE: PARSING TABLE
F -> id F -> (E)

 This grammar is LL(1).

 So, the parse tree can be derived from the stack
implementation of the given parsing table.
 55

Continue…

But
 There are grammars which may requite LL(1)
parsing.

 For e.g. Look at next grammar…..

 56

Continue…

TABLE: FIRST & FOLLOW

GRAMMAR:
SYMBOL FIRST FOLLOW
S  iEtSS’ | a
S a,i $,e
S’  eS |ε
S’ e,ε $,e
Eb
E b t
 57
SYMBOL FIRST FOLLOW
S  iEtSS’ |
a a,i $,e
TABLE:
S’  eS |ε
e, ε $,e
FAST & FOLLOW
Eb
b t

Non
Termin INPUT SYMBOLS
al
TABLE: a b e i t $
PARSING TABLE S
S’
E
 58
SYMBOL FIRST FOLLOW
S  iEtSS’ |
a a,i $,e
TABLE:
S’  eS |ε
e, ε $,e
FAST & FOLLOW
Eb
b t

Non
Termin INPUT SYMBOLS
al
TABLE: a b e i t $
PARSING TABLE S Sa
S’
E
 59
SYMBOL FIRST FOLLOW
S  iEtSS’ |
a a,i $,e
TABLE:
S’  eS |ε
e, ε $,e
FAST & FOLLOW
Eb
b t

Non
Termin INPUT SYMBOLS
al
TABLE: a b e i t $
PARSING TABLE S Sa
SiEtSS
’
S’
E
 60
SYMBOL FIRST FOLLOW
S  iEtSS’ |
a a,i $,e
TABLE:
S’  eS |ε
e, ε $,e
FAST & FOLLOW
Eb
b t

Non
Termin INPUT SYMBOLS
al
TABLE: a b e i t $
PARSING TABLE S Sa
SiEtSS
’
S’ S’  eS
E
 61
SYMBOL FIRST FOLLOW
S  iEtSS’ |
a a,i $,e
TABLE:
S’  eS |ε
e, ε $,e
FAST & FOLLOW
Eb
b t

Non
Termin INPUT SYMBOLS
al
TABLE: a b e i t $
PARSING TABLE S Sa
SiEtSS
’
S’  eS
S’ S’ε
S’ε
E
 62
SYMBOL FIRST FOLLOW
S  iEtSS’ |
a a,i $,e
TABLE:
S’  eS |ε
e, ε $,e
FAST & FOLLOW
Eb
b t

Non
Termin INPUT SYMBOLS
al
TABLE: a b e i t $
PARSING TABLE S Sa
SiEtSS
’
S’  eS
S’ S’ε
S’ε
E Eb
 63
SYMBOL FIRST FOLLOW
S  iEtSS’ |
a a,i $,e
TABLE:
S’  eS |ε
e, ε $,e
FAST & FOLLOW
Eb
b t

Non
Termin INPUT SYMBOLS
al
TABLE: a b e i t $
PARSING TABLE S Sa
SiEtSS
’
S’  eS
S’ S’ε
AMBIGUITY S’ε
E Eb
 Continue… 64

 The grammar is ambiguous and it is evident by the fact that

we have two entries corresponding to M[S’,e] containing
S’  ε and S’  eS.
 Note that the ambiguity will be solved if we use LL(2) parser,
i.e.
Always see for the two input symbols.
 LL(1) grammars have distinct properties.
- No ambiguous grammar or left recursive grammar
can be LL(1).
 Thus , the given grammar is not LL(1).
 65

STEP: STACK IMPLEMENTATION

 66

STACK Implementation

 The predictive parser uses an explicit stack to keep track of

pending non-terminals. It can thus be implemented without
recursion.
 Note that productions output are tracing out a lefmost
derivation
 The grammar symbols on the stack make up left-sentential
forms
 67

LL(1) Stack
 The input buffer contains the string to be parsed; $ is
the end-of-input marker
 The stack contains a sequence of grammar symbols
 Initially, the stack contains the start symbol of the
grammar on the top of $.
 68
LL(1) Stack

The parser is controlled by a program that behaves as follows:

The program considers X, the symbol on top of the stack, and
a, the current input symbol.
These two symbols, X and a determine the action of the
parser.
 There are three possibilities.
 69
LL(1) Stack

1. X  a  $,
the parser halts and annouces successful completion.
2. Xa$
the parser pops x off the stack and advances input pointer
to next input symbol
3. If X is a nonterminal, the program consults entry M[x,a] of
parsing table M.
If the entry is a production M[x,a] = {x → uvw } then
the parser replaces x on top of the stack by wvu (with
u on top).

As output, the parser just prints the production used:

x → uvw .
 70

LL(1) Stack

Grammar: Example:
E -> TE' Let’s parse the input
E'-> +TE'|ε string
T -> FT'
T' -> *FT'|ε id+idid
F -> (E)|id Using the
nonrecursive LL(1)
parser
 71
id + id  id $

E
$
stack Parsing
Table
Parsing Table
72

id + * ( ) $
E E →TE' E →TE'

E' E' → E' → E' →

+TE'
T T →FT' T →FT'

T' T' →  T →*FT' T' → T' →

F F → id F
→(E )
 73
id + id  id $

E
$
E →T E'
stack Parsing
Table
 74
id + id  id $

T
E'
$
TParsing
→ F T'
Non
Termin INPUT SYMBOLS
al

stack
Table M
id + * ( ) $
E -> E ->
E
TE’ TE’
E' -> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
T’ -> T’ -> T’ ->
 75
id + id  id $

F
T'
E'
$
→ id
FParsing
Non
Termin INPUT SYMBOLS
al

stack
Table M
id + * ( ) $
E -> E ->
E
TE’ TE’
E' -> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
T’ -> T’ -> T’ ->
 76
id + id  id $

id
T'
E'
$ Non
Termin INPUT SYMBOLS

stack
al
Parsing
Table M
id + * ( ) $
E -> E ->
E
TE’ TE’
E' -> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
T’ -> T’ -> T’ ->
 77
+ id  id $

T'
E'
$
T' → 
Non
Termin INPUT SYMBOLS

stack
al
Parsing
Table M
id + * ( ) $
E -> E ->
E
TE’ TE’
E' -> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
T’ -> T’ -> T’ ->
 78
+ id  id $

E'
$ Non
Termin
al → +T E'
E'Parsing
INPUT SYMBOLS

stack
Table M
id + * ( ) $
E -> E ->
E
TE’ TE’
E' -> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
T’ -> T’ -> T’ ->
 79
+ id  id $

+
T
E'
$ Non
Termin INPUT SYMBOLS

stack
al
Parsing
Table M
id + * ( ) $
E -> E ->
E
TE’ TE’
E' -> E’ -> E’ ->
E’
+TE’ ε ε
T -> T ->
T
FT’ FT’
T’ -> T’ -> T’ ->
 MATCHED STACK INPUT ACTION
E$ id+id * id$
TE’$ id+id * id$ E->TE’
80

FT’E’$ id+id * id$ T->FT’

id T’E’$ id+id * id$ F->id

id T’E’$ +id * id$ Match id
id E’$ +id * id$ T’->Є
id +TE’$ +id * id$ E’-> +TE’
id+ TE’$ id * id$ Match +

id+ FT’E’$ id * id$ T-> FT’

id+ idT’E’$ id * id$ F-> id

id+id T’E’$ * id$ Match id
id+id * FT’E’$ * id$ T’-> *FT’
id+id * FT’E’$ id$ Match *
id+id * idT’E’$ id$ F-> id
id+id * id T’E’$ $ Match id
id+id * id E’$ $ T’-> Є
id+id * id $ $ E’-> Є
 81

STEP: LL(1) PARSE TREE

LL(1) Parse Tree 82

 Top-down parsing expands a parse tree from

the start symbol to the leaves
 Always expand the leftmost non-terminal
 id+idid
E 83

E'
T

+ E'
F T' T


id  F T'

id * F T'
DONE…

id 