Hot Downloads
Home»LALR parsers related tags
Search Software:Search
    LALR parsers in tags
  • Kelbt
    Kelbt

    Kelbt generates backtracking LALR parsers. 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. What's New in This Release: [ read full changelog ] · The -I option was added for specifying include directories. · The "token uses" construct was fixed.

    Size: Download
    LALR parsers in description
  • Bison
    Bison

    Bison is a general-purpose parser generator. Bison project is a general-purpose parser generator that converts a grammar description for an LALR context-free grammar into a C program to parse that grammar.Once you are proficient with Bison, you can use it to develop a wide range of 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. Anyone familiar with Yacc should be able to use Bison with little trouble. You need to be fluent in C programming in order to use Bison.

    Size: Download
  • Kelbt
    Kelbt

    Kelbt generates backtracking LALR parsers. 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. What's New in This Release: [ read full changelog ] · The -I option was added for specifying include directories. · The "token uses" construct was fixed.

    Size: Download
  • PyBison
    PyBison

    PyBison is a Python-based parser that operates at the speed of C. 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) it's very possible PyBison will work on Windows as well. Here are some key features of "PyBison": · 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)

    Size: Download
  • SJPT: Simple Java Parsing Toolkit
    SJPT: Simple Java Parsing Toolkit

    SJPT: Simple Java Parsing Toolkit is a simple Java parser toolkit. SJPT is parsing toolkit that supports both top-down (LL(1) and Simple Precedence) and bottom-up parsing (LR(0), SLR(1), LR(1) and LALR(1)). The toolkit also supports generating Java parsers for all the bottom-up parsing methods, based on a CUP definition (similar to Yacc and CUP, but not restricted to LALR parsers only). I worked alone on this project for the laboratory on Compilers.SJPT is free software under the terms of the GNU GPL.

    Size: Download
  • CL-Yacc
    CL-Yacc

    CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, etc. CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due to DeRemer and Pennello, which is used by Bison and lalr.scm (not to be confused with lalr.cl).While CL-Yacc has undergone no systematic testing, I use it for compiling a grammar for a superset of C (over 400 productions) that routinely parses thousands of lines of C code. Here are some key features of "CL-Yacc": · Free Software with very liberal redistribution provisions (COPYING); · a single file that you are welcome to distribute with your application; · reasonable (but not outstanding) performance; · support for ambiguous grammars (operator precedence and associativity). What's New in This Release: [ read full changelog ] · Kill YACC-EOF-SYMBOL, use NIL instead. · Add abstract condition types. · Add a full example (calculator.lisp).

    Size: Download
  • Yapps2
    Yapps2

    An easy to use parser generator producing human-readable Python code Yapps (Yet Another Python Parser System) is an easy to use parser generator that is written in Python and generates Python code. Yapps2 is simple, is easy to use, and produces human-readable parsers. It is not fast, powerful, or particularly flexible. Yapps is designed to be used when regular expressions are not enough and other parser systems are too much -- situations where you may write your own recursive descent parser.Some unusual features of Yapps that may be of interest are: 1. Yapps produces human-readable recursive descent parsers. There are several heuristics used to keep the generated code simple. 2. Yapps produces context-sensitive scanners that pick tokens based on the type of tokens accepted by the parser. In some situations, token matching is ambiguous unless the context is taken into account. 3. Yapps rules can pass arguments down to subrules, so subrules can use information (such as declarations) that was parsed at higher levels in the parsing process. These are sometimes called attribute grammars.There are several disadvantages of using Yapps over another parser system: 1. Yapps parsers are LL(1), which is less powerful in parsing power than LALR or SLR. There are some inconveniences having to do with LL(1) (such as the lack of operator precedence) that lead to more explicit grammars. 2. The Yapps scanner can only read from strings, not from files, so it may not be useful if your input is large. However, it is possible to write a custom scanner for your application. (Note: the enhanced version of Yapps in Debian can read from files.) 3. Yapps is not designed with efficiency in mind. It’s not the fastest parser available (nor is it the slowest). Requirements: · Python

    Size: Download

Top Freeware

Top shareware

Related Search