University Institute of Technology

Rajiv Gandhi Proudyogiki Vishwavidyalaya

Bhopal

(SESSION 2011-2012)
DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

Practical File: Compiler Design

Submitted to Submitted By:

Mr. Mahesh Parmar Manish Kumar
Chouriya
Roll No. 0101cs081025
 INDEX
PAGE EXPERIMENT DATE REMARK
1. Write a Program for lexical Analyzer.

2. Write a Program for Syntax Analyzer.

3. Develop a recursive descent parser.

4. Write a program for generating quadruples form and triples

form for various intermediate code forms.

5. Write a program to generate the intermediate code in the form

of polish notation.

6. Write a program to perform operations on stack.

7. Write a program to calculate the first and follow of the given

grammar.

8. Write a program to simulate heap storage allocation strategy.

9. Given any intermediate code form implement code

optimization techniques.

10. Write a lex program to convert the substring abc to ABC from
the given input string.

11. Write a lex program to find out total number of vowels and
consonants from the given input string.

12. Write a lex program to identify the capital strings from the
given input string.

2
1) Write a Program for lexical Analyzer.

Solution:-

#include<iostream.h>
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main ()
{
int id=0,addop=0,subop=0,multop=0,divop=0,semicolon=0,number=0,assignop=0;
char *ptr;
clrscr();
cout<<"\t\t\t*************LEXICAL ANALYSER**************\t\t\t";
cout<<"\nEnter The Expression: ";
gets(ptr);
cout<<endl;
while(*ptr!='\0')
{
if((*ptr>=48)&&(*ptr<=57))
{
while((*ptr>=48)&&(*ptr<=57))
{
ptr++;}
printf("");
number=number+1;
}
if((*ptr>=65)&&(*ptr<=90)||(*ptr>=97)&&(*ptr<=122))
{
while((*ptr>=65)&&(*ptr<=90)||(*ptr>=97)&&(*ptr<=122)||(*ptr>=48)&&(*ptr<=57
))
{
ptr++;}
id++;
}
if(*ptr==61)
{
printf("%c Assignment\n",*ptr);
assignop++;}
if(*ptr==43)
{
printf("%c Add\n",*ptr);
addop++;

3
 }
if(*ptr==45)
{
printf("%c Subtract\n",*ptr);
subop++;
}
if(*ptr==42)
{printf("%c Multiplication\n",*ptr);
multop++;
}
if(*ptr==47)
{
printf("%c Divide\n",*ptr);
divop++;
}
if(*ptr==59)
{printf("%c semicolon\n",*ptr);
semicolon++;
}
ptr++;
}
cout<<ptr;
printf("\n The Given Expression Contains Following Operations : \n\n Identifier: %d\n
Number: %d\n Add Operation: %d\n Multiplication Operation: %d\n Assignment
Operation: %d\n Semicolon: %d\n Divide Operation: %d\n Substract Operation:
%d",id,number,addop,multop,assignop,semicolon,divop,subop);
getch();
}

Output:-

*************LEXICAL ANALYSER**************

Enter the Expression: A=b*c+d

= Assignment
* Multiplication
+ Add

The Given Expression Contains Following Operations:

Identifier: 4

4
Number: 0
Add Operation: 1
Multiplication Operation: 1
Assignment Operation: 1
Semicolon: 0
Divide Operation: 0
Substract Operation: 0

5
2) Write a Program for Syntax Analyzer.

Solution:-

#include<iostream.h>
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<process.h>
void main()
{
int ans,i;

char*all_key[]={"int","char","float","double","auto","const","default","extern","far","
long","near","register","short","signed","static","unsigned","void","break","case","co
ntinue","do","else","enum","for","goto","if","return","struct","switch","typedef","un
ion","while"};
char input_key[10];
clrscr();
cout<<"Enter the keyword:";
cin>>input_key;

for(i=0;i<32;i++)
{
ans=strcmp(input_key,all_key[i]);
if(ans==0)
{
cout<<"Correct keyword";
getch();
exit(0);
}
}
cout<<"\n incorrect keyword!!";
getch();
exit(0);
}

Output:-

Enter the keyword: float

Correct keyword

6
3) Develop a Recursive Descent Parser.

Solution:-

#include<stdio.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>
#define SIZE 128
#define NONE -1
#define EOS ‘\0’
#define NUM 257
#define KEYWORD 258
#define ID 259
#define DONE 260
#define MAX 999
char !exemes[MAX];
char buffer[SIZE];
int lastchar = -1;
int lastentry = 0;
int tokenval=DONE;
int lineno=1;
int lookahead;
struct entry{
char *lexptr;
int token;
}symtable[100];
struct entry keywords[ ]=
{“if”,KEYWORD,”else”,KEYWORD,
“for”,KEYWORD,
“int”,KEYWORD,”float”,KEYWORD,”double”,KEYWORD,”char”,KEYWORD,
“struct”,KEYWORD,
“return”,KEYWORD,
0,0};
Void Error_Message(char *m)
{
fprintf(stderr, ”line %d: %s \n”, lineno,m));
exit(1);
}
int look_up(char s[ ])
{
int k;

7
for(k=lastentry;k.>0;k=k-1)
if(strcmp(symtable[k].lexptr,s)= =0)
return k;
return 0;
}
{
int len;
len = strlen (s);
if(lastentry+1> = MAX)
error_message(“symbol table is full”)’
if (lastchar + len +1 = MAX )
error_message(“lexemes array is full”);
lastentry = lastentry +1;
symtable[lastentry].token = toksymtable[lastentry].lexptr = & lexemes [lastchar + 1];
lastchar = lastchar + len + 1;
strcpy(symtable[lastentry].lexptr,s);
return lastentry;
}
void initialize()
{
struct entry *ptr;
for(ptr = keywords;ptr->token;ptr++)
insert(ptr->[Link]->token);
}
int lexer()
{
int t;
int val, i = 0;
while(1)
{
t= getchar();
if(t = = ‘ ‘|| t = = ‘\t’)

else if (t= = ‘\n’)

lineno = lineno=1;
else if (isdigit(t))
{
ungetc(t,stdin);
scanf(“%d”,& tokenval);
return NUM;
}
else if(isalpha(t))
{

8
while(isalnum(t))
{
buffer[i] = t;
t = getchar();
i = i+1;
if(i> =SIZE) error_message(“compiler error”);

}
buffer[i]=EOS;
if (t! = EOF)
ungetc(t,stdin);
val = look_up(buffer);
if(val = =0) val = insert(buffer,ID);
tokenval = val;
return symtable[val].token;
}
else if(t= =EOF)
return DONE;
else
{
tokenval= NONE’
return t;
}
}
}
void match(int t)
{
if(lookahead= =t)
lookahead=lexer();
else
error_message(“syntax error”);
}
void display(int t,int tvl)
{
if(t = =’+’!!t= =’-’!!t= =’*’!!t= =’/’)
printf(“\n Arithmatic Operater :%c”,t);
else if(t==NUM)
printf(“\n Mumber : %d”,tval);
else if(t==ID)
printf(“\n Identifier : %s”,symtable[tval].lexptr);
else
printf(“\n token %d tokenval %d”,t,tokenval);
}

9
void F()
{
void E( );
switch(lookahead)
{
case’(‘:
Match(‘(‘);
E( );
Match(‘)’);
break;
case NUM:
display(NUM,tokenval);
Match(NUM);
break;
case ID:
display(ID,tokenval);
Match(ID);
break;
default:
Error_Message(“Syntax Error”);
}
}
void t( )
{
int t;
F();
While(1)
{
Switch(lookahead)
{
case’*’:t=lookahead;
Match(lookahead);
F();
Display(t,NONE);
continue;
case’/’:t=lookahead;
Match(lookahead);
F();
display(t,NONE);
continue;
default;
return;
}

10
}
}
void E()
{
int t;
T();
while(1)
{
switch(lookahead)
{
Case’+:t =lookahead;
Match(lookahead);
T();
display([Link]);
continue;
case'-':t=lookahead;
Match(lookahead);
T();
display([Link]);
continue;
default:
return;
}
}
}
void parser()
{
lookahead=lexer();
while(lookahead!=DONE)
{
E();
Match(';');
}
}

void main()
{
char ans;
clrscr();
printf("\n\t\t Program for Recursive Descent Parsing \n\n");
Initialize();
printf("\n Enter the expression ");
printf("And place ;at the end");

11
 printf("\nPress cntrl Z to terminate...\n");
parser();
}

Output:-

Program For recursive Descent parsing

Enter the expression And place ;at the end

Press Cntrl Zto terminate...
2+3*4;

Number:2
Number:3
Number:4
Arithmetic Operator: *
Arithmetic Operator: +
2+3*4+5;

Number:2
Number:3
Number:4
Arithmetic Operator: *
Arithmetic Operator: +
Number:5
Arithmetic Operator: +
a-b;

Indentifier: a
Indentifier: b

Arithmetic Operator: -
+1;
line 7: Syntax Error

12
4) Write a program for generating quadruples form and triples form for
various intermediate code forms.

Solution:-

#include<iostream.h>
#include<conio.h>
#include<string.h>
void main()
{
clrscr();
char arr[10][10],a[10][10];
int i,n,x[10];
cout<<"Enter the No. of Strings:";
cin>>n;
for(i=0;i<n;i++)
{
cout<<"Enter the "<<i+1<<"String:";
cin>>arr[i];
}
for(i=0;i<n;i++)
{
x[i]=strlen(arr[i]);
if(x[i]>4)
{
a[i][0]=arr[i][0];
a[i][1]=arr[i][3];
a[i][2]=arr[i][2];
a[i][3]=arr[i][4];
}
else
{
a[i][0]=arr[i][0];
a[i][1]=arr[i][1];
a[i][2]=arr[i][2];
}}
cout<<"The Quadrapules are:";
for(i=0;i<n;i++)
{
cout<<"\n"<<a[i][0];
cout<<"\t"<<a[i][1];
cout<<"\t"<<a[i][2];
cout<<"\t"<<a[i][3];

13
 cout<<"\n";
}
if(x[i]>4)
{
a[i][0]=arr[i][3];
a[i][1]=arr[i][2];
a[i][2]=arr[i][4];
}
else
{
a[i][0]=arr[i][1];
a[i][1]=i-1;
}
cout<<"the Triples are:";
for(i=0;i<n;i++)
{
cout<<"\n"<<a[i][0];
cout<<"\t"<<a[i][1];
cout<<"\t"<<a[i][2];
cout<<"\n";
}
getch();
}

Output:-

Enter the No. of Strings:2

Enter the 1 String:t=a+b
Enter the 2 String:c=t
The Quadrapules are:
t + a b

c = t
the Triples are:
+ a b

= t

14
5) Write a program to generate the intermediate code in the form of polish notation.

Solution:-

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
struct stack
{
char s[30];
int top;
}st;
void main()
{
char input[30];
void input_to_code(char infix[30]);
clrscr();
prntf("\n Enter an input in the form of expression");
scanf("%s",input);
input_to_code(input);
getch();
}
void input_to_code(char input[30])
{
[Link]=-1;
st.s[[Link]]=’$’;
char polish[30];
int I,j;
char ch;
int instack(char ch);
int incoming(char ch);
void push(char item);
char pop();
j=0;
strrev(input);
for(i=0;input[i]!=’\0’;i++)
{
ch=input[i];
while(instack(st.s[[Link]])>incoming(ch))
{

15
polish[j]=pop();
j++;
}
If(instack(st.s[[Link]])!-incoming(ch))
push(ch);
else
pop();
}
while((ch=pop())!=’$’)
{
polish[j]=ch;
j++;
}
polish[j]=’\0’;
strrev(polish);
printf(“\n The polish notation is %s”,polish);
}
int instack(char ch)
{
int priority;
switch(ch)
{
case')':priority=0;
break;
case'+':
case'-':priority=1;
break;
case'*':
case'/':priority=3;
break;
case'^':priority=6;
break;
case'$':priority=-1;
break;
default:priority=8;//when it is operand
break;
}
return priority;
}
int incoming(char ch)
{
int priority;
switch(ch)

16
 {
case'+':
case'-':priority=2;
break;
case'*':
case'/':priority=4;
break;
case'^':priority=5;
break;
case'(':priority=0;
break;
case')':priority=9;
break;
default:priority=7://when it is operand
}
return priority;
}
void push(char item)
{
[Link]++;
st.s[[Link]]=item;
}
char pop
{
char e;
e=st.s[[Link]];
[Link]--;
return e;
}

Output:-

Enter an input in the form of expression (a+b)*(c-d)

The polish notation is *+ab-cd

17
6) Write a program to perform operations on stack.

Solution:-

# include<iostream.h>
# include<process.h>
# include<conio.h>
# define SIZE 20

class stack
{
int a[SIZE];
int tos; // Top of Stack
public:
stack();
void push(int);
int pop();
int isempty();
int isfull();
};
stack::stack()
{
tos=0; //Initialize Top of Stack
}

int stack::isempty()
{
return (tos==0?1:0);
}
int stack::isfull()
{
return (tos==SIZE?1:0);
}

void stack::push(int i)
{
if(!isfull())
{
a[tos]=i;
tos++;
}
else
{

18
cout<<"Stack overflow error ! Possible Data Loss !";
}
}
int stack::pop()
{
if(!isempty())
{
return(a[--tos]);
}
else
{
cout<<"Stack is empty! What to pop...!";
}
return 0;
}

void main()
{
clrscr();
stack s;
int ch=1,num;
while(ch!=0)
{
cout<<"Stack Operations Maim Men\n [Link]\n [Link]\n [Link] \n [Link] \n
[Link]";

cin>>ch;
switch(ch)
{
case 0:
exit(1); //Normal Termination of Program
case 1:
cout<<"Enter the number to push";
cin>>num;
[Link](num);
break;
case 2:
cout<<"Number popped from the stack is: "<<[Link]()<<endl;
break;
case 3:
([Link]())?(cout<<"Stack is empty."):(cout<<"Stack is not empty.");
break;
case 4:

19
 ([Link]())?(cout<<"Stack is full."):(cout<<"Stack is not full.");
break;
default:
cout<<"Illegal [Link] try again";
}
}//end of while
getch();}

Output:-

Stack Operations Main Menu

[Link]
[Link]
[Link]
[Link]
[Link]
1
Enter the number to push4
Stack Operations Main Menu
[Link]
[Link]
[Link]
[Link]
0.Exit2
Number popped from the stack is: 4
Stack Operations Main Menu
[Link]
[Link]
[Link]
[Link]
0.Exit4
Stack is not [Link] Operations Main Menu
[Link]
[Link]
[Link]
[Link]
0.Exit3
Stack is [Link] Operations Main Menu
[Link]
[Link]
[Link]
[Link]
[Link]

20
7)Write a program to calculate the first and follow of the given grammer.

Solution:-

#include<iostream.h>
#include<stdio.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
char **arr;
int *flagstate;
int **markarr;
char **foundfirst;
int *firstisnull;
int *NtSymbols;
char **foundfollow;
int **followgoesto;

int strmergeunique(char*dest,const char *source)

{
int strlength=strlen(source),change=0;
for(int i=0;i<strlength;i++)
{
if(!strchr(dest,source[i]))
{
dest[strlen(dest)+1]='\0';
dest[strlen(dest)]=source[i];
change=1;
}
}
return change;
}
char* first(char* ch,int &k,int rowno)
{
char prod[50]={'\0'},prod1[50]={'\0'};
int i=0,isnull,preisnull=0;
while(1)
{ isnull=0;
if(isupper(ch[i]))
{int j=0;
j=NtSymbols[toascii(ch[i])-65]+1;
if(!flagstate[j-1])
{

21
strcpy(prod1,first(arr[j-1]+1,isnull,j-1));
strcpy(foundfirst[j-1],prod1);
flagstate[j-1]=1;
firstisnull[j-1]=isnull;
}
else
{
strcpy(prod1,foundfirst[j-1]);
isnull=firstisnull[j-1];}
preisnull=isnull;
// printf("first (%c)-> %s%c",arr[j-1][0],prod1,isnull?'@':' ');
strmergeunique(prod,prod1);
if(isnull==1)
{ i++;
continue;
}
else
k=k|isnull;//if k=1 k remains 1 else it is isnull
}
else
{if(ch[i]=='@')
{ k=1;}
else
{
if(ch[i]=='/')
{
i++;
k=k|preisnull;
continue;
}
if(ch[i]=='\x0'&&preisnull==1)
{
k=1;
return prod;
}
prod[strlen(prod)+1]='\0';
prod[strlen(prod)]=ch[i];}}
int prev=1;
for(int p=0;p<10&&markarr[rowno][p]!=-1;p++)
{
if(markarr[rowno][p]>i)
{
i=markarr[rowno][p]+1;

22
prev=0;
break;}}
if(!prev) continue;

return prod;
}
}
char *first(char*ch ,int &k)
{
char prod[50]={'\0'},prod1[50]={'\0'};
int i=0,isnull,preisnull=0;
if(ch[0]=='\x0')
{
k=1;
return ch;}
while(1)
{ isnull=0;
if(isupper(ch[i]))
{
int j=0;
j=NtSymbols[toascii(ch[i])-65]+1;
if(!flagstate[j-1])
{
strcpy(prod1,first(arr[j-1]+1,isnull,j-1));
strcpy(foundfirst[j-1],prod1);
flagstate[j-1]=1;
firstisnull[j-1]=isnull;}
else
{
strcpy(prod1,foundfirst[j-1]);
isnull=firstisnull[j-1];}
preisnull=isnull;
// printf("first (%c)-> %s%c",arr[j-1][0],prod1,isnull?'@':' ');
strmergeunique(prod,prod1);
if(isnull==1)
{ i++;
continue;}}
else
{
if(ch[i]=='@')
{ k=1;
}

23
else
{
if(ch[i]=='\x0'&&preisnull==1)
{
k=1;
return prod;
}
prod[strlen(prod)+1]='\0';
prod[strlen(prod)]=ch[i];
}
}
return prod;
}

}
void follow(int );
void main()
{
int nt;
clrscr();
printf("Enter [Link] nonterminals :");
scanf("%d",&nt);
arr=new char*[nt];
markarr=new int*[nt];
foundfirst=new char*[nt];
foundfollow=new char*[nt];
flagstate=new int[nt];
firstisnull=new int[nt];
followgoesto=new int*[nt];
NtSymbols=new int[26];
for (int i=0;i<nt;i++)
{
arr[i]=new char[100];
markarr[i]=new int[10];
foundfirst[i]=new char[10];
memset(foundfirst[i],'\0',10);
foundfollow[i]=new char[10];
memset(foundfollow[i],'\0',10);
flagstate[i]=0;
firstisnull[i]=0;
followgoesto[i]=new int[nt];
followgoesto[i][0]=0;
printf("Enter non terminal ");

24
cin>>arr[i][0];
flushall();
printf("Enter Production for %c------>",arr[i][0]);
gets(arr[i]+1);

NtSymbols[toascii(arr[i][0])-65]=i;
for(int temp=1,k=0;temp<strlen(arr[i]);temp++)
{
if(arr[i][temp]=='/')
markarr[i][k++]=temp-1;
}
markarr[i][k]=-1;
}

char prod[50];
int isnull=0;
follow(nt);
cout<<endl<<endl;
for(i=0;i<nt;i++)
{
isnull=0;
strcpy(prod,first(arr[i]+1,isnull,i));
printf("First (%c)--> { %s %c}\n",arr[i][0],prod,isnull?'@':' ');
printf("Follow (%c)--> { %s }\n",arr[i][0],foundfollow[i]);
delete arr[i];
delete markarr[i];
delete foundfirst[i];
delete followgoesto[i];
}
delete arr;
delete markarr;
delete flagstate;
delete foundfirst;
delete firstisnull;
delete NtSymbols;
delete foundfollow;
}

void follow(int no_of_nonteminals)

{
char Beta[10]={'\0'},prod[20],BigB;
int nonterminal=0,isnull=0;
strcpy(foundfollow[0],"$");

25
while(nonterminal<no_of_nonteminals)
{

for(int eachletter=1;arr[nonterminal][eachletter]!='\0';eachletter++)
{
BigB=arr[nonterminal][eachletter];
if(isupper(BigB))
{
for(int i=eachletter+1;arr[nonterminal][i]!='/'
&&arr[nonterminal][i]!='\x0';i++)
{
Beta[i-eachletter-1]=arr[nonterminal][i];
}
Beta[i-eachletter-1]='\0';
isnull=0;
strcpy(prod,first(Beta,isnull));
strmergeunique(foundfollow[NtSymbols[toascii(BigB)-65]],prod);
if(isnull)
{
followgoesto[ nonterminal ][ followgoesto[nonterminal][0]+1
]=NtSymbols[toascii(BigB)-65];
followgoesto[nonterminal][0]++;
}
}
}
nonterminal++;
}
int change=0;
do
{
change=0;
for(int i=0;i<nonterminal;i++)
{
for(int j=1;j<=followgoesto[i][0];j++)
{
change|=strmergeunique(foundfollow[followgoesto[i][j]],foundfollow[i]);
}}}
while(change);
getch();
}

26
Output:-

Enter [Link] nonterminals :3

Enter non terminal E
Enter Production for E------>B+d
Enter non terminal B
Enter Production for B------>cC
Enter non terminal C
Enter Production for C------>a+e

First (E)--> { c }
Follow (E)--> { $ }
First (B)--> { c }
Follow (B)--> { + }
First (C)--> { a }
Follow (C)--> { + }

27
8) write a program to simulate Heap allocation strategy.

Solution:

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0

typedef struct Heap

{
int data;
struct Heap *next;
}
node;
node *create();
void main()
{
int choice,val;
char ans;
node*head;
void display(node*);
node *search(node*,int);
node *insert(node*);
void dele(node * *);
head = NULL;
do
{
clrscr();
printf(“\nProgram to perform various operations on Heap using Dynamic memory
management”);
printf(“\[Link]”);
printf(“\[Link]”);
printf(“\[Link] an element in a list”);
printf(“\[Link] an element from list”);
printf(“\[Link]”);
printf(“\nEnter Your Choice (1-5)”);
scanf(%d”,&choice);
switch(choice)
{
case 1:head = create();
Break;

28
case 2: display(head);
Break;
case 3: head = insert(head);
Break;
case 4: dele(&head(;
Break;
case 5: exit(0)
default:clrscr();
printf(“Invalid Choice,Try again”);
getch();
}
}
while(choice !=5);
}
node* create()
{
node *temp,*New,*head;
int val,flag;
char ans=’y’;
node *get_node();
temp = NULL;
flag = TRUE;
do
{
printf(“\n Enter the Element:”);
scanf(“%d”,&val);
New= get_node();
if (New = = NULL)
printf(“\n Memory is not allocated”);
New -> data = val;
if (flag = = TRUE)
{
head = New;
temp = head;
flag = False;
}
else
{
temp ->next = New;
temp = New;
}
printf(“\n Do you enter more elements? (y/n)”);
ans=getche();

29
}
while(ans= = ‘y’);
printf(“\n The list is created \n”);
getch();
clrscr();
return head;
}
node *get_node()
{
node *temp;
temp=(node *) malloc(sizeof(node));
temp ->next = NULL;
return temp;
}
void display(node *head)
{
node *temp;
temp=head;
if(temp==NULL)
{
printf("\nThe list is empty\n");
getch();
clrscr();
return;
}
while(temp!=NULL)
{
printf("%d->",temp->data);
temp=temp->next;
}
printf("NULL");
getch();
clrscr();
}
node *search(node *head, int key)
{
node *temp;
int found;
temp=head;
if(temp==NULL)
{
printf(“The Linked List is empty\n”);
getch();

30
clrscr();
return NULL;
}
found=FALSE;
while(temp!=NULL&&found==FALSE)
{
if(temp->data!=key)
temp=temp->next;
else
found=TRUE;
}
if(found==TRUE)
{
printf(“\nThe Element is present in the list\n”);
getch();
return temp;
}
else
{
printf(“The Element is not present in the list\n”);
getch();
return NULL;
}
}
node *insert(node *head)
{
int choice;
node *insert_head(node *);
void insert_after(node *);
void insert_last(node *);
printf(“\[Link] a node as a head node”);
printf(“\[Link] a node as a last node”);
printf(“\[Link] a node at intermediate position in the list”);
printf(“\n Enter the your choice for insertion of node”);
scanf(“%d”,&choice);
switch(choice)
{
case 1:head=insert_head(head);
break;
case2:insert_last(head);
break;
case 3:insert_after(head);
break;

31
}
return head;
}
node*insert_head(node*head)
{
niode*New,*temp;
New get_node();
printf("\n Enter the elemaent which you want to insert*”);
scanf(“%d”,& New->data);
if(head= =NULL)
head =New;
else
{
temp=head;
New->next=temp;
head=new;
}
return head;
}
Void insert_last(node*head)
{
node*new,*temp;
New=get_node();
printf(“\n Enter the element which you want to insert”);
scanf(%d”,& New->data);
if(head = =NULL)
head= New;
else
{
temp=head;
while(temp->next!=NULL)
temp=temp->next;
temp->next=New;
New->next=NULL;
}
}
void insert_after(node*head)
{
int key;
node*New,*temp;
New= get_node();
print(“\n Enter the element which you want to insert
scanf(“%d”,&New->data);

32
if(head= =NULL)
{
head=New;
}
printf(“\n Enter the element after which you want to insert the node”);
scanf(“%d”,&key);
temp=head;
do
{
if(temp->data= =key)
{
New->next=temp->next;
temp->next=New;
return;
}
else
temp=temp->next;
}
while((temp!=NULL);
}
}
node *get_prev(node*head,int vall)
{
node * temp, *prev;
int flag;
temp = head;
if (temp = = NULL)
return NULL;
flag = FALSE;
prev = NULL;
while (temp!=NULL &&!flag)
{
if (temp->data! = val)
{
prev =temp;
temp= temp->next;
}
else
flag =TRUE;
}
if (flag)
return prev;
else

33
 return NULL;
}
Void dele(node**head)
{
node*temp,*prev;
int key ;
temp=*head;
if(temp= = NULL)
{
printf(“\n The list is empty\n”);
getchch();
clrscr();
return;
}
clrscr();
printf(“\enter the element you want to delete:”);
Scanf(“%d”,& key);
temp= search(*head,key);
if(temp !=NULL)
{
prev= get_prev(*head,key);
if(prev!=NULL)
{
prev ->next =temp->next;
free(temp);
}
else
{
*head =temp->next;
free(temp);// using the mem. de-allocation function
}
printf(“\the element is deleted\n”);
getch();
clrscr();
}
}

Output:-

program to perform various operation on heap using dynamic memory management

[Link]
[Link]
[Link] an element in list

34
[Link] an element from list
[Link]
Enter your Choice(1-5)1

Enter the Element :10

Do you want to enter more elements?(y/n)y

Enter the Element:20

Do you want to enter more elements?(y/n)y

Enter the Element:30

Do you want to enter more elements?(y/n)

The list is created

Program to perform various operation on heap using dynamic memory management

1. create
[Link]
3. insert an element in list
[Link] an element from list
[Link]
Enter your choice(1-5)2
10-> 20-> 30-> null

Program to perform various operation on heap using dynamic memory management

1. Create
[Link]
3. Insert an element in list
[Link] an element from list
[Link]
Enter the element you want to delete:20

The Element is present in list

The Element is deleted

Program to perform various operation on heap using dynamic memory management

[Link]
[Link]
[Link] an element in list

35
[Link] an element from list
[Link]
Enter Your Choice(1-5)2
10-> 30-> NULL

36
9) Given any intermediate code form implement code optimization techniques.

Solution:-

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

Struct ConstFold
{
char New_Str[10];
char str[10];
}Opt_Data[20];

Void ReadInput(char Buffer[],FILE *Out_file);

int Gen_Token(char str[],char Tokens[][10]);

int New_index=0;

int main()
{
FILE *in_file,*Out_file;
char Buffer[100],ch;
int i=0;
in_file =fopen(“d:\\[Link]”,”r”);
out_file =fopen(“d:\\[Link]”,”w”);
clrscr();
while(1);
{
ch =fgetc(In_file);
i=0;
while(1)
{
if(ch = = ‘\n’)
break;
Buffer[i++] = ch;
ch =fgetc(In_file);
if(ch = =EOF)
break;
}
if(ch= =EOF)

37
break;
buffer[i]=’\0’;
ReadInput(Buffer,Out_file);
}
return 0;
}

void ReadInput(char Buffer[],FILE *Out_file)

{
char temp[100],Token[10][10];
int n,I,j,flag=0;
strcpy(temp,buffer);
n =Gen_Token(temp,Token);
for(i=0;i<n;i++)
{
if(!strcmp(Token[i],”=”))
{
if(isdigit(Token[i+1][0]) ║Token[i+1][0] = = ‘.’
{
flag =1;
strcpy(Opt_Data[New_index].New_Str,Token[i-1]
strcpy(Opt_Data[New_index++].Str,Token[i+1]);
}
}
}
if(!flag)
{
for(i=0;j<New_index;;i++)
{
for(j=0;j<n;j++)
{
if(!strcmp(Opt_Data[i].New_Str,Token[j]))
strcpy(Token[j],Opt_Data[i].str);
}
}
}
fflush(out_file);
strcpy(temp,””);
for(i=0;i<n;i++)
{
strcat(temp,Token[i]);
if(token[i+1][0]!=’.’║Token[i+1][0]!=’;’)
strcat(temp,” ”);

38
 }
strcat(temp,”\n\0”);

fwrite(&temp,strlen(temp),1,Out_file);
}

int Gen_token(char str[],char Token[][10])

{
int i=0,j=0,k=0;
while(str[k]= =’’॥ str[k]= =’\t’)
k++;
while(str[k]!=’\0’)
{
j=0;
while(str[k])= =’’ ॥ str[k]= =’\t’)
k++
while(str[k]!=’’&& str[k]!=’\0’
&& str[k]!=’=’ && str[k]!=’/’
&& str[k]!=’+’ && str[k]!=’-’
&& str[k]!=’*’ && str[k]!=’,’ &&str[k]!=’;’)
Token[i][j++] = str[k++] ;
Token [i++][j]= ‘\0’;
if(str[k]= =’=’ ॥ str[k]= =’/’ ॥ str[k]= =’+’ ॥ str[k]= =’-’ ॥ str[k]= =’*’ ॥ str[k]= =’,’ ॥ str[k]=
=’;’ )
{
Token[i][0]=str[k++];
Token[i++][1]=’\0’;
}
if(str[k]= =’\0’)
break;
}
return i;
}

Input file: [Link]

#include<stdio.h>
main()
{
float pi=3.14,r,a;
a=pi*r*r;
printf(“a = %f”,a);

39
 return 0;
}

Output File: [Link]

#include<stdio.h>
main()
{
float pi=3.14,r,a;
a=3.14*r*r;
printf(“a = %f”,a);
return 0;
}

40
10) Write a lex program to convert the substring abc to ABC from the given
input string.

Solution:-

%{
#include<stdio.h>
#include<string.h>
int i;
%}
%%
[a-zA-Z]* {
for(i=0;i<yyleng;i++)
{
if((yytext[i]==’a’)&&(yytext[i+1]==’b’)&&(yytext[i+2]==’c’))
{
yytext[i]=’A’;
yytext[i+1]=’B’
yytext[i+2]=’C’
}
}
printf(“%s”’yytext);
}
[\t]* return;
.* {ECHO;}
\n {printf(“%s”,yytext);}
%%
main()
{
yylex();
}
int yywrap()
{
return 1;
}
Output:-

[root@aap Syssoftprograms]# vi abctest.l

[root@aap Syssoftprograms]# lex abctest.l
[root@aap Syssoftprograms]# cc [Link].c
[root@aap Syssoftprograms]# ./[Link]
helloabcabcworld
helloABCABCworld

41
11) Write a lex program to find out total number of vowels and consonants
from the given input string.

Solution:-

%{
/*Definition section*/
int vowel_cnt=0,consonant_cnt=0;
%}
vowel [aeiou]+
consonant [^aeiou]
eol \n
%%
{eol} return 0;
[ \t]+ ;
{vowel} {vowel_cnt++;}
{consonant} {consonant_cnt++;}
%%
int main()
{
printf(“\n Enter some input string\n);
yylex();
printf(“Vowels=%d and consonant=%d\n”,vowel_cnt,consonant_cnt);
return 0;
}
int yywrap()
{
return 1;
}

Output:-

[root@aap root]# lex vowel.l

[root@aap root]# cc [Link].c
[root@aap root]# ./[Link]
Enter some input string
parth
Vowels=1 and consonant=4
[root@aap root]#

42
12)Write a lex program to identify the capital strings from the given input
string.

Solution:-

/*Definition section*/
%}
%%
[A-Z]+[ \t\n\.\,] {printf(“%s”,yytext);}
. ;
%%
main()
{
printf(“\n Enter some input with capital words in between\n”);
yylex();
}
int yywrap()
{
return 1;
}

Output:-

[root@aap root]# lex upper.l

[root@aap root]# gcc [Link].c -ll
[root@aap root]# ./[Link]

Enter some input with capital words in between

I am PROUD of you – INDIA
I PROUD INDIA

43