Object Oriented Programming

GATE

Data Structures

Data Structures in Python

Power BI

Data Science

Django

Data Structure and Algorithm

Python

Recursion

Arrays

Searching

Sorting

String

Linked List

Data Structures in C

Maths

Strings

C++ Tricks

System Design

Theory of Computation

Computer Organization and Architecture

Operating System

Engineering Mathematics

Database

Digital Logic

Computer Networks

GATE 2022

Java

GeeksforGeeks School

Hashing

Competitive Programming

Problem of the Day

School

HTML

Javascript

Bootstrap

Web Development

Android

Microsoft Office

Machine Learning

Resume Builder

Miscellaneous

Gblog

TechTips

React

Advanced JavaScript

DSA Self Paced

CS-subjects

Data Structures and Algorithms

Operating Systems

C Language

DBMS

Basics of CPP

Data Structures ( Basics )

Object Oriented Design

Dynamic Programming

Data Interpretation and Logical Reasoning

Algorithms

Core Java

RESTful APIs

Spring Basics

CPP-Tricks

Basics of Java

Aptitude

GATE YT

Flutter

Application Development

Blockchain

GFG SDE Sheet

SDE Sheet

Deep Learning

Go Programming

Placement

C++ Programs

Data Visualisation

DevOps

Docker

Queue

Matrix

Trie

Stack

Graph

Tree

Magic Numbers

Divide and Conquer

React Native

React JS

Interview-Questions

Advanced Java

cloud-computing

income tax

Artificial Intelligence

Programming Languages

Computer Graphics

Cyber Security

Project Management

DSA / Placements

GATE Prep

Data Analytics / Data Science

Development

Cloud / DevOps

All Courses

Courses

ML & Data Science

Interview Corner

CS Subjects

School Learning

Software and Tools

Tutorials

Google Build with AI

Practice Coding Problems

Connect 1:1 with Experts

Practice

Apply Now!

Post Jobs

Jobs Updates

Jobs

Are you curious about how programming languages are translated into executable code? Join us in this captivating tutorial as we dive into the fascinating world of compiler design – the backbone of modern software development, empowering you to understand the inner workings of programming languages and compilers.For additional details, check out our article: <a href="https://www.geeksforgeeks.org/introduction-of-compiler-design/">https://www.geeksforgeeks.org/introduction-of-compiler-design/</a>&nbsp;

Introduction to Compiler Design for GATE CSE

In this video, we will be discussing what is Intermediate Code Generation in Compiler Design. The procedure of translating any source code language into an internal form of code, before converting it completely to target code or machine code is called Intermediate code.&nbsp; This creation of Intermediate Code for any specific target machine is carried out by an intermediate code generator. Intermediate Code lies between high-level and machine-level language.&nbsp;Source Code → Intermediate Code → Target CodeIf any compiler is directly translating source code to machine code without generating the intermediate code, then for every new system/machine, a completely new compiler would have been required. Intermediate code eliminates the requirement of any new compiler by keeping the analysis part (front end) the same for all compilers. The synthesis part of the compiler i.e. the backend is changed as per the target machine.It is comparatively easy to modify source code for improving the performance of code by applying techniques of code optimization on intermediate code. Intermediate code is generally machine-independent. Because of this machine's independence, the portability of the code is enhanced. Retargeting has been facilitated. It’s now easier to modify source code for improving the source code’s performance by optimizing intermediate code.Different types of Intermediate Code representations are:<ul><li>Postfix notation</li><li>Three-address code&nbsp;</li><li>Syntax Tree</li></ul>Intermediate code generation in compiler design <a href="https://www.geeksforgeeks.org/intermediate-code-generation-in-compiler-design/">https://www.geeksforgeeks.org/intermediate-code-generation-in-compiler-design/</a>

Intermediate Code Generation in Compiler Design

Optimizing any code or algorithm plays an important role in enhancing its performance in terms of decreasing time complexity, space complexity, etc. It might involve decreasing the code’s size up to much extent. So, it can be said that optimization helps in reducing the resources and space consumed, thus increasing the compilation speed.Performing code optimization manually involves much time and the process is tedious too. So, it’s better to use a code optimizer for the same. An optimized code promotes the reusability of code.&nbsp;The code optimization procedure can be classified into two types:Machine Independent Optimization: This optimization phase improves the intermediate code for getting better target code in output. This intermediate code doesn’t involve, in general, any CPU registers or absolute memory locations.Machine Dependent Optimization: It is done after the generation of the target code. It generally involves CPU registers as well as absolute memory references. Such optimizers try to take maximum advantage of the memory hierarchy.Different ways of code optimization:<ul><li>Variable propagation method</li><li>Constant propagation</li><li>Constant folding</li><li>Copy Propagation</li><li>Common subexpression elimination</li><li>Dead code elimination</li><li>Unreachable code elimination</li><li>Strength reduction</li><li>Null sequences Code optimisation in compiler design: <a href="https://www.geeksforgeeks.org/code-optimization-in-compiler-design/">https://www.geeksforgeeks.org/code-optimization-in-compiler-design/</a></li></ul>

Code Optimization Techniques in Compiler Design

In this video, we will discussing what is three address code in compiler design. Three address code is one of the widely used intermediate codes which is easy in terms of creating and converting to target code. It uses three addresses at most and one operator for defining any expression.&nbsp;Basically, three address codes are used in determining the sequence of actions for the compiler.In three address codes, any expression is first broken down into such a way that no more than three addresses are required to express the code. These instructions are helpful in translating into assembly language easily.Three operands are equated with mostly anyone binary operator and an assignment. Generally, Three Address Codes are represented as p = q op r. p, q, and r are operands. Operands can be any constants or temporary variables generated by the compiler. op represents an operator.Some other examples of Three Address Codes are:<ul><li>p = q + r</li><li>x = y x z</li></ul>There are three ways to represent three address codes:<ul><li>Quadruple</li><li>Triples</li><li>Indirect Triples</li></ul>Quadruples: This representation consists of four fields: op, arg1, arg2, and result. op stands for operator and arg1, arg2 stands for two arguments or operands and the result is a variable used for storing the expression’s result.Characteristics:<ul><li>Easy in rearranging code for global optimization.</li><li>Quick access to temporary variables with the help of a symbol table.</li><li>Uses many temporary variables, that result in increasing time and space complexity.</li></ul>Triples:&nbsp;It doesn’t use any additional temporary variable for representing a single operation, instead whenever such reference is needed, a pointer is used. So, it is consisting of three fields only: op, arg1, and arg2.Disadvantage:<ul><li>Temporary variables are implicit and so it becomes difficult to rearrange the code.</li><li>Difficult to optimize code because optimization requires the movement of intermediate code. When any triple is moved, any other triple pointing to it must also be updated, so it may create a disturbance.</li></ul>Indirect Triples: It also makes use of a pointer to all the references to computations that are made individually and stored. It is quite similar to quadruple representation but it requires less space compared to that. In this, temporary variables are implicit, and rearranging the code is easier.Three address code: <a href="https://www.geeksforgeeks.org/three-address-code-compiler/">https://www.geeksforgeeks.org/three-address-code-compiler/</a>

Three address code in Compiler Design

In this video, we will be covering what is SDT in detail. The full form of SDT is Syntax Directed Translation. Whenever any informal notations (known as semantic rules) are associated with the CFG (Context Free Grammar), they are called STD.&nbsp; So it can be said that: Grammar + Semantic Rules = Syntax Directed TranslationIn the SDT, each non-terminal generally get one or more attribute depending on the type of attribute. These attribute values are evaluated by semantic rules corresponding to the rules of production. In SDT, information can be passed in either a bottom-up or top-down approach to parse tree with respect to the attributes that are attached to nodes.&nbsp; SDT rules utilize: 1) Node’s Lexical Values 2) Constants&nbsp; 3) Attributes with respect to the non-terminalsThe regular approach for SDT is constructing a parse tree and computing the attribute’s values at nodes of the parse tree by scanning them in any pre-defined order. Synthesized attributes: It is an attribute of non-terminal on the LHS of a production. It can take value only from its children.&nbsp; Example: If A → BC is a production, A’s attribute is dependent on B’s or C’s attributes.Inherited attributes: It is an attribute of non-terminal on the RHS of a production. It can take value either from its parent or from its siblings.&nbsp; Example: If A → BC is a production, B’s attribute is dependent on A’s or C’s attributes.S-attributed SDT: It uses only Synthesized Attributes. S-attributed SDTs are evaluated in bottom-up parsing, as the values of the parent node depend upon the values of the child nodes. Example: S → PQ &nbsp;{ S.val = P.val + Q.val }L-attributed SDT: It uses both Synthesized and Inherited Attributes, with a restriction that inherited attributes can inherit the values from left siblings only. S-attributed SDTs are evaluated in a top-down and left-to-right manner. Example: S→ PQ &nbsp;{ S.val = P.val + Q.val } // It is L-attributed &nbsp;M → AB &nbsp;{ A.val = B.val} // Not L-attributed SDT in compiler design: <a href="https://www.geeksforgeeks.org/syntax-directed-translation-in-compiler-design/">https://www.geeksforgeeks.org/syntax-directed-translation-in-compiler-design/</a>

Syntax Directed Translation (SDT) in Compiler Design

In this video, we will be discussing what is recursive descent parser &amp; the steps for constructing recursive descent parser. The parser which is using recursive functions or procedures to parse any given string, it is known as a Recursive descent parser. This parser uses the Top Down Parsing technique, without the involvement of backtracking.&nbsp; It uses different recursive procedures for processing the given string, with the help of Recursive languages.The main approach of this parsing is relating every non-terminal with their corresponding procedures. Every procedure reads a sequence of given characters that can possibly be produced by that non-terminal.Recursive descent Parser cannot parse Left Recursive or Left Factored Grammar. After removing left recursion as well as left factoring from any grammar, it is ready to be scanned/ parsed by any recursive descent parser.&nbsp; Recursive Descent Parsers aren’t as fast as some of the parsing methods. It’s quite difficult to provide good or meaningful error messages in Recursive Descent Parsers.Steps for constructing Recursive Descent Parser:<ul><li>The RHS of a production rule is being converted into the code one by one symbol.</li><li>If any non-terminal is given as input, then a procedure call is made corresponding to that non-terminal procedure.</li><li>If any terminal is given as input, then it’s matched with the input’s look-ahead.</li><li>If the production rule is having more alternates, then these alternatives should be combined into a single procedure.</li><li>Initially, the parser is activated by the start symbol’s procedure call.</li></ul>Recursive Descent Parser <a href="https://www.geeksforgeeks.org/recursive-descent-parser/">https://www.geeksforgeeks.org/recursive-descent-parser/</a>

Recursive Descent Parser with Example in Compiler Design

In this video, we will try to understand what is ambiguous grammar with the help of an example.&nbsp; Any grammar can be said as ambiguous grammar if there are multiple leftmost or rightmost derivative available for it. Also, any grammar is ambiguous grammar if multiple parse trees are possible for any given string. Any grammar that isn’t ambiguous, it is known as unambiguous grammar.&nbsp; Ambiguous grammar and unambiguous grammar, both are the types of context-free grammar. In case of any unambiguous grammar, every valid string should be having unique leftmost derivative or unique parse tree. Ambiguous grammar, is not good for the construction of compiler as it is generating more than one parse tree for same string and thus resulting in confusion.&nbsp; So, it’s always recommendable to eliminate ambiguity from any grammar. But unfortunately, there are no specific methods available to convert ambiguous grammar into unambiguous.&nbsp; Infact, there is no way by which we can automatically detect the ambiguity present in any grammar. Ambiguous grammar is generating parse tree of smaller size compared to unambiguous grammar. Ambiguous grammar is capable of generating parse tree faster.&nbsp; Try to disambiguate given grammar i.e., rewrite grammar in such a way that there’s only one parse tree possible for any string that can be represented by the grammar. Ambiguous grammar can be converted to the unambiguous grammar, by applying the below rules:&nbsp; In case the left associative operators i.e. +, -, / or * are utilized in production, then you should apply left recursion in given production rule so that the parse tree will grow on left side only.&nbsp; Similarly, in case the right associative operators i.e. ^ is utilized in production, then you should apply right recursion in given production rule so that the parse tree will grow on right side only.&nbsp; Ambiguous grammar: <a href="https://www.geeksforgeeks.org/ambiguous-grammar/">https://www.geeksforgeeks.org/ambiguous-grammar/</a>

Ambiguous Grammar in Compiler Design

In this video, we will be covering what is Non-deterministic grammar, left factoring &amp; left recursion in detail.Let us first see what is non-deterministic grammar.Grammar having common prefixes is called non-deterministic grammar. Such grammar requires backtracking due to confusion, which is actually a costly process. After tracing the first input “A”, there are two available options. So, the confusion is to go with b1, b2, or b3. Due to this confusion, Top-Down Parsers don’t prefer to parse Non-Deterministic Grammar.The process of removing this confusion is called eliminating non-determinism or Left Factoring. Most of the parsers avoid parsing grammar with non-deterministic behaviour, so we must remove non-determinism from the grammar before passing the grammar to parser.It is a procedure of factoring out common prefixes as long as possible. It is generally used in case when it’s not clear which of two available options should be used to expand LHS non-terminal. This grammar that is obtained after left-factoring is known as Left Factored Grammar. With left factored grammar compiler no longer needs backtracking. As backtracking is a costly procedure, so it can be avoided using left factored grammar. Left factoring can be applied to the grammar multiple times until the grammar becomes deterministic and unambiguous.Any Grammar G (V, T, P, S) can be said as left-recursive grammar if it is having production of the form: A → A α | β, where V means variable, T means Terminal, P means production rules, and S means Starting Symbol.&nbsp; It is called left-recursive because the LHS of the production is again occurring at first place on the RHS of the production. Such left recursion is said to be a problematic condition for the Top-down parsers.So, it is very necessary to eliminate left recursion from grammar.Introduction of parsing ambiguity &amp; parsers: <a href="https://www.geeksforgeeks.org/introduction-of-parsing-ambiguity-and-parsers-set-1/">https://www.geeksforgeeks.org/introduction-of-parsing-ambiguity-and-parsers-set-1/</a> Removing direct &amp; indirect left recursion in grammar: <a href="https://www.geeksforgeeks.org/removing-direct-and-indirect-left-recursion-in-a-grammar/">https://www.geeksforgeeks.org/removing-direct-and-indirect-left-recursion-in-a-grammar/</a>

Left Factoring (LF), Left Recursion (LR) and Non-deterministic in Grammar | Compiler Design

In this video, we will be covering what are first() & follow() in compiler design in detail
In compiler design, the sets of first and follow are required by the parser to identify and apply the appropriate production rules at the proper position. In Top-Down parsers, the sets of FIRST and FOLLOW help in determining which production is to be applied and when. 

Backtracking is needed in many cases of Syntax Analysis phase, which is very complicated to implement practically. Problem of Backtracking can be resolved by finding out the FIRST() set.

In Bottom-Down parsers, the sets of FIRST and FOLLOW help in identifying when the reduction should be applied.
Backtracking is needed in many cases of the Syntax Analysis phase, which is very complicated to implement practically. 

Problem of Backtracking can be resolved by finding out FIRST() set. If the first symbol of the production in RHS is: a terminal (including NULL), then include it directly in FIRST() set a non-terminal, then call the FIRST() function on that non-terminal and include those elements in the FIRST() set

The functions FOLLOW() and FIRST() are both involved while calculating FOLLOW() Set of any given Non-Terminal. 

If following any variable you have:
1) Terminal: Then write it as it is, in the follow set
2) Non-Terminal: Then write the elements of its FIRST() set
3) Last element of RHS: Then write FOLLOW() of LHS

FOLLOW() set will never contain NULL. FOLLOW() of starting symbol will at least contain $.

First & Follow in Compiler design: https://www.geeksforgeeks.org/why-first-and-follow-in-compiler-design/

First and Follow in Compiler Design

In this video, we will be specifically covering what is parsing &amp; the types of parsers are. Parsing is a phase of the compiler that generally takes token strings as input and then tokens are converted into Parse Tree or Syntax Tree. This process of transforming the data from one format to another i.e. from token to Parse Tree is called Parsing.Parser are mainly of two types: 1) Top-down parser 2) Bottom-up parserFurther Top-down and bottom-up parsers are categorized into different parsers: 1) Top-down Parser: The top-down parser generates parse for any given input string with the help of CFG grammar productions by expanding non-terminals i.e. starting from start symbol, expanding its productions and finally ending on terminals. Top-down parser uses left most derivation.Top-down parsers can be further classified into two types: Recursive descent parser &amp; Non-recursive descent parser2) Bottom-up Parser: Bottom-up Parsers generate the syntax tree or parse tree for any given input with help of the grammar productions by compressing non-terminals of Grammar’s RHS i.e. it starts from the existing non-terminals and ends on the start symbol. It uses the reverse of the rightmost derivation.Bottom-up parsers can be further classified into: - LR parsers &amp; Operator precedence parser:Types of Parsers in Compiler Design: <a href="https://www.geeksforgeeks.org/types-of-parsers-in-compiler-design/">https://www.geeksforgeeks.org/types-of-parsers-in-compiler-design/</a>

What is Parsing? Types of Parser | Compiler Design

Lexical Analysis is the first phase of compiler designing. Lexical Analysis helps in converting the source code into a series of tokens. In this video, we will be covering what is lexical analyser &amp; it's working as well.A lexical analyzer contains a tokenizer/ scanner. In case the lexical analyzer detects any invalid token, it generates an error. The primary role of the Lexical Analyzer is scanning character streams from source code, checking for valid tokens, and then pass data to the syntax analysis phase.Tokens are sequence of characters which represents any information unit in source code. Lexemes are sequence of the characters in a token. They are generally known as instance of token. There are predefined set of rules, considering which we can say that any lexeme is valid or not. These rules of identifying the validity of lexemes/ tokens are defined by the rules of grammar, with respect to pattern. Pattern describes what can be valid token, and such patterns are defined with the help of regex (regular expressions). There are different types of tokens, which are as follows: Keywords, Special Characters, Identifiers, Strings, Constant, Operators, etc.Working of Lexical Analyser: The primary task of the lexical analysis is reading input characters in code &amp; producing tokens. Lexical analyzer scans complete source code. It is identifying each token in order. Scanners are implemented in such a way that they produce the tokens only when it is being requested by parser. The command: “Get next token” is sent from parser to lexical analyzer, when it wants the next token in sequence. On acceptance of this command, lexical analyzer then scans input for next token and sends it to the parser.Roles of Lexical Analyser: Tokenization i.e. Divide the source code into valid tokens. Remove white space characters from the source code. Remove all the comments from the source code. Generate error messages along with the specific numbers of rows and columns. Helps in identifying token into symbol table. Helps to expand the macros if found in the source program.Lexical Analysis in Compiler Design: <a href="https://www.geeksforgeeks.org/introduction-of-lexical-analysis/">https://www.geeksforgeeks.org/introduction-of-lexical-analysis/</a> Working of Lexical Analyser: <a href="https://www.geeksforgeeks.org/working-of-lexical-analyzer-in-compiler/">https://www.geeksforgeeks.org/working-of-lexical-analyzer-in-compiler/</a>

Lexical Analysis & it's Working | Compiler Design

Error Handler is connected to all the phases of Compiler (Lexical Analyzer, Syntax Analyzer, Semantic Analyzer, Intermediate Code Generator, Code Optimizer, and Target Code Generator). The tasks of the Error Handler are to detect each error, report it to the user, and then make some recovery strategies and implement the strategies to handle the error.Three primary functions of Error Handler are: 1) Error Detection 2) Error Reporting 3) Error RecoveryError Detection and reporting:1) Lexical: It detects error when sequence of any input doesn’t match any token pattern. 2) Syntactical: These errors are detected during syntax phase analysis if something is missing like parenthesis, semicolon, operator, etc 3) Semantical: These errors are detected during semantic analysis phase. Such errors can occur due to wrong matching of operators with operands, assigning incompatible value to a variable, undeclared variable, etc. 4) Logical: Any error that is not specific enough to be included in above three categories and that includes logical issues in problem are logical errors. Example: Code not reachable, code iterating infinitely, etc.Error Recovery:Lexical error: Lexical errors are recovered using Panic Mode recovery1) Unknown characters are deleted. 2) Missing characters are inserted. 3) Transpose the characters. 4) Replace the characters.Syntactic Phase Error: Errors are recovered using:1) Panic Mode Recovery: Missing parenthesis, semicolon, etc. are inserted. 2) Statement Mode Recovery/ Phrase Level Recovery: In this method, right after discovering any error, recovery is done by correcting remaining input such that the remaining input statement allows parser to move further. It includes removing extra semicolons, etc. 3) Error productions: If any compiler designer has prior knowledge of errors which are common then such known errors can be recovered by increasing the existing grammar with error production that produce incorrect constructs. 4) Global correction: In Global Correction recovery method, parser considers full program at once. If there’s any error, it tries to find the closest matching of that program which is error-free and creates a syntax tree/ parse tree accordingly.Semantic Errors: In semantic phase, errors are being recovered by using symbol table. If datatypes of two operands are incompatible, compiler performs automatic type conversion.Error recovery &amp; detection in Compiler Design: <a href="https://www.geeksforgeeks.org/error-detection-recovery-compiler/">https://www.geeksforgeeks.org/error-detection-recovery-compiler/</a>

Error Detection and Recovery in Lexical Analyser

Practice Problems

JavaScript

Linux