Compiler 22

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
Kirti College of Arts, Science and Commerce.
[ NAAC Accredited : “A Grade”]
CERTIFICATE
This is to certify that Mr./Miss_________________ of M.Sc Part-I [COMPUTER
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.
Lecturer-in-charge Head of Department

( Mrs.Akshata Nayak) Dept of Com.Sc and I.T
(Dr. Seema Purohit)
NAAC Accreditation “A” Grade
Kirti M. Doongursee College, Dadar, Mumbai-28
Dept. of Computer Science & I.T.
M.Sc. (Part-I) 2006 – 07
Compiler Construction ( Section-I )
INDEX
No. Title Page No. Date Sign
1 Parsing using DFA
2 NFA to DFA
3 Removal of Empty State( λ / є )
4 Removal of Left Recursion
5 LL(1) Parsing Table
6 Warshall’s Algorithm
7 LR(0) Parsing
8 Right & Left Linear Grammars
9 Minimize the Automata
10 Simple Precedence Matrix (SPM)
11 Parsing using SPM
12 Linearizing a given SPM

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

M.Sc. (Part-I) 2006 – 07
Compiler Construction (Section-I)

PRACTICAL 1
Write a program for acceptance of a string using DFA
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:
No. of states in DFA are:3
No. of final states in DFA are:1
Enter state number(s) of final states(s):2
No. of characters you are using in DFA are:2
Enter those characters one by one:

ab
Describe your DFA
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
1) Enter the string to be tested: aab

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

Error!!!
Invalid string
Roll No. – 22

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 - - -
Write the program to convert the given NFA into DFA

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;
N->E_Closure( N->start_state ); // î-CLOSURE ( q0 ) is in Closure
// Build The First DFA state

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 )
cout << "Not Found\n";
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];
ctr = j; // no of states in arrayY
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 DFA :: CheckPrev( int array[30], int no )

{
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
No Of Output States For Input a= 0
No Of Output States For Input b= 0
For State 1
For State 2
For State 3
For State 4
For State 5
For State 6
For State 7
For State 8
For State 9
For State 10
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

M.Sc. (Part-I) 2006 – 07

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>
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 Add_To_E_Closure(int state);
void Calculate_E_Closure(int state,NFA n);
void Disp_E_Closure(int state);
};
void state::Add_To_E_Closure(int stat)

{
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();
Add_To_E_Closure(temp);
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 2 on e :: -1
form state 2 on a :: 3 -1
form state 3 on e :: 6 -1
form state 4 on b :: 5 -1
form state 5 on e :: 6 -1
form state 0 on e ::1 7

form state 0 on a ::-1
form state 0 on b ::-1
form state 2 on e ::-1
form state 2 on a ::3 -1
form state 3 on e ::6
form state 4 on b ::5
form state 5 on e ::6
enter the satte for e.closure(-1 for exit)::0

07142

142

2

367142

4

567142

67142

7
Roll No. – 22

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<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];
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][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

M.Sc. (Part-I) 2006 – 07

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<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 , "î");
strcpy( StartSymbol , "E");

}
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;
}
cout<<"\n\t\t\tFollow of all Non Terminal"<<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, " " );
}
return( 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 );
}
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 )
);
}
else
{
FindPos = strcmpstr( T_in_Follow, FIRST[j].Terminals[l] );
if( FindPos == -1 )
{
strcat( T_in_Follow,
FIRST[j].Terminals[l] );
}
}
}
}// if
else
{
if( strcmp( Prods[i].Symbol, "á" ) == 0 )
{
strcat( T_in_Follow,
FindFollow( PROD[ Prods[i].ProdLoc ].lhs ) );
}
}
}//else
}//for
return( T_in_Follow );
}
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

M.Sc. (Part-I) 2006 – 07

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;
}
}
}
}
cout<<"\n\n\nMatrix after applying WARSHALL'S

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";
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";
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

M.Sc. (Part-I) 2006 – 07

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>
unsigned char prod[10][10]=

{"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 Added(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;
clno=Added(i-1);
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;
}
if(Added(i-1) != -1)
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 Added(int n)
{
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

M.Sc. (Part-I) 2006 – 07

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<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:
*********** RIGHT Linear Grammar **********

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

M.Sc. (Part-I) 2006 – 07

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<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

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("\n\n");
for(i=0;i<=6;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("\n\n");
for(i=0;i<=6;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("\n\n");
for(i=0;i<=6;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("\n\n");
for(i=0;i<7;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("\n\n");
for(i=0;i<7;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

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<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 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);
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].rhs , "^");

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";
{
cout << endl << symb[i];
for(j=0;j<no_symb;j++)
cout << "\t" << spm[i][j];
}
}
void SPM :: 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 SPM :: PrintGrammer(void)

{

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

{
cout<<"\nProduction No "<<i+1<<" "<<prod[i].lhs<<"->" ;
cout<<prod[i].rhs;
}
getch();
}
int SPM :: getSymbPos(char symbol)

{
int 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";
{
cout << "Symbol" << i+1 << ":";
cin >> symb[i];
}
symb[no_symb]='\0';
cout << endl;

cout << "\t" << symb[i];
cout << endl;
{
cout << symb[i];
{
//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
Stack Opr Input12

$ < (a,a)$
$( < a,a)$
$(a < ,a)$
$(S > ,a)$

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

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<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;
{
maxpath=0;
findNextPath(i,0,0,'F');
FGPath[0][i]=maxpath;
}
{
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')
{
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
{
if(spm[i][g]=='<')
{
//path=path+1;
findNextPath(i,g,path+1,'F');
}
if(i==no_symb)
if(path > maxpath)
{
maxpath = path;
return 0;
}
}
}
void SPM :: printFG()

{
int i,j;
cout << endl << endl;

cout << endl << "f";

cout << "\t" << FGPath[0][i];
cout << endl << "g";

cout << "\t" << FGPath[1][i];
}
void SPM :: inputSPM()

{
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";
{
cout << "Symbol" << i+1 << ":";
cin >> symb[i];
}
symb[no_symb]='\0';
cout << endl;

cout << endl;
{
cout << symb[i];
{
//cout << "\t";
cin >> spm[i][j];
}
}*/
}
void SPM :: printSPM()

{
int i,j;
cout << endl << "\t";

cout << symb[i] << "\t";
{
cout << endl << symb[i];
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

M.Sc. (Part-I) 2006 – 07
PRACTICAL 13
Parsing using Simple Precedence Functions
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<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 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);
FGTable(void);
void PrintGrammer(void);
void copyInput();
void printParseTable();
};
void FGTable :: 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<<"\nNT"<<i+1<<" "<<NT[i];
cout<<"\nT"<<i+1<<" : "<< T[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;
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;
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];
}
}
}
void FGTable :: printFG()

{
int i,j;

cout << endl << "f";

cout << "\t" << FPath[i];
cout << endl << "g";

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

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<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 string to be parsed:#T*(E+T)#
Enter the exclusive symbol :T
Handle:E+T
P:#T*(E)#
Handle:(E)
P:#T*F#
Handle:T*F
P:#T#
String is parsableT
M.Sc. (Part-I) 2006 – 07
Compiler Construction ( Section–II )
INDEX
No
Title Page No. Date Sign
.
1 Three Address Code
2 Quadruple Representation
3 Triple Representation
4 Optimize the Quadruples
5 Indirect Triple Representation
6 DAG
7 Construct Natural Loop
8 Live Variable Analysis
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

M.Sc. (Part-I) 2006 – 07
Compiler Construction (Section-II)
PRACTICAL 1
Three – Address Code
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:
// Quadraples and Triples

#include<stdio.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;
} quadraple[10];
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);
void findQuadra();
int findOpenBrace(char*,int);
int findCloseBrace(char*,int);
char* subString(char*,int,int);
void printQuadra(void);
};
void Grammer :: printQuadra(void)

{
int i;
cout << endl << "Three Address Code:" << endl;
for(i=0;i<no_qdrpl;i++)
{
if(quadraple[i].op != '=')
cout << "T" << quadraple[i].R << " = ";
if(quadraple[i].A1 >= '0' && quadraple[i].A1 <= '9')

cout << "T" << quadraple[i].A1 << " ";
else
cout << quadraple[i].A1 << " ";
cout << quadraple[i].op << " ";
if(quadraple[i].A2 >= '0' && quadraple[i].A2 <= '9')

cout << "T" << quadraple[i].A2 << " ";
else
cout << quadraple[i].A2 << " ";
cout << 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;
}
void Grammer :: findQuadra()

{
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 getQuadra;
}
}
{
if(inputString[k]=='+' || inputString[k]=='-')
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
if(inputString[k]=='=')
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
}
if(posCloseBrace == posOpenBrace+4) // omly one expr in brackets

{
startExpr=posOpenBrace;
endExpr=posCloseBrace;
goto getQuadra;
}
if(posOpenBrace != -1) // no any bracket in string

{
for(k=posOpenBrace;k<posCloseBrace;k++)
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
}
getQuadra:
if( inputString[startExpr]=='(' && inputString[endExpr]==')' ) // only one expr

in brackets
{
quadraple[no_qdrpl].A1 = inputString[startExpr+1];
quadraple[no_qdrpl].op = inputString[startExpr+2];
quadraple[no_qdrpl].R = result++;
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];

else
no_qdrpl++;
}
else
{
quadraple[no_qdrpl].A1 = inputString[startExpr];
if(inputString[startExpr] >= '0' && inputString[startExpr] <= '9')

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

else
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;
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;
{
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.findQuadra();
cout << endl;
g.printQuadra();
getch();
return 0;
}
OUTPUT:
Enter the String:a*b*(c*d)
Variables are as Follows:

abcd
Operators are as Follows:
*
Three Address Code:

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

M.Sc. (Part-I) 2006 – 07
PRACTICAL 2 & 3
Obtain the Intermediate Representation of the given arithmetic expression in the

Matrix form
a. Quadruple representation of three address statements.
b. Triple representation of three address statements.
Consider the expression : (a+b)*(c+d)

Then it’s Intermediate Representation is,
Quadruple :
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:
// Quadraples and Triples

#include<stdio.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;
} quadraple[10];
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);
void findQuadra();
};

{
int i;
cout << endl << "Quadraple Table" << endl;
cout << "\tOP\tA1\tA2\tR" << endl;
{
cout << "E" << i << "\t" << quadraple[i].op << "\t" << quadraple[i].A1 << "\t"
<< quadraple[i].A2 << "\t" << quadraple[i].R << endl;
}
cout << endl << "Triple Table" << endl;

cout << "\tOP\tA1\tA2" << endl;
{
cout << i << "\t" << triple[i].op << "\t" << triple[i].A1 << "\t" << triple[i].A2
<< endl;
}
}

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

{
int i,k,l;
char *subStr;
{
startExpr=0;

{
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
}

{
goto getQuadra;
}

{
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
}
getQuadra:

in brackets
{

else

else
no_qdrpl++;
}
else
{

else

else
no_qdrpl++;
}
strcpy(subStr,"");
l=0;
k=0;
{
if(startExpr == k)
{
k = endExpr+1;
}
else
{
k++;
}
l++;
}
subStr[l] = '\0';
}
}

{
{
if(str[k] == '(')
currentPos=k;
if(str[k] == ')')
break;
}
return currentPos;
}

{
int k;
if(str[k] == ')')
return k;
return -1;
}
{
int i,j;
clrscr();
no_op=0;
no_var=0;
no_qdrpl=0;
result=1;
gets(inputString);
{
{
{
goto nextVar;
nextVar:
}
else
{
{
goto nextOp;
nextOp:
}
}
else
{
getch();
exit(0);
}
}
}


}
int main(void)
{
Grammer g;
//int result;
g.findQuadra();
cout << endl;
g.printQuadra();
getch();
return 0;
}
OUTPUT:
Enter the String:a=b*(c+d)

abcd
=*+
Quadraple Table
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

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.
Consider the expression (a+b)*(a+b)

Then it’s quadruple’s :
Op Arg1 Arg2 Result

0 + a b T1
1 + a b T2
2 * T1 T2 T3
Then it’s optimized quadruple’s
Op Arg1 Arg2 Result

0 + a b T1
1 * T1 T1 T2
PROGRAM:
// Optimization
#include<stdio.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;
} quadraple[10];
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);
void findQuadra();
};

{
int i;
{
cout << "E" << i << "\t" << quadraple[i].op << "\t" << quadraple[i].A1 << "\t" <<
quadraple[i].A2 << "\t" << quadraple[i].R << endl;
}

{
cout << i << "\t" << triple[i].op << "\t" << triple[i].A1 << "\t" << triple[i].A2 <<
endl;
}
}

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

{
int i,k,l;
char *subStr;
{
startExpr=0;

{
{
if(inputString[k]=='*' || inputString[k]=='/' || inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
}

{
goto getQuadra;
}

{
{
if(inputString[k]=='*' || inputString[k]=='/' || inputString[k]=='%')
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
}
getQuadra:
if( inputString[startExpr]=='(' && inputString[endExpr]==')' ) // only one expr in
brackets
{
for(k=0;k<no_qdrpl;k++)
{
if( (int)quadraple[k].A1 == (int)inputString[startExpr+1] &&
(int)quadraple[k].op == (int)inputString[startExpr+2] &&
(int)quadraple[k].A2 == (int)inputString[startExpr+3])
{
res=k+2;
goto processStr;
}
}

else

else
res=result;
no_qdrpl++;
}
else
{
{
if( (int)quadraple[k].A1 == (int)inputString[startExpr] &&
(int)quadraple[k].op == (int)inputString[startExpr+1] &&
(int)quadraple[k].A2 == (int)inputString[startExpr+2])
{
res=k+2;
goto processStr;
}
}

else

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

{
{
if(str[k] == '(')
currentPos=k;
if(str[k] == ')')
break;
}
return currentPos;
}

{
int k;
if(str[k] == ')')
return k;
return -1;
}
{
int i,j;
clrscr();
no_op=0;
no_var=0;
no_qdrpl=0;
result=1;
gets(inputString);
{
{
{
goto nextVar;
nextVar:
}
else
if(inputString[i] == '+' || inputString[i] == '-' || inputString[i] == '*' ||
inputString[i] == '/' || inputString[i] == '%' || inputString[i] == '(' ||
inputString[i] == ')')
{
{
goto nextOp;
nextOp:
}
}
else
{
cout << endl << inputString[i] << " is encoutered in the string as
invalid character, Thus the string is invalid.";
getch();
exit(0);
}
}
}


}
int main(void)
{
Grammer g;
g.findQuadra();
cout << endl;
g.printQuadra();
getch();
return 0;
}
OUTPUT:
Enter the String:(a+b)*(c+d)-(a+b+c)

abcd

+*-
Quadraple Table
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

M.Sc. (Part-I) 2006 – 07
PRACTICAL 5
Indirect Triple Representation
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<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();
void printTriple(void);
};
void Grammer :: printTriple(void)

{
int i,j;
for(i=0;i<no_triple;i++)
statement[i] = i;
cout << "\tstatement" << endl;

cout << i << "\t" << (int)&statement[i] << endl;

{
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 i,k,l;
char *subStr;
{
startExpr=0;

{
{
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}
}
if(posCloseBrace == posOpenBrace+4) // only one expr in brackets

{
goto getTriple;
}
if(posOpenBrace != -1) // many expr in bracket

{
{
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getTriple;
}
}
{
{
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];
no_triple++;
result++;
}
else
{
triple[no_triple].A1 = inputString[startExpr];
triple[no_triple].op = inputString[startExpr+1];
no_triple++;
result++;
}
strcpy(subStr,"");
l=0;
k=0;
{
if(startExpr == k)
{
k = endExpr+1;
}
else
{
k++;
}
l++;
}
subStr[l] = '\0';
}
}

{
{
if(str[k] == '(')
currentPos=k;
if(str[k] == ')')
break;
}
return currentPos;
}

{
int k;
if(str[k] == ')')
return k;
return -1;
}
{
int i,j;
clrscr();
no_op=0;
no_var=0;
no_triple=0;
result=0;
gets(inputString);
{
{
{
goto nextVar;
nextVar:
}
else
{
{
goto nextOp;
nextOp:
}
}
else
{
getch();
exit(0);
}
}
}


}
int main(void)
{
Grammer g;
//int result;
g.findTriple();
cout << endl;
g.printTriple();
getch();
return 0;
}
OUTPUT:
Enter the String:a=b*(c+d)

abcd
=*+
Triple Table
statement
0 -96
1 -94
2 -92
OP A1 A2
-96 + c d
-94 * b -96
-92 = a -94
Roll No. – 22

M.Sc. (Part-I) 2006 – 07
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<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];
int noThreeAddCode,noNode;
char code[20][20];
public:
void inputThreeAddCode();
void findDag();
char* subString(char[],int,int);
void addNode(char[]);
};
void Dag :: inputThreeAddCode()

{
noThreeAddCode=3;
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;
for(i=0;i<noThreeAddCode;i++)
{
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)
{
op='-';
}
else
{
str = strchr(code[i],'*');
if(str)
{
op='*';
}
else
{
str = strchr(code[i],'/');
if(str)
{
op='/';
}
else
{
str = strchr(code[i],'%');
if(str)
{
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);
addNode(operand1);
addNode(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:
}
printf("\nLabel\tAddr\tId\tLeft\tRight",dagNode[i].label,&(dagNode[i].label),dagNod
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;
{
if(str[k] != ' ')
}
return returnStr;
}
void main()
{
Dag d;
clrscr();
d.inputThreeAddCode();
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

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<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);
};
void Natural :: printNaturalLoop()

{
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;
}
void Natural :: printFlowGraph()

{
int i,j;
cout << "Node\tpaths" << endl;
{
cout << i << "\t";
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;
{
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
Your back edge is of type n -> d.

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

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<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 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';
{
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;
}
}
void LiveVar :: printDFST()

{
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;
cout << DFN[i] << " ";
cout << endl << "\nBlock\t\tDEF\t\tUSE\t\tIn\t\tOut\n";

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;
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[2].endNodes[0]=3;flowGraph[2].endNodes[1]=4;
strcpy(du[1].def,"BC");strcpy(du[1].use,"");
strcpy(du[2].def,"AD");strcpy(du[2].use,"ABC");
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");
}
void LiveVar :: printFlowGraph()

{
int i,j;
{
cout << i << "\t";
cout << endl;
}
}
void main()
{
LiveVar l;
clrscr();
l.inputFlowGraph();
l.printFlowGraph();
l.findDFST();
l.findLiveVar();
l.printDFST();
getch();
}
OUTPUT:
Depth First Spanning Tree:

1->2
2->3
3->4
4->6
3->5
Depth First Ordering:

123546
Block DEF USE In Out

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

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<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 findDFST();
void printDFST();
void search(int);
};
void LiveVar :: printDFST()

{
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;
cout << DFN[i] << " ";
}
void LiveVar :: findDFST()

{
int m,i,j;
dfst_n = 0;
dfn_n = no_node;
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;
}
void LiveVar :: printFlowGraph()

{
int i,j;
{
cout << i << "\t";
cout << endl;
}
}
void main()
{
LiveVar l;
clrscr();
l.inputFlowGraph();
l.printFlowGraph();
l.findDFST();
l.printDFST();
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;
{
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
Depth First Spanning Tree:

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

M.Sc. (Part-I) 2006 – 07
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
ADD R0 b
MOV R1 c
ADD R1 d
MOV R2 R0
MUL R2 R1
PROGRAM:
// Assembler
#include<stdio.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;
} quadraple[10];
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);
void findQuadra();
void findAssm(void);
};
void Grammer :: findAssm(void)

{
int 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=='+')
sprintf(assm[reg_count].opr,"ADD");
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 << "E" << i << "\t" << quadraple[i].op << "\t" << quadraple[i].A1 << "\t"
<< quadraple[i].A2 << "\t" << quadraple[i].R << endl;
}

{
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* returnStr;
int k,l=0;
return returnStr;
}

{
int i,k,l;
char *subStr;
{
startExpr=0;

{
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
}

{
goto getQuadra;
}

{
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
{
{
startExpr=k-1;
endExpr=k+1;
goto getQuadra;
}
}
}
getQuadra:

in brackets
{
{
if( (int)quadraple[k].A1 == (int)inputString[startExpr+1] &&
(int)quadraple[k].op == (int)inputString[startExpr+2] && (int)quadraple[k].A2 ==
(int)inputString[startExpr+3])
{
res=k+2;
goto processStr;
//cout << endl << "true";
}
}

else

else
res=result;
no_qdrpl++;
}
else
{
{
if( (int)quadraple[k].A1 == (int)inputString[startExpr] &&
(int)quadraple[k].op == (int)inputString[startExpr+1] && (int)quadraple[k].A2 ==
(int)inputString[startExpr+2])
{
res=k+2;
goto processStr;
}
}

else

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

{
{
if(str[k] == '(')
currentPos=k;
if(str[k] == ')')
break;
}
return currentPos;
}

{
int k;
if(str[k] == ')')
return k;
return -1;
}
{
int i,j;
clrscr();
no_op=0;
no_var=0;
no_qdrpl=0;
reg_count=0;
reg=0;
result=1;
gets(inputString);
//inputString="(a+b)*(c+d)";
{
{
{
goto nextVar;
nextVar:
}
else
if(inputString[i] == '+' || inputString[i] == '-' || inputString[i] ==
'*' || inputString[i] == '/' || inputString[i] == '%' || inputString[i] == '(' || inputString[i] == ')')
{
{
goto nextOp;
nextOp:
}
}
else
{
getch();
exit(0);
}
}
}


}
int main(void)
{
Grammer g;
//int result;
g.findQuadra();
g.findAssm();
cout << endl;
g.printQuadra();
getch();
return 0;
}
OUTPUT:
Enter String:a*b+c*d

abcd
*+
Quadraple Table
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
ADD R0 R1
Roll No. – 22

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>
#define MAX 100
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:
Enter infix expression: ab+c*

((a+b)*c)
Enter infix expression: abc*+

(a+(b*c))
Enter infix expression: ab+cd+*

((a+b)*(c+d))
Enter infix expression: ab-cd+e-f*+

((a-b)+((c+d)-e)*f)
Roll No. – 22

M.Sc. (Part-I) 2006 – 07
PRACTICAL 12
Infix to Postfix Conversion
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:
Enter infix expression:(a+b)*c

ab+c*
Enter infix expression:a+b*c

abc*+
Enter infix expression:(a+b)*(c+d)

ab+cd+*
Enter infix expression:((a-b)+((c+d)-e)*f)

ab-cd+e-f*+
Roll No. – 22

M.Sc. (Part-I) 2006 – 07
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<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;
};
{
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;
}
}
{
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++)
{
{
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;

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

Compiler 22

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Compiler 22

Uploaded by

Copyright:

Available Formats

M. Sc.

Part I [COMPUTER SCIENCE]

Department of Computer Science and Information Technology

This is to certify that Mr./Miss_________________ of M.Sc Part-I [COMPUTER

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

Lecturer-in-charge Head of Department

No. Title Page No. Date Sign

1 Parsing using DFA

3 Removal of Empty State( λ / є )

4 Removal of Left Recursion

5 LL(1) Parsing Table

8 Right & Left Linear Grammars

9 Minimize the Automata

10 Simple Precedence Matrix (SPM)

11 Parsing using SPM

12 Linearizing a given SPM

NAAC Accreditation “A” Grade

Compiler Construction (Section-I)

Write a program for acceptance of a string using DFA

Suppose the following transition table

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

void p_dfa::dfa(char *str)

No. of states in DFA are:3

No. of final states in DFA are:1

Enter state number(s) of final states(s):2

No. of characters you are using in DFA are:2

Enter those characters one by one:

Describe your DFA

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

1) Enter the string to be tested: aab

2) Enter the string to be tested: abab

NAAC Accreditation “A” Grade

Compiler Construction (Section-I)

You are provided with a NFA with λ moves

Write the program to convert the given NFA into DFA

//PROGRAM FOR NFA TO DFA CONVERSION.

void NFA :: init1(void)

int closure[15], cl=0;

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

void NFA :: PrintFA(void)

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

void NFA :: E_Closure( int state_no )

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

void NFA_TO_DFA( NFA *N, DFA *D )

int T[15], Y[20];

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

N->E_Closure( N->start_state ); // î-CLOSURE ( q0 ) is in Closure

// Build The First DFA state

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

while( current < D->nDFAstates )

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

cout << "\b\b } ";

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

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

ctr = j; // no of states in arrayY

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

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

int DFA :: CheckPrev( int array[30], int no )

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

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

void DFA :: PrintDFA(void)

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

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

void NFA_TO_DFA( NFA N, DFA D )

int strcmpstr( char str1, char str2 );

int strcmpstr( char str1, char str2 )