The document discusses the roles of compilers and interpreters. It explains that a compiler translates an entire program into machine code in one pass, while an interpreter translates and executes code line-by-line. The document also covers the basics of lexical analysis, including how it breaks source code into tokens by removing whitespace and comments. It provides an example of tokens identified in a code snippet and discusses how the lexical analyzer works with the symbol table and syntax analyzer.

1. Topic – Compiler and Interpreter, Lexical
Analysis
Name : Souvik Roy
Class Roll: IT2020/025
Uni Roll : 11700220036
College Name : RCC Institute Of Information
Technology

2. Interpreter And Compiler
An interpreter is a program that
executes the programming code
directly instead of just translating it into
another format. It translates and
executes programming language
statements one by one. An interpreter
takes less time to interpret a source
program as distinguished by a compiler.
A compiler is a computer program that
reads a program written in a high-level
language such as FORTRAN, PL/I,
COBOL, etc. It can translate it into the
same program in a low-level language
including machine language. The
compiler also finds out the various
errors encountered during the
compilation of a
2 ->
3 ->
4 ->
5 ->
6 ->
7 ->
9 ->
1 ->
8 ->

3. Differences Between Compiler and Interpreter
1 ->
2 ->
4 ->
5 ->
6 ->
7 ->
9 ->
1 ->
8 ->
Compiler Interpreter
A compiler translates the entire source
code in a single run.
An interpreter translates the entire source
code line by line.
It consumes less time i.e., it is faster than
an interpreter.
It consumes much more time than the
compiler i.e., it is slower than the
compiler.
It is more efficient. It is less efficient.
CPU utilization is more. CPU utilization is less as compared to the
compiler.
Both syntactic and semantic errors can be
checked simultaneously.
Only syntactic errors are checked.
The compiler is larger. Interpreters are often smaller than
compilers.
It is not flexible. It is flexible.
The localization of errors is difficult. The localization of error is easier than the
compiler.
A presence of an error can cause the
whole program to be re-organized.
A presence of an error causes only a part
of the program to be re-organized.
The compiler is used by the language such
as C, C++.
An interpreter is used by languages such
as Java.
2 ->
3 ->
1 ->

4. 4 ->
5 ->
6 ->
7 ->
9 ->
8 ->
2 ->
3 ->
1 ->
Compiler – Design and Phases
T
O
P
I
C

5. Terms To Be Familiar With Before Starting Out
With Lexical Analysis
• Lexeme
Lexeme can be defined as a sequence of characters
that forms a pattern and can be recognized as a token.
• Pattern
After identifying the pattern of lexeme one can
describe what kind of token can be formed. Such as
the pattern of some lexeme forms a keyword, the
pattern of some lexemes forms an identifier.
• Token
A lexeme with a valid pattern forms a token. In lexical
analysis, a valid token can be identifiers, keywords,
separators, special characters, constants and
operators.
• Symbol Table is an important data structure created
and maintained by the compiler in order to keep track
of semantics of variables i.e. it stores information
about the scope and binding information about
names, information about instances of various entities
such as variable and function names, classes, objects,
etc.
• Scope Management - A compiler maintains two types
of symbol tables: a global symbol table which can be
accessed by all the procedures and scope symbol
tables that are created for each scope in the program.
4 ->
5 ->
6 ->
7 ->
9 ->
8 ->
2 ->
3 ->
1 ->
Symbol table breakdown example
Categorisation of tokens

6. Lexical Analysis
4 ->
5 ->
6 ->
7 ->
9 ->
8 ->
2 ->
3 ->
1 ->
Lexical analysis is the first phase of a compiler. It takes modified source code from
language preprocessors that are written in the form of sentences. The lexical
analyzer breaks these syntaxes into a series of tokens, by removing any whitespace
or comments in the source code.
If the lexical analyzer finds a token invalid, it generates an error. The lexical analyzer
works closely with the syntax analyzer. It reads character streams from the source
code, checks for legal tokens, and passes the data to the syntax analyzer when it
demands.

7. Lexical Analysis : Breaking Of Code
into Tokens
• #include <stdio.h>
• int maximum(int
x, int y)
• { // This will
compare 2
numbers
• if (x > y)
• return x;
• else {
• return y;
• }
• }
Lexeme Token
int Keyword
maximum Identifier
( Operator
int Keyword
x Identifier
, Operator
int Keyword
Y Identifier
) Operator
{ Operator
If Keyword
4 ->
5 ->
6 ->
7 ->
9 ->
8 ->
2 ->
3 ->
1 ->

8. Lexical Analyzer Parser
Output Input project
Carry out linguistic structure
examination
Recognize Tokens
Make a theoretical portrayal of the
program
Addition symbols into Symbol Table Better image table sections
It creates lexical blunders It create parse tree of the program
Comparison of Lexical Analyzer & Parse
ROLE OF LEXICAL ANALYSIS
Lexical analyzer likewise performs beneath given assignments:
This distinguishes the token in the image table
Remove place and remarks from the source code.
Associate blunder messages with the source code.
Help to create macros in the event that they are in the source code
Study input nature from the source program
4 ->
5 ->
6 ->
7 ->
9 ->
8 ->
2 ->
3 ->
1 ->

9. A Little Example To Remember
Lexical Analysis
4 ->
5 ->
6 ->
7 ->
9 ->
8 ->
2 ->
3 ->
1 ->

10. References
• Ada 95 Reference Manual. Intermetrics, Inc., 1995. ANSI/ISO/IEC-8652:1995.
• A.V. Aho and M.J. Corasick. Efficient String Matching: An Aid to Bibliographic
Search. Communications of the ACM, 18(6):333-340, June 1975
• Alfred V. Aho, Monica S. Lam, Ravi Sethi, Jeffery D. Ullman Compilers : Principles,
Technique and Tools, 2nd ed. PEARSON Education 2009.
• P. Bumbulis and D.D. Cowan. RE2C: A More Versatile Scanner Generator. ACM
Letters on Programming Languages and Systems, 2(1-4):70–84, 1993.
• R.J. Cichelli. Minimal Perfect Hash Functions Made Simple. Communications of the
ACM, 23:17–19, 1980.
• A.V. Aho, R. Sethi, and J.D. Ullman. Compilers. Addison-Wesley, 1986.
• J. Barnes. Programming in Ada 95. Addison Wesley, 1995.
• https://www.ques10.com/p/21837/explain-role-of-lexical-analyser/
• https://www.guru99.com/compiler-design-lexical-analysis.html
• https://www.javatpoint.com/compiler-tutorial
• https://www.tutorialspoint.com/compiler_design/compiler_design_types_of_parsi
ng.htm
• https://en.wikibooks.org/wiki/Compiler_Construction/Lexical_analysis
HOME AGAIN