Free lalr software for linux

SableCC is an object-oriented framework that generates compilers (and interpreters) in the Java programming language. SableCC framework is based on two fundamental design decisions.
Firstly, the framework uses object-oriented techniques to automatically build a strictly typed abstract syntax tree. Secondly, the framework generates tree-walker classes using an extended version of the visitor design pattern which enables the implementation of actions on the nodes of the abstract syntax tree using inheritance.
These two design decisions lead to a tool that supports a shorter development cycle for constructing compilers.
Main features:
- Deterministic Finite Automaton (DFA) based lexers with full Unicode support and lexical states.
- Extended Backus-Naur Form grammar syntax. (Supports the *, ? and + operators).
- LALR(1) based parsers.
- Automatic generation of strictly-typed abstract syntax trees.
- Automatic generation of tree-walker classes.
Whats New in 3.2 Stable Release:
- SableCC now generates generic Java code.
Whats New in 4 Alpha 3 Development Release:
- Improved syntax for SableCC lexers.
- The exponent operator and code to implement its functionality.
- The Any keyword and code to implements its functionality.
- Robust and intuitive SableCC-based command line parsing.
- Parsing of lexer specifications.
- Partial semantic verification of lexer specifications.
- Improved build script.
- Additional unit tests.
- Additional documentation.

Kelbt project can generate backtracking LALR parsers. Standard LALR parser generators emit an error upon encountering a conflict in the parse tables. Kelbt forges onward, generating parsers which handle conflicts by backtracking at runtime. Kelbt is able to generate a parser for any context-free grammar and therefore implements a generalized parsing method.
Kelbt is different from other backtracking LR systems in two ways. First, it elevates backtracking to the level of semantic actions by introducing a class of actions called undo actions. Undo actions are invoked as the backtracker undoes parsing and allow the user to revert any side effects of forward semantic actions. This makes it possible to backtrack over language constructs which must modify global state in preparation for handling context dependencies.
Second, Kelbt enables a user-controlled parsing strategy which approximates that of generalized recursive-descent parsing. This makes it easy for the user to resolve language ambiguities by ordering the grammar productions of a nonterminal according to their precedence. It is approximate in the sense that for most grammars the equivalent of an ordered choice parsing strategy is achieved. In cases where productions are parsed out of the order given, there is a simple grammar transformation which remedies the problem. See the CASCON paper for more details.
As a proof of concept, Kelbt has been used to write a partial C++ parser (included) which is composed of strictly a scanner, a name lookup stage and a grammar with standard semantic actions and semantic undo actions.
Enhancements:
- The -l option was added for turning off line directives in generated code.
- The class keyword was added.
- This indicates that a nonterminal or the token type is a C++ class, and should have its constructors and destructors called.
- The shortest statement was added.
- This allows one to force a shortest match of a list of items.
- The semantics of commit was changed.
- It now forces a full commit rather than a scoped commit.
- Many other improvements were made.

Dragon is a powerful parser generator. It produces a consequent, object-oriented, integrated scanner and parser solution. Dragon parser generator also scales for very large grammar defintions. Since dragon parses LR(1) grammars, the generation algorithm is quite CPU intensive.
Using LR(1) instead of LALR decreases efficiency of the parser, but avoids some reduce/reduce conflicts in some cases. Dragon provides a very clean and structured way for the integration of application specific context code. Dragon combines the lexical and syntactical analysis and the corresponding code generation.
Enhancements:
- The switch option -y was added to switch between a dynamically allocated parse table or a static parse table.
- An escape feature was added for special token definitions.

PyBison is a Python binding to the Bison (yacc) and Flex (lex) parser-generator utilities.
It allows parsers to be quickly and easily developed as Python class declarations, and for these parsers to take advantage of the fast and powerful C-based Bison/Flex.
Users write a subclass of a basic Parser object, containing a set of methods and attributes specifying the grammar and lexical analysis rules, and taking callbacks for providing parser input, and receiving parser target events.
Presently, PyBison is only working on Linux (and possibly *BSD-based) systems. However, in time, (or if someone volunteers to help out with probably 2 hours coding for a small shim layer) its very possible PyBison will work on Windows as well.
Main features:
- Runs at near the speed of C-based parsers, due to direct hooks into bison-generated C code
- Full LALR(1) grammar support
- Includes a utility to convert your legacy grammar (.y) and scanner (.l) scripts into python modules compatible with PyBison
- Easy to understand - the walkthrough and the examples will have you writing your own parsers in minutes
- Comfortable and intuitive callback mechanisms
- Can export parse tree to XML with a simple method call (New!)
- Can reconstitute a parse tree from XML (New!)
- Examples include working parsers for the languages:
- - ANSI C
- - Java (1.4.2)