Vous êtes sur la page 1sur 199

# M. Sc.

## Part I [COMPUTER SCIENCE]

Practical Journal [ Principles of Compiler Design ]
Seat Number [ ]

## Department of Computer Science and Information Technology

Deccan Education Society’s
Kirti College of Arts, Science and Commerce.
[ NAAC Accredited : “A Grade”]
Department of Computer Science and Information Technology
Deccan Education Society’s
Kirti College of Arts, Science and Commerce.
[ NAAC Accredited : “A Grade”]

CERTIFICATE

## SCIENCE] with Seat No._______has successfully completed the practical of

Principles of Compiler Design under my supervision in this college during the year

2006 - 2007.

( Mrs.Akshata Nayak) Dept of Com.Sc and I.T
(Dr. Seema Purohit)
Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07
Compiler Construction ( Section-I )
INDEX

2 NFA to DFA

## 5 LL(1) Parsing Table

6 Warshall’s Algorithm

7 LR(0) Parsing

## 12 Linearizing a given SPM

Parsing using Simple Precedence
13 Function
14 Operator Precedence Matrix (OPM)
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 1

## Suppose the following transition table

a B
0 1 0
1 1 2
2 0 2

Find the string you are enter is accepted by above DFA or not?
PROGRAM:

#include<iostream.h>
#include<conio.h>
#include<process.h>
#include<string.h>

class p_dfa
{
int n,n1,n2,final[10],fa[10][10];
char ch[10],*str;
public:
void accept();
void dfa(char*);
};

void p_dfa::accept()
{
int i,j;
cout << endl << "No. of states in DFA are:";
cin >> n;
cout << endl << "No. of final states in DFA are:";
cin >> n1;
cout << endl << "Enter state number(s) of final states(s):";
for(i=0;i<n1;i++)
cin >> final[i];

cout << endl << "No. of characters you are using in DFA are:";
cin >> n2;
cout << endl << "Enter those characters one by one:" << endl;
for(i=0;i<n2;i++)
cin >> ch[i];

## cout << endl << "Describe your DFA" << endl;

cout << endl << "If char 'A' is output from stayte i to state j";
cout << endl << "then write j at combination of i & 'A'" << endl;

for(i=0;i<n2;i++)
cout << "\t" << ch[i];
cout << endl;

for(i=0;i<n;i++)
{
cout << i << "\t";
for(j=0;j<n2;j++)
cin >> fa[i][j];
}
cout << endl << "Enter the string to be tested:";
cin >> str;
dfa(str);
}

## void p_dfa::dfa(char *str)

{
int i,j,len,state=0,flag;
char c;
len = strlen(str);

for(i=0;i<len;i++)
{
c = str[i];
for(j=0;j<n2;j++)
{
if(c == ch[j])
{
if(fa[state][j] != 0)
{
state = fa[state][j];
break;
}
else
{
cout << endl << "Error!!!";
cout << endl << "Invalid string";

exit(0);
}
}
}
}
flag=0;
for(i=0;i<n1;i++)
if(state == final[i])
{
cout << endl << "Valid string";
flag=1;
}

if(flag=0)
cout << endl << "Invalid string (Final state never obtained)!!!";
}
void main()
{
p_dfa d;
clrscr();

d.accept();
getch();
}
OUTPUT:

ab

## If char 'A' is output from stayte i to state j

then write j at combination of i & 'A'
a b
0 1 0
1 1 2
2 0 2

Valid string

## 2) Enter the string to be tested: abab

Error!!!
Invalid string
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 2

## You are provided with a NFA with λ moves

a. Write the transition table.
b. Write the procedure to convert the NFA with λ closure to it equivalent
without λ moves.
c. Implement it in C++. Finally output the transition table of the converted
NFA.
Consider the following transition table for (a+b)*abb

e a B
0 {1,7} - -
1 {2,4} - -

2 - 3 -
3 {6} - -

4 - - 5
5 {6} - -
6 {1,7} - -

7 - 8 -
8 - - 9
9 - - 10
10 - - -

PROGRAM:

## //PROGRAM FOR NFA TO DFA CONVERSION.

#include <stdio.h>
#include <iostream.h>
#include <conio.h>

class DFA;

class NFA
{
protected:
struct TR
{
int no_of_o_s; // Number of output states for input
int output_states[10]; // the output states
}tr[20][5]; // Default 15 are States 5 are Inputs

int no_of_states;
char states[20];
// For Start State q0
int start_state;
// For Set Of Final States F
int no_final_states;
int final_states[10];
// Input Set Of Alphabet
int no_inps;
char inputs[5];

public :
void init1(void);
void E_Closure( int state_no );
void PrintFA(void);
friend void NFA_TO_DFA( NFA *N, DFA *D );
friend int TFind( NFA *N, DFA *D, int current, int array[15], int input );
friend int FindEpsi_T( NFA *N, int array[15], int no, int arrayY[20] );
friend void AddState( NFA *N, DFA *D, int current, int array[15], int no, int input,
int found );
};

## void NFA :: init1(void)

{
int i,j,k;
cout<<"The NFA Values \n";
cout<<"No. Of States = ";
cin>>no_of_states;
cout<<"Start State = ";
cin>>start_state;
cout<<"No. Of Final States = ";
cin>>no_final_states;
for(i=0;i<no_final_states;i++)
{
cout<<" "<<i<<" th Final State ";
cin>>final_states[i];
}
cout<<"No. Of Inputs = ";
cin>>no_inps;
for(i=0;i<no_inps;i++)
{
cout<<"Enter "<<i<<" th Input Symbol ";
cin>>inputs[i];
}
cout<<"Enter The Transitions \n";
for(i=0;i<no_of_states;i++)
{
cout<<"For State "<<i<<"\n";
for(j=0;j<no_inps;j++)
{
cout<<"No Of Output States For Input "<<inputs[j]<<"=”;
cin>>tr[i][j].no_of_o_s;
for(k=0;k<tr[i][j].no_of_o_s;k++)
{
cout<<"Enter those states :";
cin>>tr[i][j].output_states[k];
}
}
}
}

class DFA
{
private :
struct TR
{
int output_state; // the output state for input
};

struct DState
{
int no_states;
int states[15];
struct TR trn[10];
}DStates[15];

int nDFAstates;
// F
int no_final_states;
int final_states[10];
// Input Alphabet
int no_inps;
char inputs[5];

public :
int start_state;
DFA(void);
friend void NFA_TO_DFA( NFA *N, DFA *D );
friend int TFind( NFA *N, DFA *D, int current, int array[15], int input );
friend int FindEpsi_T( NFA *N, int array[15], int no, int arrayY[20] );
int CheckPrev( int array[15], int no );
friend void AddState( NFA *N, DFA *D, int current, int array[15], int no, int input,
int found );
int AcceptString( int CurrState, char *str, int Pos );
void PrintDFA(void);
};

## int closure[15], cl=0;

void main()
{
NFA Nfa;
DFA Dfa;
int i;
char InpStr[10];
clrscr();
Nfa.init1();
Nfa.PrintFA();
NFA_TO_DFA( &Nfa, &Dfa );
Dfa.PrintDFA( );

## /* cout << "\nEnter Input String : ";

cin >> InpStr;
if( Dfa.AcceptString( Dfa.start_state, InpStr, 0 ) )
cout <<"\n"<<InpStr<<" String is Accepted by DFA ";
else
cout <<"\n"<<" String is Not Accepted by DFA ";*/
getch();
}

DFA :: DFA(void)
{
int i, j;
for( i = 0; i < 15; i++ )
for( j = 0; j < 10; j++ )
DStates[i].trn[j].output_state = -1;
}

## void NFA :: PrintFA(void)

{
int i, j, k;
clrscr();
cout << "\n\n Transition Table For Given NFA\n";
cout << "******************************************************\n";
cout << " STATES INPUTS\n ";
for( i = 0; i < no_inps; i++ )
cout << inputs[i] << "\t\t";
cout << "\n______________________________________________________\n";

## for( i = 0; i < no_of_states; i++ )

{
cout << "q" << i ;
for( j = 0; j < no_inps; j++ )
{
cout << "\t\t ";
for( k = 0; k < tr[i][j].no_of_o_s; k++ )
cout << "q" << tr[i][j].output_states[k] << " ";
}
cout << "\n";
}
getch();
}

## void NFA :: E_Closure( int state_no )

{
int stack[15], top=0, pop_state, i, j, findflg = 0;

cl = 0;
stack[top] = state_no;
closure[cl++] = state_no;

while( top != -1 )
{
pop_state = stack[top];
top--;

## for(i=0; i < tr[pop_state][0].no_of_o_s; ++i)

{
findflg = 0;
for( j = 0; j < cl; j++ )
{
if( tr[pop_state][0].output_states[i] == closure[j] )
findflg = 1;
}
if( !findflg )
{
top++;
stack[top] = tr[pop_state][0].output_states[i];
closure[cl++] = tr[pop_state][0].output_states[i];
}
}
}
}

## void NFA_TO_DFA( NFA *N, DFA *D )

{
int i, j, k, l, current, m, found;

## int T[15], Y[20];

int nT, nY;

D->start_state = 0;
D->no_final_states = 0;

D->no_inps = N->no_inps;

## for( i = 1; i < N->no_inps; i++ )

{
D->inputs[i] = N->inputs[i];
}

current = 0;
cl = 0;

current=0;

## for( j=0; j< cl; ++j )

D->DStates[current].states[j] = closure[j];

D->DStates[current].no_states = cl;
D->nDFAstates = current;
(D->nDFAstates)++;

## while( current < D->nDFAstates )

{
for ( i=1; i < N->no_inps; ++i )
{
nT = TFind( N, D, current, T, i );
nY = FindEpsi_T( N, T, nT, Y );
found = D->CheckPrev( Y, nY );

## AddState( N, D, current, Y, nY, i, found );

cout << "Input : " << N->inputs[i] << " => T = { ";
for( l = 0; l < nT; l++ )
cout << T[l] << ", ";

## cout << "\b\b } ";

cout << "Y = { ";
for( l = 0; l < nY; l++ )
cout << Y[l] << ", ";
cout << "\b\b } ";
if( !found )
else
cout << "Found\n";
}
current++;
}
}

int TFind( NFA *N, DFA *D, int current, int array[15], int input )
{
int i, j, n, ctr;
ctr = 0;

## for( i=0; i<D->DStates[current].no_states; ++i )

{
n = N->tr[ D->DStates[current].states[i] ][input].no_of_o_s;
for( j = 0; j < n; j++ )
{
array[ctr] = N->tr[ D->DStates[current].states[i] ][input].output_states[j];
ctr++;
}
}
return( ctr );
}

int FindEpsi_T( NFA *N, int array[15], int no, int arrayY[20] )
{
int i, j, ctr, dupl, m;
cl = 0;

N->E_Closure( array[0] );

## for(j=0; j<cl; ++j)

arrayY[j] = closure[j];

## for(i=1; i<no; ++i)

{
cl=0;
N->E_Closure( array[i] );

## for( j=0; j<cl; ++j )

{
dupl = 0;
for(m=0; m<ctr; ++m) // traverse array Y for Duplicate
{
if( closure[j] == arrayY[m] )
dupl = 1;
}
if( !dupl )
arrayY[ctr++] = closure[j];
}
}
return ctr;
}

{
int i, j, k, l;

## for(i=0; i < nDFAstates; ++i)

{
l = 0;
for( j=0; j < DStates[i].no_states; ++j)
{
for( k=0; k<no; ++k )
{
if( DStates[i].states[j] == array[k] )
l++;
}
}
if( DStates[i].no_states == no && l == no )
return( i );
}
return 0;
}

void AddState( NFA *N, DFA *D, int current, int array[15], int no, int input, int found )
{
int i, j, flag;

if( !found )
{
flag = 0;
for(i=0; i < no; ++i)
{
D->DStates[D->nDFAstates].states[i] = array[i];

## for(j=0; j < N->no_final_states; ++j)

{
if( D->DStates[D->nDFAstates].states[i] == N->final_states[j] )
{
flag = 1;
break;
}
}
}
if( flag )
{
D->final_states[D->no_final_states] = D->nDFAstates;
D->no_final_states++;
}

D->DStates[D->nDFAstates].no_states = no;
D->DStates[current].trn[input].output_state = D->nDFAstates;
D->nDFAstates++;
}
else
D->DStates[current].trn[input].output_state = found;
}

## void DFA :: PrintDFA(void)

{
int i, j, k;
cout << "\n\n Transition Table For Given DFA\n";
cout << "******************************************************\n";
cout << " STATES INPUTS\n";
cout << " ";

## for( i = 1; i < no_inps; i++ )

cout << inputs[i] << "\t\t";
cout << "\n------------------------------------------------------\n";

## for( i = 0; i < nDFAstates; i++ )

{
cout << "q" << i ;
for( j = 1; j < no_inps; j++ )
{
cout << "\t\t ";
cout << "q" << DStates[i].trn[j].output_state << " ";
}
cout << "\n";
}
cout << "------------------------------------------------------\n";
cout << "Start State is : q" << start_state << "\n";
cout << "Final States : { ";
for( i = 0; i < no_final_states; i++ )
{
cout << "q" << final_states[i] << ", ";
}
cout << "\b\b } ";
getch();
}
OUTPUT:

## The NFA Values

No. Of States = 11

Start State = 0

## No. Of Final States = 1

0th Final State 10

No. Of Inputs = 3
Enter 0 th Input Symbol e
Enter 1 th Input Symbol a
Enter 2 th Input Symbol b

## Enter The Transitions

For State 0
No Of Output States For Input e= 2
Enter those states :1
Enter those states :7
No Of Output States For Input a= 0
No Of Output States For Input b= 0

For State 1
No Of Output States For Input e= 2
Enter those states :2
Enter those states :4
No Of Output States For Input a= 0
No Of Output States For Input b= 0

For State 2
No Of Output States For Input e= 0
No Of Output States For Input a= 1
Enter those states :3
No Of Output States For Input b= 0

For State 3
No Of Output States For Input e= 1
Enter those states :6
No Of Output States For Input a= 0
No Of Output States For Input b= 0

For State 4
No Of Output States For Input e= 0
No Of Output States For Input a= 0
No Of Output States For Input b= 1
Enter those states :5
For State 5
No Of Output States For Input e= 1
Enter those states :6
No Of Output States For Input a= 0
No Of Output States For Input b= 0

For State 6
No Of Output States For Input e= 2
Enter those states :1
Enter those states :7
No Of Output States For Input a= 0
No Of Output States For Input b= 0

For State 7
No Of Output States For Input e= 0
No Of Output States For Input a= 1
Enter those states :8
No Of Output States For Input b= 0

For State 8
No Of Output States For Input e= 0
No Of Output States For Input a= 0
No Of Output States For Input b= 1
Enter those states :9

For State 9
No Of Output States For Input e= 0
No Of Output States For Input a= 0
No Of Output States For Input b= 1
Enter those states :10

For State 10
No Of Output States For Input e= 0
No Of Output States For Input a= 0
No Of Output States For Input b= 0
STATES INPUTS
e a b
______________________________________________________
q0 q1 q7
q1 q2 q4
q2 q3
q3 q6
q4 q5
q5 q6
q6 q1 q7
q7 q8
q8 q9
q9 q10
q10

## Input : a => T = { 8, 3 } Y = { 8, 3, 6, 1, 7, 2, 4 } Not Found

Input : b => T = { 5 } Y = { 5, 6, 1, 7, 2, 4 } Not Found
Input : a => T = { 8, 3 } Y = { 8, 3, 6, 1, 7, 2, 4 } Found
Input : b => T = { 9, 5 } Y = { 9, 5, 6, 1, 7, 2, 4 } Not Found
Input : a => T = { 8, 3 } Y = { 8, 3, 6, 1, 7, 2, 4 } Found
Input : b => T = { 5 } Y = { 5, 6, 1, 7, 2, 4 } Found
Input : a => T = { 8, 3 } Y = { 8, 3, 6, 1, 7, 2, 4 } Found
Input : b => T = { 10, 5 } Y = { 10, 5, 6, 1, 7, 2, 4 } Not Found
Input : a => T = { 8, 3 } Y = { 8, 3, 6, 1, 7, 2, 4 } Found
Input : b => T = { 5 } Y = { 5, 6, 1, 7, 2, 4 } Found

## Transition Table For Given DFA

******************************************************
STATES INPUTS
a b
------------------------------------------------------
q0 q1 q2
q1 q1 q3
q2 q1 q2
q3 q1 q4
q4 q1 q2
------------------------------------------------------

Start State is : q0

Final States : { q4 }
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-I)

PRACTICAL 3
You are provided with a NFA with λ moves
d. Write the transition table.
e. Write the procedure to find out the λ closure.
f. Implement it in C++. Finally output is the λ closure of particular state.
Consider the following transition table for (a+b)*

E a b
0 {1,7} - -
1 {2,4} - -
2 - 3 -
3 {6} - -
4 - - 5
5 {6} - -
6 {1,7} - -
7 - - -

## Write the program to find out the λ closure of given states

PROGRAM:

#include<stdio.h>
#include<conio.h>
#include<process.h>
#include<iostream.h>

class stack
{
public: int top,s[50];
stack(void){top= -1;}
void push(int i);
int pop(void);
void display(void);
int Is_Empty(void);
};

int stack::Is_Empty(void)
{
if(top==-1)
return 1;
else
return 0;
}

void stack::display(void)
{
for(;top>-1;top--)
{
cout<< "\n"<<s[top];
}
getch();
}

int stack::pop(void)
{
if(top==-1)
{
cout<<"\n\n\terror:stack is empty";
getch();
exit(0);
}
return s[top--];
}

void stack::push(int i)
{
if(top==49)
{
cout<<"\n\n\terror::stack is full.....";
getch();
exit(0);
}
s[++top]=i;
}

class NFA
{
public: int TransTable[10][10],Array[100];
char Symbol[10],MarkOn[50];
int NoOfStates,NoOfInputSymbols;
void InputTTable(void);
void PrintTTable(void);
void MarkState(int state);
void UnMarkAll(void);
int Is_Marked(int state);
};

## int NFA::Is_Marked(int state)

{
if(MarkOn[state]==0)
return 0;
else
return 1;
}

void NFA::UnMarkAll(void)
{
for(int i=0;i<NoOfStates;i++)
MarkOn[i]=0;
}

## void NFA::MarkState(int state)

{
MarkOn[state]=1;
}

void NFA::InputTTable(void)
{
int i,j,pos=0;
clrscr();
cout<<"enter no of states::";
cin>>NoOfStates;
cout<<"enter no of input symbols::";
cin>>NoOfInputSymbols;
cout<<"enter those input symbols::";
for(i=0;i<NoOfInputSymbols;i++)
cin>>Symbol[i];
cout<<"\nEnter the transition table(enter -1 for Halt)";
for(i=0;i<NoOfStates;i++)
for(j=0;j<NoOfInputSymbols;j++)
{
cout<<"\nform state\t "<<i<<"\t on\t"<<Symbol[j]<<"\t:: ";
TransTable[i][j]=pos;
while(1)
{
cin>>Array[pos++];
if(Array[pos-1]==-1)
break;
}
}
}

void NFA::PrintTTable(void)
{
int i,j,pos;
for(i=0;i<NoOfStates;i++)
for(j=0;j<NoOfInputSymbols;j++)
{
cout<<"\n form state"<<i<<"\ton"<<Symbol[j]<<"\t::";
pos=TransTable[i][j];
while(Array[pos]!=-1)
{
cout<<Array[pos++]<<" ";
}
}
}

class state
{
public: int j,Label,E_Closure_Set[50],count;
state(void){count=0;}
void Calculate_E_Closure(int state,NFA n);
void Disp_E_Closure(int state);
};

{
E_Closure_Set[count++]=stat;
}

## void state::Disp_E_Closure(int state)

{
cout<<endl;
for(int i=0;i<count;i++)
cout<<E_Closure_Set[i]<<" ";
getch();
j=0;
}
void state::Calculate_E_Closure(int stat,NFA n)
{
int pos;
int temp;
stack s;
count=0;
n.UnMarkAll();
clrscr();
s.push(stat);
n.MarkState(stat);
cout<<endl<<endl<<"the epslone closure of"<<stat<<"is::\n\t";
while(!s.Is_Empty())
{
temp=s.pop();
pos=n.TransTable[temp][0];
while(n.Array[pos]!=-1)
{
if(!n.Is_Marked(n.Array[pos]))
{
s.push(n.Array[pos]);
n.MarkState(n.Array[pos]);
}
pos++;
}
}
Disp_E_Closure(stat);
}

int main(void)
{
state state1;
NFA n;
n.InputTTable();
n.PrintTTable();
while(1)
{
cout<<"\n enter the satte for e.closure(-1 for exit)::";
cin>>state1.Label;
if(state1.Label==-1)break;
state1.Calculate_E_Closure(state1.Label,n);
}
return 0;
}
OUTPUT:
enter no of states::8
enter no of input symbols::3
enter those input symbols::e a b

## Enter the transition table(enter -1 for Halt)

form state 0 on e :: 1 7 -1

form state 0 on a :: -1

form state 0 on b :: -1

form state 1 on e :: 2 4 -1

form state 1 on a :: -1

form state 1 on b :: -1

form state 2 on e :: -1

form state 2 on a :: 3 -1

form state 2 on b :: -1

form state 3 on e :: 6 -1

form state 3 on a :: -1

form state 3 on b :: -1

form state 4 on e :: -1

form state 4 on a :: -1

form state 4 on b :: 5 -1

form state 5 on e :: 6 -1

form state 5 on a :: -1

form state 5 on b :: -1

form state 6 on e :: 1 7 -1

form state 6 on a :: -1

form state 6 on b :: -1
form state 7 on e :: -1
form state 7 on a :: -1

form state 7 on b :: -1

## form state 0 on e ::1 7

form state 0 on a ::-1
form state 0 on b ::-1
form state 1 on e ::2 4
form state 1 on a ::-1
form state 1 on b ::-1
form state 2 on e ::-1
form state 2 on a ::3 -1
form state 2 on b ::-1
form state 3 on e ::6
form state 3 on a ::-1
form state 3 on b ::-1
form state 4 on e ::-1
form state 4 on a ::-1
form state 4 on b ::5
form state 5 on e ::6
form state 5 on a ::-1
form state 5 on b ::-1
form state 6 on e ::1 7
form state 6 on a ::-1
form state 6 on b ::-1
form state 7 on e ::-1
form state 7 on a ::-1
form state 7 on b ::-1

07142

142

2

367142

4

567142

67142

## enter the satte for e.closure(-1 for exit)::7

7
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 4

## You are provided with a grammer

Write an algorithm to remove the left recursion
Implement it in C++.
Consider the Grammer
E -> E + T
E -> T
T -> T * F
T -> F
F -> ( E )
F -> id
Remove the left recursion for above grammer
PROGRAM:

#include<iostream.h>
#include<process.h>
#include<string.h>
#include<conio.h>

class lf
{
int prod,p_new,prd,pflag[10];
char PROD[10][15],
P_NEW[15][15];
public:
void initial();
void input();
void Left_recursion();
void display();
};

void lf::initial()
{
int i,j;
for(i=0;i<15;i++)
{
for(j=0;j<15;j++)
{
PROD[i][j]='\0';
P_NEW[i][j]='\0';
}
}
for(i=0;i<10;i++)
pflag[i]=0;
prod=0;
p_new=0;
}

void lf::input()
{
int i,j;
cout<<endl<<"Enter no.of production are:";
cin>>prod;
cout<<endl<<"enter production:";
for(i=0;i<prod;i++)
cin>>PROD[i];
}

void lf::Left_recursion()
{
char extra[]={'U','V','W','X','Y','Z'};
int i,j,l,x,k,u;
clrscr();
p_new=0;
x=0;
for(i=0;i<prod;i++)
{
if(pflag[i]==0)
{
if(PROD[i][0]==PROD[i][3])
{
pflag[i]=1;
for(j=i+1;j<prod;j++)
{
if((PROD[j][0]==PROD[i][0]) && (PROD[j][0]!=PROD[j][3]))
{
pflag[j]=1;
P_NEW[p_new][0]=PROD[j][0];
P_NEW[p_new][1]='-';
P_NEW[p_new][2]='>';
l=3;
while(PROD[j][l]!='\0')
{
P_NEW[p_new][l]=PROD[j][l];
l++;
}
P_NEW[p_new][l]=extra[x];
p_new++;
P_NEW[p_new][0]=extra[x];
P_NEW[p_new][1]='-';
P_NEW[p_new][2]='>';
u=4;
while(PROD[i][u]!='\0')
{
P_NEW[p_new][u-1]=PROD[i][u];
u++;
}
u--;
P_NEW[p_new][u]=extra[x];
p_new++;
P_NEW[p_new][0]=extra[x];
P_NEW[p_new][1]='-';
P_NEW[p_new][2]='>';
P_NEW[p_new][3]='#';
p_new++;
x++;
}
};
}
else
{
strcpy(P_NEW[p_new],PROD[i]);
p_new++;
}
}
}
}

void lf::display()
{
int i;
cout<<endl<<"production sfter left recursion are:";
for(i=0;i<p_new;i++)
cout<<endl<<P_NEW[i];
}

void main()
{
lf l;
clrscr();
l.initial();
l.input();
l.Left_recursion();
l.display();
getch();
}
OUTPUT:

## Enter no.of production are:6

enter production:
E->E+T
E->T
T->T*F
T->F
F->(E)
F->id

## production sfter left recursion are:

E->TU
U->+TU
U->#
T->FV
V->*FV
V->#
F->(E)
F->id
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-I)

PRACTICAL 5

Input a grammar from the user. Identify the input Terminals, and Non-terminal
a) Write a C++ Code to compute the FIRST, FOLLOW of all terminal.
b) Write a C++ Code to Compute the LL(1) Parsing Table for the given
grammer.

## Consider the grammer,

E -> T E’
E’ -> + T E’
T -> F T’
T’ -> * F T’
F -> ( E )
F -> id
E’ -> ε
T’ -> ε
Compute the FIRST, FOLLOW & build the parsing table.
PROGRAM:

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>

class GRAMMER
{

int no_nt;
char NT[20][10];

int no_t;
char T[20][10];

int no_prod;
struct PRD
{
char lhs[10];
char rhs[80];
}PROD[10];

char StartSymbol[10];

struct First_and_Follow
{
char Nt[10];
char Terminals[10][10];
int no_T;
}FIRST[20], FOLLOW[20];

char *First;

public :
char InputString[20];
GRAMMER( void );
void PrintGrammer( void );
int FindFirstSymbol( struct PRD P, char FS[10] );
int IsT_NT( char Symb[10] );
void FindFirstFollow();
char *FindFirst( char Nt[10] );
char *FindFollow( char Nt[10] );
};

## int strcmpstr( char *str1, char *str2 );

GRAMMER :: GRAMMER(void)
{
clrscr();

no_nt = 5;
strcpy( NT[0], "E");
strcpy( NT[1], "T");
strcpy( NT[2], "F");
strcpy( NT[3], "E'");
strcpy( NT[4], "T'");

no_t = 6;
strcpy( T[0] ,"+");
strcpy( T[1] , "*");
strcpy( T[2] , "(");
strcpy( T[3] , ")");
strcpy( T[4] , "id");
strcpy( T[5] , "î");

no_prod = 8;
strcpy( PROD[0].lhs , "E");
strcpy( PROD[0].rhs , "T E'");

## strcpy( PROD[1].lhs , "E'");

strcpy( PROD[1].rhs , "+ T E'");

## strcpy( PROD[2].lhs , "T");

strcpy( PROD[2].rhs , "F T'");

## strcpy( PROD[3].lhs , "T'");

strcpy( PROD[3].rhs , "* F T'");

## strcpy( PROD[4].lhs , "F");

strcpy( PROD[4].rhs , "( E )");

## strcpy( PROD[5].lhs , "F");

strcpy( PROD[5].rhs , "id");

## strcpy( PROD[6].lhs , "E'");

strcpy( PROD[6].rhs , "î");

## strcpy( PROD[7].lhs , "T'");

strcpy( PROD[7].rhs , "î");

}

## void GRAMMER :: PrintGrammer ( void )

{
cout<<"\nSTART STATE : "<<StartSymbol;

## cout<<"\nNon Terminlas : ";

for(int i=0; i<no_nt; ++i )
cout<<"\nNT"<<i+1<<" "<<NT[i];

cout<<"\nTerminals : ";

## for(i=0; i<no_t; ++i )

cout<<"\nT"<<i+1<<" : "<< T[i];

## cout << "\nProductions : ";

for(i=0;i<no_prod;++i)
{
cout<<"\nProduction No "<<i+1<<" "<<PROD[i].lhs<<"->" ;
cout<<PROD[i].rhs;
}

getch();
}

## void GRAMMER :: FindFirstFollow()

{
int i, j, k, l, index,m;
char *trial,*tempLhs,tempRhs;
int res;

## strcpy( T[no_t++], "\$" );

index = 0;
for( index = 0; index < no_nt; index++ )
{
strset( FIRST[index].Nt, '\0');
for( i = 0; i < no_t; i++ )
strset( FIRST[index].Terminals[i], '\0');
FIRST[index].no_T = 0;
}

## for( i = 0; i < no_nt; i++ )

{
strcpy( FIRST[i].Nt, NT[i] );
First = FindFirst( NT[i] );
k = 0;
for( j = 0; First[j] != '\0'; j++ )
{
if( First[j] != ' ' )
{
FIRST[i].Terminals[FIRST[i].no_T][k++] = First[j];
}
else
{
FIRST[i].Terminals[FIRST[i].no_T][k] = '\0';
if( IsT_NT( FIRST[i].Terminals[ FIRST[i].no_T ] ) == 1 )
FIRST[i].no_T++;

k = 0;
}
}
}

index = 0;
for( index = 0; index < no_nt; index++ )
{
strset( FOLLOW[index].Nt, '\0');
for( i = 0; i < no_t; i++ )
strset( FOLLOW[index].Terminals[i], '\0');
FOLLOW[index].no_T = 0;
}

## for( i = 0; i < no_nt; i++ )

{
First = FindFollow( NT[i] );
strcpy(trial,First);
strcpy( FOLLOW[i].Nt, NT[i] );
k = 0;
for( j = 0; trial[j] != '\0'; j++ )
{
if( trial[j] != ' ' )
{
FOLLOW[i].Terminals[ FOLLOW[i].no_T ][k++] = trial[j];
}
else
{
FOLLOW[i].Terminals[ FOLLOW[i].no_T ][k] = '\0';
if(IsT_NT( FOLLOW[i].Terminals[ FOLLOW[i].no_T ] ) == 1
)
FOLLOW[i].no_T++;
k = 0;
}
}
}
cout<<"\n\t\t\tFirst of all Non Terminal"<<endl;
for(k =0;k < no_nt;k++)
{
cout << "\nFIRST( " << FIRST[k].Nt << " ) = { ";

## for( l = 0; l < FIRST[k].no_T; l++ )

{
cout << FIRST[k].Terminals[l] << ", ";
}
cout << "\b\b }"<<endl;
}
for( k = 0; k < no_nt; k++ )
{
cout << "\nFOLLOW( " << FOLLOW[k].Nt << " ) = { ";

## for( l = 0; l < FOLLOW[k].no_T; l++ )

{
cout << FOLLOW[k].Terminals[l] << ", ";
}
cout << "\b\b }"<<endl;
}
cout<<endl;
for(i=0;i<no_t; i++)
if(strcmp(T[i],"î")!=0)
cout << "\t" << T[i];

for(i=0;i<no_nt;i++)
{
cout << endl;
cout << NT[i];

for(j=0;j<no_t; j++)
{
if(strcmp(T[j],"î")!=0)
{
cout << "\t";
for(k=0;k<FIRST[i].no_T;k++)
{
if(strcmp(FIRST[i].Terminals[k],T[j])==0)
{
for(l=0;l<no_prod;l++)
{
if(strcmp(PROD[l].lhs,NT[i]) == 0)
{
cout << l+1;
goto direct;
}
}
}

if(strcmp(FIRST[i].Terminals[k],"î")==0)
{
for(l=0;l<FOLLOW[i].no_T;l++)
{
res
=strcmp(FOLLOW[i].Terminals[l],T[j]);
if(res==0)
{
for(m=0;m<no_prod;m++)
{

strcpy(tempLhs,PROD[m].lhs);
tempRhs
=PROD[m].rhs[0];

if(strcmp(NT[i],tempLhs)==0 &&
tempRhs=='î')
cout << m+1;
}
goto direct;
}
}
}
}
}
direct:
}
}
}

## int GRAMMER :: FindFirstSymbol( struct PRD P, char FS[10] )

{
int k;

for( k=0; P.rhs[k] != '\0'; k++ ) // to find first Symbol in the rhs
{
if( P.rhs[k] != ' ' )
FS[k] = P.rhs[k];
else
break;
}

FS[k] = '\0';

## for( k = 0; k < no_t; k++ )

{
if( strcmp( FS, T[k] ) == 0 )
return( 1 );
}

## for( k = 0; k < no_nt; k++ )

{
if( strcmp( FS, NT[k] ) == 0 )
return( 2 );
}

return( 0 );
}
int GRAMMER :: IsT_NT( char Symb[10] )
{
int k;

## for( k = 0; k < no_t; k++ )

{
if( strcmp( Symb, T[k] ) == 0 )
return( 1 );
}

## for( k = 0; k < no_nt; k++ )

{
if( strcmp( Symb, NT[k] ) == 0 )
return( 2 );
}

return( 0 );
}

## char * GRAMMER :: FindFirst( char Nt[10] )

{
int i, j, k, l, isTorNT, ProdLoc[10], prods;
char FirstSymbol[10], T_in_First[10] = "";

prods = 0;
for( i = 0; i < no_prod; i++ )
{
if( strcmp( PROD[i].lhs, Nt ) == 0 )
{
ProdLoc[prods++] = i;
}
}

## for( i = 0; i < prods; i++ )

{
isTorNT = FindFirstSymbol( PROD[ ProdLoc[i] ], FirstSymbol );

## if( isTorNT == 1 ) // if First Symbol is Terminal

{
strcat( T_in_First, FirstSymbol );
strcat( T_in_First, " " );
}
else
{
if( isTorNT == 2 ) // if First Symbol is Non Terminal
{
strcat( T_in_First, FindFirst( FirstSymbol ) );
strcat( T_in_First, " " );
}
}
}

return( T_in_First );
}

## char * GRAMMER :: FindFollow( char Nt[10] )

{
int i, j, k, l, m, isTorNT, FindPos, prods, found;
char FirstSymbol[10], T_in_Follow[10] = "";

struct Prod
{
int ProdLoc;
char Symbol[10];
}Prods[10];

found = 0;

## for( j = 0; j < no_nt; j++ )

{
if( strcmp( FOLLOW[j].Nt, Nt ) == 0 )
{
found = 1;
break;
}
}

if( found )
{
for( l = 0; l < FOLLOW[j].no_T; l++ )
{
strcat( T_in_Follow, FOLLOW[j].Terminals[l] );
strcat( T_in_Follow, " " );
}
}

## if( strcmp( Nt, StartSymbol ) == 0 )

strcat( T_in_Follow, "\$ " );

prods = 0;
for( i = 0; i < no_prod; i++ )
{
//it returns last char's position of Nt

## FindPos = strcmpstr( PROD[i].rhs, Nt );

if( FindPos != -1 )
{
if( strlen( PROD[i].rhs ) == FindPos )
{
if( strcmp( PROD[i].lhs, Nt ) != 0 )
{
strcpy( Prods[prods].Symbol, "á" );
Prods[prods++].ProdLoc = i;
}
}
else
{
j = FindPos;
while( PROD[i].rhs[j] == ' ' )

j++;
k = 0;
while( PROD[i].rhs[j] != '\0' )
{
if( PROD[i].rhs[j] == ' ' )
break;
else
Prods[prods].Symbol[k++] = PROD[i].rhs[j++];
}
Prods[prods].Symbol[k] = '\0';
if( strcmp( PROD[i].lhs, Prods[prods].Symbol ) != 0 )
Prods[prods++].ProdLoc = i;
}
}
}

## for( i = 0; i < prods; i++ )

{
if( IsT_NT( Prods[i].Symbol ) == 1 )
{
strcat( T_in_Follow, Prods[i].Symbol );
strcat( T_in_Follow, " " );
}
else
{
if( IsT_NT( Prods[i].Symbol ) == 2 )
{
for( j = 0; j < no_nt; j++ )
{
if( strcmp( FIRST[j].Nt, Prods[i].Symbol ) == 0 )
break;
}

## for( l = 0; l < FIRST[j].no_T; l++ )

{
if( strcmp( FIRST[j].Terminals[l], "î" ) == 0 )
{
strcat( T_in_Follow, FindFollow( PROD[ Prods[i].ProdLoc ].lhs )
);
strcat( T_in_Follow, " " );
}
else
{
FindPos = strcmpstr( T_in_Follow, FIRST[j].Terminals[l] );
if( FindPos == -1 )
{
strcat( T_in_Follow,
FIRST[j].Terminals[l] );
strcat( T_in_Follow, " " );
}
}
}
}// if
else
{
if( strcmp( Prods[i].Symbol, "á" ) == 0 )
{
strcat( T_in_Follow,
FindFollow( PROD[ Prods[i].ProdLoc ].lhs ) );
strcat( T_in_Follow, " " );
}
}
}//else
}//for

}

## int strcmpstr( char *str1, char *str2 )

{
int i, j, pos;

pos = -1;
if( strlen(str1) > strlen(str2) )
{
for( i = 0, j = 0; str1[i] != '\0'; i++ )
{
if( str1[i] == str2[j] )
{
j++;

if( j == strlen( str2 ) && i < strlen( str1 ) && str1[i+1] == ' ' )
{
pos = ++i; // Forwarding pointer to end of str2 in str1
break;
}

## if( j == strlen( str2 ) && str1[i+1] == '\0' )

{
pos = ++i; // Forwarding pointer to end of str2 in str1
break;
}

## if( str1[i+1] != str2[j] || j == strlen( str2 ))

j = 0;
}
}
}

return pos;
}

int main(void)
{
GRAMMER G1;
int result;
G1.PrintGrammer();
G1.FindFirstFollow();
getch();
return 0;
}
OUTPUT:

Non Terminals :
NT1 E
NT2 T
NT3 F
NT4 E'
NT5 T'

Terminals :
T1 : +
T2 : *
T3 : (
T4 : )
T5 : id
T6 : ε

Productions :
Production No 1 E->T E'
Production No 2 E'->+ T E'
Production No 3 T->F T'
Production No 4 T'->* F T'
Production No 5 F->( E )
Production No 6 F->id
Production No 7 E'->ε
Production No 8 T'->ε

## First of all Non Terminal

FIRST( E ) = { (, id }
FIRST( T ) = { (, id }
FIRST( F ) = { (, id }
FIRST( E' ) = { +, ε }
FIRST( T' ) = { *, ε }

## Follow of all Non Terminal

FOLLOW( E ) = { \$, ) }
FOLLOW( T ) = { +, \$, ) }
FOLLOW( F ) = { *, +, \$, ) }
FOLLOW( E' ) = { \$, ) }
FOLLOW( T' ) = { +, \$, ) }

+ * ( ) id \$
E 1 1
T 3 3
F 5 5
E' 2 7 7
T' 8 4 8 8
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-I)

PRACTICAL 6

Warshall’s Algorithm

You are given Warshall’s algorithm. Write a C-program to accept the following
initial matrix.

000010
000100
000010
010000
100000
010000

Perform the steps of Warshall’s Algorithm and output the final matrix

OUTPUT is :
100010
010100
100010
010100
100010
010100
Program:

#include <iostream.h>
#include <conio.h>
#include <string.h>

## void print(int m[6][6]);

void main()
{
int i,j,k;
int m[6][6]={
0,0,0,0,1,0,
0,0,0,1,0,0,
0,0,0,0,1,0,
0,1,0,0,0,0,
1,0,0,0,0,0,
0,1,0,0,0,0
};
clrscr();
cout<<"\n\n\t\tInitial Matrix\n\n";

print(m);
getch();

for(k=0;k<6;++k)
{
for(i=0;i<6;++i)
{
for(j=0;j<6;++j)
{
if(m[i][k]==m[k][j] && 1 ==m[k][j])
{
m[i][j]=1;
}
}
}
}

Algorithm\n\n";
print(m);
getch();
}

## void print(int m[6][6])

{
int i,j;
cout<<(char)218<<"\t\t\t\t\t\t"<<(char)191<<"\n";
cout<<(char)179<<"\t\t\t\t\t\t"<<(char)179<<"\n";
for(i=0;i<6;++i)
{
cout<< (char)179<<"\t\t\t\t\t\t"<< (char)179<<"\n";
for(j=0;j<6;++j)
{
cout<<m[i][j]<<"\t";

}
}
cout<<(char)179<<"\n";
cout<<(char)192<<"\t\t\t\t\t\t"<<(char)217<<"\n";

OUTPUT:

Initial Matrix

0 0 0 0 1 0
0 0 0 1 0 0
0 0 0 0 1 0
0 1 0 0 0 0
1 0 0 0 0 0
0 1 0 0 0 0

## Matrix after applying WARSHALL'S Algorithm

1 0 0 0 1 0
0 1 0 1 0 0
1 0 0 0 1 0
0 1 0 1 0 0
1 0 0 0 1 0
0 1 0 1 0 0
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-I)

PRACTICAL 7

Input a CFG
1) Write a program to compute the SLR(0) items for the grammar.
2) Write a program to print the parsing table for the given grammar.
PROGRAM:

## //PROGRAM FOR SLR PARSER .

#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>

{"A->E",
"E->E+T",
"E->T",
"T->T*F",
"T->F",
"F->(E)",
"F->i"
};

## int tp = 7,S = 0,tt = 5,tnt = 3;

int i=0,j=0,State[20];

## const unsigned char NT[10]={"ETF"},T[10]={"+*()i\$"},

TNT[15]={"ETF+*()i"};
char foll[5][10]={"+)\$","+*)\$","+*)\$"};

struct node
{
int pno,dpos;
};

struct t
{
char s;
int n;
};

struct t1
{
struct t lr[10];
int group[5];
};

struct t1 action[15];
struct node closure[12][12];
int g[15][10];

void main()
{
int clno,no=0,x,y,k,l,z,len,count=-1,d=0;
void Find_Closure(int,int);
void Sort_Closure(int,int);
int Find_T_index(char);
int Find_NT_index(char);
void Print_Tab(int);
void display_group(void);
closure[i][j].pno=0;
closure[i][j++].dpos=3;
Find_Closure(no,3);
Sort_Closure(i,j);
State[i]=j;
S=1;
do
{
count++;
z=State[count];
for(k=0;k<tnt+tt;k++)
{
i++;
j=0;
d=0;
for(l=0;l<z;l++)
{
x=closure[count][l].pno;
y=closure[count][l].dpos;
if(prod[x][y]==TNT[k])
{
d=1;
closure[i][j].pno=x;
closure[i][j++].dpos=++y;
if((y<strlen(prod[x]))&&(isupper(prod[x][y])))
Find_Closure(x,y);
}
}
if(d==0)
{
i--;
continue;
}

Sort_Closure(i,j);
State[i]=j;
if(clno==-1)
clno=i;
if(isupper(TNT[k]))
action[count].group[k]=clno;
else
{
action[count].lr[k-tnt].s='S';
action[count].lr[k-tnt].n=clno;
}
i--;
else
{
S++;
for(l=0;l<State[l];l++)
{
if(closure[i][l].pno==0)
{
action[i].lr[tt].s='A';
continue;
}
len=strlen(prod[closure[i][l].pno]);
if(len==closure[i][l].dpos)
{
char v = prod[closure[i][l].pno][0];
int u = Find_NT_index(v);
for(x=0;x<strlen(foll[u]);x++)
{
int w=Find_T_index(foll[u][x]);
action[i].lr[w].s='R';
action[i].lr[w].n=closure[i][l].pno;
}
}
}
}
}
}while(count != S);
Print_Tab(S);
getch();
display_group();
getch();
}

## void Print_Tab(int states)

{
int i,j,lin=3;
clrscr();
printf("\t\t");
for(i=0;i<=tt;i++)
printf("%c\t",T[i]);
for(i=0;i<tnt;i++)
printf("%c\t",NT[i]);
for(i=0;i<=states;i++)
{
gotoxy(1,lin);
printf("I%d\t",i);
for(j=0;j<=tt;j++)
{
if(action[i].lr[j].s !='\x0')
{
printf("%c",action[i].lr[j].s);
if(action[i].lr[j].s=='A')
continue;
printf("%d",action[i].lr[j].n);
printf("\t");
}
else
printf("\t");
}
for(j=0;j<tnt;j++)
{
if(action[i].group[j])
{
printf(" %2d",action[i].group[j]);
printf("\t");
}
else
printf("\t");
}
lin++;
}
return;
}

## void Sort_Closure(int clno,int prodno)

{
int i,j;
struct node temp;
for(i=0;i<prodno-1;i++)
{
for(j=i+1;j<prodno;j++)
{
if(closure[clno][i].pno > closure[clno][j].pno)
{
temp=closure[clno][i];
closure[clno][i]=closure[clno][j];
closure[clno][j]=temp;
}
}
}
for(i=0;i<prodno-1;i++)
{
for(j=i+1;j<prodno;j++)
{
if((closure[clno][i].dpos>closure[clno][j].dpos)
&& (closure[clno][i].pno==closure[clno][j].pno))
{
temp=closure[clno][i];
closure[clno][i]=closure[clno][j];
closure[clno][j]=temp;
}
}
}
}

{
int j,k,d=1;
for(k=0;k<=n;k++)
{
if(State[k]==State[n+1])
{
d=0;
for(j=0;j<State[k];j++)
{
if((closure[k][j].pno != closure[n+1][j].pno)
|| (closure[k][j].dpos != closure[n+1][j].dpos))
break;
else
d++;
}
if(d==State[k])
return(k);
}
}
return(-1);
}

## void Find_Closure(int no,int dp)

{
int k;
char temp[5];
if(isupper(prod[no][dp]))
{
for(k=0;k<tp;k++)
{
if(prod[k][0]==prod[no][dp])
{
closure[i][j].pno=k;
closure[i][j++].dpos=3;
if((isupper(prod[k][3])) &&(prod[k][3] !=
prod[k][0]))
Find_Closure(k,3);
}
}
}
return;
}
int Find_NT_index(char c)
{
int i;
for(i=0;i<tnt;i++)
if(NT[i]==c)
return(i);
return(-1);
}

int Find_T_index(char c)
{
int i;
for(i=0;i<tt;i++)
if(T[i]==c)
return(i);
return(-1);
}

void display_group()
{
int i,j,k,dot_print=0;

for(i=0;i<S;++i)
{
printf("\nI%d:",i);
for(j=0;j<State[i];++j)
{

printf("\n\t%c->",prod[closure[i][j].pno][0]);
dot_print=0;
for(k=3;k<strlen(prod[closure[i][j].pno]);++k)
{
if(k==closure[i][j].dpos)
{
printf(".%c",prod[closure[i][j].pno][k]);
dot_print=1;

}
else
printf("%c",prod[closure[i][j].pno][k]);
}
if(dot_print!=1)
{
printf(".",prod[closure[i][j].pno][k]);
}
}
}
}
OUTPUT:

+ * ( ) i \$
E T F
-------------------------------------------------------------
I0 S4 S5 1 2
3
-------------------------------------------------------------
I1 S6 A
-------------------------------------------------------------
I2 R2 S7 R2
-------------------------------------------------------------
I3 R4 R4 R4 A
-------------------------------------------------------------
I4 S4 S5 8 2 3
-------------------------------------------------------------
I5 R6 R6 R6 A
-------------------------------------------------------------
I6 S4 S5 9 3
-------------------------------------------------------------
I7 S4 S5 10
-------------------------------------------------------------
I8 S6 S11
-------------------------------------------------------------
I9 R1 S7 R1
-------------------------------------------------------------
I10 R3 R3 R3
-------------------------------------------------------------
I11 R5 R5 R5
-------------------------------------------------------------
I12 S4 10
-------------------------------------------------------------

I0:
A->.E
E->.E+T
E->.T
T->.T*F
T->.F
F->.(E)
F->.i

I1:
A->E.
E->E.+T

I2:
E->T.
T->T.*F
I3:
T->F.

I4:
E->.E+T
E->.T
T->.T*F
T->.F

I5:
F->i
I6:
E->E+.T
T->.T*F
T->.F
F->.(E)
F->.i
I7:
T->T*.F
F->.(E)
F->.i
I8:
E->E.+T
F->(E.)
I9:
E->E+T.
T->T.*F
I10:
T->T*F.
I11:
F->(E)
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-I)

PRACTICAL 8

You are provided with a Right Linear grammar below. Perform the
following on to it.
a. Define Left Linear & Right Linear Grammar.
b. Write the pseudo-code for converting Right Linear Grammar to
Left Linear Grammars.
c. Write a C program to convert the Right Linear Grammar given
below to Left Linear Convert the given Right Linear grammar to
Left Linear Grammar.
d. Clearly define the new Non-Terminals, Terminals, Productions &
the Start state of the converted grammar.
Input Î
S -> a
S-> bU
S-> bR
R->abaU
R->U
U->b
U->aS
PROGRAM:

#include<iostream.h>
#include<conio.h>
#include<math.h>
#include<string.h>

void main()
{
char right[10][10]={"S->a","S->bU","S->bR","R->abaU","R->U","U->b","U->aS");
char left[10][10]={"","","","","","",""};
clrscr();
char ter[5]={'a','b'};
char nonter[10]={'S','U','R'};
char sym[10]={'e','e','o'};
int i,j,k,l,m;
cout<<"*****************RIGHT Linear Grammar***********"<<endl;
for(i=0;i<=6;i++)
{
cout<<i<<" "<<right[i];
cout<<"\n";
}
cout<<endl;
k=0;
m=0;
for(i=0;i<7;i++)
{
for(j=0;j<strlen(right[i]);i++)
{
k=i;
/* For length equal to 4*/
if(strlen(right[i])==4)
{
for(int n=0;n<strlen(ter);n++)
{
l=0;
if(right[i][3]==ter[n])
{
left[k][l]=sym[m];
l++;
left[k][l]=right[i][j];
l++;
left[k][l]=right[i][j+3];
m=m+1;
}
}
for(int n1=0;n1<strlen(nonter);n++)
{
l=0;
if(right[i][3]==nonter[n1])
{
left[k][l]=right[i][3];
l++;
left[k][l]=right[i][0];
}
}
}
/*Length Greater than 4*/
else
{
l=0;
char temp;
temp=right[i][l];
left[k][l]=right[i][strlen(right[i]-1];
l++;
left[k][l]=temp;
for(int i1=3;i1<(strlen(right[i]-1);i++)
{
l++;
left[k][l]=right[i][i1];
}
}
}
cout<<"*********LEFT Linear Grammar********"<<endl;
for(int o=0;o<7;o++)
{
cout<<o<<""<<left[o][o]<<"->";
for(int o1=1;o1<strlen(left[o]);o1++)
{
cout<<left[o][o1];
}
cout<<"\n";
}
getch();
}
}
OUTPUT:

0 S->a
1 S->bU
2 S->bR
3 R->abaU
4 R->U
5 U->b
6 U->aS

## *********** LEFT Linear Grammar *************

0 ->Sa
1 U->Sb
2 R->Sb
3 U->RaRb
4 U->R
5 o->Ub
6 S->Ua
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-I)

PRACTICAL 9
Minimize Automata

## Write a c program to track of suitable representation of the productions with

suitable data structure.Input or code the following number of transition
symbols,the number of DFA states and destination states for all transition
symbols on all states.

## Input the following transitions

a b

A B C

B B D

C B C

D B E

E B C

and the minimize number of DFA states and print the minimize DFA transition table.

a b

A B A

B B D

D B E

E B A
PROGRAM:

Minimize Automata
Coding:

#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<iostream.h>
#include<string.h>
int state_no(char);
char dfa[5][4]={"ABC",
"BBD",
"CBC",
"DBE",
"EBC"};
void main()
{
int i,j,k,l,m,a,b,c,d,e,f,g,h;
clrscr();
char final_state[5];
final_state[0]='E';
final_state[1]='\0';
char group[4][4];
char new_group[5][4];

## cout<<"********* DFA *******"<<endl;

cout<<""<<"\t"<<"a"<<"\t"<<"b"<<endl;
for(i=0;i<5;i++)
{
for(j=0;j<=2;j++)
{
cout<<dfa[i][j];
cout<<"\t";
}
cout<<endl;
}
cout<<"Give Final State="<<" "<<final_state<<endl;

## /* This use to find min DFA */

k=0;l=0;
q:
for(i=0;i<=4;i++)
{
for(j=1;j<3;j++)
{
if(dfa[i][j]==final_state[k])
{
k++;
final_state[k]=dfa[i][0];
l++;
goto q;
}
}
}

c=1;d=0;e=0;
for(a=0;a<=4;a++)
{
for(b=0;b<=4;b++)
{
if(b==a)
{
b++;
}
if((dfa[a][c]==dfa[b][c]) && (dfa[a][c+1]==dfa[b][c+1]))
{
group[d][e]=dfa[a][0];
e++;
group[d][e]=dfa[b][0];
d++;

break;
}
}
}

for(int q=0;q<4;q++)
{
for(m=0;m<4;m++)
{
if(final_state[q]<final_state[m])
{
char temp=final_state[q];
final_state[q]=final_state[m];
final_state[m]=temp;
}
}
}
cout<<endl<<endl<<"********** MIN DFA ***********"<<endl;
cout<<" "<<"\ta\tb"<<endl;

for(int o=0;o<=3;o++)
{
int ff=state_no(final_state[o]);
if(dfa[ff][1]==group[0][1])
dfa[ff][1]=group[0][0];
if(dfa[ff][2]==group[0][1])
dfa[ff][2]=group[0][0];
cout<<final_state[o]<<"\t"<<dfa[ff][1]<<"\t"<<dfa[ff][2]<<endl;
}

getch();
}
int state_no(char cc)
{
for(int aa=0;aa<=4;aa++)
{
if(dfa[aa][0]==cc)
{
return(aa);
}
}
return(0);
}

OUTPUT:

********DFA*****
a b
A B C
B B D
C B C
D B E
E B C
Final State=E

************MIN DFA*******
a b
A B A
B B D
D B E
E B A
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 10

## Simple Precedence Matrix

You have been given the following rules to obtain the ‘Less –Than’ and ‘Greater-Than’
matrices.

## Less Than Æ = ( First )+

Greater Than Æ = ( LAST+ )T = ( FIRST* )

Write a C-Program to extract The First, Equal (Plus_Minus) and Last matrices from the

following Grammar. By using the above rules obtain the ‘Less Than’ , ‘Greater Than’

matrices and by superimposition of the three matrices obtain and print the SPM.

## Enter the following grammar g : { N,T,P,S }

Productions P : Z ÆbMb
MÆ(L

MÆa
LÆMa)
PROGRAM:
Simple Precedance Matrix

Coding:

#include<stdio.h>
#include<conio.h>
#include<string.h>
//#include"temparr.h"
char prod[][4]={"bMb","(L","Ma)","a"},rhs[4]={'z','M','L','M'};char symbs[15];
int equalto[7][7],first[7][7],last[7][7],lastT[7][7],firstST[7][7],gr[7][7],gr1[7][7],lr[7][7],flag;
int spm[7][7];
void main()
{
clrscr();
int i,j;
int func(char c);
void temparr();
void equaltof();
void firstplusf();
void lastplusf();
void multi(int arr1[7][7],int arr2[7][7],int arr3[7][7]);
temparr();
equaltof();
clrscr();
firstplusf();
clrscr();
lastplusf();
flag=1;
multi(equalto,first,lr);
flag=2;
multi(lastT,equalto,gr);
flag=3;
multi(gr,firstST,gr1);
clrscr();
printf("SPM:-\n\n");
for(i=0;i<=6;i++)
printf("\t%c",symbs[i]);
printf("\n\n");
for(i=0;i<=6;i++)
{
printf("%c\t",symbs[i]);
for(j=0;j<=6;j++)
{ if(equalto[i][j]==1)
spm[i][j]=-1;
if(lr[i][j]==1)
spm[i][j]=1;
if(gr1[i][j]==1)
spm[i][j]=2;
printf("%d\t",spm[i][j]);
}
printf("\n\n");
}
printf("equal precedence:-(-1)\n");
printf("less than precedence:-(1)\n");
printf("greater than precedence:-(2)\n");
getch();
}
int func(char c)
{
int i,j,len;len=strlen(symbs);
for(i=0;i<len;i++)
{
if(c==symbs[i])
{j=i;break;}
}
return j;
}
void equaltof()
{
int i,j,k,a,b,c;
for(i=0;i<=3;i++)
{
j=0;
while(prod[i][j]!='\0')
{
a=func(prod[i][j]);
j++;
if(prod[i][j]!='\0')
{
b=func(prod[i][j]);
}
else
break;
equalto[a][b]=1;
}
}
printf("(+-) MATRIX:-\n");
for(i=0;i<=6;i++)
printf("\t%c",symbs[i]);
printf("\n\n");
for(i=0;i<=6;i++)
{
printf("%c\t",symbs[i]);
for(j=0;j<=6;j++)
printf("%d\t",equalto[i][j]);
printf("\n\n");
}
getch();
}
void firstplusf()
{
int i,j,k,a,b,c;
for(i=0;i<=3;i++)
{
a=func(rhs[i]);
b=func(prod[i][0]);
first[a][b]=1;
firstST[a][b]=1;
}
printf("FIRST+ MATRIX:-\n");
for(i=0;i<=6;i++)
printf("\t%c",symbs[i]);
printf("\n\n");
for(i=0;i<=6;i++)
{
printf("%c\t",symbs[i]);
for(j=0;j<=6;j++)
{
if(first[i][j]==1)
{
for(k=0;k<=6;k++)
if(first[j][k]==1)
{
first[i][k]=1;
firstST[i][k]=1;
}
}
printf("%d\t",first[i][j]);
}
firstST[i][i]=1;
printf("\n\n");
}
getch();clrscr();
printf("FIRST* MATRIX:-\n");
for(i=0;i<=6;i++)
printf("\t%c",symbs[i]);
printf("\n\n");
for(i=0;i<=6;i++)
{
printf("%c\t",symbs[i]);
for(j=0;j<=6;j++)
printf("%d\t",firstST[i][j]);
printf("\n\n");
}
getch();

}
void lastplusf()
{
int i,j,k,a,b,c;char z;
for(i=0;i<=3;i++)
{
a=func(rhs[i]);
c=strlen(prod[i]);
b=func(prod[i][c-1]);
last[a][b]=1;
}
printf("LastT MATRIX:-\n");
for(i=0;i<7;i++)
printf("\t%c",symbs[i]);
printf("\n\n");
for(i=0;i<7;i++)
{
printf("%c\t",symbs[i]);
for(j=0;j<7;j++)
{
if(last[i][j]==1)
{
for(k=0;k<7;k++)
if(last[j][k]==1)
last[i][k]=1;
}
if(last[i][j]==1)lastT[j][i]=1;//transpose of last
printf("%d\t",lastT[i][j]);
}
printf("\n\n");
}
getch();
}
void multi(int arr1[7][7],int arr2[7][7],int gr[7][7])
{
clrscr();
int i,j,k,mul,sum=0;
for(i=0;i<=6;i++)
{
for(j=0;j<=6;j++)
{
sum=0,mul=0;
for(k=0;k<=6;k++)
{
mul=arr1[i][k]*arr2[k][j];
sum=sum+mul;
}
gr[i][j]=sum;
}
}
if(flag==1)printf("Less Than:-\n\n");
if(flag==2)printf("Lastpl_Trans*equalto:-\n\n");
if(flag==3)printf("Greater Than:-\n\n");
for(i=0;i<7;i++)
printf("\t%c",symbs[i]);
printf("\n\n");
for(i=0;i<7;i++)
{
printf("%c\t",symbs[i]);
for(j=0;j<7;j++)
{
printf("%d\t",gr[i][j]);
}
printf("\n\n");
}
getch();
}
void temparr()
{
int i,j,k,l=0,flag=0,len,len1,flag1,len2;
for(i=0;i<4;i++)
{
len=strlen(prod[i]);
if(i==0)
{
symbs[0]=rhs[0];
if(symbs[0]!=prod[0][0])
symbs[++l]=prod[0][0];
k=1;
}
else
{
k=0;len2=strlen(symbs);
for(j=0;j<len2;j++)
{
flag1=0;
if(symbs[j]==rhs[i])
{
flag1=1;break;
}
}
if(flag1!=1)
symbs[++l]=rhs[i];
}
for(;k<len;k++)
{
flag=0;len1=strlen(symbs);
for(j=0;j<len1;j++)
{
if(symbs[j]==prod[i][k])
{
flag=1;break;
}
}
if(flag!=1)
symbs[++l]=prod[i][k];
}
}
}

Output:
Less than matrix is :

## Greater than matrix is :

SPM

Z b M L a ( )

Z 0 0 0 0 0 0 0

b 0 0 -1 0 0 1 0

M 0 -1 0 0 0 -1 0

L 0 0 1 1 -1 1 0

a 0 2 0 0 0 2 0

( 0 2 0 0 0 2 -1

) 0 2 0 0 0 2 0

equal precedence:-(-1)
less than precedence:-(-1)
greater than precedence:-(-2)
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 11

## Parsing using Simple Precedence Matrix ( SPM )

You are given a SPM of order m * m (m =7,8,9,10).Write a C-program to implement the

parsing algorithm for the SPM. Input the following Grammar and parse the strings given

below:

Grammar G:{N,T,P,S}

Productions P:
ZÆbMb
MÆ( L
MÆa
LÆMa)

SPM

## Parse the Strings using above SPM :

b ( aa ) b
b ((aa)a)b
b ((aaa)a)b
Output the step by step reduction.
PROGRAM:
// Parsing using SPM
#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class SPM
{
int no_symb;
char symb[20];
char spm[20][20];

int no_nt;
char NT[20][10];

int no_t;
char T[20][10];

int no_prod;
struct PRD
{
char lhs[10];
char rhs[20];
}prod[10];

char StartSymbol[10];
char stack[20][20];
char opr[20];
char input[20][20];
char inputString[20];
int parseStep;
int stackMem;

public:
void inputSPM();
void printSPM();
void parseString();
int getSymbPos(char);
void convInput(int);
void convStack(int);
char InputString[20];
void PrintGrammer(void);
void copyInput();
void printParseTable();
};

## void SPM :: inputSPM()

{
int i,j;
clrscr();

no_nt = 3;
strcpy( NT[0], "R");
strcpy( NT[1], "S");
strcpy( NT[2], "T");

no_t = 6;
strcpy( T[0] ,"a");
strcpy( T[1] ,"^");
strcpy( T[2] ,",");
strcpy( T[3] ,"(");
strcpy( T[4] ,")");
strcpy( T[5] ,"\$");

no_symb=9;
symb[0]='R';
symb[1]='S';
symb[2]='T';
symb[3]='a';
symb[4]='^';
symb[5]=',';
symb[6]='(';
symb[7]=')';
symb[8]='\$';

no_prod = 6;

## strcpy( prod[0].lhs , "S");

strcpy( prod[0].rhs , "a");

## strcpy( prod[1].lhs , "S");

strcpy( prod[1].rhs , "^");

## strcpy( prod[2].lhs , "S");

strcpy( prod[2].rhs , "(R)");

## strcpy( prod[3].lhs , "T");

strcpy( prod[3].rhs , "S,T");

## strcpy( prod[4].lhs , "T");

strcpy( prod[4].rhs , "S");

## strcpy( prod[5].lhs , "R");

strcpy( prod[5].rhs , "T");

## strcpy( StartSymbol , "S");

strcpy(inputString,"(a,a)");

spm[0][0]='0';
spm[0][1]='0';
spm[0][2]='0';
spm[0][3]='0';
spm[0][4]='0';
spm[0][5]='0';
spm[0][6]='0';
spm[0][7]='=';
spm[0][8]='0';

spm[1][0]='0';
spm[1][1]='0';
spm[1][2]='0';
spm[1][3]='0';
spm[1][4]='0';
spm[1][5]='=';
spm[1][6]='0';
spm[1][7]='>';
spm[1][8]='0';

spm[2][0]='0';
spm[2][1]='0';
spm[2][2]='0';
spm[2][3]='0';
spm[2][4]='0';
spm[2][5]='0';
spm[2][6]='0';
spm[2][7]='>';
spm[2][8]='0';

spm[3][0]='0';
spm[3][1]='0';
spm[3][2]='0';
spm[3][3]='0';
spm[3][4]='0';
spm[3][5]='>';
spm[3][6]='0';
spm[3][7]='>';
spm[3][8]='>';

spm[4][0]='0';
spm[4][1]='0';
spm[4][2]='0';
spm[4][3]='0';
spm[4][4]='0';
spm[4][5]='>';
spm[4][6]='0';
spm[4][7]='>';
spm[4][8]='>';

spm[5][0]='0';
spm[5][1]='<';
spm[5][2]='=';
spm[5][3]='<';
spm[5][4]='<';
spm[5][5]='0';
spm[5][6]='<';
spm[5][7]='0';
spm[5][8]='0';

spm[6][0]='=';
spm[6][1]='<';
spm[6][2]='<';
spm[6][3]='<';
spm[6][4]='<';
spm[6][5]='0';
spm[6][6]='<';
spm[6][7]='0';
spm[6][8]='0';

spm[7][0]='0';
spm[7][1]='0';
spm[7][2]='0';
spm[7][3]='0';
spm[7][4]='0';
spm[7][5]='>';
spm[7][6]='0';
spm[7][7]='>';
spm[7][8]='>';

spm[8][0]='0';
spm[8][1]='0';
spm[8][2]='0';
spm[8][3]='<';
spm[8][4]='<';
spm[8][5]='0';
spm[8][6]='<';
spm[8][7]='0';
spm[8][8]='0';

parseStep=0;
}

## void SPM :: printSPM()

{
int i,j;
cout << endl << "\t";
for(i=0;i<no_symb;i++)
cout << symb[i] << "\t";

for(i=0;i<no_symb;i++)
{
cout << endl << symb[i];
for(j=0;j<no_symb;j++)
cout << "\t" << spm[i][j];
}
}

{
int i;

## cout << endl << endl << "Stack\tOpr\tInput";

printf("%d",parseStep);
for(i=0;i<parseStep;i++)
cout << endl << stack[i] << "\t" << opr[i] << "\t" << input[i];
}

## void SPM :: PrintGrammer(void)

{
cout<<"\nSTART STATE : "<<StartSymbol;

## cout<<"\nNon Terminlas : ";

for(int i=0; i<no_nt; ++i )
cout<<"\nNT"<<i+1<<" "<<NT[i];

cout<<"\nTerminals : ";
for(i=0; i<no_t; ++i )
cout<<"\nT"<<i+1<<" : "<< T[i];

## cout << "\nProductions : ";

for(i=0;i<no_prod;++i)
{
cout<<"\nProduction No "<<i+1<<" "<<prod[i].lhs<<"->" ;
cout<<prod[i].rhs;
}

getch();
}

## int SPM :: getSymbPos(char symbol)

{
int i;
for(i=0;i<no_symb;i++)
if(symb[i] == symbol)
return i;
}

## void SPM :: parseString()

{
char temp,*startSymCheck;

parseStep=0;
strcpy(stack[0],"\$");
opr[0]='<';
strcpy(input[0],inputString);
strcat(input[0],"\$");
strcpy(startSymCheck,"\$");
strcat(startSymCheck,StartSymbol);
stackMem=0;

clrscr();
while(strcmp(input[parseStep],"\$") != 0 || strcmp(stack[parseStep],"\$") != 0)
{
printf("\n%s\t%s",stack[parseStep],input[parseStep]);
parseStep++;
strcpy(input[parseStep],input[parseStep-1]);
strcpy(stack[parseStep],stack[parseStep-1]);

if(strcmp(stack[parseStep],startSymCheck) == 0 &&
strcmp(input[parseStep],"\$") == 0)
break;

if(
spm[getSymbPos(stack[parseStep][stackMem])][getSymbPos(input[parseStep][0])] == '<' ||

spm[getSymbPos(stack[parseStep][stackMem])][getSymbPos(input[parseStep][0])]
== '=')
{
if(
spm[getSymbPos(stack[parseStep][stackMem])][getSymbPos(input[parseStep][0])] == '<')
opr[parseStep]='<';
else
opr[parseStep]='=';

temp = input[parseStep][0];
convInput(parseStep);
stack[parseStep][++stackMem] = temp;
stack[parseStep][stackMem+1] = '\0';
}
else

if(spm[getSymbPos(stack[parseStep][stackMem])][getSymbPos(input[parseStep][0])]
== '>')
{
opr[parseStep]='>';
convStack(parseStep);
}
else
{
cout << "\nError in string";
getch();
exit(0);
}
}
}

## void SPM :: copyInput()

{
int i;
for(i=0;i<strlen(inputString);i++)
input[0][i]=inputString[i];
input[0][i]='\0';
}

## void SPM :: convInput(int step)

{
int i;
for(i=0;i<strlen(input[step]);i++)
input[step][i]=input[step][i+1];
}

## void SPM :: convStack(int step)

{
int i,startPos,j,s,k;
char *substr,*newstr;
char change='y';

for(i=0;i<no_prod;i++)
{
strcpy(newstr,stack[step]);
if((substr=strstr(newstr,prod[i].rhs)) != NULL)
{
startPos=0;
s=0;
k=0;
//newstr[strlen(stack[step])]='\0';
checkAgain:

s=substr-newstr;
startPos=startPos+s+k;
k++;
for(j=s+1;j<strlen(newstr);j++)
newstr[j-s-1] = substr[j-s];
newstr[j-s-1]='\0';
if((substr=strstr(newstr,prod[i].rhs)) != NULL)
goto checkAgain;

## if(strlen(stack[step]) == strlen(prod[i].rhs) + startPos)

{
stackMem = stackMem - strlen(prod[i].rhs) + 1;
stack[step][startPos]=prod[i].lhs[0];
for(j = startPos+1 ; j < startPos + strlen(prod[i].rhs) ; j++)
stack[step][j]=stack[step][j+strlen(prod[i].rhs)-
1];
break;
}
}
}
}

void main(void)
{
SPM s;
s.inputSPM();
s.printSPM();
s.PrintGrammer();
s.parseString();
s.printParseTable();
getch();
}

## /*cout << "\n How many symbols: ";

cin >> no_symb;
cout << "\n Enter " << no_symb << " symbols:\n";

for(i=0;i<no_symb;i++)
{
cout << "Symbol" << i+1 << ":";
cin >> symb[i];
}
symb[no_symb]='\0';

## cout << endl;

for(i=0;i<no_symb;i++)
cout << "\t" << symb[i];
cout << endl;

for(i=0;i<no_symb;i++)
{
cout << symb[i];
for(j=0;j<no_symb;j++)
{
//cout << "\t";
cin >> spm[i][j];
}
}*/

OUTPUT:

R S T a > ^ , ( )
R 0 0 0 0 0 0 0 = 0
S 0 0 0 0 0 0 = > 0
T 0 0 0 0 0 0 0 > 0
a 0 0 0 0 0 > 0 > >
^ 0 0 0 0 0 > 0 > >
, 0 < = < < 0 < 0 0
( = < < < < 0 < 0 0
) 0 0 0 0 0 > 0 > >
\$ 0 0 0 < < 0 < 0 0

START STATE : S
Non Terminlas :
NT1 R
NT2 S
NT3 T

Terminals :
T1 : a
T2 : ^
T3 : ,
T4 : (
T5 : )
T6 : \$

Productions :
Production No 1 S->a
Production No 2 S->^
Production No 3 S->(R)
Production No 4 T->S,T
Production No 5 T->S
Production No 6 R->T

\$ < (a,a)\$
\$( < a,a)\$
\$(a < ,a)\$

## \$(S > ,a)\$

\$(S, = a)\$
\$(S,a < )\$
\$(S,S > )\$
\$(S,T > )\$
\$(T > )\$
\$(R > )\$
\$(R) = \$
\$S > \$
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 12

## Linearizing a given SPM

Write a C-program which accepts the following SPM and linearizes it to obtain
SPM functions ( f & g ) and display them in suitable format.

INPUT is

OUTPUT is
Program:

## // Lenearizing a given SPM

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class SPM
{
int no_symb;
char symb[20];
char ForG;
int FGPath[2][20];
char spm[20][20];
int maxpath;

public:
void inputSPM();
void printSPM();
void findFG();
void printFG();
int findNextPath(int,int,int,char);
};

## void SPM :: findFG()

{
int i,j,k,fcounter,gcounter,tracePath=0;

for(i=0;i<no_symb;i++)
{
maxpath=0;
findNextPath(i,0,0,'F');
FGPath[0][i]=maxpath;
}

for(i=0;i<no_symb;i++)
{
maxpath=0;
findNextPath(0,i,0,'G');
FGPath[1][i]=maxpath;
}
}

## int SPM :: findNextPath(int f,int g,int path,char FG)

{
int i,j;
if(FG=='F')
{
for(i=0;i<no_symb;i++)
if(spm[f][i]=='>')
{
//path=path+1;
findNextPath(f,i,path+1,'G');
}
if(i==no_symb)
if(path > maxpath)
{
maxpath = path;
return 0;
}
}
else
{
for(i=0;i<no_symb;i++)
if(spm[i][g]=='<')
{
//path=path+1;
findNextPath(i,g,path+1,'F');
}
if(i==no_symb)
if(path > maxpath)
{
maxpath = path;
return 0;
}
}
}

{
int i,j;

## cout << endl << endl;

for(i=0;i<no_symb;i++)
cout << "\t" << symb[i];

## cout << endl << "f";

for(i=0;i<no_symb;i++)
cout << "\t" << FGPath[0][i];

## cout << endl << "g";

for(i=0;i<no_symb;i++)
cout << "\t" << FGPath[1][i];
}

{
int i,j;
clrscr();

no_symb=4;
symb[0]='i';
symb[1]='+';
symb[2]='*';
symb[3]='\$';

spm[0][0]='0';
spm[0][1]='>';
spm[0][2]='>';
spm[0][3]='>';
spm[1][0]='<';
spm[1][1]='>';
spm[1][2]='<';
spm[1][3]='>';
spm[2][0]='<';
spm[2][1]='>';
spm[2][2]='>';
spm[2][3]='>';
spm[3][0]='<';
spm[3][1]='<';
spm[3][2]='<';
spm[3][3]='0';

## /*cout << "\n How many symbols: ";

cin >> no_symb;
cout << "\n Enter " << no_symb << " symbols:\n";

for(i=0;i<no_symb;i++)
{
cout << "Symbol" << i+1 << ":";
cin >> symb[i];
}
symb[no_symb]='\0';

## cout << endl;

for(i=0;i<no_symb;i++)
cout << "\t" << symb[i];
cout << endl;

for(i=0;i<no_symb;i++)
{
cout << symb[i];
for(j=0;j<no_symb;j++)
{
//cout << "\t";
cin >> spm[i][j];
}
}*/
}

{
int i,j;

## cout << endl << "\t";

for(i=0;i<no_symb;i++)
cout << symb[i] << "\t";

for(i=0;i<no_symb;i++)
{
cout << endl << symb[i];
for(j=0;j<no_symb;j++)
cout << "\t" << spm[i][j];
}
}

int main(void)
{
SPM s;
s.inputSPM();
s.printSPM();
s.findFG();
s.printFG();
getch();
return 0;
}

OUTPUT:

i + * \$
i 0 > > >
+ < > < >
* < > > >
\$ < < < 0

i + * \$
f 4 2 4 0
g 5 1 3 0
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 13

## Write a C-program which accepts the following Simple Precedence Functions

and parse the strings given below and display them.

INPUT is

## Parse the following strings :

1) b ( aa ) b
2) b ( ( aa ) a ) b
3) b ( ( aaa) a ) b
PROGRAM

## // SPM parsing using SPM functions

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class FGTable
{
int no_symb;
char symb[20];
int FPath[20],GPath[20];

int no_nt;
char NT[20][10];

int no_t;
char T[20][10];

int no_prod;

struct PRD
{
char lhs[10];
char rhs[20];
}prod[10];

char StartSymbol[10];

char stack[20][20];
char opr[20];
char input[20][20];
char inputString[20];
int parseStep;
int stackMem;

public:
void inputFG();
void printFG();
void parseString();
int getSymbPos(char);
void convInput(int);
void convStack(int);
char InputString[20];
FGTable(void);
void PrintGrammer(void);
void copyInput();
void printParseTable();
};

{
int i;

## cout << endl << endl << "Stack\tOpr\tInput";

printf("%d",parseStep);
for(i=0;i<parseStep;i++)
cout << endl << stack[i] << "\t" << opr[i] << "\t" << input[i];
}

## void FGTable :: PrintGrammer(void)

{
cout<<"\nSTART STATE : "<<StartSymbol;

## cout<<"\nNon Terminlas : ";

for(int i=0; i<no_nt; ++i )
cout<<"\nNT"<<i+1<<" "<<NT[i];

cout<<"\nTerminals : ";
for(i=0; i<no_t; ++i )
cout<<"\nT"<<i+1<<" : "<< T[i];

## cout << "\nProductions : ";

for(i=0;i<no_prod;++i)
{
cout<<"\nProduction No "<<i+1<<" "<<prod[i].lhs<<"->" ;
cout<<prod[i].rhs;
}

getch();
}

FGTable :: FGTable(void)
{
clrscr();
parseStep=0;
}

## int FGTable :: getSymbPos(char symbol)

{
int i;
for(i=0;i<no_symb;i++)
if(symb[i] == symbol)
return i;
}

## void FGTable :: parseString()

{
char temp,*startSymCheck;

parseStep=0;
strcpy(stack[0],"\$");
opr[0]='<';
strcpy(input[0],inputString);
strcat(input[0],"\$");
strcpy(startSymCheck,"\$");
strcat(startSymCheck,StartSymbol);
stackMem=0;

while(strcmp(input[parseStep],"\$") != 0 || strcmp(stack[parseStep],"\$") != 0)
{
parseStep++;
strcpy(input[parseStep],input[parseStep-1]);
strcpy(stack[parseStep],stack[parseStep-1]);

if(strcmp(stack[parseStep],startSymCheck) == 0)
break;

if(FPath[getSymbPos(stack[parseStep][stackMem])] <=
GPath[getSymbPos(input[parseStep][0])])
{
if(FPath[getSymbPos(stack[parseStep][stackMem])] <
GPath[getSymbPos(input[parseStep][0])])
opr[parseStep]='<';
else
opr[parseStep]='=';

temp = input[parseStep][0];
convInput(parseStep);
stack[parseStep][++stackMem] = temp;
stack[parseStep][stackMem+1] = '\0';
}
else
{
opr[parseStep]='>';
convStack(parseStep);
}
}
}

## void FGTable :: copyInput()

{
int i;
for(i=0;i<strlen(inputString);i++)
input[0][i]=inputString[i];
input[0][i]='\0';
}
void FGTable :: convInput(int step)
{
int i;
for(i=0;i<strlen(input[step]);i++)
input[step][i]=input[step][i+1];
}

## void FGTable :: convStack(int step)

{
int i,startPos,j;
char *substr;
char change='y';

for(i=0;i<no_prod;i++)
if((substr=strstr(stack[step],prod[i].rhs)) != NULL)
{
startPos=substr-stack[step];

## if(strlen(stack[step]) == strlen(prod[i].rhs) + startPos)

{
stackMem = stackMem - strlen(prod[i].rhs) + 1;
stack[step][startPos]=prod[i].lhs[0];
for(j = startPos+1 ; j < startPos + strlen(prod[i].rhs) ; j++)
stack[step][j]=stack[step][j+strlen(prod[i].rhs)-
1];
}
}
}

{
int i,j;

## cout << endl << endl;

for(i=0;i<no_symb;i++)
cout << "\t" << symb[i];

## cout << endl << "f";

for(i=0;i<no_symb;i++)
cout << "\t" << FPath[i];

## cout << endl << "g";

for(i=0;i<no_symb;i++)
cout << "\t" << GPath[i];
}

## void FGTable :: inputFG()

{
int i,j;
clrscr();

no_symb=8;
symb[0]='Z';
symb[1]='M';
symb[2]='L';
symb[3]='a';
symb[4]='b';
symb[5]='(';
symb[6]=')';
symb[7]='\$';

FPath[0]=1;
FPath[1]=7;
FPath[2]=8;
FPath[3]=9;
FPath[4]=4;
FPath[5]=2;
FPath[6]=8;
FPath[7]=0;

GPath[0]=1;
GPath[1]=4;
GPath[2]=2;
GPath[3]=7;
GPath[4]=7;
GPath[5]=5;
GPath[6]=9;
GPath[7]=0;

no_nt = 3;
strcpy( NT[0], "Z");
strcpy( NT[1], "M");
strcpy( NT[2], "L");

no_t = 4;
strcpy( T[0] ,"a");
strcpy( T[1] , "b");
strcpy( T[2] , "(");
strcpy( T[3] , ")");

no_prod = 4;
strcpy( prod[0].lhs , "Z");
strcpy( prod[0].rhs , "bMb");

## strcpy( prod[1].lhs , "M");

strcpy( prod[1].rhs , "(L");

## strcpy( prod[2].lhs , "M");

strcpy( prod[2].rhs , "a");
strcpy( prod[3].lhs , "L");
strcpy( prod[3].rhs , "Ma)");

## strcpy( StartSymbol , "Z");

strcpy(inputString,"b(aa)b");
}

void main(void)
{
FGTable f;
f.inputFG();
f.printFG();
f.parseString();
f.printParseTable();
getch();
}

OUTPUT:

Z M L a b ( ) \$
f 1 7 8 9 4 2 8 0
g 1 4 2 7 7 5 9 0

## Stack Opr Input

\$ < b(aa)b\$
\$b < (aa)b\$
\$b( < aa)b\$
\$b(a < a)b\$
\$b(M > a)b\$
\$b(Ma = )b\$
\$b(Ma) = b\$
\$b(L > b\$
\$bM > b\$
\$bMb = \$
\$Z > \$
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 14

## Operator Precedence grammar ( OPM )

You have been given the following rules to obtain the ‘Less Than’ & ‘Greater
Than’ Matrices.

## Less Than -> ( FIRST ) * ( FIRST TERM )

Greater Than -> ( LAST * ) (LAST TERM ) T ( )
Write a C-program to extract the FIRST, EQUAL, LAST,
FIRST_TERM, EQUAL_TERM & LAST_TERM matrices from the following
Grammar. By using superimposition of the three matrices obtain & print the
OPM.

Grammar G : { N, T, P, S }

Production is E -> E + T / T

T -> T * F / F

F -> ( E ) / id
PROGRAM:

#include<iostream.h>
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<stdlib.h>
#include<alloc.h>
#include<string.h>

class opm
{
private:
char s[20],cnt[10],ct[10],**p1,**prod,**lval,**rval;
int meq[10][10],mfplus[10][10],mfstar[10][10],ml[10][10];
int c,i,cp,t,j,nt,n,k,l;
int m3[10][10],m[10][10],mfterm[10][10],mlterm[10][10],mltr[10][10];
int eq[10][10];
char sim[10][10];
public:
void get_data();
void display(int m[10][10]);
void equal();
void first();
void last();
void multiply(int m1[10][10],int m2[10][10]);
void superimpose();
void parse();
void fterm();
void lterm();
void less();
void pequal();
void greater();
void matrix();
void simpose();
};

void opm::get_data()
{
cout<<"\nHow many nonterminals:";
cin>>nt;
cout<<"\nEnter nonterminals:";
for(i=0;i<nt;i++)
cin>>cnt[i];
cout<<"\nHow many terminals:";
cin>>t;
cout<<"\nEnter terminals:";
for(i=0;i<t;i++)
cin>>ct[i];
//i=i+1;
ct[i]='#';
t=t+1;
cout<<"\nHow many productions:";
cin>>cp;
int n1=0;
lval=(char **)malloc(sizeof(char)*10);
rval=(char **)malloc(sizeof(char)*10);
for(n1=0;n1<cp;n1++)
{
lval[n1]=(char *)malloc(sizeof(char)*10);
rval[n1]=(char *)malloc(sizeof(char)*10);
}
prod[n1]=(char *)malloc(sizeof(char)*10);
for(n1=0;n1<cp;n1++)
prod[n1]=(char *)malloc(sizeof(char)*10);
for(k=0;k<cp;k++)
{
cout<<"\nEnter the production:";
gets(prod[k]);
p1[k]=strtok(prod[k]," ");
lval[k]=strtok(p1[k],"=");
rval[k]=strtok(NULL," ");
}
for(k=0;k<nt;k++)
s[k]=cnt[k];
l=k;
k=0;
while(ct[k]!='\0')
{
s[l]=ct[k];
k++;
l++;
cout<<"\t"<<s[l];
}
}

void opm::matrix()
{
for(i=0;i<t+nt;i++)
{
for(j=0;j<t+nt;j++)
{
meq[i][j]=0;
mfplus[i][j]=0;
mfstar[i][j]=0;
ml[i][j]=0;
mfterm[i][j]=0;
mlterm[i][j]=0;
mltr[i][j]=0;
m3[i][j]=0;
eq[i][j]=0;
sim[i][j]='0';
}
}
}

void opm::equal()
{
char s1,s2;
int x=0,y=0,a=0,b=0;
clrscr();
for(k=0;k<cp;k++)
{
if(strlen(rval[k])>1)
{
for(l=0;l<strlen(rval[k]);l++)
{
s1=rval[k][l];
if(rval[k][++l]!=NULL)
s2=rval[k][l];
else
break;
x=y=0;
while(s[x]!='\0')
{
if(s[x]==s1)
{
a=x;
break;
}
x++;
}//while

while(s[y]!='\0')
{
if(s[y]==s2)
{
b=y;
break;
}
y++;
}//while
meq[a][b]=1;
l--;
}//for
}//if
}//for
cout<<"Equal :\n";
display(meq);
}

void opm::first()
{
char f1,f2;
int x=0,y=0,a=0,b=0;
n=t+nt;
for(k=0;k<cp;k++)
{
f1=lval[k][0];
f2=rval[k][0];
x=y=0;
while(s[x]!='\0')
{
if(s[x]==f1)
{
a=x;
break;
}//if
x++;
}//while
while(s[y]!='\0')
{
if(s[y]==f2)
{
b=y;
break;
}
y++;
}
mfplus[a][b]=1;
}

int i1=0;
while(i1<n)
{
for(int j2=0;j2<n;j2++)
{
if(mfplus[j2][i1]==1)
{
for(int k2=0;k2<n;k2++)
mfplus[j2][k2]=(mfplus[j2][k2] || mfplus[i1][k2]);
}//if
}
i1++;
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
mfstar[i][j]=mfplus[i][j];
mfstar[i][i]=1;
}
cout<<"First* :\n";
display(mfstar);
}

void opm::fterm()
{
flushall();
char s1,s2;
int flag=0;
int x=0,y=0,a=0,b=0,k1=0;
for(k1=0;k1<cp;k1++)
{
flag=0;
if(strlen(rval[k1])==1)
{
for(i=0;i<nt;i++)
{
if(rval[k1][0]==cnt[i])
{
flag=1;
break;
}
}
}
if(flag!=1)
{
s1=lval[k1][0];

for(i=0;i<t;i++)
{
if(rval[k1][0]==ct[i])
s2=rval[k1][0];
else if(rval[k1][1]==ct[i])
s2=rval[k1][1];
}
x=y=0;
while(s[x]!='\0')
{
if(s[x]==s1)
{
a=x;
break;
}//if
x++;
}//while
while(s[y]!='\0')
{
if(s[y]==s2)
{
b=y;
break;
}
y++;
}
mfterm[a][b]=1;
}
}
cout<<"\n Firstterm :";
display(mfterm);
}

void opm::lterm()
{
char l1,l2;
int x=0,y=0,a=0,b=0;
int z,flag1=0;
flushall();
for(k=0;k<cp;k++)
{
flag1=0;
if(strlen(rval[k])==1)
{
for(i=0;i<nt;i++)
{
if(rval[k][0]==cnt[i])
{
flag1=1;
break;
}
else
flag1=0;
}
}
if(flag1!=1)
{
l1=lval[k][0];
z=strlen(rval[k]);
for(i=0;i<t;i++)
{
if(rval[k][z-1]==ct[i])
l2=rval[k][z-1];
else if(rval[k][z-2]==ct[i])
l2=rval[k][z-2];
}
x=y=0;
while(s[x]!='\0')
{
if(s[x]==l1)
{
a=x;
break;
}//if
x++;
}//while
while(s[y]!='\0')
{
if(s[y]==l2)
{
b=y;
break;
}
y++;
} //while
mlterm[a][b]=1;
}//if
}//for
cout<<"Lastterm :\n";
display(mlterm);
}

void opm::last()
{
char l1,l2;
int x=0,y=0,a=0,b=0;
int z;
int n=t+nt;
flushall();
for(k=0;k<cp;k++)
{
l1=lval[k][0];
z=strlen(rval[k]);
l2=rval[k][z-1];
x=y=0;
while(s[x]!='\0')
{
if(s[x]==l1)
{
a=x;
break;
}//if
x++;
}//while
while(s[y]!='\0')
{
if(s[y]==l2)
{
b=y;
break;
}
y++;
} //while
ml[a][b]=1;
}//for
int i1=0;
while(i1<n)
{
for(int j1=0;j1<n;j1++)
{
if(ml[j1][i1]==1)
{
for(int k1=0;k1<n;k1++)
ml[j1][k1]=(ml[j1][k1] || ml[i1][k1]);
}//if
}
i1++;
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
ml[i][i]=1;
}

cout<<"Last * :\n";
display(ml);
}

void opm::greater()
{
int n=t+nt;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
m3[i][j]=0;
multiply(ml,mlterm);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
ml[i][j]=0;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
ml[j][i]=m3[i][j];
}
for(i=0;i<n;i++)
for(j=0;j<n;j++)
m3[i][j]=0;
multiply(ml,meq);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
mltr[i][j]=m3[i][j];
cout<<"\nGreater Matrix : ";
display(mltr);
}

void opm::less()
{
int n=t+nt;
multiply(meq,mfstar);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
mfstar[i][j]=0;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
mfstar[i][j]=m3[i][j];
}
for(i=0;i<n;i++)
for(j=0;j<n;j++)
m3[i][j]=0;
multiply(mfstar,mfterm);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
mfstar[i][j]=0;
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
mfstar[i][j]=m3[i][j];
}
cout<<"\n Less Matrix :";
display(mfstar);
}

void opm::pequal()
{
int i1,j1,i2,i3,k1,x,y,a,b;
char l,m;
for(j1=0;j1<cp;j1++)
{
for(k1=0;k1<strlen(rval[j1]);k1++)
{
l=m='\0';
a=b=0;
for(i1=0;i1<t;i1++)
if(rval[j1][k1]==ct[i1])
{
l=rval[j1][k1];
for(i2=0;i2<t;i2++)
if(rval[j1][k1+1]==ct[i2])
{
m=rval[j1][k1+1];
break;
}
else if(rval[j1][k1+2]==ct[i2])
for(i3=0;i3<t;i3++)
if(rval[j1][k1+2]==ct[i3])
{
m=rval[j1][k1+2];
break;
}
}//if
if(l!='\0' && m!='\0')
{
x=y=0;
while(s[x]!='\0')
{
if(s[x]==l)
{
a=x;
break;
}//if

x++;
}//while
while(s[y]!='\0')
{
if(s[y]==m)
{
b=y;
break;
}
y++;
} //while
eq[a][b]=1;
a=b=0;
}//if

}
}
cout<<"\nEqual precedence:";
display(eq);
}

## void opm::multiply(int m1[10][10],int m2[10][10])

{
int n=t+nt;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
for(int k=0;k<n;k++)
m3[i][j]=m3[i][j] + m1[i][k] * m2[k][j];
if(m3[i][j]>=2)
m3[i][j]=1;
}
}
}

void opm::simpose()
{
int a,b,c;
a=nt+t;
for(i=0;i<a;i++)
for(j=0;j<a;j++)
{
sim[i][j]='0';
m[i][j]=0;
}

for(i=a-t;i<a;i++)
{
m[i][a-1]=3;
m[a-1][i]=2;
}
for(i=0;i<a;i++)
{
for(j=0;j<a;j++)
{
if(mfstar[i][j]==1)
{
sim[i][j]='<';
m[i][j]=2;
}
if(mltr[i][j]==1)
{
sim[i][j]='>';
m[i][j]=3;
}
if(eq[i][j]==1)
{
sim[i][j]='=';
m[i][j]=1;
}
}
}
display(m);
cout<<"\nSuperimposed matrix:";
cout<<"\n";
for(i=0;i<a;i++)
cout<<"\t"<<s[i];
cout<<"\n ----------------------------------------------------------------";
for(i=0;i<a;i++)
{
cout<<"\n "<<s[i];
cout<<" |";
for(j=0;j<a;j++)
cout<<"\t"<<sim[i][j];
}
}

void opm::parse()
{
char c;
int q=0,m1=0,k=0,v,w;
char p[15],hand[10];
int a,b,fh=-1,bh=-1,inh=0,e=1;
int flag=0;
cout<<"\nEnter the string to be parsed:";
gets(p);
cout<<"\n Enter the exclusive symbol :";
cin>>c;
q=strlen(p);
m1=0;
while(m1<q)
{
// a=b=0;
/* if(p[m1]=='#')
{
a=1;
flag=1;
v=w=0;
}*/
for(k=0;k<t;k++)
if(p[m1]==ct[k])
v=w=0;
if(flag==0)
{
a=b=0;
while(s[v]!='\0')
{
if(s[v]==p[m1])
{
a=v;
flag=1;
break;
}
v++;
}
}
if(flag==1)
{
m1++;
for(k=0;k<t;k++)
if(p[m1]==ct[k])
{
while(s[w]!='\0')

{
if(s[w]==p[m1])
{
b=w;
flag=0;
// m1--;
break;
}
w++;
}//while
}//if
// m1--;
}//if
if(a!=0 && b!=0)
{
switch(m[a][b])
{
case 2:

{
for(int k1=0;k1<nt;k1++)
{
if(p[m1-1]==cnt[k1])
{
fh=m1-1;
break;
}
else
{
fh=m1;
// break;
}
}
break;
}
case 3: bh=m1-1; break;
case 1: e++;
}//switch
if(fh>=0 && bh>0)
{
inh=fh;
for(k=0;fh<=bh;fh++,k++)
hand[k]=p[fh];
hand[k]='\0';
cout<<"\nHandle:"<<hand;
for(k=0;k<cp;k++)
{
if(strcmp(rval[k],hand)==0)
{
p[inh]=lval[k][0];
break;
}
}
for(;p[bh]!='\0';)
p[++inh]=p[++bh];
p[bh]='\0';
a=b=0;
cout<<"\n P:"<<p;
fh=bh=e=m1=-1;
}//if
}//if a,b
if(a==0)
m1++;
if(p[1]==c &&strlen(p)==3)
break;
}//while
for(k=0;k<cp;k++)
if(strcmp(rval[k],hand)==0)
break;
if(c==lval[k][0])
cout<<"\nString is parsable"<<lval[k][0];
else
cout<<"\nString is not parsable";
}
void opm::display(int m[10][10])
{
cout<<"\n\n";
flushall();
int p=t+nt;
for(i=0;i<p;i++)
cout<<"\t"<<s[i];
cout<<"\n ------------------------------------------------------------------";
for(i=0;i<p;i++)
{
cout<<"\n "<<s[i];
cout<<" |";
for(j=0;j<p;j++)
cout<<"\t"<<m[i][j];
}
}
void main()
{
opm o1;
int a;
clrscr();
flushall();
o1.get_data();
o1.matrix();
o1.equal();
getch();
clrscr();
o1.first();
getch();
clrscr();
o1.last();
getch();
clrscr();
o1.fterm();
getch();
clrscr();
o1.lterm();
getch();
clrscr();
o1.less();
getch();
clrscr();
o1.greater();
getch();
clrscr();
o1.pequal();
getch();
clrscr();
o1.simpose();
getch();
clrscr();
o1.parse();
getch();
}
OUTPUT-

Program Input:-

## How many nonterminals:3

Enter nonterminals:ETF
How many terminals:5
Enter terminals:+*()i
How many productions:6
Enter the production:E=E+T
Enter the production:T=T*F
Enter the production:E=T
Enter the production:T=F
Enter the production:F=(E)
Enter the production:F=i

Program Output:-

Equal :
E T F + * ( ) i #
------------------------------------------------------------------
E| 0 0 0 1 0 0 1 0 0
T| 0 0 0 0 1 0 0 0 0
F| 0 0 0 0 0 0 0 0 0
+| 0 1 0 0 0 0 0 0 0
*| 0 0 1 0 0 0 0 0 0
(| 1 0 0 0 0 0 0 0 0
)| 0 0 0 0 0 0 0 0 0
i| 0 0 0 0 0 0 0 0 0
#| 0 0 0 0 0 0 0 0 0

First* :
E T F + * ( ) i #
------------------------------------------------------------------
E| 1 1 1 0 0 1 0 1 0
T| 0 1 1 0 0 1 0 1 0
F| 0 0 1 0 0 1 0 1 0
+| 0 0 0 1 0 0 0 0 0
*| 0 0 0 0 1 0 0 0 0
(| 0 0 0 0 0 1 0 0 0
)| 0 0 0 0 0 0 1 0 0
i| 0 0 0 0 0 0 0 1 0
#| 0 0 0 0 0 0 0 0 1
Last * :
E T F + * ( ) i #
------------------------------------------------------------------
E| 1 1 1 0 0 0 1 1 0
T| 0 1 1 0 0 0 1 1 0
F| 0 0 1 0 0 0 1 1 0
+| 0 0 0 1 0 0 0 0 0
*| 0 0 0 0 1 0 0 0 0
(| 0 0 0 0 0 1 0 0 0
)| 0 0 0 0 0 0 1 0 0
i| 0 0 0 0 0 0 0 1 0
#| 0 0 0 0 0 0 0 0 1

Firstterm :
E T F + * ( ) i #
------------------------------------------------------------------
E| 0 0 0 1 0 0 0 0 0
T| 0 0 0 0 1 0 0 0 0
F| 0 0 0 0 0 1 0 1 0
+| 0 0 0 0 0 0 0 0 0
*| 0 0 0 0 0 0 0 0 0
(| 0 0 0 0 0 0 0 0 0
)| 0 0 0 0 0 0 0 0 0
i| 0 0 0 0 0 0 0 0 0
#| 0 0 0 0 0 0 0 0 0

Lastterm :
E T F + * ( ) i #
------------------------------------------------------------------
E| 0 0 0 1 0 0 0 0 0
T| 0 0 0 0 1 0 0 0 0
F| 0 0 0 0 0 0 1 1 0
+| 0 0 0 0 0 0 0 0 0
*| 0 0 0 0 0 0 0 0 0
(| 0 0 0 0 0 0 0 0 0
)| 0 0 0 0 0 0 0 0 0
i| 0 0 0 0 0 0 0 0 0
#| 0 0 0 0 0 0 0 0 0
Less Matrix :
E T F + * ( ) i #
------------------------------------------------------------------
E| 0 0 0 0 0 0 0 0 0
T| 0 0 0 0 0 0 0 0 0
F| 0 0 0 0 0 0 0 0 0
+| 0 0 0 0 1 1 0 1 0
*| 0 0 0 0 0 1 0 1 0
(| 0 0 0 1 1 1 0 1 0
)| 0 0 0 0 0 0 0 0 0
i| 0 0 0 0 0 0 0 0 0
#| 0 0 0 0 0 0 0 0 0

Greater Matrix :
E T F + * ( ) i #
------------------------------------------------------------------
E| 0 0 0 0 0 0 0 0 0
T| 0 0 0 0 0 0 0 0 0
F| 0 0 0 0 0 0 0 0 0
+| 0 0 0 1 0 0 1 0 0
*| 0 0 0 1 1 0 1 0 0
(| 0 0 0 0 0 0 0 0 0
)| 0 0 0 1 1 0 1 0 0
i| 0 0 0 1 1 0 1 0 0
#| 0 0 0 0 0 0 0 0 0

Equal precedence:
E T F + * ( ) i #
------------------------------------------------------------------
E| 0 0 0 0 0 0 0 0 0
T| 0 0 0 0 0 0 0 0 0
F| 0 0 0 0 0 0 0 0 0
+| 0 0 0 0 0 0 0 0 0
*| 0 0 0 0 0 0 0 0 0
(| 0 0 0 0 0 0 1 0 0
)| 0 0 0 0 0 0 0 0 0
i| 0 0 0 0 0 0 0 0 0
#| 0 0 0 0 0 0 0 0 0
E T F + * ( ) i #
------------------------------------------------------------------
E| 0 0 0 0 0 0 0 0 0
T| 0 0 0 0 0 0 0 0 0
F| 0 0 0 0 0 0 0 0 0
+| 0 0 0 3 2 2 3 2 3
*| 0 0 0 3 3 2 3 2 3
(| 0 0 0 2 2 2 1 2 3
)| 0 0 0 3 3 0 3 0 3
i| 0 0 0 3 3 0 3 0 3
#| 0 0 0 2 2 2 2 2 2

Superimposed matrix:
E T F + * ( ) i #
----------------------------------------------------------------
E| 0 0 0 0 0 0 0 0 0
T| 0 0 0 0 0 0 0 0 0
F| 0 0 0 0 0 0 0 0 0
+| 0 0 0 > < < > < 0
*| 0 0 0 > > < > < 0
(| 0 0 0 < < < = < 0
)| 0 0 0 > > 0 > 0 0
i| 0 0 0 > > 0 > 0 0
#| 0 0 0 0 0 0 0 0 0

## Enter the exclusive symbol :T

Handle:E+T
P:#T*(E)#
Handle:(E)
P:#T*F#
Handle:T*F
P:#T#
String is parsableT
Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07
Compiler Construction ( Section–II )
INDEX

No
Title Page No. Date Sign
.

3 Triple Representation

6 DAG

## 9 Depth Spanning Tree

10 Code Generation

11 Postfix to Infix

12 Infix to Postfix
Read the program in file & find out
13
the token in the program.
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-II)

PRACTICAL 1

Write a program to obtain Three - Address code for the following arithmetic operation
:
a*b*(c*d)
First Step in generation of the 3 address code of the operation is A=c * d
obtain the operation a * b * A is a temporary variable.
PROGRAM:

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class Grammer
{
struct qdrplr
{
char op;
char A1;
char A2;
int R;

struct tripl
{
char op;
char A1;
char A2;
} triple[10];

int no_qdrpl;
int result;

public:
char *inputString;
int res;
char operators[20];
int no_op;
char variables[20];
int no_var;
Grammer(void);
int findOpenBrace(char*,int);
int findCloseBrace(char*,int);
char* subString(char*,int,int);
};

{
int i;
cout << endl << "Three Address Code:" << endl;
for(i=0;i<no_qdrpl;i++)
{
cout << "T" << quadraple[i].R << " = ";

cout << "T" << quadraple[i].A1 << " ";
else
cout << quadraple[i].A1 << " ";

## cout << quadraple[i].op << " ";

cout << "T" << quadraple[i].A2 << " ";
else
cout << quadraple[i].A2 << " ";

}
}

## char* Grammer :: subString(char *str, int start, int end)

{
char* returnStr;
int k,l=0;

for(k=start;k<=end;k++)
returnStr[l++] = str[k];
returnStr[l] = '\0';
return returnStr;
}

{
int posOpenBrace,posCloseBrace,startExpr,endExpr;
int i,k,l;
char *subStr;

while(strlen(inputString) > 1)
{
startExpr=0;
endExpr=strlen(inputString);

posOpenBrace = findOpenBrace(inputString,0);
if(posOpenBrace != -1)
posCloseBrace = findCloseBrace(inputString,posOpenBrace);

## if(posOpenBrace == -1) // no any bracket in string

{
for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='*' || inputString[k]=='/' ||
inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='=')
{
startExpr=k-1;
endExpr=k+1;
}
}
}

## if(posCloseBrace == posOpenBrace+4) // omly one expr in brackets

{
startExpr=posOpenBrace;
endExpr=posCloseBrace;
}

## if(posOpenBrace != -1) // no any bracket in string

{
for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='*' || inputString[k]=='/' ||
inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='=')
{
startExpr=k-1;
endExpr=k+1;
}
}
}

in brackets
{

## if(inputString[startExpr+1] >= '0' && inputString[startExpr+1] <= '9')

triple[no_qdrpl].A1 = inputString[startExpr+1]-1;
else
triple[no_qdrpl].A1 = inputString[startExpr+1];

triple[no_qdrpl].op = inputString[startExpr+2];

## if(inputString[startExpr+3] >= '0' && inputString[startExpr+3] <= '9')

triple[no_qdrpl].A2 = inputString[startExpr+3]-1;
else
triple[no_qdrpl].A2 = inputString[startExpr+3];

no_qdrpl++;
}
else
{

## if(inputString[startExpr] >= '0' && inputString[startExpr] <= '9')

triple[no_qdrpl].A1 = inputString[startExpr]-1;
else
triple[no_qdrpl].A1 = inputString[startExpr];

triple[no_qdrpl].op = inputString[startExpr+1];

## if(inputString[startExpr+2] >= '0' && inputString[startExpr+2] <= '9')

triple[no_qdrpl].A2 = inputString[startExpr+2]-1;
else
triple[no_qdrpl].A2 = inputString[startExpr+2];

no_qdrpl++;
}

strcpy(subStr,"");
l=0;
k=0;
while(inputString[k] != '\0')
{
if(startExpr == k)
{
subStr[l] = 48+result-1;
k = endExpr+1;
}
else
{
subStr[l] = inputString[k];
k++;
}
l++;
}
subStr[l] = '\0';

strcpy(inputString,subStr);
}
}

## int Grammer :: findOpenBrace(char *str,int startPos)

{
int k,currentPos=-1;

for(k=startPos;k<strlen(str);k++)
{
if(str[k] == '(')
currentPos=k;
if(str[k] == ')')
break;
}

return currentPos;
}

## int Grammer :: findCloseBrace(char *str,int startPos)

{
int k;

for(k=startPos;k<strlen(str);k++)
if(str[k] == ')')
return k;
return -1;
}

Grammer :: Grammer(void)
{
int i,j;
clrscr();

no_op=0;
no_var=0;
no_qdrpl=0;
result=1;
cout << "Enter the String:";
gets(inputString);
//cout << inputString;

for(i=0;i<strlen(inputString);i++)
{
if(inputString[i] != ' ')
{
if( ((int)inputString[i] >= 65 && (int)inputString[i] <= 90) ||
((int)inputString[i] >= 97 && (int)inputString[i] <= 122) )
{
for(j=0;j<no_var;j++)
if(inputString[i] == variables[j])
goto nextVar;
variables[no_var++] = inputString[i];
nextVar:
}
else
if(inputString[i] == '=' || inputString[i] == '+' || inputString[i]
== '-' || inputString[i] == '*' || inputString[i] == '/' || inputString[i] == '%' || inputString[i] == '('
|| inputString[i] == ')')
{
if(inputString[i] != '(' && inputString[i] != ')')
{
for(j=0;j<no_op;j++)
if(inputString[i] == operators[j])
goto nextOp;
operators[no_op++] = inputString[i];
nextOp:
}
}
else
{
cout << endl << inputString[i] << " is encoutered in the
string as invalid character, Thus the string is invalid.";
getch();
exit(0);
}
}
}

## cout << endl << "Variables are as Follows:" << endl;

for(i=0;i<no_var;i++)
cout << variables[i] << " ";

## cout << endl << "Operators are as Follows:" << endl;

for(i=0;i<no_op;i++)
cout << operators[i] << " ";
}

int main(void)
{
Grammer g;
//int result;
//G1.PrintGrammer();
//dg.FindFirstFollow();
cout << endl;
getch();
return 0;
}
OUTPUT:

## Variables are as Follows:

abcd
Operators are as Follows:
*

T1 = c * d
T2 = a * b
T3 = T2 * T1
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 2 & 3

## Obtain the Intermediate Representation of the given arithmetic expression in the

Matrix form
b. Triple representation of three address statements.

## Consider the expression : (a+b)*(c+d)

Then it’s Intermediate Representation is,
OP ARG1 ARG2 RESULT
0 + a B T1
1 + c D T2
2 * T1 T2 T3

Triple :
OP ARG1 ARG2
0 + a B
1 + c D
2 * (0) (1)
Program:

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class Grammer
{
struct qdrplr
{
char op;
char A1;
char A2;
int R;

struct tripl
{
char op;
char A1;
char A2;
} triple[10];

int no_qdrpl;
int result;

public:
char *inputString;
int res;
char operators[20];
int no_op;
char variables[20];
int no_var;
Grammer(void);
int findOpenBrace(char*,int);
int findCloseBrace(char*,int);
char* subString(char*,int,int);
};

{
int i;
cout << endl << "Quadraple Table" << endl;
cout << "\tOP\tA1\tA2\tR" << endl;

for(i=0;i<no_qdrpl;i++)
{
cout << "E" << i << "\t" << quadraple[i].op << "\t" << quadraple[i].A1 << "\t"
}

## cout << endl << "Triple Table" << endl;

cout << "\tOP\tA1\tA2" << endl;

for(i=0;i<no_qdrpl;i++)
{
cout << i << "\t" << triple[i].op << "\t" << triple[i].A1 << "\t" << triple[i].A2
<< endl;
}
}

## char* Grammer :: subString(char *str, int start, int end)

{
char* returnStr;
int k,l=0;

for(k=start;k<=end;k++)
returnStr[l++] = str[k];
returnStr[l] = '\0';
return returnStr;
}

{
int posOpenBrace,posCloseBrace,startExpr,endExpr;
int i,k,l;
char *subStr;

while(strlen(inputString) > 1)
{
startExpr=0;
endExpr=strlen(inputString);

posOpenBrace = findOpenBrace(inputString,0);
if(posOpenBrace != -1)
posCloseBrace = findCloseBrace(inputString,posOpenBrace);

## if(posOpenBrace == -1) // no any bracket in string

{
for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='*' || inputString[k]=='/' ||
inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='=')
{
startExpr=k-1;
endExpr=k+1;
}
}
}

## if(posCloseBrace == posOpenBrace+4) // omly one expr in brackets

{
startExpr=posOpenBrace;
endExpr=posCloseBrace;
}

## if(posOpenBrace != -1) // no any bracket in string

{
for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='*' || inputString[k]=='/' ||
inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
}
}
for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='=')
{
startExpr=k-1;
endExpr=k+1;
}
}
}

in brackets
{

## if(inputString[startExpr+1] >= '0' && inputString[startExpr+1] <= '9')

triple[no_qdrpl].A1 = inputString[startExpr+1]-1;
else
triple[no_qdrpl].A1 = inputString[startExpr+1];

triple[no_qdrpl].op = inputString[startExpr+2];

## if(inputString[startExpr+3] >= '0' && inputString[startExpr+3] <= '9')

triple[no_qdrpl].A2 = inputString[startExpr+3]-1;
else
triple[no_qdrpl].A2 = inputString[startExpr+3];

no_qdrpl++;
}
else
{

## if(inputString[startExpr] >= '0' && inputString[startExpr] <= '9')

triple[no_qdrpl].A1 = inputString[startExpr]-1;
else
triple[no_qdrpl].A1 = inputString[startExpr];

triple[no_qdrpl].op = inputString[startExpr+1];

## if(inputString[startExpr+2] >= '0' && inputString[startExpr+2] <= '9')

triple[no_qdrpl].A2 = inputString[startExpr+2]-1;
else
triple[no_qdrpl].A2 = inputString[startExpr+2];

no_qdrpl++;
}

strcpy(subStr,"");
l=0;
k=0;
while(inputString[k] != '\0')
{
if(startExpr == k)
{
subStr[l] = 48+result-1;
k = endExpr+1;
}
else
{
subStr[l] = inputString[k];
k++;
}
l++;
}
subStr[l] = '\0';

strcpy(inputString,subStr);
}
}

## int Grammer :: findOpenBrace(char *str,int startPos)

{
int k,currentPos=-1;

for(k=startPos;k<strlen(str);k++)
{
if(str[k] == '(')
currentPos=k;
if(str[k] == ')')
break;
}

return currentPos;
}

## int Grammer :: findCloseBrace(char *str,int startPos)

{
int k;

for(k=startPos;k<strlen(str);k++)
if(str[k] == ')')
return k;
return -1;
}

Grammer :: Grammer(void)
{
int i,j;
clrscr();

no_op=0;
no_var=0;
no_qdrpl=0;
result=1;
cout << "Enter the String:";
gets(inputString);
//cout << inputString;

for(i=0;i<strlen(inputString);i++)
{
if(inputString[i] != ' ')
{
if( ((int)inputString[i] >= 65 && (int)inputString[i] <= 90) ||
((int)inputString[i] >= 97 && (int)inputString[i] <= 122) )
{
for(j=0;j<no_var;j++)
if(inputString[i] == variables[j])
goto nextVar;
variables[no_var++] = inputString[i];
nextVar:
}
else
if(inputString[i] == '=' || inputString[i] == '+' || inputString[i]
== '-' || inputString[i] == '*' || inputString[i] == '/' || inputString[i] == '%' || inputString[i] == '('
|| inputString[i] == ')')
{
if(inputString[i] != '(' && inputString[i] != ')')
{
for(j=0;j<no_op;j++)
if(inputString[i] == operators[j])
goto nextOp;
operators[no_op++] = inputString[i];
nextOp:
}
}
else
{
cout << endl << inputString[i] << " is encoutered in the
string as invalid character, Thus the string is invalid.";
getch();
exit(0);
}
}
}

## cout << endl << "Variables are as Follows:" << endl;

for(i=0;i<no_var;i++)
cout << variables[i] << " ";

## cout << endl << "Operators are as Follows:" << endl;

for(i=0;i<no_op;i++)
cout << operators[i] << " ";
}

int main(void)
{
Grammer g;
//int result;
//G1.PrintGrammer();
//dg.FindFirstFollow();
cout << endl;
getch();
return 0;
}
OUTPUT:

## Variables are as Follows:

abcd
Operators are as Follows:
=*+

OP A1 A2 R
E0 + c d 1
E1 * b 1 2
E2 = a 2 3

Triple Table
OP A1 A2
0 + c d
1 * b 0
2 = a 1
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 4

## Perform optimization on the quadruples provided to you and generate an

optimized quadruple to produce optimized code for the program.

0 + a b T1
1 + a b T2
2 * T1 T2 T3

## Op Arg1 Arg2 Result

0 + a b T1
1 * T1 T1 T2
PROGRAM:

// Optimization
#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class Grammer
{
struct qdrplr
{
char op;
char A1;
char A2;
int R;

struct tripl
{
char op;
char A1;
char A2;
} triple[10];

int no_qdrpl;
int result;

public:
char *inputString;
int res;
char operators[20];
int no_op;
char variables[20];
int no_var;
Grammer(void);
int findOpenBrace(char*,int);
int findCloseBrace(char*,int);
char* subString(char*,int,int);
};

{
int i;
cout << endl << "Quadraple Table" << endl;
cout << "\tOP\tA1\tA2\tR" << endl;
for(i=0;i<no_qdrpl;i++)
{
cout << "E" << i << "\t" << quadraple[i].op << "\t" << quadraple[i].A1 << "\t" <<
}

## cout << endl << "Triple Table" << endl;

cout << "\tOP\tA1\tA2" << endl;

for(i=0;i<no_qdrpl;i++)
{
cout << i << "\t" << triple[i].op << "\t" << triple[i].A1 << "\t" << triple[i].A2 <<
endl;
}
}

## char* Grammer :: subString(char *str, int start, int end)

{
char* returnStr;
int k,l=0;

for(k=start;k<=end;k++)
returnStr[l++] = str[k];
returnStr[l] = '\0';
return returnStr;
}

{
int posOpenBrace,posCloseBrace,startExpr,endExpr;
int i,k,l;
char *subStr;

while(strlen(inputString) > 1)
{
startExpr=0;
endExpr=strlen(inputString);

posOpenBrace = findOpenBrace(inputString,0);
if(posOpenBrace != -1)
posCloseBrace = findCloseBrace(inputString,posOpenBrace);

## if(posOpenBrace == -1) // no any bracket in string

{
for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='*' || inputString[k]=='/' || inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
}
}
}

## if(posCloseBrace == posOpenBrace+4) // omly one expr in brackets

{
startExpr=posOpenBrace;
endExpr=posCloseBrace;
}

## if(posOpenBrace != -1) // no any bracket in string

{
for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='*' || inputString[k]=='/' || inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
}
}
}

if( inputString[startExpr]=='(' && inputString[endExpr]==')' ) // only one expr in
brackets
{
for(k=0;k<no_qdrpl;k++)
{
{
res=k+2;
goto processStr;
}
}

## if(inputString[startExpr+1] >= '0' && inputString[startExpr+1] <= '9')

triple[no_qdrpl].A1 = inputString[startExpr+1]-1;
else
triple[no_qdrpl].A1 = inputString[startExpr+1];

triple[no_qdrpl].op = inputString[startExpr+2];

## if(inputString[startExpr+3] >= '0' && inputString[startExpr+3] <= '9')

triple[no_qdrpl].A2 = inputString[startExpr+3]-1;
else
triple[no_qdrpl].A2 = inputString[startExpr+3];

res=result;
no_qdrpl++;
}
else
{
for(k=0;k<no_qdrpl;k++)
{
{
res=k+2;
goto processStr;
}
}

## if(inputString[startExpr] >= '0' && inputString[startExpr] <= '9')

triple[no_qdrpl].A1 = inputString[startExpr]-1;
else
triple[no_qdrpl].A1 = inputString[startExpr];

triple[no_qdrpl].op = inputString[startExpr+1];

## if(inputString[startExpr+2] >= '0' && inputString[startExpr+2] <= '9')

triple[no_qdrpl].A2 = inputString[startExpr+2]-1;
else
triple[no_qdrpl].A2 = inputString[startExpr+2];

res=result;
no_qdrpl++;
}

processStr:
strcpy(subStr,"");
l=0;
k=0;
while(inputString[k] != '\0')
{
if(startExpr == k)
{
subStr[l] = 48+res-1;
k = endExpr+1;
}
else
{
subStr[l] = inputString[k];
k++;
}
l++;
}
subStr[l] = '\0';

strcpy(inputString,subStr);
}
}

## int Grammer :: findOpenBrace(char *str,int startPos)

{
int k,currentPos=-1;

for(k=startPos;k<strlen(str);k++)
{
if(str[k] == '(')
currentPos=k;
if(str[k] == ')')
break;
}

return currentPos;
}

## int Grammer :: findCloseBrace(char *str,int startPos)

{
int k;

for(k=startPos;k<strlen(str);k++)
if(str[k] == ')')
return k;
return -1;
}

Grammer :: Grammer(void)
{
int i,j;
clrscr();

no_op=0;
no_var=0;
no_qdrpl=0;
result=1;
cout << "Enter the String:";
gets(inputString);

for(i=0;i<strlen(inputString);i++)
{
if(inputString[i] != ' ')
{
if( ((int)inputString[i] >= 65 && (int)inputString[i] <= 90) ||
((int)inputString[i] >= 97 && (int)inputString[i] <= 122) )
{
for(j=0;j<no_var;j++)
if(inputString[i] == variables[j])
goto nextVar;
variables[no_var++] = inputString[i];
nextVar:
}
else
if(inputString[i] == '+' || inputString[i] == '-' || inputString[i] == '*' ||
inputString[i] == '/' || inputString[i] == '%' || inputString[i] == '(' ||
inputString[i] == ')')
{
if(inputString[i] != '(' && inputString[i] != ')')
{
for(j=0;j<no_op;j++)
if(inputString[i] == operators[j])
goto nextOp;
operators[no_op++] = inputString[i];
nextOp:
}
}
else
{
cout << endl << inputString[i] << " is encoutered in the string as
invalid character, Thus the string is invalid.";
getch();
exit(0);
}
}
}

## cout << endl << "Variables are as Follows:" << endl;

for(i=0;i<no_var;i++)
cout << variables[i] << " ";

## cout << endl << "Operators are as Follows:" << endl;

for(i=0;i<no_op;i++)
cout << operators[i] << " ";
}

int main(void)
{
Grammer g;
cout << endl;
getch();
return 0;
}
OUTPUT:

abcd

## Operators are as Follows:

+*-

OP A1 A2 R
E0 + a b 1
E1 + c d 2
E2 + 1 c 3
E3 * 1 2 4
E4 - 4 3 5

Triple Table

OP A1 A2
0 + a b
1 + c d
2 + 0 c
3 * 0 1
4 - 3 2
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 5

## Write a program to obtain indirect triple representation of a following operation

a= - b * ( c + d)

## Indirect triple representation is similar to Triple representation but stores the

addresses of instruction in a separate array.
PROGRAM:

## // Indirect Triple Representation

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class Grammer
{
struct triple
{
char op;
char A1;
char A2;
} triple[10];

int no_triple;
int result;
int statement[20];

public:
char *inputString;
char operators[20];
int no_op;
char variables[20];
int no_var;
Grammer(void);
void findTriple();
int findOpenBrace(char*,int);
int findCloseBrace(char*,int);
void printTriple(void);
};

## void Grammer :: printTriple(void)

{
int i,j;

for(i=0;i<no_triple;i++)
statement[i] = i;

## cout << "\tstatement" << endl;

for(i=0;i<no_triple;i++)
cout << i << "\t" << (int)&statement[i] << endl;

## cout << endl << endl;

cout << "\tOP\tA1\tA2" << endl;
for(i=0;i<no_triple;i++)
{
cout << (int)&statement[i] << "\t" << triple[i].op << "\t";

## if(triple[i].A1 >= '0' && triple[i].A1 <= '9')

{
j = (int)triple[i].A1-48;
cout << (int)&statement[j] << "\t";
}
else
cout << triple[i].A1 << "\t";

## if(triple[i].A2 >= '0' && triple[i].A2 <= '9')

{
j = (int)triple[i].A2-48;
cout << (int)&statement[j] << "\t" << endl;
}
else
cout << triple[i].A2 << "\t" << endl;
}
}

## void Grammer :: findTriple()

{
int posOpenBrace,posCloseBrace,startExpr,endExpr;
int i,k,l;
char *subStr;

while(strlen(inputString) > 1)
{
startExpr=0;
endExpr=strlen(inputString);

posOpenBrace = findOpenBrace(inputString,0);
if(posOpenBrace != -1)
posCloseBrace = findCloseBrace(inputString,posOpenBrace);

## if(posOpenBrace == -1) // no any bracket in string

{
for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='*' || inputString[k]=='/' ||
inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}

for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}

for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='=')
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}
}

## if(posCloseBrace == posOpenBrace+4) // only one expr in brackets

{
startExpr=posOpenBrace;
endExpr=posCloseBrace;
goto getTriple;
}

## if(posOpenBrace != -1) // many expr in bracket

{
for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='*' || inputString[k]=='/' ||
inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}

for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}

for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='=')
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}
}

getTriple:

## if( inputString[startExpr]=='(' && inputString[endExpr]==')' ) // omly one

expr in brackets
{
triple[no_triple].A1 = inputString[startExpr+1];
triple[no_triple].op = inputString[startExpr+2];
triple[no_triple].A2 = inputString[startExpr+3];
no_triple++;
result++;
}
else
{
triple[no_triple].A1 = inputString[startExpr];
triple[no_triple].op = inputString[startExpr+1];
triple[no_triple].A2 = inputString[startExpr+2];
no_triple++;
result++;
}

strcpy(subStr,"");
l=0;
k=0;
while(inputString[k] != '\0')
{
if(startExpr == k)
{
subStr[l] = 48+result-1;
k = endExpr+1;
}
else
{
subStr[l] = inputString[k];
k++;
}
l++;
}
subStr[l] = '\0';

strcpy(inputString,subStr);
}
}

## int Grammer :: findOpenBrace(char *str,int startPos)

{
int k,currentPos=-1;

for(k=startPos;k<strlen(str);k++)
{
if(str[k] == '(')
currentPos=k;
if(str[k] == ')')
break;
}

return currentPos;
}

## int Grammer :: findCloseBrace(char *str,int startPos)

{
int k;

for(k=startPos;k<strlen(str);k++)
if(str[k] == ')')
return k;
return -1;
}

Grammer :: Grammer(void)
{
int i,j;
clrscr();

no_op=0;
no_var=0;
no_triple=0;
result=0;
cout << "Enter the String:";
gets(inputString);
//cout << inputString;

for(i=0;i<strlen(inputString);i++)
{
if(inputString[i] != ' ')
{
if( ((int)inputString[i] >= 65 && (int)inputString[i] <= 90) ||
((int)inputString[i] >= 97 && (int)inputString[i] <= 122) )
{
for(j=0;j<no_var;j++)
if(inputString[i] == variables[j])
goto nextVar;
variables[no_var++] = inputString[i];
nextVar:
}
else
if(inputString[i] == '=' || inputString[i] == '+' || inputString[i]
== '-' || inputString[i] == '*' || inputString[i] == '/' || inputString[i] == '%' || inputString[i] == '('
|| inputString[i] == ')')
{
if(inputString[i] != '(' && inputString[i] != ')')
{
for(j=0;j<no_op;j++)
if(inputString[i] == operators[j])
goto nextOp;
operators[no_op++] = inputString[i];
nextOp:
}
}
else
{
cout << endl << inputString[i] << " is encoutered in the
string as invalid character, Thus the string is invalid.";
getch();
exit(0);
}
}
}

## cout << endl << "Variables are as Follows:" << endl;

for(i=0;i<no_var;i++)
cout << variables[i] << " ";

## cout << endl << "Operators are as Follows:" << endl;

for(i=0;i<no_op;i++)
cout << operators[i] << " ";
}

int main(void)
{
Grammer g;
//int result;
//G1.PrintGrammer();
//dg.FindFirstFollow();
g.findTriple();
cout << endl;
g.printTriple();
getch();
return 0;
}

OUTPUT:

## Variables are as Follows:

abcd
Operators are as Follows:
=*+

Triple Table
statement
0 -96
1 -94
2 -92

OP A1 A2
-96 + c d
-94 * b -96
-92 = a -94
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-II)

PRACTICAL 6

DAG

Write a program which representations a DAG in the form of table with the
fields : Label, Address, identifiers, Left Child, & Right Child for a sequence of
Three Address Code. Input the following Three Address Codes and display the
step by step output of the DAG

A=B+C

B=C+D

D=A
PROGRAM:

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class Dag
{
struct node
{
char label[20],id[20],left[20],right[20];
}dagNode[20];

char code[20][20];

public:
void findDag();
char* subString(char[],int,int);
};

{

strcpy(code[0],"A=B+C");
strcpy(code[1],"B=C+D");
strcpy(code[2],"D=A");
}

## void Dag :: addNode(char lbl[])

{
int i;

for(i=0;i<noNode;i++)
{
if(strcmp(dagNode[i].label,lbl) == 0)
goto end;
}
sprintf(dagNode[noNode].label,"%s",lbl);
sprintf(dagNode[noNode].id,"");
sprintf(dagNode[noNode].left,"");
sprintf(dagNode[noNode++].right,"");
end:
}
void Dag :: findDag()
{
int i,j=0;
char *str;
char res[20],op;
char operand1[20],operand2[20];
int eqSpace,opSpace;

noNode=0;
{
strcpy(res,"");
strcpy(operand1,"");
strcpy(operand2,"");
op='n';

str = strchr(code[i],'=');
if(str)
eqSpace=str-code[i];

str = strchr(code[i],'+');
if(str)
{
opSpace=str-code[i];
op='+';
}
else
{
str = strchr(code[i],'-');
if(str)
{
opSpace=str-code[i];
op='-';
}
else
{
str = strchr(code[i],'*');
if(str)
{
opSpace=str-code[i];
op='*';
}
else
{
str = strchr(code[i],'/');
if(str)
{
opSpace=str-code[i];
op='/';
}
else
{
str = strchr(code[i],'%');
if(str)
{
opSpace=str-code[i];
op='%';
}
}
}
}
}

if(op != 'n')
{
strcpy(operand1,subString(code[i],eqSpace+1,opSpace-1));
strcpy(operand2,subString(code[i],opSpace+1,strlen(code[i])-1));
}
else
strcpy(operand1,subString(code[i],eqSpace+1,opSpace-1));
strcpy(res,subString(code[i],0,eqSpace-1));

for(j=0;j<noNode;j++)
{
if(dagNode[j].label[0]==op && strcmp(dagNode[j].left,operand1)==0
&& strcmp(dagNode[j].right,operand2)==0)
{
strcat(dagNode[j].id,",");
strcat(dagNode[j].id,res);
goto next;
}
}

if(op!='n')
{
sprintf(dagNode[noNode].label,"%c",op);
sprintf(dagNode[noNode].id,"%s",res);
sprintf(dagNode[noNode].left,"%s",operand1);
sprintf(dagNode[noNode++].right,"%s",operand2);
}
else
{
for(j=0;j<noNode;j++)
{
if(strstr(dagNode[j].id,operand1) != NULL)
{
strcat(dagNode[j].id,",");
strcat(dagNode[j].id,res);
}
}
}
next:
}

e[i].id,dagNode[i].left,dagNode[i].right);
for(i=0;i<noNode;i++)
printf("\n%s\t%d\t%s\t%s\t%s",dagNode[i].label,&(dagNode[i].label),dagNod
e[i].id,dagNode[i].left,dagNode[i].right);
}

## char* Dag :: subString(char *str, int start, int end)

{
char returnStr[20];
int k,l=0;

for(k=start;k<=end;k++)
{
if(str[k] != ' ')
returnStr[l++] = str[k];
}
returnStr[l] = '\0';
return returnStr;
}

void main()
{
Dag d;
clrscr();
d.findDag();
getch();
}
OUTPUT:

Input Statements
A=B+C
B=C+D
D=A

## Label Addr Id Left Right

+ -2014 A,D B C
B -1934
C -1854
+ -1774 B C D
D -1694
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 7

## Construct Natural Loop

Write a program to create your own data structure to represent a flow – graph.
Write code to construct natural loop from a back edge for the following 5 nodes

Input : -

1->NULL

2->NULL

3->1

4->2

5->4
PROGRAM:

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class Natural
{
int no_node,n,d;
int stack[20],stackMem,loop[20],loopMem;

struct FG
{
int paths;
int endNodes[10];
}flowGraph[20];

public:
void inputFlowGraph();
void printFlowGraph();
void inputBackEdge();
void findNaturalLoop();
void printNaturalLoop();
void insert(int);
};

{
int i;

## cout << "Natural Loop:" << endl;

for(i=0;i<loopMem;i++)
cout << loop[i] << " ";
}

## void Natural :: findNaturalLoop()

{
int m,i,j;

stackMem=0;
loopMem=0;
loop[loopMem++]=d;
insert(n);

while(stackMem != 0)
{
m = stack[--stackMem];
for(i=1;i<=no_node;i++)
for(j=0;j<flowGraph[i].paths;j++)
if(flowGraph[i].endNodes[j] == m)
insert(i);
}
}

## void Natural :: insert(int node)

{
int i;

for(i=0;i<loopMem;i++)
if(loop[i] == node)
goto endFun;

loop[loopMem++]=node;
stack[stackMem++]=node;

endFun:
}

## void Natural :: inputFlowGraph()

{
no_node=10;

flowGraph[1].paths=2;
flowGraph[1].endNodes[0]=2;
flowGraph[1].endNodes[1]=3;

flowGraph[2].paths=1;
flowGraph[2].endNodes[0]=3;

flowGraph[3].paths=1;
flowGraph[3].endNodes[0]=4;

flowGraph[4].paths=3;
flowGraph[4].endNodes[0]=5;
flowGraph[4].endNodes[1]=6;
flowGraph[4].endNodes[2]=3;

flowGraph[5].paths=1;
flowGraph[5].endNodes[0]=7;

flowGraph[6].paths=1;
flowGraph[6].endNodes[0]=7;

flowGraph[7].paths=2;
flowGraph[7].endNodes[0]=8;
flowGraph[7].endNodes[1]=4;
flowGraph[8].paths=3;
flowGraph[8].endNodes[0]=9;
flowGraph[8].endNodes[1]=10;
flowGraph[8].endNodes[2]=3;

flowGraph[9].paths=1;
flowGraph[9].endNodes[0]=1;

flowGraph[10].paths=1;
flowGraph[10].endNodes[0]=7;
}

{
int i,j;

## cout << "Node\tpaths" << endl;

for(i=1;i<=no_node;i++)
{
cout << i << "\t";
for(j=0;j<flowGraph[i].paths;j++)
cout << flowGraph[i].endNodes[j] << " ";
cout << endl;
}
}

## void Natural :: inputBackEdge()

{
cout << "Your back edge is of type n -> d." << endl;
cout << "Enter n:";
cin >> n;
cout << "Enter d:";
cin >> d;
}

void main()
{
Natural n;
clrscr();
n.inputFlowGraph();
n.printFlowGraph();
n.inputBackEdge();
n.findNaturalLoop();
n.printNaturalLoop();
getch();
}
/*void Natural :: inputFlowGraph()
{
int i,j;

## cout << "How many nodes:" << endl;

cin >> no_node;

for(i=0;i<no_node;i++)
{
cout << "For Node " << i+1 << ":" << endl;
cout << "How many paths to other nodes:";
cin >> flowGraph[i].paths;
for(j=0;j<flowGraph[i].paths;j++)
{
cout << "Path " << j+1 << " goes to the node:";
cin >> flowGraph[i].endNodes[j];
}
}
}*/

OUTPUT:

Node paths
1 23
2 3
3 4
4 563
5 7
6 7
7 84
8 9 10 3
9 1
10 7

Enter n:10
Enter d:7

Natural Loop:
7 10 8

## Your back edge is of type n -> d.

Enter n:9
Enter d:1

Natural Loop:
1 9 8 7 5 6 10 4 3 2
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 8

## Live Variable Analysis

Write a program to accept a sequence of variables, the IN set for each block of
the flow graph & determine the Live Variables based on the Live – Variable
Analysis algorithm. Output the OUT set – the variables live on exit from each
block of the flow graph.
PROGRAM:

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class LiveVar
{
int DFN[20],dfn_n,dfst_n;
char mark[20];
char change;

struct dfs
{
int startN,endN;
}DFST[30];

struct FG
{
int paths;
int endNodes[10];
}flowGraph[20];

struct DefUse
{
int no_def,no_use;
char def[20];
char use[20];
}du[20];

struct InOut
{
int no_in,no_out;
char in[20];
char out[20];
}inout[20];

public:
int no_node;
void inputFlowGraph();
void printFlowGraph();
void findDFST();
void printDFST();
void search(int);
void findLiveVar();
char* minus(int);
void sort(char*);
};

## void LiveVar :: sort(char* str)

{
int i,j;
char temp;

for(i=0;i<strlen(str);i++)
for(j=i+1;j<strlen(str);j++)
if(str[i] > str[j])
{
temp = str[i];
str[i] = str[j];
str[j] = temp;
}
}

## char* LiveVar :: minus(int n)

{
char s[20],s1[20],s2[20];
int i,j,k;

strcpy(s,"");
strcat(s,du[n].def);
strcat(s,du[n].use);

for(i=0;i<strlen(s);i++)
for(j=i+1;j<strlen(s);j++)
if(s[i] == s[j] && s[i] != ' ' && s[j]!=' ')
s[j] = ' ';

j=0;
for(i=0;i<=strlen(s);i++)
if(s[i] != ' ')
s1[j++] = s[i];

k=0;
for(i=0;i<strlen(inout[n].out);i++)
{
for(j=0;j<strlen(s1);j++)
if(inout[n].out[i] == s1[j])
goto endLoop;
s2[k++]=inout[n].out[i];
endLoop:
}
s2[k]='\0';

if(strcmp(s2,"")==0)
return s1;
else
return s2;
}

## void LiveVar :: findLiveVar()

{
int i,j,k,l,m;
char *str,*str1;

change='y';
for(i=1;i<=no_node;i++)
{
inout[i].no_in=0;
inout[i].no_out=0;
strcpy(inout[i].in,"");
strcpy(inout[i].out,"");
}
clrscr();
again:
if(change!='n')
{
change='n';
for(i=no_node;i>=1;i--)
{
strcpy(str,"");
for(j=0;j<flowGraph[DFN[i]].paths;j++)
strcat(str,inout[flowGraph[DFN[i]].endNodes[j]].in);

if(strcmp(str,"") != 0)
{
for(k=0;k<strlen(str);k++)
for(l=k+1;l<strlen(str);l++)
if(str[k] == str[l] && str[k] != ' ')
str[l] = ' ';
l=0;
for(k=0;k<=strlen(str);k++)
if(str[k] != ' ')
str1[l++] = str[k];
sort(str1);
strcpy(inout[DFN[i]].out,str1);
}

str =minus(DFN[i]);
sort(str);
if(strcmp(inout[DFN[i]].in,str) != 0)
{
change='y';
strcpy(inout[DFN[i]].in,str);
}
}
goto again;
}
}

{
int i;

## cout << "Depth First Spanning Tree:" << endl;

for(i=0;i<dfst_n;i++)
cout << DFST[i].startN << "->" << DFST[i].endN << endl;
cout << endl;
cout << "Depth First Ordering:" << endl;
for(i=1;i<=no_node;i++)
cout << DFN[i] << " ";

## cout << endl << "\nBlock\t\tDEF\t\tUSE\t\tIn\t\tOut\n";

for(i=1;i<=no_node;i++)
cout << i << "\t\t" << du[i].def << "\t\t" << du[i].use << "\t\t" << inout[i].in
<< "\t\t" << inout[i].out << endl;
}

## void LiveVar :: findDFST()

{
int m,i,j;

dfst_n = 0;
dfn_n = no_node;

for(i=1;i<=no_node;i++)
mark[i] = 'u';

search(1);
}

## void LiveVar :: search(int node)

{
int i;

mark[node] = 'v';

for(i=0;i<flowGraph[node].paths;i++)
if( mark[flowGraph[node].endNodes[i]] == 'u')
{
DFST[dfst_n].startN = node;
DFST[dfst_n++].endN = flowGraph[node].endNodes[i];

search(flowGraph[node].endNodes[i]);
}
DFN[node] = dfn_n;
dfn_n = dfn_n - 1;
}

## void LiveVar :: inputFlowGraph()

{
no_node=6;

flowGraph[1].paths=1;
flowGraph[1].endNodes[0]=2;

flowGraph[2].paths=2;
flowGraph[2].endNodes[0]=3;flowGraph[2].endNodes[1]=4;

flowGraph[3].paths=2;
flowGraph[3].endNodes[0]=4;flowGraph[3].endNodes[1]=5;

flowGraph[4].paths=2;
flowGraph[4].endNodes[0]=2;flowGraph[4].endNodes[1]=6;

flowGraph[5].paths=1;
flowGraph[5].endNodes[0]=3;

flowGraph[6].paths=0;

strcpy(du[1].def,"BC");strcpy(du[1].use,"");
strcpy(du[3].def,"D");strcpy(du[3].use,"CD");
strcpy(du[4].def,"CE");strcpy(du[4].use,"ABC");
strcpy(du[5].def,"DE");strcpy(du[5].use,"BCE");
strcpy(du[6].def,"BC");strcpy(du[6].use,"BCD");
}

{
int i,j;

## cout << "Node\tpaths" << endl;

for(i=1;i<=no_node;i++)
{
cout << i << "\t";
for(j=0;j<flowGraph[i].paths;j++)
cout << flowGraph[i].endNodes[j] << " ";
cout << endl;
}
}

void main()
{
LiveVar l;
clrscr();
l.inputFlowGraph();
l.printFlowGraph();
l.findDFST();
l.findLiveVar();
l.printDFST();
getch();
}

OUTPUT:

1->2
2->3
3->4
4->6
3->5

123546

## Block DEF USE In Out

1 BC E E
3 D CD BE BCDE
4 CE ABC D BCDE
5 DE BCE BCDE BE
6 BC BCD BCD
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 9

## Depth First Spanning Tree

Write a program to create your own data structure to represent a flow – graph.
Using this structure construct a depth - first ordering of the flow graph
recursively. Write a depth first traversal program and invoke it on the example
string

1->3->4->6->7->8->10

## And print the large traversed node in that order.

PROGRAM:

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class LiveVar
{
int no_node;
int DFN[20],dfn_n,dfst_n;
char mark[20];

struct dfs
{
int startN,endN;
}DFST[30];

struct FG
{
int paths;
int endNodes[10];
}flowGraph[20];

public:
void inputFlowGraph();
void printFlowGraph();
void findDFST();
void printDFST();
void search(int);
};

{
int i;

## cout << "Depth First Spanning Tree:" << endl;

for(i=0;i<dfst_n;i++)
cout << DFST[i].startN << "->" << DFST[i].endN << endl;
cout << endl;
cout << "Depth First Ordering:" << endl;
for(i=1;i<=no_node;i++)
cout << DFN[i] << " ";
}

## void LiveVar :: findDFST()

{
int m,i,j;

dfst_n = 0;
dfn_n = no_node;

for(i=1;i<=no_node;i++)
mark[i] = 'u';

search(1);
}

## void LiveVar :: search(int node)

{
int i;

mark[node] = 'v';

for(i=0;i<flowGraph[node].paths;i++)
if( mark[flowGraph[node].endNodes[i]] == 'u')
{
DFST[dfst_n].startN = node;
DFST[dfst_n++].endN = flowGraph[node].endNodes[i];

search(flowGraph[node].endNodes[i]);
}

DFN[node] = dfn_n;
dfn_n = dfn_n - 1;
}

## void LiveVar :: inputFlowGraph()

{
no_node=10;

flowGraph[1].paths=2;
flowGraph[1].endNodes[0]=2;
flowGraph[1].endNodes[1]=3;

flowGraph[2].paths=1;
flowGraph[2].endNodes[0]=3;

flowGraph[3].paths=1;
flowGraph[3].endNodes[0]=4;

flowGraph[4].paths=3;
flowGraph[4].endNodes[0]=5;
flowGraph[4].endNodes[1]=6;
flowGraph[4].endNodes[2]=3;

flowGraph[5].paths=1;
flowGraph[5].endNodes[0]=7;

flowGraph[6].paths=1;
flowGraph[6].endNodes[0]=7;

flowGraph[7].paths=2;
flowGraph[7].endNodes[0]=8;
flowGraph[7].endNodes[1]=4;

flowGraph[8].paths=3;
flowGraph[8].endNodes[0]=9;
flowGraph[8].endNodes[1]=10;
flowGraph[8].endNodes[2]=3;

flowGraph[9].paths=1;
flowGraph[9].endNodes[0]=1;

flowGraph[10].paths=1;
flowGraph[10].endNodes[0]=7;
}

{
int i,j;

## cout << "Node\tpaths" << endl;

for(i=1;i<=no_node;i++)
{
cout << i << "\t";
for(j=0;j<flowGraph[i].paths;j++)
cout << flowGraph[i].endNodes[j] << " ";
cout << endl;
}
}

void main()
{
LiveVar l;
clrscr();
l.inputFlowGraph();
l.printFlowGraph();
l.findDFST();
l.printDFST();
getch();
}

{
int i,j;

## cout << "How many nodes:" << endl;

cin >> no_node;

for(i=0;i<no_node;i++)
{
cout << "For Node " << i+1 << ":" << endl;
cout << "How many paths to other nodes:";
cin >> flowGraph[i].paths;
for(j=0;j<flowGraph[i].paths;j++)
{
cout << "Path " << j+1 << " goes to the node:";
cin >> flowGraph[i].endNodes[j];
}
}
}*/

OUTPUT:

Node paths
1 23
2 3
3 4
4 563
5 7
6 7
7 84
8 9 10 3
9 1
10 7

1->2
2->3
3->4
4->5
5->7
7->8
8->9
8->10
4->6

## Depth First Ordering:

1 2 3 4 6 5 7 8 10 9
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-II)

PRACTICAL 10

Generate the assembly code for the intermediate representation obtains in the
triple.

## Suppose the expression (a+b)*(c+d)

Triple is :
OP ARG1 ARG2
0 + a B
1 + c D
2 * (0) (1)
Then it’s assembly code is
MOV R0 a
MOV R1 c
MOV R2 R0
MUL R2 R1
PROGRAM:

// Assembler
#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class Grammer
{
struct qdrplr
{
char op;
char A1;
char A2;
int R;

struct tripl
{
char op;
char A1;
char A2;
} triple[10];

struct assembly
{
char opr[10];
char A1[10];
char A2[10];
}assm[20];

int no_qdrpl;
int result;
int reg_count,reg;

public:
char *inputString;
int res;
char operators[20];
int no_op;
char variables[20];
int no_var;
Grammer(void);
int findOpenBrace(char*,int);
int findCloseBrace(char*,int);
char* subString(char*,int,int);
void findAssm(void);
};

## void Grammer :: findAssm(void)

{
int i;

for(i=0;i<no_qdrpl;i++)
{
if(!(triple[i].A1 >= '0' && triple[i].A1 <= '9') && !(triple[i].A2 >= '0' &&
triple[i].A2 <= '9'))
{
sprintf(assm[reg_count].opr,"MOV");
sprintf(assm[reg_count].A1,"R%d",reg++);
sprintf(assm[reg_count++].A2,"%c",triple[i].A1);
}

if(triple[i].op=='+')
if(triple[i].op=='-')
sprintf(assm[reg_count].opr,"SUB");
if(triple[i].op=='*')
sprintf(assm[reg_count].opr,"MUL");
if(triple[i].op=='/')
sprintf(assm[reg_count].opr,"DIV");

## if(!(triple[i].A2 >= '0' && triple[i].A2 <= '9'))

{
sprintf(assm[reg_count].A1,"R%d",reg-1);
sprintf(assm[reg_count].A2,"%c",triple[i].A2);
}
else
{
if(!(triple[i].A1 >= '0' && triple[i].A1 <= '9'))
{
sprintf(assm[reg_count].A1,"R%d",reg-1);
sprintf(assm[reg_count].A2,"%c",triple[i].A1);
}
else
{
sprintf(assm[reg_count].A1,"R%c",triple[i].A1);
sprintf(assm[reg_count].A2,"R%c",triple[i].A2);
}
}
reg_count++;
}
}
{
int i;
cout << endl << "Quadraple Table" << endl;
cout << "\tOP\tA1\tA2\tR" << endl;

for(i=0;i<no_qdrpl;i++)
{
cout << "E" << i << "\t" << quadraple[i].op << "\t" << quadraple[i].A1 << "\t"
}

## cout << endl << "Triple Table" << endl;

cout << "\tOP\tA1\tA2" << endl;

for(i=0;i<no_qdrpl;i++)
{
cout << i << "\t" << triple[i].op << "\t" << triple[i].A1 << "\t" << triple[i].A2
<< endl;
}

## cout << endl << "Assembly Code" << endl;

for(i=0;i<reg_count;i++)
{
cout << "\t" << assm[i].opr << "\t" << assm[i].A1 << "\t" << assm[i].A2 <<
endl;
}

## char* Grammer :: subString(char *str, int start, int end)

{
char* returnStr;
int k,l=0;

for(k=start;k<=end;k++)
returnStr[l++] = str[k];
returnStr[l] = '\0';
return returnStr;
}

{
int posOpenBrace,posCloseBrace,startExpr,endExpr;
int i,k,l;
char *subStr;

while(strlen(inputString) > 1)
{
startExpr=0;
endExpr=strlen(inputString);
posOpenBrace = findOpenBrace(inputString,0);
if(posOpenBrace != -1)
posCloseBrace = findCloseBrace(inputString,posOpenBrace);

## if(posOpenBrace == -1) // no any bracket in string

{
for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='*' || inputString[k]=='/' ||
inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=0;k<strlen(inputString);k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
}
}
}

## if(posCloseBrace == posOpenBrace+4) // omly one expr in brackets

{
startExpr=posOpenBrace;
endExpr=posCloseBrace;
}

## if(posOpenBrace != -1) // no any bracket in string

{
for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='*' || inputString[k]=='/' ||
inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
}
}

for(k=posOpenBrace;k<posCloseBrace;k++)
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
}
}
}

## if( inputString[startExpr]=='(' && inputString[endExpr]==')' ) // only one expr

in brackets
{
for(k=0;k<no_qdrpl;k++)
{
(int)inputString[startExpr+3])
{
res=k+2;
goto processStr;
//cout << endl << "true";
}
}

## if(inputString[startExpr+1] >= '0' && inputString[startExpr+1] <= '9')

triple[no_qdrpl].A1 = inputString[startExpr+1]-1;
else
triple[no_qdrpl].A1 = inputString[startExpr+1];

triple[no_qdrpl].op = inputString[startExpr+2];

## if(inputString[startExpr+3] >= '0' && inputString[startExpr+3] <= '9')

triple[no_qdrpl].A2 = inputString[startExpr+3]-1;
else
triple[no_qdrpl].A2 = inputString[startExpr+3];

res=result;
no_qdrpl++;
}
else
{
for(k=0;k<no_qdrpl;k++)
{
(int)inputString[startExpr+2])
{
res=k+2;
goto processStr;
}
}

## if(inputString[startExpr] >= '0' && inputString[startExpr] <= '9')

triple[no_qdrpl].A1 = inputString[startExpr]-1;
else
triple[no_qdrpl].A1 = inputString[startExpr];

triple[no_qdrpl].op = inputString[startExpr+1];

## if(inputString[startExpr+2] >= '0' && inputString[startExpr+2] <= '9')

triple[no_qdrpl].A2 = inputString[startExpr+2]-1;
else
triple[no_qdrpl].A2 = inputString[startExpr+2];

res=result;
no_qdrpl++;
}

processStr:
strcpy(subStr,"");
l=0;
k=0;
while(inputString[k] != '\0')
{
if(startExpr == k)
{
subStr[l] = 48+res-1;
k = endExpr+1;
}
else
{
subStr[l] = inputString[k];
k++;
}
l++;
}
subStr[l] = '\0';
strcpy(inputString,subStr);
}
}

## int Grammer :: findOpenBrace(char *str,int startPos)

{
int k,currentPos=-1;

for(k=startPos;k<strlen(str);k++)
{
if(str[k] == '(')
currentPos=k;
if(str[k] == ')')
break;
}

return currentPos;
}

## int Grammer :: findCloseBrace(char *str,int startPos)

{
int k;

for(k=startPos;k<strlen(str);k++)
if(str[k] == ')')
return k;
return -1;
}

Grammer :: Grammer(void)
{
int i,j;
clrscr();

no_op=0;
no_var=0;
no_qdrpl=0;
reg_count=0;
reg=0;
result=1;
cout << "Enter the String:";
gets(inputString);
//inputString="(a+b)*(c+d)";

for(i=0;i<strlen(inputString);i++)
{
if(inputString[i] != ' ')
{
if( ((int)inputString[i] >= 65 && (int)inputString[i] <= 90) ||
((int)inputString[i] >= 97 && (int)inputString[i] <= 122) )
{
for(j=0;j<no_var;j++)
if(inputString[i] == variables[j])
goto nextVar;
variables[no_var++] = inputString[i];
nextVar:
}
else
if(inputString[i] == '+' || inputString[i] == '-' || inputString[i] ==
'*' || inputString[i] == '/' || inputString[i] == '%' || inputString[i] == '(' || inputString[i] == ')')
{
if(inputString[i] != '(' && inputString[i] != ')')
{
for(j=0;j<no_op;j++)
if(inputString[i] == operators[j])
goto nextOp;
operators[no_op++] = inputString[i];
nextOp:
}
}
else
{
cout << endl << inputString[i] << " is encoutered in the
string as invalid character, Thus the string is invalid.";
getch();
exit(0);
}
}
}

## cout << endl << "Variables are as Follows:" << endl;

for(i=0;i<no_var;i++)
cout << variables[i] << " ";

## cout << endl << "Operators are as Follows:" << endl;

for(i=0;i<no_op;i++)
cout << operators[i] << " ";
}

int main(void)
{
Grammer g;
//int result;
//G1.PrintGrammer();
//dg.FindFirstFollow();
g.findAssm();
cout << endl;
getch();
return 0;
}

OUTPUT:

Enter String:a*b+c*d

## Variables are as Follows:

abcd
Operators are as Follows:
*+

OP A1 A2 R
E0 * a b 1
E1 * c d 2
E2 + 1 2 3

Triple Table
OP A1 A2
0 * a b
1 * c d
2 + 0 1

Assembly Code
MOV R0 a
MUL R0 b
MOV R1 c
MUL R1 d
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 11

## Postfix to Infix Conversion

Write a program to obtain an operation in postfix form and convert it to infix
form using a suitable algorithm

Postfix expression : a b c * +

Infix form : a + b * c
PROGRAM:

#include<stdio.h>

## void pop (char*);

void push(char*);

char stack[MAX][MAX];
int top = -1;

void main()
{
char s[MAX], str1[MAX], str2[MAX], str[MAX];
char s1[2],temp[2];
int i=0;
clrscr( ) ;

## printf("\Enter the postfix expression: ");

gets(s);

while (s[i]!='\0')
{
/*skip whitespace, if any*/
if(s[i] == ' ')
i++;

if (s[i] == '%' || s[i] == '*'|| s[i] == '-' || s[i] == '+' || s[i] == '/')
{
pop(str1);
pop(str2);

temp[0] ='(';
temp[1] ='\0';

strcpy(str, temp);
strcat(str, str2);

temp[0] = s[i];

temp[1] = '\0';

strcat(str,temp);

strcat(str, str1);

temp[0] =')';
temp[1] ='\0';

strcat(str,temp);

push(str);
}
else
{
temp[0]=s[i];

temp[1]='\0';

strcpy(s1, temp);

push(s1);

}
i++;
}
printf("\n%s", stack[0]);
}

## void pop(char *a1)

{
strcpy(a1,stack[top]);
top--;
}

## void push (char*str)

{
if(top == MAX - 1)
printf("\nstack is full");
else
{
top++;
strcpy(stack[top], str);
}
}
OUTPUT:

((a+b)*c)

(a+(b*c))

((a+b)*(c+d))

## Enter infix expression: ab-cd+e-f*+

((a-b)+((c+d)-e)*f)
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

PRACTICAL 12

## Write a program to obtain an operation in infix form and convert it to postfix

form using a suitable algorithm

Infix expression: a + b * c

Postfix form : a b c * +
PROGRAM:

#include<stdio.h>
#include<stdlib.h>

#define MAXCOLS 80
#define TRUE 1
#define FALSE 0

void postfix(char*,char*);
int isoperand(char);
void popandtest(struct stack*,char*,int*);
int prcd(char,char);
void push(struct stack*,char);
char pop(struct stack*);

struct stack
{
int top;
char items[MAXCOLS];
};

void main()
{
char infix[MAXCOLS];
char postr[MAXCOLS];
int pos=0;

clrscr();
printf("Enter infix expression:");
while((infix[pos++] = getchar()) != '\n');
infix[--pos]='\0';
postfix(infix,postr);
printf("%s\n",postr);
getch();
}

## void postfix(char *infix,char *postr)

{
int position,und;
int outpos=0;
char topsymb='+';
char symb;
struct stack opstk;
opstk.top=-1;

for(position=0;(symb=infix[position])!='\0';position++)
{
if(!isoperand(symb))
postr[outpos++] = symb;
else
{
popandtest(&opstk,&topsymb,&und);
while(!und && prcd(topsymb,symb))
{
postr[outpos++] = topsymb;
popandtest(&opstk,&topsymb,&und);
}

if(!und)
push(&opstk,topsymb);

if(und || symb!=')')
push(&opstk,symb);
else
topsymb = pop(&opstk);
}
}

while(!empty(&opstk))
postr[outpos++] = pop(&opstk);
postr[outpos] = '\0';
}

## int isoperand(char symb)

{
return (symb=='(' || symb==')' || symb=='*' || symb=='/' || symb=='+' || symb=='-' ||
symb=='%');
}

## void popandtest(struct stack *ps,char *px,int *pund)

{
if(empty(ps))
{
*pund=TRUE;
return;
}
*pund = FALSE;
*px = ps->items[ps->top--];
return;
}

## int prcd(char s1,char s2)

{
if((s1=='*' || s1=='/' || s1=='%') && (s2=='+' || s2=='-'))
return TRUE;

## if((s1=='+'|| s1=='-') && (s2=='*' || s2=='/' || s2=='%'))

return FALSE;
if( s1=='(' && (s2=='*' || s2=='/' || s2=='+' || s2=='-' || s2=='%' || s2==')') )
return FALSE;

if( (s1=='(' || s1=='*' || s1=='/' || s1=='+' || s1=='-' || s1=='%') && s1!=')' && s2=='(')
return FALSE;

if( (s1==')' || s1=='*' || s1=='/' || s1=='+' || s1=='-' || s1=='%') && s1!='(' && s2==')')
return TRUE;
}

## void push(struct stack* ps,char x)

{
ps->items[++(ps->top)] = x;
return;
}

## char pop(struct stack *ps)

{
if(empty(ps))
{
printf("%","stack underflow");
exit(1);
}
return(ps->items[ps->top--]);
}

## int empty(struct stack *ps)

{
if(ps->top == -1)
return TRUE;
else
return FALSE;
}
OUTPUT:

ab+c*

abc*+

ab+cd+*

## Enter infix expression:((a-b)+((c+d)-e)*f)

ab-cd+e-f*+
Roll No. – 22

Deccan Education Society’s
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07

## Compiler Construction (Section-II)

PRACTICAL 13

Input a file. Search for the token viz. variable, operator symbols, & constants &
maintain the list of such tokens separately under separate classes.

Consider, read the file contain the addition of two numbers program then write
a program to identify the variable, constant & operator in your program &
display this variable, constant & operator on console.
Main()
{
int a,c;
c=a+100;
printf(“Sum=%d”);
}
Then the o/p is :
Variable => a, c
Constants => 100
Operator => +, =
PROGRAM:

#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

class Grammer
{
public:
Grammer(void);
char *str;
char words[30][30];
int wordLen[100];
int noOfWords;
void findWords(void);
char vars[50];
char operators[50];
int constants[50];
int no_vars,no_op,no_const;
};

Grammer :: Grammer(void)
{
FILE* f1;
char c;
char *tmp;
int i=0,j,wordFound=0,k;
no_vars=0;
no_op=0;
no_const=0;
int tmpNum=0;

clrscr();
f1 = fopen("d:\\msc\\compiler\\try.txt","r");

while((c=getc(f1)) != EOF)
str[i++] = c;
str[i]='\0';

noOfWords=0;
j=0;
i=strlen(str);
for(i=0;i<strlen(str);i++)
{
if(str[i]==' ' || str[i]==';' || str[i]=='\n' || str[i]=='\t' || str[i]==',' || str[i]=='{' || str[i]=='}')
{
if(wordFound==1)
{
wordLen[noOfWords]=j;
noOfWords++;
j=0;
wordFound=0;
}
}
else
{
words[noOfWords][j++]=str[i];
if(str[i]=='+' || str[i]=='-' || str[i]=='*' || str[i]=='/' || str[i]=='%' || str[i]=='=')
{
wordLen[noOfWords]=j;
noOfWords++;
j=0;
wordFound=0;
}
else
wordFound=1;
}
}

for(i=0;i<noOfWords;i++)
{
if(strcmp(words[i],"int")==0)
{
cout << endl;
wordLen[i]=0;
words[i][0]='\0';
goto nextWord;
}
for(j=0;j<wordLen[i];j++)
{
if(words[i][j]=='(' || words[i][j]==')' || words[i][j]=='"')
{
wordLen[i]=0;
words[i][0]='\0';
goto nextWord;
}
}

for(j=0;j<wordLen[i];j++)
{
if(!((int)words[i][j]>=48 && (int)words[i][j]<=57))
{
goto nextWord;
}
}
constants[no_const++]=atoi(words[i]);
wordLen[i]=0;
words[i][0]='\0';
nextWord:
}

for(i=0;i<noOfWords;i++)

{
for(j=0;j<wordLen[i];j++)
{
if(words[i][j]=='+' || words[i][j]=='-' || words[i][j]=='*' || words[i][j]=='/' ||
words[i][j]=='=' || words[i][j]=='%')
{
for(k=0;k<no_op;k++)
if(operators[k]==words[i][j])
goto nextVar;
operators[no_op++]=words[i][j];
nextVar:
}
else
{
for(k=0;k<no_vars;k++)
if(vars[k]==words[i][j])
goto nextOp;
vars[no_vars++]=words[i][j];
nextOp:
}
}
}

## cout << "Variables:" << endl;

for(i=0;i<no_vars;i++)
cout << vars[i] << ",";

## cout << endl << "Operators:" << endl;

for(i=0;i<no_op;i++)
cout << operators[i] << ",";

## cout << endl << "Constants:" << endl;

for(i=0;i<no_const;i++)
cout << constants[i] << ",";
}

void main()
{
Grammer g;
getch();
}
FILE INPUT:

Try.txt

main()
{
int a,c;
c=a+100;
printf("%d",c);
}

OUTPUT:

Variables:
a,c

Operators:
=,+

Constants:
100