Grammatic -- a tool for grammar definition reuse and modularity

Grammatic is a tool for grammar definition and manipulation aimed to improve modularity and reuse of grammars and related development artifacts. It is independent from parsing technology and any other details of target system implementation. Grammatic provides a way for annotating grammars with arbitrary metadata (like associativity attributes, semantic actions or anything else). It might be used as a front-end for external tools like parser generators to make their input grammars modular and reusable. This paper describes main principles behind Grammatic and gives an overview of languages it provides and their ability to separate concerns and define reusable modules. Also it presents sketches of possible use cases for the tool.

💡 Research Summary

Grammatic is presented as a language‑agnostic front‑end tool that addresses the long‑standing problem of monolithic grammar specifications in traditional parser generators. The authors argue that most existing tools intertwine the core grammar with auxiliary information such as associativity, precedence, semantic actions, or IDE‑specific metadata, making reuse across projects or target parsers cumbersome. Grammatic’s design revolves around three core concepts: modular grammar units, a flexible annotation mechanism, and a parser‑independent plugin architecture.

A grammar is expressed as a collection of modules. Each module encapsulates a set of productions, token definitions, and symbols, and can import other modules using a namespace‑aware import statement. This import system prevents name clashes and enables the construction of a hierarchy of reusable language fragments (e.g., expression sub‑grammars, type systems, or common statement blocks). The modular approach encourages “write once, use everywhere” practices, especially in large‑scale language engineering where multiple front‑ends share a substantial core.

Grammatic introduces metadata annotations that can be attached to any grammar element (rules, tokens, symbols). An annotation is a simple key‑value pair, but the system imposes no fixed schema, allowing developers to embed parser‑generator‑specific attributes (e.g., @assoc:left, @prec:3 for ANTLR) as well as arbitrary information such as IDE code‑completion hints, documentation snippets, test‑case references, or custom validation rules. Because annotations are themselves modular, a library of reusable attribute sets can be built and shared across projects.

To reduce duplication of recurring patterns, Grammatic provides a template mechanism. Templates are parameterized grammar fragments that can declare type parameters and constraints. For instance, a binary‑operator template can be instantiated with a concrete list of operators, automatically generating the appropriate productions and associated metadata. Instantiation occurs during the preprocessing phase, and the result is emitted as a conventional BNF‑style grammar ready for downstream tools.

The parser‑independent plugin architecture decouples Grammatic from any specific parsing technology. The core DSL describes the grammar and its annotations; a set of output plugins translate this representation into the concrete syntax expected by target tools such as ANTLR, JavaCC, SableCC, or any future parser generator. Adding support for a new parser merely requires implementing a small transformation script, making Grammatic a versatile front‑end for heterogeneous toolchains.

Performance considerations are addressed by treating Grammatic as a pre‑processing step. The generated grammar is handed off to the chosen parser generator, so runtime parsing speed is unaffected. For very large module graphs, the authors provide caching and incremental build support: only modules that have changed are re‑processed, while unchanged parts are retrieved from a persistent cache, dramatically reducing build times in continuous‑integration environments.

The paper sketches several use cases: (1) educational language suites where a core language is shared between a teaching compiler and a production compiler, each adding its own annotations; (2) multi‑target compilers (JVM, JavaScript, native) that reuse a common front‑end grammar while swapping out target‑specific plugins; (3) IDE integration where the same grammar source drives syntax highlighting, auto‑completion, and documentation generation via different annotation layers.

Limitations are acknowledged. Grammatic currently focuses on static grammar transformation and does not natively support dynamic macro‑based extensions or runtime‑generated grammars. The annotation system lacks a formal schema language, so complex validation must be performed by external tools. Future work includes developing a type‑checked annotation schema, richer static analysis, and extending the plugin model to accommodate dynamic grammar features.

In summary, Grammatic offers a systematic approach to grammar reuse and modularity by separating concerns through modules, flexible metadata, and a parser‑agnostic output layer. Its design promises to simplify large‑scale language development, improve maintainability, and enable seamless integration with a variety of parsing and development tools.