Programming Language Processors in Java Compilers and Interpreters

by Watt, David; Watt, David; Brown, Deryck

• ISBN13: 9780130257864
• ISBN10: 0130257869
• Edition: 1st
• Format: Hardcover
• Copyright: 2000-01-07
• Publisher: Pearson

Summary

David A Watt and Deryck F Brown Programming Language Processors in Java Compilers and Interpreters This book provides a gently paced introduction to techniques for implementing programming languages by means of compilers and interpreters, using the object-oriented programming language Java. The book aims to exemplify good software engineering principles at the same time as explaining the specific techniques needed to build compilers and interpreters. Features * The book shows clearly how a simple compiler can be decomposed into a syntactic analyzer, a contextual analyzer, and a code generator, communicating via an abstract syntax tree. * The book is accompanied by a complete working compiler and interpreter, provided via the Internet, and free of charge for educational use. * The book contains numerous exercises, together with sample answers to selected exercises. It also contains a number of suggested projects, involving extensions to the accompanying compiler. * All examples in the book are expressed in Java, and the compiler and interpreter are structured using object-oriented design patterns. David Watt teaches algorithms and data structures, programming languages, and software design. Deryck Brown teaches compilers, object-oriented programming, operating systems, and software engineering.

Author Biography

David Watt teaches algorithms and data structures, programming languages, and software design. Deryck Brown teaches compilers, object-oriented programming, operating systems, and software engineering.

Table of Contents

1. Introduction.
2. Language Processors.
3. Compilation.
4. Syntactic Analysis.
5. Contextual Analysis.
6. Run-time Organization.
7. Code Generation.
8. Interpretation.
9. Conclusion.

Excerpts

Preface The subject of this book is the implementation of programming languages. Programming language processors are programs that process other programs. The primary examples of language processors are compilers and interpreters. Programming languages are of central importance in computer science. They are the most fundamental tools of software engineers, who are completely dependent on the quality of the language processors they use. There is an interplay between the design of programming languages and computer instruction sets: compilers must bridge the gap between high-level languages and machine code. And programming language design itself raises strong feelings among computer scientists, as witnessed by the proliferation of language paradigms. Imperative and object-oriented languages are currently dominant in terms of actual usage, and it is on the implementation of such languages that this book focuses. Programming language implementation is a particularly fascinating topic, in our view, because of its close interplay between theory and practice. Ever since the dawn of computer science, the engineering of language processors has driven, and has been vastly improved by, the development of relevant theories. Nowadays, the principles of programming language implementation are very well understood. An experienced compiler writer can implement a simple programming language about as fast as he or she can type. The basic techniques are simple yet effective, and can be lucidly presented to students. Once the techniques have been mastered, building a compiler from scratch is essentially an exercise in software engineering. A textbook example of a compiler is often the first complete program of its size seen by computer science students. Such an example should therefore be an exemplar of good software engineering principles. Regrettably, many compiler textbooks offend these principles. This textbook, based on a total of about twenty-five years' experience of teaching programming language implementation, aims to exemplify good software engineering principles at the same time as explaining the specific techniques needed to build compilers and interpreters. The book shows how to design and build simple compilers and interpreters using the object-oriented programming language Java. The reasons for this choice are twofold. First, object-oriented methods have emerged as a dominant software engineering technology, yielding substantial improvements in software modularity, maintainability, and reusability. Secondly, Java itself has experienced a prodigious growth in popularity since its appearance as recently as 1994, and that for good technical reasons: Java is simple, consistent, portable, and equipped with an extremely rich class library. Soon we can expect all computer science students to have at least some familiarity with Java. A Programming Languages Series This is the fourth of a series of books on programming languages: Programming Language Concepts and Paradigms Programming Language Syntax and Semantics Programming Language Processors Programming Language Processors in Java Programming Language Concepts and Paradigmsstudies the concepts underlying programming languages, and the major language paradigms that use these concepts in different ways; in other words, it is about language design.Programming Language Syntax and Semanticsshows how we can formally specify the syntax (form) and semantics (meaning) of programming languages.Programming Language Processorsstudies the implementation of programming languages, examining language processors such as compilers and interpreters, and using Pascal as the implementation language.Programming Language Processors in Javalikewise studies the implementation of programming languages, but now using Java