Chapter – three

Syntax analysis

1
A Predictive Parser table
E  TE’
E’  +TE’ | 
T  FT’
Grammar: T’  FT’ | 
F  ( E ) | id

NON- INPUT SYMBOL

TERMINAL id + * ( ) $
E E  TE’ E  TE’
Parsing E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
Table: T’ T’  T’  *FT’ T’   T’  
F F  id F  (E)

2
 Predictive Parsing Simulation

INPUT: id + id  id $ OUTPUT:
E

T E’
T
E
Predictive Parsing
STACK:
E’
$ Program
$

PARSING NON-
TERMINAL id +
INPUT SYMBOL
* ( ) $
TABLE: E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E) 3
 Predictive Parsing Simulation…

INPUT: id + id  id $ OUTPUT:
E

T E’
Predictive Parsing
STACK: T
F
Program F T’
T’
E’
E’
$
$

PARSING NON- INPUT SYMBOL

TERMINAL
TABLE: id + * ( ) $
E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E) 4
 Predictive Parsing Simulation…

INPUT: id + id  id $ OUTPUT:
E

T E’
Predictive Parsing
STACK: id
T
F
Program F T’
T’
E’
E’
$ id
$

PARSING NON- INPUT SYMBOL

TERMINAL
TABLE: id + * ( ) $
E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E) 5
 Predictive Parsing Simulation…

INPUT: id + id  id $ OUTPUT:
E

T E’
Predictive Parsing
STACK: T’
E’
Program F T’
E’
$
$ id 

PARSING NON- INPUT SYMBOL

TERMINAL
TABLE: id + * ( ) $
E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E) 6
 Predictive Parsing Simulation…

The predictive parser proceeds E

in this fashion using the T E’

following productions:
E’  +TE’ F T’ + T E’

T  FT’ id  F T’ 
F  id
id  F T’
T’   FT’
F  id id 
T’   When Top(Stack) = input = $
E’   the parser halts and accepts the
input string.
7
 Rules to Create FIRST
GRAMMAR: FIRST rules:
E  TE’ 1. If X is a terminal, FIRST(X) = {X}
E’  +TE’ | 
T  FT’ 2. If X   , then   FIRST(X)
T’  FT’ |  3. If X  Y1Y2 ••• Yk
F  ( E ) | id and Y1 ••• Yi-1 * 
SETS: and a FIRST(Yi)
FIRST(id) = {id} then a  FIRST(X)
FIRST() = {}
FIRST(+) = {+}
FIRST(() = {(}
FIRST()) = {)}
FIRST(E’) = {} {+, }
FIRST(T’) = {} {, }
FIRST(F) = {(, id}
FIRST(T) = FIRST(F) = {(, id}
FIRST(E) = FIRST(T) = {(, id}
8
 FIRST(E’) = {+, }
FIRST(T’) = { , }
FIRST(F) = {(, id}
FIRST(T) = {(, id}
Rules to Create FOLLOW
FIRST(E) = {(, id}

GRAMMAR: FOLLOW rules:

E  TE’ 1. If S is the start symbol, then $  FOLLOW(S)
E’  +TE’ | 
2. If A  B,
T  FT’
T’  FT’ | 
and a  FIRST()
F  ( E ) | id and a  
then a  FOLLOW(B)
SETS: 3. If A  B
FOLLOW(E) = {$} { ), $} and a  FOLLOW(A)
FOLLOW(E’) = { ), $} then a  FOLLOW(B)
FOLLOW(T) = { ), $} 3a. If A  B
 *  and
and a  FOLLOW(A)
then a  FOLLOW(B)

A and B are non-terminals,

 and  are strings of grammar symbols 9
 FIRST(E’) = {+, }
FIRST(T’) = { , }
FIRST(F) = {(, id}
FIRST(T) = {(, id}
Rules to Create FOLLOW
FIRST(E) = {(, id}

GRAMMAR: FOLLOW rules:

E  TE’ 1. If S is the start symbol, then $  FOLLOW(S)
E’  +TE’ | 
2. If A  B,
T  FT’
T’  FT’ | 
and a  FIRST()
F  ( E ) | id and a  
then a  FOLLOW(B)
SETS: 3. If A  B
FOLLOW(E) = {), $} and a  FOLLOW(A)
FOLLOW(E’) = { ), $} then a  FOLLOW(B)
FOLLOW(T) = { ), $} {+, ), $} 3a. If A  B
 *  and
and a  FOLLOW(A)
then a  FOLLOW(B)

10
 FIRST(E’) = {+, }
FIRST(T’) = { , }
FIRST(F) = {(, id}
FIRST(T) = {(, id}
Rules to Create FOLLOW
FIRST(E) = {(, id}

GRAMMAR: FOLLOW rules:

E  TE’ 1. If S is the start symbol, then $  FOLLOW(S)
E’  +TE’ | 
2. If A  B,
T  FT’
T’  FT’ | 
and a  FIRST()
F  ( E ) | id and a  
then a  FOLLOW(B)
SETS: 3. If A  B
FOLLOW(E) = {), $} and a  FOLLOW(A)
FOLLOW(E’) = { ), $} then a  FOLLOW(B)
FOLLOW(T) = {+, ), $} 3a. If A  B
 *  and
FOLLOW(T’) = {+, ), $}
and a  FOLLOW(A)
then a  FOLLOW(B)

11
 FIRST(E’) = {+, }
FIRST(T’) = { , }
FIRST(F) = {(, id}
FIRST(T) = {(, id}
Rules to Create FOLLOW
FIRST(E) = {(, id}

GRAMMAR: FOLLOW rules:

E  TE’ 1. If S is the start symbol, then $  FOLLOW(S)
E’  +TE’ | 
2. If A  B,
T  FT’
T’  FT’ | 
and a  FIRST()
F  ( E ) | id and a  
then a  FOLLOW(B)
SETS: 3. If A  B
FOLLOW(E) = {), $} and a  FOLLOW(A)
FOLLOW(E’) = { ), $} then a  FOLLOW(B)
FOLLOW(T) = {+, ), $} 3a. If A  B
 *  and
FOLLOW(T’) = {+, ), $}
FOLLOW(F) = {+, ), $} and a  FOLLOW(A)
then a  FOLLOW(B)

12
 FIRST(E’) = {+, }
FIRST(T’) = { , }
FIRST(F) = {(, id}
FIRST(T) = {(, id}
Rules to Create FOLLOW
FIRST(E) = {(, id}

GRAMMAR: FOLLOW rules:

E  TE’ 1. If S is the start symbol, then $  FOLLOW(S)
E’  +TE’ | 
2. If A  B,
T  FT’
T’  FT’ | 
and a  FIRST()
F  ( E ) | id and a  
then a  FOLLOW(B)
SETS: 3. If A  B
FOLLOW(E) = {), $} and a  FOLLOW(A)
FOLLOW(E’) = { ), $} then a  FOLLOW(B)
FOLLOW(T) = {+, ), $} 3a. If A  B
 * and
FOLLOW(T’) = {+, ), $}
FOLLOW(F) = {+, ), $} {+, , ), $} and a  FOLLOW(A)
then a  FOLLOW(B)

13
GRAMMAR: FIRST SETS: FOLLOW SETS:
E  TE’ FIRST(E’) = {+, } FOLLOW(E) = {), $}
Rules to Build Parsing Table
E’  +TE’ | 
T  FT’
FIRST(T’) = { , }
FIRST(F) = {(, id}
FOLLOW(E’) = { ), $}
FOLLOW(T) = {+, ), $}
T’  FT’ |  FIRST(T) = {(, id}
F  ( E ) | id FOLLOW(T’) = {+, ), $}
FIRST(E) = {(, id} FOLLOW(F) = {+, , ), $}

1. If A  :
if a  FIRST(), add A   to M[A, a]

PARSING NON- INPUT SYMBOL

TERMINAL id + * ( ) $
TABLE: E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E)

14
GRAMMAR: FIRST SETS: FOLLOW SETS:
E  TE’ FIRST(E’) = {+, } FOLLOW(E) = {), $}
Rules to Build Parsing Table
E’  +TE’ | 
T  FT’
FIRST(T’) = { , }
FIRST(F) = {(, id}
FOLLOW(E’) = { ), $}
FOLLOW(T) = {+, ), $}
T’  FT’ |  FIRST(T) = {(, id}
F  ( E ) | id FOLLOW(T’) = {+, ), $}
FIRST(E) = {(, id} FOLLOW(F) = {+, , ), $}

1. If A  :
if a  FIRST(), add A   to M[A, a]

PARSING NON- INPUT SYMBOL

TERMINAL id + * ( ) $
TABLE: E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E)

15
GRAMMAR: FIRST SETS: FOLLOW SETS:
E  TE’ FIRST(E’) = {+, } FOLLOW(E) = {), $}
Rules to Build Parsing Table
E’  +TE’ | 
T  FT’
FIRST(T’) = { , }
FIRST(F) = {(, id}
FOLLOW(E’) = { ), $}
FOLLOW(T) = {+, ), $}
T’  FT’ |  FIRST(T) = {(, id}
F  ( E ) | id FOLLOW(T’) = {+, ), $}
FIRST(E) = {(, id} FOLLOW(F) = {+, , ), $}

1. If A  :
if a  FIRST(), add A   to M[A, a]

PARSING NON- INPUT SYMBOL

TERMINAL id + * ( ) $
TABLE: E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E)

16
GRAMMAR: FIRST SETS: FOLLOW SETS:
E  TE’ FIRST(E’) = {+, } FOLLOW(E) = {), $}
Rules to Build Parsing Table
E’  +TE’ | 
T  FT’
FIRST(T’) = { , }
FIRST(F) = {(, id}
FOLLOW(E’) = { ), $}
FOLLOW(T) = {+, ), $}
T’  FT’ |  FIRST(T) = {(, id}
F  ( E ) | id FOLLOW(T’) = {+, ), $}
FIRST(E) = {(, id} FOLLOW(F) = {+, , ), $}

1. If A  :
if a  FIRST(), add A   to M[A, a]

PARSING NON- INPUT SYMBOL

TERMINAL id + * ( ) $
TABLE: E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E)

17
GRAMMAR: FIRST SETS: FOLLOW SETS:
E  TE’ FIRST(E’) = {+, } FOLLOW(E) = {), $}
Rules to Build Parsing Table
E’  +TE’ | 
T  FT’
FIRST(T’) = { , }
FIRST(F) = {(, id}
FOLLOW(E’) = { ), $}
FOLLOW(T) = {+, ), $}
T’  FT’ |  FIRST(T) = {(, id}
F  ( E ) | id FOLLOW(T’) = {+, ), $}
FIRST(E) = {(, id} FOLLOW(F) = {+, , ), $}

1. If A  :
if a  FIRST(), add A   to M[A, a]

PARSING NON- INPUT SYMBOL

TERMINAL id + * ( ) $
TABLE: E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E)

18
GRAMMAR: FIRST SETS: FOLLOW SETS:
E  TE’ FIRST(E’) = {+, } FOLLOW(E) = {), $}
Rules to Build Parsing Table
E’  +TE’ | 
T  FT’
FIRST(T’) = { , }
FIRST(F) = {(, id}
FOLLOW(E’) = { ), $}
FOLLOW(T) = {+, ), $}
T’  FT’ |  FIRST(T) = {(, id}
F  ( E ) | id FOLLOW(T’) = {+, ), $}
FIRST(E) = {(, id} FOLLOW(F) = {+, , ), $}

1. If A  :
if a  FIRST(), add A   to M[A, a]
2. If A  :
if   FIRST(), add A   to M[A, b]
for each terminal b  FOLLOW(A),

PARSING NON- INPUT SYMBOL

TERMINAL id + * ( ) $
TABLE: E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E)

19
GRAMMAR: FIRST SETS: FOLLOW SETS:
E  TE’ FIRST(E’) = {+, } FOLLOW(E) = {), $}
Rules to Build Parsing Table
E’  +TE’ | 
T  FT’
FIRST(T’) = { , }
FIRST(F) = {(, id}
FOLLOW(E’) = { ), $}
FOLLOW(T) = {+, ), $}
T’  FT’ |  FIRST(T) = {(, id}
F  ( E ) | id FOLLOW(T’) = {+, ), $}
FIRST(E) = {(, id} FOLLOW(F) = {+, , ), $}

1. If A  :
if a  FIRST(), add A   to M[A, a]
2. If A  :
if   FIRST(), add A   to M[A, b]
for each terminal b  FOLLOW(A),

PARSING NON- INPUT SYMBOL

TERMINAL id + * ( ) $
TABLE: E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E)

20
GRAMMAR: FIRST SETS: FOLLOW SETS:
E  TE’ FIRST(E’) = {+, } FOLLOW(E) = {), $}
Rules to Build Parsing Table
E’  +TE’ | 
T  FT’
FIRST(T’) = { , }
FIRST(F) = {(, id}
FOLLOW(E’) = { ), $}
FOLLOW(T) = {+, ), $}
T’  FT’ |  FIRST(T) = {(, id}
F  ( E ) | id FOLLOW(T’) = {+, ), $}
FIRST(E) = {(, id} FOLLOW(F) = {+, , ), $}

1. If A  :
if a  FIRST(), add A   to M[A, a]
2. If A  :
if   FIRST(), add A   to M[A, b]
for each terminal b  FOLLOW(A),
3. If A  :
if   FIRST(), and $  FOLLOW(A),
add A   to M[A, $]
PARSING NON- INPUT SYMBOL
TERMINAL id + * ( ) $
TABLE: E E  TE’ E  TE’
E’ E’  +TE’ E’   E’  
T T  FT’ T  FT’
T’ T’  T’  *FT’ T’   T’  
F F  id F  (E)

21
 Bottom-Up Parser
A bottom-up parser, or a shift-reduce parser, begins
at the leaves and works up to the top of the tree.

The reduction steps trace a rightmost derivation

on reverse.

S  aABe
Consider the Grammar: A  Abc | b
B d

We want to parse the input string abbcde.

22
 Bottom-Up Parser: Simulation

INPUT: a b b c d e $ OUTPUT:

Production
S  aABe
Bottom-Up Parsing
A  Abc
Program
Ab
Bd

23
 Bottom-Up Parser: Simulation

INPUT: a b b c d e $ OUTPUT:

Production
S  aABe
Bottom-Up Parsing
A  Abc Program A
Ab
Bd b

24
 Bottom-Up Parser: Simulation

INPUT: a A b c d e $ OUTPUT:

Production
S  aABe
Bottom-Up Parsing
A  Abc Program A
Ab
Bd b

25
 Bottom-Up Parser: Simulation

INPUT: a A b c d e $ OUTPUT:

Production
S  aABe
Bottom-Up Parsing
A  Abc Program A
Ab
Bd b

We are not reducing here in this example.

A parser would reduce, get stuck and then backtrack!

26
 Bottom-Up Parser: Simulation

INPUT: a A b c d e $ OUTPUT:

Production
A
S  aABe
Bottom-Up Parsing
A  Abc Program A b c
Ab
Bd b

27
 Bottom-Up Parser: Simulation

INPUT: a A d e $ OUTPUT:

Production
A
S  aABe
Bottom-Up Parsing
A  Abc Program A b c
Ab
Bd b

28
 Bottom-Up Parser: Simulation

INPUT: a A d e $ OUTPUT:

Production
A B
S  aABe
Bottom-Up Parsing
A  Abc Program A b c d
Ab
Bd b

29
 Bottom-Up Parser: Simulation

INPUT: a A B e $ OUTPUT:

Production
A B
S  aABe
Bottom-Up Parsing
A  Abc Program A b c d
Ab
Bd b

30
 Bottom-Up Parser: Simulation

INPUT: a A B e $ OUTPUT:
S
Production e
a A B
S  aABe
Bottom-Up Parsing
A  Abc Program A b c d
Ab
Bd b

31
Bottom-Up Parser: Simulation

INPUT: S $ OUTPUT:
S
Production e
a A B
S  aABe
Bottom-Up Parsing
A  Abc Program A b c d
Ab
Bd b

This parser is known as an LR Parser because

it scans the input from Left to right, and it constructs
a Rightmost derivation in reverse order.
32
 LR Parser: Simulation

Input

S
t
LR Parsing
a Output
Program
c
k

action goto

33
 LR Parser: Simulation

Can be parsed with this action

The following grammar: and goto table
(1) E E+T
(2) ET State action goto
id + * ( ) $ E T F
(3) T TF 0 s5 s4 1 2 3
(4) T F 1 s6 acc
2 r2 s7 r2 r2
(5) F (E) 3 r4 r4 r4 r4
(6) F  id 4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
11 r5 r5 r5 r5

34
GRAMMAR:
(1) E E+T
(2)
(3)
ET
T TF
LR Parser: Simulation
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: E
0
Program

State action goto

id + * ( ) $ E T F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
35
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E E+T
ET LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: E
5
Program
id
0
State action goto
id + * ( ) $ E T F F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
36
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E E+T
ET
LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: 0
Program

State action goto

id + * ( ) $ E T F F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
37
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E E+T
ET LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: E
3
Program
F
0 T
State action goto
id + * ( ) $ E T F F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
38
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E E+T
ET LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: 0
Program

T
State action goto
id + * ( ) $ E T F F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
39
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E E+T
ET LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: E
2
Program
T
0 T
State action goto
id + * ( ) $ E T F F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
40
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E
E
E+T
T LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: E
7
Program

2 T
T State action goto
0 id + * ( ) $ E T F F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
11 r5 r5 r5 r5 41
GRAMMAR:
(1)
(2)
E
E
E+T
T LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: E
5
Program
id
7 T F
 State action goto
2 id + * ( ) $ E T F F id
T 0 s5 s4 1 2 3
1 s6 acc
0 2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
42
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E
E
E+T
T LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: E
7
Program

2 T F
T State action goto
0 id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
43
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E
E
E+T
T
LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: 10
E T
Program
F
7 T  F
 State action goto
2 id + * ( ) $ E T F F id
T 0 s5 s4 1 2 3
1 s6 acc
0 2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
44
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E E+T
ET LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id

LR Parsing
STACK: 0 T
Program

T  F
State action goto
id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
45
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E E+T
ET
LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id
E
LR Parsing
STACK: 2 T
Program
T
0 T  F
State action goto
id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
46
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E E+T
ET
LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id
E
LR Parsing
STACK: 0 T
Program

T  F
State action goto
id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
47
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E E+T
E’  T
LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id
E
LR Parsing
STACK: 1 T
Program
E
0 T  F
State action goto
id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
48
11 r5 r5 r5 r5
GRAMMAR:
(1)
(2)
E
E
E+T
T
LR Parser: Simulation
(3) T TF
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id
E
LR Parsing
STACK: 6 T
Program
+
1 T  F
E State action goto
0 id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
49
11 r5 r5 r5 r5
GRAMMAR:
(1) E E+T
(2)
(3)
E
T
T
TF
LR Parser: Simulation
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id
E
LR Parsing
STACK: 5 T F
Program
id
6 T  F id
+ State action goto
1 id + * ( ) $ E T F F id
E 0 s5 s4 1 2 3
1 s6 acc
0 2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
50
11 r5 r5 r5 r5
GRAMMAR:
(1) E E+T
(2)
(3)
E
T
T
TF
LR Parser: Simulation
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id
E
LR Parsing
STACK: 6 T F
Program
+
1 T  F id
E State action goto
0 id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
51
11 r5 r5 r5 r5
GRAMMAR:
(1) E E+T
(2)
(3)
E
T
T
TF
LR Parser: Simulation
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id
E T
LR Parsing
STACK: 3 T F
Program
F
6 T  F id
+ State action goto
1 id + * ( ) $ E T F F id
E 0 s5 s4 1 2 3
1 s6 acc
0 2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
52
11 r5 r5 r5 r5
GRAMMAR:
(1) E E+T
(2)
(3)
E
T
T
TF
LR Parser: Simulation
OUTPUT:
(4) T F
(5) F (E)
INPUT: id  id + id $
(6) F  id
E
LR Parsing
STACK: 6 T F
Program
+
1 T  F id
E State action goto
0 id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
53
11 r5 r5 r5 r5
GRAMMAR:
(1) E E+T
(2)
(3)
E
T
T
TF
LR Parser: Simulation
OUTPUT:
(4) T F
(5) F (E) E
INPUT: id  id + id $
(6) F  id
E + T
LR Parsing
STACK: 9 T F
Program
T
6 T  F id
+ State action goto
1 id + * ( ) $ E T F F id
E 0 s5 s4 1 2 3
1 s6 acc
0 2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
54
11 r5 r5 r5 r5
GRAMMAR:
(1) E E+T
(2)
(3)
ET
T TF
LR Parser: Simulation
OUTPUT:
(4) T F
(5) F (E) E
INPUT: id  id + id $
(6) F  id
E + T
LR Parsing
STACK: 0 T F
Program

T  F id
State action goto
id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
55
11 r5 r5 r5 r5
GRAMMAR:
(1) E E+T
(2)
(3)
E
T
T
TF
LR Parser: Simulation
OUTPUT:
(4) T F
(5) F (E) E
INPUT: id  id + id $
(6) F  id
E + T
LR Parsing
STACK: 1 T F
Program
E
0 T  F id
State action goto
id + * ( ) $ E T F F id
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
id
3 r4 r4 r4 r4
4 s5 s4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 9 3
7 s5 s4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
56
11 r5 r5 r5 r5