NFA state DFA state a b

{1, 2} A B C
{3,4,5} B {} B
{4,5} C {} B

Epison-Closure({1}) = {1,2}

D-trans[A,a] = epison-Closure(move(A, a)) = {3} = {3,4,5}

move(A, b) = {4}

move(B, a) = {}

move(B, b) = {4} = {3,4,5}

move(C,a) = {}

move(C,b) = {4} = {3,4,5}

start state=A

end state=B,C
Epilson-closure({0})={0,1,2,3,7}

D-trans[A,a] = epilson-closure(Move(A,a)) = {2} = {1,2,3,4,6,7}

Move(A,b) = {3} = {1,2,3,5,6,7}

Move(B,a) = {2} = {1,2,3,4,6,7}

Move(B,b) = {3} = {1,2,3,5,6,7}

Move(C,a) = {2} = {1,2,3,4,6,7}

Move(c,b) = {3} = {1,2,3,5,6,7}

NFA DFA a b
{0,1,2,3,7} A B C
{1,2,3,4,6,7} B B C
{1,2,3,5,6,7} C B C
Epilson-closure({0}) = {0,1,2,3,4,6,7,9,10}

Move(A,a) = {3} = {1,2,3,4,5,6,7,9,10}

Move(A,b) = {7} = {1,2,3,4,5,6,7,8,9,10}

Move(B,a) = {3}= {1,2,3,4,5,6,7,9,10}

Move(B,b) = {7} = {1,2,3,4,5,6,7,8,9,10}

Move(C,a) = {3} = {1,2,3,4,5,6,7,9,10}

Move(C,b) = {7} = {1,2,3,4,5,6,7,8,9,10}

NFA DFA a b
{0,1,2,3,4,6,7,9,10} A B C
{1,2,3,4,5,6,7,9,10} B B C
{1,2,3,4,6,7,8,9,10} C B C
3a)

<id,celcius><=><punc,(><id,fahreiheit><op,-><number,32><punc,)><op,*><punc,
(><number,5><op,/><number,9><punc,)>

b)

Lexeme Token Type Token

celcius identifier <identifier,celcius>
= operator <op,=>
( punctuation <(>
fahrenheit identifier <id, Fahrenheit>
) punctuation <)>
- operator <op,->
32 number <number,32>
* op <op,*>
/ op <op,/>
5 number <number,5>
9 number <number,9>

Celcius -1

Fahrenheit - 2

c)

[a-z] = ([a-z]-[0-9]2)*([0-9]1/[0-9]1)

IRST E = FIRST T = {int,(}

FIRST T = {int,(}
FIRST X = {+,e}

FIRST Y = {*,e}

FOLLOW E = {),$}

FOLLOW T = FOLLOW(Y) + FIRST(Y) + FOLLOW(X) = apa ni

FOLLOW X = FOLLOW(E) = {),$}

FOLLOW Y = FOLLOW(T) + FIRST(T) = apa ni

A+a |a*a |(a)

A*(a+a)

E -> E *E

->E * (E)

->E*(E+E)

E -> E + F | F

F -> F * A |A

A -> (

4a)
b)

E -> E + E I E * E I (E) l id

1.Eliminating ambiguous

E -> E + F | F

F -> F * A | A

A -> (E) | id

2.Eliminating left recursive grammar

E’ -> E’ + F

E -> FE’ | ϵ

F’ -> F * A’

F -> AF’ | ϵ

A -> (E) | id
5a)

S -> 0A

A ->0A1 | 1

FIRST(S) = {0}

FIRST(A) = {0,1}

FOLLOW(S) = {$}

FOLLOW(A) = FOLLOW(S) U {1} = {$,1}

Parsing table

0 1
S S -> 0A

A A ->0A1 A ->1
W=0011

Matched Stack Input Action

S$ 0011$ S -> 0A
0A$ 0011$ match 0
0 A$ 011$ A ->0A1
00 0A1$ 011$ match 0
A1$ 11$ A ->1
001 11$ 11$ match 1
0011 1$ 1$ match 1
$ $ stop

a)

FIRST FOLLOW
start FIRST(decl) = {int,string} {$}
decl FIRST(type) = {int,string} FIRST(stmt) = {id}
type {int,string} First(list) = {id}
list {id} {;}
more {,e} FOLLOW(list) = {;}
stmt {id} FOLLOW(start) = {$}
expr {id,number} FOLLOW(stmt) = {$}
b)

int string ; , id number

start start->decl start->decl
tsmt tsmt
decl decl -> decl -> type
type list ; list ;
type type -> int type -> string
list list ->id
more
more more - more -
>e >, id
more
stmt stmt ->
id :=
expr
expr expr -> expr -> number
id

Non Terminal First Follow

S [,a First(x) u first(y) u follow(x) u
follow(y) = $,b,c,],+,-
X {+,€} u FIRST(Y) = {+,€,-} ] ,c
Y {-,€} {b} u FOLLOW(X) = b,],c

NT [ ] a b c + $ -
S S->[SX] S->a
X X->e X->e X->+SY X->e
Y Y->e Y->e Y->e Y->-SXc
b) w = [a+a-ac]
 Matched Stack Input Action
S$ [a+a-ac]$ S->[SX]
[ [SX]$ [a+a-ac]$ match [
[ SX]$ a+a-ac]$ S->a
[a aX]$ a+a-ac]$ match a
[a X]$ +a-ac]$ X->+SY
[a +SY]$ +a-ac]$ match +
[a+ SY]$ a-ac]$ S->a
[a+ aY]$ a-ac]$ match a
[a+a Y]$ -ac]$ Y -> -SXc
[a+a -SXc]$ -ac]$ match -
[a+a- SXc]$ ac]$ S->a
[a+a- aXc]$ ac]$ match a
[a+a-a Xc]$ c]$ X->€
[a+a-a c]$ c]$ match c
[a+a-ac ]$ ]$ match ]
[a+a-ac] $ $ accept

a)

i. S -> do S while S

-> do while S do S while S

-> do while do S while S do S while S

->do while do while S do S while S

-> do while do while do S while S

-> do while do while do while S

-> do while do while do while

ii)

S -> do S while S

 do while S
 do while do S while S
 do while do while S do S while S
 do while do while do S while S
 do while do while do while S
 do while do while do while

1.

S’ -> S

S -> aSbS

S -> a

W=aab#

Stack Symbol Input Action

0 $ aab#$ s3
03 $a ab#$ s3
033 $aa b#$ s4
0334 $aab #$ r3
0336 $aaA #$ r2
036 $aA #$ r2
02 $A #$ s5
025 $A# $ r1
01 $$ $ accept