What is new in the 3rd edition

[iGherghe]

Hello John,
I bought 2nd edition of Introduction to Compiler Design: An Object-Oriented Approach Using Java in August just before the 3rd edition was published. Can you please write a few words about the difference between the 2nd and 3rd editions ? I'm tempted to buy the 3rd edition if there are substantial differences compared with the 2nd.
Regards,
Gherghe

[SoftMoore]

Thank you for purchasing the second edition. The summary of the differences below is taken directly from the Preface of the third edition.
John I. Moore, Jr.

Changes in the Third Edition
The third edition retains the objectives, emphasis, and general structure of the first two editions, but there are a number of significant changes that can be grouped into four broad categories.

1. CPRL Language Changes.

• The CPRL language is now a little more like C-based languages and less like Pascal-based languages. For example, reserved words “begin” and “end” have largely been replaced by braces “{” and “}”, and program execution now starts with a parameterless procedure named “main()”. Similarly, subroutine declarations and calls now require parentheses even if there are no parameters.
• Subprograms, including main(), can now be called before they have been declared, but initial declarations (i.e., variables, constants, and types) must still appear before being used.
• String types are now fully supported (the previous edition supported only string literals), and record types (a.k.a., structures) were added.
• Similar to C, array parameters in CPRL are now passed by reference whether or not they are declared as such, even for functions.

2. CVM Changes.

• There are new instructions to support string input and assignment plus several new optimized versions of existing instructions.• Instructions that read from standard input (e.g., GETINT) now write directly to the variable address found on the top of the stack. Previously these instructions pushed the input value onto the stack, and a store instruction was required to update the variable.
• The CMP (compare) instruction was removed. So, for example, branch instructions like BL (branch less than) and BGE (branch greater or equal) now pop two integers off the stack, compare them, and branch accordingly. This approach is similar to the way branch instructions work in the JVM and other stack-based architectures.

3. Compiler Implementation Changes.

• The use of null values has been greatly reduced, especially with respect to abstract syntax trees. For example, most parser methods now return either EmptyExpression, EmptyInitialDecl, EmptySubprogramDecl, or EmptyStatement rather than null when a syntax error in encountered.
• The parser can now use more than one lookahead token to make parsing decisions.

4. Other Changes.

• The notation for context-free grammars was changed to more closely resemble the one defined in ISO/IEC 14977, an international standard for EBNF notation. For example, “zero or more” is now represented by braces “{“ and “}”.
• A more complete discussion of scopes has been added together with a cleaner implementation of scopes in the compiler.

In addition, there are two new chapters, several new exercises, many new paragraphs, various rewordings to make the presentation easier to understand, and a few corrections. Overall I am extremely pleased with the final result.