Experiment number:

Date:

1. Design and implement a lexical analyzer for given language using C and the lexical
analyzer should Ignore redundant spaces,tabs and new lines.

AIM: To Design and implement a lexical analyzer for given language using C and the lexical
analyzer should Ignore redundant spaces,tabs and new lines.

PROGRAM:
#include<string.h>
#include<conio.h>
#include<ctype.h>
#include<stdio.h>
void main()
{
FILE *f1;
char c,str[10];
int lineno=1,num=0,i=0;
clrscr();
printf("\nEnter the c program\n");
f1=fopen("input.txt","w");
while((c=getchar())!=EOF)
putc(c,f1);
fclose(f1);
f1=fopen("input.txt","r");
while((c=getc(f1))!=EOF) // TO READ THE GIVEN FILE
{
if(isdigit(c)) // TO RECOGNIZE NUMBERS
{
num=c-48;
c=getc(f1);
while(isdigit(c))
{
num=num*10+(c-48);
c=getc(f1);
}
printf("%d is a number \n",num);
ungetc(c,f1);
}
else if(isalpha(c)) // TO RECOGNIZE KEYWORDS AND IDENTIFIERS

{
str[i++]=c;
c=getc(f1);
while(isdigit(c)||isalpha(c)||c=='_'||c=='$')
{
str[i++]=c;
c=getc(f1);
}
str[i++]='\0';
if(strcmp("for",str)==0||strcmp("while",str)==0||strcmp("do",str)==0||
strcmp("int",str)==0||strcmp("float",str)==0||strcmp("char",str)==0||
strcmp("double",str)==0||strcmp("static",str)==0||
strcmp("switch",str)==0||strcmp("case",str)==0) // TYPE 32 KEYWORDS
printf("%s is a keyword\n",str);

else

1
Experiment number:
Date:

printf("%s is a identifier\n",str);
ungetc(c,f1);
i=0;
}
else if(c==' '||c=='\t') // TO IGNORE THE SPACE
printf("\n");
else if(c=='\n') // TO COUNT LINE NUMBER
lineno++;
else // TO FIND SPECIAL SYMBOL
printf("%c is a special symbol\n",c);
}
printf("Total no. of lines are: %d\n",lineno);
fclose(f1);
getch();
}

2
Experiment number:
Date:

OUTPUT:

RESULT:

3
Experiment number:
Date:

2.Implementation of lexical anlyzer using lex tool?

AIM: To implement lexical analyzer using lex tool

PROGRAM:

/* program name is lexp.l */

%{
/* program to recognize a c program */
int COMMENT=0;
int cnt=0;
%}
identifier [a-zA-Z][a-zA-Z0-9]*
%%
#.* { printf("\n%s is a PREPROCESSOR DIRECTIVE",yytext);}
int |
float |
char |
double |
while |
for |
do |
if |
break |
continue |
void |
switch |
case |
long |
struct |
const |
typedef |
return |
else |
goto {printf("\n\t%s is a KEYWORD",yytext);}
"/*" {COMMENT = 1;}
"*/" {COMMENT = 0; cnt++;}
{identifier}\( {if(!COMMENT)printf("\n\nFUNCTION\n\t%s",yytext);}
\{ {if(!COMMENT) printf("\n BLOCK BEGINS");}
\} {if(!COMMENT) printf("\n BLOCK ENDS");}
{identifier}(\[[0-9]*\])? {if(!COMMENT) printf("\n %s IDENTIFIER",yytext);}
\".*\" {if(!COMMENT) printf("\n\t%s is a STRING",yytext);}
[0-9]+ {if(!COMMENT) printf("\n\t%s is a NUMBER",yytext);}
\)(\;)? {if(!COMMENT) printf("\n\t");ECHO;printf("\n");}
\( ECHO;
= {if(!COMMENT)printf("\n\t%s is an ASSIGNMENT OPERATOR",yytext);}
\<= |
\>= |
\< |
== |
\> {if(!COMMENT) printf("\n\t%s is a RELATIONAL OPERATOR",yytext);}
%%
int main(int argc,char **argv)
{
if (argc > 1)

4
Experiment number:
Date:

{
FILE *file;
file = fopen(argv[1],"r");
if(!file)
{
printf("could not open %s \n",argv[1]);
exit(0);
}
yyin = file;
}
yylex();
printf("\n\n Total No.Of comments are %d",cnt);
return 0;
}
int yywrap()
{
return 1;
}

5
Experiment number:
Date:

OUTPUT:

RESULT:

6
Experiment number:
Date:

3.Generate YACC specification for a few syntactic categories

a) Program to recognize a valid arithmetic expression that uses operator +, - , * and /

AIM: To write a Program to recognize a valid arithmetic expression that uses operator +, - , * and /

PROGRAM:

%{ #include <stdio.h>

#include <ctype.h>

#include <stdlib.h>

%}

%token num let

%left '+' '-'

%left '*' '/'

%%

Stmt : Stmt „\n‟ { printf (“\n.. Valid Expression.. \n”); exit(0); }

| expr

| error „\n‟ { printf (“\n..Invalid ..\n”); exit(0); }

expr : num

| let

| expr ‟ + ‟ expr

| expr ‟ - ‟ expr

| expr ‟ * ‟ expr

| expr ‟ / ‟ expr

| '(' expr ')'

%%

main ( )

7
Experiment number:
Date:

printf (“Enter an expression to validate : ”);

yyparse ( );

yylex()

int ch;

while ( ( ch = getchar() ) == ' ' );

if ( isdigit(ch) )

return num; // return token num

if ( isalpha(ch) )

return let; // return token let

return ch;

yyerror (char *s)

printf ( “%s”, s );

8
Experiment number:
Date:

OUTPUT:

RESULT:

9
Experiment number:
Date:

3(b) Program to recognize a valid variable which starts with a letter followed by any number of
letters or digits

AIM: To write a Program to recognize a valid variable which starts with a letter followed by any
number of letters or digits

PROGRAM:

%{

#include "y.tab.h"

%}

%%

[0-9] return digit;

[a-z] return letter;

[\n] return yytext[0];

. return 0;

%%

/* Yacc program to validate the given variable */

%{

#include<type.h>

%}

% token digit letter;

%%

ident : expn '\n' { printf ("valid\n"); exit (0); }

expn : letter

| expn letter

| expn digit

| error { yyerror ("invalid \n"); exit (0); }

%%

main()

10
Experiment number:
Date:

yyparse();

yyerror (char *s)

printf("%s", s);

/* Yacc program which has c program to pass tokens */

%{

#include <stdio.h>

#include <ctype.h>

%}

%token LETTER DIGIT

%%

st:st LETTER DIGIT '\n' {printf("\nVALID");}

| st '\n'

| error '\n' {yyerror("\nINVALID");yyerrok;}

%%

main()

yyparse();

yylex()

char c;

while((c=getchar())==' ');

11
Experiment number:
Date:

if(islower(c)) return LETTER;

if(isdigit(c)) return DIGIT;

return c;

yyerror(char *s)

printf("%s",s);

12
Experiment number:
Date:

OUTPUT:

RESULT:

13
Experiment number:
Date:

3© Implementation of calculator using LEX and YACC

AIM: To write a program to implement calculator using LEX and YACC

PROGRAM:

%{

#include<stdio.h>

#include<math.h>

#include"y.tab.h"

%}

%%

([0-9]+|([0-9]*\.[0-9]+)([eE][-+]?[0-9]+)?)

{yylval.dval=atof(yytext);

return NUMBER;}

MEM {return MEM;}

[\t];

\$ {return 0;}

\n {return yytext[0];}

. {return yytext[0];}

%%

Cal.y

%{

#include<stdio.h>

#include<math.h>

double memvar;

%}

%union

double dval;

www.annauniversityplus.com

14
Experiment number:
Date:

%token<dval> NUMBER

%token<dval> MEM

%left '-' '+'

%left '*' '/'

%nonassoc UMINUS

%type<dval> expression

%%

start:statement '\n'

|start statement '\n'

statement:MEM '=' expression {memvar=$3;}

|expression {printf("answer=%g\n",$1);}

expression:expression'+'expression {$$=$1+$3;}

|expression'-'expression {$$=$1-$3;}

|expression'*'expression {$$=$1*$3;}

|expression'/'expression {if($3==0)

yyerror("divide by zero");

else

$$=$1/$3;

};

expression:'-'expression %prec UMINUS {$$= -$2;}

|'('expression')' {$$=$2;}

|NUMBER {$$=$1;}

|MEM {$$=memvar;};

%%

int main(void)

15
Experiment number:
Date:

printf("Enter the expression");

yyparse();

printf("\n\n");

return 0;

int yywrap()

www.annauniversityplus.com

return 0;

int yyerror(char *error)

printf("%s\n",error);

return 0;

16
Experiment number:
Date:

OUTPUT:

RESULT:

17
Experiment number:
Date:

3(d) Convert the BNF rules into YACC form and write code to generate abstract syntax tree

AIM: To write a program to convert the BNF rules into YACC form and write code to generate
abstract syntax tree

PROGRAM:

<int.l>

#include"y.tab.h"

#include<stdio.h>

#include<string.h>

int LineNo=1;

identifier [a-zA-Z][_a-zA-Z0-9]*

number [0-9]+|([0-9]*\.[0-9]+)

%%

main\(\) return MAIN;

if return IF;

else return ELSE;

while return WHILE;

int |

char |

float return TYPE;

{identifier} {strcpy(yylval.var,yytext);

return VAR;}

{number} {strcpy(yylval.var,yytext);

return NUM;}

< |> |>= |<= |==

{strcpy(yylval.var,yytext);

18
Experiment number:
Date:

return RELOP;}

[ \t] ;

\n LineNo++;

. return yytext[0];

%%

<int.y>

%{

#include<string.h>

#include<stdio.h>

struct quad{

char op[5];

char arg1[10];

char arg2[10];

char result[10];

}QUAD[30];

struct stack{

int items[100];

int top; }stk;

int Index=0,tIndex=0,StNo,Ind,tInd;

extern int LineNo;

%}

%union{

char var[10];

%token <var> NUM VAR RELOP

%token MAIN IF ELSE WHILE TYPE

%type <var> EXPR ASSIGNMENT CONDITION IFST ELSEST WHILELOOP

%left '-' '+'

19
Experiment number:
Date:

%left '*' '/'

%%

PROGRAM : MAIN BLOCK

BLOCK: '{' CODE '}'

CODE: BLOCK

| STATEMENT CODE

| STATEMENT

STATEMENT: DESCT ';'

| ASSIGNMENT ';'

| CONDST

| WHILEST

; DESCT: TYPE VARLIST

; VARLIST: VAR ',' VARLIST

| VAR

ASSIGNMENT: VAR '=' EXPR{

strcpy(QUAD[Index].op,"=");

strcpy(QUAD[Index].arg1,$3);

strcpy(QUAD[Index].arg2,"");

strcpy(QUAD[Index].result,$1);

strcpy($$,QUAD[Index++].result); } ;

EXPR: EXPR '+' EXPR {AddQuadruple("+",$1,$3,$$);}

| EXPR '-' EXPR {AddQuadruple("-",$1,$3,$$);}

| EXPR '*' EXPR {AddQuadruple("*",$1,$3,$$);}

| EXPR '/' EXPR {AddQuadruple("/",$1,$3,$$);}

20
Experiment number:
Date:

| '-' EXPR {AddQuadruple("UMIN",$2,"",$$);}

| '(' EXPR ')' {strcpy($$,$2);}

| VAR

| NUM

CONDST: IFST{

Ind=pop();

sprintf(QUAD[Ind].result,"%d",Index);

Ind=pop();

sprintf(QUAD[Ind].result,"%d",Index); } | IFST ELSEST ;

IFST: IF '(' CONDITION ')'

strcpy(QUAD[Index].op,"==");

strcpy(QUAD[Index].arg1,$3);

strcpy(QUAD[Index].arg2,"FALSE");

strcpy(QUAD[Index].result,"-1");

push(Index);

Index++;

BLOCK {

strcpy(QUAD[Index].op,"GOTO");

strcpy(QUAD[Index].arg1,"");

strcpy(QUAD[Index].arg2,"");

strcpy(QUAD[Index].result,"-1");

push(Index);

Index++;

};

ELSEST: ELSE{

21
Experiment number:
Date:

tInd=pop();

Ind=pop();

push(tInd);

sprintf(QUAD[Ind].result,"%d",Index);

BLOCK{

Ind=pop();

sprintf(QUAD[Ind].result,"%d",Index);

};

CONDITION: VAR RELOP VAR {AddQuadruple($2,$1,$3,$$);

StNo=Index-1;

| VAR

| NUM

WHILEST: WHILELOOP{

Ind=pop();

sprintf(QUAD[Ind].result,"%d",StNo);

Ind=pop();

sprintf(QUAD[Ind].result,"%d",Index); }

WHILELOOP: WHILE '(' CONDITION ')' {

strcpy(QUAD[Index].op,"==");

strcpy(QUAD[Index].arg1,$3);

strcpy(QUAD[Index].arg2,"FALSE");

strcpy(QUAD[Index].result,"-1");

push(Index);

Index++;

22
Experiment number:
Date:

BLOCK {

strcpy(QUAD[Index].op,"GOTO");

strcpy(QUAD[Index].arg1,"");

strcpy(QUAD[Index].arg2,"");

strcpy(QUAD[Index].result,"-1");

push(Index);

Index++;

%%

extern FILE *yyin;

int main(int argc,char *argv[]) {

FILE *fp;

int i; if(argc>1){

fp=fopen(argv[1],"r");

if(!fp) {

printf("\n File not found");

exit(0);

yyin=fp;

yyparse();

printf("\n\n\t\t ----------------------------""\n\t\t Pos Operator Arg1 Arg2 Result" "\n\t\t -----------

---------"); for(i=0;i<Index;i++)

printf("\n\t\t %d\t %s\t %s\t %s\t

%s",i,QUAD[i].op,QUAD[i].arg1,QUAD[i].arg2,QUAD[i].result); } printf("\n\t\t --------------

23
Experiment number:
Date:

---------"); printf("\n\n"); return 0;

void push(int data)

{ stk.top++;

if(stk.top==100)

{ printf("\n Stack overflow\n");

exit(0);

stk.items[stk.top]=data;

} int pop()

{ int data;

if(stk.top==-1)

{ printf

("\n Stack underflow\n");

exit(0);}

data=stk.items[stk.top--];

return data;

} void AddQuadruple(char op[5],char arg1[10],char arg2[10],char result[10]) {

strcpy(QUAD[Index].op,op);

strcpy(QUAD[Index].arg1,arg1);

strcpy(QUAD[Index].arg2,arg2);

sprintf(QUAD[Index].result,"t%d",tIndex++);

strcpy(result,QUAD[Index++].result); }

yyerror()

printf("\n Error on line no:%d",LineNo);

Input:

24
Experiment number:
Date:

$vi test.c

main()

int a,b,c;

if(a<b)

a=a+b;

while(a<b)

a=a+b;

if(a<=b)

c=a-b;

else

c=a+b;

}case 1:

printf("Enter the old label\n");

scanf("%s",l);

printf("Enter the new label\n");

scanf("%s",nl);

s=search(l);

if(s==0)

25
Experiment number:
Date:

printf("NO such label");

else

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

if(strcmp(p->label,l)==0)

strcpy(p->label,nl);

p=p->next;

break;

case 2:

printf("Enter the label whose address is to modified\n");

scanf("%s",l);

printf("Enter the new address\n");

scanf("%d",&add);

s=search(l);

if(s==0)

printf("NO such label");

else

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

26
Experiment number:
Date:

if(strcmp(p->label,l)==0)

p->addr=add;

}}

p=p->next;

break;

case 3:

printf("Enter the old label : ");

scanf("%s",l);

printf("Enter the new label : ");

scanf("%s",nl);

printf("Enter the new address : ");

scanf("%d",&add);

s=search(l);

if(s==0)

printf("NO such label");

else

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

if(strcmp(p->label,l)==0)

strcpy(p->label,nl);

p->addr=add;

27
Experiment number:
Date:

p=p->next;

break;

void del()

int a;

char l[10];

struct symbtab *p,*q;

p=first;

printf("Enter the label to be deleted\n");

scanf("%s",l);

a=search(l);

if(a==0)

printf("Label not found\n");

else

if(strcmp(first->label,l)==0)

first=first->next;

else if(strcmp(last->label,l)==0)

28
Experiment number:
Date:

q=p->next;

while(strcmp(q->label,l)!=0)

p=p->next;

q=q->next;

p->next=null;

last=p;

else

q=p->next;

while(strcmp(q->label,l)!=0)

p=p->next;

q=q->next;

p->next=q->next;

size--;

29
Experiment number:
Date:

OUTPUT:

RESULT:

30
Experiment number:
Date:

4.Write program to find e-closure of all states of any given NFA with e-transitions

AIM: To write a program to find e-closure of all states of any given NFA with e-transitions

PROGRAM:

#include<stdio.h>

#include<string.h>

char result[20][20],copy[3],states[20][20];

void add_state(char a[3],int i){

strcpy(result[i],a);

void display(int n){

int k=0;

printf("nnn Epsilon closure of %s = { ",copy);

while(k < n){

printf(" %s",result[k]);

k++;

printf(" } nnn");

int main(){

FILE *INPUT;

INPUT=fopen("input.dat","r");

char state[3];

int end,i=0,n,k=0;

char state1[3],input[3],state2[3];

31
Experiment number:
Date:

printf("n Enter the no of states: ");

scanf("%d",&n);

printf("n Enter the states n");

for(k=0;k<3;k++){

scanf("%s",states[k]);

for( k=0;k<n;k++){

i=0;

strcpy(state,states[k]);

strcpy(copy,state);

add_state(state,i++);

while(1){

end = fscanf(INPUT,"%s%s%s",state1,input,state2);

if (end == EOF ){

break;

if( strcmp(state,state1) == 0 ){

if( strcmp(input,"e") == 0 ) {

add_state(state2,i++);

strcpy(state, state2);

display(i);

32
Experiment number:
Date:

rewind(INPUT);

return 0;

33
Experiment number:
Date:

OUTPUT:

RESULT:

34
Experiment number:
Date:

5.Write program to convert NFA with e to NFA without e transition

AIM: To write a program to convert NFA with e to NFA without e transition

PROGRAM:

#include<stdio.h>
#include<stdlib.h>
struct node
{
int st;
struct node *link;
};

void findclosure(int,int);
void insert_trantbl(int ,char, int);
int findalpha(char);
void findfinalstate(void);
void unionclosure(int);
void print_e_closure(int);
static int set[20],nostate,noalpha,s,notransition,nofinal,start,finalstate[20],c,r,buffer[20];
char alphabet[20];
static int e_closure[20][20]={0};
struct node * transition[20][20]={NULL};
void main()
{
int i,j,k,m,t,n;

struct node *temp;

printf("enter the number of alphabets?\n");
scanf("%d",&noalpha);
getchar();
printf("NOTE:- [ use letter e as epsilon]\n");

printf("NOTE:- [e must be last character ,if it is present]\n");

printf("\nEnter alphabets?\n");
for(i=0;i<noalpha;i++)
{

alphabet[i]=getchar();
getchar();
}
printf("Enter the number of states?\n");
scanf("%d",&nostate);
printf("Enter the start state?\n");
scanf("%d",&start);
printf("Enter the number of final states?\n");
scanf("%d",&nofinal);
printf("Enter the final states?\n");
for(i=0;i<nofinal;i++)
scanf("%d",&finalstate[i]);
printf("Enter no of transition?\n");
scanf("%d",&notransition);
printf("NOTE:- [Transition is in the form--> qno alphabet qno]\n",notransition);

35
Experiment number:
Date:

printf("NOTE:- [States number must be greater than zero]\n");

printf("\nEnter transition?\n");
for(i=0;i<notransition;i++)
{

scanf("%d %c%d",&r,&c,&s);
insert_trantbl(r,c,s);

printf("\n");

for(i=1;i<=nostate;i++)
{
c=0;
for(j=0;j<20;j++)

{
buffer[j]=0;
e_closure[i][j]=0;
}
findclosure(i,i);
}
printf("Equivalent NFA without epsilon\n");
printf("-----------------------------------\n");
printf("start state:");
print_e_closure(start);
printf("\nAlphabets:");
for(i=0;i<noalpha;i++)
printf("%c ",alphabet[i]);
printf("\n States :" );
for(i=1;i<=nostate;i++)
print_e_closure(i);

printf("\nTnransitions are...:\n");

for(i=1;i<=nostate;i++)
{

for(j=0;j<noalpha-1;j++)
{
for(m=1;m<=nostate;m++)
set[m]=0;
for(k=0;e_closure[i][k]!=0;k++)
{

t=e_closure[i][k];
temp=transition[t][j];
while(temp!=NULL)
{

unionclosure(temp->st);
temp=temp->link;

36
Experiment number:
Date:

}
}
printf("\n");
print_e_closure(i);
printf("%c\t",alphabet[j] );
printf("{");
for(n=1;n<=nostate;n++)
{
if(set[n]!=0)
printf("q%d,",n);
}
printf("}");
}
}
printf("\n Final states:");
findfinalstate();

void findclosure(int x,int sta)

{
struct node *temp;
int i;
if(buffer[x])
return;
e_closure[sta][c++]=x;
buffer[x]=1;
if(alphabet[noalpha-1]=='e' && transition[x][noalpha-1]!=NULL)
{
temp=transition[x][noalpha-1];
while(temp!=NULL)
{
findclosure(temp->st,sta);
temp=temp->link;
}
}
}

void insert_trantbl(int r,char c,int s)

{
int j;
struct node *temp;
j=findalpha(c);
if(j==999)
{
printf("error\n");
exit(0);
}
temp=(struct node *) malloc(sizeof(struct node));
temp->st=s;
temp->link=transition[r][j];

37
Experiment number:
Date:

transition[r][j]=temp;
}

int findalpha(char c)
{
int i;
for(i=0;i<noalpha;i++)
if(alphabet[i]==c)
return i;

return(999);

void unionclosure(int i)
{
int j=0,k;
while(e_closure[i][j]!=0)
{
k=e_closure[i][j];
set[k]=1;
j++;
}
}
void findfinalstate()
{
int i,j,k,t;
for(i=0;i<nofinal;i++)
{
for(j=1;j<=nostate;j++)
{
for(k=0;e_closure[j][k]!=0;k++)
{
if(e_closure[j][k]==finalstate[i])
{

print_e_closure(j);
}
}
}
}

void print_e_closure(int i)
{
int j;
printf("{");
for(j=0;e_closure[i][j]!=0;j++)
printf("q%d,",e_closure[i][j]);
printf("}\t");
}

38
Experiment number:
Date:

OUTPUT:

RESULT:

39
Experiment number:
Date:

6. Write program to convert NFA to DFA

AIM: To write a program to convert NFA to DFA

PROGRAM:

#include<iostream.h>
#include<string.h>
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
char nfa[50][50],s[20],st[10][20],eclos[20],input[20];
int x,e,top=0,topd=0,n=0,ns,nos,in;
int checke(char a)
{
int i;
for(i=0;i<e;i++)
{
if(eclos[i]==a)
return i;
}
return -1;
}
int check(char a)
{
int i;
for(i=0;i<in;i++)
{
if(input[i]==a)
return i;
}
return -1;
}
void push(char a)
{
s[top]=a;
top++;
}
char pop()
{
top--;
return s[top];
}
void pushd(char *a)
{
strcpy(st[topd],a);
topd++;
}

40
Experiment number:
Date:

char *popd()
{
topd--;
return st[topd];
}
int ctoi(char a)
{
int i=a-48;
return i;
}
char itoc(int a)
{
char i=a+48;
return i;
}
char *eclosure(char *a)
{
int i,j;
char c;
for(i=0;i<strlen(a);i++)
push(a[i]);
e=strlen(a);
strcpy(eclos,a);
while(top!=0)
{
c=pop();
for(j=0;j<ns;j++)
{
if(nfa[ctoi(c)][j]=='e')
{
if(check(itoc(j))==-1)
{
eclos[e]=itoc(j);
push(eclos[e]);
e++;
}
}
}
}
eclos[e]='\0';
return eclos;
}

void main()
{
int i,j,k,count;

41
Experiment number:
Date:

char ec[20],a[20],b[20],c[20],dstates[10][10];
clrscr();
cout<<"Enter the number of states"<<endl;
cin>>ns;
for(i=0;i<ns;i++)
{
for(j=0;j<ns;j++)
{
cout<<"Move["<<i<<"]["<<j<<"]";
cin>>nfa[i][j];
if(nfa[i][j]!='-'&&nfa[i][j]!='e')
{
if((check(nfa[i][j]))==-1)
input[in++]=nfa[i][j];
}
}
}
topd=0;
nos=0;
c[0]=itoc(0);
c[1]='\0';
pushd(eclosure(c));
strcpy(dstates[nos],eclosure(c));
for(x=0;x<in;x++)
cout<<"\t"<<input[x];
cout<<"\n";
while(topd>0)
{
strcpy(a,popd());
cout<<a<<"\t";
for(i=0;i<in;i++)
{
int len=0;
for(j=0;j<strlen(a);j++)
{
int x=ctoi(a[j]);
for(k=0;k<ns;k++)
{
if(nfa[x][k]==input[i])
ec[len++]=itoc(k);
}
}
ec[len]='\0';
strcpy(b,eclosure(ec));
count=0;
for(j=0;j<=nos;j++)
{

42
Experiment number:
Date:

if(strcmp(dstates[j],b)==0)
count++;
}
if(count==0)
{
if(b[0]!='\0')
{
nos++;
pushd(b);
strcpy(dstates[nos],b);
}
}
cout<<b<<"\t";
}
cout<<endl;
}
getch();
}

43
Experiment number:
Date:

OUTPUT:

RESULT:

44
Experiment number:
Date:

7.Write program to minimize any given DFA

AIM: To write a program to minimize any given DFA

PROGRAM:

#include

#include

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

45
Experiment number:
Date:

int nos,noi,nof,j,k,nods=-1;

void pushA(int z)

stackA[++Aptr]=z;

void pushB(int z)

stackB[++Bptr]=z;

int popA()

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

46
Experiment number:
Date:

int popB()

return stackB[Bptr--];

int peekA()

return stackA[Aptr];

int peekB()

return stackA[Bptr];

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;

for(i=0;i<bptr;i++)< span="" style="box-sizing: border-box;">

47
Experiment number:
Date:

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

48
Experiment number:
Date:

printf("\n\t\t ---------------------------------------------- ");

printf("\n States \tString \tInputs\n");

for(i=0;i<noi;i++)< span="" style="box-sizing: border-box;">

printf("\t %c",inp[i]);

printf("\n\t ------------------------------------------------- ");

for(i=0;i<nods;i++)< span="" style="box-sizing: border-box;">

if(Dstates[i].is_final==0)

printf("\n%c",Dstates[i].name);

else

printf("\n*%c",Dstates[i].name);

printf("\t%s",Dstates[i].StateString);

for(j=0;j<noi;j++)< span="" style="box-sizing: border-box;">

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)< span="" style="box-sizing: border-box;">

pushA(States[st].tranlist[j].tostates[ctr++]);

49
Experiment number:
Date:

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

void main()

int i,final[20],start,fin=0;

char c,ans,st[20];

50
Experiment number:
Date:

printf("\n Enter no of states in NFA:");

scanf("%d",&nos);

for(i=0;i<nos;i++)< span="" style="box-sizing: border-box;">

{

States[i].no=i;

printf("\n Enter the start states:");

scanf("%d",&start);

printf("Enter the no of final states:");

scanf("%d",&nof);

printf("Enter the final states:\n");

for(i=0;i<nof;i++)< span="" style="box-sizing: border-box;">

scanf("%d",&final[i]);

printf("\n Enter the no of input symbols:");

scanf("%d",&noi);

c=getchar();

printf("Enter the input symbols:\n");

for(i=0;i<noi;i++)< span="" style="box-sizing: border-box;">

scanf("%c",&inp[i]);

c=getchar();

//g1inp[i]='e';

inp=[i]=’e’;

printf("\n Enter the transitions:(-1 to stop)\n");

for(i=0;i<nos;i++)< span="" style="box-sizing: border-box;">

51
Experiment number:
Date:

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

k--;

ans='n';

break;
}

States[i].tranlist[j].notran=k;

}
}

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)< span="" style="box-sizing: border-box;">

52
Experiment number:
Date:

for(j=0;j<noi;j++)< span="" style="box-sizing: border-box;">

fin=0;
copy(i);
while(Bptr!=-1)

move(popB(),j);

while(Aptr!=-1)

lambda_closure(peekA());

tostring();

for(k=0;k<nods;k++)< span="" style="box-sizing: border-box;">

{
if((strcmp(temp,Dstates[k].StateString)==0))
{
Dstates[i].trans[j]=Dstates[k].name;
break;
}
}
if(k==nods)
{
nods++;

for(k=0;k<nof;k++)< span="" style="box-sizing: border-box;">

{
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();
#include

53
Experiment number:
Date:

#include

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

54
Experiment number:
Date:

int popA()

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 peekA()

return stackA[Aptr];

int peekB()

return stackA[Bptr];

int seek(int arr[],int ptr,int s)

55
Experiment number:
Date:

int i;

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

if(s==arr[i])

return 1;

return 0;

void sort()

int i,j,temp;

for(i=0;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++)

56
Experiment number:
Date:

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("\n States \tString \tInputs\n");

for(i=0;i

printf("\t %c",inp[i]);

printf("\n\t ------------------------------------------------- ");

for(i=0;i

if(Dstates[i].is_final==0)

printf("\n%c",Dstates[i].name);

else

printf("\n*%c",Dstates[i].name);

printf("\t%s",Dstates[i].StateString);

for(j=0;j

printf("\t%c",Dstates[i].trans[j]);

printf("\n");

void move(int st,int j)

57
Experiment number:
Date:

int ctr=0;

while(ctr

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

void main()

int i,final[20],start,fin=0;

char c,ans,st[20];

printf("\n Enter no of states in NFA:");

58
Experiment number:
Date:

scanf("%d",&nos);

for(i=0;i

States[i].no=i;

printf("\n Enter the start states:");

scanf("%d",&start);

printf("Enter the no of final states:");

scanf("%d",&nof);

printf("Enter the final states:\n");

for(i=0;i

scanf("%d",&final[i]);

printf("\n Enter the no of input symbols:");

scanf("%d",&noi);

c=getchar();

printf("Enter the input symbols:\n");

for(i=0;i

scanf("%c",&inp[i]);

c=getchar();

//g1inp[i]='e';

inp=[i]=’e’;

printf("\n Enter the transitions:(-1 to stop)\n");

for(i=0;i

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

States[i].tranlist[j].sym=inp[j];

k=0;

ans='y';

59
Experiment number:
Date:

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

k--;

ans='n';

break;

States[i].tranlist[j].notran=k;

i=0;nods=0,fin=0;

pushA(start);

lambda_closure(peekA());

tostring();

Dstates[nods].name='A';

nods++;

strcpy(Dstates[0].StateString,temp);

while(i

for(j=0;j

fin=0;

copy(i);

while(Bptr!=-1)

move(popB(),j);

60
Experiment number:
Date:

while(Aptr!=-1)

lambda_closure(peekA());

tostring();

for(k=0;k

if((strcmp(temp,Dstates[k].StateString)==0))

Dstates[i].trans[j]=Dstates[k].name;

break;

if(k==nods)

nods++;

for(k=0;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();

61
Experiment number:
Date:

OUTPUT:

62
Experiment number:
Date:

RESULT:

8. Develop an operator precedence parser for a given language

AIM: To write a program to develop an operator precedence parser for a given language

PROGRAM:

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

char *input;
int i=0;
char lasthandle[6],stack[50],handles[][5]={")E(","E*E","E+E","i","E^E"};
//(E) becomes )E( when pushed to stack

int top=0,l;
char prec[9][9]={

/*input*/

/*stack + - * / ^ i ( ) $ */

/* + */ '>', '>','<','<','<','<','<','>','>',

/* - */ '>', '>','<','<','<','<','<','>','>',

/* * */ '>', '>','>','>','<','<','<','>','>',

/* / */ '>', '>','>','>','<','<','<','>','>',

/* ^ */ '>', '>','>','>','<','<','<','>','>',

/* i */ '>', '>','>','>','>','e','e','>','>',

63
Experiment number:
Date:

/* ( */ '<', '<','<','<','<','<','<','>','e',

/* ) */ '>', '>','>','>','>','e','e','>','>',

/* $ */ '<', '<','<','<','<','<','<','<','>',

};

int getindex(char c)
{
switch(c)
{
case '+':return 0;
case '-':return 1;
case '*':return 2;
case '/':return 3;
case '^':return 4;
case 'i':return 5;
case '(':return 6;
case ')':return 7;
case '$':return 8;
}
}

int shift()
{
stack[++top]=*(input+i++);
stack[top+1]='\0';
}

int reduce()
{
int i,len,found,t;
for(i=0;i<5;i++)//selecting handles

64
Experiment number:
Date:

{
len=strlen(handles[i]);
if(stack[top]==handles[i][0]&&top+1>=len)
{
found=1;
for(t=0;t<len;t++)
{
if(stack[top-t]!=handles[i][t])
{
found=0;
break;
}
}
if(found==1)
{
stack[top-t+1]='E';
top=top-t+1;
strcpy(lasthandle,handles[i]);
stack[top+1]='\0';
return 1;//successful reduction
}
}
}
return 0;
}
void dispstack()
{
int j;
for(j=0;j<=top;j++)
printf("%c",stack[j]);
}
void dispinput()
{
int j;
for(j=i;j<l;j++)
printf("%c",*(input+j));

65
Experiment number:
Date:

}
void main()
{
int j;
input=(char*)malloc(50*sizeof(char));
printf("\nEnter the string\n");
scanf("%s",input);
input=strcat(input,"$");
l=strlen(input);
strcpy(stack,"$");
printf("\nSTACK\tINPUT\tACTION");
while(i<=l)
{
shift();
printf("\n");
dispstack();
printf("\t");
dispinput();
printf("\tShift");
if(prec[getindex(stack[top])][getindex(input[i])]=='>')
{
while(reduce())
{
printf("\n");
dispstack();
printf("\t");
dispinput();
printf("\tReduced: E->%s",lasthandle);
}
}
}
if(strcmp(stack,"$E$")==0)
printf("\nAccepted;");
else
printf("\nNot Accepted;");
}

66
Experiment number:
Date:

OUTPUT:

67
Experiment number:
Date:

RESULT:

9.Write program to find simulate first and follow of any given grammar

AIM: To write program to find simulate first and follow of any given grammar

PROGRAM:

#include<stdio.h>
#include<ctype.h>
void FIRST(char );
int count,n=0;
char prodn[10][10], first[10];
main()
{
int i,choice;
char c,ch;
printf("How many productions ? :");
scanf("%d",&count);
printf("Enter %d productions epsilon= $ :\n\n",count);
for(i=0;i<count;i++)
scanf("%s%c",prodn[i],&ch);
do
{
n=0;
printf("Element :");
scanf("%c",&c);
FIRST(c);
printf("\n FIRST(%c)= { ",c);
for(i=0;i<n;i++)
printf("%c ",first[i]);
printf("}\n");
printf("press 1 to continue : ");
scanf("%d%c",&choice,&ch);

68
Experiment number:
Date:

}
while(choice==1);
}
void FIRST(char c)
{
int j;
if(!(isupper(c)))first[n++]=c;
for(j=0;j<count;j++)
{
if(prodn[j][0]==c)
{
if(prodn[j][2]=='$') first[n++]='$';
else if(islower(prodn[j][2]))first[n++]=prodn[j][2];
else FIRST(prodn[j][2]);
}
}
}

69
Experiment number:
Date:

OUTPUT:

70
Experiment number:
Date:

RESULT:

10.Construct a recursive descent parser for an expression

AIM:To write a program to construct a recursive descent parser for an expression

PROGRAM:

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

char input[10];
int i,error;
void E();
void T();
void Eprime();
void Tprime();
void F();
main()
{
i=0;
error=0;
printf("Enter an arithmetic expression : ");

// Eg: a+a*a
gets(input);
E();
if(strlen(input)==i&&error==0)
printf("\nAccepted..!!!\n");
else printf("\nRejected..!!!\n");
}

71
Experiment number:
Date:

void E()
{
T();
Eprime();
}
void Eprime()
{
if(input[i]=='+')
{
i++;
T();
Eprime();
}
}
void T()
{
F();
Tprime();
}
void Tprime()
{
if(input[i]=='*')
{
i++;
F();
Tprime();
}
}
void F()
{
if(isalnum(input[i]))i++;
else if(input[i]=='(')
{
i++;
E();
if(input[i]==')')

72
Experiment number:
Date:

i++;

else error=1;
}

else error=1;
}

OUTPUT:

73
Experiment number:
Date:

RESULT:

11.Construct a shift reduce parser for an expression

AIM:To write a program to construct a shift reduce parser for an expression

PROGRAM:

#include<stdio.h>
#include<iostream.h>
#include<ctype.h>
#include<string.h>
#include<conio.h>
struct stru1
{
char non_ter[1],pro[25];
}cfg[25];
int n,st=-1,j,i,t=-1,m;
int v,c,p=1;
char str[20],stack[20],ch,tmp[10];
void match(int k);
void matchl(int k);
void main()
{
clrscr();
cprintf("Enter the number of productions:\n\r");
cscanf("%d",&n);
cprintf("\n\r");
cprintf("Enter the productions on LEFT and RIGHT sides:\n\r");

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

74
Experiment number:
Date:

{
cscanf("%s",cfg[i].non_ter);
cprintf("\n\r");
cprintf("->\n\r");
cscanf("%s",cfg[i].pro);
cprintf("\n\r");
}
cprintf("Enter the input string:\n\r");
cscanf("%s",str);
cprintf("\n\r");
i=0;
do
{
ch=str[i];
stack[++st]=ch;
tmp[0]=ch;
match(1);
i++;
}while(str[i]!='\0');
c=st;
v=st;
cputs(stack);
cprintf("\n\r");
while(st!=0)
{
v=--st;
t=-1;
p=0;
while(v<=c)
{
tmp[++t]=stack[v++];
p++;
}
matchl(p);
}
cfg[0].non_ter[1]='\0';

75
Experiment number:
Date:

if(strcmp(stack,cfg[0].non_ter)==0)
cprintf("String is present in Grammar G\n\r");
else
cprintf("String is not present in Grammar G\n\r");
}

void match(int k)
{
for(j=0;j<n;j++)
{
if(strlen(cfg[j].pro)==k)
{
if(strcmp(tmp,cfg[j].pro)==0)
{
stack[st]=cfg[j].non_ter[0];
break;
}
}
}
}
void matchl(int k)
{
int x=1,y;
y=k-1;
for(j=0;j<n;j++)
{
if(strlen(cfg[j].pro)==k)
{
if(strcmp(tmp,cfg[j].pro)==0)
{
k=c-k+1;
stack[k]=cfg[j].non_ter[0];
do
{
stack[k+x]='\0';
tmp[t--]='\0';

76
Experiment number:
Date:

c--;
x++;
}while(x<=y);
tmp[t]='\0';
cputs(stack);
cprintf("\n\r");
break;
}
}
}
}

77
Experiment number:
Date:

OUTPUT:

78
Experiment number:
Date:

RESULT:

12.Write a program to perform loop unrolling

AIM: To write a program to perform loop unrolling

PROGRAM:

#include<stdio.h>

int main(void)
{
for (int i=0; i<5; i++)
printf("Hello\n");

return 0;
}

79
Experiment number:
Date:

OUTPUT:

80
Experiment number:
Date:

RESULT:

13.Write a program to perform constant propagation

AIM:To write a program to perform constant propagation

PROGRAM:

#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<conio.h>
void input();
void output();
void change(int p,char *res);
void constant();
struct expr
{
char op[2],op1[5],op2[5],res[5];
int flag;
}arr[10];
int n;
void main()
{
clrscr();
input();
constant();
output();
getch();
}
void input()

81
Experiment number:
Date:

{
int i;
printf("\n\nEnter the maximum number of expressions : ");
scanf("%d",&n);
printf("\nEnter the input : \n");
for(i=0;i<n;i++)
{
scanf("%s",arr[i].op);
scanf("%s",arr[i].op1);
scanf("%s",arr[i].op2);
scanf("%s",arr[i].res);
arr[i].flag=0;
}
}
void constant()
{
int i;
int op1,op2,res;
char op,res1[5];
for(i=0;i<n;i++)
{
if(isdigit(arr[i].op1[0]) && isdigit(arr[i].op2[0]) || strcmp(arr[i].op,"=")==0) /*if both digits, store
them in variables*/
{
op1=atoi(arr[i].op1);
op2=atoi(arr[i].op2);
op=arr[i].op[0];
switch(op)
{
case '+':
res=op1+op2;
break;
case '-':
res=op1-op2;
break;
case '*':

82
Experiment number:
Date:

res=op1*op2;
break;
case '/':
res=op1/op2;
break;
case '=':
res=op1;
break;
}
sprintf(res1,"%d",res);
arr[i].flag=1; /*eliminate expr and replace any operand below that uses result of this expr */
change(i,res1);
}
}
}
void output()
{
int i=0;
printf("\nOptimized code is : ");
for(i=0;i<n;i++)
{
if(!arr[i].flag)
{
printf("\n%s %s %s %s",arr[i].op,arr[i].op1,arr[i].op2,arr[i].res);
}
}
}
void change(int p,char *res)
{
int i;
for(i=p+1;i<n;i++)
{
if(strcmp(arr[p].res,arr[i].op1)==0)
strcpy(arr[i].op1,res);
else if(strcmp(arr[p].res,arr[i].op2)==0)
strcpy(arr[i].op2,res);

83
Experiment number:
Date:

}
}

OUTPUT:

84
Experiment number:
Date:

RESULT:

14. Implementation Intermediate code generation for simple expression

AIM: To implementation intermediate code generation for simple expression

PROGRAM:

#include<stdio.h>
#include<conio.h>
#include<string.h>
char op[2],arg1[5],arg2[5],result[5];
void main()
{
FILE *fp1,*fp2;
fp1=fopen("input.txt","r");
fp2=fopen("output.txt","w");
while(!feof(fp1))
{

fscanf(fp1,"%s%s%s%s",op,arg1,arg2,result);
if(strcmp(op,"+")==0)
{
fprintf(fp2,"\nMOV R0,%s",arg1);
fprintf(fp2,"\nADD R0,%s",arg2);
fprintf(fp2,"\nMOV %s,R0",result);
}
if(strcmp(op,"*")==0)
{

85
Experiment number:
Date:

fprintf(fp2,"\nMOV R0,%s",arg1);
fprintf(fp2,"\nMUL R0,%s",arg2);
fprintf(fp2,"\nMOV %s,R0",result);
}
if(strcmp(op,"-")==0)
{
fprintf(fp2,"\nMOV R0,%s",arg1);
fprintf(fp2,"\nSUB R0,%s",arg2);
fprintf(fp2,"\nMOV %s,R0",result);
}
if(strcmp(op,"/")==0)
{
fprintf(fp2,"\nMOV R0,%s",arg1);
fprintf(fp2,"\nDIV R0,%s",arg2);
fprintf(fp2,"\nMOV %s,R0",result);
}
if(strcmp(op,"=")==0)
{
fprintf(fp2,"\nMOV R0,%s",arg1);
fprintf(fp2,"\nMOV %s,R0",result);
}
}
fclose(fp1);
fclose(fp2);
getch();
}
}

86
Experiment number:
Date:

OUTPUT:

87
Experiment number:
Date:

RESULT:

88