parser generators
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
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).
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.
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.
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.
- 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
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.