Building Parsers with Java? [With CD]

by Steven John Metsker

Parser building is a powerful programming technique that opens a world of opportunity for designing how users interact with applications. By creating mini-languages, you can precisely address the... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0201719622
• ISBN13: 9780201719628
• Release Date: March 2001
• Publisher: Addison-Wesley Professional
• Length: 400 Pages
• Weight: 1.42 lbs.
• Dimensions: 0.8" x 7.4" x 9.2"

Customer Reviews

Good practical book on building parsers

This book does not assume that you understand compilers or programming language theory. However, the beauty and eloquence of what the book is trying to teach you will be far clearer if you do understand these disciplines. This book teaches you how to build nondeterministic recursive-descent parsers. If you are interested in other kinds of parsers, then you need to consult another source. The classic source on these other kinds of parsers is "Compilers: Principles, Techniques, and Tools" by Aho, also known as "The Dragon Book". This book explains how to write parsers for new computer languages that you create. Each chapter focuses on either background, techniques, or applications. A chart at the beginning of chapter one shows you which chapter focuses on each topic. Each chapter builds on the material presented in preceding chapters, so you should probably proceed through this book linearly. I review this book in the context of the table of contents: 1. Introduction - Just performs an overview of the book. 2. The Elements of a Parser - Explains what a parser is, introduces the building blocks of applied parsers, and shows how to compose new parsers from existing ones. 3. Building a Parser - Explains the steps in designing and coding a parser. 4. Testing a Parser - How to test a new language's features and also how to use random testing to detect ambiguity and other problems. 5. Parsing Data Languages - Shows how to create a parser that reads the elements of a data language. A data language is a set of strings that describe objects following a local convention. 6. Transforming a Grammar - How to ensure the correct behavior of operators in a language and how to avoid looping in a parser, which can follow from loops in a grammar. 7. Parsing Arithmetic - This chapter develops an arithmetic parser. Arithmetic usually appears as part of a larger language. 8. Parsing Regular Expressions - develops a regular expression parser. A regular expression is a string that uses symbols to describe a pattern of characters. 9. Advanced Tokenizing - Describes the tokenizers that are part of the Java programming language as well as the customizable tokenizer of this particular book. Tokenizing a string means breaking the string into logical nuggets so that you can define your parser in terms of these nuggets rather than individual characters. 10. Matching Mechanics - Explains how the fundamental types of parsers in this book match text. 11. Extending the Parser Toolkit - How to extend a parser toolkit which includes introducing new types of terminals or completely different parser types. 12. Engines - Introduces a logic engine, which is a piece of software that is able to return objects and groups of objects in response to a logical query. 13. Logic Programming - Shows how to program with facts and rules. 14. Parsing a Logic Language - How to construct a parser for a logic language. It shows how to build a parser for the Logikus programming language that was in

A superb book that will let you write your own language parsers in just a few days

One of the best programming related books I have found. It certainly is one of the most original and most enjoyable reading materials I have found. And having read a lot, that says something :) Steven provides the reader a strong Java framework for building your own language parsers, and contrary to some reviews I've found, he's right to do so, since he introduces a very complex issue simplifying it to the point that in just a couple of days you can write your own parsers. This book is a member of a very few select of books that should be considered "Must Have". It's one of those purchases you will not regret.

Best example of design patterns in a complex system

I purchased this book for two reasons.1. My compiler class in college was the only CS class I took that really kicked my butt in the code. Maybe because it was the first application I had to write in school and live with it for a whole semester? Always felt guilty about my 'lack' of knowledge in this area and wanted to do something about it.2. I was hitting the wall with how far I could push XML at work. I had been converting a config data file to an XML file as a go between for an embeded system and a Java application. The embedded guys added meta information to the legacy config file with special comments. All of the sudden a simple convert to XML and back via XSL wan't going to cut it! Panic!!! I stumbled over this book last week while getting the new Applied Java Patterns book. The preface for this book was by one of the authors from the GoF book.(Vlissides) After reading his comments I figured he was a smart guy and learned something so surely I could as well.WOW!With this book and the excellant supporting code library I was able to write a parser that contained around 15 simple tokens in one week. The author's code is free to use as long as you don't claim it as your own.The supplied code is one of the best uses I've seen to date on how to solve a serious and complex problem with design patterns.College kids having to build a parser from scratch for a class may not like this book. I would still consider this a great intro or refresher since you have working code to play with.Caution: If your new to 'design patterns' AND parsers your not ready for this book. If you know design patterns 'just a little' and your curious about parsers think of this book as a working model to play with, embrace and extend. You could possibly use this book to learn design patterns. It is well written code that solves some cool problems. Oh! Before I forget. If you do not know what recursion means or how it works. Your not ready for this book.If your on a deadline an you need something quick, look here first. Best code I've seen packaged with a development book. I also liked how the code was installed by using an install.html file that detected your OS with a trusted applet and then installed the code AND the JVM. Nice touch for people that can't download a 30MB JDK over a 56K modem. :-)Great book I would highly recomend to any Senior Level Java Developer or college student in a compiler class.

Includes more than three hundred Java classes

In Building Parsers With JAVA, computer language expert Steven Metsker shows how to create parsers that recognize custom programming languages. Readers will learn how to design, code and test a working parser; how to create a parser to read data language; how to crate a new computer language; how to translate the design of language into code; how to accept an arithmetic formula and compute its result; how to build parsers for a custom query language going beyond SQL; and much, much more. The "user friendly" text is enhanced with an accompany CD-ROM containing all of the examples and the parser toolkit, including more than three hundred Java classes and their corresponding javadoc documentation. Also provided are example programs for the new logic, query, and imperative languages introduced in the text. Building Parsers With JAVA is an indispensable and highly recommended book/CD addition to the language programmer reference shelf.

John Vlissides Foreword is right on the money

The foreword says "Traditional parsing tools are overkill at best, antiquated and unusable at worst. The result? Ad hoc has become the parsing approach of choice.But when I read this book, I had a change of heart."So did I. I came across this book (a week and a half ago) when I was just about to begin designing a small language to embed in an application. I was loathing the task to come because the parser development tools are all oriented towards large languages and there's nothing to help with small ones. I really didn't want to go learn all about JavaCC or SableCC. They are both excellent tools, but overkill for my tiny language.The first day, I read chapters 1-5 and wrote a couple of experimental attempts at pieces of our desired langauge to prove that it would work. The second day, reading material from chapters 4 (on testing), 5 (on data languages), and 6 (on transforming grammars), I paired with another developer and we developed the entire grammar for our little language. The third day, we used chapter 5 again and bits of chapters 10 (Matching Mechanics) and 16 (Parsing an Imperative Language) to develop the actions in our language.Absolutely fantastic. Useful. Practical. On topic without the wasted digressions introducing basic Java concepts that are so prevalent in many Java books.