Open Source Parser Generators - Page 3

A parser generator for PEG grammars, built using Java, currently producing code for Java.

Ayauhteotl is a parser generator to parse XML files, using an XML-like syntax. The parser generator takes an XML file which describe the structure of the XML files to parse and which associates a semantic (for now in \\\\\\\"C\\\\\\\") t

A simple way to create a syntax highlighting editor for a custom language/grammar and/or create custom grammar parsers. This is a .NET project written in C#. See details here: http://acct001.com/wordpress/?p=190

Berkeley Yacc is an LALR(1) parser generator. Berkeley Yacc has been made as compatible as possible with AT&T Yacc. Berkeley Yacc has been extended to generate Python, Perl and Java code.

Blade Language Developer (or Project Blade for short) is a toolkit for creating domain specific or general programming languages. The toolkit offers a language for describing grammars, and templatable parser generator.

CppCC is an object-oriented scanner and LL(k) parser generator. It aims to replace LEX&YACC for those who write C++ applications that involve parsing.

Generate a parser at runtime from a collection of C++ objects. Concisely state a parser specification in ordinary C++ code. Learn from a parser generator with an object-oriented design.

Covra is a project to help design compilers. C3 is a tool specialized on the easy design and construction of ASTs, it is independent of the compiler compilers or parser generator that is used. It generates Java and C# code. Require JRE 1.6.0.

cson (CoffeeScript‑Object‑Notation) is a human-friendly data serialization format similar to JSON but using CoffeeScript syntax, with a library (and CLI) to parse and serialize between CSON, JSON, and JavaScript objects. Executing the method with a callback still executes the method synchronously. Requires or parses a file path of the desired format into an Object If the format option is not specified, we use the filename to detect what it should be; otherwise, we default to parsing CSON.

CSP Canonical LR(1) Parser Generator. Includes lexer and parser generator. Supports all OS. Produces code as standard ANSI C++ w/ minimal STL and usable in commercial or non-commercial purposes.

Chaperon is a LALR(1) parser, which parse structured text documents and generate XML documents as output. It includes a parser generator like yacc and a regex scaner like lex. As input use Chaperon a grammar written in XML.

Chatette is a Python-based tool for generating training datasets for Natural Language Understanding (NLU) models, particularly those used with Rasa NLU. It employs a domain-specific language to define templates, enabling the creation of diverse and extensive training examples for intent classification and entity recognition.​

Coco/S is a compiler generator that takes plain EBNF grammar files and features a SAX style call back API. It is written in Java and produces a Java Scanner (Lexer) and Parser for the language described by the input grammar. Coco/S is a branch of the 2010/11 release of Coco/R for Java. While Coco/R takes an attributed grammar file, Coco/S has a callback API. This has the advantage of a clean separation between grammar (EBNF) and Compiler/Interpreter.

RiDL is a set of tools to simplify building compilers using Nemerle. It includes a lexical analyzer generator and a parser generator.

Use multiple methods (View/SurfaceView/TextureView) to achieve efficient drawing. Analysis of xml barrage format at station B. The basic barrage accurately restores the drawing. Supports mode7 special barrage. Multi-core model optimization, efficient pre-caching mechanism. Supports multiple display effect options for real-time switching. Real-time barrage display support. Wrap Barrage Support/Sport Barrage Support. Supports custom fonts. Supports multiple barrage parameter settings. Supports multiple methods of barrage shielding. Download the latest version or grab via Maven or Gradle.

This is an implementation continuously under development of Dynamic Syntax, a word-by-word incremental semantic grammar, especially suited to dialogue. The implementation contains the following: (1) depth-first and breadth-first parsers and generators, based on hand-crafted domain-specific lexicons but cover a broad range of structures, including relatives and tense; (2) a prototype incremental dialogue system, DyLan, based on Jindigo (Skantze & Hjalmarsson, 2010), but using the Dynamic Syntax (Kempson et. al. 2001, Cann et. al. 2005) parser/generator; (3) a grammar induction module which learns DS incremental grammars from data (Eshghi et. al. 2013). For more information on DS, and this implementation, please see the files DSImp_TechReport.pdf, and README.txt included here under "files".

Elcc is an Earley parser generator written in Python and compatible with Yacc/Bison Syntax.

The Embedded XML Parser Generator is creating some C source code that parses XML files (or streams) from a user specified document structure. Generated code can support advanced features (inter-dependencies, native data types etc...).

GJSON is a Go library designed for extremely fast, allocation-free retrieval of values from JSON documents. It enables you to query nested JSON structures using one-liner dot-notation or array-based paths and includes wildcard and comparison operators. The library is optimized for speed and zero allocations, benchmarking significantly faster than Go’s standard encoding/json unmarshal approaches. It supports parsing JSON lines (newline-delimited JSON) as an array for large stream processing. GJSON also provides modifiers (such as @reverse, @flatten, @keys) which allow transformation or inspection directly via the path syntax. Because it works on raw bytes or strings, it's suited for high-performance JSON parsing without needing to define Go struct types.

MIGRATED TO GITHUB: https://github.com/patins1/ifc4emf/

Instaparse is a simple yet powerful parser generator for Clojure and ClojureScript that turns grammars written in EBNF or ABNF into executable parsers, with support for left recursion, ambiguous grammars, PEG-like lookahead, and various output formats. Instaparse supports most of the common notations for context-free grammars. For example, a popular alternative to * is to surround the term with curly braces {}, and a popular alternative to ? is to surround the term with square brackets []. Rules can be specified with =, :, :=, or ::=. Rules can optionally end with ;. Instaparse is very flexible in terms of how you use whitespace (as in Clojure, , is treated as whitespace) and you can liberally use parentheses for grouping.

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.

A Java command-line option parser generator, providing function similar to GNU Getopt, but much richer.

Top-down parser that can parse parentheses and braces and quotes but let's the rest to you. See documentation in Files/doc.