Compiler Construction
•Download as PPT, PDF•
4 likes•10,941 views
The document provides an introduction to compiler construction including: 1. The objectives of understanding how to build a compiler, use compiler construction tools, understand assembly code and virtual machines, and define grammars. 2. An overview of compilers and interpreters including the analysis-synthesis model of compilation where analysis determines operations from the source program and synthesis translates those operations into the target program. 3. An outline of the phases of compilation including preprocessing, compiling, assembling, and linking source code into absolute machine code using tools like scanners, parsers, syntax-directed translation, and code generators.
Report
Share
Report
Share
Recommended
Compilers
A compiler is a program that translates a program written in one language into an equivalent target language. The front end checks syntax and semantics, while the back end translates the source code into assembly code. The compiler performs lexical analysis, syntax analysis, semantic analysis, code generation, optimization, and error handling. It identifies errors at compile time to help produce efficient, error-free code.
Compiler design
This document discusses compiler design and how compilers work. It begins with prerequisites and definitions of compilers and their origins. It then describes the architecture of compilers, including lexical analysis, parsing, semantic analysis, code optimization, and code generation. It explains how compilers translate high-level code into machine-executable code. In conclusions, it summarizes that compilers translate code without changing meaning and aim to make code efficient. References for further reading on compiler design principles are also provided.
Introduction to Compiler design
The document discusses compilers and their role in translating high-level programming languages into machine-readable code. It notes that compilers perform several key functions: lexical analysis, syntax analysis, generation of an intermediate representation, optimization of the intermediate code, and finally generation of assembly or machine code. The compiler allows programmers to write code in a high-level language that is easier for humans while still producing efficient low-level code that computers can execute.
Phases of Compiler
The document provides an overview of compilers by discussing:
1. Compilers translate source code into executable target code by going through several phases including lexical analysis, syntax analysis, semantic analysis, code optimization, and code generation.
2. An interpreter directly executes source code statement by statement while a compiler produces target code as translation. Compiled code generally runs faster than interpreted code.
3. The phases of a compiler include a front end that analyzes the source code and produces intermediate code, and a back end that optimizes and generates the target code.
Compiler Construction introduction
The document discusses the basics of compiler construction. It begins by defining key terms like compilers, source and target languages. It then describes the main phases of compilation as lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization and machine code generation. It also discusses symbol tables, compiler tools and generations of programming languages.
Compiler Design
This document provides information about the CS416 Compiler Design course, including the instructor details, prerequisites, textbook, grading breakdown, course outline, and an overview of the major parts and phases of a compiler. The course will cover topics such as lexical analysis, syntax analysis using top-down and bottom-up parsing, semantic analysis using attribute grammars, intermediate code generation, code optimization, and code generation.
Syntax Analysis in Compiler Design
Syntax analysis is the second phase of compiler design after lexical analysis. The parser checks if the input string follows the rules and structure of the formal grammar. It builds a parse tree to represent the syntactic structure. If the input string can be derived from the parse tree using the grammar, it is syntactically correct. Otherwise, an error is reported. Parsers use various techniques like panic-mode, phrase-level, and global correction to handle syntax errors and attempt to continue parsing. Context-free grammars are commonly used with productions defining the syntax rules. Derivations show the step-by-step application of productions to generate the input string from the start symbol.
Compiler Construction
How compiler works?Phases of compiler,Virtual machines for compiler,Assembler,two pass Assembler,Quadruples,Triples,
Recommended
Compilers
A compiler is a program that translates a program written in one language into an equivalent target language. The front end checks syntax and semantics, while the back end translates the source code into assembly code. The compiler performs lexical analysis, syntax analysis, semantic analysis, code generation, optimization, and error handling. It identifies errors at compile time to help produce efficient, error-free code.
Compiler design
This document discusses compiler design and how compilers work. It begins with prerequisites and definitions of compilers and their origins. It then describes the architecture of compilers, including lexical analysis, parsing, semantic analysis, code optimization, and code generation. It explains how compilers translate high-level code into machine-executable code. In conclusions, it summarizes that compilers translate code without changing meaning and aim to make code efficient. References for further reading on compiler design principles are also provided.
Introduction to Compiler design
The document discusses compilers and their role in translating high-level programming languages into machine-readable code. It notes that compilers perform several key functions: lexical analysis, syntax analysis, generation of an intermediate representation, optimization of the intermediate code, and finally generation of assembly or machine code. The compiler allows programmers to write code in a high-level language that is easier for humans while still producing efficient low-level code that computers can execute.
Phases of Compiler
The document provides an overview of compilers by discussing:
1. Compilers translate source code into executable target code by going through several phases including lexical analysis, syntax analysis, semantic analysis, code optimization, and code generation.
2. An interpreter directly executes source code statement by statement while a compiler produces target code as translation. Compiled code generally runs faster than interpreted code.
3. The phases of a compiler include a front end that analyzes the source code and produces intermediate code, and a back end that optimizes and generates the target code.
Compiler Construction introduction
The document discusses the basics of compiler construction. It begins by defining key terms like compilers, source and target languages. It then describes the main phases of compilation as lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization and machine code generation. It also discusses symbol tables, compiler tools and generations of programming languages.
Compiler Design
This document provides information about the CS416 Compiler Design course, including the instructor details, prerequisites, textbook, grading breakdown, course outline, and an overview of the major parts and phases of a compiler. The course will cover topics such as lexical analysis, syntax analysis using top-down and bottom-up parsing, semantic analysis using attribute grammars, intermediate code generation, code optimization, and code generation.
Syntax Analysis in Compiler Design
Syntax analysis is the second phase of compiler design after lexical analysis. The parser checks if the input string follows the rules and structure of the formal grammar. It builds a parse tree to represent the syntactic structure. If the input string can be derived from the parse tree using the grammar, it is syntactically correct. Otherwise, an error is reported. Parsers use various techniques like panic-mode, phrase-level, and global correction to handle syntax errors and attempt to continue parsing. Context-free grammars are commonly used with productions defining the syntax rules. Derivations show the step-by-step application of productions to generate the input string from the start symbol.
Compiler Construction
How compiler works?Phases of compiler,Virtual machines for compiler,Assembler,two pass Assembler,Quadruples,Triples,
Introduction to Compiler Construction
Translation of a program written in a source language into a semantically equivalent program written in a target language
It also reports to its users the presence of errors in the source program
Semantic analysis
presentation slides compiler construction
SDT is done by attaching rules to productions in a grammar
Every node of the abstract syntax tree is attached with certain attribute set
Example :
E---- E+T {E.val=E.val+T.val}
Lexical analysis - Compiler Design
The document discusses lexical analysis in compilers. It describes how the lexical analyzer reads source code characters and divides them into tokens. Regular expressions are used to specify patterns for token recognition. The lexical analyzer generates a finite state automaton to recognize these patterns. Lexical analysis is the first phase of compilation that separates the input into tokens for the parser.
Intermediate code generation (Compiler Design)
Compiler Design
Discuss Topics: Intermediate code generation
three address code generation
quadruple,triple,Indirect triple etc
Specification-of-tokens
Types of strings, How to specify token, regular expression representation, notations of regular expression
Context free grammars
Context free grammars (CFGs) are formal systems that describe the structure of languages. A CFG consists of variables, terminals, production rules, and a start variable. Production rules take the form of a single variable producing a string of terminals and/or variables. CFGs can capture the recursive structure of natural languages while ignoring agreement and reference. They are used to define context-free languages and generate parse trees. Ambiguous grammars have sentences with multiple parse trees, and disambiguation aims to impose an ordering on derivations. While ambiguity cannot always be eliminated, simplifying and restricting grammars has theoretical and practical benefits.
Assemblers
This document discusses assembly language and assemblers. It begins by explaining that assembly language provides a more readable and convenient way to program compared to machine language. It then describes how an assembler works, translating assembly language programs into machine code. The elements of assembly language are defined, including mnemonic operation codes, symbolic operands, and data declarations. The document also covers instruction formats, sample assembly language programs, and the processing an assembler performs to generate machine code from assembly code.
Lex
Lex is a program generator designed for lexical processing of character input streams. It works by translating a table of regular expressions and corresponding program fragments provided by the user into a program. This program then reads an input stream, partitions it into strings matching the given expressions, and executes the associated program fragments in order. Flex is a fast lexical analyzer generator that is an alternative to Lex. It generates scanners that recognize lexical patterns in text based on pairs of regular expressions and C code provided by the user.
Introduction to Compiler
This document provides an introduction to compilers, including definitions of key terms like source code, target code, and compiler phases. It describes the main stages in compilation: scanning, parsing, semantic analysis, intermediate code generation, code optimization, and code generation. It also discusses important data structures like symbol tables, literal tables, and parse trees. Finally, it reviews the history of compilers from the 1930s to the 1970s and development of technologies like assemblers, recursive descent parsing, and LR parsing.
Passes of compilers
There are two types of compiler passes: multi-pass compilers perform multiple traversals of the source code to perform different stages of compilation like scanning, parsing, semantic analysis, etc. One-pass compilers only traverse the source code once, performing all compilation stages on each line before moving to the next.
Bootstrapping is the process of using a compiler written in a language to compile itself, allowing the creation of a self-hosting compiler for that language. It involves first creating a simple bootstrap compiler for a language subset, then using that to compile a full compiler for the language which can then compile future versions.
Compiler construction tools
Compiler construction tools were introduced to aid in the development of compilers. These tools include scanner generators, parser generators, syntax-directed translation engines, and automatic code generators. Scanner generators produce lexical analyzers based on regular expressions to recognize tokens. Parser generators take context-free grammars as input to produce syntax analyzers. Syntax-directed translation engines associate translations with parse trees to generate intermediate code. Automatic code generators take intermediate code as input and output machine language. These tools help automate and simplify the compiler development process.
Unit1 principle of programming language
This document provides an overview of key concepts related to programming languages. It discusses the definition of a programming language and the history and evolution of popular languages from 1951 to present. It covers programming language paradigms like procedural, object-oriented, functional, and logic-based languages. It also discusses factors that influence language design like efficiency, regularity, and issues in language translation. Finally, it summarizes the structure and operation of computers and how different programming models map to underlying computer architectures.
Principles of programming languages. Detail notes
The document provides an overview of principles of programming languages, including:
- Reasons for studying programming language concepts such as improved ability to learn new languages.
- Categories of programming languages including imperative, functional, logic, and object-oriented languages.
- Factors that influence language design such as computer architecture and programming methodologies.
- Methods of describing syntax including Backus-Naur Form and context-free grammars. Attribute grammars add semantic information to parse trees.
- Implementation methods for languages including compilation, interpretation, and hybrid systems.
Compiler Design Unit 1
This document provides an overview of compilers, including their history, components, and construction. It discusses the need for compilers to translate high-level programming languages into machine-readable code. The key phases of a compiler are described as scanning, parsing, semantic analysis, intermediate code generation, optimization, and code generation. Compiler construction relies on tools like scanner and parser generators.
Issues in the design of Code Generator
The document discusses issues in code generation by a compiler. It defines code generation as converting an intermediate representation into executable machine code. The code generator accesses symbol tables and performs multiple passes over intermediate forms. Key issues addressed include the input to the code generator, generating code for the target machine, memory management, instruction selection, register allocation, and optimization techniques like reordering independent instructions to improve efficiency.
Top down parsing
This document discusses top-down parsing and different types of top-down parsers, including recursive descent parsers, predictive parsers, and LL(1) grammars. It explains how to build predictive parsers without recursion by using a parsing table constructed from the FIRST and FOLLOW sets of grammar symbols. The key steps are: 1) computing FIRST and FOLLOW, 2) filling the predictive parsing table based on FIRST/FOLLOW, 3) using the table to parse inputs in a non-recursive manner by maintaining the parser's own stack. An example is provided to illustrate constructing the FIRST/FOLLOW sets and parsing table for a sample grammar.
Lecture 01 introduction to compiler
This document provides an introduction to compilers, including:
- What compilers are and their role in translating programs to machine code
- The main phases of compilation: lexical analysis, syntax analysis, semantic analysis, code generation, and optimization
- Key concepts like tokens, parsing, symbol tables, and intermediate representations
- Related software tools like preprocessors, assemblers, loaders, and linkers
Principal source of optimization in compiler design
Unit 5 Principal source of optimization in compiler design in SRM IST, Kattankulathur by Prof. R. Rajkumar AP | CSE | SRM IST
Chapter 5 Syntax Directed Translation
Syntax directed translation allows semantic information to be associated with a formal language by attaching attributes to grammar symbols and defining semantic rules. There are several types of attributes including synthesized and inherited. Syntax directed definitions specify attribute values using semantic rules associated with grammar productions. Evaluation of attributes requires determining an order such as a topological sort of a dependency graph. Syntax directed translation schemes embed program fragments called semantic actions within grammar productions. Actions can be placed inside or at the ends of productions. Various parsing strategies like bottom-up can be used to execute the actions at appropriate times during parsing.
COMPILER DESIGN
This document provides an overview of syntax analysis in compiler design. It discusses context free grammars, derivations, parse trees, ambiguity, and various parsing techniques. Top-down parsing approaches like recursive descent parsing and LL(1) parsing are described. Bottom-up techniques including shift-reduce parsing and operator precedence parsing are also introduced. The document provides examples and practice problems related to grammar rules, derivations, parse trees, and eliminating ambiguity.
Compiler Chapter 1
Compiler principles, techniques, and tools by Alfred V. Aho, Ravi Sethi, Jeffrey D.Ullman,
Compiler Chapter 1,
what is compiler and five phases of compiler
pls download to see full transition and parse tree structure .pls contact for further detail
adilm717@gmail.com
More Related Content
What's hot
Introduction to Compiler Construction
Translation of a program written in a source language into a semantically equivalent program written in a target language
It also reports to its users the presence of errors in the source program
Semantic analysis
presentation slides compiler construction
SDT is done by attaching rules to productions in a grammar
Every node of the abstract syntax tree is attached with certain attribute set
Example :
E---- E+T {E.val=E.val+T.val}
Lexical analysis - Compiler Design
The document discusses lexical analysis in compilers. It describes how the lexical analyzer reads source code characters and divides them into tokens. Regular expressions are used to specify patterns for token recognition. The lexical analyzer generates a finite state automaton to recognize these patterns. Lexical analysis is the first phase of compilation that separates the input into tokens for the parser.
Intermediate code generation (Compiler Design)
Compiler Design
Discuss Topics: Intermediate code generation
three address code generation
quadruple,triple,Indirect triple etc
Specification-of-tokens
Types of strings, How to specify token, regular expression representation, notations of regular expression
Context free grammars
Context free grammars (CFGs) are formal systems that describe the structure of languages. A CFG consists of variables, terminals, production rules, and a start variable. Production rules take the form of a single variable producing a string of terminals and/or variables. CFGs can capture the recursive structure of natural languages while ignoring agreement and reference. They are used to define context-free languages and generate parse trees. Ambiguous grammars have sentences with multiple parse trees, and disambiguation aims to impose an ordering on derivations. While ambiguity cannot always be eliminated, simplifying and restricting grammars has theoretical and practical benefits.
Assemblers
This document discusses assembly language and assemblers. It begins by explaining that assembly language provides a more readable and convenient way to program compared to machine language. It then describes how an assembler works, translating assembly language programs into machine code. The elements of assembly language are defined, including mnemonic operation codes, symbolic operands, and data declarations. The document also covers instruction formats, sample assembly language programs, and the processing an assembler performs to generate machine code from assembly code.
Lex
Lex is a program generator designed for lexical processing of character input streams. It works by translating a table of regular expressions and corresponding program fragments provided by the user into a program. This program then reads an input stream, partitions it into strings matching the given expressions, and executes the associated program fragments in order. Flex is a fast lexical analyzer generator that is an alternative to Lex. It generates scanners that recognize lexical patterns in text based on pairs of regular expressions and C code provided by the user.
Introduction to Compiler
This document provides an introduction to compilers, including definitions of key terms like source code, target code, and compiler phases. It describes the main stages in compilation: scanning, parsing, semantic analysis, intermediate code generation, code optimization, and code generation. It also discusses important data structures like symbol tables, literal tables, and parse trees. Finally, it reviews the history of compilers from the 1930s to the 1970s and development of technologies like assemblers, recursive descent parsing, and LR parsing.
Passes of compilers
There are two types of compiler passes: multi-pass compilers perform multiple traversals of the source code to perform different stages of compilation like scanning, parsing, semantic analysis, etc. One-pass compilers only traverse the source code once, performing all compilation stages on each line before moving to the next.
Bootstrapping is the process of using a compiler written in a language to compile itself, allowing the creation of a self-hosting compiler for that language. It involves first creating a simple bootstrap compiler for a language subset, then using that to compile a full compiler for the language which can then compile future versions.
Compiler construction tools
Compiler construction tools were introduced to aid in the development of compilers. These tools include scanner generators, parser generators, syntax-directed translation engines, and automatic code generators. Scanner generators produce lexical analyzers based on regular expressions to recognize tokens. Parser generators take context-free grammars as input to produce syntax analyzers. Syntax-directed translation engines associate translations with parse trees to generate intermediate code. Automatic code generators take intermediate code as input and output machine language. These tools help automate and simplify the compiler development process.
Unit1 principle of programming language
This document provides an overview of key concepts related to programming languages. It discusses the definition of a programming language and the history and evolution of popular languages from 1951 to present. It covers programming language paradigms like procedural, object-oriented, functional, and logic-based languages. It also discusses factors that influence language design like efficiency, regularity, and issues in language translation. Finally, it summarizes the structure and operation of computers and how different programming models map to underlying computer architectures.
Principles of programming languages. Detail notes
The document provides an overview of principles of programming languages, including:
- Reasons for studying programming language concepts such as improved ability to learn new languages.
- Categories of programming languages including imperative, functional, logic, and object-oriented languages.
- Factors that influence language design such as computer architecture and programming methodologies.
- Methods of describing syntax including Backus-Naur Form and context-free grammars. Attribute grammars add semantic information to parse trees.
- Implementation methods for languages including compilation, interpretation, and hybrid systems.
Compiler Design Unit 1
This document provides an overview of compilers, including their history, components, and construction. It discusses the need for compilers to translate high-level programming languages into machine-readable code. The key phases of a compiler are described as scanning, parsing, semantic analysis, intermediate code generation, optimization, and code generation. Compiler construction relies on tools like scanner and parser generators.
Issues in the design of Code Generator
The document discusses issues in code generation by a compiler. It defines code generation as converting an intermediate representation into executable machine code. The code generator accesses symbol tables and performs multiple passes over intermediate forms. Key issues addressed include the input to the code generator, generating code for the target machine, memory management, instruction selection, register allocation, and optimization techniques like reordering independent instructions to improve efficiency.
Top down parsing
This document discusses top-down parsing and different types of top-down parsers, including recursive descent parsers, predictive parsers, and LL(1) grammars. It explains how to build predictive parsers without recursion by using a parsing table constructed from the FIRST and FOLLOW sets of grammar symbols. The key steps are: 1) computing FIRST and FOLLOW, 2) filling the predictive parsing table based on FIRST/FOLLOW, 3) using the table to parse inputs in a non-recursive manner by maintaining the parser's own stack. An example is provided to illustrate constructing the FIRST/FOLLOW sets and parsing table for a sample grammar.
Lecture 01 introduction to compiler
This document provides an introduction to compilers, including:
- What compilers are and their role in translating programs to machine code
- The main phases of compilation: lexical analysis, syntax analysis, semantic analysis, code generation, and optimization
- Key concepts like tokens, parsing, symbol tables, and intermediate representations
- Related software tools like preprocessors, assemblers, loaders, and linkers
Principal source of optimization in compiler design
Unit 5 Principal source of optimization in compiler design in SRM IST, Kattankulathur by Prof. R. Rajkumar AP | CSE | SRM IST
Chapter 5 Syntax Directed Translation
Syntax directed translation allows semantic information to be associated with a formal language by attaching attributes to grammar symbols and defining semantic rules. There are several types of attributes including synthesized and inherited. Syntax directed definitions specify attribute values using semantic rules associated with grammar productions. Evaluation of attributes requires determining an order such as a topological sort of a dependency graph. Syntax directed translation schemes embed program fragments called semantic actions within grammar productions. Actions can be placed inside or at the ends of productions. Various parsing strategies like bottom-up can be used to execute the actions at appropriate times during parsing.
COMPILER DESIGN
This document provides an overview of syntax analysis in compiler design. It discusses context free grammars, derivations, parse trees, ambiguity, and various parsing techniques. Top-down parsing approaches like recursive descent parsing and LL(1) parsing are described. Bottom-up techniques including shift-reduce parsing and operator precedence parsing are also introduced. The document provides examples and practice problems related to grammar rules, derivations, parse trees, and eliminating ambiguity.
What's hot (20)
Principal source of optimization in compiler design
Principal source of optimization in compiler design
Viewers also liked
Compiler Chapter 1
Compiler principles, techniques, and tools by Alfred V. Aho, Ravi Sethi, Jeffrey D.Ullman,
Compiler Chapter 1,
what is compiler and five phases of compiler
pls download to see full transition and parse tree structure .pls contact for further detail
adilm717@gmail.com
Phases of the Compiler - Systems Programming
The document describes the various phases of compilation:
1. Lexical analysis scans the source code and groups characters into tokens.
2. Syntax analysis checks syntax and constructs parse trees.
3. Semantic analysis generates intermediate code, checks for semantic errors using symbol tables, and enforces type checking.
4. Optional optimization improves programs by making them more efficient.
Compiler Construction
Translation of a program written in a source language into a semantically equivalent program written in a target language
Compiler Construction Course - Introduction
The document provides an overview of compilers and interpreters. It discusses how compilers translate source code into target code like machine language while interpreters directly execute source code. It also describes the different stages of compilation from preprocessing to assembly and linking. Key points made include:
- Compilers translate entire programs at once while interpreters translate and execute one line at a time.
- Compilers generate error reports after full translation while interpreters stop at the first error.
- Compilation takes more time than interpretation but executed code runs faster.
- Some languages use hybrid approaches that interpret translated bytecode for faster execution.
- Larger programs are compiled in pieces and linked together with libraries before execution.
Compiler construction
Compiler Construction
Phases of a compiler
Analysis and synthesis phases
-------------------
-> Compilation Issues
-> Phases of compilation
-> Structure of compiler
-> Code Analysis
Compiler Design - Introduction to Compiler
This document contains information about a compiler design course including the instructor's contact details, class schedules, grading breakdown, attendance policies, prerequisite knowledge, recommended textbooks, an overview of what will be covered in the course, and brief introductions and explanations of the main stages of compilation: lexical analysis, parsing, semantic analysis, optimization, and code generation.
Lexical analyzer
The document discusses the different phases of a compiler including lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization, and code generation. It provides details on each phase and the techniques involved. The overall structure of a compiler is given as taking a source program through various representations until target machine code is generated. Key terms related to compilers like tokens, lexemes, and parsing techniques are also introduced.
Compiler
This document defines and describes compilers. It discusses that a compiler translates high-level programming languages into machine-level languages. The compiler process involves two main phases - analysis and synthesis. The analysis phase breaks down the source code and generates an intermediate representation through lexical, syntax and semantic analysis. The synthesis phase then generates target code from the intermediate representation, optimizing and outputting assembly code. The document also outlines the typical structure of a compiler into front-end, middle-end and back-end components and discusses native compilers, cross compilers and virtual machines.
compiler and their types
The document discusses compilers, defining them as programs that translate human-oriented programming languages into machine languages. It describes the main phases of a compiler as lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization, and code generation. Finally, it outlines different types of compilers, including native code compilers, cross compilers, source-to-source compilers, one-pass compilers, threaded code compilers, incremental compilers, and source compilers.
Lecture 11 semantic analysis 2
This document discusses inherited and synthesized attributes in semantic analysis using syntax-directed translation (SDT). It covers:
- Synthesized attributes are defined by semantic rules associated with productions and rely only on child nodes, while inherited attributes rely on parent/sibling nodes.
- Terminals can have synthesized attributes from lexing but not inherited attributes. Nonterminals can have both.
- Annotated parse trees show attribute values, while dependency graphs determine evaluation order.
- S-attributed definitions rely only on synthesized attributes and evaluate bottom-up. L-attributed definitions restrict inherited attributes to avoid cycles.
- SDTs can construct syntax trees during parsing to decouple parsing from translation
Syntax directed translation
This document discusses syntax-directed translation, which refers to a method of compiler implementation where the source language translation is completely driven by the parser. The parsing process and parse trees are used to direct semantic analysis and translation of the source program. Attributes and semantic rules are associated with the grammar symbols and productions to control semantic analysis and translation. There are two main representations of semantic rules: syntax-directed definitions and syntax-directed translation schemes. Syntax-directed translation schemes embed program fragments called semantic actions within production bodies and are more efficient than syntax-directed definitions as they indicate the order of evaluation of semantic actions. Attribute grammars can be used to represent syntax-directed translations.
Compiler Design Basics
This document provides an overview of compiler design, including:
- The history and importance of compilers in translating high-level code to machine-level code.
- The main components of a compiler including the front-end (analysis), back-end (synthesis), and tools used in compiler construction.
- Key phases of compilation like lexical analysis, syntax analysis, semantic analysis, code optimization, and code generation.
- Types of translators like interpreters, assemblers, cross-compilers and their functions.
- Compiler construction tools that help generate scanners, parsers, translation engines, code generators, and data flow analysis.
Ch5a
The document discusses syntax-directed translation using attribute grammars. Attribute grammars assign semantic values or attributes to the symbols in a context-free grammar. A depth-first traversal of the parse tree executes semantic rules that calculate the values of attributes. There are two types of attributes: synthesized attributes which are computed bottom-up and inherited attributes which are passed top-down. L-attributed grammars allow efficient evaluation by passing inherited attributes left-to-right during a depth-first traversal.
Lexical analyzer
This document provides an introduction to lexical analysis and regular expressions. It discusses topics like input buffering, token specifications, the basic rules of regular expressions, precedence of operators, equivalence of expressions, transition diagrams, and the lex tool for generating lexical analyzers from regular expressions. Key points covered include the definition of regular languages by regular expressions, the use of finite automata to recognize patterns in lexical analysis, and how lex compiles a file written in its language into a C program that acts as a lexical analyzer.
Input-Buffering
Algorithm for Buffer Pairs, Algorithm for Sentinels,
Working of Buffer Pairs and Sentinels with example
Recognition-of-tokens
Relational operator transition diagram, transition diagram of identifiers or digits, Token Recognition, rules to specify and recognize token
Ktu - s1 me module 1 (Calculus Module 1)
This document defines and explains several types of infinite series and tests used to determine if they converge or diverge. It introduces infinite series and sequences of partial sums. It then discusses tests for convergence/divergence including the geometric series test, limit comparison test, ratio test, root test, alternating series test, absolute convergence test, and radius of convergence for power series. Types of series covered include Taylor series and Maclaurin series expansions.
Lecture 1 introduction to language processors
The document provides an overview of the different phases of a compiler: lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization, and code generation. It discusses each phase briefly and provides examples to illustrate how a program is processed through each step of compilation.
Register Allocation
This document discusses register allocation in compiler construction. It begins with an example of constructing an interference graph from a code snippet during liveness analysis. It then covers the main steps of register allocation: constructing interference graphs from liveness analysis, graph coloring to assign registers while minimizing spills, and handling move instructions through coalescing. It provides examples demonstrating graph coloring on interference graphs with different numbers of available registers.
Viewers also liked (20)
Similar to Compiler Construction
4_5802928814682016556.pptx
The document summarizes key concepts about compiler design. It defines a compiler as a program that translates source code written in one language into an equivalent executable program in another language. Compilers are classified based on the number of passes, such as single-pass and multi-pass compilers. The document also discusses the analysis-synthesis model of compilation, which involves analyzing the source program to create an intermediate representation, then synthesizing target code from that representation. Major phases of a compiler include lexical analysis, parsing, semantic analysis, code generation, and optimization.
CD - CH1 - Introduction to compiler design.pptx
The document summarizes key concepts about compiler design. It defines a compiler as a program that translates source code written in one language into an equivalent executable program in another language. Compilers are classified based on the number of passes they use, such as single-pass and multi-pass compilers. The analysis-synthesis model is described as the two-part process of compilation involving analysis of the source program and synthesis of the translated code. The phases of a compiler include lexical analysis, parsing, semantic analysis, code generation and optimization.
Cd ch1 - introduction
The document discusses the phases of a compiler. It describes the phases as:
1) Lexical analysis which converts source code into tokens.
2) Syntax analysis which checks the syntax is correct and builds a parse tree.
3) Semantic analysis which checks for semantic errors using symbol tables.
4) Intermediate code generation which converts the parse tree into an intermediate representation.
5) Optimization of the intermediate code.
6) Code generation which converts the optimized intermediate code into assembly code and then machine code.
Chap01-Intro.ppt
The document provides an overview of compilers and their organization. It discusses how compilers translate human-oriented programming languages into machine languages. The main sections describe what compilers do, including the machine codes and target code formats they generate. It also distinguishes between compilers and interpreters. Other sections cover the syntax and semantics of languages, and the typical organization of a compiler into a front-end and back-end. The front-end performs analysis and the back-end performs code generation. Key compiler components like scanners, parsers, type checkers and code generators are also introduced.
System software
This document provides an overview of a system software course, including:
- The course will cover compilers, assemblers, linkers, loaders, macro processors, and file/process management under Windows.
- The objective is to gain a deep understanding of how computers work by examining the relationship between system software and machine architecture, and how system software aids in program development and execution.
- Key topics will include an introduction to system software, compilers, loaders, operating systems, and the programming process from coding to running a program.
COMPILER DESIGN PPTS.pptx
The document provides an overview of the compilation process and the different phases involved in compiler construction. It can be summarized as follows:
1. A compiler translates a program written in a source language into an equivalent program in a target language. It performs analysis, synthesis and error checking during this translation process.
2. The major phases of a compiler include lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization, code generation and linking. Tools like Lex and Yacc are commonly used to generate lexical and syntax analyzers.
3. Regular expressions are used to specify patterns for tokens during lexical analysis. A lexical analyzer reads the source program and generates a sequence of tokens by matching character sequences to patterns
Compiler Design Basics
This document provides an overview of compilers, including their structure and purpose. It discusses:
- What a compiler is and its main functions of analysis and synthesis.
- The history and need for compilers, from early assembly languages to modern high-level languages.
- The structure of a compiler, including lexical analysis, syntax analysis, semantic analysis, code optimization, and code generation.
- Different types of translators like interpreters, assemblers, and linkers.
- Tools that help in compiler construction like scanner generators, parser generators, and code generators.
Compiler Design Introduction
The document provides an overview of compiler design and the various phases involved in compiling a program from a high-level language to machine code. It describes the six main phases as lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization, and code generation. It explains the functions of each phase and how the output of one phase feeds into the next until an optimized machine code is produced for execution.
Cd unit i
The document discusses compilers and their design. It explains that compilers translate human-oriented programming languages into machine languages. It describes the typical structure of a compiler, which includes phases like scanning, parsing, semantic analysis, code generation and optimization. The document also discusses how programming language design and computer architecture influence compiler design considerations.
Overall 23 11_2007_hdp
This document provides an overview of system software topics including operating systems, compilers, assemblers, linkers, loaders, debuggers, editors and more. It discusses the design and implementation of these programs and how they support the operation of a computer. Key points covered include the roles of assemblers in translating assembly code to object code, linkers and loaders in combining object files and libraries and preparing programs for execution, and compilers in translating high-level languages to machine-readable object code. The document also examines machine architectures like SIC/XE and differences between CISC and RISC designs.
Introduction to Compilers
This document provides an overview of compilers and translation processes. It defines a compiler as a program that transforms source code into a target language like assembly or machine code. Compilers perform analysis on the source code and synthesis to translate it. Compilers can be one-pass or multi-pass. Other translators include preprocessors, interpreters, assemblers, linkers, loaders, cross-compilers, language converters, rewriters, and decompilers. The history and need for compilers and programming languages is also discussed.
1 introduction to compiler
The document provides an overview of the 4th stage of compiler introduction. It discusses the structure of a compiler in 7 steps: scanner, parser, semantic routines, code generator, optimizer, intermediate representation, and target code generation. The scanner tokenizes input. The parser builds a syntactic structure. Semantic routines check semantics and translate. The code generator outputs target code from intermediate representation, while the optimizer improves the code. The document also outlines the syntax and semantics of programming languages.
Ch1 (1).ppt
This document provides an introduction to compiler construction. It outlines the objectives of understanding how to build a compiler, use compiler construction tools, and be familiar with concepts like virtual machines, grammars, and optimization techniques. It defines compilation as translating a program to a semantically equivalent target language and interpretation as performing operations implied by a source program. The analysis-synthesis model and how it is used in compilers and other tools is described. The phases of a compiler from preprocessing to code generation are outlined.
Compiler Design Introduction
The document provides an introduction to compiler design, including:
- A compiler converts a program written in a high-level language into machine code. It can run on a different machine than the target.
- Language processing systems like compilers transform high-level code into a form usable by machines through a series of translations.
- A compiler analyzes source code in two main phases - analysis and synthesis. The analysis phase creates an intermediate representation, and the synthesis phase generates target code from that.
Compiler design
The document discusses compiler design and the phases of compilation. It aims to help readers build a compiler, understand compiler construction tools, and be familiar with grammars and techniques like analysis and optimization. The key phases of a compiler discussed are scanning, parsing, semantic analysis, code generation, and optimization. Preprocessors, compilers, assemblers and linkers are also explained in the document.
Cd econtent link1
The document discusses compiler design and the phases of compilation. It aims to help readers build a compiler, understand compiler construction tools, and be familiar with grammars and techniques like analysis and optimization. The key phases of a compiler discussed are scanning, parsing, semantic analysis, code generation, and optimization. Preprocessors, compilers, assemblers and linkers are also explained in the compilation process.
Compiler1
The document outlines the major phases of a compiler: lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization, and code generation. It describes the purpose and techniques used in each phase, including how lexical analyzers produce tokens, parsers use context-free grammars to build parse trees, and semantic analyzers perform type checking using attribute grammars. The intermediate code generation phase produces machine-independent codes that are later optimized and translated to machine-specific target codes.
Language processor
The language processor performs tasks required to process a specified programming language such as translating and interpreting. It includes an editor to write and manage code, a compiler to check syntax and translate to machine code, an interpreter to check, translate and execute instructions without producing object code, and other tools. The program development cycle involves defining the problem, analyzing it, designing an algorithmic solution, coding the program, compiling and linking the code, loading the program for execution, testing it, and revising if needed.
.NET Core, ASP.NET Core Course, Session 3
Session 3,
Introducing to Compiler
What is the LLVM?
LLILC
RyuJIT
AOT Compilation
Preprocessors and Conditional Compilation
An Overview on Dependency Injection
Introduction to compiler
The document provides an introduction to compilers. It discusses that compilers are language translators that take source code as input and convert it to another language as output. The compilation process involves multiple phases including lexical analysis, syntax analysis, semantic analysis, code generation, and code optimization. It describes the different phases of compilation in detail and explains concepts like intermediate code representation, symbol tables, and grammars.
Similar to Compiler Construction (20)
More from Army Public School and College -Faisal
SENSOR WHITEBOARDS
Here is a flow diagram showing the steps in how a microprocessor controls the switching on and off of a street lamp:
[FLOW DIAGRAM]
1. Microprocessor checks if it is night time (using light sensor input)
2. If night, microprocessor switches on street lamp
3. Microprocessor starts timer
4. Microprocessor checks timer - if not expired, lamp remains on
5. If timer expires, microprocessor checks if it is still night time
6. If still night, microprocessor resets timer and lamp remains on
7. If no longer night, microprocessor switches off street lamp
8. Microprocessor stops - no further switching of lamp
INPUT AND OUTPUT DEVICES
This document discusses various input and output devices used with computers. It focuses on scanners, describing them as devices that capture images from printed sources for computer display and editing. Scanners are either two-dimensional or three-dimensional. Two-dimensional scanners are most common and generally used to input hard-copy documents by converting them to an electronic form. Computers with optical character recognition software can further convert scanned text into an editable text file format. Common applications of 2D scanners include making digital copies of documents or pictures, and creating 2D images of other objects.
INPUT AND OUTPUT DEVICES
This document discusses different types of printers and their components and functions. It begins by distinguishing between impact printers, which use mechanical parts to print, and non-impact printers, which print without striking the paper. It then focuses on inkjet printers, describing their main components like the print head with nozzles that spray ink droplets, ink cartridges, and stepper motor. Laser printers are also summarized, explaining how they use a laser beam to attract toner powder to the page to print. The printing process for both inkjet and laser printers is outlined in multiple steps.
2d and 3d cutters
This document discusses various input and output devices used in computer systems. It describes 2D and 3D cutters, explaining that 3D cutters can recognize objects in three dimensions rather than just two. It discusses how 2D cutters work using lasers to make precise cuts. It also describes 3D laser cutters, subtractive manufacturing which involves cutting material away, and different types of actuators like electric motors, solenoids, and stepper motors which are used to produce movement.
SCANNERS /BARCODE
3D scanners scan solid objects and produce three-dimensional images by capturing x, y, and z coordinates of multiple points on the object's surface. These scans can be used in computer-aided design (CAD) programs for engineering and design purposes. Two-dimensional scanners are used at airports to scan passports and capture traveler photos for identification, extracting biometric data like eye and facial feature distances. Computed tomography (CT) scanners build 3D images of solid objects through multiple thin "slices", using x-rays, radio frequencies, or gamma imaging to capture each slice digitally. Barcode readers scan barcodes, which represent numbers using varying dark and light line thicknesses, and decode the information
3D PRINTERS
3D printers use additive manufacturing to build solid objects layer by layer using materials like powdered resin, metal, or paper. CAD software is used to design objects which are then printed by 3D printers. There are different types of 3D printing technologies like direct 3D printing which uses inkjet printing techniques and binder 3D printing which binds powdered materials. 3D printing enables the creation of complex geometries and is used across industries like aerospace, automotive, robotics, and education.
Operaing system
The document discusses operating systems and their functions. It describes how operating systems control computer systems by managing programs, files and directories, system devices, and allowing multitasking. It also discusses the different types of user interfaces that operating systems use including command line interfaces, menu driven interfaces, and graphical user interfaces.
Module 2 handouts part 2
This document discusses cascaded first-order filters and second-order transfer functions for filters. It introduces cascaded filters and their characteristics. It then discusses second-order transfer functions, examining features like low-pass, high-pass, and band-pass filters. Finally, it introduces second-order Sallen-Key filter circuits and shows examples of designing low-pass, high-pass, and band-pass filters using these circuits.
Module 2 handouts part 1
This document discusses operational amplifiers and basic op amp circuits. It begins by introducing op amps and their ideal behavior, including that they have no voltage difference between inputs and infinite gain. Comparator and buffer circuits are presented as examples. The document then discusses inverting and non-inverting amplifiers, difference amplifiers, and summing amplifiers. Integrating and differentiating circuits using op amps are also introduced. Finally, the document discusses active filters and derivations for low-pass and high-pass filter circuits.
Module 1 ELECTRONICS
This document provides an overview and review of key concepts in electronics circuits, including:
1) Circuit elements such as resistors, capacitors, and inductors are introduced along with their i-v characteristics and connections in series and parallel.
2) Kirchhoff's laws including Kirchhoff's voltage law (KVL) and Kirchhoff's current law (KCL) are reviewed and applied to example circuits.
3) Impedance, transfer functions, and frequency response plots (Bode plots) are discussed as ways to characterize and analyze AC circuits.
Module 1
This document provides an overview and review of key concepts in electronics circuits, including:
1) Circuit elements such as resistors, capacitors, and inductors are introduced along with their i-v characteristics and connections in series and parallel.
2) Kirchhoff's laws including Kirchhoff's voltage law (KVL) and Kirchhoff's current law (KCL) are reviewed and applied to example circuits.
3) Impedance, transfer functions, and frequency response plots (Bode plots) are discussed as ways to characterize and analyze AC circuits.
Cookies may be set by the website you are visiting
Cookies are small data files that are used to identify users and their preferences. They can be set by the website being visited ("first party cookies") or other sites ("third party cookies"). First party cookies store information like login credentials or shopping cart items while third party cookies can track browsing across different sites for advertising purposes. Cookies are stored either temporarily for a browsing session or persistently for longer periods. Users can manage cookie settings and blocking through their browser preferences.
Css
CSS (Cascading Style Sheets) allows separation of document content from document presentation by defining styles like fonts, colors, spacing in external .css files or internal <style> tags. CSS selectors target HTML elements by name, id, class, or attribute to style them. Styles can be defined externally, internally, or inline. When multiple conflicting styles apply, the cascade order gives precedence to inline styles, then internal and external styles, and lastly browser defaults.
python 1
Python was created by Guido van Rossum in 1989 at CWI in the Netherlands as a successor to the ABC language. It was influenced by languages like Modula-3 and C. Major releases include Python 2.0 in 2000 which included a garbage collector and support for Unicode, and Python 3.0 in 2008 which was a major backwards incompatible release.
Boolean and comparison_instructions
1. The document describes various bitwise operations including AND, OR, XOR, NOT, TEST, and CMP and how they affect flags and values.
2. It provides examples of using each operation to clear/set bits, convert between binary and ASCII, check register parity, and compare values.
3. In-class problems are presented and answered involving manipulating register bits through single instructions.
hadoop_module
Apache Hadoop is an open source software framework created in 2005 for distributed storage and processing of large datasets across clusters of computers. It allows for reliable and scalable computation across large amounts of data and nodes. The core modules include Hadoop Common, HDFS for distributed file storage, YARN for job scheduling and cluster resource management, and MapReduce for distributed processing of large datasets. The Hadoop ecosystem has grown significantly and includes additional popular components such as Pig, Hive, HBase, Zookeeper, Oozie, Flume, Spark and Impala.
Polymorphism (2)
This document discusses polymorphism in C# through method overloading and overriding. It shows how to create a base DrawingObject class that can be inherited by Line, Circle, and Square classes, where each subclass overrides the Draw method to output its type. The Main method creates instances of each subclass and calls their Draw methods to demonstrate polymorphism. The document also compares abstract classes and interfaces, noting that abstract classes can contain implemented methods while interfaces only contain signatures, and interfaces allow multiple inheritance while abstract classes do not.
Object Oriented Programming
This document discusses key concepts of object-oriented design and programming. It defines object-oriented design as planning a system of interacting objects to solve software problems. It describes object-oriented programming as representing concepts as objects that have data fields and methods. The document outlines some key pillars of object-oriented programming including inheritance, which allows code reuse; encapsulation, which protects data; and access modifiers like public, private, and protected, which control object accessibility.
Presentation 2
Constants refer to fixed values that cannot be altered during program execution. They include integer, floating point, character, and string literals. Constants are defined using the #define preprocessor or const keyword and are treated like regular variables except their values cannot change. Common operators in C include arithmetic, relational, logical, and bitwise operators that perform math, comparison, logic and bit manipulation functions.
Lecture 1 progrmming with C
This document provides an introduction to the C programming language. It discusses that C was created to develop the UNIX operating system and is widely used for systems programming. The document then covers C program structure, tokens, basic syntax, identifiers, keywords, whitespace, data types including integer and floating point types, variables, and variable scope and storage duration. It provides examples of declaring, defining, initializing and using different variables in a sample C program.
More from Army Public School and College -Faisal (20)
Cookies may be set by the website you are visiting
Cookies may be set by the website you are visiting
Recently uploaded
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
RPMS Template 2023-2024 by: Irene S. Rueco
Your Skill Boost Masterclass: Strategies for Effective Upskilling
Your Skill Boost Masterclass: Strategies for Effective UpskillingExcellence Foundation for South Sudan
Strategies for Effective Upskilling is a presentation by Chinwendu Peace in a Your Skill Boost Masterclass organisation by the Excellence Foundation for South Sudan on 08th and 09th June 2024 from 1 PM to 3 PM on each day.Digital Artifact 1 - 10VCD Environments Unit
Digital Artifact 1 - 10VCD Environments Unit - NGV Pavilion Concept Design
Hindi varnamala | hindi alphabet PPT.pdf
हिंदी वर्णमाला पीपीटी, hindi alphabet PPT presentation, hindi varnamala PPT, Hindi Varnamala pdf, हिंदी स्वर, हिंदी व्यंजन, sikhiye hindi varnmala, dr. mulla adam ali, hindi language and literature, hindi alphabet with drawing, hindi alphabet pdf, hindi varnamala for childrens, hindi language, hindi varnamala practice for kids, https://www.drmullaadamali.com
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...Dr. Vinod Kumar Kanvaria
Exploiting Artificial Intelligence for Empowering Researchers and Faculty,
International FDP on Fundamentals of Research in Social Sciences
at Integral University, Lucknow, 06.06.2024
By Dr. Vinod Kumar KanvariaMain Java[All of the Base Concepts}.docx
This is part 1 of my Java Learning Journey. This Contains Custom methods, classes, constructors, packages, multithreading , try- catch block, finally block and more.
clinical examination of hip joint (1).pdf
described clinical examination all orthopeadic conditions .
How to Fix the Import Error in the Odoo 17
An import error occurs when a program fails to import a module or library, disrupting its execution. In languages like Python, this issue arises when the specified module cannot be found or accessed, hindering the program's functionality. Resolving import errors is crucial for maintaining smooth software operation and uninterrupted development processes.
How to Build a Module in Odoo 17 Using the Scaffold Method
Odoo provides an option for creating a module by using a single line command. By using this command the user can make a whole structure of a module. It is very easy for a beginner to make a module. There is no need to make each file manually. This slide will show how to create a module using the scaffold method.
Pengantar Penggunaan Flutter - Dart programming language1.pptx
Pengantar Penggunaan Flutter - Dart programming language1.pptx
How to Add Chatter in the odoo 17 ERP Module
In Odoo, the chatter is like a chat tool that helps you work together on records. You can leave notes and track things, making it easier to talk with your team and partners. Inside chatter, all communication history, activity, and changes will be displayed.
How to Make a Field Mandatory in Odoo 17
In Odoo, making a field required can be done through both Python code and XML views. When you set the required attribute to True in Python code, it makes the field required across all views where it's used. Conversely, when you set the required attribute in XML views, it makes the field required only in the context of that particular view.
Community pharmacy- Social and preventive pharmacy UNIT 5
Covered community pharmacy topic of the subject Social and preventive pharmacy for Diploma and Bachelor of pharmacy
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...National Information Standards Organization (NISO)
This presentation was provided by Steph Pollock of The American Psychological Association’s Journals Program, and Damita Snow, of The American Society of Civil Engineers (ASCE), for the initial session of NISO's 2024 Training Series "DEIA in the Scholarly Landscape." Session One: 'Setting Expectations: a DEIA Primer,' was held June 6, 2024.Recently uploaded (20)
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
Your Skill Boost Masterclass: Strategies for Effective Upskilling
Your Skill Boost Masterclass: Strategies for Effective Upskilling
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Pride Month Slides 2024 David Douglas School District
Pride Month Slides 2024 David Douglas School District
Film vocab for eal 3 students: Australia the movie
Film vocab for eal 3 students: Australia the movie
How to Build a Module in Odoo 17 Using the Scaffold Method
How to Build a Module in Odoo 17 Using the Scaffold Method
Pengantar Penggunaan Flutter - Dart programming language1.pptx
Pengantar Penggunaan Flutter - Dart programming language1.pptx
Community pharmacy- Social and preventive pharmacy UNIT 5
Community pharmacy- Social and preventive pharmacy UNIT 5
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Compiler Construction
- 1. Introduction to Compiler Construction • 1
- 2. Objectives • Be able to build a compiler for a (simplified) (programming) language • Know how to use compiler construction tools, such as generators of scanners and parsers • Be familiar with assembly code and virtual machines, such as the JVM, and bytecode • Be able to define LL(1), LR(1), and LALR(1) grammars • Be familiar with compiler analysis and optimization techniques • … learn how to work on a larger software project! 2
- 3. Compilers and Interpreters • “Compilation” – Translation of a program written in a source language into a semantically equivalent program written in a target language – Oversimplified view: Input Source Target Compiler Program Program Error messages Output3
- 4. Compilers and Interpreters (cont’d) • “Interpretation” – Performing the operations implied by the source program – Oversimplified view: Source Program Interpreter Output Input Error messages 4
- 5. The Analysis-Synthesis Model of Compilation • There are two parts to compilation: – Analysis determines the operations implied by the source program which are recorded in a tree structure – Synthesis takes the tree structure and translates the operations therein into the target program 5
- 6. Other Tools that Use the Analysis-Synthesis Model • Editors (syntax highlighting) • Pretty printers (e.g. Doxygen) • Static checkers (e.g. Lint and Splint) • Interpreters • Text formatters (e.g. TeX and LaTeX) • Silicon compilers (e.g. VHDL) • Query interpreters/compilers (Databases) 6
- 7. Preprocessors, Compilers, Assemblers, and Linkers Skeletal Source Program Preprocessor Source Program Try for example: Compiler gcc -v myprog.c Target Assembly Program Assembler Relocatable Object Code Linker Libraries and Relocatable Object Files COP5621 Fall 2011 7 Absolute Machine Code
- 8. The Grouping of Phases • Compiler front and back ends: – Front end: analysis (machine independent) – Back end: synthesis (machine dependent) • Compiler passes: – A collection of phases is done only once (single pass) or multiple times (multi pass) • Single pass: usually requires everything to be defined before being used in source program • Multi pass: compiler may have to keep entire program representation in memory 8
- 9. Compiler-Construction Tools • Software development tools are available to implement one or more compiler phases – Scanner generators – Parser generators – Syntax-directed translation engines – Automatic code generators – Data-flow engines 9
- 10. Outline • Introduction • A simple One-Pass Compiler for the JVM • Lexical Analysis and Lex/Flex • Syntax Analysis and Yacc/Bison • Syntax-Directed Translation • Static Semantics and Type Checking • Run-Time Environments • Intermediate Code Generation • Target Code Generation • Code Optimization COP5621 Fall 2011 10