The Attribute-Logic Engine integrates phrase structure parsing and constraint logic programming with typed feature structures as terms.

LALR Parser generator for syntax directed parsing. AnaGram 2.01 runs on Win32 platforms: Win9x, ME, NT, 2000. AnaGram generates ANSI compatible platform independent C or C++ code. No runtime libraries are required.

ANTLR official site
An ANTLR Tutorial

Beaver is a LALR(1) parser generator. It takes a context free grammar and converts it into a Java class that implements a parser for the language described by the grammar. Beaver accepts grammars expressed in the Extended Backus-Naur form (EBNF).

GNU's free version of the parser generator Yacc.
Bison manual

BTYACC is a modified version of yacc that supports automatic backtracking and semantic disambiguation to parse ambiguous grammars, as well as syntactic sugar for inherited attributes (which tend to introduce conflicts).
Whenever a btyacc generated parser runs into a shift-reduce or reduce-reduce error in the parse table, it remembers the current parse point (yacc stack and input stream state), and goes into trial parse mode. It then continues parsing, ignoring most rule actions. If it runs into an error (either through the parse table or through an action calling YYERROR), it backtracks to the most recent conflict point and tries a different alternative. If it finds a successful parse (reaches the end of the input or an action calls YYVALID), it backtracks to the point where it first entered trial parse mode, and continues with a full parse (executing all actions), following the path of the successful trial.

Berkeley Yacc is a public domain LALR(1) parser generator. It has been made as compatible as possible with AT&T Yacc.

The Java based Constructor of Useful Parsers (CUP for short) is a system for generating LALR parsers from simple specifications. It serves the same role as the widely used program YACC, and in fact offers most of the features of YACC. However, CUP is written in Java, uses specifications including embedded Java code, and produces parsers which are implemented in Java.

A top-down parser generator that supports specifications in a style similar to syntax-directed translation schemes. The specification language is based on EBNF. Depot4 is intended for use by non-experts implementing domain-specific languages.

Gobo Eiffel Yacc is a general-purpose parser generator that converts a grammar description for an LALR(1) context-free grammar into an Eiffel class equipped with routines to parse that grammar. Geyacc may be used to develop a wide range of language parsers, from those used in simple desk calculators to complex programming languages. Geyacc is very similar to yacc and GNU bison. Anyone familiar with these utilities and fluent in Eiffel programming should be able to use geyacc with little trouble.

Unlike other parser generators, the GOLD Parser strives to be a development tool that can be used with numerous programming languages and on multiple platforms while maintaining modern design concepts.
Modern bottom-up parsers use a Deterministic Finite Automaton (DFA) for identifying different classes of tokens and a LALR(1) state machine to parse them. The actual LALR(1) and DFA algorithms are easy to implement since they rely on tables to determine actions and state transition. Consequently, it is the computing of these tables that is both time-consuming and complex.The GOLD Parser Builder performs this task; reading from a source grammar outline and then computing the appropriate tables. This information is then saved to a Compiled Grammar Table file which can be, subsequently, loaded by the actual parser engine and used.

The Gardens Point Parser Generator (gppg) is a Yacc/Bison like parser generator. Both the parser generator and the parser runtime components are implemented entirely in C#. They make extensive use of generic collection classes and so require Beta Version 2.0 of the .NET Framework. The parser generator takes a Bison/Yacc style grammar specification with semantic actions coded in C# and produces an LALR(1) parser. It is designed to be simple, efficient and as similar as possible to Yacc/Bison in functionality. It does not include a scanner/lexical analyser generator. The parser’s interfaces however, are designed to be as simple as possible with minimal object-orientation.

Grammatica is a C# and Java parser generator for LL(k) grammars with unlimited number od lookahead tokes. Grammatica has automatic error recovery and detailed error messages, and support for testing and debugging grammars without generating source code.

Happy is a parser generator system for Haskell, similar to the tool `yacc' for C. Like `yacc', it takes a file containing an annotated BNF specification of a grammar and produces a Haskell module containing a parser for the grammar. Happy is flexible; unlike `yacc', you can have several Happy parsers in the same program. Happy can work in conjunction with a lexical analyser supplied by the user (either hand-written or generated by another program), or it can parse a stream of characters directly (but this isn't practical in most cases). The current public version of Happy is 0.9a, which was released on February 28, 1996.

100% Pure Java Parser generator producing parsers in Java

LALR(1) parser generator for JavaScript, JScript and other ECMAScript-based derivates, which was itself completely written in JavaScript! JS/CC can be embedded on a website (this acts as a learning environment) or be executed on Windows-systems via JScript.NET or Windows Script Host. JS/CC is open source under the Artistic License.

Lemon is an LALR(1) parser generator similar to Yacc or Bison but with some important differences:

- Lemon is using a different grammar syntax which is less prone to programming errors.
- The parser generated by Lemon is both re-entrant and thread-safe.
- Lemon includes the concept of a non-terminal destructor, which makes it much easier to write a parser that does not leak memory.

LLgen is a tool for generating an efficient recursive descent parser from an ELL(1) grammar. The grammar may be ambiguous or more general than ELL(1): there are both static and dynamic facilities to resolve the ambiguities.

An LALR parser generator, lexer generator, symbol-table builder, abstract-syntax-tree construction and intermediate code emitter, in short, a compiler front-end generator. Based on the new powerful TBNF grammar notation, less coding required than other systems.

Parser generator heavily based on JavaCC project, for generating C# lexer/parser from given grammar files. The generated parsers are fully compatible with both Mono and .NET parsers. MinosseCC is licenced under MIT Licence.

RDP compiles attributed LL(1) grammars decorated with C-language semantic actions into recursive descent parsers.

SLK is strong LL(k) parser generator. Difference between LL(k) and "strong LL(k)" is that "strong LL(k)" does not use any of the left context of the parse. This is somewhat less powerful than LL(k), but results in much smaller grammars and parsing tables.

Spirit is an object oriented recursive descent parser generator framework implemented using template meta-programming techniques. Expression templates allow us to approximate the syntax of Extended Backus Normal Form (EBNF) completely in C++. Parser objects are composed through operator overloading and the result is a backtracking LL(inf) parser that is capable of parsing rather ambiguous grammars. The Spirit framework enables a target grammar to be written exclusively in C++. Inline EBNF grammar specifications can mix freely with other C++ code and, thanks to the generative power of C++ templates, are immediately executable. In retrospect, conventional compiler-compilers or parser-generators have to perform an additional translation step from the source EBNF code to C or C++ code.

Reusable OO Parser for Eiffel Reengineering written entirely in Eiffel.

AT&T Yacc is the classical parser generator that comes with Unix. This is an official man page.

Resources on the Web

by Stephen C. Johnson
Comprehensive description of Yacc

by John David Stone

by Etienne Bernard

GRDP is a new style of parser generator that allows you to protoype new languages without regard to the underlying parsing technology. Once a working prototype is obtained, GRDP can be used to refine the language specification to improve parser performance.

YooParse is a free full LR(1)/LALR(1) parser generator for C++. It is designed to work with YooLex to provide a lex/yacc like parser solution for C++ programmers.