Finalised Modified Copy of Pcd Lab Manual

SEC CSE/VI PCD LAB MANUAL

1

SRINIVASAN ENGINEERING COLLEGE

COMPUTER SCIENCE AND ENGINEERING

ANNA UNIVERSITY OF TECHNOLOGY TRICHIRAPALLI

REGULATION 2008

III CSE (2010-2014)

CS1356

COMPILER DESIGN LABORATORY

LAB MANUAL

BY

S.JAYANTHI, Assistant Professor.

A.SATHIYA, Assistant Professor.


2

Preface

This laboratory manual is prepared by the Department of Computer Science and

engineeringfor Compiler Design Laboratory (CS-1356). Thislab manual can be used as

instructional book for students, staff and instructors to assist in performing and understanding the

experiments. In the first part of the manual, experiments as per syllabus are described and in the

second part of the manual, experiments that are beyond the syllabus but expected for university

laboratory examination are displayed. Thismanual will be available in electronic form from

College‟s official website,for the betterment of students.

Acknowledgement

Wewould like to express our profound gratitude and deep regards to the support offered

by the ChairmanShri. A.Srinivasan. We also take this opportunity to express a deep sense of

gratitude to our Principal Dr.B.Karthikeyan,M.E,Ph.D, for his valuable information and

guidance, which helped us in completing this task through various stages.We extend our hearty

thanks to our head of the department Prof.J.Mercy Geraldine M.E, (Ph.D), for her constant

encouragement and constructive comments.

Finally the valuable comments from fellow faculty and assistanceprovided by the

department are highly acknowledged.


3

CHAPTER NO TOPIC PAGE NO

I

Introduction to the language 5

Main Features

Advantages

Limitations

Applications

II Syllabus 6

III System Requirements 7

IV

Description about each experiment

Aim

Learning Objective

General procedure to execute programs

8

V Experiments

1 &2 Implementalexicalanalyzerin“C”. 10

3 UseLEXtooltoimplementalexicalanalyzer. 22

4 Implementarecursivedescentparserforanexpressiongramm

arthat generatesarithmeticexpressionswithdigits,+and*.

29

5 UseYACCandLEXtoimplementaparserforthesamegra

mmarasgiveninproblem. 33

6 Write semantic rules to the YACC program in

problem 5 and

implementacalculatorthattakesanexpressionwithdigits

,+and*andcomputesandprintsitsvalue.

37

7&8 Implementthefrontendofacompilerthatgeneratesthethreead

dresscode for a simple language with: one data type

integer, arithmetic operators, relational operators,

variable declaration statement, oneconditional

construct,oneiterativeconstructandassignmentstatement.

44

9&10 Implementthebackendofthecompilerwhichtakesthethreead

dresscodegeneratedinproblems7and8,andproducesthe8086

assembly language instructions that can be assembled and

run using a 8086

assembler.Thetargetassemblyinstructionscanbesimplemov

e,add, sub,jump.Alsosimpleaddressingmodesareused.

51

VII Experiments beyond the syllabus 56

VIII Future Enhancements 64

References


4

INTRODUCTION OF THE LANGUAGE (Turbo C language)

MAIN FEATURES

It is a robust language whose rich set of built-in functions and operators can be used

to write any complex program

C is highly portable. This means that C programs written for one computer can be

run onanother with little or no modification.

C language is well suited for structured programming, thus requiring the user to

think of a problem in terms of function modules or blocks.

Programs written in C are efficient and fast. This is due to its variety of data types

andpowerful operators. It is many times faster than BASIC.

Another important feature of C is its ability to extend itself. A C program is

basically acollection of functions, which are supported by the C library.

ADVANTAGES

C source code can be optimized much more than higher-level languages because the

language set is relatively small and very efficient

C has which is its application in Firmware programming (hardware). That is due to

its ability to use/work with assembly and communicate directly with controllers,

processors and other devices.

C is a building block for many other currently known languages.

C is a compiled language versus an interpreted language. Explained simply, this

means that the code is compacted into executable instruction (in the case of

windows anyway) rather than being "translated" on the fly at run time.

LIMITATIONS

Weak text processing capabilities - C's string library is extremely primitive (it

doesn't even define an actual string type), and text processing is labor-intensive and

error-prone.

Security and safety issues- several library functions (gets() being the most

notorious) provide easy exploits for malware, and anything involving pointers is

going to be unsafe (it's hard to guard against being passed an invalid pointer);

Weak memory management capabilities - Like text processing, managing

memory in C is labor-intensive and error-prone

No built-in collections library - C doesn't provide readymade collections (lists,

queues, stacks, etc.), meaning you have to roll your own.

No built-in support for networking, sound, graphics, etc. - C is a product of the

early 1970s and it shows; byte streams are about the highest level of abstraction

you're going to find in the C library.


5

APPLICATIONS

C language is used for creating computer applications and also used a lot in writing embedded

software/firmware for various electronics, industrial and communications products which use

micro-controllers.

It is also used in developing verification software, test code, simulators etc. for various

applications and hardware products.

C has been used successfully for every type of programming problem imaginable from operating

systems to spreadsheets to expert systems.

C was initially used for system development work, in particular the programs that make-up the

operating system.

C has been used as a general-purpose language because of its popularity with programmers.


6

SYLLABUS

CS1356 –COMPILERDESIGNLABORATORY

LISTOFEXPERIMENTS

1&

2 Implementalexicalanalyzerin“C”.

3 UseLEXtooltoimplementalexicalanalyzer.

4 Implementarecursivedescentparserforanexpressiongrammarthat

generatesarithmeticexpressionswithdigits,+and*.

5 UseYACCandLEXtoimplementaparserforthesamegrammarasgiveninproblem

6 Write semantic rules to the YACC program in problem 5 and

implementacalculatorthattakesanexpressionwithdigits,+and*andcomputesandprintsitsval

ue.

7&

8 Implementthefrontendofacompilerthatgeneratesthethreeaddresscode for a simple

language with: one data type integer, arithmetic operators, relational operators, variable

declaration statement, oneconditional

construct,oneiterativeconstructandassignmentstatement.

9&

10 Implementthebackendofthecompilerwhichtakesthethreeaddresscodegeneratedinproblems

7and8,andproducesthe8086assembly language instructions that can be assembled and

run using a 8086 assembler.Thetargetassemblyinstructionscanbesimplemove,add,

sub,jump.Alsosimpleaddressingmodesareused.


7

SYSTEM REQUIREMENTS

HARDWARE REQUIREMENTS

Processors - 2.0 GHz or Higher

RAM - 256 MB or Higher

Hard Disk - 20 GB or Higher

Operating System - Linux andWindows 2000/XP/NT

SOFTWAREREQUIREMENTS

TURBO C (Freeware)


8

ABOUT THE COMPILER LABORATORY

AIM

To provide an understanding of the design aspect of operating system.

To introduce the major concept areas of language translation and compiler design.

To develop an awareness of the function and complexity of modern compilers.

To provide practical, hands-on experience in compiler design, writing and modification.

To provide an introduction to the system software like assemblers, compilers, and

macros.

OVERVIEW OF THE EXPERIMENTS Lexical analyzerprogram that reads source program and produce a list of tokens

(“linear” analysis)

Lexis a program generator that takes lexical specification as input, and produces a

lexical processor written in C. (The code for lex file can be saved with .l extension)

YACCandLEX tools can generate code for a single function – respectively, “get a token

form input stream” and “parse a sequence of tokens to see if it matches a grammer”..

(The code for YACC file can be saved with .y extension)

YACCtool is well implemented to perform calculator

functionthattakesanexpressionwithdigits,+and*andcomputesandprintsitsvalue.

Front end of the compiler parses and tokenizes the source file, verify syntax and

semantics (the rules of the programming language), and translate the source code into an

intermediate representation (threeaddresscode).

Backend takes the intermediate representation of the code and converts it into

targetassemblyinstructions.

LEARNING OBJECTIVES

The objective of this lab is to provide a student with an understanding of the fundamental

principles in compiler design and to provide the skills needed for building compilers.They can

also have knowledge of the underlying machine architecture, the limitations and efficiency of

various design techniques of compilers implementation. It also covers programming in various

tools like LEX and YACC for scanning and parsing etc.


9

GENERAL PROCEDURE FOR EXECUTING PROGRAMS

Steps to execute a C program with Linux utility. Step 1 :Use an editor, such as vi, ex, or ed to write the program. The name of the file containing

the program should end in .c(Ex: vishow.c)

For example, the file show.ccontains the following lines:

main()

{

printf(“ welcome to GNEC “);

}

Step 2: To save the file

:wq

Step 3: Submit the file to CC ( the C Compiler )

$ cc show.c

If the program is okay, the compiled version is placed in a file called a.out

Step 4: To run the program, type a.out

$ a.out


10

EX NO: 1&2

IMPLEMENTATION OF A LEXICAL ANALYZER DATE :

DESCRIPTION

Break input string into “words” called tokens

The main functions of lexical analyzer are :-

Stripping out comments and white spaces

Correlating error messages with the source program

OBJECTIVE

The main objective is to to write a program to implement a lexical analyzer which can

read input characters and group them into “tokens.”

HOW IT IS BEING ACHIEVED?

It is achieved by extracting character from the expression using built in functions in C,

such as is alpha(),isalnum(), etc.

SYNTAXES & KEYWORDS

isalpha()-Returns True if all characters in s are alphabetic, False otherwise

isalnum ()-Returns True if all characters in s are alphanumeric, False otherwise.

HOW TO EXECUTE THE PROGRAM

[cs303@localhost cs303]$ cc lexical

[cs303@localhost cs303]$ ./a.out

REQUIREMENTS FOR EXECUTION

S.No. Facilities required Quantity

1 System 1

2 O/S Turbo C

3 S/W name Compiler


11

EXPECTED OUTPUT AND ITS FORM

This program takes a source program as input, and it is expected to produce a stream of

tokens as output.

LIMITATIONS

The lexical analyzer reads source text and produces tokens, which arethe basic lexical units of

the language.

The limitations are some trailing context patterns cannot be properly matched and generate

warning messages („dangerous trailing context‟).

APPLICATIONS

Lex, a programming tool for the Unix system, is a successful solution to the general problem of

lexical analysis.

Lex is targeted only C. It also places artificial limits on the size of strings that can be recognized.

This feature is typically used to handle quoted strings with escapes to denote special characters.

ALGORITHM

1.Start the program.

2.Extract first character from the expression using get char () function.

3.Check the character

i) If it is a digit then print the token as number.

ii) If it is a „+‟,‟-„,‟*‟, or „/‟ then print the token as OPERATOR.

iii) If it is a „<‟,‟>‟,‟<=‟,‟>=‟,‟/-„,--, then print the token as RELATIONAL OPERATOR.

iv) If it is a „(„,‟)‟, then print the token as PARANTHESIS.

v) If it is an „int‟,‟float‟,‟if‟‟,‟while‟, and etc then print the token as KEYWORD.

vi) If it is a Single letter on a letter followed by a digit or number, and then prints the token as

IDENTIFIER.

4.Token is obtained using Step 3.

5. Go to Step3 otherwise proceed.


12

PROGRAM

PROGRAM NAME:lexical.c

#include<stdio.h>

#include<string.h>

#include<ctype.h>

Void main()

{

charstr[MAX];

int state=0;

inti=0,j,started=0,endid,startcon,endcon;

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

str[j]=NULL;

printf(“\nProgram on lexical analyzer\n”);

printf(“\nEnter the string”);

gets(str);

str[strlen(str)]=‟‟;

printf(“\nAnalysis”);

while(str[i]!=NULL)

{

while(str[i]==‟‟)

i++;

switch(state)

{

case 0:

if(str[i]==‟i‟)state=1;

else if(str[i]==‟w‟)state=3;

else if(str[i]==‟d‟)state=8;

else if(str[i]==‟e‟)state=10;

else if(str[i]==‟f‟)state=14;

else if(isalpha(str[i])||str[i]==‟_‟)

{

state=17;

stated=I;

}

else if(str[i]==‟<‟)state=19;

else if(str[i]==‟>‟)state=21;

else if(str[i]==‟=‟)state=23;

{

state=25;

startcon=I;

}

else if(str[i]==‟(‟)state=26;


13

else if(str[i]==‟)‟)state=27;

else if(str[i]==‟;‟)state=28;

else if(str[i]==‟+‟)state=29;

else if(str[i]==‟-‟)state=30;

break;

case 1:

if(str[i]==‟f‟)state=2;

else

{

state=17;

Startid=i-1;

i--;

}

break;

case 2:

if(str[i]==‟c‟||str[i]==NULL)

{

printf(“\nif:Keyword”);

state=0;

i--;

}

else

{

state=17;

started=i-2;

i--;

}

break;

case 3:

if(str[i]==‟h‟)state=4;

else

{

state=17;

start=i-1;

i--;

}

break;

case 4:

if(str[i]==‟I‟)state=5;

else

{

state=17;

state=i-2;

i--;


14

}

break;

case 5:

if(str[i]==‟e‟)state=6;

else

{

state=17;

started=i-3;

i--;

}

break;

case 6:


else

{

state=17;

state=i-4;

i--;

}

break;

case 7:

if(str[i]==‟(„||str[i]==NULL)

{

printf(“\nWhile:Keyword”);

state=0;

i--;

}

else

{

state=17;

started=i-5;

i--;

}

break;

case 8:

if(str[i]==‟0‟)state=9;

else

{

state=17;

startid=i-1;

i--;

}

break;


15

case 9:

if(str[i]==‟{„||str[i]==‟‟||str[i]==NULL||str==‟(„)

{

printf(“\nDo:Keyword”);

state=0;

i--;

}

break;

case 10:

if(str[i]==‟l'state=11;

else

{

state=17;

startid=i-1;

i--; }

break;

case 11:

if(str[i]==‟s‟)state=12;

else

{

state=17;

startid=i-2;

i--;

}

break;

case 12:


else

{

state=17;

startid=i-3;

i--;

}

break;

case 13:

if(str[i]==‟{„||str[i]==‟‟||str[i]==NULL)

{

printf(“\nElse:Keyword”);

state=0;

i--; }

else

{

state=17;

startid=i-4;


16

i--; }

break;

case 14:

if(str[i]==‟o‟)state=15;

else

{

state=17;

startid=i-1;

i--;

}

break;

case 15:

if(str[i]==‟r‟)state=16;

else

{

state=17;

startid=i-2;

i--;

}

break;

case 16:

if(str[i]==‟(„||str[i]==NULL)

{

printf(“\nFor:Keyword”);

state=0;

i--;

}

else

{

state=17;

startid=i-3;

i--;

}

break;

case 17:

if(isalnum(str[i])||str[i]==‟-„)

{

state=18;

i++;

}

else

if(str[i]==NULL||str[i]==‟<‟||str[i]==‟>‟||str[i]==‟(„||str[i]==‟)‟||str[i]==‟;‟||str[i]==‟+‟||str[i]= =‟-„)

state=18;

i--;


17

break;

case 18:

if(str[i]==NULL||str[i]==‟<‟||str[i]==‟>‟||str[i]==‟(„||str[i]==‟)‟||str[i]==‟;‟||str[i]==‟+‟||str[i]=

=‟-„)

{

endid=i-1;

printf(“\n”);

for(j=startid;j<endid;j++)

printf(“\n%c”,str[i]);

printf(“\nn:Identifier”);

state=0;

i--;

}

break;

case 19:

if(str[i]==‟=‟)

state=20;

i--;

else if(isalnum(str[i])||str[i]==‟-„)

{

printf(„\n<:Relational Operator”);

state=0;

}

break;

case 20:

if(isalnum(str[i]||str[i]==‟-„)

{

printf(“\n<=Relaitonal Operator”);

i--;

state=0;

}

break;

case 21:

if(isalnum(str[i]||str[i]==‟=„)

state=22;

else if(isalnum(str[i])||str[i]==‟-„)

{

printf(“\n>:Relaitonal Operator”);

i--;

state=0;


18

}

break;

case 22:

if(isalnum(str[i])||str[i]==‟-„)

{

printf(“\n>:Relaitonal Operator”);

i--;

state=0;

}

break;

case 23:

if(str[i]==‟=‟)

state=24;

else

{

printf(“\n=:Assignment Operator”);

i--;

state=0;

}

case 24:

if(isalnum(str[i])

{

printf(“\n==:Relational Operator”);

state=0;

}

break;

case 25:

if(isalpha(str[i])

{

printf(“\n**ERROR**”);

puts(str);

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

printf(“\n”);

printf(“\n”);

printf(“\nError at position %d alphabet cannot follow digit”,i);

state=99;

}

else if(str[i]==‟(„||str[i]==‟)‟||str[i]==‟<‟||str[i]==‟>‟||str[i]==NULL||str[i]==‟;‟||str[i]==‟=‟)

{

endcon=i-1;

printf(“”);

for(j=startcon;j<=endcon;j++)

printf(“\n%c”,str[i]);

printf(“\n:Constant”);


19

state=0;

i--;

}

break;

case 26:

printf(“\n(:Special Character”);

startid=I;

state=0;

i--;

break;

case 27:

printf(“\n):Special Character”);

state=0;

i--;

break;

case 28:

printf(“\n;:Special Character”);

state=0;

i--;

break;

case 29:

printf(“\n+:Operator”);

state=0;

i--;

break;

case 30:

printf(“\n-:Operator”);

state=0;

i--;

break;

case 99:

goto END;

}

i==;

}

printf(“\nEnd of program”);

END:

}


20

OUTPUT

[cs303@localhost cs303]$ cc lexical.c

[cs303@localhost cs303]$ ./a.out

Enter the string: (a+b)

),( : Special Character

b,a : Identifier

h+ : Arithmetic Operator

RESULT

The program has been executed to the lexical analyzer in „C‟ was implemented and the above output

is obtained

VIVA QUESTIONS

1. List the various phases of a compiler. (Nov/Dec 2008)

The following are the various phases of a compiler:

Lexical Analyzer

Syntax Analyzer

Semantic Analyzer

Intermediate code generator

Code optimizer

Code generator

2. Describe Lexical analyzer.

It converts a text representation of the program (sequence of characters) into a sequence

of lexical unit for a particular language (tokens). A program which performs lexical analysis is

called a lexical analyzer, lexer or scanner.

3.What is a symbol table?

A symbol table is a data structure containing a record for each identifier, with fieldsfor the

attributes of the identifier. The data structure allows us to find the record for eachidentifier quickly and to

store or retrieve data from that record quickly. Whenever an identifier is detected by a lexical analyzer, it

is entered into the symbol table. The attributes of an identifier cannot be determined by the lexical

analyzer.


21

4.What is a compiler?

A compiler is a program that reads a program written in one language–the source language and

translates it into an equivalent program in another language-the target language.The compiler reports to

its user the presence of errors in the source program.

POSSILBLE QUESTIONS

1. Implement a lexical analyzer Input string - a C program with Comments

2.Implement a lexical analyzer Input string - a C program to calculate leading of non terminal.

3.Implement a lexical analyzer Input string - a C program without Comments


22

EX NO: 3

IMPLEMENTATION OF A LEXICAL ANALYZER USING LEXTOOL

DATE :

DESCRIPTION

Lex is a tool for generating scanners. Scanners are programs thatrecognize lexical

patterns in text. These lexical patterns (or regularexpressions) are defined in a particular syntax.

OBJECTIVE

The main objective is lex is a tool that converts input information into a series of tokens.

SYNTAXES & KEYWORDS

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

The shorthand character range construction „[x-y]‟ matches any of the characters

between (and including) x and y. For example, [a-c] means the same as a|b|c, and [a-cA-C]

means the same as a|b|c|A|B|C.

# assigns “PREPROCESSOR DIRECTIVE”

If the statement begins with „\*‟ and ends with „*/‟ the Assign as “COMMENT”.

LEX SOURCE PROGRAM

LEX SPECIFICATION

The lex program consists of three parts

%{

declarations

%}

%%

translation rules

%%

auxillary procedures

The declarations section includes declarations of variables,constants and regular

definitions.

The regular definitions are statements and are used as components of the regular

expressions,appearing in the translation rules.


23

The translation rules of a lex program are of the form

P1{action 1}

P2{action 2}

.

.

.

pn{action n}

The simple lex example

%{

#include <stdio.h>

%}

%%

beginprintf("Started\n");

helloprintf("Hello yourself!\n");

thanksprintf("Your welcome\n");

endprintf("Stopped\n");

%%

The first block, defined by the %{...%}, defines the text that will be inserted into thegenerated C

source. In this case, because the examples later use the printf()function, you ensure that the

stdio.h header is included.

The second block, identified by the %% sequence, contains the definitions of theidentified string

input and the result. In these cases, for a simple word, anappropriate response is printed.

fopen() is used to open the source for scanning.

identifier [a-zA-Z][a-zA-Z0-9]* is used to separate tokens that matches any of the characters

between (and including) […].


[CS228@localhost cs228]$ vilexprogram.c

[CS228@localhost cs228]$ lexprogram.l

{cs228@localhost cs228]$cc lexprogram.yy.c

[cs228@localhost cs228]$./a.outarea.c


24



1 System 1

2 O/S Linux

3 S/W name Compiler

EXPECTED OUTPUT AND ITS FORM:

Lex tool inthis program is expected to produce tokens.

ADVANTAGES

It quickly generates solutions to problems that involve lexical analysis, that is, the recognition of

strings of characters that satisfy certain characteristics.

This enables to solve a wide class of problems drawn from text processing, code enciphering,

compiler writing, and other areas.

LIMITATIONS

We can easily understand some of lex‟s limitations. For example, lex cannot be used to

recognize nested structures such as parentheses. Nested structures are handled by incorporating a

stack.

Whenever we encounter a “(” we push it on the stack. When a “)” is encountered we match it

with the top of the stack and pop the stack. However lex only has states and transitions between

states.

APPLICATIONS

Lex is used to create a sample lexical analyzer for c programming language;it can recognize the

valid symbols in c programming language including valid programming constructs.


25

ALGORITHM

1. Initialize COMMENT=0

Declare the Statement rule for the identifier.

2. If the statement begins with # then assign“PREPROCESSOR DIRECTIVE”.

If the variables are declared as Int, Float, Char, Double, Long, Struct and Words are like

whilefor break and Then assign as “KEYWORDS”.

3. If the statement begins with # then assign“PREPROCESSOR DIRECTIVE”.

If the variables are declared as Int, Float, Char, Double, Long, Struct and Words are like

while for break and Then assign as “KEYWORDS”.

If it is a not a COMMENT, then mark as FUNCTION.

4. If the word enclosed with “ “then print it as string and if it has [0-9] then Print as

“NUMBER”

5. It contains operators like <, >, <=, >=, := then assign as Relational Operators.

PROGRAM

%{

Int COMMENT=0;

%}

Identifier[a-zA-Z][a-zA-Z0-9]*

%%

#.*{print{“\n %s is a PREPROCESSOR DIRECTIVE”,yynext);}

Int|

Float|

Char|

double|

while|

do|

for|

if|break|

continue|

void|

switch|

case|

long|

struct|

const|

tupedef|


26

return|

else|

goto { print(“\n|n\t %s is a KEYWORD”,YYTEXT);}

“/*”{COMMWNR=1;}

“*/”{COMME[NT=0;}

{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 anASSIGNMENTOPERATOR”,yytext);]

\<=|

\>=|

\<|

==|

\>{if(!COMMENT)printf(“\n\t is a RELATIONAL OPERATOR”,yytext);}

.|\n

%%

int main(intargc,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();

}

//input program saved in .c

#include<stdio.h>

#include<stdlib.h>

double area of circle(double v);

int main(intargc,char *argv[])

{


27

if(argc<2)

{

printf(“usage;%s radius\n”,argv[0]);

exit(1);

}

else

{

double radius =atof(argv[1]);

double area=area_of_circle_radius);

printf(“area of circle with radius %f-%f\n‟,radius,area);

}

return0;

}

OUTPUT

[CS228@localhost cs228]$lexprogram.l

{cs228@localhost cs228]$cc lexprogram.yy.c

[cs228@localhost cs228]$./a.outarea.c

RESULT

The program has been executed to the lexical analyzerusing lex tool in „C‟ was implemented and

the above output is obtained

VIVA QUESTIONS

1. List the various error recovery strategies for a lexical analysis.

Possible error recovery actions are:

Panic mode recovery

Deleting an extraneous character

Inserting a missing character

Replacing an incorrect character by a correct character

Transposing two adjacent characters

2.Define back patching.

Back patching is the activity of filling up unspecified information of labels

usingappropriate semantic actions in during the code generation process.In the

semanticactions the functions used are mklist(i),merge_list(p1,p2) and back patch(p,i)


28

3.Mention the functions that are used in back patching.

(i)creates the new list. The index iis passed as an argument to this function

Where I is an index to the array of quadruple.

(ii)merge_list (p1,p2) this function concatenates two lists pointed by p1 and p2.

It returns the pointer to the concatenated list.

(iii)backpatch (p,i) inserts i as target label for the statement pointed by pointer p.

POSSIBLE QUESTIONS

1. Write a Program to insert a character string into a file from the console.

2. Write a Program to recognize white space, count no. of identifiers, characters, tabs & the length

of the input strings 3. Write a Program to generate a token from input string


29

EX NO: 4

IMPLEMENTATION OF A RECURSIVEDESCENTPARSER DATE :

DESCRIPTION

A recursive-descent parser is simple to construct from a classical context-free grammar if

the grammar has the so-called LL(1) property; it means that the parser can always decide what to

do by looking at the next input character.

OBJECTIVE

To develop a recursive descendent parserthat attempts to verify that the syntax of the

input stream is correct as it is read from left to right.

SYNTAXES & KEYWORDS

Parsing Expression Grammar is a list of one or more ”rules” of the form:

name= expr;

where expris a parsing expression, and name is a name given to it. The name is a string of

one or moreletters (a-z, A-Z) and/or digits, starting with a letter. White space is allowed

everywhere except insidenames.

A recursive descent parser traverses the tree by first calling a procedure to recognize an E.

This procedure reads an 'x' and a '+' and then calls a procedure to recognize a T. This would look

like the following routine.


The program can be executed using a Turbo c compiler.


This program is expected to verify that the syntax of the input stream by reading it left to

write for its correctness.


30

ADVANTAGES

A recursive descent parser is clearly much simpler than an LL parser to implement, however

(just as an LL one is simply than an LR one).

Recursive-descent can handle any grammar which is LL(*) (that is, unlimitedlookahead) as well

as a small set of ambiguous grammars.

Recursive descent parsers tend to be faster but can be more complicated. Consequently, recursive

descent parsers are generally only used for simple tasks and grammar based parsers are used to

parse more sophisticated languages.

LIMITATIONS

The main limitation of recursive descent parsing (and all top-down parsing algorithms in

general) is that they only work on grammars with certain properties. For example, if a grammar

contains any left recursion, recursive descent parsing doesn't work.

Recursive descent parsing are its exponential time complexity and non-termination in the

face of left recursion.

APPLICATIONS

A Recursive Descent Parser supports the flexibility of an external DSL without requiring parser

generator.

The Recursive Descent Parser can be implemented in whatever general-purpose language one

chooses.

It uses control flow operators to implement the various grammar operators.

Individual methods or functions implement the parsing rules for the different nonterminal

symbols in the grammar.

ALGORITHM

1)Start the program.

2) Declare variables for buffer size and length.

3) Get the expansion for which recursive descent parsing to be implemented.

4) Recursive descent function is called.

5) If given expression is not regular error message is displayed.

6) Recursive Descent parser is implemented and expression is displayed.

7) Stop the program.


31

PROGRAM

#include<stdio.h>

#include<string.h>

void A(void);

char string[10];

intip_ptr = 0;

inti;

int main() {

int length = 0;

printf("Recursive Decent parser\n");

printf("\n\nProduction is:\n");

printf("\n\ts->cAb\n\tA->ad/a\n");

printf("\nEnter string: ");

scanf("%s", string);

length = strlen(string);

if (string[i] == 'c') {

ip_ptr++;

i++;

A();

if (string[i] == 'b') {

ip_ptr++;

i++;

}

}

if (length == ip_ptr&& length > 2)

printf("\nValid String\n");

else

printf("\nInvalid String\n");

return 0;

}

void A() {

if (string[i] == 'a') {

i++;

ip_ptr++;

if (string[i] == 'd') {

i++;

ip_ptr++;

}

}

}


32

OUTPUT

Recursive Decent parser

Production is:

s->cAb

A->ad/a

Enter string: ab

Invalid String

RESULT

The program has been executed to the

implementarecursivedescentparserforanexpressiongrammar was implemented and the above

output is obtained

VIVA QUESTIONS

1. Define recursivedescentparser.

A basic operation necessary for this involves reading characters from the input stream and

matching then with terminals from the grammar that describes the syntax of the input. Our

recursive descent parsers will look ahead one character and advance the input stream reading

pointer when proper matches occur.

2. Define chain rule.

Ridding a grammar of chain rules merely involves substitution and makes the resultant parser

more efficient.

3. Define Top-down parsing.

Start at the root of the parse tree and grow toward leaves

Pick a production & try to match the input

Bad “pick” may need to backtrack

POSSIBLE QUESTIONS:

1.Write a Program to read a text file.

2.Write a program to eliminate left recursion

3.Write a program which reads a left-recursive regular grammar, and removes left recursion from

the grammar.


33

EX NO:5 IMPLEMENTATION OF PARSER USING YACC AND LEX

DATE :

DESCRIPTION

YACC and LEX tool are used for analyzing the subset of CProgram thatrecognize a valid arithmetic

expression.

OBJECTIVE

Be proficient on writing grammars to specify syntax

Understand the theories behind different parsing strategies-their strengths and

limitations

Understand how the generation of parser can be automated

Be able to use YACC to generate parsers

SYNTAXES & KEYWORDS

o The symbols have higher precedence than symbols declared before in a %left, %right

or %nonassoc line.

o They have lower precedence than symbols declared after in a %left, %right or

%nonassoc line. The symbols are declared to associate to the left (%left), to the right

(%right), or to be non-associative (%nonassoc).



1 System 1

2 O/S LINUX

3 S/W name Compiler


34

HOW TO EXECUTE THE PROGRAM ?

The program can be executed C compiler in Linux OS.

$ lex prog1.l

$ yacc -d prog1.y

$ cc -c lex.yy.cy.tab.c

$ cc -o a.outlex.yy.oy.tab.o -lfl

$ ./a.out


This program is expected to verify the given arithmetic operation for its correctness.

ADVANTAGES

Parser using YACC AND LEX tool can be used to check arithmetic expression for its correctness.

ALGORITHM

1. Include the necessary header files.

2. Declare the semantic rule for the identifier and number.

3. If the statement begins with main (), if else * while, the return as

MAIN, IF ELSE and WHILE.

If the variables are declared as int, float and char then return as VAR and NUM

4. Include the necessary header files.

Initialize the err no=0 and declare like no as integer.

5. Declare the necessary tokens for the grammar.


35

PROGRAM

LEX PART

%{#include "y.tab.h"

%}

%%

[a-zA-Z] {return ALPHA;}

[0-9]+ {return NUMBER;}[\t\n]+ ;

. {returnyytext[0];}%%

YACC PART

%{#include<stdio.h>

%}

%token NUMBER ALPHA

%left '+''-'

%left '*''/'

%left '('')'

%%

expr:'+'expr

|'-'expr

|expr'+'expr

|expr'-'expr

|expr'*'expr

|expr'/'expr

|'('expr')'|NUMBER |ALPHA;

%%

int main()

{

printf("enter an arithematic expression\n");

yyparse();

printf("arithematic expression is valid\n");

return 0;

}

intyyerror(char *msg)

{

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

printf("\narithematic expression is invalid");

exit(0);

}


36

OUTPUT

$ lex prog1.l

$ yacc -d prog1.y

$ cc -c lex.yy.cy.tab.c

$ cc -o a.outlex.yy.oy.tab.o -lfl

$ ./a.out

enter an arithmetic expression(a+d)*(c-e)

Arithmetic expression is valid

RESULT

The program has been executed to the parser using YACC and LEX TOOL was

implementedand the above output is obtained.

VIVA QUESTIONS

1. Explain yacc and lex tool

Lex and Yacc can generate program fragments that solve the first task.

The task of discovering the source structure again is decomposed into subtasks:

1. Split the source file into tokens (Lex).

2. Find the hierarchical structure of the program (Yacc)

2. Defineflex, a fast scanner generator

Flex is a tool for generating scanners: programs which recognized lexical patterns in text. flex

reads the given input files, or its standard input if no file names are given, for a description of a

scanner to generate

3. Define Bison, The YACC-compatible Parser Generator

Bison is a general-purpose parser generator that converts a grammar description for an LALR(1)

context-free grammar into a C program to parse that grammar

POSSIBLE QUESTIONS

1. Convertthe BNF rules into Yacc form and write codetogenerate abstract syntax tree

2. Write a Program to read a text file and copy it into the other text file.

3.Implement parser using yacc


37

EX NO: 6

IMPLEMENTATION OF CALCULATOR USING YACC DATE :

DESCRIPTION

In this programs two classical tools for compilers, Lex and Yacc are used to create a

simple, desk-calculator program that performs addition, subtraction, multiplication, and division

operations.

OBJECTIVE

To write semantic rules to the YACC program and implement a calculator that takes an

expression with digits + and * and computes and prints its values.

SYNTAXES & KEYWORDS

LEX tool

Input to Lex is divided into three sections with %% dividing the sections. This is best illustrated

by example.

YACC tool

%token symbol...symbol

Declare the given symbols as tokens (terminal symbols). These symbols are added as constant

constructors for the token concrete type.

%token <type>symbol...symbol

Declare the given symbols as tokens with an attached attribute of the given type.

%start symbol...symbol

Declare the given symbols as entry points for the grammar.

%type <type>symbol...symbol

….definitions……..

%%

……rules……….

%%

……subroutines……….


38

%left symbol...symbol

%right symbol...symbol

%nonassocsymbol...symbol

Associate precedences and associativities to the given symbols. All symbols on the same line are

given the same precedence. They have higher precedence than symbols declared before in a

%left, %right or %nonassoc line. They have lower precedence than symbols declared after in a

%left, %right or %nonassoc line. The symbols are declared to associate to the left (%left), to the

right (%right), or to be non-associative (%nonassoc).

%% ……………….

……………………%%

In this program two classical tools for compilers are user, that are

o Lex: A Lexical Analyzer Generator

o Yacc: “Yet Another Compiler Compiler” (Parser Generator)

Lex creates programs that scan tokens one by one.

Yacc takes a grammar (sentence structure) and generates a parser.

In the first part of the program contains source code for Lex tool and the second part of

the program contains YACC tool which groups the tokens logically.

The program can be executed by using c compiler with linux utility.

Indicates the rules section of

the YACC program


39

To create the desk calculator example program, do the following:

1. Process the yacc grammar file using the -d optional flag (which informs the yacc command to

create a file that defines the tokens used in addition to the C language source code):

yacc -d desk.yacc

2. Use the ls command to verify that the following files were created:

y.tab.c

The C language source file that the yacc command created for the parser

y.tab.h

A header file containing define statements for the tokens used by the parser

3. Process the lex specification file:

lexdesk.lex

4. Use the ls command to verify that the following file was created:

lex.yy.c

The C language source file that the lex command created for the lexical analyzer

5. Compile and link the two C language source files:

cc y.tab.clex.yy.c

6. Use the ls command to verify that the following files were created:

y.tab.o

The object file for the y.tab.c source file

lex.yy.o

The object file for the lex.yy.c source file

a.out

The executable program file

To run the program directly from the a.out file, type:

$ a.out

OR

To move the program to a file with a more descriptive name, as in the following example, and

run it, type:

$ mva.out calculate

$ calculate


40


[root@localhost ~] # lexdesk.l

[root@localhost ~] # yacc –d desk.y

[root@localhost ~] # lex.yy.cy.tab.c –ll

[root@localhost ~] #./a.out



1 System 1

2 O/S Linux

3 S/W name Compiler

EXPECTED OUTPUT

Resultant value for the arithmetic operations.

USE OF THIS OUTPUT

The output can be used to decompose the compiler into two parts read the source program and

discover its structure(to solve this LEX and YACC used) from which target program can be

generated.

ADVANTAGES

In this program, single back end is developed for single source language.

It also has the advantage of allowing the use of a single back end for multiple source

languages, and similarly allows the use of different back ends for different targets.

APPLICATIONS

This program can be used to develop lexical analyzer and parser for a compiler using C programming

language.


41

ALGORITHM

1 . Start the program.

2.Perform the calculation using both the lex and yacc.

3.In the lex tool, if the given expression contains numbers and letters then they are displayed.

4.In the same way, the digits, letters and uminus are identified and displayed using yacctool.

5.The calculation is performed and the result is displayed.

6.Stop the program.

PROGRAM

LEX TOOL

%{

#include "y.tab.h"

#include<math.h>

%}

%%

[0-9]+ { yylval.dval = atof(yytext);

return NUMBER;

}

[0-9]+\.[0-9]+ { yylval.dval = atof(yytext);

return NUMBER;

}

[a-z] { yylval.vblname = yytext[0];

return NAME;

}

[ \t] { }

\n { return 0; }

. { returnyytext[0]; }

%%

YACC TOOL

%{

#include<math.h>

#include<stdio.h>

%}

%union

{


42

doubledval;

charvblname;

}

%token <vblname> NAME

%token <dval> NUMBER

%left '+' '-'

%left '*' '/'

%nonassoc UMINUS

%type <dval> expression

%%

statement: NAME '=' expression { printf("%c = %g \n",$1,$3); }

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

;

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

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

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

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

{

yyerror("Divide by zero");

}

else

$$ = $1 / $3;

}

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

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

| NUMBER { $$ = $1; }

;

%%

main()

{

yyparse();

}

intyyerror (char *s)

{

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

exit(0);

}


43

OUTPUT

[root@localhost ~] # lexdesk.l

[root@localhost ~] # yacc –d desk.y

[root@localhost ~] # lex.yy.cy.tab.c –ll

[root@localhost ~] #./a.out

((2+3) + (4+5))

= 26

RESULT

The program has been executed to lex and yacc tool is developed and a calculator operation is

achieved.

VIVA QUESTION AND ANSWERS

1. What is LEX?

Lex is a computer program that generates lexical analysis ("scanners" or "lexers").

2. Write the Structure of a Lex file.

The structure of a Lex file is divided into three sections, separated by lines that contain only

two percent signs, as follows:

Definition section

%%

Rules section

%%

C code section

3. What is YACC?

The Yacc is a computer program used to generate parser.

POSSIBLE QUESTIONS

1. Develop a parser which accepts a string and reports whether it is a valid SQL query

statement or not.

2. Implementa Lexical analyzer for identifying different types of token usingyacc and lex tool

3.Design a parser which accepts a string and tells whether the string is accepted by above

grammar or not using lex and yacc tool


44

EX NO: 7& 8

IMPLEMENTATION OF FRONT END OF COMPILER

DATE :

DESCRIPTION

The front end analyzes the source code to build an internal representation of the program,

called the intermediate representation of source code.

OBJECTIVE

To implement the front end of a compiler that generators the three address code for a

simple language with one data type integer arithmetic operator relational operators variable

declaration statement one conditional construct one iterative construct and assignment

statements.

Front end of the compiler can be developed by using the features of C programming language.

IMPORTANT SYNTAXES & KEYWORDS

scanf("%s",&pg[i]);

if((strcmp(pg[i],"getch();"))==0)

if(pg[j][1]=='=')

while((strcmp(pg[j],"}"))!=0)

if((strcmp(pg[j],"}"))==0)

DESCRIPTION

In this program first the program from the user is received an input. The operators are compared

to perform its relative operations for which assembly code will be created.


The program can be executed by using turbo Ccompiler(Alt+F9 … for compilation,

Ctrl+F9 … to Run)


45



1 System 1

2 O/S Windows XP

3 S/W name Compiler


Front end of the compiler is expected to generate intermediate representation of source code.

USE OF THIS OUTPUT

This program, the front end translates the source language into an intermediate representation.

This output can be given as the input to the second stage(or pass/ the back end) of the compiler.

ADVANTAGES

Developing front end of the compiler resolves the disadvantage of compiling in a single pass

where it is not possible to perform many of the sophisticated “compiler optimization” needed to

generate high quality code.

LIMITATIONS

It can be difficult to count exactly how many passes an optimizing compiler makes. For instance,

different phases of optimization may analyse one expression many times but only analyse

another expression once.

APPLICATIONS

This program can be used to develop a front end of a compiler using c programming language.

ALGORITHM

1) Start the program.

2) Get the coding from the user.

3) Find the operators, arguments and results from the coding.

4) Display the value in the table.

5) Stop the program.

PROGRAM


46

#include<stdio.h>

#include<conio.h>

#include<string.h>

void main()

{

char pg[100][100],str1[24];int tem=-1,ct=0,i=-1,j=0,j1,pos=-1,t=-1,flag,flag1,tt=0,fg=0;

printf("Enter the codings \n");

while(i>-2)

{

i++;lab1:t++;

scanf("%s",&pg[i]);

if((strcmp(pg[i],"getch();"))==0)

{

i=-2;goto lab1;

}

}

printf("\n pos \t oper \t arg1 \t arg2 \tresult \n");

while(j<t)

{

lop:ct=0;

if(pg[j][1]=='=')

{

pos++;

tem++;

printf("%d\t%c\t%c\t%c\tt%d\n",pos,pg[j][3],pg[j][2],pg[j][4],tem);

pos++;

printf("%d\t:=\tt%d\t\t%c\n",pos,tem,pg[j][0]);

}

else if(((strcmp(pg[j],"if"))==0)||((strcmp(pg[j],"while"))==0))

{

if((strcmp(pg[j],"if"))==0)

strcpy(str1,"if");

if((strcmp(pg[j],"while"))==0)

strcpy(str1,"ehile");

j++; j1=j;

tem++;

pos++;

if(pg[j][3]=='=')


47

printf("%d\t%c\t%c\t%c\tt%%d\n",pos,pg[j][2],pg[j][1],pg[j][4],tem);

else printf("%d\t%c\t%c\t%c\tt%d\n",pos,pg[j][2],pg[j][1],pg[j][3],tem);

j1+=2;

pos++;


{

j++;

if(pg[j][1]=='=')

{

tt=j;

fg=1;

}

ct++;

}

ct=ct+pos+1;

printf("%d\t==\tt%d\tFALSE\t%d\n",pos,tem,ct);

if(fg==1)

{

j=tt;goto lop;

}


{

pos++;

tem++;


pos++;

printf("%d\t:=\tt%d\t\t%c\n",pos,tem,pg[j][0]);

j++;

}

if((strcmp(pg[j+1],"else"))==0)

{

ct=0;

j++; j1=j;

j1+=2;

pos++;


{

j1++;ct++;

}

ct=ct*2;


48

ct++;ct+=(pos+1);

j+=2;

printf("%d\tGOTO\t\t\\t%d\n",pos,ct);


{

pos++;

tem++;


pos++;

printf("%t:=\tt%d\t\t%c\n",pos,tem,pg[j][0]);

j++;

}

pos++;

printf("%d\tGOTO\t\t\t\%d\n",pos,ct);

}

}

if((strcmp(pg[j],"}"))==0)

{

pos++;

printf("%d\tGOTO\t\t\t%d\n",pos,pos+1);

}

j++;

}

getch();

}


49

OUTPUT

Enter the codings

void main()

{

if(a<b)

{

a=a+b;

}

while(b<c)

{

b=b+c;

}

getch();

}

posoper arg1 arg2 result

0 + a b t0

1 := t0 a

2 GOTO 3

3 + b c t1

4 := t1 b

5 GOTO 6

RESULT

The programhas been executed to implement the front end of the compiler and the above output

is obtained.

VIVA QUESTIONS

1. Describe about front end and its phases.

The front end consists of those phases or parts of phases that depend primarily on the source

languageand are largely independent of the target machine. These include

Lexical and Syntactic analysis

The creation of symbol table

Semantic analysis

Generation of intermediate code

A certain amount of code optimization can be done by the front end as well. Also includes error

handlingthat goes along with each of these phases.

2. What is Intermediate Code Generation?


50

After syntax and semantic analysis, some compilers generate an explicit intermediate

representationof the source program. This intermediate representation can have a variety of

forms.

In three-address code, the source program might look like this,

temp1: = inttoreal (10)

temp2: = id3 * temp1

temp3: = id2 + temp2

id1: = temp3

3. What is meant by Code Optimisation?

The code optimization phase attempts to improve the intermediate code, so that faster

runningmachine codes will result. Some optimizations are trivial. There is a great variation in the

amount of code optimization different compilers perform. In those that do the most, called

„optimising compilers‟, a significant fraction of the time of the compiler is spent on this phase.

4. What is meant by Code Generation

The final phase of the compiler is the generation of target code, consisting normally of

relocatable machine code or assembly code. Memory locations are selected for each of the

variablesused by the program. Then, intermediate instructions are each translated into a sequence

of machineinstructions that perform the same task. A crucial aspect is the assignment of

variables to registers.

5. What are the advantages of using an intermediate language?

Retargeting - Build a compiler for a new machine by attaching a new code generator to

anexisting front-end.

Optimization - reuse intermediate code optimizers in compilers for different languages

anddifferent machines.

Note: the terms “intermediate code”, “intermediate language”, and “intermediaterepresentation”

are all used interchangeabl

POSSIBLE QUESTIONS

1. .Develop an interpreter which understands the assembly language instructions for Intel-8085

microprocessor, and executes the instructions correctly. User should be able to see the values in

all relevant “registers” (registers will be implemented through variables) at any time

2.Implement a C program for front end of compiler


51

EX NO: 9, 10

IMPLEMENTATION OF BACK END OF COMPILER DATE :

DESCRIPTION

The back end is responsible for translating the intermediate representation of the source

code from the middle-end into assembly code.

OBJECTIVE

To implement the back end of the compiler which takes the three address code and

produces the 8086 assembly language instructions that can be assembled and run using a 8086

assembly.

SYNTAXES & KEYWORDS

fopen(kk,"r"); – this statement opens a file(kk) in read mode.

printf("\t\tMOV %c,R%d\n\t",ip[i+k],j);

if(ip[i+1]=='+')

printf("\t\tADD"); // If the operator is an addition (+) then display the assembly code “MOV”

“ADD” and store the result to the corresponding R

elseprintf("\t\tSUB"); // else display the assembly code “MOV” “SUB” and store the result to the

corresponding R

In the first part of the program Open a file with read mode and read the content of the file

one by one and get the first three address code. Check the arithmetic operator If the operator is

an addition (+) then display the assembly code “ADD” and store the result to the corresponding

R and if the operator is a subtraction (-) then display the assembly code “SUB” and store the

result to the corresponding register


The program can be executed by using turbo C compiler.

The program can be executed by using turbo Ccompiler(Alt+F9 … for compilation,

Ctrl+F9 … to Run)


52



1 System 1

2 O/S Windows XP

3 S/W name Compiler


Back end of the compiler is expected to generate assembly language as the output from

the intermediate code.

USE OF THIS OUTPUT

Many modern compilers share a common 'two stage' design. The front end translates the

source language into an intermediate representation. The second stage is the back end, which

works with the internal representation to produce code in the output language. The front end and

back end may operate as separate passes, or the front end may call the back end as a subroutine,

passing it the intermediate representation.

This approach mitigates complexity separating the concerns of the front end, which

typically revolve around language semantics, error checking, and the like, from the concerns of

the back end, which concentrates on producing output that is both efficient and correct.

ADVANTAGES AND LIMITATIONS

In this program, single back end is developed for single source language.

It also has the advantage of allowing the use of a single back end for multiple source

languages, and similarly allows the use of different back ends for different targets.

APPLICATIONS

This program can be used to develop a back end of a compiler using C programming language.


53

ALGORITHM

1)Start the program.

2)Get the three variables from statements and stored in the text file k.txt.

3)Compile the program and give the path of the source file.

4) Execute the program.

5)Target code for the given statement was produced.

6)Stop the program.

PROGRAM

#include<stdio.h>

#include<conio.h>

#include<ctype.h>

#include<stdlib.h>

void main()

{

inti=2,j=0,k=2,k1=0;

charip[10],kk[10];

FILE *fp;

clrscr();

printf("\nEnter the filename of the intermediate code");

scanf("%s",&kk);

fp=fopen(kk,"r");

if(fp==NULL)

{

printf("\nError in Opening the file");

getch();

}

clrscr();

while(!feof(fp))

{

fscanf(fp,"%s\n",ip);

printf("\t\t%s\n",ip);

}

rewind(fp);

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

printf("\tStatement \t\t target code\n");

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


54

while(!feof(fp))

{

fscanf(fp,"%s",ip);

printf("\t%s",ip);

printf("\t\tMOV %c,R%d\n\t",ip[i+k],j);

if(ip[i+1]=='+')

printf("\t\tADD");

elseprintf("\t\tSUB");

if(islower(ip[i]))

printf("%c,R%d\n\n",ip[i+k1],j);

else

printf("%c,%c\n",ip[i],ip[i+2]);

j++;k1=2;k=0;

}

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

getch();

fclose(fp);

}

OUTPUT

Enter the filename of the intermediate code k.txt

X=a-b

Y=a-c

z=a+b

C=a-b

C=a-b

------------------------------

Statement target code

------------------------------

X=a-b MOV b,R0

SUBa,R0

Y=a-c MOV a,R1

SUBc,R1

z=a+b MOV a,R2

ADDb,R2

C=a-b MOV a,R3

SUBb,R3


55

C=a-b MOV a,R4

SUBb,R4

-------------------------------

RESULT

Thus the above the program is executed and the required output is obtained.

VIVA QUESTIONS

1. Define three address code.

Three address code is a sequence of statements of the general form

x : = y op z

where x,y,z are operand and op is operator.

The back end of compiler includes those portions that depend on the target machine and

generallythose portions do not depend on the source language, just the intermediate language.

These include

Code optimization

Code generation, along with error handling and symbol- table operations.

2. Write short notes on YACC.

YACC is an automatic tool for generating the parser program.

YACC stands for Yet Another Compiler Compiler which is basically the utility available from

UNIX.Basically YACC is LALR parser generator.

It can report conflict or ambiguities in the form of error messages.

POSSIBLE QUESTIONS

1. Write a Program to implement Predictive parsing table.

2.Implement the back end of the compiler which takes the three addresscode generated in

problems 7 and 8, and produces the 8086 assemblylanguage instructions that can be assembled

and run using a 8086assembler.


56

EXPERIMENTS– BEYOND THE SYLLABUS

SYMBOL TABLE MANIPULATION

OBJECTIVE

To write a program in „C‟ for manipulating Symbol Table.

ALGORITHM

1. Start the program.

2. Declare the variables.

Get the character and check it using while Loop.

3. If n value is less than or equal to I then print the symbol address and type.

Again check the n value with j.

4. The C value is changed to ASCII and check it Using if statement.

Store the C value in P and print the Identifier.

Else check the character is equal to +, -, *, /, (, ) using if statement.

5. Using for loop check I value with n and using if statement check the CH is equal to d[i]

and print the address.

Indicate flag as 0 and check the flag value is equal to zero using

symbol table not found

6. Stop the program.


57

PROGRAM

#include<stdio.h>

#include<conio.h.

#include<alloc.h>

void main()

{

int j=0,i=0,x=0,n;

int flag=0;

int *p,*add[10];

charc,ch,srch,b[10],d[10];

clrscr();

printf(“\nEnter an expression and it is terminated by $”);

while((c=getchar())!=‟$‟)

{

b[i]=c;

i++;

}

n=i-1;

i=0;

printf(“Symbol Table\n”);

printf(“\nSymbol\t\tAddress\t\ttype”);

while(j<=n)

{

c=b[j];

if(isalpha(toascii©)))

if(j==0)

{

p=malloc(c);

add|x|=p;

printf(“\n\t%c\t\t%d\t\tidentifier”,c,p);

}

clscr();

{

ch=b[j|l];

if(ch==‟+‟||ch==‟*‟||ch==‟/‟||ch=‟=‟||ch=‟)‟);

{

p=malloc(c);

add|x|=p;


58

d|x|=c;

printf(“\n\t%c\t\t%d\t\tidentifier”,c,p);

x++;

j++;

}

printf(“\nEnter the symbol to search”);

fflush(stdin);

srch=getchar();

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

{

if(srch==d[i])

{

printf(“\nSymbol found\t”);

printf(“%c\t%s%d\n”,srch,”@address”,add[i]);

break;

flag=1;

if(flag==1)

{

printf(“Symbol not found”);

getch();

}

OUTPUT

Enter an expression & it is terminated by $:a+b+$

Symbol Table

Symbol Address Type

a 1910 identifier

b 2012 identifier

Enter the symbol to search: a

Symbol found a @address1910

Enter the symbol to search: b

Symbol found b @address2012

Symbol not found


59

E-CLOSURE

OBJECTIVE

To write a program to implement an E-CLOSURE in „c‟.

ALGORITHM

1. Start the program

2. Declare the required variables.

3. Declare file pointers as F1. Enter the input program.

4. Using while loop check the E-move of each state.

5. Print E-Closure of each State.

6. Stop the program.

PROGRAM

#include<stdio.h>

#include<conio.h>

#include<ctype.h>

void main()

{

char a[20][20];

intc,k,count,j,I=1;

FILE *f1;

clrscr();

f1=fopen(“input.txt”,”r”);

while((c=fgetc(f1))!=EOF)

{

k=1;

while(c!=‟\n‟ $$ c!=EOF)

{

a[i][k]=c;

k++;

c-iqctc(i1);

i=2;

for(i=2;i<count;i++)


60

{

printf(“E-Closure(%c)=(%c”,a[I][l],a[I][l]);

j=3;

if(a[I][j]!=‟ „)

printf(“,”);

while(a[I][j]!=‟\t‟)

{

if(a[I][j]==‟ „)

break;

clrscr();

printf(“)”);

printf(“\n”);

}

getch();

}

OUTPUT

E b

0 1,2 - -

1 2 - -

2 3,1 - -

3 2,1 - -

E-closure(0)={0,1,2}

E-closure(1)={1,2}

E-closure(2)={2,a

3,1}

E-closure(3)={3,2,1}


61

OPERATOR PRECEDENCE PARSING

OBJECTIVE

To write a C program for implementin operator precedence parsing for given grammar

ALGORITHM

1. Start the program.

2.Declare all necessary header files and variables

3.Assign all the precedence relation for given grammar in a 2 d array

4.Get input from user in an array

5.Append $ symbol at the end of the input

6.Create stack using array and put $ as first element

7.Display the contents of stack and input array

8.If last element of stack and input is $ then the parsing is completed

9.Compare top of stack and top of input use find function to get element

10.If the symbol is space print parser error

11.If the symbol is < then shift top element of input to stack.


13.If the symbol is > then remove all elements from stack


15.End of the program.

PROGRAM

#include<stdio.h>

#include<conio.h>

int find(char a)

{

switch(a)

{

case 'a':

return 0;

case '+':

return 1;

case '*':


62

return 2;

case '$':

return 3;}

}

void display(char a[],int top1,char b[],int top2)

{

inti;for(i=0;i<=top1;i++)

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

printf("\t");

for(i=top2;i<strlen(b);i++)

printf("%c",b[i]);printf("\n");

}

int main()

{

char table[][4]= {' ','>','>','>','<','<','<','>','<','>','<','>','<','<','<',' '};

char input[10];

char stack[10]={'$'};

inttop_stack=0,top_input=0,i,j;

clrscr();

printf("operator precedence parsing for E->E+E/E*E/a\n");

printf("enter the string\n");

scanf("%s",input);

strcat(input,"$");

printf("stack\tinput\n");

display(stack,top_stack,input,top_input);

while(1)

{

if((stack[top_stack]=='$')&&(input[top_input]=='$'))

{printf("string accepted");

break;

}

if(table[find(stack[top_stack])][find(input[top_input])]==' ')

{

printf("parse error");

getch();

exit(0);

}

if(table[find(stack[top_stack])][find(input[top_input])]=='<')

{

stack[++top_stack]='<';


63

stack[++top_stack]=input[top_input];

top_input++;


continue;

}

if(table[find(stack[top_stack])][find(input[top_input])]=='>')

{

stack[++top_stack]='>';


top_stack-=3;


}

}

getch();

}

OUTPUT

Operator precedence parsing for E->E+E/E*E/a

Enter the string

a+a*a

stack input

$ a+a*a$

$<a +a*a$

$<a> +a*a$

$ +a*a$

$<+ a*a$

$<+<a *a$

$<+<a> *a$

$<+ *a$

$<+<* a$

$<+<*<a $

$<+<*<a> $

$<+<* $

$<+<*> $

$<+ $

$<+> $

$ $

string accepted


64

REFERENCES

1. A V Aho, R. Sethi, .J D Ullman, "Compilers: Principles,Techniques, and Tools", Pearson

Education, ISBN 81 - 7758 - 5902. J. R. Levine, T. Mason, D. Brown, "Lex&Yacc",

O'Reilly, 2000,ISBN 81-7366 -061-X.– 83.K. Louden, "Compiler Construction:

Principles and Practice",Thomson Brookes/Cole (ISE), 2003, ISBN 981 - 243 - 694-4

2. Reference book: John R. Levine, lex&yacc

3. Reference ppt: Lecture 2: Lexical Analysis, CS 440/540, George Mason university

4. Reference URL: http://dinosaur.compilertools.net/

5. Online manual: http://dinosaur.compilertools.net/flex/index.html

FUTURE DEVELOPMENTS

Prolog language,adopting the theoretical principle of first order predicate, is a popular and preferred logic

programming language amid fields of study. At present noted deviations of prolog language, Turbo

prolog, visual prolog etc .

The future development targets the functional characteristics and working mechanism of the compiler

through the analysis of prolog language organizing and translating procedure in conjunction with logical

attribute of the language.

http://dinosaur.compilertools.net/

http://dinosaur.compilertools.net/flex/index.html

Documents

Finalised Modified Copy of Pcd Lab Manual