Directory of Lexer and Parser Generators Resources

Home > Computers > Programming > Compilers > Lexer and Parser Generators

Subcategories

• ANTLR
• Java
• Python

Resources in This Category

• A Compact Guide to Lex and Yacc

  http://epaperpress.com/lexandyacc/index.html
  Tutorial in Lex and Yacc, tools that simplify compiler construction.

• AnaGram

  http://www.parsifalsoft.com/
  Provides a powerful grammar notation, special features for maintenance of highly configurable parsers, visual parsing and unique interactive debugging tools, supporting thread-safe parsers. The program produces C/C++ parsers for use on any platform and runs under Win9x/NT. A free trial copy is available.

• AustenX Parser Generator

  http://scratchy.org.nz/austen.php
  An easy-to-use parser (and lexical) generator for Java, using an extended Parsing Expression Grammar framework and with advanced packrat parsing ability.

• Bison++ and Flex++

  ftp://lnx1.hrz.tu-darmstadt.de/pub/programming/languages/C++/tools/flex++bison++/
  A retargeting of bison-1 and flex 2.3 to C++ capable of generating classes. As with Bison and Flex these two tools are independent but designed for mutual compatibility. Examples are provided to help in getting started.

• BtYacc patches: BackTracking Yacc

  http://www.vendian.org/mncharity/dir3/btyacc/
  The version of BtYacc on siber.com suffers from a few minor, but annoying bugs. This is a page with patches.

• BtYacc: BackTracking Yacc

  http://www.siber.com/btyacc/
  A modified version of yacc that supports automatic backtracking and semantic disambiguation to parse ambiguous grammars. It also has syntactic sugar for inherited attributes.

• ClearParse

  http://clearparse.sourceforge.net/
  A small, flexible parsing engine with practically unlimited backtracking capability. [Open Source]

• Coco/R compiler generator

  http://www.ssw.uni-linz.ac.at/Research/Projects/Compiler.html
  Coco/R combines the functionality of the well-known UNIX tools lex and yacc, to form an extremely easy to use compiler generator that generates recursive descent parsers, their associated scanners, and (in some versions) a driver program, from attributed grammars (written using EBNF syntax with attributes and semantic actions) which conform to the restrictions imposed by LL(1) parsing (rather than LALR parsing, as allowed by yacc).

• CppCC (C++ Compiler Compiler)

  http://cppcc.sourceforge.net/
  A scanner+LL(k = 1..Inf) parser generator for C++. Allows easy top-down description of grammars in an intuitive and extensible manner. [Open source, GPL]

• Elkhound: A GLR Parser Generator

  http://scottmcpeak.com/elkhound/
  Almost as fast as Bison (for deterministic portions of input) but can parse any context-free grammar. [Open source (BSD)]

• Flex

  http://flex.sourceforge.net/
  A fast lexical analyser generator. It is a tool for generating programs that perform pattern-matching on text. There are many applications for Flex, including writing compilers in conjunction with GNU Bison. [Open source, GPL]

• GNU Bison

  http://www.gnu.org/software/bison/
  A general-purpose parser generator that converts a grammar description for an LALR context-free grammar into a C program to parse that grammar. [Open source, GPL]

• GnuWin32

  http://gnuwin32.sourceforge.net/
  Various GNU tools and software for Win32 including ports of bison, byacc, and flex.

• GOLD Parser

  http://goldparser.org/
  A free parser generator. Unlike common compiler-compilers, it does not require to embed grammar directly into source code. Instead, the Builder analyzes the grammar description and saves the parse tables to a separate file. This file can be subsequently loaded by the actual parser engine and used. [Open Source]

• GradSoft YaYacc

  http://www.gradsoft.com.ua/products/yayacc_eng.html
  Yet another Yacc, which accept yacc grammar and produce C++ template-based reentrant code. [Open Source, BSD license]

• Grammatica

  http://grammatica.percederberg.net/
  Grammatica is a free LL(k) parser generator (compiler compiler) for C# and Java. Support for automatic error recovery, and instant parsing is available.

• Happy Parser Generator for Haskell

  http://www.haskell.org/happy/
  Takes BNF specification of a grammar and produces a Haskell module containing the parser for that grammar.

• Hapy

  http://hapy.sourceforge.net/
  A runtime parser generator library. It generates parsers from BNF-like language grammars. Parsing scripting languages and communication protocol messages are typical use cases. [Public domain]

• iburg, A Tree Parser Generator

  https://github.com/drh/iburg
  Generates fast tree parsers for cost-augmented tree grammars. A variant of iburg is used in the code generators for lcc.

• IParse

  http://www.iwriteiam.nl/MM.html
  An interpreting parser, meaning that it accepts as input a grammar and a source file to be parsed according to that grammar, producing an abstract program tree. Very compact implementation.

• IronMeta

  http://ironmeta.sourceforge.net/
  IronMeta is an implementation of Alessandro Warth's OMeta metaprogramming system in C#. It provides a packrat parser generator that generates parsers for Parsing Expression Grammars that operate on arbitrary streams of objects.

• JavaCC

  http://javacc.java.net/
  Java Compiler Compiler reads a grammar specification and converts it to a Java program that can recognize matches to the grammar. In addition to the parser generator itself, JavaCC provides other standard capabilities related to parser generation such as tree building (via a tool called JJTree included with JavaCC), actions, and debugging.

• jay

  http://www.cs.rit.edu/~ats/projects/lp/doc/jay/package-summary.html
  A version of yacc for Java rather than C. Documentation in German.

• JB2CSharp

  http://sourceforge.net/projects/jb2csharp/
  A port of the Java-Bison/Flex software developed by the Serl project at the University of Colorado, Boulder. Parsers and lexers will be able to use C# actions. The open source .NET project Mono has requested the port, and here it is. [Open source, BSD License]

• JS/CC Parser Generator

  http://jscc.phorward-software.com/
  JS/CC is a LALR(1) parser and lexer generator for JavaScript/ECMAScript which is entirely written in JavaScript.

• Lapg

  http://lapg.sourceforge.net/
  The combined lexical analyzer and parser generator, which converts a description for a context-free LALR grammar into source file to parse the grammar. [Open source, GPL]

• Lex and Yacc for Delphi 3

  http://www.17slon.com/gp/gp/tply.htm
  Port of lex and yacc to Delphi 3. Base at port to Turbo Pascal.

• lexertl: The Modular Lexical Analyser Generator

  http://www.benhanson.net/lexertl.html
  Generation of run-time lexical analysers, increasing flexibility through exposed state machine generated from a lex specification. Compiles under Unix using GCC 4.0.1 and as Visual C++.

• LLgen parser generator

  http://www.cs.vu.nl/~ceriel/LLgen.html
  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.

• LRSTAR

  http://sourceforge.net/projects/lrstar/
  LALR parser generator and lexer generator producing fast applications in C/C++.

• ModelCC Model-Driven Parser Generator

  http://arxiv.org/abs/1501.02038
  A model-based parser generator that decouples language specification from language processing, avoiding some of the problems caused by grammar-driven parser generators.

• Naive Language Tools

  http://sourceforge.net/projects/naivelangtools/
  NLT is a free, open-source C# lexer and parser suite containing GLR parser, enabling parsing of ambiguous grammars. Grammar can be defined directly in code or in separate file (lex/yacc-like) for included generator.

• Oops

  http://www.cs.rit.edu/~ats/projects/oops3/doc/
  An object-oriented parser generator implemented in Java.

• Parsertl: The Modular Parser Generator

  http://www.benhanson.net/parsertl.html
  A parser generator for C++. Currently supporting LALR(1), it may eventually possibly IELR and LALR(k).

• Pattern matching

  http://www.dmitry-kazakov.de/match/match.htm
  Pattern matching in syntax analysis as influenced by SNOBOL4. The library distributed under the GNU Library General Public License provides for recursive patterns, various iterators and user-defined patterns along with bindings for Ada, K and R C/ANSI C/C++.

• PCCTS Resources

  http://www.polhode.com/pccts.html
  The primary source of maintenance releases for the PCCTS compiler construction tool set. PCCTS is an LL(k) recursive descent parser generator with semantic predicates and backtracking. It was developed by T.J. Parr.

• PEG.js

  http://pegjs.org/
  A parser generator for JavaScript based on the parsing expression grammar formalism.

• PRECC - A PREttier Compiler-Compiler

  http://formalmethods.wikia.com/wiki/PRECC
  An infinite-lookahead parser generator for context-dependent grammars which generates ANSI C code. Specification scripts are in very extended BNF with inherited and synthetic attributes allowed. Converter for yacc scripts is available as well as documentation and related papers.

• Ragel State Machine Compiler

  http://www.colm.net/open-source/ragel/
  Compiles FSMs from regular languages into executable C, C++, Objective-C or D code. The GPL'ed software can be used to create a parser for any language that is regular. Examples include parsing Unix mailbox files and general lexing tasks.

• re2c lexer generator

  http://re2c.org/
  re2c is a tool for writing fast and flexible lexers. A re2c generated scanner is usually 2-3 times faster than a flex based scanner, and its input model is much more flexible.

• Rie

  http://www.is.titech.ac.jp/~sassa/lab/rie-e.html
  This compiler frontend generation system based on an ECLR-attributed grammar is open source, written in C and may be regarded as an extension of Yacc/Bison.

• SGLR: a Scannerless Generalized LR parser

  http://strategoxt.org/Sdf/SGLR
  Interprets parse tables generated from an SDF2 syntax definition. Scannerless means that no scanner is used to tokenize the input stream; the parse table contains enough information for both the lexical and the context-free syntax. [Open source (LGPL)]

• SLK Parser Generator

  http://www.slkpg.com/
  Produces compact and efficient LR(k) or LL(k) parsers in C, C++, C# and Java. Features include automated grammar transformations, clean EBNF syntax, optional backtracking, new LL(k) algorithms and an uncomplicated API. Under development for 25+ years, fully supported and actively being enhanced on a full-time basis.

• Soul

  http://sourceforge.net/projects/soul.berlios/
  An object oriented recursive descent parser generator framework implemented using C++ operator overloading techniques. It is inspired by Spirit but uses only a few template classes thus allowing more flexibility and fastest compilation time. [Open source, LGPL]

• Spirit C++ Parser Framework

  http://boost-spirit.com/home/
  Set of C++ libraries for parsing and output generation implemented as Domain Specific Embedded Languages (DSEL) using Expression templates and Template Meta-Programming. Enable a target grammar to be written exclusively in C++. Inline grammar specifications can mix freely with other C++ code and the generative power of C++ templates allows for immediate executability.

• Styx

  http://www.speculate.de/styx/
  A scanner and lalr(1) parser generator. It has features like automatic derivation of depth grammar, production of the abstract syntax tree including its C interface and preserves full source information to facilitate source-source translation.

• Sweet Parser

  http://www.sweetsoftware.co.nz/parser_overview.html
  A C++ parser library that generates LALR(1) parsers from EBNF grammars.

• TextTransformer

  http://texttransformer.com/
  A parsergenerator, a simple c++ interpreter and an interactive debugger combined to a visual development environment, which analyzes, evaluates, converts texts immediately.

• The LEMON Parser Generator

  http://www.hwaci.com/sw/lemon/
  Very simple LALR(1) open-source parser generator. Outputs C, claims to produce faster parsers than yacc/bison.

• The LEX & YACC Page

  http://dinosaur.compilertools.net/
  All about Lex, Yacc, Flex, and Bison: Overview, Online Documentation, Papers, Tools, Pointers

• The RDP parser generator

  http://www.dcs.rhbnc.ac.uk/research/languages/projects/rdp.html
  A parser generator which compiles attributed LL(1) grammars decorated with C semantic actions into recursive descent compilers.

• Toy Parser Generator

  http://cdsoft.fr/tpg/
  TPG is a parser generator for Python. Given a simple attributed grammar, it produces a Recursive Descent Parser.

• Turbo Pascal Lex/Yacc

  http://www.musikwissenschaft.uni-mainz.de/~ag/tply/
  A compiler generator for Turbo Pascal and compatibles. The package contains two programs, TP Lex and Yacc, which are approximately compatible with the UNIX utilities Lex and Yacc, but are written in and produce code for the Turbo Pascal programming language. Works with all recent flavours of Turbo/Borland Pascal, including Delphi and Free Pascal Compiler.

• Visual BNF

  http://www.intralogic.eu/
  An LR(1) parser by Intralogic for Backus-Naur form and generating parse tables DLL's in .NET assembly.

• Visual Parse++

  http://visual-parse.software.informer.com/
  The tool allows visual design of lexers and parsers for use in C, C++, Java, Delphi and Visual Basic applications under Windows 95/98/NT/2000, SunOS, Linux and with XML support from version 4.0.

• VisualLangLab: A Visual Parser-Generator IDE

  http://vll.java.net/
  A visual parser-generator IDE for developing parsers without any textual grammar specification (BNF/EBNF/PEG), script or code.

• Yacc++(R) and the Language Objects Library

  http://world.std.com/~compres/
  Object-oriented rewrite of Lex and Yacc for C++, with automatic AST class generation, grammar inheritance, minimal state ELR(1) and technology. (Commercial package)

• YAY - Yet Another YACC

  http://www.thinkage.ca/english/products/product-yay.shtml
  Closed-source, but free LALR(2) parser generator, accepts yacc input with some extensions.

• YooLex (Yet another Object-Oriented Lex)

  http://yoolex.sourceforge.net/
  A Flex like scanner code generator, but it generates C++ scanner classes that are re-entrant and compatible with the newer standard of C++/STL. Multiple scanner classes and instances can co-exist in a program without tweaking of macros.

Related Categories

• Home > Computers > Programming > Compilers > Compiler Construction Kits
• Home > Computers > Programming > Compilers > Attribute Grammar Systems
• Home > Computers > Programming > Metaprogramming > Source Code Generators

 

Home > Computers > Programming > Compilers > Lexer and Parser Generators

 

---

 

Thanks to DMOZ, which built a great web directory for nearly two decades and freely shared it with the web. About us