pcd record

GOVERNMENT COLLEGE OF ENGINEERING

SALEM – 636 011.

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

070230069 – PRINCIPLES OF COMPILER DESIGN LABORATORY

FINAL YEAR

NAME : ______________________________

REGISTER NUMBER : ______________________________

1

GOVERNMENT COLLEGE OF ENGINEERING

SALEM – 636 011.

070230069 – PRINCIPLES OF COMPILER DESIGN LABORATORY

Certified that this is the Bonafide Record of work done by Mr. / Ms.

…………………………………………………………………….….. of SEVENTH SEMESTER

of …………….…………………………………………………………. during the Academic Year

2010 – 2011.

Staff – In – Charge

Submitted for the Practical Examination held on ………………..

His / Her University Register Number is ...……………………….

INTERNAL EXAMINER EXTERNAL EXAMINER

2

TABLE OF CONTENTS

S.NO DATE NAME OF THE EXPERIMENTPAGE

NOSIGNATURE

1Lexical Analyzer For ‘C’ Statements 4

2Lexical Analyzer For Assembly

Language Statements8

3Lexical Analyser Using Lex Tools 13

4Recursive Descent Parsing For

Arithmetic Expression Using + And *20

5Parser Implementation Using Yacc &

Lex28

6Implementing Calculator Using Yacc 32

7Simple Intermediate Code Generation 35

8Intermediate code generation

Three address code for Boolean expression

39

9Assembly Code Generation

44

3

Ex.No : 01 LEXICAL ANALYZER FOR ‘C’ STATEMENTS

Date :

AIM :

To write a ‘c’ program to implement the lexical analyzer for ‘c’ statements.

ALGORITHM :

1. Start the Program.

2. Declare the variables and main function.

3. Open a text file in the read mode and read the expression from that file.

4. In main function, if the string of the files contains reserved words go to reserved function.

5. Compare reserved words with the string print these reserved words if they appear.

6. The defined reserved words are if, then else, do, while, and for.

7. Else check whether it contains the operator such as +,-,*, /,>, <,! , =.

8. Print the operators if it matches.

9. Else take it as the string is an identifier.

10. Stop the Program.

11. Print the Result.

4

CODING :

#include<stdio.h>

#include<conio.h>

#include<string.h>

char string[20],reswords[20][20],ids[20][20],ops[20][20];

int c1=-1,c2=-1,c3=-1,i;

int res(char *word)

{

int i;

char reserved[][10]={"if","then","elso","do","while","for"};

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

if(strcmp(reserved[i],word)==0)

return(1);

return(0);

}

int op(char *word)

{

int i;

char operat[10][4]={"+","-","*"," /","=","!=",">","<"};

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

if(strcmp(operat[i],word)==0)

return(1);

return(0);

}

void main()

{

FILE *fp;

fp=fopen("src.txt","r");

clrscr();

while(fscanf(fp,"%s",string)!=EOF)

{

if(res(string)==1)

5

strcpy(reswords[++c1],string);

else if(op(string)==1)

strcpy(ops[++c2],string);

else

strcpy(ids[++c3],string);

}

printf("\n Reserved words \n ");

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

printf("\n %s",reswords[i]);

printf("\n Operator \n ");

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

printf("\n %s",ops[i]);

printf("\n Identifer \n ");

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

printf("\n %s",ids[i]);

getch();

}

6

INPUT AND OUTPUT:

Reserved Words

if

then

else

do

Operator

+ - *

Identifiers

a b c

RESULT :

Thus the ‘c’ program to implement the lexical analyzer for ‘c’ statements is written and the output is verified.

7

Ex.No : 02 LEXICAL ANALYZER FOR ASSEMBLY Date : LANGUAGE STATEMENTS

AIM :

To write a c program to implement a lexical analyzer for assembly language.

ALGORITHM :

1. Start the program.

2. Declare the variables and as string, data, arithmetic identifiers and register.

3. Define the main function. open a text file in the read mode and read the assembly language

expressions from that file.

4. In that main function, perform the following step until the file exists.

5. If the string contains data transfer code like MOV, MOVF, load and store and then compare

the string with the data transfer word and print the data transfer word.

6. Else check whether the string contains the arithmetic operators such as add, addf, mul, mulf,

sub and div. The print it as a arithmetic one.

7. Else check whether the string contain the register such as R1,R2,R3 and R4.

8. If the expressions contain those words print it and check for string contains the variables such

as A, B, C, D.

9. Else print the expression string as identifier.

10. Print the result and Stop the program.

8

CODING :

#include<stdio.h>

#include<conio.h>

#include<string.h>

Char string[20], data[20][20], arith[20][20], var[20][20], ids[20][20], reg[20][20];

int c1=-1, c2=-1,c3=-1,c4=-1,c5=-1,i;

int dat(char *word)

{

int i;

char datatransfer[][10]={ “mov ”, ” movf ”, ”store”, ”load”};

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

if(strcmp(datatranfer[i],word)==0)

return(1);

return(0);

}

int ari(char *word)

{

int i;

char arithmetic[][12]={“add”, “addf”, “mulf”,” sub”, “div” };

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

if(strmp(arithmetic[i].word)==0)

return(1);

return(0);

}

int regis(char *word)

{

int i;

char register[][12]={“R1”, “R2”, “R3”, “R4” };

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

if(strcmp(register[i],word)==0)

return(1);

return(0);

}

9

int variable(char *word)

{

int i;

char variables[][16]={“A”, “B”, “C”, “D”};

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

if(strcmp(variables[i],word)==0)

return(1);

return(0);

}

void main()

{

FILE *fp;

fp = fopen(“str. text”, ”r”);

clrscr();

while((fscanf(fp ”%s”, String)!=EOF)

{

if(dat(String)==1)

strcpy(data[++c1],String);

else if(ari(String)==1)

strcpy(arith[++c2],String);

else if(regis(String)==1)

strcpy(reg[++c3],String);

else if(variable(string)==1)

strcpy(var[++c4],string);

else

strcpy(ids[++c5],String);

}

printf(“\n DATA TRANSFERED”);

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

printf(“\n %s”, data[i]);

printf(“ ARITHMETIC”);

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

printf(“\n %s”, arith[i]);

printf(“\n REGISTER “);

10

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

printf(“\n %s”, reg[i]);

printf(“\n VARIABLES” \n”);

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

printf(“ \n %s”, var[i]);

printf(“\n IDENTIFERS”);

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

printf(“ \n %s”, ids[i]);

getch();

}

11

INPUT AND OUTPUT :

DATA TRANSFERRED

movf

mov

ARITHMETIC

add

mulf

REGISTERS

A

B

C

D

IDENTIFIERS

tg

RESULT :

Thus the c program to implement a lexical analyzer for assembly language is written and the

output is verified.

12

Ex.No : 03 LEXICAL ANALYSER USING LEX TOOLS

Date :

AIM :

To write a c program using of lex tool to implement the lexical analyser.

ALGORITHM :

1. Start the program.

2. Define the size, number, keywords , parenthesis, lexeme, buffer and token value

3. Declare the variables as lexemes, buffer, last char, last entry and token value.

4. Define the main function with following steps.

5. Call the initialize function declare the structure pointer.

6. Declare the keywords like if for, else, int, float, double, char, struct, return and then in array.

7. If lookahead is equal to lexeme means those to lexer function initialize the variables.

8. Get the input expression and if expression have paranthesis then return parenthesis.

9. Else if the expression as relational operator like <,>,<=,=>,!= then return relational operator.

10. Else if the expression as assignment operator return the assignment

operator get the digit in stdin and return in number.

11. If the input expression as error then return compile error.

12. If the lookahead is equal to number then print the number, then Keyword, parenthesis,

identifier, assignment operator are printed in the output.

13. If the expression given in the output then same expression will be

displayed input file.

14. Stop the program.

13

CODING :

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

#define KEYWORD 257

#define PAREN 258

#define ID 259

#define ASSIGN 260

#define REL –op261

#define DONE 262

#define MAX 999

Char lexemes[max];

Char buffer[size];

int lastchar =-1;

int lastentry =0;

int token val =NONE;

int lineno =1;

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,”then” KEYWORD,0,0};

14

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=k-1)

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(“lexemes array is full”);

lastentry=lastentry+1;

symtable[lastentry].token=tok;

symtable[lastentry].lexptr=&lexemes[lastchar+1];

lastchar=lastchar+len+1;

strcpy(symtable[lastentry].lexptr,s);

return lastentry;

}

Void Intialize()

{

Struct entry *ptr;

for(ptr=keywords;ptr->token;ptr++)

insert(ptr->lexptr,ptr->token);

}

int lexer()

{

15

int t;

int val,i=0;

while(i)

{

t=getchar();

if(t==’’||t==’\t’)

else if(t==’\n’)

lineno=lineno+1;

else if(t==’(‘||t==’)’)

return PAREN;

else if(t==’<’||t==’>’||t==’<=’||t==’>=’||t==’!=’)

return REL_OP;

else if(t==’=’)

return ASSIGN;

else if(is digit(t))

{

Ungetc(t,stdin);

Scanf(“%d”,&tokenval);

return NUM;

}

else if(is alpha(t))

{

While(is alnum(t))

{

buffer[i]=t;

i=i+1;

if(i>=SIZE)

Error_Message(“computer error”);

}

buffer[i]=EOS;

if(t1=EOF)

ungetc(t,stdin);

val=look_up(buffer);

if(val==0)

16

val=insert(buffer,ID);

token val=val;

return symtable[val].token;

}

else if(t==EOF)

return DONE;

else

{

token val=NONE;

return t;

}

}

}

void main()

{

int lookahead;

char ans;

clrscr();

printf(“\n\t\t program for lexical analysis \n”);

initialize();

printf(“\n enter the expression and put at the end”);

printf(“\n press ctrl z to terminate…..\n”);

lookahead=lexer();

while(lookahead!=DONE)

{

if(lookahead==NUM)

{

Printf(“\n number”);

Printf(“%d”,token val);

if(lookahead==’+’||lookahead==’-‘|| lookahead==’*’|| lookahead==’/’)

printf(“\n operator”);

if(lookahead==PAREN)

printf(“\n identifier”);

printf(“%s”symtable[tokenval],lexptr);

17

}

if(lookahead==KEYWORD)

printf(“\n keywords”);

if(lookahead==ASSIGN)

printf(“\n assignment operator”);

if(lookahead==REL_OP)

printf(“\n relational operator”);

lookahead=lexer;

}

}

}

18

INPUT AND OUTPUT:

Program for lexical analysis

Enter the expression and put; at the end

Press ctrl+z at the end to terminate

If(x=y) then x

Keyword

paranthesis

Identifier: x

Assignment Operator

Identifier: y

Paranthesis

Keyword

Identifier: x

RESULT :

Thus the c program using of lex tool to implement the lexical analyser is written and the

output is verified.

19

Ex.No : 04 RECURSIVE DESCENT PARSING FOR ARITHMETICDate : EXPRESSION USING + AND *

AIM :

To write a C program to implement the recursive descent parsing.

ALGORITHM :

1. Start the program.

2. Define the variables as size, none,EOS,NUM,keywords, ID,DONE,MAX.

3. Declare the variables, lexemes, buffer, last char,last entry, token val,line no,lookahead and

structure pointer.

4. Create the function such as Error_message,lookup,insert, initialize, lexer, match, display,F(),

T(),E() and parser for perfoming various operations.

5. Check for the condition in the symbol table and lexemes array by using insert function.

6. If lookahead matches with the variable then lookahead equals lexer,else point syntax error.

7. Yet the input expression,if it matches with +, -,*, / display as arithmetic operator, if it

matches with Num display as number, or else if it is ID display as identifier.

8. If the expression matches with C symbol call the E() for checking + and – and return ‘)’ with

that expression.

9. If the lookahead doesn’t matches with DONE VALUE means then call the E() and match ; at

the end.

10. In the main, call the initialize function and then print the statements such as Enter the

expression, and place semicolon at the end. Press ctrl+z to terminate and call the parser

function.

11. Stop the program.

20

CODING :

#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 lexemes[MAX];

char buffer[SIZE];

int last char=-1;

int last entry=0;

int tokenval=DONE;

int lineno=1;

int lookahead;

struct entry

{

char *lexptr;

int token;

}

symtable[100];

struct entry keyword[]={“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)

{

fprint(stderr,”line%d%s\n”,lineno,m);

21

exit(1);

}

int look_up(char s[])

{

int k;

for(k=lastentry;k>0;k=k-1)

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

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

insert(ptr->lexptr,ptr->token);

}

int lexer()

{

int i;

nt val,i=0;

while()

22

{

t=getchar();

if(t==’’||t==’\t’)

else if(t==’\t’)

lineno=lineno+1;

else if(isdigit(t))

{

ungetc(t,stdin);

scanf(“%d”,&tokenval);

return NUM;

}

else if(isalpha(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)

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

{

23

tokenval=NONE;

return t;

}

}

}

void match(int t)

{

if(lookahead==t)

ookahead=lexer;

else Error_Message(“Syntax error”);

}

void display(int t, int val)

{

if(t==’+’||t==’-’||t==’*’||t==’%’)

printf(“Arithmetic Operator:%c”,t);

else if(t==NUM)

printf(“\n Number: %d”, tval);

else if(t==ID)

printf(“\n Identifier:%s”,symtable[tval].lexptr);

else

printf(“\n Token %d token valid %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);

24

break;

default:Error_Message(“Syntax Error”);

}

}

void T()

{

put t;

F();

while(1)

{

switch(lookahead)

{

case’*’: t=lookahead;

match(lookahead);

continue;

case’/’:t=lookahead;

match(lookahead);

F();

display(t,NONE);

continue;

default:return n;

}

}

}

void E()

{

int t;

T();

while(1)

{

switch(lookahead)

{

case’+’: t=lookahead;

match(lookahead);

25

T();

display(t,NONE);

continue;

case’-’:t=lookahead;

match(lookahead);

T();

display(t,NONE);

continue;

default:return n;

}

}

}

void parser()

{

lookahead=lexer;

while(lookahead!=DONE)

{

E();

match(‘i’);

}

}

void main()

{

char ans;

clrscr();

printf(“\n\n Program For Recursive Descent Parsing\n\n”);

initialize();

printf(“\n Enter the expression”);

printf(“\n And Place’;’ at the end”);

printf(“Press ctrl+z to terminate”);

parser();

getch();

}

26

INPUT AND OUTPUT :

Program for Recursive Descent parsing

Enter the expression

And place; at the end

Press ctrl + z to terminate

ax + by + cz;

Identifier =ax

Identifier : by

Arithmetic Operator: +

Identifier : cz

Arithmetic Operator : +

RESULT :

Thus the implementation of recursive descent parsing using C program is successfully

written and verified.

27

Ex.No : 05 PARSER IMPLEMENTATION USING YACC & LEXDate :

AIM :

To write a program to implement the parser using YACC and LEX tool.

ALGORITHM :

1. Start the program.

2. Create the translator programs calc1.y and calc1.l using YACC and LEX respectively.

3. Calc1.y

i. In the Declaration part, include the header files of ‘c’ and ‘lex’.

ii. Specify the token to be processed as integer.

iii. Write the translation rules for the arithmetic expressions ‘+’, ‘-‘, ‘*’,’/’.

iv. Write the error routine yyerrror().

v. In order to create Yacc lexical analyzer with lex, include lex.yy.c and call the parser

function yyparse() in the main().

4. Calc1.l

i. Include the necessary files in the declaration part.

ii. In the translation part, analyze the input characters one by one return the

corresponding values.

iii. If no one matches the pattern, then return the error message.

5. Compile calc1.y and calc1.l using yacc and lex tool respectively so that it will generate the

y.tab.c file automatically.

6. Compile y.tab.c using cc compiler and get the output.

28

CODING :

// parser.y

%{

#include <stdio.h>

int yylex(void);

void yyerror(char *);

%}

%token INTEGER

%%

program:

program expr '\n' { printf("%d\n", $2); }

|

;

expr:

INTEGER

| expr '+' expr { $$ = $1 + $3; }

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

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

| expr '/' expr { $$ = $1 / $3; }

;

%%

void yyerror(char *s)

{

fprintf(stderr, "%s\n", s);

}

#include "lex.yy.c"

int main(void)

{

yyparse();

return 0;

}

//parser.l

%{

29

#include <stdlib.h>

void yyerror(char *);

%}

%%

[0-9]+ {

yylval = atoi(yytext);

return INTEGER;

}

[+*-/\n] { return *yytext; }

[ \t] { }

. yyerror("Unknown character");

%%

int yywrap(void) {

return 1;

}

30

INPUT AND OUTPUT :

$ lex calc1.l

$ yacc calc1.y

$ cc y.tab.c

$ ./a.out

23*4

92

20*3

60

2*3+10

26

RESULT :

Thus the program to implement the parser using YACC and LEX tool is written and the

output is verified.

31

Ex.No : 06 IMPLEMENTING CALCULATOR USING YACCDate :

AIM :

To write a program to implement the calculator using YACC tool.

ALGORITHM :

1. Start the program.

2. In the Declaration part, include the header files stdio.h and ctype.h and initialize variables ‘i’

and‘t’.

3. Specify the token to be processed as DIGIT.

4. Write the translation rules for the arithmetic expressions ‘+’, ‘-‘, ‘*’,’/’ and others as ‘^’ and

‘\n’.

5. Write the error routine yyerrror().

6. Analyze the input characters one by one and convert it from ASCII values to their original

values and return it.

7. Call the parser function yyparse() in the main method.

8. Stop the program.

32

CODING :

%{

#include<stdio.h>

#include<ctype.h>

int i,t=0;

%}

%token DIGIT

%%

line : expr'\n' { printf("%d\n",$1);};

expr : expr '+' term { $$=$1+$3;}| term;

term : term '*' val{ $$=$1*$3;}| val;

val : val '-' val1 {$$=$1-$3;}|val1;

val1 : val1 '/' val2 {$$=$1/$3;}|val2;

val2 :val2 '^' factor {t=$1;for(i=0;i<$3-1;i++) $1*=t;$$=$1;} |factor;

factor:'('expr')'{$$=$2;}| DIGIT;

%%

int main(void)

{

return yyparse();

}

void yyerror(char*s)

{

fprintf(stderr,"%s\n",s);

}

yylex()

{

int c;

c=getchar();

if(isdigit(c))

{

yylval=c-'0';

return DIGIT;

}

return c;}

33

INPUT AND OUTPUT:

$ yacc calc.y

$ cc y.tab.c

$ ./a.out

2*3+5-2

9

RESULT :

Thus the program to implement the calculator using YACC tool is written and the output is

verified.

34

Ex.No : 07 SIMPLE INTERMEDIATE CODE GENERATION

Date :

AIM :

To write a ‘c’ program to generate the simple intermediate code for the given postfix

expression.

ALGORITHM :

1. Start the program.

2. Get the input expression from the user.

3. Scan the expression one by one until ‘=’ is found.

4. Increment the i value by one when the character is alphabet.

5. Call the codegen().

6. Codegen() analyses the input stream and generates the intermediate

code.

7. The process exits when ‘\0’ character is encountered.

8. Stop the program.

35

CODING :

#include<stdio.h>

#include<ctype.h>

#include<string.h>

void codegen();

char exp[20];

int i=0,t=49;

void main()

{

int j;

printf("Enter the postfix expression ending with ’=’:");

scanf("%s",exp);

while(exp[i]!='=')

{

while(isalpha(exp[i]))

i++;

codegen();

}

printf("%c %c t\%c\n\n",exp[0],exp[2],exp[1]);

getch();

}

void codegen()

{

int j,k;

if(isdigit(exp[i-1]))

printf("t%c %c t%c %c\n\n",t,exp[i],exp[i-1],exp[i-2]);

else if (isdigit(exp[i-2]))

printf("t%c %c %c t%c\n\n",t,exp[i],exp[i-1],exp[i-2]);

else

printf("t%c %c %c %c\n\n",t,exp[i],exp[i-1],exp[i-2]);

exp[i-2]=t;

k=i-1;

j=i+1;

while(exp[j]!='\0')

36

{

exp[k]=exp[j];

k++;

j++;

}

exp[k]='\0';

i=i-1;

t++;

}

37

INPUT AND OUTPUT :

Enter the postfix exp:

abcd*+e- = z

t1 * d c

t2 + t1 b

t3 - e t2

a = t3

RESULT :

Thus the ‘c’ program to generate the simple intermediate code for the given postfix

expression is written and the output is verified.

38

Ex.No : 08 INTERMEDIATE CODE GENERATION THREE ADDRESSDate : CODE FOR BOOLEAN EXPRESSION

AIM :

To write a ‘c’ program to generate the three address code for Boolean expression.

ALGORITHM :

1. Start the program.

2. Create the input file ‘inp.txt’ containing input code to be given.

3. Open the file by specifying the path and scan the input streams one by one and print it.

4. Then analyze the characters one by one whether it is an integer, keyword, operator or

identifier and generates the three address code accordingly.

5. Stop the program.

39

CODING :

#include<stdio.h>

#include<conio.h>

#include<string.h>

void main()

{

FILE *in;

char temp[20],a[20],inp[20];

int i,j,k,f,f1;

clrscr();

i=0;

in=fopen("c:\\inp.txt","r");

printf(“\n Input file contains…”);

while((fscanf(in,"%s\n",inp))!=EOF)

{

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

}

rewind(in);

printf("\n\n Three Address Code\n");

while((fscanf(in,"%s\n",inp))!=EOF)

{

if((inp[i]=='i')&&(inp[++i]=='f'))

{

printf("1 if");

i=i+2;

do

{

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

i++;

}

while(inp[i]!=')');

printf("goto 5\n");

fscanf(in,"%s",a);

f=1;

40

}

else if(strcmp(inp,"else")==0)

{

i=0;

fscanf(in,"%s",temp);

while(temp[i]!='=')

{

i++;

}

k=i;

printf("2 t=");

for(j=k+1;j<strlen(temp)-1;j++)

{

printf("%c",temp[j]);

}

printf("\n3 %c=t",temp[0]);

printf("\n4 goto 7");

f1=1;

}

if(f==1 && f1==1)

{

i=0;

k=0;

while(a[i]!='=')

{

i++;

}

k=i;

printf("\n5 t1=");

for(j=k+1;j<strlen(a)-1;j++)

{

printf("%c",a[j]);

}

printf("\n6 %c =t1\n",a[0]);

41

}

}

getch();

}

42

INPUT AND OUTPUT :

Inp.txt

if(b<c)

a=c-b;

else

a=b-c;

Three Address Code

1 ifb<cgoto 5

2 t=b-c

3 a=t

4 goto 7

5 t1=c-b

6 a =t1

RESULT :

Thus the ‘c’ program to generate the three address code for Boolean expression is written and

the output is verified.

43

Ex.No : 09 ASSEMBLY CODE GENERATIONDate :

AIM :

To write a ‘c’ program to generate the assembly code for the given input.

ALGORITHM :

1. Start the program.

2. Create the input file ‘instrn.txt’ containing input code to be given.

3. Get the choice of whether the input should be given manually or to be read from the input.

4. If the input to be get manually, then get number of statements and run the ‘for’ loop

accordingly and get the input statements.

5. Save the input statements in the file named ‘userinp.txt’ and open the file.

6. If the input to be read from the file, then open ‘instrn.txt’.

7. Then analyze the characters one by one whether it is an integer, keyword, operator or

identifier and generates the assembly code accordingly.

8. Stop the program.

44

CODING :

#include<stdio.h>

#include<conio.h>

char* findinstrn(char);

void main()

{

int i,j,k,m,n,f,t,p=1;

char a,a1,l,op,tas[20],instrn[20];

FILE *f1,*f2,*f3;

clrscr();

f1=fopen("c:\\instrn.txt","r");

f2=fopen("c:\\userinp.txt","w");

i=1;

while(p==1)

{

rewind(f1);

printf("\n\nTo give input directly press 1 or To take from a file press 0:");

scanf("%d",&t);

if(t==1)

{

printf("\n\nEnter the no of statements:");

scanf("%d",&n);

printf("\n\nNow enter the statements\n\n");

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

{

scanf("%s",tas);

fprintf(f2,"\n%s",tas);

}

fclose(f2);

f3=fopen("userinp.txt","r");

}

else

f3=fopen("c:\\instrn.txt","r");

while(!feof(f3))

45

{

fscanf(f3,"%s",tas);

f=0;

if(strlen(tas)==5)

{

l=tas[0];

a=tas[2];

op=tas[3];

a1=tas[4];

f=1;

}

else

{

l=tas[0];

a=tas[2];

}

if(f==1)

{

printf("\nMOVE\tR%d,%c",i,a);

strcpy(instrn,findinstrn(op));

printf("\n%s\tR%d,%c",instrn,i,a1);

printf("\nMOVE\t %c,R%d",l,i);

i++;

}

else

printf("\nMOVE\t %c,%c",l,a);

}

printf("\n\nDo U want to continue(y=1/n=0):");

scanf("%d",&p);

}

fcloseall();

getch();

}

char* findinstrn(char c)

46

{

if(c=='+')

return "ADD";

else if(c=='-')

return "SUB";

else if(c=='/')

return "DIV";

else if(c=='*')

return "MUL";

else

return "";

}

47

INPUT FILE:

instrn.txt

A=c*d

B=e/f

C=b+A

D=C-B

a=D

OUTPUT:

To give inputs directly press 1 or to take from a file press 0:0

MOVE R1,c

MUL R1,d

MOVE A,R1

MOVE R2,e

DIV R2,f

MOVE B,R2

MOVE R3,b

ADD R3,A

MOVE C,R3

MOVE R4,C

SUB R4,B

MOVE D,R4

MOVE a,D

Do U want to continue(y=1/n=0):1

To give input directly press 1 or To take from a file press 0:1

Enter the no of statements:3

Now enter the statements

A=b*c

B=A+d

a=B

MOVE R3,b

MUL R3,c

MOVE A,R3

48

MOVE R4,A

ADD R4,d

MOVE B,R4

MOVE a,B

RESULT :

Thus the ‘c’ program to generate the assembly code for the given input is written and the

output is verified.

49