Usted está aquí: Inicio Ingeniería Informática Language Processors Syllabus

Syllabus

Acciones de Documento
  • Vista de contenidos
  • Marcadores (bookmarks)
  • Exportación de LTI
Autores: David Griol Barres, Antonio Berlanga de Jesús, Jesús García Herrero, Juan Manuel Alonso Weber
Syllabus de la asignatura: Temas que forman parte de la asignatura.

 

Unit 1. Introduction to Language Processors

   1.1. Aims of the course
   1.2. Why to Take this Course?
   1.3. Related Topics
   1.4. What are Compilers?
     1.4.1 Motivation and Goals
   1.5. Compilers vs. Translators
   1.6. Compilers vs. Interpreters
   1.7. Related Programs
   1.8. Compiler Architecture
   1.9. Evolution
   1.10. Compiler Classification
   1.11. The Phases of a Compiler
     1.11.1. Introduction: Front-end and Back-end
     1.11.2. Lexical Analysis
     1.11.3. Syntax Analysis
     1.11.4. Semantic Analysis
     1.11.5. Symbol Table
     1.11.6. Intermediate Code Generation
     1.11.7. Code Optimization
     1.11.8. Final Code Generation
     1.11.9. Error Handling
   1.12. Programming Language Design
   1.13. T-Notation and Bootstrapping
   1.14. Programming Paradigms
   1.15. Recommended Bibliography

 

UNIT 2. Lexical Analysis

   2.1. Introduction: Definitions
   2.2. The Role of a Lexical Analyzer
   2.3. Scanner Implementation
     2.3.1. Loop and Switch Programs
     2.3.2. Recognizing Patterns by means of Regular Expressions
   2.4. Regular Expressions Review
     2.4.1. Regular Expressions for Tokens
   2.5. Finite Automata Review
   2.6. Implementing the Scanner
     2.6.1. From Regular Expressions to NFA
     2.6.2. From NFA to DFA
     2.6.3. From DFA to the Program

 

UNIT 3. Formal Grammars Review

   3.1. Introduction
   3.2. Motivation
   3.3. Definitions
   3.4. Formal Grammars
     3.4.1. BNF Notation
     3.4.2. Examples
     3.4.3. Chomsky Hierarchy
     3.4.4. Definitions
     3.4.5. Derivations and Parse Trees
   3.5. Issues in Parsing Context-Free Grammars
     3.5.1. Ambiguity
     3.5.2. Left-Recursion
     3.5.3. Left-Factoring
   3.6. Push-Down Automata Review

 

UNIT 4. Syntax Analysis

   4.1. Introduction
   4.2. Position of the Parser
   4.3. The role of the Parser
   4.4. Advantages of Using Grammars
   4.5. Types of Parsers
     4.5.1. Top-Down Parsing
     4.5.2. Bottom-Up Parsing
   4.6. Syntax Analyzers. Problems

 

UNIT 5. Top-Down Parsing Techniques

   5.1. Introduction
   5.2. Possible Methodologies
     5.2.1. Backtracking
     5.2.2. Recursive Descent
     5.2.3. Top-Down Predictive Parsing
       5.2.3.1. Table-Driven LL(1) Parsing
         5.2.3.1.1. First and Follow Sets
         5.2.3.1.2. LL(1) Grammars
         5.2.3.1.3. Construction of the Predictive Parsing Table

 

UNIT 6. Bottom-Up Parsing Techniques

   6.1. Introduction
   6.2. Bottom-Up Parsers
   6.3. LR(K) Methods
     6.3.1. Shift-Reduce Parsing
     6.3.2. LR Parsing Engine
     6.3.3. Model of a LR parser
     6.3.4. The LR Parsing Table
     6.3.5. Constructing the Canonical LR(0) Collection
     6.3.6. Limitations of LR(0) Parsing
     6.3.7. LR(0) and LR(1)
     6.3.8. SLR(1)
     6.3.9. LALR(1)

 

UNIT 7. Semantic Analysis

   7.1. Introduction
   7.2. Semantic Analysis
   7.3. Type Checking
     7.3.1. Designing a Type Checker
   7.4. Flow of Control Checks
   7.5. Uniqueness Check
   7.6. Name-Related Checks
   7.7. Cycles in Representations of Types
   7.8. Scope Checking
   7.9. Example of a Simple Language

 

UNIT 8. Error Handling

   8.1. Introduction
   8.2. Recovering from Errors
   8.3. Error Recovery Strategies
     8.3.1. Panic Mode
     8.3.2. Phase Level
     8.3.3. Error Productions
     8.3.4. Global Correction Techniques
     8.3.5. Error Detection and Recovery in LL Parsers
     8.3.6. Error Detection and Recovery in LR Parsers

 

UNIT 9. Intermediate Code Generation

   9.1. Introduction
   9.2. Advantages and disadvantages
   9.3. Compiler architecture review
     9.3.1. The Role of Intermediate Code
     9.3.2. Analysis Phase
     9.3.3. Synthesis Phase
   9.4. Intermediate Languages Types
     9.4.1. Graphical IRs
     9.4.2. Linearized IC
   9.5. Graphical IRs
     9.5.1. Abstract Syntax Trees
     9.5.2. Directed Acyclic Graphs
     9.5.3. Control Flow Graphs
   9.6. Linearized IC
     9.6.1. Stack based
     9.6.2. Three-Address Code
       9.6.2.1. Triples and Quadruples
   9.7. Declarations

 

UNIT 10. Code Optimization

   10.1. Introduction
   10.2. Principles of Design
   10.3 Basic Blocks
   10.4. Local Optimizations
     10.4.1. Constant Folding
     10.4.2. Constant Propagation
     10.4.3. Algebraic Simplification and Reassociation
     10.4.4. Strength Reduction
     10.4.5. Other Local Optimizations
   10.5. Global Optimizations
   10.6. Live Variable Analysis

 

UNIT 11.  Final Code Generation

   11.1. Introduction
   11.2. Main Issues
   11.3. Input to the Code Generator
   11.4. Target Programs/Target Machine
   11.6. The Target Machine
   11.7. Instruction Cost
   11.8. Instruction Selection
   11.9. Basic Blocks
     11.9.1. Basic Blocks and Flow Graphs
     11.9.2. Transformations on Basic Blocks
   11.10. Register Allocation

 

Reutilizar Curso
Descargar este curso