Finalised Modified Copy of Pcd Lab Manual
Transcript of 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.
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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)
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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;
SEC CSE/VI PCD LAB MANUAL
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--;
SEC CSE/VI PCD LAB MANUAL
14
}
break;
case 5:
if(str[i]==‟e‟)state=6;
else
{
state=17;
started=i-3;
i--;
}
break;
case 6:
if(str[i]==‟e‟)state=7;
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;
SEC CSE/VI PCD LAB MANUAL
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:
if(str[i]==‟e‟)state=13;
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;
SEC CSE/VI PCD LAB MANUAL
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--;
SEC CSE/VI PCD LAB MANUAL
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;
SEC CSE/VI PCD LAB MANUAL
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”);
SEC CSE/VI PCD LAB MANUAL
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:
}
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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) […].
HOW TO EXECUTE THE PROGRAM
[CS228@localhost cs228]$ vilexprogram.c
[CS228@localhost cs228]$ lexprogram.l
{cs228@localhost cs228]$cc lexprogram.yy.c
[cs228@localhost cs228]$./a.outarea.c
SEC CSE/VI PCD LAB MANUAL
24
REQUIREMENTS FOR EXECUTION
S.No. Facilities required Quantity
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.
SEC CSE/VI PCD LAB MANUAL
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|
SEC CSE/VI PCD LAB MANUAL
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[])
{
SEC CSE/VI PCD LAB MANUAL
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)
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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.
HOW TO EXECUTE THE PROGRAM
The program can be executed using a Turbo c compiler.
EXPECTED OUTPUT AND ITS FORM
This program is expected to verify that the syntax of the input stream by reading it left to
write for its correctness.
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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++;
}
}
}
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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).
REQUIREMENTS FOR EXECUTION
S.No. Facilities required Quantity
1 System 1
2 O/S LINUX
3 S/W name Compiler
SEC CSE/VI PCD LAB MANUAL
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
EXPECTED OUTPUT AND ITS FORM
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.
SEC CSE/VI PCD LAB MANUAL
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);
}
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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……….
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
40
HOW TO EXECUTE THE PROGRAM
[root@localhost ~] # lexdesk.l
[root@localhost ~] # yacc –d desk.y
[root@localhost ~] # lex.yy.cy.tab.c –ll
[root@localhost ~] #./a.out
REQUIREMENTS FOR EXECUTION
S.No. Facilities required Quantity
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.
SEC CSE/VI PCD LAB MANUAL
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
{
SEC CSE/VI PCD LAB MANUAL
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);
}
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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.
HOW TO EXECUTE THE PROGRAM
The program can be executed by using turbo Ccompiler(Alt+F9 … for compilation,
Ctrl+F9 … to Run)
SEC CSE/VI PCD LAB MANUAL
45
REQUIREMENTS FOR EXECUTION
S.No. Facilities required Quantity
1 System 1
2 O/S Windows XP
3 S/W name Compiler
EXPECTED OUTPUT AND ITS FORM
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
SEC CSE/VI PCD LAB MANUAL
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]=='=')
SEC CSE/VI PCD LAB MANUAL
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++;
while((strcmp(pg[j],"}"))!=0)
{
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;
}
while((strcmp(pg[j],"}"))!=0)
{
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]);
j++;
}
if((strcmp(pg[j+1],"else"))==0)
{
ct=0;
j++; j1=j;
j1+=2;
pos++;
while((strcmp(pg[j],"}"))!=0)
{
j1++;ct++;
}
ct=ct*2;
SEC CSE/VI PCD LAB MANUAL
48
ct++;ct+=(pos+1);
j+=2;
printf("%d\tGOTO\t\t\\t%d\n",pos,ct);
while((strcmp(pg[j],"}"))!=0)
{
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("%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();
}
SEC CSE/VI PCD LAB MANUAL
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?
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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
HOW TO EXECUTE THE PROGRAM
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)
SEC CSE/VI PCD LAB MANUAL
52
REQUIREMENTS FOR EXECUTION
S.No. Facilities required Quantity
1 System 1
2 O/S Windows XP
3 S/W name Compiler
EXPECTED OUTPUT AND ITS FORM
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.
SEC CSE/VI PCD LAB MANUAL
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");
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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.
SEC CSE/VI PCD LAB MANUAL
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;
SEC CSE/VI PCD LAB MANUAL
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
SEC CSE/VI PCD LAB MANUAL
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++)
SEC CSE/VI PCD LAB MANUAL
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}
SEC CSE/VI PCD LAB MANUAL
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.
12.Display the contents of stack and input array
13.If the symbol is > then remove all elements from stack
14.Display the contents of stack and input array
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 '*':
SEC CSE/VI PCD LAB MANUAL
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]='<';
SEC CSE/VI PCD LAB MANUAL
63
stack[++top_stack]=input[top_input];
top_input++;
display(stack,top_stack,input,top_input);
continue;
}
if(table[find(stack[top_stack])][find(input[top_input])]=='>')
{
stack[++top_stack]='>';
display(stack,top_stack,input,top_input);
top_stack-=3;
display(stack,top_stack,input,top_input);
}
}
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
SEC CSE/VI PCD LAB MANUAL
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.