Avg. Customer Review:
Number of Reviews: 2
table of contents
Reviewer:
eoi (see more about me) from LA CA
Crafting a Compiler with C offers an innovative approach to
compiler design for students or professional programmers who use C. Through
numerous examples and exercises, you'll learn how to design a working compiler
from start to finish. The book also provides balanced coverage of both theoretical
and implementation issues, with detailed discussions of standard compiler topics
such as top-down and bottom- up parsing, semantic analysis, intermediate representations,
and code generation. All the procedures in this book are presented in a readable,
C-based notation. Features:
· Based on the best-selling Crafting a Compiler.
· Balances an excellent, readable introduction to compiler
theory with a wealth of realistic compler design examples and exercises.
· Emphasizes the use of compiler tools that generate parsers
and scanners.
· Discusses LR parsing and reduction techniques thoroughly.
· Introduces FLex and ScanGen early.
· Includes optional advanced topics at the end of each chapter.
Chapter 1 Introduction
An overview of the compilation process begins the text. The
concept of constructing a compiler from a collection of components is emphasized.
The idea of using tools to generate some of these components is introduced.
Chapter 2 A Simple Compiler
A very simple language, Micro, is presented, and each of the
components of a compiler is discussed with respect to compiling Micro. Parts
of the text of a compiler for Micro (written in Ada) are included in this chapter.
The compilation of features of more comprehensive Ada subsets is the motivation
for the techniques presented in the following chapters.
Chapter 3 Scanning Theory and Practice
The basic concepts and techniques for building the lexical
analysis component of a compiler are presented. This discussion includes both
the development of hand-coded scanners and the use of scanner generation tools
for implementation of table-driven scanners.
Chapter 4 Grammars and Parsing
Fundamentals of formal language concepts and grammars are
presented in this chapter, including context-free grammars, BNF notation, derivations,
and parse trees. Since First and Follow sets are used in the definitions of
both top- down and bottom-up parsing techniques, they are defined in this chapter.
A discussion of language and grammar relationships is also included.
Chapter 5 LL(1) Grammars and Parsing
Top-down parsing is presented as the initial approach to syntax
analysis. Both recursive descent and LL(1) are discussed, with an emphasis on
the latter. Use of parser generators is a major focus of this chapter.
Chapter 6 LR Parsing
Bottom-up parsing is presented as an alternative approach
to syntax analysis. LR, SLR and LALR parsing concepts are introduced and compared
with LL techniques. Again, use of parser generators is a major focus of the
chapter.
Chapter 7 Semantic Processing
The fundamentals of semantic processing in conjunction with
top-down and bottom-up parsers are presented in this chapter. Topics include
a comparison of alternative compiler organizations, addition of action symbols
to a gram mar (for top-down parsing), rewriting grammars for "semantic hooks"
(for bottom-up parsing), definition of semantic records and use of a semantic
stack, checking semantic correctness, and producing intermediate code.
Chapter 8 Symbol Tables
This chapter stresses the use of a symbol table as an abstract
component, util ized by the rest of the compiler through a precisely defined
interface. Possible implementations are presented, followed by discussions of
symbol tables for handling nested scopes and language features used to define
names accessible from surrounding scopes (such as records and Ada packages).
Chapter 9 Run-time Storage Organization
Basic techniques for run-time storage management is presented,
including dis cussions of static allocation, stack-based allocation and generalized
dynamic (heap) allocation.
Chapter 10 Processing Declarations
Basic techniques for processing type, variable, and constant
declarations are discussed. The organization of this material is based on semantic
routines for handling specific language features.
Chapter 11 Processing Expressions and Data Structure References
Semantic routines for handling variable references and arithmetic
and Boolean expressions are outlined. Address computation methods for array
elements and record fields are included in the discussion of variables references.
In this
and the next two chapters, emphasis is placed on techniques
for checking semantic correctness and generating intermediate code for use by
a target code generator.
Chapter 12 Translating Control Structures
Compilation techniques for features such as if statements,
case statements, and various looping constructs are the focus of this chapter.
A point of emphasis is effective use of a semantic stack or syntax tree to simplify
the job of handling these constructs, which can be nested and which can extend
over arbitrary amounts of program text. Students should gain an understanding
of the advantage of this general technique over ad hoc approaches.
Chapter 13 Translating Procedures and Functions
Techniques for processing both declarations and calls of subprograms
are presented. Since much of the complexity of this topic involves parameters,
considerable material is provided that deals with building parameter descriptions,
checking for correctness of actual parameters in subprogram calls, and code-generation
techniques required by various parameter modes. The concept of a run-time activation
stack is discussed here, and the support routines necessary to implement one
are outlined.
Chapter 14 Attribute Grammars and Multipass Translation
Multipass translation is modeled by traversal over an intermediate
form. The attribute model of information flow receives particular emphasis.
Chapter 15 Code Generation and Local Code Optimization
The code generator is presented as a separate component that
translates from the intermediate code generated by the semantic routines to
the final target code of the compiler. Such topics as instruction selection,
register management, and use of addressing modes are presented. Use of a code
generator- generator is discussed. Discussion of basic block optimizations is
included in this chapter.
Chapter 16 Global Optimization
The focus of this chapter is on practical techniques that
yield useful improvements from a moderate amount of effort. Thus the main sections
of the chapter include global data flow analysis, optimizing subprogram calls,
and optimizing loops.
Chapter 17 Parsing in the Real World
This chapter includes material on two major topics necessary
for implementing practical compilers: syntax-error handling and table compaction.
The error-handling section presents error-recovery and error-repair techniques
applicable to recursive descent, LL and LR parsers. The table compaction techniques
included are applicable to both LL and LR parser tables, as well as to scanner
tables and any other situation requiring efficient storage with fast access
to elements of sparse tables.
Good treatment of difficult materialDecember 23, 1999
Reviewer: Mr James S Battle from London
This book has a nice balance of theory and practical algorithms. There is enough
detail to allow a (patient) reader to implement his own compiler tools, though
like most other books on the subject, this book leaves you with the feeling
that the area might have died about twenty years ago (no insult intended!);
an update needed, to include OO languages, some treatment of the complexities
associated with parsing modern languages, C++ etc. All things considered, still
a great book, well worth the money
based on 5 reviews. (
Based on 15 reviews.
5 Stars with caveats......., October 10, 2000 
Soso, January 15, 2002 
Please don't buy it!, February 23, 2000
One
of the best books, April 6, 2005
based on 10 reviews. (Write
a review) 
Great for hard-core compiler gurus, November 29, 1999