UNIT-1

A compiler translates the code written in one language to some other language without changing the
meaning of the program. It is also expected that a compiler should make the target code efficient and
optimized in terms of time and space.
Compiler design principles provide an in-depth view of translation and optimization process. Compiler
design covers basic translation mechanism and error detection & recovery. It includes lexical, syntax,
and semantic analysis as front end, and code generation and optimization as back-end.

Compiler Design - Overview

Computers are a balanced mix of software and hardware. Hardware is just a piece of mechanical device
and its functions are being controlled by a compatible software. Hardware understands instructions in
the form of electronic charge, which is the counterpart of binary language in software programming.
Binary language has only two alphabets, 0 and 1. To instruct, the hardware codes must be written in
binary format, which is simply a series of 1s and 0s. It would be a difficult and cumbersome task for
computer programmers to write such codes, which is why we have compilers to write such codes.
Language Processing System
We have learnt that any computer system is made of hardware and software. The hardware understands
a language, which humans cannot understand. So, we write programs in high-level language, which is
easier for us to understand and remember. These programs are then fed into a series of tools and OS
components to get the desired code that can be used by the machine. This is known as Language
Processing System.

The high-level language is converted into binary language in various phases. A compiler is a program
that converts high-level language to assembly language. Similarly, an assembler is a program that
converts the assembly language to machine-level language.
Let us first understand how a program, using C compiler, is executed on a host machine.
• User writes a program in C language (high-level language).
• The C compiler, compiles the program and translates it to assembly program (low-level
language).
• An assembler then translates the assembly program into machine code (object).
• A linker tool is used to link all the parts of the program together for execution (executable
machine code).
• A loader loads all of them into memory and then the program is executed.
Before diving straight into the concepts of compilers, we should understand a few other tools that work
closely with compilers.
Preprocessor
A preprocessor, generally considered as a part of compiler, is a tool that produces input for compilers.
It deals with macro-processing, augmentation, file inclusion, language extension, etc.
Interpreter
An interpreter, like a compiler, translates high-level language into low-level machine language. The
difference lies in the way they read the source code or input. A compiler reads the whole source code
at once, creates tokens, checks semantics, generates intermediate code, executes the whole program and
may involve many passes. In contrast, an interpreter reads a statement from the input, converts it to an
intermediate code, executes it, then takes the next statement in sequence. If an error occurs, an
interpreter stops execution and reports it. whereas a compiler reads the whole program even if it
encounters several errors.
Assembler
An assembler translates assembly language programs into machine code.The output of an assembler is
called an object file, which contains a combination of machine instructions as well as the data required
to place these instructions in memory.
Linker
Linker is a computer program that links and merges various object files together in order to make an
executable file. All these files might have been compiled by separate assemblers. The major task of a
linker is to search and locate referenced module/routines in a program and to determine the memory
location where these codes will be loaded, making the program instruction to have absolute references.
Loader
Loader is a part of operating system and is responsible for loading executable files into memory and
execute them. It calculates the size of a program (instructions and data) and creates memory space for
it. It initializes various registers to initiate execution.
Cross-compiler
A compiler that runs on platform (A) and is capable of generating executable code for platform (B) is
called a cross-compiler.
Source-to-source Compiler
A compiler that takes the source code of one programming language and translates it into the source
code of another programming language is called a source-to-source compiler.

Architecture
A compiler can broadly be divided into two phases based on the way they compile.
Analysis Phase
Known as the front-end of the compiler, the analysis phase of the compiler reads the source program,
divides it into core parts and then checks for lexical, grammar and syntax errors.The analysis phase
generates an intermediate representation of the source program and symbol table, which should be fed
to the Synthesis phase as input.

Synthesis Phase known as the back-end of the compiler, the synthesis phase generates the target
program with the help of intermediate source code representation and symbol table.
A compiler can have many phases and passes.
• Pass: A pass refers to the traversal of a compiler through the entire program.
• Phase: A phase of a compiler is a distinguishable stage, which takes input from the previous
stage, processes and yields output that can be used as input for the next stage. A pass can have
more than one phase.

Phases of Compiler
• The compilation process is a sequence of various phases. Each phase takes input from its
previous stage, has its own representation of source program, and feeds its output to the next
phase of the compiler. Let us understand the phases of a compiler.
 • Lexical Analysis
The first phase of scanner works as a text scanner. This phase scans the source code as a stream of
characters and converts it into meaningful lexemes. Lexical analyzer represents these lexemes in the
form of tokens as:

• <token-name, attribute-value>

• Syntax Analysis
The next phase is called the syntax analysis or parsing. It takes the token produced by lexical analysis
as input and generates a parse tree (or syntax tree). In this phase, token arrangements are checked against
the source code grammar, i.e. the parser checks if the expression made by the tokens is syntactically
correct.
• Semantic Analysis
Semantic analysis checks whether the parse tree constructed follows the rules of language. For example,
assignment of values is between compatible data types, and adding string to an integer. Also, the
semantic analyzer keeps track of identifiers, their types and expressions; whether identifiers are declared
before use or not etc. The semantic analyzer produces an annotated syntax tree as an output.
• Intermediate Code Generation
After semantic analysis the compiler generates an intermediate code of the source code for the target
machine. It represents a program for some abstract machine. It is in between the high-level language
and the machine language. This intermediate code should be generated in such a way that it makes it
easier to be translated into the target machine code.
• Code Optimization
The next phase does code optimization of the intermediate code. Optimization can be assumed as
something that removes unnecessary code lines, and arranges the sequence of statements in order to
speed up the program execution without wasting resources (CPU, memory).
• Code Generation
In this phase, the code generator takes the optimized representation of the intermediate code and maps
it to the target machine language. The code generator translates the intermediate code into a sequence
of (generally) re-locatable machine code. Sequence of instructions of machine code performs the task
as the intermediate code would do.
• Symbol Table
It is a data-structure maintained throughout all the phases of a compiler. All the identifier's names along
with their types are stored here. The symbol table makes it easier for the compiler to quickly search the
identifier record and retrieve it. The symbol table is also used for scope management.

BOOTSTRAPPING
o Bootstrapping is widely used in the compilation development.
o Bootstrapping is used to produce a self-hosting compiler. Self-hosting compiler is a type of
compiler that can compile its own source code.
o Bootstrap compiler is used to compile the compiler and then you can use this compiled
compiler to compile everything else as well as future versions of itself.

A compiler can be characterized by three languages:

 1. Source Language
2. Target Language
3. Implementation Language

The T- diagram shows a compiler SCIT for Source S, Target T, implemented in I.

Follow some steps to produce a new language L for machine A:

1. Create a compiler SCAA for subset, S of the desired language, L using language "A" and that
compiler runs on machine A.

2. Create a compiler LCSA for language L written in a subset of L.

3. Compile LCSA using the compiler SCAA to obtain LCAA. LCAA is a compiler for language L, which
runs on machine A and produces code for machine A.

The process described by the T-diagrams is called bootstrapping.

Finite Automata
Finite automata is a state machine that takes a string of symbols as input and changes its state
accordingly. Finite automata is a recognizer for regular expressions. When a regular expression string
is fed into finite automata, it changes its state for each literal. If the input string is successfully processed
and the automata reaches its final state, it is accepted, i.e., the string just fed was said to be a valid token
of the language in hand.
The mathematical model of finite automata consists of:

• Finite set of states (Q)

• Finite set of input symbols (Σ)
• One Start state (q0)
• Set of final states (qf)
• Transition function (δ)
The transition function (δ) maps the finite set of state (Q) to a finite set of input symbols (Σ), Q × Σ ➔ Q
Finite Automata Construction
Let L(r) be a regular language recognized by some finite automata (FA).
• States: States of FA are represented by circles. State names are written inside circles.
• Start state: The state from where the automata starts, is known as the start state. Start state has
an arrow pointed towards it.
• Intermediate states: All intermediate states have at least two arrows; one pointing to and
another pointing out from them.
• Final state: If the input string is successfully parsed, the automata is expected to be in this state.
Final state is represented by double circles. It may have any odd number of arrows pointing to
it and even number of arrows pointing out from it. The number of odd arrows are one greater
than even, i.e. odd = even+1.
• Transition: The transition from one state to another state happens when a desired symbol in the
input is found. Upon transition, automata can either move to the next state or stay in the same
state. Movement from one state to another is shown as a directed arrow, where the arrows points
to the destination state. If automata stays on the same state, an arrow pointing from a state to
itself is drawn.
Example: We assume FA accepts any three digit binary value ending in digit 1. FA = {Q(q0, qf), Σ(0,1),
q0, qf, δ}

Regular Expressions
The lexical analyzer needs to scan and identify only a finite set of valid string/token/lexeme that belong
to the language in hand. It searches for the pattern defined by the language rules.
Regular expressions have the capability to express finite languages by defining a pattern for finite
strings of symbols. The grammar defined by regular expressions is known as regular grammar. The
language defined by regular grammar is known as regular language.
Regular expression is an important notation for specifying patterns. Each pattern matches a set of
strings, so regular expressions serve as names for a set of strings. Programming language tokens can be
described by regular languages. The specification of regular expressions is an example of a recursive
definition. Regular languages are easy to understand and have efficient implementation.
There are a number of algebraic laws that are obeyed by regular expressions, which can be used to
manipulate regular expressions into equivalent forms.
Operations
The various operations on languages are:
• Union of two languages L and M is written as
L U M = {s | s is in L or s is in M}
• Concatenation of two languages L and M is written as
LM = {st | s is in L and t is in M}
 • The Kleene Closure of a language L is written as
L* = Zero or more occurrence of language L.
Notations
If r and s are regular expressions denoting the languages L(r) and L(s), then
• Union: (r)|(s) is a regular expression denoting L(r) U L(s)
• Concatenation: (r)(s) is a regular expression denoting L(r)L(s)
• Kleene closure: (r)* is a regular expression denoting (L(r))*
• (r) is a regular expression denoting L(r)

Precedence and Associativity

• *, concatenation (.), and | (pipe sign) are left associative
• * has the highest precedence
• Concatenation (.) has the second highest precedence.
• | (pipe sign) has the lowest precedence of all.

Representing valid tokens of a language in regular expression

If x is a regular expression, then:
• x* means zero or more occurrence of x.
i.e., it can generate {e, x, xx, xxx, xxxx, … }
• x+ means one or more occurrence of x.
i.e., it can generate {x, xx, xxx, xxxx … } or x.x*
• x? means at most one occurrence of x
i.e., it can generate either {x} or {e}.
[a-z] is all lower-case alphabets of English language.
[A-Z] is all upper-case alphabets of English language.
[0-9] is all-natural digits used in mathematics.
Representing occurrence of symbols using regular expressions
letter = [a – z] or [A – Z]
digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 or [0-9]
sign = [ + | - ]
Representing language tokens using regular expressions
Decimal = (sign)?(digit)+
Identifier = (letter)(letter | digit)*
The only problem left with the lexical analyzer is how to verify the validity of a regular expression used
in specifying the patterns of keywords of a language. A well-accepted solution is to use finite automata
for verification.

Lexical Analysis
Lexical analysis is the first phase of a compiler. It takes the 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.
Tokens
Lexemes are said to be a sequence of characters (alphanumeric) in a token. There are some predefined
rules for every lexeme to be identified as a valid token. These rules are defined by grammar rules, by
means of a pattern. A pattern explains what can be a token, and these patterns are defined by means of
regular expressions.
In programming language, keywords, constants, identifiers, strings, numbers, operators and
punctuations symbols can be considered as tokens.
For example, in C language, the variable declaration line

int value = 100;

contains the tokens:

int (keyword), value (identifier), = (operator), 100 (constant) and ; (symbol).

Specifications of Tokens
Let us understand how the language theory undertakes the following terms:
Alphabets
Any finite set of symbols {0,1} is a set of binary alphabets, {0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F} is a set
of Hexadecimal alphabets, {a-z, A-Z} is a set of English language alphabets.
Strings
Any finite sequence of alphabets is called a string. Length of the string is the total number of occurrence
of alphabets, e.g., the length of the string tutorialspoint is 14 and is denoted by |tutorialspoint| = 14. A
string having no alphabets, i.e. a string of zero length is known as an empty string and is denoted by ε
(epsilon).
Special Symbols
A typical high-level language contains the following symbols:-
Arithmetic Symbols Addition(+), Subtraction(-), Modulo(%), Multiplication(*),
Division(/)

Punctuation Comma(,), Semicolon(;), Dot(.), Arrow(->)

Assignment =

Special Assignment +=, /=, *=, -=

Comparison ==, !=, <, <=, >, >=

Preprocessor #
 Location Specifier &

Logical &, &&, |, ||, !

Shift Operator >>, >>>, <<, <<<

Language
A language is considered as a finite set of strings over some finite set of alphabets. Computer languages
are considered as finite sets, and mathematically set operations can be performed on them. Finite
languages can be described by means of regular expressions.
Longest Match Rule
When the lexical analyzer read the source-code, it scans the code letter by letter; and when it encounters
a whitespace, operator symbol, or special symbols, it decides that a word is completed.
For example:

int intvalue;
While scanning both lexemes till ‘int’, the lexical analyzer cannot determine whether it is a
keyword int or the initials of identifier int value.
The Longest Match Rule states that the lexeme scanned should be determined based on the longest
match among all the tokens available.
The lexical analyzer also follows rule priority where a reserved word, e.g., a keyword, of a language
is given priority over user input. That is, if the lexical analyzer finds a lexeme that matches with any
existing reserved word, it should generate an error.

Optimization of DFA
To optimize the DFA you have to follow the various steps. These are as follows:
Step 1: Remove all the states that are unreachable from the initial state via any set of the transition of
DFA.
Step 2: Draw the transition table for all pair of states.
Step 3: Now split the transition table into two tables T1 and T2. T1 contains all final states and T2
contains non-final states.
Step 4: Find the similar rows from T1 such that:
1. δ (q, a) = p
2. δ (r, a) = p
That means, find the two states which have same value of a and b and remove one of them.
Step 5: Repeat step 3 until there is no similar rows are available in the transition table T1.
Step 6: Repeat step 3 and step 4 for table T2 also.
Step 7: Now combine the reduced T1 and T2 tables. The combined transition table is the transition
table of minimized DFA.
Example
Solution:
Step 1: In the given DFA, q2 and q4 are the unreachable states so remove them.
Step 2: Draw the transition table for rest of the states.

Step 3:
Now divide rows of transition table into two sets as:
1. One set contains those rows, which start from non-final sates:

2. Other set contains those rows, which starts from final states.

Step 4: Set 1 has no similar rows so set 1 will be the same.

Step 5: In set 2, row 1 and row 2 are similar since q3 and q5 transit to same state on 0 and 1. So skip
q5 and then replace q5 by q3 in the rest.

Step 6: Now combine set 1 and set 2 as:

Now it is the transition table of minimized DFA.

Transition diagram of minimized DFA:

Fig: Minimized DFA

LEXICAL ANALYZER GENERATOR
It is ...
... a tool to generate lexical analyzers. A lexical analyzer is a program that transforms a stream of
characters into a stream of 'atomic chunks of meaning', so called tokens.

It does ...

o generate directly coded lexical analyzers, rather than table-based engines.

o respond to queries on Unicode properties and regular expressions on the command line.
o generate state transition graphs of the generated engines.
It has ...

o Many examples.
o Modes that can be inherited and mode transitions that can be controlled.
o Line and column number counting as part of the generated engine.
o Include stacks for include file management.
o Support for indentation-based analysis (INDENT, DEDENT, NODENT tokens).
o Path and Template compression for minimal code size.
o Two token passing strategies: 'queue' and 'single token'.
o Support for customized token types.
o Event handlers for fine grained control over analyzer actions.
LEX
o Lex is a program that generates lexical analyzer. It is used with YACC parser generator.
o The lexical analyzer is a program that transforms an input stream into a sequence of tokens.
o It reads the input stream and produces the source code as output through implementing the
lexical analyzer in the C program.

The function of Lex is as follows:

o Firstly, lexical analyzer creates a program lex.1 in the Lex language. Then Lex compiler runs
the lex.1 program and produces a C program lex.yy.c.
o Finally, C compiler runs the lex.yy.c program and produces an object program a.out.
o a.out is lexical analyzer that transforms an input stream into a sequence of tokens.
 Lex file format
A Lex program is separated into three sections by %% delimiters. The formal of Lex source is as
follows:
{ definitions }
%%
{ rules }
%%
{ user subroutines }
Definitions include declarations of constant, variable and regular definitions.
Rules define the statement of form p1 {action1} p2 {action2}....pn {action}.
Where pi describes the regular expression and action1 describes the actions what action the lexical
analyzer should take when pattern pi matches a lexeme.
User subroutines are auxiliary procedures needed by the actions. The subroutine can be loaded with
the lexical analyzer and compiled separately.
FORMAL GRAMMAR
• Formal grammar is a set of rules. It is used to identify correct or incorrect strings of tokens in a
language. The formal grammar is represented as G.
• Formal grammar is used to generate all possible strings over the alphabet that is syntactically
correct in the language.
• Formal grammar is used mostly in the syntactic analysis phase (parsing) particularly during the
compilation.

Formal grammar G is written as follows:

1. G = <V, N, P, S>

Where:

N describes a finite set of non-terminal symbols.

V describes a finite set of terminal symbols.
P describes a set of production rules
S is the start symbol.

Example:
1. L = {a, b}, N = {S, R, B}

Production rules:
1. S = bR
2. R = aR
3. R = aB
4. B=b

Through this production we can produce some strings like: bab, baab, baaab etc.

This production describes the string of shape banab.

Fig: Formal grammar

 BNF NOTATION
BNF stands for Backus-Naur Form. It is used to write a formal representation of a context-free
grammar. It is also used to describe the syntax of a programming language.

BNF notation is basically just a variant of a context-free grammar.

In BNF, productions have the form:

1. Left side → definition

Where leftside ∈ (Vn∪ Vt)+ and definition ∈ (Vn∪ Vt)*. In BNF, the leftside contains one non-
terminal.

We can define the several productions with the same leftside. All the productions are separated by a
vertical bar symbol "|".

There is the production for any grammar as follows:

1. S → aSa
2. S → bSb
3. S → c

In BNF, we can represent above grammar as follows:

1. S → aSa| bSb| c
YACC
o YACC stands for Yet Another Compiler Compiler.
o YACC provides a tool to produce a parser for a given grammar.
o YACC is a program designed to compile a LALR (1) grammar.
o It is used to produce the source code of the syntactic analyzer of the language produced by
LALR (1) grammar.
o The input of YACC is the rule or grammar and the output is a C program.

These are some points about YACC:

Input: A CFG- file.y

Output: A parser y.tab.c (yacc)

o The output file "file.output" contains the parsing tables.
o The file "file.tab.h" contains declarations.
o The parser called the yyparse ().
o Parser expects to use a function called yylex () to get tokens.

The basic operational sequence is as follows:

This file contains the desired grammar in YACC format.

 It shows the YACC program.

It is the c source program created by YACC.

C Compiler

Executable file that will parse grammar given in gram.Y

CONTEXT FREE GRAMMAR

Context free grammar is a formal grammar which is used to generate all possible strings in a given
formal language.

Context free grammar G can be defined by four tuples as:

1. G= (V, T, P, S)
Where,
G describes the grammar
T describes a finite set of terminal symbols.
V describes a finite set of non-terminal symbols
P describes a set of production rules
S is the start symbol.
In CFG, the start symbol is used to derive the string. You can derive the string by repeatedly replacing
a non-terminal by the right-hand side of the production, until all non-terminal has been replaced by
terminal symbols.

Example:
L= {wcwR | w € (a, b)*}
Capabilities of CFG
There are the various capabilities of CFG:
o Context free grammar is useful to describe most of the programming languages.
o If the grammar is properly designed then an efficient parser can be constructed automatically.
o Using the features of associatively & precedence information, suitable grammars for
expressions can be constructed.
o Context free grammar is capable of describing nested structures like: balanced parentheses,
matching begin-end, corresponding if-then-else's & so on.
Derivation
Derivation is a sequence of production rules. It is used to get the input string through these production
rules. During parsing we have to take two decisions. These are as follows:
o We have to decide the non-terminal which is to be replaced.
o We have to decide the production rule by which the non-terminal will be replaced.

We have two options to decide which non-terminal to be replaced with production rule.

Left-most Derivation
 In the left most derivation, the input is scanned and replaced with the production rule from left to right.
So in left most derivatives we read the input string from left to right.
Example:
Production rules:
1. S = S + S
2. S = S - S
3. S = a | b |c
Input:
a-b+c

The left-most derivation is:

1. S=S+S
2. S=S-S+S
3. S=a-S+S
4. S=a-b+S
5. S=a-b+c

Right-most Derivation
In the right most derivation, the input is scanned and replaced with the production rule from right to
left. So, in right most derivatives we read the input string from right to left.
Example:
1. S = S + S
2. S = S - S
3. S = a | b |c
Input:
a-b+c

The right-most derivation is:

1. S=S-S
2. S=S-S+S
3. S=S-S+c
4. S=S-b+c
5. S=a-b+c
Parse tree
• Parse tree is the graphical representation of symbol. The symbol can be terminal or non-terminal.
• In parsing, the string is derived using the start symbol. The root of the parse tree is that start
symbol.
• It is the graphical representation of symbol that can be terminals or non-terminals.
• Parse tree follows the precedence of operators. The deepest sub-tree traversed first. So, the
operator in the parent node has less precedence over the operator in the sub-tree.

The parse tree follows these points:

o All leaf nodes have to be terminals.
o All interior nodes have to be non-terminals.
o In-order traversal gives original input string.
Example:

Production rules:
1. T= T + T | T * T
2. T = a|b|c
 Input:
a*b+c
Step 1: Step 4:

Step 2:

Step 5:

Step 3:

Ambiguity

A grammar is said to be ambiguous if there exists more than one leftmost derivation or more than one
rightmost derivative or more than one parse tree for the given input string. If the grammar is not
ambiguous then it is called unambiguous.

Example:
1. S = aSb | SS
2. S = ∈

For the string aabb, the above grammar generates two parse trees:

If the grammar has ambiguity then it is not good for a compiler construction. No method can
automatically detect and remove the ambiguity but you can remove ambiguity by re-writing the whole
grammar without ambiguity.