TRINITY COLLEGE OF ENGG & TECHNOLOGY

1) A Program to Design Lexical Analyzer.

#include<string.h>
#include<ctype.h>
#include<stdio.h>
void keyword(char str[10])
{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)
Printf(“\n%s is a keyword”,str);
else
printf(“\n%s is an identifier",str);
}
main()
{
FILE *f1,*f2,*f3;
char c,str[10],st1[10];
int num[100],lineno=0,tokenvalue=0,i=0,j=0,k=0;
printf("\nEnter the c program");/*gets(st1);*/
f1=fopen("input","w");
while((c=getchar()!=EOF)
put(c,f1);
fclose(f1);
f1=fopen("input","r");
f2=fopen("identifier","w");
f3=fopen("specialchar","w");
while((c=getc(f1))!=EOF))
{
if(isdigit(c))
{
tokenvalue=c-'0';
c=getc(f1);
while(isdigit(c))
{
tokenvalue*=10+c-'0';
c=getc(f1);
}
num[i++]=tokenvalue;
ungetc(c,f1);
}elseif(isalpha(c))
{
putc(c,f2);
c=getc(f1);
while(isdigit(c)||isalpha(c)||c=='_'||c=='S')
{
putc(c,f2);
c=getc(f1);
}
putc('',f2);
ungetc(c,f1);
Compiler Design Lab Page 1
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

}else if(c==''||c=='\t')
printf("");
else if(c=='\n')
lineno++;
else
putc(c,f3);
}
fclose(f2);
fclose(f3);
fclose(f1);
printf("\nThe no's in the program are");
for(j=0;j<i;j++)
printf("%d",num[j]);
printf("\n");
f2=fopen("identifier","r");
k=0;
printf("The keywords and identifiers are:");
while((c=getc(f2))!=EOF)
{
if(c!='')
str[k++]=c;
else
{
str[k]='\0';
keyword(str);
k=0;
}
}
fclose(f2);
f3=fopen("specialchar","r");
printf("\nSpecial characters are");
while((c=getc(f3))!=EOF)
printf("%c",c);
printf("\n");
fclose(f3);
printf("Total no. of lines are:%d",lineno);
}

Output:
Enter the C program
a+b*c
Ctrl-D
The no's in the program are:
The keywords and identifiers are:
a is an identifier and terminal
b is an identifier and terminal
c is an identifier and terminal
special characters are:
+*
Total no. of lines are:1
Compiler Design Lab Page 2
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

2) Implement the Lexical Analyzer Using Lex Tool

/*program name is lexp.l*/
%{
/*program to recognize a c program*/
int COMMENT=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;}
/*{printf("\n\n\t%s is a COMMENT\n",yytext);}*/
"*/"{COMMENT=0;}
/*printf("\n\n\t%s is a COMMENT\n",yytext);}*/
{identifier}\({if(!COMMENT)printf("\n\nFUNCTION\n\t%s",yytext);}
\{if(!COMMENT)printf("\nBLOCK BEGINS");}
\}{if(!COMMENT)printf("\nBLOCK ENDS");}
{identifier}(\[[0-9]*\])?{if(!COMMENT)printf("\n%sIDENTIFIER",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);}
\<= |
\>= |
\< |
== |
Compiler Design Lab Page 3
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

\>{if(!COMMENT)printf("\n\t%s is a RELATIONAL OPERATOR",yytext);}

%%
int main(int argc,char **argv)
{
if(argc>1)
{
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");
return 0;
}int yywrap()
{
return 0;}

Input:
Svi var.c
main()
{
int a,b;
}

Output:
Slex lex.l
Scc lex.yy.c
S./a.out var.c
#include<stdio.h>is a PREPROCESSOR DIRECTIVE
FUNCTION
main()

BLOCK BEGINS
int is a KEYWORD
a IDENTIFIER b IDENTIFIER BLOCK ENDS

Compiler Design Lab Page 4

 TRINITY COLLEGE OF ENGG & TECHNOLOGY

3) Implementation of Predictive Parser.

#include<stdio.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 lexemes[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;
for(k=lastentry;k>0;k--)
if(strcmp(symtable[k].lexptr,s)==0)
return k;
return 0;
}int insert(char s[],int tok)
{
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;
Compiler Design Lab Page 5
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

symtable[lastentry].token=tok;
symtable[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+1)
insert(ptr->lexptr,ptr->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(isalph(t))
{
while(isalnum(t))
{
buffer[i]=t;
t=getchar();
i=i+1;
if(i>=SIZE)
Error_Message("Compiler error");
}
buffer[i]=EOS;
if(t!=EOF)
unget(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
{
Compiler Design Lab Page 6
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

tokenval=NONE;
return t;
}
}
}
void Match(int t)
{
if(lookahead==t)
lookahead=lexer();
else
Error_Message("Syntax error");
}
void display(int t,int tval)
{
if(t=='+'||t=='-'||t=='*'||t=='/')
printf("\nArithmetic Operator:%c",t);
else if(t==NUM)
printf("\nNumber:%d",tval);
else if(t==ID)
printf("\nIdentifier: %s",symtable[tval].lexptr);
else
printf("\nToken %d tokenval %d",t,tokenval);
}
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;
Compiler Design Lab Page 7
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

Match(lookahead);
F();
display(t,NONE);
continue;
case '/':t=lookahead;
Match(lookahead);
display(t,NONE);
continue;
default:return;
}
}
}
void E()
{
int t;
T();
while(1)
{
switch(lookahead)
{
case'+':t=lookahead;
Match(lookahead);
T();
display(t,NONE);
continue;
case '-':t=lookahead;
Match(lookahead);
T();
display(t,NONE);
continue;
default:return;
}
}
}
void parser()
{
lookahead=lexer();
while(looakahead!=DONE)
{
E();
Match(';');
}}
main()
{
char ans[10];
printf("\nProgram for recursive decent parsing");
printf("\n Enter the expression");
printf("And place;at the end\n");
printf("Press Ctrl-Z to terminate\n");
parser(); }
Compiler Design Lab Page 8
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

Output:
Program for recursive decent parsing
Enter the expression And place;at the end
Press Ctrl-Z to terminate
a+b*c;
Identifier:a
Identifier:b
Identifier:c
Arithmetic Operator:*
Arithmetic Operator:+
2*3;
Number:2
Number:3
Arithmetic Operator:*
+3;
line 5,Syntax error
Ctrl-Z

Compiler Design Lab Page 9

 TRINITY COLLEGE OF ENGG & TECHNOLOGY

4) Design LALR BOttom up Parser

<parser.l>
%{
#include<stdio.h>
#include"y.tab.h"
%}
%%
[0-9]+{yylval.dval=atof(yytext);
return DIGIT;
}
\n|.return yytext[0];
%%
<parser.y>
%{
/*This YACC specification file generates the LALR parser for the program considered in
experiment 4.*/
#include<stdio.h>
%}
%union
{
double dval;
}
%token<dval>DIGIT
%type<dval>expr
%type<dval>term
%type<dval>factor
%%
line:expr'\n'{
printf("%g\n",$1);
}
;
expr:expr'+'term{$$=$1+$3;}
|term
;
term:term'*'factor($$=$1*S3;}
|factor
;
factor:'('expr')'{$$=$2;}
|DIGIT
;
%%
int main()
{
yyparse();
}
yyerror(char *s)
{
printf("%s",s);
}

Compiler Design Lab Page 10

 TRINITY COLLEGE OF ENGG & TECHNOLOGY

Output:
Slex parser.1
Syacc -d parser.y
Scc lex.yy.c.y.tab.c -ll -lm
S./a.out
2+3
5.0000

Compiler Design Lab Page 11

 TRINITY COLLEGE OF ENGG & TECHNOLOGY

5) Convert the BNF rules into Yacc form and write code to generate abstract syntax tree.
<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);
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;
Compiler Design Lab Page 12
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

%}
%union
{
char var[10];
}
%token <var> NUM VAR RELOP
%token MAIN ID ELSE WHILE TYPE
%type <var> EXPR ASSIGNMENT CONDITION IFST ELSEST WHILELOOP
%left '-' '+'
%left '*' '/'
%%
PROGRAM:MAIN bloCK
;
BLOCK:'{'CODE'}'
;
CODE BLOCK
|STATEMENT CODE
|STATEMENT
;
STATEMENT:DESCT';'
|ASSIGNMENT';'
|CONDST
|WHILEST
;
DESCT:TYPE 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,$$);}
|'-'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);
}
Compiler Design Lab Page 13
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

|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);
}
BLOCK{
strcpy(QUAD[Index].op,"GOTO");
strcpy(QUAD[Index].arg1,"");
strcpy(QUAD[Index].arg2,"");
strcpy(QUAD[Index].result,"-1");
push(Index);
Index++;
};
ELSEST:ELSE{
tInd=pop();
Ind=pop();
push(tInd);
sprintf(QUAD[Ind].result,"%d",Index);
}
BLOCK{
Ind=pop();
sprintf(QUAD[Ind].reslult,"%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++;
}
BLOCK{
strcpy(QUAD[Index].op,"GOTO");
Compiler Design Lab Page 14
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

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("File not found");
exit(0);
}
yyin=fp;
}
yyparse();
printf("\n\n\t\t---------------------------------""\n\t\tPos 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---------------------------");
printf("\n\n");
return 0;
}
void push(int data)
{
stk.top++;
if(stk.top==100)
{
printf("\nStack overflow\n);
exit(0);
}
stk.items[stk.top]=data;
}
int pop()
{
int data;
if(stk.top==-1)
Compiler Design Lab Page 15
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

{
printf("\nStack 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("\nError on line no.%d",LineNo);
}
Input:
Svi 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;
}
}

Compiler Design Lab Page 16

 TRINITY COLLEGE OF ENGG & TECHNOLOGY

Output:
Slex int.l
Syacc -d int.y
Sgcc lex.yy.c y.tab.c -ll -lm
S./a.out test.c

Pos Operator Arg1 Arg2 Result

0 < a b to
1 == to FALSE 5
2 + a b t1
3 = t1 a
4 GOTO 5
5 < a b t2
6 == t2 FALSE 10
7 + a b t3
8 = t3 a
9 GOTO 5
10 <= a b t4
11 == t4 FALSE 15
12 - a b t5
13 = t5 c
14 GOTO 17
15 + a b t3
16 = t6 c

Compiler Design Lab Page 17

 TRINITY COLLEGE OF ENGG & TECHNOLOGY

6) A program to Generate Machine code

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int label[20];
int no=0;
int main()
{
FILE *fp1,*fp2;
char fname[10],op[10],ch;
char foperand1[8],operand2[8],result[8];
int i=0,j=0;
printf("\nEnter filename of the intermediate code");
scanf("%s",&fname);
fp1=fopen(fname,"r");
fp2=fopen("target.txt","w");
if(fp1==NULL||fp2==NULL)
{
printf("\nError opening the file");
exit(0);
}
while(!feof(fp1))
{
fprintf(fp2,"\n");
fscanf(fp1,"%s",op);
i++;
if(check_label(i))
fprintf(fp2,"\nlabel#%d",i);
if(strcmp(op,"print")==0)
{
fscanf(fp1,"%s",result);
fprintf(fp2,"\n\tOUT%s",result);
}
if(strcmp(op,"goto")==0)
{
fscanf(fp1,"%s %s",operand1,operand2);
fprintf(fp2,"\n\tJMP %s,label#%s",operand1,operand2);
label[no++]=atoi(operand2);
}
if(strcmp(op,"[]=")==0)
{
fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n\tSTORE %s[%s],%s",operand1,operand2,result);
}
if(strcmp(op,"uminus")==0)
{
fscanf(fp1,"%s %s",operand,result);
fprintf(fp2,"\n\tLOAD -%s,R1",operand1);
fprintf(fp2,"\n\tSTORE R1,%s",result);
}
Compiler Design Lab Page 18
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

switch(op[0])
{
case '*':fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n\tLOAD",operand1);
fprintf(fp2,"\n\tLOAD %s,R1",operand2);
fprintf(fp2,"\n\tMUL R1,R0");
fprintf(fp2,"\n\tSTORE R0,%s",result);
break;
case '+':fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n\tLOAD %s,R0",operand1);
fprintf(fp2,"\n\tLOAD %s,R1",operand2);
fprintf(fp2,"\n\tADD R1,R0");
fprintf(fp2,"\n\tSTORE R0,%s",result);
break;
case '-':fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n\tLOAD %s,R0",operand1);
fprintf(fp2,"\n\tLOAD %s,R1",operand2);
fprintf(fp2,"\n\tSUB R1,R0");
fprintf(fp2,"\n\tSTORE R0,%s",result);
break;
case '/':fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n\tLOAD %s,R0",operand1);
fprintf(fp2,"\n\tLOAD %s,R1",operand2);
fprintf(fp2,"\n\tDIV R1,R0");
fprintf(fp2,"\n\tSTORE R0,%s",result);
break;
case '%':fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n\tLOAD %s,R0",operand1);
fprintf(fp2,"\n\tLOAD %s,R1",operand2);
fprintf(fp2,"\n\tDIV R1,R0,%s",result);
break;
case '=':fscanf(fp1,"%s %s",operand1,result);
fprintf(fp2,"\n\tSTORE %s %s",operand1,result);
break;
case '>':j++;
fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n\tLOAD %s,R0",operand1);
frprintf(fp2,"\n\tJGT %s,label#%s",operand2,result);
label[no++]=atoi(result);
break;
case '<':fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n\tLOAD %s,R0",operand1);
fprintf(fp2,"\n\tJLT %s,label#%d",operand2,result);
label[no++]=atoi(result);
break;
}
}
fclose(fp2);
fclose(fp1);
fp2=fopen("target.txt","r");
Compiler Design Lab Page 19
 TRINITY COLLEGE OF ENGG & TECHNOLOGY

if(fp2==NULL)
{
printf("Error opening the file\n");
exit(0);
}
do
{
ch=fgetc(fp2);
printf("%c",ch);
}while(ch!=EOF);
fclose(fp1);
return(0);
}int check_label(int k)
{
int i;
for(i=0;i<no;i++)
{
if(k==label[i])
return 1;
}
return 0;
}

Input:
Svi int.txt
=t1 2
[]=a 0 1
[]=a 1 2
[]=a 2 3
*t1 6 t2
+a[2] t2 t3
-a[2] t2 t3
/t3 t2 2
uminus t2 2
print t2
goto t2 t3
=t3 99
uminus 25 t2
*t2 t3 t3
uminus t1 t1
+t1 t3 t4
print t4

Compiler Design Lab Page 20

 TRINITY COLLEGE OF ENGG & TECHNOLOGY

Output:
Enter filename of the intermediate code:int.txt
STORE t1,2
STORE a[0],1
STORE a[1],2
STORE a[2],3
LOAD t1,R0
LOAD 6,R1
ADD R1,R0
STORE R0,t3
LOAD a[2],R0
LOAD t2,R1
ADD R1,R0
STORE R0,t3
LOAD a[t2],R0
LOAD t1,R1
SUB R1,R0
STORE R0,t2
LOAD t3,R0
LOAD t2,R1
DIV R1,R0
STORE R0,t2
LOAD t2,R1
STORE R1,t2
LOAD t2,R0
JGT 5,label#11
label#11:OUT t2
JMP t2,label#13
label#13:STORE t3,99
LOAD 25,R1
STORE R1,t2
LOAD t2,R0
LOAD t3,R1
MUL R1,R0
STORE R0,t3
LOAD t1,R1
STORE R1,t1
LOAD t1,R0
LOAD t3,R1
ADD R1,R0
STORE R0,t4
OUT t4

Compiler Design Lab Page 21