Learn Compiler Design: From B. K.

Sharma

UNIT I

Lexical Analysis: NFA To DFA

Learn Compiler Design: From B. K. Sharma

Unit I: Syllabus
• Introduction to Compiler
• Major Data Structures in Compiler
• Types of Compiler
• Front-End and Back-End of Compiler
• Compiler Structure:
– Analysis-synthesis model of compilation
• Various phases of Compiler
Learn Compiler Design: From B. K. Sharma

Unit I: Syllabus
• Lexical Analysis:
– Input Buffering
– Specification and Recognition of Tokens
– Design of a Lexical Analyzer Generator
• Lex
Learn Compiler Design: From B. K. Sharma
Summary of Lecture 9: Regular Expression and
Lexical Analyzer
1: Abstract model of a computing entity or digital
computers that decides whether to accept or reject a
string is called
2: In Finite Automaton, the automaton is exactly one of a
finite number of states at any given time.
3: Two main types of automata are DFA and NFA.
4: Three specifications of tokens are : string, language and
regular expressions.
5. Regular language is accepted by Finite Automata and is
described by regular expression.
6: Tokens are specified by regular expressions and recognized
by Finite Automata.
7: Thompson’s Construction is used to convert regular expressions to NFA with
-moves
Learn Compiler Design: From B. K. Sharma

Mapping of Lesson with Course Outcome

(CO)
Lesson CO
Lesson 10: Conversion Understand Lexical
of NFA to DFA Analysis and
implement it using lex
tool.
Learn Compiler Design: From B. K. Sharma
Lesson 9: Regular Expression and Finite
Automata : Learning Outcomes
At the end of this lesson, students will be able to

1: Define NFA with ε-moves.

2: Convert NFA with ε-moves into DFA using

subset construction algorithm.
Learn Compiler Design: From B. K. Sharma

Active Learning Activity: Diagnostic

Assessment
One- Minute Paper
Observe the following FA and answer the
question given below:

Justify the statement “The above finite

automata is DFA as well as NFA”.
Learn Compiler Design: From B. K. Sharma

Inside the scanner generator

RE

Thompson construction

NFA

Subset construction

DFA

Minimization Hopcroft’s Algorithm

Minimized DFA

DFA simulation Scanner

generator

Scanner Program
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

NFA with ε move:
If any FA contains ε transition or move, the finite
automata is called NFA with ε move.
The subset construction algorithm converts an NFA
with ε moves into a DFA using:

ε-Closure(s): ε-Closure of a state s

ε-Closure(S): ε-Closure of a set of states S

MoveNFA(S, α): δ(S, α)

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

ε-Closure(s):Example
ε-Closure(s): A set of states which can be reached
from the state s with only ε(null) move
including the state s itself.

ε-closure {q0} = {q0, q1, q2} ε-closure {q1} = {q1}

ε-closure {q2} = {q2} ε-closure {q3} = {q3}
ε-closure {q4} = {q4}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

ε-Closure(S):

Given a set of states S, ε-Closure(S) will give the

set of states reachable from each state in S using
only ε transition.

Where S is a subset of set of states Q.

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

ε-Closure(S):Example

ε-closure ({q0,q1,q2}) =ε-closure (q0) U ε-closure (q1)

U ε-closure (q2)
= {q0, q1, q2} U {q1) U {q2)
= {q0, q1, q2}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

MoveNFA(S, α): δ(S, α)

Set of NFA states to which there is a transition

on input symbol ‘α’ from some state ‘s’ in S.

Set of all NFA states reachable from the set S

upon ‘α’ as input symbol.
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Example of MoveNFA(S, α): δ(S, α)

MoveNFA((q0, q1, q2), 0)

= ε-closure {MoveNFA((q0, q1, q2), 0) }
= ε-closure {MoveNFA(q0, 0) ∪ MoveNFA(q1, 0)
∪ MoveNFA(q2, 0) }
= ε-closure {q3}
= {q3}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Example of MoveNFA(S, α): δ(S, α)

MoveNFA((q0, q1, q2), 1)

= ε-closure {MoveNFA((q0, q1, q2), 1) }
= ε-closure {MoveNFA(q0, 1) ∪
MoveNFA( q1, 1) ∪ MoveNFA( q2, 1) }
= ε-closure {q3}
= {q3}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm

Operation Description
Set of NFA states reachable from NFA
ε- closure(s)
state s on ε-transitions alone.
Set of NFA states reachable from some
NFA state s in set S on ε-transitions
ε- closure(S) alone.
= ∪s in S ε- closure(s)
Set of NFA states to which there is a
move(S, α) transition on input symbol α from some
state s in S
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm

ε-Closure(s): {s}  {t  s  …  t}

ε-Closure(S): sS -closure(s)

MoveNFA(S, α): {t  s  α t and s  T}

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Examples of -closure and move
a
 1 2

start b b
 a
0 3 4 5 6
a b

 b
7 8

-closure({0}) = {0,1,3,7} move({0,1,3,7},a) = {2,4,7}

-closure({2,4,7}) = {2,4,7} move({2,4,7},a) = {7}

-closure({7}) = {7} move({7},b) = {8}

-closure({8}) = {8} move({8},a) = 
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 1

ε-closure {q0} = {q0, q1, q2} ε-closure {q1} = {q1}

ε-closure {q2} = {q2} ε-closure {q3} = {q3}

ε-closure {q4} = {q4}

Now, let ε-closure {q0} = {q0, q1, q2} be state A.
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 1

MoveDFA((q0, q1, q2), 0)=MoveDFA(A, 0)

= ε-closure {MoveNFA((q0, q1, q2), 0) }
= ε-closure {MoveNFA(q0, 0) ∪ MoveNFA(q1, 0)
∪ MoveNFA(q2, 0) }
= ε-closure {q3}
= {q3} call it as state B.
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 1

MoveDFA (A, 1) = ε-closure {MoveNFA((q0, q1, q2), 1) }

= ε-closure {MoveNFA((q0, 1) ∪
MoveNFA(q1, 1) ∪ MoveNFA(q2, 1) }
= ε-closure {q3}
= {q3} = B.
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 1

NFA

The Partial DFA:

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 1

Now, for state B:

MoveDFA(B, 0) = ε-closure {MoveNFA(q3, 0) } = ϕ
MoveDFA(B, 1) = ε-closure {MoveNFA(q3, 1) }
= ε-closure {q4} = {q4} i.e. state C
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 1

For state C:
MoveDFA(C, 0) = ε-closure {MoveNFA(q4, 0) } = ϕ
MoveDFA(C, 1) = ε-closure {MoveNFA(q4, 1) } = ϕ
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 1

The DFA is :
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2
Convert the given NFA into its equivalent DFA.
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

ε-closure(q0) = {q0, q1, q2}

ε-closure(q1) = {q1, q2}
ε-closure(q2) = {q2}
Let ε-closure(q0) = {q0, q1, q2}, call it as state A.
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

MoveDFA (A, 0) = ε-closure{MoveNFA((q0, q1, q2), 0)}

= ε-closure{MoveNFA(q0, 0) ∪
MoveNFA (q1, 0) ∪ MoveNFA (q2, 0)}
= ε-closure{q0}
= {q0, q1, q2}=A
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

MoveDFA(A, 1) = ε-closure{MoveNFA((q0, q1, q2), 1)}

= ε-closure{MoveNFA(q0, 1) ∪ δ(q1, 1) ∪
MoveNFA (q2, 1)}
= ε-closure{q1}

= {q1, q2} call it as state B

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

MoveDFA(A, 2) = ε-closure{MoveNFA((q0, q1, q2), 2)}

= ε-closure{MoveNFA(q0, 2) ∪ MoveNFA (q1, 2) ∪

MoveNFA (q2, 2)}

= ε-closure{q2}
= {q2} call it state C
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

Thus we have obtained The partial DFA will be:

MoveDFA(A, 0) = A
MoveDFA(A, 1) = B
MoveDFA(A, 2) = C
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

Now we will find the transitions on states B and C for

each input.
MoveDFA(B, 0) = ε-closure{MoveNFA((q1, q2), 0)}
= ε-closure{MoveNFA(q1, 0) ∪ MoveNFA (q2, 0)}
= ε-closure{ϕ}
= ϕ
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

MoveDFA(B, 1) = ε-closure{MoveNFA((q1, q2), 1)}

= ε-closure{MoveNFA(q1, 1) ∪ MoveNFA (q2, 1)}
= ε-closure{q1}
= {q1, q2} i.e. state B itself
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

MoveNFA(B, 2) = ε-closure{MoveNFA((q1, q2), 2)}

= ε-closure{MoveNFA(q1, 2) ∪ MoveNFA (q2, 2)}

= ε-closure{q2}

= {q2} i.e. state C itself

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

The partial transition diagram will

Thus we have obtained be
MoveDFA(B, 0) = ϕ
MoveDFA(B, 1) = B
MoveDFA(B, 2) = C
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

Now we will obtain transitions for C:

MoveDFA(C, 0) = ε-closure{MoveNFA(q2, 0)}
= ε-closure{ϕ}
= ϕ
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

MoveDFA(C, 1) = ε-closure{MoveNFA(q2, 1)}

= ε-closure{ϕ}
= ϕ
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

MoveDFA(C, 2) = ε-closure{MoveNFA(q2, 2)}

= {q2}, C itself
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

Hence the DFA

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 2

As A = {q0, q1, q2} in which final state q2 lies hence A is

final state. B = {q1, q2} in which the state q2 lies hence
B is also final state. C = {q2}, the state q2 lies hence C
is also a final state.
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 3
Convert the given NFA for (alb) * abb into its equivalent
DFA.

a
2 3
start     a b b
0 1 6 7 8 9 10

4 b
b
5 

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

The subset construction algorithm
Example: 3

a
2 3

start    a b b
0 1 6 7 8 9 10

4
bb
5



First we calculate ε-closure of each state in the NFA:
ε-closure(s)
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA


a
2 3

start    a b b
0 1 6 7 8 9 10

4
bb
5


ε-closure(0)= {0,1,2,4,7} ε-closure(5)= {1, 2, 4, 5, 6, 7}

ε-closure(1)= {1,2,4}  ε-closure(6)= {1, 2, 4, 6, 7}
ε-closure(2)= {2} ε-closure(7)= {7}
ε-closure(3)= {1,2,3,4,6,7}
ε-closure(8)= {8}
ε-closure(4)= {4} ε-closure(9)= {9}
ε-closure(10)={10}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA


a
2 3
start     a b b
0 1 6 7 8 9 10

4 b
b
5 

Second step: Look for the start state of equivalent DFA
The start state A of the equivalent DFA is ε-closure(0)=
{0,1,2,4,7}
Then the starting state A= {0,1,2,4,7}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Third step: compute ε-closure( MoveNFA( S, α))

First Compute input alphabet: { a, b }

Second compute:
1: MoveDFA(A,a)= ε-closure( MoveNFA( A, a))
2: MoveDFA(A,b)= ε-closure( MoveNFA( A, b))
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA


a
2 3
start     a b b
0 1 6 7 8 9 10

4 bb 5 

Third step: compute ε-closure(MoveNFA( S, α))
1: MoveDFA(A,a)= ε-closure(MoveNFA( A, a))
=ε-closure(MoveNFA({0,1,2,4,7},a)
Among states {0,1,2,4,7}, only 2 and 7 have
transitions on ‘a’ to 3, 8 respectively.
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA


a
2 3
start     a b b
0 1 6 7 8 9 10

4 bb 5 

Thus, MoveNFA(A,a)={3,8}
Now, ε-closure({3,8})= {1,2,3,4,6,7,8}
Thus we conclude:
1: MoveDFA(A,a)= ε-closure(MoveNFA( A, a))
= ε-closure({3,8})= {1,2,3,4,6,7,8}
Call this new state B = {1,2,3,4,6,7,8}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Third step: compute ε-closure(MoveNFA( S, α))
1: MoveDFA(A,a)= B
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA


a
2 3
start     a b b
0 1 6 7 8 9 10

4 bb 5 

Third step: compute ε-closure(MoveNFA( S, α))
2: MoveDFA(A,b)= ε-closure(MoveNFA( A, b))
=ε-closure(MoveNFA({0,1,2,4,7},b)

Among states {0,1,2,4,7}, only 4 has transitions on

‘b’ and it goes to 5.
Thus, MoveNFA(A,b)={5}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA


a
2 3
start     a b b
0 1 6 7 8 9 10

4 bb 5 

Now, ε-closure({5})= {1,2,4,5,6,7}
1: MoveDFA(A,b)= ε-closure(MoveNFA( A, b))
= ε-closure({5})= {1,2,4,5,6,7}
Call this new state C = {1,2,4,5,6,7}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Third step: compute ε-closure(MoveNFA( S, a))
1: MoveDFA(A,b)= C
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Partial DFA:
b

b C
a

Start a b
A B
a
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Third compute:
3: MoveDFA(B,a)= ε-closure( MoveNFA( B, a))
4: MoveDFA(B,b)= ε-closure( MoveNFA( B, b))
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

3: MoveDFA(B,a)= ε-closure( MoveNFA( B, a))

B = {1,2,3,4,6,7,8}

Among states of B={1,2,3,4,6,7,8}, only 2 and 7

have transitions on ‘a’ and it goes to 3 and 8
respectively.
Thus MoveDFA(B,a)= ε-closure( MoveNFA( B, a))
= ε-closure({3,8})={1,2,3,4,6,7,8}
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

MoveDFA(B,a)= B
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

4: MoveDFA(B,b)= ε-closure( MoveNFA( B, b))

B = {1,2,3,4,6,7,8}

Among states of B={1,2,3,4,6,7,8}, only 4 and 8 have

transitions on ‘b’ and it goes to 5 and 9 respectively.

Thus MoveDFA(B,b)= ε-closure( MoveNFA( B, b))

= ε-closure({5,9})={1,2,4,5,6,7,9}=D
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

MoveDFA(B,b)=D
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Fourth compute:
5: MoveDFA(C,a)= ε-closure( MoveNFA( C, a))
6: MoveDFA(C,b)= ε-closure( MoveNFA( C, b))
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

5: MoveDFA(C,a)= ε-closure( MoveNFA( C, a))
C = {1,2,4,5,6,7}

Among states of C={1,2,4,5,6,7}, only 2 and 7 have

transitions on ‘a’ and it goes to 3 and 8 respectively.

Thus MoveDFA(C,a)= ε-closure( MoveNFA( C, a))

= ε-closure({3,8})={1,2,3,4,6,7,8}=B
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

MoveDFA(C,a)=B
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

6: MoveDFA(C,b)= ε-closure( MoveNFA( C, b))
C= {1,2,4,5,6,7}

Among states of C={1,2,4,5,6,7}, only 4 has transition

on ‘b’ and it goes to 5.

Thus MoveDFA(C,b)= ε-closure( MoveNFA( C, b))

= ε-closure({5})={1,2,4,5,6,7}=C
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

MoveDFA(C,b)=C
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Fifth compute:
7: MoveDFA(D,a)= ε-closure( MoveNFA( D, a))
8: MoveDFA(D,b)= ε-closure( MoveNFA( D, b))
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

7: MoveDFA(D,a)= ε-closure( MoveNFA( D, a))

D= {1,2,4,5,6,7,9}

Among states of D={1,2,4,5,6,7,9}, only 2 and 7 have

transitions on ‘a’ and it goes to 3 and 8 respectively.

Thus MoveDFA(D,a)= ε-closure( MoveNFA( D, a))

= ε-closure({3,8})={1,2,3,4,6,7,8}=B
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

MoveDFA(D,a)=B
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

8: MoveDFA(D,b)= ε-closure( MoveNFA( D, b))

D= {1,2,4,5,6,7,9}

Among states of D={1,2,4,5,6,7,9}, only 4 and 9 have

transitions on ‘b’ and it goes to 5 and 10 respectively.

Thus MoveDFA(D,b)=ε-closure( MoveNFA( D, b))

=ε-closure({5,10})={1,2,4,5,6,7,10}=E
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

MoveDFA(D,b)=E
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Sixth compute:
9: MoveDFA(E,a)= ε-closure( MoveNFA( E, a))
10: MoveDFA(E,b)= ε-closure( MoveNFA( E, b))
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

9: MoveDFA(E,a)= ε-closure( MoveNFA( E, a))
E= {1,2,4,5,6,7,10}

Among states of E={1,2,4,5,6,7,10}, only 2 and 7

have transitions on ‘a’ and it goes to 3 and 8
respectively.
Thus MoveDFA(E,a)=ε-closure( MoveNFA( E, a))
=ε-closure({3,8})={1,2,3,4,6,7,8}=B
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

MoveDFA(E,a)=B
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

10: MoveDFA(E,b)= ε-closure( MoveNFA( E, b))
E= {1,2,4,5,6,7,10}

Among states of E={1,2,4,5,6,7,10}, only 4 has

transition on ‘b’ and it goes to 5.

Thus MoveDFA(E,b)=ε-closure( MoveNFA( E, b))

=ε-closure({5})={1,2,4,5,6,7}=C
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

MoveDFA(E,b)=C
Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

Transition Table for DFA

Learn Compiler Design: From B. K. Sharma

NFA with ε-moves to DFA

RESULT OF APPLYING SUBSET CONSTRUCTION

FOR NFA N for RE(alb) * abb to DFA
Learn Compiler Design: From B. K. Sharma
Summary of Lecture 10: Regular Expression and
Lexical Analyzer
1: If any FA contains ε transition or move, the finite
automata is called NFA with ε move.

2: The subset construction algorithm converts an NFA with

ε moves into a DFA using:

ε-Closure(s):
ε-Closure(S): ε-Closure of a set of states S

MoveNFA(S, α):
Learn Compiler Design: From B. K. Sharma

Regular Expressions and FSA: Questions

How is Finite Automata useful for lexical analysis?
Construct the NFA and DFA for the following regular
expression: ( a + b )*abb

Construct minimum state expression DFA for the following

regular expression:

(a | b)* a(a | b)

Show the construction of NFA for following regular

expression.

(a | b)*a (a | b)
Draw the transition diagram for identifiers.