Parsers Books

It's good for programming Parse

Before reading the book I was unsure of where to start. We had a large language, similar to Java which we wanted to parse, and we wanted to do it without using a compiler-compiler. By changing the author's design slightly so that the parsers were singletons and only a single assembly was ever created, we were able to parse large and complex files very quickly. More importantly, the design is such that making changes to your language is a snap. This was a must for us since our language is still in flux. If you have any kind of language you need to parse, Java is your implementation language, and for whatever reason you cannot use a compiler-compiler, then this is the book for you. The author's code included with the book will get you on your feet and running quickly. If Java is not your implementation language then keep in mind that the patterns taught in this book will work in any Object-Oriented language. Thanks to this book we now have an a new programming language which we have open sourced. Five-stars, thanks so much for the great book!

this review is intended to help potential customers better decide for themselves ; i was nearly dissuaded from purchasing a copy due to the reviews by inexperienced ( and apparently lazy ) programmers

the provided code, and related concepts, are examined fully in the text. the code is so OOP-trivial ( this is a good Java design rather than rehashed procedural code clumsily ported to the OO-Language du-jour ) that anyone familiar with the basics of Java, C++ or C# should be able to compose their own library in a short period of time. in the preface the author suggests the reader be familiar with Design Patterns and UML, but he has included sections which address the minimal use he makes of UML. most 'somewhat experienced' programmers will be able to see through the scant UML diagrams to the underlying concepts they address, but he explains the notation anyway. as for Patterns, they are mentioned in passing but are not examined in any way which might hinder the uninitiated

one reviewer laments that ''... the author's explanation of his code library is virtually non-existent -- you're going to have to figure out what he's talking about all on your own'' - this was not the same book i read. in addition to including comprehensive javadoc ( Java documentation in HTML format is provided on the CD as well as his web site, if you're buying a used copy ) to help guide readers interested in ''digging into his code'', the author walks the reader through the concepts presented in this book in an incremental and rather intuitive way. starting from ''the ground-up'' is not always a good idea, and i'm glad this author followed his instincts rather than the herd

the code supplied is working code ( a feat almost unheard of today ), the examination of which helps to illustrate function better than any equivalent volume of text could. in fact the code is so well decomposed in terms of OOP that the text cannot fail to assist even entry-level programmers in the creation of their own parsers using the concepts presented. as for the difficulty of making oneself independent of 'his toolkit', i can only say that more than 95% of the class methods are under ten lines of code ( most are under six ), so it seems that anyone willing to apply themselves should be able to succeed in doing so ; especially considering the fact that his included code covers far more ground than a more sharply focused ( 'real world' ) implementation would ( meaning that, in terms of volume, you would only need to write or implement a tiny fraction of what is included with the book to satisfy any specific implementation )

some reviewers have unambiguously reported putting the concepts presented in this book to work - and quickly - which says a great deal given the perceived complexity of the subject. indeed, creating a parser for a macro assembler for a particular embedded processor was so trivial ( thanks to the concepts in this book ) that i am confident modifying it for other targets will be trivial, as it was modeled after the author's OOP examples. having said that, the OOP perspective this author has provided seems the principal way in which this book is differentiated, making space for itself in an already crowded marketplace

ignorance of the subject matter can be blamed for many of these negative reviews ; some reviewers are so unfamiliar with the subject matter as to call all compiler related concepts 'black-box'. each of the compiler books on my shelf examines a recursive descent parser, but in a far less practical way, and typically in pseudo-code ( including a prominent example claiming to use Java, but instead presenting what i consider to be nothing more than procedural C pseudo-code fragments ). BPWJ follows a preferable route, and anyone who has inordinate difficulty might better fail with a more abstract text on the subject before blaming this author for their own inadequacies

one reviewer complains about the onus of being expected to participate in order to gain comprehension by stating ''To compound it, that code can be a bit perplexing when 95% of his variables have one-letter names -- it just isn't very readable if you're not already familiar with his ideas and approach'', which mystifies me, given that well over 95% of the class methods are under ten lines of code ( most are under six ) ... what kind of neurological damage would account for an inability to retain the type of an identifier within the span of six lines ?

for example :

Token t = new Token();
Assembly a = new Assembly();
String s = "some string given the highly problematic identifier s''

should the time a programmer saves by using OOP be squandered on thinking up unnecessary, lengthy names whose lifespan is less than ten lines ? especially considering that peripheral vision will nearly always encompass the code in question, a scant few lines above ? now ... what was 't' again ???

to round-out his list of disappointments, this same reviewer states ''The good news is that you'll be up and running and writing simple grammars and parsers in very little time. The bad news is that if you're working on anything [...] find yourself forced to peer into the black box to figure what the heck [his code] actually IS doing'', with which i agree - the code included is not geared to any specific project you may have in mind ; rather it is nearly exhaustive so that a working example for you to study is always at hand. warning : you will need to participate if you wish to make use of what you can learn by studying this book. if you are willing to do that, success can be yours ... passively being granted mastery in any area of programming ? i'll take the Vegas odds on that !

another reviewer makes several complaints ... in order : ''(1) ... everything is so dependent on the included framework makes it difficult to learn from. (2) I think the best programming books teach you how to build step-by-step from the ground up. (3) Instead, this book expects you to immerse yourself in the code first''

(1) the code, and related concepts, are examined fully in the text. the code is well designed OOP, rather than a ham-fisted port of procedural code, meaning that anyone with minimal experience in any OO language should be able to write their own, rapidly turning his ''fascinating ideas'' into a coded reality all their own

(2) as for ''learning from the ground up'', the text progresses slowly, beginning with a general overview ( to help readers get their bearings within the overarching conceptual framework being presented ) and moving into actual, albeit initially trivial, examples ( as any good programming book should ) and progresses from that point with chapters focusing on discrete aspects of the subject, as well as considering various implementation domains

(3) good code ( especially *working* code ) helps to illustrate function better than any equivalent volume of text could. having said that, the author forces no one to immerse themselves in code. naturally code is presented - this is a programming book after all, and not a purely theoretical one. the presented code is so well decomposed ( into OO Java ) that the text cannot fail to guide a programmer in the creation of his own parsers using the concepts presented ... so making oneself independent of his 'framework' seems trivial enough, given, again, a minimal competency in nearly any relatively modern OO language. as already indicated, the code is slowly examined initially, and given the brevity of procedures ( mentioned above ) it seems reasonable that anyone willing to apply themselves should be able to master the concepts presented in this book

i cannot abide an above average programming text being trashed by the inexperienced, who might have anticipated possessing ''mad 3l33t haxor skilz'' after flipping through the pages - reviewers reporting having used the material presented in this book tell us more than any failure ever could

warning : anyone who considers studying clear Java code difficult, or is unwilling to expend the effort needed to succeed in learning a new task, should avoid this book and every other book on the subject. perhaps IDG should be made aware of the sales they could expect for a new 'Dummies' title. then these unhappy campers could enjoy cartoons ( ''to spice things up'' ) and be given strained examples, twisted for the sole purpose of setting-up some moronic joke

one note about the code : it was written under an early version of Java ( the book was published in 2001, remember ) and to bring it up to current standards will require hitting the files over the head with a compiler. NetBeans quickly directed me to add annotations, mostly @pragma, which took a few minutes. not a big deal, but now you know

OK, now it's up to you to choose

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 introduced in the previous chapter.
15. Parsing a Query Language - Constructs a parser for a query language. A query language parser translates textual queries into calls to an engine. The engine proves the query against a source of rules and data and returns successful proofs as the result of the query.
16. Parsing an Imperative Language - Shows how to create a parser for imperative languages. An imperative language parser translates a textual script into a composition of commands that direct a sequence of actions.
17. Directions - Points out areas for further reading and programming.

I used this book to create a parser for a visual language, and I found the instructions in this book very complete and helpful. I would recommend the following books if you are interested in getting deeper into the theory behind this book - "Programming Language Pragmatics" and also "Introduction to the Theory of Computation" by Sipser.

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.

I own arround 80 books about compiler/language design, and this is what I have to say about this book.

It's a FIVE star, if you are looking for a easy cookbook to deal with simple free text input in your application (e.g. a command line to enter commands in your application, or write your own scripting language).

However it's a ONE star, if you want to learn or write your own compiler or want to deal with very complex free format text input (e.g. a real programming language). This book doesn't really cover the theory behind parsing and scanning although there are some chapters about Logic programming.

Everyone can read this book. It doesn't rely on 'higher math'. It is not a dry text. With this book everyone can write a descent text processor.

The problem with this book (which is a advantage for novice people, and a disadvantage for people who want to learn something about compiling), is that this book rely on a parsing/scanning/interpreter framework/library of the author. This framework is not described in this book. You only learn how to use this framework. This is nice for people who only want to build a parser based on this framework, but a disadvantage for people who want to learn something about the theory or the algorithms (used in this framework or in parsers/scanners in general).

The book of Terence Parr describes his ANTLR LL top-down parser generator
very clearly and with outstanding academic style of presentation.
The ANTLR tool is powerful, I like to use it, since it easier to use and
more well documented (with the Parr's book) than the alternative javacc tool
or the traditional lex/yacc/bison tools.
Shortly, I strongly recommend the Terence's book to both the
industrial programmers/developers and to the academic community.

This book very thoroughly documents the ANTLR parser generator, but it does so with a Java bias that is so strong it excludes all of the other languages ANTLR supports. This makes sense on some level since ANTLR is a Java tool written by a Java developer, but for those of us who have an equally strong bias AGAINST Java the example code can best be described as nap inducing.

If you want to use ANTLR with C or Python or any other language, stick to the free documentation on the web.

If you have any interest in compiler design, building translators, building intelligent editors, code generation, understanding what goes into building your own computer language, or just how to use ANTLR v3 then you may want to get a copy of this book.

This book is all about ANTLR. ANTLR is a tool you can use to build compilers and interpreters for computer languages, but don't let that scare you off. With the increasing interest in domain specific languages, bulding intelligent editors, code generation, and model driven development books like this are becoming ever more important. Terence Parr has made the topic far more approachable than any other book I have read (or attempted to read) on the topic.

In the first few chapters the author walks readers through the phases of parser construction using language that is approachable and easy to understand. He explains the needed principles and demonstrates their application with well chosen examples.

This is followed by a quick tour of how one might use ANTLR. I love the approach taken in this chapter as it takes a small example and shows two different ways to approach the problem using ANTLR. This is coupled with explanations describing when you want to use one approach over another.

The middle section of the book goes into depth on the various aspects of ANTLR. This is the reference section. Don't expect to be able to read these chapters one after another in quick succession. There's just too much to take in all at once!

The text is littered with references both forward and back to other sections and topics of interest. You can tell the author has spent a lot of time working with compiler construction by the breadth and depth of information presented. I really liked the motivating examples he gives for certain ANTLR features such as the need to emit imaginary tokens when lexing python (see page 94 in chapter 4).

The first chapter of part three of the book delves into the depths of the parsing algorithm used in ANTLR since you will need to understand it when you run into parsing errors and need to make sense of them.

The remaining chapters are devoted to ways to deal with the problems you may run into when trying to parse various language constructs.

This book has left a very lasting impression on me. I can visualize what goes into an editor like eclipse more fully. I no longer feel that the topic of abstract syntax trees is above my head and I feel I am better equipped to tackle the dragon book. I also understand why lisp programmers say that lisp has no syntax (take a look at the serialized form of the AST from chapter 3 on page 62, it looks like a bunch of s-expressions!).

One more note: ANTLR itself is a domain specific language (DSL) and serves as a prime example of how a DSL can greatly increase the clarity of the solution to a problem if the solution is described in terms native to the problem domain. (I think that's what the folks in the lisp camp have been saying for a long time.) ANTLR helps show the value of having DSLs and this book shows how easy it can be to write one!

ANTLR is pretty much the de facto tool when it comes to writing parsers. In this book Terence Parr has given a really nice and detailed guide to ANTLR 3. Usually a reference book is pretty dry, but not this one. Terence has a nice, relaxed writing style which makes this a very easy read. Also it has lots of examples to guide you along the way.


A must read for anyone planning to work with ANTLR, write parsers or just wanting to get an insight into parsing theory.

You may have decided to use the Parser Generator ANTLR because it can generate code in many different languages like CSharp, Python and of course Java.
In this case you have to get this book. The current online documentation is minimal. But beware that despite the title
there are some points that the author forgets to define (such as the EOF token, which can be important). However a more important quible is that
we are far from the quality of writing of the famous "Dragon Compiler Book".
If you are looking for pithy clear definitions like me you will be disappointed. You may waste a lot of time trying to understand error messages when they arise while generating code from a grammar.
The space devoted to Antlworks is very limited .
Hopefully this will be fixed up in future printings of this book.

This book was basic and lacked in depth detail. I actually got more out of the help file that came with log parser. I was hoping for more detail on creating and using charts. This is not one of the better books i've bought this year.

This tool is amazing in that it supports a variety input and output formats including reading in syslog and outputting into databases are pretty Excel charts. The filtering uses an SQL syntax. The tool comes with a DLL that can be registered, so that scripters (VBScript, Perl, JScript, etc.) can access the power of this tool.

This book not only covers the tool (alternative being to scrape the network for complex incomprehensible snippets), but shows real world practical solutions with the tool, from analyzing web logs, system events, security and network scans, etc.

This tool is just heavensend for analysis and transforming of any data in a variety of formats. The book and tool go hand-in-hand, and I highly recommend incorporating this into your tool (and book) into your tool kit and/or scripting endeavors immediately.

I bought this book thinking it would be a good reference point for using Log Parser 2.2, and am exceedingly impressed with the volume of real-world, practical examples.

Within minutes I had several scripts in production and was on my way to writing much more complex queries to squeeze every drop of valuable data from my logs. I'm querying IIS logs, Event Logs, CSV files and more with ease.

I've got this book at my side any time I go to write a new script. I would definitely recommend it to others.

Log Parser by it self is a wonderful tool, this book lets you get up and running with it in no time.
Additionally it gives a great insight on logs. This book is essential for any admin that wants to keep with "the going on" on his network without running agents everywhere. Log Parser toolkit lets you make logs readable (what a novel concept) without the need for heavy programming, all the scripts are included and really easy to customize. If you keep any type of log this will make your life easier and can save you major head hakes. My only recommendation is when you get one for your self, don't forget to get one for your IIS admin and your security guy, or be ready to share it. Enjoy it...

This is a complete reference for utilizing the MicrosoftLog Parser Tool in real world scenarios.
The authors do an outstanding job of bringing you from the basics of Log Parser through advanced techniques and tricks. I have thoroughly enjoyed reading it end to end, and have begun utilizing Log Parser in my daily log assessment routines. The Tips, Swiss Army Knifes, and Master Craftsman sidebars prove extremely creative and helpful.

This is the manual for the BISON compiler generator program. It doesn't try to be more so it is succinct and efficient. You can find just as good information on the internet (and in fact I believe this is exactly the same information as is on the web, just printed). It is nicely printed (nice paperback binding) and inexpensive. If you happen to appreciate printed manuals, as I do, then you may appreciate having this on your shelf for when you work with BISON.

This is a must-have book for programmers who need to develop language parsers, from those used in simple desk calculators to complex programming languages. Bison is upward compatible with Yacc: all properly-written Yacc grammars ought to work with Bison with no change. If you don't know Bison or Yacc, start by reading this book. Using Bison is a great step forward in programming technique. You wouldn't understand the benefits of using Bison in your programming work before reading this book!