Phases of Compiler | Compiler Design

Summary

This video script offers an in-depth exploration of the compiler's six phases: Lexical Analysis, Syntax Analysis, Semantic Analysis, Intermediate Code Generation, Code Optimization, and Target Code Generation. It explains the transformation of high-level language into assembly language, emphasizing the role of the symbol table and error handling. The script uses a simple mathematical expression to illustrate each phase's function, highlighting the importance of tokenization, parse tree construction, semantic verification, and optimization, culminating in the generation of efficient assembly code.

Takeaways

• 📚 A compiler is a program that consists of six distinct phases, each responsible for a specific task in the process of translating high-level language code into assembly language.
• 🔍 The Lexical Analyzer is the first phase, which breaks down the input high-level language into a stream of tokens, performing tokenization.
• 🌐 The Syntax Analyzer, also known as the Parser, constructs a parse tree from the stream of tokens, ensuring the code adheres to the language's grammar rules.
• 🔑 The Semantic Analyzer checks the parse tree for semantic correctness, including type checking, undeclared variables, and multiple declarations, using a symbol table to store variable information.
• 🛠️ Intermediate Code Generation takes the semantically verified parse tree and converts it into an intermediate representation, often in the form of three-address code.
• ⚙️ Code Optimization is an optional phase that refines the three-address code to reduce program size and improve efficiency by minimizing the number of lines.
• 🎯 Target Code Generation is the final phase, translating the optimized intermediate code into assembly language, which is closer to machine code.
• 🔍 The Symbol Table is a data structure used across all compiler phases to store and manage information about variables, such as their names and data types.
• 👮‍♂️ The Error Handler is responsible for reporting errors detected during any phase of the compilation process back to the user.
• 🔄 It is important to note that the compiler phases are not strictly sequential and can be executed in parallel, depending on the implementation.
• 📈 The script provides an example of compiling a simple line of code, demonstrating the role of each phase and the transformation from high-level language to assembly language.

Q & A

What are the six phases of a compiler?

The six phases of a compiler are Lexical Analyzer, Syntax Analyzer, Semantic Analyzer, Intermediate Code Generation, Code Optimization, and Target Code Generation.

What is the primary input for the compiler?

The primary input for the compiler is pure high-level language, which it then converts into assembly language.

What is the role of the Lexical Analyzer in the compilation process?

The Lexical Analyzer takes the input stream of characters from the high-level language and converts it into a stream of tokens, a process known as tokenization.

What is a token in the context of a Lexical Analyzer?

A token is a sequence of characters that represents the smallest unit of the language, such as identifiers, keywords, operators, and constants.

What does the Syntax Analyzer do with the stream of tokens?

The Syntax Analyzer constructs a parse tree from the stream of tokens, following a set of rules known as grammar to ensure the input is syntactically correct.

What is the purpose of the Semantic Analyzer?

The Semantic Analyzer verifies the parse tree semantically, checking for type correctness, undeclared variables, and multiple declarations, ensuring the program makes sense logically.

How does the Intermediate Code Generation phase represent the program?

The Intermediate Code Generation phase represents the program in a form known as three-address code, which is a popular format for intermediate code.

What is the function of the Code Optimization phase?

The Code Optimization phase aims to optimize the three-address code, improving the efficiency of the program by reducing the number of lines or the size of the code without changing its functionality.

What does the Target Code Generation phase produce?

The Target Code Generation phase produces assembly code, which is a lower-level representation of the program that is closer to machine code.

What is the role of the Symbol Table in the compilation process?

The Symbol Table is a data structure used to store information about the variables, their types, and other identifiers used in the program. It is utilized by various phases of the compiler, especially the Semantic Analyzer and the Lexical Analyzer, to keep track of declared elements.

What is the significance of the Error Handler in the compiler?

The Error Handler is responsible for reporting errors detected during the compilation process to the user. It is used by all phases of the compiler to ensure that any issues are communicated effectively.

Outlines

00:00

🤖 Compiler Phases Overview

This paragraph introduces the six main phases of a compiler: Lexical Analysis, Syntax Analysis, Semantic Analysis, Intermediate Code Generation, Code Optimization, and Target Code Generation. It explains the input to the compiler, which is a high-level language, and the output, which is assembly language. The paragraph also touches on the concept of a compiler as a program consisting of functions, each representing a phase, and the importance of the symbol table for storing variables and values across all phases. It sets the stage for a detailed discussion of each phase with an example.

05:02

🔍 Lexical Analysis and Tokenization

The second paragraph delves into the first phase of the compiler, Lexical Analysis, focusing on its role in converting a stream of characters into a stream of tokens. It describes the process of tokenization, where identifiers, keywords, operators, and constants are identified and given token names and values. The paragraph also explains the use of the symbol table to store information about identifiers and their types, which is crucial for later phases of the compilation process.

10:04

🌐 Syntax Analysis and Parse Tree Construction

This paragraph discusses the Syntax Analysis phase, also known as parsing, where the compiler constructs a parse tree from the stream of tokens. It highlights the importance of grammar rules in validating the syntax of the code. The process of checking the syntax correctness of the input code is explained, along with the construction of the parse tree, which is a hierarchical representation of the code's structure.

15:06

📑 Semantic Analysis and Type Checking

The fourth paragraph examines the Semantic Analysis phase, emphasizing its role in verifying the semantic correctness of the parse tree. It discusses type checking, undeclared variable detection, and multiple declaration checks as key functions of the semantic analyzer. The paragraph also clarifies the use of the symbol table in storing and retrieving data type information for variables, which is essential for semantic verification.

20:11

🔄 Intermediate Code Generation and Optimization

The focus of this paragraph is on the generation of intermediate code, specifically three-address code, and the subsequent optimization phase. It explains how the semantically verified parse tree is transformed into an intermediate representation that can be further optimized to reduce program size or improve efficiency. The paragraph also mentions that code optimization is an optional phase, as programmers can also write optimized code directly.

🛠️ Target Code Generation and Assembly Language

The final paragraph in the script describes the process of generating target code, which is the assembly language code. It illustrates how the optimized three-address code is translated into assembly code using registers and operations that the computer's hardware can understand. The paragraph concludes the discussion on compiler phases by summarizing the roles of the lexical analyzer, syntax analyzer, semantic analyzer, intermediate code generation, code optimization, and target code generation, and their interplay with the symbol table.

Keywords

💡Compiler

A compiler is a special program that translates code written in a high-level programming language into assembly language or machine code. In the video, the compiler is the central theme, as it is discussed in terms of its various phases and functions, which transform high-level language into a form that a computer can execute.

💡Phases of Compiler

The phases of a compiler refer to the distinct stages the compiler goes through to process code. There are six main phases: Lexical Analysis, Syntax Analysis, Semantic Analysis, Intermediate Code Generation, Code Optimization, and Target Code Generation. Each phase plays a critical role in the compilation process, as outlined in the script.

💡Lexical Analyzer

The lexical analyzer, also known as the scanner, is the first phase of the compiler. It takes the input code as a stream of characters and converts it into a stream of tokens. Tokens are the smallest units of the language, such as keywords, identifiers, operators, and constants. The script explains the process of tokenization and its importance in the compilation process.

💡Syntax Analyzer

The syntax analyzer, often referred to as the parser, constructs a parse tree from the stream of tokens generated by the lexical analyzer. It checks the grammatical structure of the code against a set of predefined rules, known as a grammar. The script emphasizes the critical role of the syntax analyzer in ensuring the syntactic correctness of the code.

💡Semantic Analyzer

The semantic analyzer is responsible for verifying the semantic meaning of the code, beyond its syntactic structure. It checks for type consistency, undeclared variables, and multiple declarations, among other things. The script provides examples of how the semantic analyzer uses the symbol table to ensure the semantic correctness of the code.

💡Intermediate Code Generation

Intermediate code generation involves converting the semantically verified parse tree into an intermediate representation of the code, often in the form of three-address code. This intermediate code is a simplified version of the original code, making it easier to optimize and translate into target code. The script explains the use of three-address code as a popular format for this phase.

💡Code Optimization

Code optimization is the phase where the intermediate code is analyzed and modified to improve the efficiency of the program. This can involve reducing the number of instructions, minimizing memory usage, or enhancing execution speed. The script notes that code optimization is an optional phase, as programmers can also write optimized code directly.

💡Target Code Generation

The final phase of the compiler is target code generation, where the optimized intermediate code is translated into assembly language or machine code specific to the target platform. The script illustrates this with an example of how high-level operations are translated into assembly instructions involving registers.

💡Symbol Table

A symbol table is a data structure used throughout the compilation process to store information about identifiers, such as variable names, their types, and scopes. The script explains that the symbol table is accessed by various phases of the compiler, particularly the semantic analyzer and the lexical analyzer, to maintain consistency and check for errors.

💡Error Handling

Error handling in the context of a compiler refers to the process of detecting and reporting errors that occur during the compilation process. The script mentions that each phase of the compiler, including lexical analysis and syntax analysis, has the capability to identify errors and report them to the user.

💡Type Checking

Type checking is a critical function of the semantic analyzer, where it verifies that operations are performed on compatible data types. The script provides an example of type checking by explaining the need to convert an integer to a float before performing multiplication, a process known as type casting.

Highlights

The total phases of a compiler are six, including Lexical Analyzer, Syntax Analyzer, Semantic Analyzer, Intermediate Code Generation, Code Optimization, and Target Code Generation.

A compiler takes pure high-level language as input and converts it to assembly language.

The Lexical Analyzer performs tokenization, converting a stream of characters into a stream of tokens.

Syntax Analyzer constructs a parse tree using a set of grammar rules to check for syntactic correctness.

Semantic Analyzer verifies the parse tree semantically, checking for type correctness, undeclared variables, and multiple declarations.

Intermediate Code Generation produces a three-address code representation of the program.

Code Optimization is an optional phase that aims to reduce the size of the program and the number of lines.

Target Code Generation converts the optimized three-address code into assembly code.

Symbol Table is a data structure used across all phases of the compiler for storing variables and their attributes.

Error handling is an integral part of the compiler, reporting errors found during various phases to the user.

The compiler's phases can be executed in parallel, not necessarily sequentially, as they are independent functions.

Type casting is a process where the data type of a value is converted to match the required type for operations.

The importance of the Symbol Table in storing variable names, types, and scopes for reference during compilation.

Lexical Analyzer assigns identifiers to variables and operators but does not store them in the Symbol Table unless declared.

Semantic Analyzer uses the Symbol Table to check for type mismatches, undeclared variables, and multiple declarations.

The three-address code is a popular format in intermediate code generation, limiting the use of three variables at most.

Code optimization simplifies the code by reducing the number of temporary variables and operations.

Assembly language generation involves mapping high-level constructs to machine-specific instructions.

The compiler's error handling mechanism ensures that any errors in the code are identified and reported to the user.

Transcripts

In this video, we will discuss about the phases of compiler.

So what are the total phases of compiler?

There are six phases.

Which are?

Lexical Analyzer, Syntax Analyzer, Semantic Analyzer, Intermediate Code Generation, Code Optimization and Target Code Generation.

So what does this mean?

This is the compiler of the overall app.

So what is the input for the compiler?

Pure high-level language.

And the compiler converts it to assembly language.

We have already discussed this.

So basically what is a compiler?

It is a program.

So what is a program?

It is some set of functions in a way.

So what is in it?

Compiler is a program which has six functions.

And all these six functions mean six phases.

When it is needed, we will call that function.

So now let's see what is one by one.

After that, let's go into its detailing.

So for this, the first phase is lexical analyzer.

So for this, the input is pure high-level language.

Which we call stream of characters.

Lexical analyzer has three phases.

So we will go to this character.

And it will convert it to stream of tokens.

So what is the work of lexical analyzer?

It will convert whatever is your program into tokens.

That's why it is called tokenization.

Anyway, all these things are examples.

We will understand all the things.

Now we will brief it.

What is the work of each phase?

Next, what is stream of tokens as an input?

For syntax analyzer.

What will syntax analyzer do?

It will construct it in the parse tree.

There are some set of rules in it.

It is called grammar. What happens through grammar?

The parse tree is generated.

It goes to semantic analyzer.

What does semantic analyzer do?

It is also a parse tree construct.

But it is called semantically verified parse tree.

What is it? We will understand it now.

After that, what is next?

Intermediate code generation.

So this parse tree as an input.

Semantically verified parse tree.

It is an input for intermediate code generation.

And to represent intermediate code generation,

we have a lot of formats.

But the most popular one is your three-address code.

So whatever program we write,

and at the end when we write it in intermediate code,

it will be three-address code.

Okay.

After that, this code optimization will go to it.

What code optimization will do?

It will optimize this three-address code.

It will convert it into optimized three-address code.

What is this optimized three-address code?

It will go to target code.

And what will target code generation do?

It will convert it into assembly code.

So this is the work of all the phases.

Now we will understand it as an example.

Before that, let's understand that all these phases,

when all these phases are processing,

that is, when they are running,

then it is possible that there is something

that we have to store.

Some values, some variables have to be stored.

What is the type of that variable?

To store all these things,

we need some data structure.

So for that, the data structure we use here is

your symbol table.

Who can use this?

All the phases can be used.

When someone needs to store something,

where will he go and store it?

In the symbol table.

So we have to compile the diagram.

So it is possible that at some point there will be an error.

So that error can also come in your lexical.

Syntax and so on.

There can be some error in all the phases.

So what do they report?

The error handler.

What does the error handler do?

It reports the user.

So error handlers use all the phases

and the symbol table also uses all the phases.

So this is your diagram.

Draw it.

Which is called phases of compiler.

Now we will understand the working of each phase by taking an example.

So let's see how all the phases of the compiler work.

So there are six phases.

Now let's see it one by one.

So I have taken a simple program of one line.

X equal to Y plus Z multiplied by 60.

Where X Y Z data type is float.

Okay.

So this is your pure high level language.

Because before compilation,

what is the output of pre-processing?

Pure high level language.

This is also called streams of characters.

So for lexical analyzer,

what is its output?

Tokens.

What is the work of lexical analyzer?

To convert the program into a token.

So what are tokens?

Token can be your identifier.

It can be a keyword.

It can be an operator.

It can be a constant.

These are all your tokens.

Anyway, lexical analyzer is also a separate chapter.

We will discuss that.

But here as of now we just understand

how lexical analyzer converts a program into a token.

So let's start the program.

As we got X.

So what is X?

It is X identifier.

So what is X identifier?

And what will it do correspondingly?

It will generate a token.

What is a token?

Its token name and its value.

That means attribute value.

ID comma 1.

What is exactly?

This is token name and this is its value.

Okay.

So this means it is token number 1.

Then what will come next?

Y.

Y is also your identifier.

So identifier comma second identifier.

Okay.

What is addition operator?

Then what is Z?

Your identifier is ID comma 3.

So that we can distinguish the three identifiers.

Okay.

The first number assigned is for X.

The second number assigned is for Y.

And the third number assigned is for Z.

Okay.

And all these identifiers will be found in lexical analyzer.

Symbol table.

First it is telling that 1,2,3.

That number.

Identify number 1.

Identify number 2.

Identify number 3.

In this your serial number, variable name and type.

Type of X is float.

Type of Y is also float.

Type of Z is also float.

So we will come to symbol table later.

How symbol table is created?

And who stores data in symbol table?

Everyone can store data in symbol table.

All the phases of compiler are used.

How exactly it is used?

We will come to that later.

Just understand that what is X?

Identify number 1.

Identify number 2 of Y.

Identify number 3 of Z.

What is multiplication operator?

And what is integer constant of 60?

Now here the question can be that

For X identifier,

You have written the identifier number.

That means its value.

So equal to plus multiplication 60.

Why is all this symbol table?

This can be a doubt.

It is written for identifier.

We have to identify X.

We have to identify Y.

We have to identify Z.

We have to identify numbers.

Equal to operators or constant.

Why no number is generated for this?

Because when you install C compiler in system.

By default in C compiler

Already there are many operator keywords.

So it already knows that what are they.

C compiler knows that

What is equal to, plus and multiplication.

But identifier is used.

Identifier means

It can be your variable name.

It can be your function name.

It can be your array name.

This compiler does not know.

Rules know that

By using this rule we declare variable.

We write the name of the variable.

So that's why we did not store it in symbol table.

But if there is any variable.

If there is any function name.

We have to store it in symbol table.

So that when we go to use it later.

We will know that what is X,Y,Z actually.

Because what happens.

The compiler does not know.

That X,Y,Z.

That's why we are storing it in symbol table.

That's why we are not giving any value to all these.

So this is tokenization.

This process is called tokenization.

And this X equal to Y,Z plus this

Which is written from here.

This is called lexeme.

And if we associate something with it.

What is this?

A token.

So now how will we write this?

ID comma 1.

What is ID comma 1? Identifier 1. What is this? X.

Which is equal to Y plus Z.

Multiplied by 60.

So the program.

The input of lexical analyzer.

X equal to Y plus Z.

Into 60.

And the output of this is.

This is the output.

Now where will this go?

This as an input will be syntax analyzer.

Which is second phase of compiler.

Syntax analyzer.

Which we also call parser.

Parser is a separate chapter.

The most important chapter of compiler is. Syntax analyzer.

Which is parser.

So the output of this is.

Parsery.

So what is parsery?

How is it constructed?

What are its rules and regulations?

You will see all these things later.

First we have to understand.

How is parsery constructed?

I have already drawn this.

What is the output of syntax analyzer?

Parsery.

What is the input?

Token.

What is set of rules?

As soon as you install compiler in your system.

What is the meaning of compiler?

Set of rules.

Through which we will check if there is any error or not.

So let's suppose we have taken.

Grammar.

So there will be a lot of grammar.

For this particular statement.

What is it?

S derives id which is equal to.

E equal to e plus t slash t.

T equal to t star f.

Slash f equal to id.

And int.

So what will we do through this grammar?

We will take it.

And through this grammar.

We will generate its parsery.

If this parsery is constructed.

It means it is syntactically correct.

So see how it is done.

Id which is equal to e.

E plus t.

So what will we do?

How will we check if it is correct or not?

Means we have got this input.

When we will give this to syntax analyzer.

So how will we check if your parsery is correct or not?

So what will we do?

We will check if it is equal or not.

So see.

Top to down.

What is the first leaf note?

Id.

So what is the meaning of id?

We are talking about id1.

Ok.

What is id1?

It is x.

Which is equal.

So now we will go top to down.

Top to down.

Left to right.

So it is plus.

Ok fine.

Then we will come here.

Where did we get next?

What is id3?

It is z.

What is id3?

It is z.

What is multiplication?

It is 60.

Means according to this rule.

The input we have given.

Set of tokens.

Or stream of tokens.

Means your program is syntactically correct.

Ok.

We just have to construct.

If it is constructed.

That means it is syntactically verified.

Next.

The most important phase in this compiler is.

Semantic analyzer.

We have understood this very well.

What is the work of semantic analyzer?

Input is parsery.

Output is parsery.

But what is added?

Semantically verified parsery.

This is very important.

In symbol table.

In symbol table.

These variables.

X,Y,Z.

Data types are stored.

What is that?

Semantic analyzer.

Lexical analyzer does not store it.

Why?

Because now what will it do?

It will verify semantically.

So what is the meaning of verifying semantically?

It is same parsery.

It is same parsery.

60.0

What was there?

60. That means it was integer value.

Now what will it do?

What happens is.

What will this semantic analyzer do first?

Note down here.

What is first?

Type checking.

Then undeclared variable.

Multiple declaration.

Semantic analyzer checks all these things.

So first let's see the meaning of type checking.

So the meaning of type checking is.

Let's suppose we have two values.

If we have to multiply them.

And store them somewhere.

Then data type of both values should be same.

If the data type of both values is different.

If we have to store them.

Then what will be?

Type mismatch.

So what is this?

What was this?

X.

What was this?

Y.

And what is this?

Z.

So what is the data type of X,Y and Z?

Integer.

So to multiply these two.

We have to convert integer to float.

This is called type casting.

So let's take an example of type casting.

Let's suppose int A.

Which is equal to.

Suppose this is 60.

Let's take another variable.

Float B.

Now what we have to do.

If we have to store this value in B.

Then what will we do?

B which is equal to.

Float bracket.

This is called type casting.

So here.

What is happening in this?

We have to multiply these two.

So what is your ID here?

Z.

What is the data type of Z? Float.

So what will be the data type of F? Float.

What will be the data type of T?

This is how evaluation is done.

How to evaluate in the past tree?

We will discuss that later.

Just see this.

What is your T? Float.

If we have to multiply.

Then we need this float and this float.

Only then it can be multiplied.

The data type of both can not be different.

It will be same only then we will multiply.

So the most important work of semantic analyzer.

What is that?

Semantically verify the parsage which is constructed.

That means the type should not be mismatched.

So what happened here?

It converted this 60 to 60.0.

Now this is also float.

This was already a float.

So what does this mean?

First point.

So who needs this symbol table?

Who needs this symbol table?

Semantic analyzer.

So this value which is stored.

Of X, Y and Z.

This lexical analyzer is not stored.

And yes, one very important thing.

There can be a confusion here.

First the lexical analyzer came.

So it will store this.

So it is not like that.

This is not a sequential execution in the compiler.

All the phases in the compiler.

They can be executed in parallel.

There is only one function.

There are six different functions.

I don't know which function will call whom.

So there is a set of code.

So there are many functions in it.

Function can be called anytime.

So it will jump and go there.

It will be executed.

So in the same way as soon as this line reads.

So good.

Float X, Y, Z.

So what will it need for type matching later?

Semantic analyzer.

So this float X, Y, Z.

Semantic analyzer will store.

Lexical analyzer also stores.

Let me tell you how it does it.

So this will happen.

So this means that these parts will be semantically verified.

Now what is the second?

Undeclared variable.

Let's suppose what we did.

This is not written.

This line is not there.

X equal to Y plus Z into 60.

What will the lexical analyzer do?

It will convert it into a token.

What is X? It is an identifier.

What is Y? It is also an identifier.

Because it has declared how to use the variable.

No.

It will only generate in the token.

And as soon as it comes here to the semantic analyzer.

So it will check.

Okay what is this?

Float is not here, float is not here, float is not here.

Who has stored this now?

If we do this first line.

Then who will store this?

Lexical analyzer.

Semantic analyzer stores only when its data type is declared.

But what does lexical analyzer have to do?

To convert into token.

What will it do? X, Y, Z. Corresponding.

What will it do? It will be blank.

Nothing will be stored in it.

As soon as it comes to the semantic analyzer.

It will go and check.

Okay, let's see.

So the thing is that it is missing.

So what will it do? It will show an error.

That we use such variables which are not declared.

So this is the second work.

What is the third? Multiple declaration.

So I don't know whether it is visible or not.

But see, I will explain.

Let's suppose we write int X which is equal to 60.

int X which is equal to 60.

This is the first declaration.

And who has written the second declaration?

float

X is equal to 60.0

So this means

We are using the same variable again.

There can be an integer as well.

It is not that the data type is different.

So int X is equal to 60. Float X is equal to 60.

So the memory allocation for this and for this.

So this means in the same program

We are using the same variable.

So this is also not allowed.

Who will identify this?

Semantic analyzer.

So what is the work of semantic analyzer? Type checking.

So what is the work of semantic analyzer? Type checking.

Will check if the variable is an undeclared.

Will check if the variable is an undeclared.

And will check multiple declaration.

Will check this and will show the error.

So the most important thing in all phases

Means

Syntax analyzer and Semantic analyzer

What will be the output of semantic analyzer?

Semantically verified parse tree.

So if the type is not mismatched

And your undeclared variable is not there

And there is no multiple declaration.

So what will it do?

as output. Now let's come to next intermediate code generation.

The most popular representation in intermediate code generation is 3 address code.

3 address code is also a separate chapter. So 3 address code means

that we can use only 3 maximum variables in it. T2 equal to Y plus T1.

So one variable is this, second one is this, third one is this. We can't use fourth variable.

There are many representations. But we are writing 3 address code.

So first of all, Z and 60 are multiplied. So Z multiplied by

60.0 is stored in a temporary variable. This is the output of intermediate code generation.

What is the input? Semantically verified pass-through.

We took T1 as a temporary variable, multiplied it and stored it in T1.

Now what? Y plus T1. See, Y plus Z into 60. We added it.

We added T1 into Y and stored it in T2. And T2 into X.

So what is this? 3 address code. So the output of intermediate code generation will be 3 address code.

Now who will have this? Code optimization. What is the work of code optimization?

To optimize the code, that is, to reduce the size of the program.

Or we can say to reduce the number of lines. So see, Y plus T1

we have to store in T2 and then T2 in X. So if we write directly X equal to Y plus T1, then we

have to minimize the number of lines. The size of the program is reduced by 1.

So this is your code optimization. And code optimization is not compulsory.

Code optimization is such a phase which is optional. It is possible that we wrote such a code

and wrote it directly. So its output will also be the same. So it means that code optimization

is optional. Why? Because we can write optimized code directly.

Now what is this? Optimized 3 address code. So what is optimized 3 address code?

Who will have optimized 3 address code? Target code generation.

What will it do? It will generate assembly language. So what is assembly language?

We have taken R0 and R1 two registers and stored Z value in R0 and Y value in R1.

So now what will we do? What is in R0? Z is in R0. So Z is here.

Z into 60. Where do we have to store it? We have to multiply Z into 60 and store it in R0.

So what is in R0? We have to multiply Z into 60 and store it in R0.

So what is the value of R0? Z into 60. Now what do we have to do? We have to add.

Y plus that means R0 is Z into 60. And what are we doing in R1? We are adding.

What is the value of R1? Y. So Y plus Z into 60. And then we are storing it in R1.

So addition is done in this way. Then what do we have in R1?

We have this value. Y plus Z into 60. And what have we done? We have stored it in X.

So this is your assembly language. So these were all the phases.

Did we miss any point? No. I think we have discussed all the points.

The most important thing was that what is the work of lexical analyzer? To generate token.

Ok. After that the work of syntax analyzer? To construct the past tree.

To construct the past tree and through which? Through grammar.

The work of semantic analyzer? It will verify the past tree semantically.

That means these three points. Now down this note. Ok.

Type checking, undeclared variable, multiple declaration. It will check all these.

If this is not a problem then corresponding to this. Then it will construct the semantically verified tree.

What will intermediate code generation do? It will generate three address code.

Code optimization will optimize it. That means it will reduce the number of lines.

And after that what will target code generation do? It will generate assembly code. Ok.

And this is your symbol table. Symbol table. Symbol table can use all the phases.

But mostly semantic analyzer and lexical analyzer are used.

But it is that anyone can use it. So these were all the phases of compiler.

And we have discussed it through an example. Now we will discuss that every phase is different.

What are the things in lexical analyzer? Then we will see syntax analyzer.

Then we will discuss all the chapters of semantic one by one.