20.12.07
PROCEDURAL STEPS:
2. Read the content of the file string by string using ‘fgets’ function.
4. Store all the possible keywords in a character array called ‘keys [][]’.
7. Compare ‘token []’ with the list of keywords stored in ‘keys [][]’.
11.Display all the details in a separate file using ‘fprintf ()’ function.
1|Page
PROGRAM
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
char exp[100];
char op[20]={'+','-','*','/','%','^','[',']','(',')','{','}','=',';','<','>','#',',','&','"'};
char
Keys[20][20]={"if","while","for","do","include","stdio.h","conio.h","printf",
"main","void","scanf","getch","int","char","break","continue"};
char token[20],fi[25];
int i,j,pos,k,h,m,len,c=0,g;
FILE *fp,*rp;
clrscr();
printf("enter the program to be compiled under lexical analysis");
scanf("%s",&fi);
fp=fopen(fi,"r");
rp=fopen("outlex.txt","w");
while(!feof(fp))
{
if(fgets(exp,50,fp)!=NULL)
{
len=strlen(exp);
for(i=0;i<=len;i++)
{
if(isalpha(exp[i]))
{
pos=i;
g=i;
while(isalpha(exp[g])||isdigit(exp[g]))
g++;
for(j=0;j<20;j++)
token[j]=NULL;
k=0;
for(j=pos;j<g;j++)
{
token[k]=exp[j];
k++;
2|Page
}
c=0;
if((strcmp(token,"stdio")==0)||(strcmp(token,"conio")==0))
{
token[k]='.';
token[k+1]='h';
g+=2;
}
fprintf(rp,"%s",token);
for(m=0;m<20;m++)
{
if(strcmp(token,keys[m])==0)
c++;
}
if(c==0)
fprintf(rp,"%s"," - It is a identifier\n");
else
fprintf(rp,"%s"," - It is a key word\n");
i=g-1;
}
else if(isdigit(exp[i]))
{
while(isdigit(exp[i+1]))
{
fprintf(rp,"%c",exp[i]);
i++;
}
fprintf(rp,"%c",exp[i]);
fprintf(rp,"%s"," - It is a digit\n");
}
else
{
if(exp[i]=='+'||exp[i]=='-'||exp[i]=='=')
{
i++;
if(exp[i]=='+'||exp[i]=='-'||exp[i]=='=')
fprintf(rp,"%c%c - It is an operator\n",exp[i-1],exp[i]);
else
{
fprintf(rp,"%c - It is an operator\n",exp[i-1]);
3|Page
i--;
}
}
else
{
for(h=0;h<20;h++)
{
if(exp[i]==op[h])
{
fprintf(rp,"%c - It is an operator\n",op[h]);
break;
}
}
}
}
}
}
}
getch();
}
AIM: - To write a program which accepts a NFA as input from the user and
convert it into DFA.
PROCEDURAL STEPS:
1. The number of states in NFA is obtained as input from the user and
stored.
2. Further the initial state ,final state and input symbols are also obtained
from the user.
3. Then the transition from every state for every input string is also
obtained and
stored in the structures.
5|Page
PROGRAM
#include <stdio.h>
#include <string.h>
#define STATES 50
struct Dstate
{
char name;
char StateString[STATES+1];
char trans[10];
int is_final;
}Dstates[50];
struct tran
{
char sym;
int tostates[50];
int notran;
};
struct state
{
int no;
struct tran tranlist[50];
};
int stackA[100],stackB[100],C[100],Cptr=-1,Aptr=-1,Bptr=-1;
struct state States[10];
char temp[STATES+1],inp[10];
int nos,noi,nof,j,k,nods=-1;
void pushA(int z)
{
stackA[++Aptr]=z;
}
void pushB(int z)
{
stackB[++Bptr]=z;
}
int popA()
6|Page
{
return stackA[Aptr--];
}
void copy(int i)
{
char temp[STATES+1]=" ";
int k=0;
Bptr=-1;
strcpy(temp,Dstates[i].StateString);
while(temp[k]!='\0')
{
pushB(temp[k]-'0');
k++;
}
}
int popB()
{
return stackB[Bptr--];
}
int peekB()
{
return stackA[Bptr];
}
int peekA()
{
return stackA[Aptr];
}
int seek(int arr[],int ptr,int s)
{
int i;
for(i=0;i<=ptr;i++)
{
if(s==arr[i])
return 1;
}
return 0;
}
void sort()
{
int i,j,temp;
7|Page
for(i=0;i<Bptr;i++)
{
for(j=0;j<(Bptr-i);j++)
{
if(stackB[j]>stackB[j+1])
{
temp=stackB[j];
stackB[j]=stackB[j+1];
stackB[j+1]=temp;
}
}
}
}
void tostring()
{
int i=0;
sort();
for(i=0;i<=Bptr;i++)
{
temp[i]=stackB[i]+'0';
}
temp[i]='\0';
}
void display_DTran()
{
int i,j;
printf("\n\t\t DFA Transition Table ");
printf("\n\t\t -------------------- ");
printf("\nStates\tString\tInputs\n ");
for(i=0;i<noi;i++)
{
printf("\t%c",inp[i]);
}
printf("\n \t----------");
for(i=0;i<nods;i++)
{
if(Dstates[i].is_final==0)
printf("\n%c",Dstates[i].name);
else
printf("\n*%c",Dstates[i].name);
8|Page
printf("\t%s",Dstates[i].StateString);
for(j=0;j<noi;j++)
{
printf("\t%c",Dstates[i].trans[j]);
}
}
printf("\n");
}
void move(int st,int j)
{
int ctr=0;
while(ctr<States[st].tranlist[j].notran)
{
pushA(States[st].tranlist[j].tostates[ctr++]);
}
}
void lambda_closure(int st)
{
int ctr=0,in_state=st,curst=st,chk;
while(Aptr!=-1)
{
curst=popA();
ctr=0;
in_state=curst;
while(ctr<=States[curst].tranlist[noi].notran)
{
chk=seek(stackB,Bptr,in_state);
if(chk==0)
pushB(in_state);
in_state=States[curst].tranlist[noi].tostates[ctr++];
chk=seek(stackA,Aptr,in_state);
if(chk==0 && ctr<=States[curst].tranlist[noi].notran)
pushA(in_state);
}
}
}
9|Page
main()
{
int final[20],start,fin=0,i;
char c,ans,st[20];
printf("\nEnter no. of states in NFA : ");
scanf("%d",&nos);
for(i=0;i<nos;i++)
{
States[i].no=i;
}
printf("\nEnter the start state : ");
scanf("%d",&start);
printf("Enter the no. of final states : ");
scanf("%d",&nof);
printf("\nEnter the final states : \n");
for(i=0;i<nof;i++)
scanf("%d",&final[i]);
printf("\nEnter the no. of input symbols : ");
scanf("%d",&noi);
c=getchar();
printf("\nEnter the input symbols : \n ");
for(i=0;i<noi;i++)
{
scanf("%c",&inp[i]);
c=getchar();
}
inp[i]='e';
printf("\nEnter the transitions : (-1 to stop)\n");
for(i=0;i<nos;i++)
{
for(j=0;j<=noi;j++)
{
States[i].tranlist[j].sym=inp[j];
k=0;
ans='y';
while(ans=='y')
{
printf("move(%d,%c) : ",i,inp[j]);
scanf("%d",&States[i].tranlist[j].tostates[k++]);
if(States[i].tranlist[j].tostates[k-1]==-1)
10 | P a g e
{
k--;ans='n';
break;
}
}
States[i].tranlist[j].notran=k;
}
}
//Conversion
i=0;nods=0;fin=0;
pushA(start);
lambda_closure(peekA());
tostring();
Dstates[nods].name='A';
nods++;
strcpy(Dstates[0].StateString,temp);
while(i<nods)
{
for(j=0;j<noi;j++)
{
fin=0;
copy(i);
while(Bptr!=-1)
{
move(popB(),j);
}
while(Aptr!=-1)
lambda_closure(peekA());
tostring();
for(k=0;k<nods;k++)
{
if((strcmp(temp,Dstates[k].StateString)==0))
{
Dstates[i].trans[j]=Dstates[k].name;
break;
}
}
if(k==nods)
{
11 | P a g e
nods++;
for(k=0;k<nof;k++)
{
fin=seek(stackB,Bptr,final[k]);
if(fin==1)
{
Dstates[nods-1].is_final=1;
break;
}
}
strcpy(Dstates[nods-1].StateString,temp);
Dstates[nods-1].name='A'+nods-1;
Dstates[i].trans[j]=Dstates[nods-1].name;
}
}
i++;
}
display_DTran();
getch();
return 0;
}
RESULT:
12 | P a g e
EX NO: 3 ELIMINATION OF LEFT RECURSION
27.12.07
PROCEDURAL STEPS:-
1. Get the no of production as input from the user and store it in ‘n’.
2. Read the production from the user and store it in an array ‘exp’.
3. Compare the get most non-terminal with the right side of the
production.
5. Based on the position of ’|’, extract ‘α’(alpha) and ‘β’(beta) from the
given productions.
13 | P a g e
PROGRAM:
#include<stdio.h>
#include<conio.h>
#include<string.h>
main()
{
char exp[10][100],a[10],b[10],al[10],be[10];
int i=0,j=0,n,k=0,q,h;
clrscr();
printf("Enter the no.productions\n");
scanf("%d",&n);
printf("Enter the productions\n");
for(i=0;i<n;i++)
scanf("%s",exp[i]);
for(i=0;i<n;i++)
{
q=0,h=0,k=0;
for(j=0;j<10;j++)
{
a[j]=NULL;
b[j]=NULL;
al[j]=NULL;
be[j]=NULL;
}
while(exp[i][q]!='|')
q++;
while(isalpha(exp[i][h]))
{
a[k]=exp[i][h];
h++;
k++;
}
h+=2;
k=0;
while(isalpha(exp[i][h]))
{
b[k]=exp[i][h];
h++;
k++;
14 | P a g e
}
if(strcmp(a,b)==0)
{
k=0;
while(q<strlen(exp[i])-1)
{
q++;
be[k]=exp[i][q];
k++;
}
k=0;
while(exp[i][h]!='|')
{
al[k]=exp[i][h];
k++;
h++;
}
printf("%s->%s%s'\n",a,be,a);
printf("%s'->%s%s'|%c\n",a,al,a,238);
}
} getch();
}
15 | P a g e
Ex:no: 4 ELIMINATION OF LEFT FACTORING
07.02.08
PROCEDURAL STEPS:
1. Include all necessary header files and declare variables.
2. Get the productions and count the no: of ‘l’ in the production with a
delimiter ‘#’.this is used in order to find the γ(gamma).
4. Find the β values and remove the left factoring in it using the formula
i. A -> αΑ’/γ
ii. A’ ->β1/ β2/../ βn
5. Print the productions with left factoring of the above format, thus
removing left factoring in the production.
16 | P a g e
PROGRAM:
#include<stdio.h>
#include<conio.h>
#include<string.h>
main()
{
char exp[50],a[50],g[50],al[50],be[50],ab[50];
int i=0,j=0,n,k=0,q,h,z,c,r,p,m,l,u;
clrscr();
printf("Enter the no.productions\n");
scanf("%d",&n);
for(i=0;i<n;i++)
{
for(j=0;j<50;j++)
exp[j]=NULL;
j=0;
printf("\nEnter the productions and end with a
delimiter#\n");
do
{
scanf("%c",&exp[j]);
j++;
}while(exp[j-1]!='#');
u=j-1;
q=0,h=1,k=0,z=0,r=0,p=0,c=0,m=0,l=0;
for(j=0;j<50;j++)
{
a[j]=NULL;
g[j]=NULL;
al[j]=NULL;
ab[j]=NULL;
be[j]=NULL;
}
for(z=1;z<=u;z++)
{
if(exp[z]=='|')
c++;
}
while(isalpha(exp[h]))
17 | P a g e
{
a[k]=exp[h];
h++;
k++;
}
h+=2;
m=h;
while(isalpha(exp[h])||isspace(exp[h]))
{
ab[r]=exp[h];
h++;
r++;
}
h+=1;
r=0;
while(exp[h]==ab[r])
{
al[p]=ab[r];
h++;
r++;
p++;
}
r=0;
h=1;
while(r!=c)
{
while(exp[h]=='|')
{
h++;
r++;
}
h++;
}
r=h;
p=0;
h--;
l=h-1;
while(r<=u)
{
g[p]=exp[h];
18 | P a g e
p++;
h++;
r++;
}
printf("%s->%s%s'|%s\n",a,al,a,g);
printf("%s'->",a);
h=m-1;
while(h<l)
{
m=0;
while(m<strlen(al))
{
h++;
m++;
}
h++;
be[q]=exp[h];
while(exp[h]!='|')
{
be[q]=exp[h];
q++;
h++;
}
if(be[q]=='|')
{
be[q]=238;
q++;
}
be[q]='|';
q++;
}
for(j=0;j<strlen(be)-1;j++)
printf("%c",be[j]);
}
getch();
}
RESULT:
Thus left factoring is eliminated from the given grammar.
19 | P a g e
EX NO: 5 FIRST OF A GRAMMAR
20.03.08
PROCEDURAL STEPS:
4. After repeating the step 2, 3 for all the production, scan the top
production in the stack
20 | P a g e
Program:
#include<stdio.h>
#include<conio.h>
void firstrule();
void secondrule();
void rall();
char ip[10][10],first[10][10],follow[10][10],nt[10];
int i,n,flag,j,ind1;
void main()
{
clrscr();
printf("enter the no of production\n");
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%s",ip[i]);
flag=0;
for(j=0;j<i;j++)
if(nt[j]==ip[i][0])
flag=1;
if(flag==0)
{
nt[ind1] = ip[i][0];
ind1++;
}
}
printf("enter the first values\n");
for(i=0;i<ind1;i++)
scanf("%s",&first[i]);
firstrule();
secondrule();
rall();
printf("\nFOLLOW\n");
for(i=0;i<ind1;i++)
printf(" %c-> %s\n",nt[i],follow[i]);
getch();
}
void firstrule()
{
21 | P a g e
follow[0][0]='$';
}
void secondrule()
{
int z,y,x,source=0,des,flag,dumy,i,test,x1;
for(z=0;z<n;z++)
{
i=0;
for(y=3;y<strlen(ip[z]);y++)
{
if((isalpha(ip[z][y]))&&(isupper(ip[z][y])))
{
if((isalpha(ip[z][y+1]))&&(isupper(ip[z][y+1])))
{
for(x=0;x<ind1;x++)
if(nt[x]==ip[z][y])
des=x;
for(x1=y+1;x1<strlen(ip[z]);x1++)
{
flag=0;
for(x=0;x<ind1;x++)
if(nt[x]==ip[z][x1])
source=x;
for(x=0;x<strlen(first[source]);x++)
if(first[source][x]!='#')
{
for(i=0;i<strlen(follow[des]);i++)
if(first[source][x]==follow[des][i])
flag=1
if (flag==0)
follow[des][strlen(follow[des])]=first[source][x];
}
}}
else
{
if(ip[z][y+1]!='\0')
{
22 | P a g e
for(x=0;x<ind1;x++)
if(nt[x]==ip[z][y])
des=x;
follow[des][strlen(follow[des])]=ip[z][y+1];
}
}
}
}
void rall()
{
int x,y,z,temp,source,des,dump,test;
for(x=0;x<n;x++)
{
for(y=3;y<strlen(ip[x]);y++)
{
if((isalpha(ip[x][y]))&&(isupper(ip[x][y])))
{
if((isalpha(ip[x][y+1]))&&(isupper(ip[x][y+1])))
{
for(z=0;z<ind1;z++)
{
if(ip[x][y+1]==nt[z])
temp=z;
}
flag=0;
for(z=0;z<strlen(first[temp]);z++)
if(first[temp][z]=='#')
flag=1;
if(flag==1)
{
for(i=0;i<ind1;i++)
{
if(nt[i]==ip[x][0])
source=i;
if(nt[i]==ip[x][y])
des=i;
}
for(i=0;i<strlen(follow[source]);i++)
{
23 | P a g e
test=0;
for(z=0;z<strlen(follow[des]);z++)
if(follow[source][i]==follow[des][z])
test=1;
if(test==0)
{
strcat(follow[des],follow[source]);
break;
}
}
}
}
else if(ip[x][y+1]=='\0')
{
for(i=0;i<ind1;i++)
{
if(nt[i]==ip[x][0])
source=i;
if(nt[i]==ip[x][y])
des=i;
}
if(source!=des)
{
test=0;
for(i=0;i<strlen(follow[des]);i++)
for(j=0;j<strlen(follow[source]);j++)
if(follow[source][j]==follow[des][i])
test=1;
if(test==0)
strcat(follow[des],follow[source]);
}}}
}}}
RESULT:
24 | P a g e
EX NO:6 FOLLOW OF A GRAMMAR
20.03.08
PROCEDURAL STEPS:
25 | P a g e
Program
#include<stdio.h>
#include<conio.h>
#include<string.h>
void firstrule();
void backtrack();
char ip[10][10],first[10][10],nt[10],stack[10][10];
int i,n,flag,j,ind1,top=0;
void main()
{
clrscr();
printf("enter the no of production\n");
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%s",ip[i]);
for(i=0;i<10;i++)
for(j=0;j<10;j++)
first[i][j]=NULL;
for(i=0;i<n;i++)
{
flag=0;
for(j=0;j<n;j++)
if(nt[j]==ip[i][0])
flag=1;
if(flag==0)
{
nt[ind1] = ip[i][0];
ind1++;
}
}
firstrule();
/*for(i=0;i<top;i++)
printf("STACK %s\n",stack[i]);*/
backtrack();
printf("\n final\n");
for(i=0;i<ind1;i++)
printf("first %s\n",first[i]);
26 | P a g e
getch();
}
void firstrule()
{
int z,y,dumy,index,test;
for(z=0;z<n;z++)
{
for(y=3;y<strlen(ip[z]);y++)
{
for(i=0;i<ind1;i++)
if(ip[z][0]==nt[i])
index=i;
if((isalpha(ip[z][3]))&&(isupper(ip[z][3])))
{
strcpy(stack[top],ip[z]);
top++;
break;
}
else
{
dumy=strlen(first[index]);
test=0;
for(i=0;i<dumy;i++)
if(first[index][i]==ip[z][y])
test=1;
if(test==0)
first[index][dumy]=ip[z][y];
break;
}
}
}
}
void backtrack()
{
int z,index,y,index2,j,dumy,flag,test,copy,etest;
char temp[10];
27 | P a g e
for(z=top-1;z>=0;z--)
{
flag=0;
copy=0;
for(y=3;y<strlen(stack[z]);y++)
{
temp[copy]=stack[z][y];
copy++;
for(i=0;i<ind1;i++)
{
if(stack[z][0]==nt[i])
index=i;
if(stack[z][y]==nt[i])
index2=i;
}
etest=0;
for(j=0;j<strlen(first[index2]);j++)
{
if(first[index2][j]=='#')
{
flag++;
etest=1;
}
else
{
dumy=strlen(first[index]);
test=0;
for(i=0;i<dumy;i++)
if(first[index][i]==first[index2][j])
test=1;
if(test==0)
first[index][dumy]=first[index2][j];
}
}
if(etest==0)
28 | P a g e
break;
}
temp[copy]='\0';
if(flag==strlen(temp))
{
dumy=strlen(first[index]);
first[index][dumy]='#';
}
}
}
RESULT:
29 | P a g e
EX NO: 07 Checking Grammar is LL (1) or Not
20.12.07
PROCEDURAL STEPS:
12.Get the number of production from the user and the productions in the
grammar.
13.Get the first and follow values of all the non-terminals involved.
16.In order to fill the table with desired entries we need to compute the
index values of column and rows in accordance with the first values of
all the non terminals involved entry
18.Now all the entries are filled in and a flag concept is used for checking
more than one entry in a cell
30 | P a g e
PROGRAM
#include<stdio.h>
#include<conio.h>
#include<string.h>
char out[20][20][20],nt[10],te[10],ip[20][20],first[20][20],dup[20];
char ip3[20][20],ip2[20][20],follow[10][10],temp[5];
int
i,flag,ind1=0,n,k1=0,j,k=0,teind,q,ct=0,dump,count,count1,test,slen=0;
void getdata();
void followcall(int);
void cal();
void duplicate(int);
void main()
{
int cnt=0;
clrscr();
getdata();
cal();
printf("NO OF ROW IS %d \t COLUMN IS %d:\n",ind1,k1);
cnt=0;
for(i=0;i<k1;i++)
printf("\t%c",te[i]);
for(i=0;i<ind1;i++)
{
printf("\n\n%c ",nt[i]);
for(j=0;j<k1;j++)
{
if(strlen(out[i][j])>slen)
cnt++;
printf("%s\t ",out[i][j]);
}
printf("\n");
}
if(cnt>0)
printf("It is not a LL(1) grammar\n");
else
{
printf("It is a LL(1) grammar\n");
topdown();
31 | P a g e
}
getch();
}
void getdata()
{
for(i=0;i<10;i++)
{
for(j=0;j<10;j++)
ip[i][j]=ip2[i][j]=ip3[i][j]=NULL;
}
printf("enter the no production\n");
scanf("%d",&n);
printf("enter the productionds\n");
count=0,slen=0;
for(i=0;i<n;i++)
{
scanf("%s",&ip[i]);
if(strlen(ip[i])>slen)
slen=strlen(ip[i]);
}
q=0;
for(i=0;i<n;i++)
{
flag=0;
for(j=0;j<n;j++)
{
if(nt[j]==ip[i][0])
{
dup[q]=ip[i][0];
q++;
flag=1;
}
}
if(flag==0)
{
nt[ind1] = ip[i][0];
ind1++;
}
}
for(i=0;i<n;i++)
32 | P a g e
if(ip[i][3]=='#')
{
for(j=i;j<n;j++)
strcpy(ip[j],ip[j+1]);
n--;
}
printf("enter the first values\n");
k1=0;
for(i=0;i<ind1;i++)
{
scanf("%s",&first[i]);
for(j=0;j<strlen(first[i]);j++)
{
flag=0;
for(k=0;k<=k1;k++)
if((te[k]==first[i][j])||(first[i][j]=='#'))
flag=1;
if(flag==0)
{
te[k1]=first[i][j];
k1++;
}
}
}
printf("enter the follow values\n");
for(i=0;i<ind1;i++)
{
scanf("%s",&follow[i]);
for(j=0;j<strlen(follow[i]);j++)
{
flag=0;
for(k=0;k<=k1;k++)
if(te[k]==follow[i][j])
flag=1;
if(flag==0)
{
te[k1]=follow[i][j];
k1++;
}
}
33 | P a g e
}
count=0;
for(i=0;i<ind1;i++)
{
test=0;
for(j=0;j<n;j++)
{
if(ip[j][0]==nt[i])
test++;
if((test>1)&&(ip[j][0]==nt[i]))
{
strcpy(ip2[count],ip[j]);
count++;
}
}
}
count1=0;
i=0;
for(i=0;i<n;i++)
{
test=0;
for(j=0;j<count;j++)
if(strcmp(ip2[j],ip[i])==0)
test=1;
if(test==0)
{
strcpy(ip3[count1],ip[i]);
count1++;
}
}
}
void cal()
{
int z,teindex,ntindex;
for(i=0;i<count1;i++)
{
for(j=0;j<strlen(first[i]);j++)
{
test=0;
for(k=0;k<count;k++)
34 | P a g e
if(ip3[i][0]==ip2[k][0])
test=1;
if(test==1)
{
duplicate(i);
break;
}
else
{
if(first[i][j]=='#')
followcall(i);
else
{
for(z=0;z<k1;z++)
if(first[i][j]==te[z])
teindex=z;
for(z=0;z<count1;z++)
if(ip3[i][0]==nt[z])
ntindex=z;
strcat(out[ntindex][teindex],ip3[i]);
}
}
}
}
}
void followcall( int a)
{
int z,y;
for(y=0;y<strlen(follow[a]);y++)
for(z=0;z<=k1;z++)
if(follow[a][y]==te[z])
{
temp[0]=nt[a];
temp[1]='-';
temp[2]='>';
temp[3]='#';
temp[4]='\0';
strcat(out[a][z],temp);
}
}
35 | P a g e
void duplicate( int a)
{
int dup=0,z,teindex,ntindex,ct=0;
for(z=0;z<k1;z++)
if(first[a][0]==te[z])
{
teindex=z;
ct++;
}
for(z=0;z<count1;z++)
if(ip3[a][0]==nt[z])
ntindex=z;
strcat(out[ntindex][teindex],ip3[a]);
for(z=0;z<count;z++)
if(ip3[a][0]==ip2[z][0])
{
dup=z;
break;
}
while(ip3[a][0]==ip2[dup][0])
{
for(z=0;z<count1;z++)
if(ip2[dup][0]==nt[z])
ntindex=z;
strcat(out[ntindex][ct],ip2[dup]);
dup++;
ct++;
}
}
36 | P a g e
EX NO: 08 Top –Down Parser for LL (1) Grammar
20.12.07
PROCEDURAL STEPS:
2. Get the input string for which the parsing is to be carried out.
4. Now check whether the stack is having only $ content and iterate a
loop until the number of elements in the stack is greater than or equal
to one.
5. Now compare the top of the stack with the initial input terminal
compute the production to be applied by referring the LL (1) table.
6. Reference is being carried out by computing the row value from stack
top and column value from the current input terminal.
7. The above two steps are carried out until the stack top has the same
terminal in accordance with the input string so that a pop is performed
on the stack and the input string is reduced by one terminal.
8. In this way the input string is parsed and in every step the stack
contents, input string and the action taken is displayed.
9. So after the loop terminates if the contents of the stack and the input
string is having ‘ $’ as the only content then the given string is
accepted else it is not accepted.
#include<stdio.h>
#include<conio.h>
#include<string.h>
char out[20][20][20],nt[10],te[10],ip[20][20],first[20][20],dup[20];
char ip3[20][20],ip2[20][20],follow[10][10],temp[5];
int
i,flag,ind1=0,n,k1=0,j,k=0,teind,q,ct=0,dump,count,count1,test,slen=0;
void getdata();
void followcall(int);
void cal();
void topdown();
void duplicate(int);
void main()
{
int cnt=0;
clrscr();
getdata();
cal();
printf("NO OF ROW IS %d \t COLUMN IS %d:\n",ind1,k1);
cnt=0;
for(i=0;i<k1;i++)
printf("\t%c",te[i]);
for(i=0;i<ind1;i++)
{
printf("\n\n%c ",nt[i]);
for(j=0;j<k1;j++)
{
if(strlen(out[i][j])>slen)
cnt++;
printf("%s\t ",out[i][j]);
}
printf("\n");
}
if(cnt>0)
printf("It is not a LL(1) grammar\n");
else
{
printf("It is a LL(1) grammar\n");
38 | P a g e
topdown();
}
getch();
}
void getdata()
{
for(i=0;i<10;i++)
{
for(j=0;j<10;j++)
ip[i][j]=ip2[i][j]=ip3[i][j]=NULL;
}
printf("enter the no production\n");
scanf("%d",&n);
printf("enter the productionds\n");
count=0,slen=0;
for(i=0;i<n;i++)
{
scanf("%s",&ip[i]);
if(strlen(ip[i])>slen)
slen=strlen(ip[i]);
}
q=0;
for(i=0;i<n;i++)
{
flag=0;
for(j=0;j<n;j++)
{
if(nt[j]==ip[i][0])
{
dup[q]=ip[i][0];
q++;
flag=1;
}
}
if(flag==0)
{
nt[ind1] = ip[i][0];
ind1++;
}
}
39 | P a g e
for(i=0;i<n;i++)
if(ip[i][3]=='#')
{
for(j=i;j<n;j++)
strcpy(ip[j],ip[j+1]);
n--;
}
printf("enter the first values\n");
k1=0;
for(i=0;i<ind1;i++)
{
scanf("%s",&first[i]);
for(j=0;j<strlen(first[i]);j++)
{
flag=0;
for(k=0;k<=k1;k++)
if((te[k]==first[i][j])||(first[i][j]=='#'))
flag=1;
if(flag==0)
{
te[k1]=first[i][j];
k1++;
}
}
}
printf("enter the follow values\n");
for(i=0;i<ind1;i++)
{
scanf("%s",&follow[i]);
for(j=0;j<strlen(follow[i]);j++)
{
flag=0;
for(k=0;k<=k1;k++)
if(te[k]==follow[i][j])
flag=1;
if(flag==0)
{
te[k1]=follow[i][j];
k1++;
}
40 | P a g e
}
}
count=0;
for(i=0;i<ind1;i++)
{
test=0;
for(j=0;j<n;j++)
{
if(ip[j][0]==nt[i])
test++;
if((test>1)&&(ip[j][0]==nt[i]))
{
strcpy(ip2[count],ip[j]);
count++;
}
}
}
count1=0;
i=0;
for(i=0;i<n;i++)
{
test=0;
for(j=0;j<count;j++)
if(strcmp(ip2[j],ip[i])==0)
test=1;
if(test==0)
{
strcpy(ip3[count1],ip[i]);
count1++;
}
}
}
void cal()
{
int z,teindex,ntindex;
for(i=0;i<count1;i++)
{
for(j=0;j<strlen(first[i]);j++)
{
test=0;
41 | P a g e
for(k=0;k<count;k++)
if(ip3[i][0]==ip2[k][0])
test=1;
if(test==1)
{
duplicate(i);
break;
}
else
{
if(first[i][j]=='#')
followcall(i);
else
{
for(z=0;z<k1;z++)
if(first[i][j]==te[z])
teindex=z;
for(z=0;z<count1;z++)
if(ip3[i][0]==nt[z])
ntindex=z;
strcat(out[ntindex][teindex],ip3[i]);
}
}
}
}
}
void followcall( int a)
{
int z,y;
for(y=0;y<strlen(follow[a]);y++)
for(z=0;z<=k1;z++)
if(follow[a][y]==te[z])
{
temp[0]=nt[a];
temp[1]='-';
temp[2]='>';
temp[3]='#';
temp[4]='\0';
strcat(out[a][z],temp);
}
42 | P a g e
}
void duplicate( int a)
{
int dup=0,z,teindex,ntindex,ct=0;
for(z=0;z<k1;z++)
if(first[a][0]==te[z])
{
teindex=z;
ct++;
}
for(z=0;z<count1;z++)
if(ip3[a][0]==nt[z])
ntindex=z;
strcat(out[ntindex][teindex],ip3[a]);
for(z=0;z<count;z++)
if(ip3[a][0]==ip2[z][0])
{
dup=z;
break;
}
while(ip3[a][0]==ip2[dup][0])
{
for(z=0;z<count1;z++)
if(ip2[dup][0]==nt[z])
ntindex=z;
strcat(out[ntindex][ct],ip2[dup]);
dup++;
ct++;
}
}
void topdown()
{
int ct1=0,ct2,i,j,stindex=0,ipindex=0,ct3,c=0;
char stack[10],iptd[10],temp1[10];
for(i=0;i<10;i++)
stack[i]='\0';
stack[0]='$';
stack[1]=ip3[0][0];
printf("Enter ip string to parse!");
43 | P a g e
scanf("%s",&iptd);
while(strlen(stack)>=1)
{
if(strcmp(iptd,"$")!=0)
{
if(stack[strlen(stack)-1]=='#')
stack[strlen(stack)-1]='\0';
c=0;
for(j=0;j<ind1;j++)
{
if(stack[strlen(stack)-1]==nt[j])
stindex = j;
else
c++;
}
if(c==ind1)
break;
c=0;
for(j=0;j<k1;j++)
{
if(iptd[0]==te[j])
ipindex=j;
else
c++;
}
if(c==k1)
break;
ct2=0;
printf("\nStack is %s \t\t IP is %s \t\t Out is
%s\n",stack,iptd,out[stindex][ipindex]);
for(j=3;j<strlen(out[stindex][ipindex]);j++,ct2++)
temp1[ct2]= out[stindex][ipindex][j];
temp1[ct2]='\0';
ct3=strlen(stack)-1;
for(j=strlen(temp1)-1;j>=0;j--)
{
stack[ct3] = temp1[j];
ct3++;
}
c=0;
44 | P a g e
if(stack[strlen(stack)-1]==iptd[0])
{
stack[strlen(stack)-1] = '\0';
for(j=0;j<strlen(iptd)-1;j++)
{
iptd[j]=iptd[j+1];
c++;
}
if(c!=0)
iptd[j]='\0';
}
}
else
break;
}
if(strcmp(iptd,"$")==0)
{
while(strlen(stack)>1)
{
printf("\nStack is %s\t\t IP is %s \t\t Out is
%c->#\n",stack,iptd,stack[strlen(stack)-1]);
stack[strlen(stack)-1]=NULL;
}
for(i=0;i<10;i++)
stack[i]='\0';
stack[0]='$';
printf("\nStack is %s\t\t IP is %s\n",stack,iptd);
printf("The string is accepted\n");
}
else
printf("The string is not accepted\n");
}
RESULT: Thus the given input string is parsed from which a decision is
made whether the given string is generated by the grammar.
45 | P a g e
EX NO: 09 LEADING & TRAILING OF A GRAMMAR
27.03.08
PROCEDURAL STEPS:
1. The no: of productions are entered as the input and the productions for
a grammar are taken as the input.
4. The leading and trailing values are stored in two different arrays and
then print the results.
46 | P a g e
PROGRAM:
#include<stdio.h>
#include<conio.h>
#include<ctype.h>
void leading(char c[10][10],int i,int j,int n);
void slash1(char c[10][10],int i,int j,int n);
void trailing(char c[10][10],int i,int j,int n);
void slash2(char c[10][10],int i,int j,int n);
void main()
{
char c[10][10],a[10];
int q,g,n,i,j,s,r,m=238,l,t,e,h,w,x;
clrscr();
printf("enter the no of productions");
scanf("%d",&n);
printf("enter the productions with delimiter '#'");
for(i=0;i<=n;i++)
{
scanf("%s",&c[i]);
}
printf("\t\tLEADING\n");
for(i=0;i<=n;i++)
{
printf("\nleading(%c)->",c[i][0]);
j=3;
if(c[i][j-1]=='>')
{
if((isupper(c[i][j]))&&!(isupper(c[i][j+1]))&&(c[i][j+1]!='/')&&(isupper(c[i]
[j+2])))
{
printf("{%c}",c[i][j+1]);
}
else
if(!(isupper(c[i][j]))&&((isupper(c[i][j+1]))||c[i][j+1]=='#'||c[i][j+1]=='/'))
{
printf("{%c}",c[i][j]);
}
else if(isupper(c[i][j])&&(c[i][j+1]=='#'||c[i][j+1]=='/'))
{
47 | P a g e
leading(c,i,j,n);
}
}
j=3;
while(c[i][j]!='/')
{
j++;
}
if(c[i][j]=='/')
{
l=j+1;
slash1(c,i,l,n);
}
}
printf("\n\t\tTRAILING\n");
for(i=0;i<=n;i++)
{
printf("\ntrailing(%c)->",c[i][0]);
for(j=3;c[i][j]!='#';j++)
{
if(c[i][j-1]=='>')
{
if((isupper(c[i][j]))&&!(isupper(c[i][j+1]))&&c[i][j+1]!='/'&&(isupper(c[i][j
+2])))
{
printf("{%c}",c[i][j+1]);
}
else if(!(isupper(c[i][j]))&&(c[i][j+1]=='#'||c[i][j+1]=='/'))
{
printf("{%c}",c[i][j]);
}
else if(!(isupper(c[i][j]))&&(isupper(c[i][j+1]))&&!(isupper(c[i][j+2])))
{
printf("{%c}",c[i][j+2]);
}
else if((isupper(c[i][j]))&&(c[i][j+1]=='/'||c[i][j+1]=='#'))
{
trailing(c,i,j,n);
}
48 | P a g e
}
if(c[i][j]=='/')
{
l=j+1;
slash2(c,i,l,n);
}
}
}
getch();
}
void leading(char c[10][10],int i,int j,int n)
{
int s,r,e;
for(s=0;s<=n;s++)
{
if(c[s][0]==c[i][j])
{
r=3;
if(c[s][r-1]=='>')
{
if((isupper(c[s][r]))&&!(isupper(c[s][r+1]))&&(c[s][r]!='/')&&(isupper(c[s][
r+2])))
{
printf("{%c}",c[s][r+1]);
}
else
if(!(isupper(c[s][r]))&&((isupper(c[s][r+1]))||c[s][r+1]=='#'||c[s][r+1]=='/'))
{
printf("{%c}",c[s][r]);
}
else if((isupper(c[s][r]))&&(c[s][r+1]=='#'))
{
printf("leading(%c)",c[s][r]);
}
}
r=3;
while(c[s][r]!='/')
{
r++;
49 | P a g e
}
if(c[s][r]=='/')
{
e=r+1;
if(isupper(c[s][e])&&!(isupper(c[s][e+1]))&&(c[i][j+1]!='/')&&(isupper(c[s]
[e+2])))
{
printf("{%c}",c[s][e+1]);
}
else if(!(isupper(c[s][e]))&&((isupper(c[s][e+1]))||c[s][e+1]=='#'))
{
printf("{%c}",c[s][e]);
}
else if(isupper(c[s][e])&&c[s][e+1]=='#')
{
leading(c,s,e,n);
}
}
}
}
}
void slash1(char c[10][10],int i,int l,int n)
{
if(isupper(c[i][l])&&!(isupper(c[i][l+1]))&&(isupper(c[i][l+2])))
{
printf("{%c}",c[i][l+1]);
}
else if(!(isupper(c[i][l]))&&((isupper(c[i][l+1]))||(c[i][l+1]=='#')))
{
printf("{%c}",c[i][l]);
}
else if(isupper(c[i][l])&&c[i][l+1]=='#')
{
leading(c,i,l,n);
}
}
void trailing(char c[10][10],int i,int j,int n)
{
int s,r,e;
for(s=0;s<=n;s++)
50 | P a g e
{
if(c[s][0]==c[i][j])
{
for(r=3;c[s][r]!='#';r++)
{
if(c[s][r-1]=='>')
{
if((isupper(c[s][r]))&&!(isupper(c[s][r+1]))&&(c[s][r+1]!='/')&&(isupper(c[
s][r+2])))
{
printf("{%c}",c[s][r+1]);
}
else if(!(isupper(c[s][r]))&&(c[s][r+1]=='#'||c[s][r+1]=='/'))
{
printf("{%c}",c[s][r]);
}
else if(!(isupper(c[s][r]))&&isupper(c[s][r+1])&&!(isupper(c[s][r+2])))
{
printf("{%c}",c[s][r+2]);
}
else if(isupper(c[s][r])&&(c[s][r+1]=='#'))
{
printf("trailing(%c)",c[s][r]);
}
}
if(c[s][r]=='/')
{
e=r+1;
if(isupper(c[s][e])&&!(isupper(c[s][e+1]))&&(isupper(c[s][e+2])))
{
printf("{%c}",c[s][e+1]);
}
else if(!(isupper(c[s][e]))&&isupper(c[s][e+1])&&!(isupper(c[s][e+2])))
{
printf("{%c}",c[s][e+2]);
}
else if(!(isupper(c[s][e]))&&(c[s][e+1]=='#'||c[s][e+1]=='/'))
{
printf("{%c}",c[s][e]);
51 | P a g e
}
else if(isupper(c[s][e])&&c[s][e+1]=='#')
{
trailing(c,s,e,n);
}
}
}
}
}
}
void slash2(char c[10][10],int i,int l,int n)
{
if(isupper(c[i][l])&&!(isupper(c[i][l+1]))&&(isupper(c[i][l+2])))
{
printf("{%c}",c[i][l+1]);
}
else if(!(isupper(c[i][l]))&&isupper(c[i][l+1])&&!(isupper(c[i][l+2])))
{
printf("{%c}",c[i][l+2]);
}
else if(!(isupper(c[i][l]))&&(c[i][l+1]=='#'||c[i][l+1]=='/'))
{
printf("{%c}",c[i][l]);
}
else if(isupper(c[i][l])&&c[i][l+1]=='#')
{
trailing(c,i,l,n);
}
RESULT:
Thus leading and trailing for a given grammar is computed.
52 | P a g e
EX NO: 10 OPG OF THE GRAMMAR
27.03.08
AIM: To write a C program to generate the OPG table from the grammar
with its associated leading and trailing symbols.
PROCEDURAL STEPS:
1. Get the production from the user
2. Get the leading and trailing for all non terminals
3. Separate the terminals in the grammar to get the rows and columns
4. Scan the grammar of rule 1, rule 2, rule 3 and last rules
5. Enter the symbols in the corresponding table
6. Display the table.
53 | P a g e
PROGRAM:
#include<stdio.h>
#include<conio.h>
#include<string.h>
char
leading[10][10],trailling[10][10],symbol[20],ip[20][20],nt[10],out[20][20][3
];
int k,ind1,n;
void rule1();
void rule2();
void rule3();
void rule4();
void main()
{
int i,j,z,test,flag;
clrscr();
printf("enter the no of production\n");
scanf("%d",&n);
printf("ENTER THE PRODUCTION\n");
for(i=0;i<n;i++)
scanf("%s",ip[i]);
for(i=0;i<n;i++)
{
flag=0;
for(j=0;j<i;j++)
if(nt[j]==ip[i][0])
flag=1;
if(flag==0)
{
nt[ind1] = ip[i][0];
ind1++;
}
}
printf("enter the leading symbol:\n");
for(i=0;i<ind1;i++)
scanf("%s",&leading[i]);
printf("enter the trailling symbol:\n");
for(i=0;i<ind1;i++)
scanf("%s",&trailling[i]);
54 | P a g e
k=0;
for(i=0;i<ind1;i++)
for(z=0;z<strlen(leading[i]);z++)
{
test=0;
for(j=0;j<k;j++)
if(leading[i][z]==symbol[j])
test=1;
if(test==0)
{
symbol[k]=leading[i][z];
k++;
}
}
for(i=0;i<ind1;i++)
for(z=0;z<strlen(trailling[i]);z++)
{
test=0;
for(j=0;j<k;j++)
if(trailling[i][z]==symbol[j])
test=1;
if(test==0)
{
symbol[k]=trailling[i][z];
k++;
}
}
symbol[k]='$';
k++;
rule1();
rule2();
rule3();
rule4();
getch();
}
void rule1()
{
int i,index,index2,j;
for(i=0;i<k;i++)
if(symbol[i]=='$')
55 | P a g e
{
index=i;
break;
}
for(i=0;i<strlen(leading[0]);i++)
{
for(j=0;j<k;j++)
if(symbol[j]==leading[0][i])
{
index2=j;
break;
}
printf("\nrow %c column %c value
<.",symbol[index],symbol[index2]);
}
for(i=0;i<strlen(trailling[0]);i++)
{
for(j=0;j<k;j++)
if(symbol[j]==trailling[0][i])
{
index2=j;
break;
}
printf("\nrow %c column %c value
>",symbol[index2],symbol[index]);
}
}
void rule2()
{
int i,j,index,index2,z,row,column,test;
for(i=0;i<n;i++)
{
for(j=3;j<strlen(ip[i]);j++)
{
index=0;
index2=0;
if(!(isalpha(ip[i][j])) && !(isalpha(ip[i][j+1])) &&
!(ip[i][j+1]=='\0')&&!(ip[i][j+1]='/'))
{
56 | P a g e
index=j;
index2=j+1;
}
if(!(isalpha(ip[i][j])) &&
!(isalpha(ip[i][j+2]))&&!(ip[i][j+2]=='/')&&!(ip[i][j+2]=='\0'))
{
index=j;
index2=j+2;
}
row=0;
column=0;
test=0;
if((index!=0) &&(index2!=0))
{
for(z=0;z<k;z++)
{
if(ip[i][index]==symbol[z])
row=z;
if(ip[i][index2]==symbol[z])
column=z;
test=1;
}
if(test==1)
{
printf("\nrow %c column %c
=",symbol[row],symbol[column]);
test=0;
}
}
}
}
}
void rule3()
{
int i,j,ntindex,z;
for(i=0;i<n;i++)
for(j=3;j<strlen(ip[i]);j++)
if(!(isalpha(ip[i][j])) && (isalpha(ip[i][j+1]))
&&!(ip[i][j]=='/'))
57 | P a g e
{
for(z=0;z<ind1;z++)
if(ip[i][j+1]==nt[z])
ntindex=z;
for(z=0;z<strlen(leading[ntindex]);z++)
printf("\nrow %c column %c
<.",ip[i][j],leading[ntindex][z]);
}
}
void rule4()
{
int i,j,ntindex,z;
for(i=0;i<n;i++)
for(j=3;j<strlen(ip[i]);j++)
if((isalpha(ip[i][j])) && !(isalpha(ip[i][j+1]))
&&!(ip[i][j+1]=='/')&&!(ip[i][j+1]=='\0'))
{
for(z=0;z<ind1;z++)
if(ip[i][j]==nt[z])
ntindex=z;
for(z=0;z<strlen(trailling[ntindex]);z++)
printf("\nrow %c column %c
>",trailling[ntindex][z],ip[i][j+1]);
}
}
RESULT:
Thus OPG for a given grammar is computed.
58 | P a g e