Crafting a compiler with C / Charles N. Fischer and Richard J. LeBlanc, Jr. ; C code by Arnold D. Robbins.
By: Fischer, Charles N
.
Contributor(s): LeBlanc, Richard J. (Richard Joseph)
.
Material type:
BookPublisher: Redwood City, Calif. : Benjamin/Cummings Pub. Co, 1991Description: xix, 812 p. : ill. ; 24 cm.ISBN: 0805321667; 0805321691.Subject(s): C (Computer program language)| Item type | Current library | Call number | Copy number | Status | Barcode | |
|---|---|---|---|---|---|---|
| General lending | MTU Bishopstown Library Store | 005.453 (Browse shelf(Opens below)) | 1 | Available | 00030685 |
Browsing MTU Bishopstown Library shelves, Shelving location: Store Close shelf browser (Hides shelf browser)
Enhanced descriptions from Syndetics:
This extremely practical, hands-on approach to building compilers using the C programming language includes numerous examples of working code from a real compiler and covers such advanced topics as code generation, optimization, and real-world parsing. It is an ideal reference and tutorial. 0805321667B04062001
"32166"--Spine.
Includes bibliographical references (p. 799-805) and index.
Table of contents provided by Syndetics
- (Each chapter contains "Exercises".)
- Introduction
- Overview and History
- What Do Compilers Do? The Structure of a Compiler
- The Syntax and Semantics of Programming Languages
- Compiler Design and Programming Language Design
- Compiler Classifications
- Influences On Computer Design
- Exercises
- A Simple Compiler
- The Structure of a Micro Compiler
- A Micro Scanner
- The Syntax of Micro
- Recursive Descent Parsing
- Translating Micro
- Exercises
- Scanning--Theory and Practice
- Overview
- Regular Expressions
- Finite Automata and Scanners
- Using a Scanner Generator
- Practical Considerations
- Translating Regular Expressions Into Finite Automata
- Exercises
- Grammars and Parsing
- Context-Free Grammars: Concepts and Notation
- Errors in Context-Free Grammars
- Transforming Extended Bnf Grammars
- Parsers and Recognizers
- Grammar Analysis Algorithms
- Exercises
- Ll(1) Grammars and Parsers
- The Ll(1) Predict Function
- The Ll(1) Parse Table
- Building Recursive Descent Parsers From Ll(1) Tables
- An Ll(1) Parser Driver
- Ll(1) Action Symbols
- Making Grammars Ll(1)
- The If-Then-Else Problem in Ll(1) Parsing
- The Llgen Parser Generator
- Properties of Ll(1) Parsers
- Ll(K) Parsing
- Exercises
- Lr Parsing
- Shift-Reduce Parsers
- Lr Parsers
- Lr(1) Parsing
- Slr(1) Parsing
- Lalr(1). Calling Semantic Routines in Shift-Reduce Parsers
- Using a Parser Generator
- Optimizing Parse Tables
- Practical Lr(1) Parsers
- Properties of Lr Parsers
- Ll(1) Or Lalr(1), That Is The Question
- Other Shift-Reduce Techniques
- Exercises
- Semantic Processing
- Syntax-Directed Translation
- Semantic Processing Techniques
- Intermediate Representations and Code Generation
- Exercises
- Symbol Tables
- A Symbol Table Interface
- Basic Implementation Techniques
- Block-Structured Symbol Tables
- Extensions to Block-Structured Symbol Tables
- Implicit Declarations
- Overloading
- Forward References
- Summary
- Exercises
- Run-Time Storage Organization
- Static Allocation
- Stack Allocation
- Heap Allocation
- Program Layout in Memory
- Static and Dynamic Chains
- Formal Procedures
- Exercises
- Processing Declarations
- Declaration Processing Fundamentals
- Action Routines for Simple Declarations
- Action Routines for Advanced Features
- Exercises
- Processing Expressions and Data Structure References
- Introduction
- Action Routines for Simple Names, Expressions, and Data Structures
- Action Routines for Advanced Features
- Exercises
- Translating Control Structures
- If Statements
- Loops
- Compiling Exits
- The Case Statement
- Compiling Goto Statements
- Exception Handling
- Short-Circuit Boolean Expressions
- Exercises
- Translating Procedures and Functions
- Simple Subprograms
- Passing Parameters to Subprograms
- Processing Subprogram Calls and Parameter Lists
- Subprogram Invocation
- Label Parameters
- Name Parameters
- Exercises
- Attribute Grammars and Multipass Translation
- Attribute Grammars
- Tree-Structured Intermediate Representations
- Exercises
- Code Generation and Local Code Optimization