7 Phases of Compiler Construction with Example Definition & Benefits

Whenever a new language comes in market so comes a new compiler that understands it. Compiler Construction is based on 7 unique phases. Yes, Every time you click the RUN, button on your compiler your code goes through seven steps of code compilation.

Before we Learn in detail about 7 Phases of Compiler Construction with Example Definition & Benefits. 

7 Phases of Compiler Construction with Example

Lets understand, What a compiler is?

"The compiler is a software program which converts high-level language code into machine level language code or language code that the computer processor can understand."

A Compiler's compilation process is a sequence  of different phases. Each of these Phases of Compiler takes input from previous phase and feeds its results in upcoming Phase.

Let us understand step by step 7 Phases of Compiler Construction with Example Definition & Benefits.

Phases of Compiler Construction

All of these 7 compiler construction phases translate source code into tokens, create parse trees and optimize the source code through different phases.

7 Phases of Compiler Construction with Example Definition & Benefits 

1. Lexical Analyses
2. Syntax Analyses
3. Intermediate code generator
4. Machine Independent code
5. Code Generator
6. Machine dependent code
7. Target code (Analytical Phase)

1. Lexical Analysis:

This is the first Phase of the 7 Phases of Compiler Construction ,its first part code compilation. In Lexical Analysis, Lexcial Analyser scans the source code as a character stream and transforms this personality stream into significant token lexemes.

The primary functions of this phase are:

• Identify the lexical units in a source code
• Classify lexical units into classes like constants, reserved words, and enter them in different tables. It will Ignore comments in the source program
• Identify token which is not a part of the language

Example for Lexical Analysis:

<token-name, attribute-value>

Before we proceed further I want you guys to understand what I mean by a token. In simple words to answer this:

What is a Token?

Every code is first divided into token which is done so that computer can understand what you have written. This is the step of Token Generation.

A Token is a collection of information. A token can contain a Keyword, Operator, Identifier, Constant or a punctuator.

Example For Token:

A = B + 50

Tokens

A	identifier
=	Assignment operator
B	identifier
+	Addition operator
50	Number

2. Syntax Analysis:

The parsing is also regarded as syntax analysis. The tokens produced by Lexical Analysis are used as reference and then the parse tree or syntax tree is produced. The Analysis Syntax tests the token agreement against grammar. Syntax Analysis for syntactically ideal grammar.

Functions of Syntax Analysis:

This is a list of tasks performed in this phase:

• Syntax Analysis is in charge of collecting lexical tokens.
• Syntax Analysis is the phase that controls whether or not the term has been right syntactically.
• Syntax analysis Report Syntax Analysis syntax errors Construct a hierarchical framework recognized as a tree parsis. syntax analysis
• Syntax analysis also guarantees that the program's parts are meaningful.
• Syntax Analysis collects data sort and controls through this stage for consistency of the sort.
• Syntax Analysis ensures that the source language allows the operand.

Example:

Any identifier/number is an expression. Take an easy example:

Let R is an identifier and T+10 is an expression, then R= T+10 is a statement.

3. Semantic Analysis:

Semantic analysis checks the parse tree. Semantic analysis ensures that the parsing tree complies with the language laws.

Semantic analysis provides the yield for an annotated syntax tree.


For example, the assignment of values between compatible data types is not possible and the insertion of a new string into an integer is just what we are doing.


Semantic analysis tests the parsing tree and now sends its yield to the intermediate code generator.

Functions of Semantic analyses phase are:

• Semantically analysed data can be saved in the symbols panel or syntax tree to collect and warehouse data collected. We can also conduct type checks with semantic analysis. For type error, semantical mistake is displayed. Semantic analysis checks if the source language allows or does not.

Example

float x = 20.2;
float y = x*40;

The semantic analyzer will select the integer 40 before multiplication to float 40.0.

4.Intermediate Code Generation:

The fifth phase of compiler job involves the creation of intermediate code. ICG (intermediate text compiler) is the intermediate source code for the destination computer. It reflects an abstract machine program. You and I use programming and low-level language between high-level language, which the computer also understands as a machine language.

Intermediate code saves us time. It is easier to translate to Machine language. 

Functions on Intermediate Code generation:

• This should be produced from the computer program's linguistic illustration.
• Keeps the calculated values in the entire conversion method.
• Helps the middle text to be translated into target language.
• Allows you to ensure that the language is ordered beforehand.
• It contains the correct range of instructional operators.

Example

For example,

total = count + rate * 5

Intermediate code with the help of address code method is:

 
t1 := int_to_float(5) 
t2 := rate * t1 
t3 := count + t2
total := t3

6. Code Optimization:

Code optimization is the sixth phase of the building of a compiler. By optimizing, we aim to accomplish the same job, but with a simplified, more effective strategy.

•  Optimization eliminates our language and useless text lines.
• The instructions are optimized to speed the efficiency of the row of instructions.
• Optimizing software protects us valuable remembrance of our main storage (RAM) during execution of software.
• Optimizing the code also decreases program time.

The primary functions code optimization of this section are:

• Improves the time duration of the item program 
• Generates effective software still in intermediate representation.
•  Remove from the access code and eliminate unnecessary items Delete remarks that seem to have been changed from the circuit. 
• It helps determining how much time is spent by performance and building velocity.

Example:

Consider the following code

a = intofloat(10)
b = c * a
d = e + b
f = d

Can become

b =c * 10.0
f = e+b

7. Code Generation:

The code generator translates the optimized software from the intermediate code generator to the destination machine language in the last phase. The code generator transforms intermediate code in particular. The translation is an intermediate code sequence for the machine. The intermediate code sequence of the machine code instructions is performed.

The language of the goal is that of the computer. All storage places and registers are therefore selected by hand and allocated across this area. Input and anticipated outputs will be required for the software produced by this chapter.

Example:

a = b + 60.0

Would be possibly translated to registers.

MOVF a, R1
MULF #60.0, R2
ADDF R1, R2

Error Handling Routine For Different

Phases of Compiler Construction:

In the compiler design method error could occur altogether the below-given phases:

• Lexical analyzer: incorrectly spelled tokens
• Syntax analyzer: Missing parenthesis
• Intermediate code generator: Mismatched operands for associate operator
• Code Optimizer: once the statement isn't approachable
• Code Generator: inaccessible statements
• Symbol tables: Error of multiple declared identifiers
• Invalid processing pattern, incorrect sorting token combinations, range mistake, and parsing in linguistic analysis are most prevalent mistakes.

In any of the stages, the mistake could also occur. Once mistakes have been found, the classification technique has to traumatize mistakes. The error handler who processes the mistake for compiling should be informed of these mistakes. In the multitude of messages, mistakes are usually recorded.

blunders- Error encountered Phases of Compiler

Errors can stumble on each section. A stage needs some how to tackle the error after identifying an error in order to carry on the building. The previous kind of mistakes in varied fields may also occur in a computer:

Lexical errors

it includes wrong or misspelled call of some identifier i.e., identifiers typed incorrectly.

Syntactical mistakes

It is made from a lack or unbalanced parenthesis of semicolon. Syntactic errors are processed by language (parser) analyzer.
While a bug is identified, the parser should be used to parse the remainder of the submit. In trendy situations, errors may be predicted at many compilation levels, but many errors are syntactic errors and the parser has to be able to hit and record these errors inside the program for this reason.

The goals of Error handler in parser /Phases Of Compiler Construction

• Certainly and properly document the existence of errors.
 • get fast enough over any errors to detect future errors. 
• Minimum cost upload for package handling.

there are four common error-recovery techniques that can be carried out in the parser to cope with mistakes within the code.

o panic mode.

o statement stage.

o errors productions.

o worldwide correction.

Semantical errors

The outcome of inconsistent allocation of costs is these mistakes. The semanticizing mistakes anticipated to be recognized by the semanticizer are: 

• sort of mismatch,variable undeclared.
• Misuse of ID secured.
• various variable advertisements in a range.
• Access to a variable out of reach.
• Misrepresented and formal parameter.

Logical errors

Those errors arise because of now not handy code-infinite loop.

Code Compilation Steps

Compiler Compiles Codes in 5 steps. Lets discuss these 5 steps of compilation further.

1. Text Editor: Which reads the text you have written in plain text format and sends this text as a source file to Processor.
2. Processor:
    A processor processes this source file and all headers and libraries are added here to make the code definable and readable to compiler.
3. Compiler:
    It receives the file from Processor. Now, Compiler creates a object file of that code.
4. Linker:
    Linker links all the relevant stuff and makes an Executable file(.exe) and sends it to loader for final execution.
5. Loader:
    Loader finally loaded the code coming from previous terminals.

Before ending it I want to explain some basic topics further. its also important to understand:

What is a Header file?

•  A header file contains prototypes of functions and its corresponding library files contains definitions to those functions.
• A header file can also contain definitions and declarations but a library file cannot contain deceleration statements.

Where is Data stored created with New Keyword?

Data created with new keyword is stored in Heap Memory but it is accessed by stack(logical memory).

What are two main jobs of a Compiler?

There are two main jobs of a compiler:

1. Analyses: Lexical, Syntax and semantic analyses, error analyses.
2. Translation: Translate code into Machine language so that machine and interperate and act upon provided instructions.

If you have any question or you want me to write on any other topic just write it in comment section below..Providing value to you is our main objective:)