Editing Compiler-compiler

{{Short description|Program that generates parsers or compilers}}
{{Distinguish|self-hosting compiler|source-to-source compiler}}
{{more citations needed|date=October 2015}}
{{Use dmy dates|date=January 2020|cs1-dates=y}}

In [[computer science]], a '''compiler-compiler''' or '''compiler generator''' is a programming tool that creates a [[Parsing#Computer_languages|parser]], [[interpreter (computer software)|interpreter]], or [[compiler]] from some form of formal description of a [[programming language]] and machine.

The most common type of compiler-compiler is called a '''parser generator'''.<ref>{{cite book |url=https://www.worldcat.org/oclc/70775643 |title=Compilers : principles, techniques, & tools |date=2007 |others=Alfred V. Aho, Monica S. Lam, Ravi Sethi, Jeffrey D. Ullman, Alfred V. Aho |isbn=978-0-321-48681-3 |edition=Second |location=Boston |page=287 |oclc=70775643}}</ref> It handles only [[syntactic analysis]].

A formal description of a language is usually a [[formal grammar|grammar]] used as an input to a parser generator. It often resembles [[Backus–Naur form]] (BNF), [[extended Backus–Naur form]] (EBNF), or has its own syntax. Grammar files describe a [[Syntax (programming languages)|syntax]] of a generated compiler's target programming language and actions that should be taken against its specific constructs.

[[Source code]] for a parser of the programming language is returned as the parser generator's output. This source code can then be compiled into a parser, which may be either standalone or embedded. The compiled parser then accepts the source code of the target programming language as an input and performs an action or outputs an [[abstract syntax tree]] (AST).

Parser generators do not handle the [[Semantics (computer science)|semantics]] of the AST, or the [[Code generation (compiler)|generation of machine code]] for the target machine.<ref name="name">"A Syntax Directed Compiler for ALGOL 60" Edgar T. Irons, Communications of the ACM Volume 4 Issue 1, Jan. 1961.</ref>

A '''metacompiler''' is a software development tool used mainly in the construction of [[compiler]]s, [[Translator (computing)|translators]], and [[interpreter (computing)|interpreters]] for other programming languages.<ref name="McGraw"/> The input to a metacompiler is a [[computer program]] written in a [[Domain-specific language|specialized]] programming [[metalanguage]] designed mainly for the purpose of constructing compilers.<ref name="McGraw"/><ref name="CWIC" /> The language of the compiler produced is called the object language. The minimal input producing a compiler is a [[Metaprogramming|metaprogram]] specifying the object language grammar and [[Semantics (computer science)|semantic]] transformations into an [[object program]].<ref name="CWIC" /><ref name="TMETA" />

== Variants ==
A typical parser generator associates executable code with each of the rules of the grammar that should be executed when these rules are applied by the parser. These pieces of code are sometimes referred to as semantic action routines since they define the semantics of the syntactic structure that is analyzed by the parser. Depending upon the type of parser that should be generated, these routines may construct a [[parse tree]] (or [[abstract syntax tree]]), or generate executable code directly.

One of the earliest (1964), surprisingly powerful, versions of compiler-compilers is [[META II]], which accepted an analytical grammar with output facilities [[Code generation (compiler)|that produce stack machine]] code, and is able to compile its own source code and other languages.

Among the earliest programs of the original [[Unix]] versions being built at [[Bell Labs]] was the two-part [[lex (software)|lex]] and [[yacc]] system, which was normally used to output [[C programming language]] code, but had a flexible output system that could be used for everything from programming languages to text file conversion. Their modern [[GNU Project|GNU]] versions are [[Flex (lexical analyser generator)|flex]] and [[GNU Bison|bison]].

Some experimental compiler-compilers take as input a formal description of programming language semantics, typically using [[denotational semantics]]. This approach is often called 'semantics-based compiling', and was pioneered by [[Peter Mosses]]' Semantic Implementation System (SIS) in 1978.<ref>Peter Mosses, "SIS: A Compiler-Generator System Using Denotational Semantics," Report 78-4-3, Dept. of Computer Science, University of Aarhus, Denmark, June 1978</ref> However, both the generated compiler and the code it produced were inefficient in time and space. No production compilers are currently built in this way, but research continues.

The Production Quality Compiler-Compiler ([[PQCC]]) project at [[Carnegie Mellon University]] does not formalize semantics, but does have a semi-formal framework for machine description.

Compiler-compilers exist in many flavors, including bottom-up rewrite machine generators (see [http://jburg.sourceforge.net/ JBurg]) used to tile syntax trees according to a rewrite grammar for code generation, and [[attribute grammar]] parser generators (e.g. [[ANTLR]] can be used for simultaneous type checking, constant propagation, and more during the parsing stage).

===Metacompilers===
{{blockquote|Metacompilers reduce the task of writing compilers by automating the aspects that are the same regardless of the object language. This makes possible the design of [[domain-specific language]]s which are appropriate to the specification of a particular problem. A metacompiler reduces the cost of producing [[Translator (computing)|translator]]s for such [[domain-specific language|domain-specific]] object languages to a point where it becomes economically feasible to include in the solution of a problem a [[domain-specific language]] design.<ref name="CWIC" />}}

As a metacompiler's [[metalanguage]] will usually be a powerful string and symbol processing language, they often have strong applications for general-purpose applications, including generating a wide range of other software engineering and analysis tools.<ref name="CWIC" /><ref name="bayfront" />

Besides being useful for [[domain-specific language]] development, a metacompiler is a prime example of a domain-specific language, designed for the domain of compiler writing.

A metacompiler is a [[Metaprogramming|metaprogram]] ''usually written in its own metalanguage'' or an existing computer programming language. The process of a metacompiler, written in its own metalanguage, compiling itself is equivalent to [[History of compiler construction#Self-hosting compilers|self-hosting compiler]]. Most common compilers written today are self-hosting compilers. Self-hosting is a powerful tool, of many metacompilers, allowing the easy extension of their own metaprogramming metalanguage. The feature that separates a metacompiler apart from other compiler compilers is that it takes as input a specialized [[metaprogramming]] language that describes all aspects of the compiler's operation. A metaprogram produced by a metacompiler is as complete a program as a [[Computer program|program]] written in [[C++]], [[BASIC]] or any other general [[programming language]]. The metaprogramming [[metalanguage]] is a powerful attribute allowing easier development of computer programming languages and other computer tools. Command line processors, text string transforming and analysis are easily coded using metaprogramming metalanguages of metacompilers.

A full featured development package includes a [[Linker (computing)|linker]] and a [[Run time (program lifecycle phase)|run time]] support [[Library (computing)|library]]. Usually, a machine-oriented [[system programming language]], such as [[C (programming language)|C]] or C++, is needed to write the support library. A library consisting of support functions needed for the compiling process usually completes the full metacompiler package.

====The meaning of metacompiler====
In computer science, the prefix ''[[Meta (prefix)#Epistemology|meta]]'' is commonly used to mean ''about (its own category)''. For example, [[metadata]] are data that describe other data. A language that is used to describe other languages is a [[metalanguage]]. Meta may also mean [[Meta (prefix)|''on a higher level of abstraction'']]. A [[metalanguage]] operates on a higher level of abstraction in order to describe properties of a language. [[Backus–Naur form]] (BNF) is a formal [[metalanguage]] originally used to define [[ALGOL 60]]. BNF is a weak [[metalanguage]], for it describes only the [[syntax]] and says nothing about the [[semantics]] or meaning. Metaprogramming is the writing of [[computer program]]s with the ability to treat [[Computer program|program]]s as their data. A metacompiler takes as input a [[metaprogramming|metaprogram]] written in a [[metalanguage|specialized metalanguages]] (a higher level abstraction) specifically designed for the purpose of metaprogramming.<ref name="CWIC" /><ref name="TMETA" /> The output is an executable object program.

An analogy can be drawn: That as a ''C++'' compiler takes as input a ''C++'' programming language program, a ''meta''compiler takes as input a [[metaprogramming|''meta''programming]] [[metalanguage]] program.

===Forth metacompiler===
{{Tone|section|date=August 2015}}
Many advocates of the language [[Forth (programming language)|Forth]] call the process of creating a new implementation of Forth a meta-compilation and that it constitutes a metacompiler. The Forth definition of metacompiler is:
:"A metacompiler is a compiler which processes its own source code, resulting in an executable version of itself."
This Forth use of the term metacompiler is disputed in mainstream computer science. See [[Forth (programming language)#Self-compilation and cross compilation|Forth (programming language)]] and [[History of compiler construction#Forth|History of compiler construction]]. The actual Forth process of compiling itself is a combination of a Forth being a [[History of compiler construction#Self-hosting compilers|self-hosting]] [[extensible programming]] language and sometimes [[History of compiler construction#Cross compilation|cross compilation]], long established terminology in computer science. Metacompilers are a general compiler writing system. Besides the Forth metacompiler concept being indistinguishable from self-hosting and extensible language. The actual process acts at a lower level defining a minimum subset of forth ''words'', that can be used to define additional forth words, A full Forth implementation can then be defined from the base set. This sounds like a bootstrap process. The problem is that almost every general purpose language compiler also fits the Forth metacompiler description.
: When (self-hosting compiler) X processes its own source code, resulting in an executable version of itself, X is a metacompiler.
Just replace X with any common language, C, C++, [[Java (programming language)|Java]], [[Pascal (programming language)|Pascal]], [[COBOL]], [[Fortran]], [[Ada (programming language)|Ada]], [[Modula-2]], etc. And X would be a metacompiler according to the Forth usage of metacompiler. A metacompiler operates at an abstraction level above the compiler it compiles. It only operates at the same (self-hosting compiler) level when compiling itself. One has to see the problem with this definition of metacompiler. It can be applied to most any language.

However, on examining the concept of programming in Forth, adding new words to the dictionary, extending the language in this way is metaprogramming. It is this metaprogramming in Forth that makes it a metacompiler.

Programming in Forth is adding new words to the language. Changing the language in this way is [[metaprogramming]]. Forth is a metacompiler, because Forth is a language specifically designed for metaprogramming. Programming in Forth is extending Forth adding words to the Forth vocabulary creates a new Forth [[Dialect (computing)|dialect]]. Forth is a specialized metacompiler for Forth language dialects.

==History==
Design of the original compiler-compiler was started by [[Tony Brooker]] and Derrick Morris in 1959, with initial testing beginning in March 1962.<ref>{{Cite web |last=Lavington |first=Simon |date=April 2016 |title=Tony Brooker and the Atlas Compiler Compiler |url=http://curation.cs.manchester.ac.uk/atlas/elearn.cs.man.ac.uk/_atlas/docs/Tony%20Brooker%20and%20the%20Atlas%20Compiler%20Compiler.pdf |url-status=live |access-date=2023-09-29 |archive-date=2023-03-26  |archive-url=https://web.archive.org/web/20230326214708/http://curation.cs.manchester.ac.uk/atlas/elearn.cs.man.ac.uk/_atlas/docs/Tony%20Brooker%20and%20the%20Atlas%20Compiler%20Compiler.pdf }}</ref> The Brooker Morris Compiler Compiler (BMCC) was used to create compilers for the new [[Atlas (computer)|Atlas]] computer at the [[University of Manchester]], for several languages: [[Mercury Autocode]], Extended Mercury Autocode, [[Atlas Autocode]], [[ALGOL 60]] and ASA [[Fortran]]. At roughly the same time, related work was being done by E. T. (Ned) Irons at Princeton, and Alick Glennie at the Atomic Weapons Research Establishment at Aldermaston whose "Syntax Machine" paper (declassified in 1977) inspired the META series of translator writing systems mentioned below.

The early history of metacompilers is closely tied with the history of SIG/PLAN Working group 1 on Syntax Driven Compilers. The group was started primarily through the effort of Howard Metcalfe in the Los Angeles area.<ref name="Metcalfe1"/> In the fall of 1962, Howard Metcalfe designed two compiler-writing interpreters. One used a bottom-to-top analysis technique based on a method described by Ledley and Wilson.<ref name="Ledleyl"/> The other used a top-to-bottom approach based on work by Glennie to generate random English sentences from a context-free grammar.<ref name="Glenniel"/>

At the same time, Val Schorre described two "meta machines", one generative and one analytic. The generative machine was implemented and produced random algebraic expressions. Meta I the first metacompiler was implemented by Schorre on an IBM 1401 at UCLA in January 1963. His original interpreters and metamachines were written directly in a pseudo-machine language. [[META II]], however, was written in a higher-level metalanguage able to describe its own compilation into the pseudo-machine language.<ref name="METAII"/><ref name="SMALGOL"/><ref name="META1"/>

Lee Schmidt at Bolt, Beranek, and Newman wrote a metacompiler in March 1963 that utilized a CRT display on the time-sharing PDP-l.<ref name="Schmidt1"/> This compiler produced actual machine code rather than interpretive code and was partially bootstrapped from Meta I.{{citation needed|date=May 2020}}

Schorre bootstrapped Meta II from Meta I during the spring of 1963. The paper on the refined metacompiler system presented at the 1964 Philadelphia ACM conference is the first paper on a metacompiler available as a general reference. The syntax and implementation technique of Schorre's system laid the foundation for most of the systems that followed. The system was implemented on a small 1401, and was used to implement a small [[ALGOL]]-like language.{{citation needed|date=May 2020}}

Many similar systems immediately followed.{{citation needed|date=May 2020}}

Roger Rutman of [[Aptiv|AC Delco]]<!-- Not the same firm as current brand ACDelco. --> developed and implemented LOGIK, a language for logical design simulation, on the IBM 7090 in January 1964.<ref name="Rutman1"/> This compiler used an algorithm that produced efficient code for Boolean expressions.{{citation needed|date=May 2020}}

Another paper in the 1964 ACM proceedings describes [http://dl.acm.org/citation.cfm?id=808898 Meta III], developed by [http://www.peacham.com/ Schneider] and Johnson at UCLA for the IBM 7090.<ref name="Schneiderl"/> Meta III represents an attempt to produce efficient machine code, for a large class of languages. Meta III was implemented completely in assembly language. Two compilers were written in Meta III, CODOL, a compiler-writing demonstration compiler, and PUREGOL, a dialect of ALGOL 60. (It was pure gall to call it ALGOL).

Late in 1964, Lee Schmidt bootstrapped the metacompiler EQGEN, from the PDP-l to the Beckman 420. EQGEN was a logic equation generating language.

In 1964, System Development Corporation began a major effort in the development of metacompilers. This effort includes powerful metacompilers, Bookl, and Book2 written in [[Lisp (programming language)|Lisp]] which have extensive tree-searching and backup ability. An outgrowth of one of the [[AN/FSQ-32|Q-32]] systems at SDC is Meta 5.<ref name=Oppenheim/> The Meta 5 system incorporates backup of the input stream and enough other facilities to parse any context-sensitive language. This system was successfully released to a wide number of users and had many string-manipulation applications other than compiling. It has many elaborate push-down stacks, attribute setting and testing facilities, and output mechanisms. That Meta 5 successfully translates [[JOVIAL]] programs to [[PL/I]] programs demonstrates its power and flexibility.

Robert McClure at [[Texas Instruments]] invented a compiler-compiler called [[TMG (language)|TMG]] (presented in 1965). TMG was used to create early compilers for programming languages like [[B (programming language)|B]], [[PL/I]] and [[ALTRAN]]. Together with metacompiler of Val Schorre, it was an early inspiration for the last chapter of [[Donald Knuth]]'s ''[[The Art of Computer Programming]]''.<ref>{{cite conference |conference=International Conference on Attribute Grammars and Their Applications| first=Donald |last=Knuth |title=The genesis of attribute grammars |url=https://www.dcs.warwick.ac.uk/~sk/cs325/gag.pdf |location=New York |book-title=Proceedings of the International Conference on Attribute Grammars and Their Applications (Paris, France) |volume=461 |pages=1–12 |editor=P. Deransart |editor2=M. Jourdan |publisher=Springer-Verlag |year=1990 |doi=10.1007/3-540-53101-7_1 |isbn=978-3-540-53101-2 |citeseerx=10.1.1.105.5365 |series=Lecture Notes in Computer Science |access-date=2020-02-06  |archive-date=2020-11-23  |archive-url=https://web.archive.org/web/20201123154647/https://www.dcs.warwick.ac.uk/~sk/cs325/gag.pdf |url-status=live }}</ref>

The LOT system was developed during 1966 at Stanford Research Institute and was modeled very closely after Meta II.<ref name="Kirkleyl"/> It had new special-purpose constructs allowing it to generate a compiler which could in turn, compile a subset of PL/I. This system had extensive statistic-gathering facilities and was used to study the characteristics of top-down analysis.

SIMPLE is a specialized translator system designed to aid the writing of pre-processors for PL/I, SIMPLE, written in PL/I, is composed of three components: An executive, a syntax analyzer and a semantic constructor.<ref name="George"/>

The [[TREE-META]] compiler was developed at Stanford Research Institute in Menlo Park, California. April 1968. The early metacompiler history is well documented in the [http://bitsavers.informatik.uni-stuttgart.de/pdf/sri/arc/rulifson/A_Tree_Meta_For_The_XDS_940_Appendix_D_Apr68.pdf TREE META manual.] TREE META paralleled some of the SDC developments. Unlike earlier metacompilers it separated the semantics processing from the syntax processing. The syntax rules contained [[Tree (data structure)|tree]] building operations that combined recognized language elements with tree nodes. The tree structure representation of the input was then processed by a simple form of unparse rules. The unparse rules used node recognition and attribute testing that when matched resulted in the associated action being performed. In addition like tree element could also be tested in an unparse rule. Unparse rules were also a recursive language being able to call unparse rules passing elements of thee tree before the action of the unparse rule was performed.

The concept of the metamachine originally put forth by Glennie is so simple that three hardware versions have been designed and one actually implemented. The latter at Washington University in St. Louis. This machine was built from macro-modular components and has for instructions the codes described by Schorre.

CWIC (Compiler for Writing and Implementing Compilers) is the last known Schorre metacompiler. It was developed at Systems Development Corporation by Erwin Book, Dewey Val Schorre and Steven J. Sherman With the full power of (lisp 2) a list processing language optimizing algorithms could operate on syntax generated lists and trees before code generation. CWIC also had a symbol table built into the language.

With the resurgence of domain-specific languages and the need for parser generators which are easy to use, easy to understand, and easy to maintain, metacompilers are becoming a valuable tool for advanced software engineering projects.

Other examples of parser generators in the yacc vein are [[ANTLR]], [[Coco/R]],<ref name="Rechenberg-Mössenböck_1985"/> CUP,{{Citation needed|date=March 2012}} [[GNU Bison]], Eli,<ref>{{cite journal|doi=10.1145/129630.129637 |title=Eli: A complete, flexible compiler construction system |year=1992 |last1=Gray |first1=Robert W. |last2=Levi |first2=Steven P. |last3=Heuring |first3=Vincent P. |last4=Sloane |first4=Anthony M. |last5=Waite |first5=William M. |journal=Communications of the ACM |volume=35 |issue=2 |pages=121–130 |s2cid=5121773 |doi-access=free }}</ref> FSL,{{Citation needed|date=March 2012}} [[SableCC]], SID (Syntax Improving Device),<ref>{{cite journal|doi=10.1093/comjnl/11.1.31 |doi-access=free |title=A syntax improving program |year=1968 |last1=Foster |first1=J. M. |journal=The Computer Journal |volume=11 |pages=31–34 }}</ref> and [[JavaCC]]. While useful, pure parser generators only address the parsing part of the problem of building a compiler. Tools with broader scope, such as [[PQCC]], [[Coco/R]] and [[DMS Software Reengineering Toolkit]] provide considerable support for more difficult post-parsing activities such as semantic analysis, code optimization and generation.

==Schorre metalanguages==
The earliest Schorre metacompilers, META I and META II, were developed by D. Val Schorre at UCLA. Other Schorre based metacompilers followed. Each adding improvements to language analysis and/or code generation.

In programming it is common to use the programming language name to refer to both the compiler and the programming language, the context distinguishing the meaning. A C++ program is compiled using a C++ compiler. That also applies in the following. For example, META II is both the compiler and the language.
 
The metalanguages in the Schorre line of metacompilers are functional programming languages that use top down grammar analyzing syntax equations having embedded output transformation constructs.

A syntax equation:
<pre><name> = <body>;</pre>
is a compiled ''test'' function returning ''success'' or ''failure''. <name> is the function name. <body> is a form of logical expression consisting of tests that may be grouped, have alternates, and output productions. A ''test'' is like a ''bool'' in other languages, ''success'' being ''true'' and ''failure'' being ''false''.

Defining a programming language analytically top down is natural. For example, a program could be defined as:
<pre>
 program = $declaration;
</pre>
Defining a program as a sequence of zero or more declaration(s).

In the Schorre META '''''X''''' languages there is a driving rule. The program rule above is an example of a driving rule. The program rule is a ''test'' function that calls declaration, a ''test'' rule, that returns ''success'' or ''failure''. The $ loop operator repeatedly calling declaration until ''failure'' is returned. The $ operator is always successful, even when there are zero declaration. Above program would always return success. (In CWIC a long fail can bypass declaration. A long-fail is part of the backtracking system of CWIC)

The character sets of these early compilers were limited. The character '''/''' was used for the alternant (or) operator. "A or B" is written as A / B. Parentheses ( ) are used for grouping.
 A (B / C)
Describes a construct of A followed by B or C. As a boolean expression it would be
 A ''and'' (B ''or'' C)
A sequence X Y has an implied X '''and''' Y meaning. '''( )''' are grouping and '''/''' the '''or''' operator. The order of evaluation is always left to right as an input character sequence is being specified by the ordering of the tests.

Special operator words whose first character is a "." are used for clarity. .EMPTY is used as the last alternate when no previous alternant need be present.
 X (A / B / .EMPTY)
Indicates that X is optionally followed by A '''or''' B. This is a specific characteristic of these metalanguages being programming languages. Backtracking is avoided by the above. Other compiler constructor systems may have declared the three possible sequences and left it up to the parser to figure it out.

The characteristics of the metaprogramming metalanguages above are common to all Schorre metacompilers and those derived from them.

===META I===
META I was a hand compiled metacompiler used to compile META II. Little else is known of META I except that the initial compilation of META II produced nearly identical code to that of the hand coded META I compiler.

===META II===
{{main|META II}}
Each rule consists optionally of tests, operators, and output productions. A rule attempts to match some part of the input program source character stream returning success or failure. On success the input is advanced over matched characters. On failure the input is not advanced.

Output productions produced a form of assembly code directly from a syntax rule.

===TREE-META===
{{main|TREE-META}}

TREE-META introduced tree building operators ''':'''<''node_name''> and '''['''<''number''>''']''' moving the output production transforms to unparsed rules. The tree building operators were used in the grammar rules directly transforming the input into an [[abstract syntax tree]]. Unparse rules are also test functions that matched tree patterns. Unparse rules are called from a grammar rule when an abstract syntax tree is to be transformed into output code. The building of an abstract syntax tree and unparse rules allowed local optimizations to be performed by analyzing the parse tree.

Moving of output productions to the unparse rules made a clear separation of grammar analysis and code production. This made the programming easier to read and understand.

===CWIC===
In 1968–1970, Erwin Book, Dewey Val Schorre, and Steven J. Sherman developed CWIC.<ref name="CWIC" /> (Compiler for Writing and Implementing Compilers) at [[System Development Corporation]] [http://special.lib.umn.edu/findaid/xml/cbi00090-098.xml#series6 Charles Babbage Institute Center for the History of Information Technology (Box 12, folder 21)],

CWIC is a compiler development system composed of three special-purpose, domain specific, languages, each intended to permit the description of certain aspects of translation in a straight forward manner. The syntax language is used to describe the recognition of source text and the construction from it to an intermediate [[Tree (data structure)|tree]] structure. The generator language is used to describe the transformation of the tree into appropriate object language.

The syntax language follows Dewey Val Schorre's previous line of metacompilers. It most resembles TREE-META having [[Tree (data structure)|tree]] building operators in the syntax language. The unparse rules of TREE-META are extended to work with the object based generator language based on [[LISP 2]].

CWIC includes three languages:
* '''Syntax''': Transforms the source program input, into list structures using grammar transformation formula. A parsed expression structure is passed to a generator by placement of a generator call in a rule. A [[Tree (data structure)|tree]] is represented by a list whose first element is a node object. The language has operators, '''<''' and '''>''', specifically for making lists. The colon ''':''' operator is used to create node objects. ''':ADD''' creates an ADD node. The exclamation '''!''' operator combines a number of parsed entries with a node to make a tree. Trees created by syntax rules are passed to generator functions, returning success or failure. The syntax language is very close to TREE-META. Both use a colon to create a node. CWIC's tree building exclamation !<number> functions the same as TREE-META's [<number>]. 
* '''Generator''': a named series of transforming rules, each consisting of an unparse, pattern matching, rule. and an output production written in a LISP 2 like language. the translation was to IBM 360 binary machine code. Other facilities of the generator language generalized output.<ref name="CWIC" />
* '''[[MOL-360]]''': an independent [[system programming language|mid level implementation language]] for the IBM System/360 family of computers developed in 1968 and used for writing the underlying support library.

==== Generators language ====
Generators Language had semantics similar to [[Lisp (programming language)|Lisp]]. The parse [[Tree (data structure)|tree]] was thought of as a recursive list. The general form of a Generator Language function is:
<pre>  function-name(first-unparse_rule) =&gt; first-production_code_generator
           (second-unparse_rule) =&gt; second-production_code_generator
           (third-unparse_rule) =&gt; third-production_code_generator
               ...</pre>
The code to process a given [[Tree (data structure)|tree]] included the features of a general purpose programming language, plus a form: &lt;stuff&gt;, which would emit (stuff) onto the output file. 
A generator call may be used in the unparse_rule. The generator is passed the element of unparse_rule pattern in which it is placed and its return values are listed in (). For example:
<pre>  expr_gen(ADD[expr_gen(x),expr_gen(y)]) =&gt;
                                &lt;AR + (x*16)+y;&gt;
                                releasereg(y);
                                return x;
               (SUB[expr_gen(x),expr_gen(y)])=&gt;
                                &lt;SR + (x*16)+y;&gt;
                                releasereg(y);
                                return x;
               (MUL[expr_gen(x),expr_gen(y)])=&gt;
                              .
                              .
                              .
               (x)=&gt;     r1 = getreg();
                            load(r1, x);
                            return r1;
...</pre>
That is, if the parse [[Tree (data structure)|tree]] looks like (ADD[<something1>,<something2>]), expr_gen(x) would be called with <something1> and return x. A variable in the unparse rule is a local variable that can be used in the production_code_generator. expr_gen(y) is called with <something2> and returns y. Here is a generator call in an unparse rule is passed the element in the position it occupies. Hopefully in the above x and y will be registers on return. The last transforms is intended to load an atomic into a register and return the register. The first production would be used to generate the 360 "AR" (Add Register) instruction with the appropriate values in general registers. The above example is only a part of a generator. Every generator expression evaluates to a value that con then be further processed. The last transform could just as well have been written as:
<pre>
               (x)=&gt;     return load(getreg(), x);
</pre>
In this case load returns its first parameter, the register returned by getreg(). the functions load and getreg are other CWIC generators.

==== CWIC addressed [[domain-specific language]]s before the term [[domain-specific language]] existed ====
From the authors of CWIC:
 
"A metacompiler assists the task of compiler-building by automating its non creative aspects, those aspects that are the same regardless of the language which the produced compiler is to translate. This makes possible the design of languages which are appropriate to the specification of a particular problem. It reduces the cost of producing processors for such languages to a point where it becomes economically feasible to begin the solution of a problem with language design."<ref name="CWIC" />

==Examples==
{{See also|Comparison of parser generators}}
* [[ANTLR]]
* [[GNU Bison]]
* [[Coco/R]], Coco-2<ref name="Rechenberg-Mössenböck_1985"/>
* Copper <ref>{{Cite web |title=Copper {{!}} Minnesota Extensible Language Tools Group |url=https://melt.cs.umn.edu/copper/ |access-date=2025-03-25 |website=melt.cs.umn.edu}}</ref>
* [[DMS Software Reengineering Toolkit]], a program transformation system with parser generators
* Epsilon Grammar Studio
* [[Lemon (parser generator)|Lemon]] parser generator
* LRSTAR: LR(*) parser generator
* [[META II]]
* [[Parboiled (Java)|parboiled]], a Java library for building parsers.
* [[Packrat parser]]
* [[PQCC]], a compiler-compiler that is more than a parser generator.
* Syntax Improving Device (SID)
* [[SYNTAX]], an integrated toolset for compiler construction.
* tacc - The Alternative Compiler Compiler  <ref>{{Cite web |url=http://legomatrix.com/tacc/tacc.htm |access-date=2025-03-25 |website=legomatrix.com}}</ref>
* [[TREE-META]]
* [[Yacc]]
* [[Xtext]]
* [[XPL]]
* [[JavaCC]]

== See also ==
* [[Parsing expression grammar]]
* [[LL parser]]
* [[LR parser]]
* [[Simple LR parser]]
* [[LALR parser]]
* [[GLR parser]]
* [[Domain analysis]]
* [[Domain-specific language]]
* [[History of compiler construction]]
** [[History of compiler construction#Self-hosting compilers]]
* [[Metacompilation]]
* [[Program transformation]]

== References and notes ==
{{reflist|refs=

<ref name="bayfront">Neighbors, J. M. [http://www.bayfronttechnologies.com/l02draco.htm#diss80 ''Software Construction using Components''] {{Webarchive|url=https://web.archive.org/web/20180318034736/http://www.bayfronttechnologies.com/l02draco.htm#diss80 |date=2018-03-18}}. Technical Report 160, Department of Information and Computer Sciences, University of California, Irvine, 1980.</ref>

<ref name="CWIC">{{cite journal|last=Book|first=Erwin|author2=Dewey Val Schorre |author3=Steven J. Sherman |title=The CWIC/36O system, a compiler for writing and implementing compilers|journal=ACM SIGPLAN Notices|date=June 1970|volume=5|issue=6|pages=11–29|doi=10.1145/954344.954345|s2cid=44675240}}</ref>

<ref name="Glenniel">A. E. Glennie, "On the Syntax Machine and the Construction of a Universal Computer", Technical Report Number 2, AD 240–512, Computation Center, Carnegie Institute of Technology, 1960.</ref>

<ref name="Kirkleyl">Charles R. Kirkley and Johns F. Rulifson, "The LOT System of Syntax Directed Compiling", Stanford Research Institute Internal Report ISR 187531-139, 1966.</ref>
<ref name=George>George J. E. (1967a). Syntax Analyzer, Recognizer, Parser and Semantic interpretation System, Stanford Linear Accelerator Center, 15 November 1967.</ref>

<ref name="Ledleyl">Robert Ledley and J. B. Wilson, "Automatic Programming, Language Translation Through Syntactical Analysis", Communications of the Association for Computing Machinery, Vol. 5, No. 3 pp. 145–155, March 1962.</ref>

<ref name="McGraw">Metacompiler: (''computer science'') A compiler that is used chiefly to construct compilers for other programming languages.{{cite web |url=http://www.answers.com/topic/metacompiler |title=Sci-Tech Dictionary McGraw-Hill Dictionary of Scientific and Technical Terms, 6th edition |publisher=McGraw-Hill Companies |access-date=2018-04-07 |archive-date=2018-04-07  |archive-url=https://web.archive.org/web/20180407184214/http://www.answers.com/topic/metacompiler |url-status=live}}</ref>

<ref name="META1">Meta I is described in the paper given at the 1963 Colorado ACM conference. See SMALGOL.</ref>
<ref name="Rutman1">Roger Rutman, "LOGIK. A Syntax Directed Compiler for Computer Bit-Time Simulation", Master thesis, UCLA, August 1964.</ref>

<ref name="METAII">Schorre, D. V., ''META II a syntax-oriented compiler writing language'', Proceedings of the 1964 19th ACM National Conference, pp. 41.301-41.3011, 1964</ref>

<ref name="Metcalfe1">Howard Metcalfe, "A Parameterized Compiler Based on Mechanical Linguistics" Planning Research Corporation R-311, 1 March 1963, also in Annual Review in Automatic Programming, Vol. 4</ref>

<ref name="Oppenheim">D. Oppenheim and D. Haggerty, "META 5: A Tool to Manipulate Strings of Data", Proceedings of the 21st National Conference of the Association for Computing Machinery, 1966.</ref>

<ref name="Rechenberg-Mössenböck_1985">{{cite book |author-first1=Peter |author-last1=Rechenberg |author-link1=:de:Peter Rechenberg |author-first2=Hanspeter |author-last2=Mössenböck |author-link2=:de:Hanspeter Mössenböck |title=Ein Compiler-Generator für Mikrocomputer - Grundlagen, Anwendungen, Programmierung in Modula-2 |language=de |edition=1 |publisher=[[Carl Hanser Verlag]] |location=Munich, Germany |date=1985 |isbn=3-446-14495-1}} (NB. The book describes the construction of Coco in [[Modula-2]].)</ref>

<ref name="Schmidt1">L. O. Schmidt, "The Status Bitt ACM SegPlan "Special Interest Group on Programming Languages" Working Group 1 News Letter, 1964.</ref>

<ref name="Schneiderl">F. W. Schneider and (G. D. Johnson, "A Syntax-Directed Compiler-writing, Compiler to generate Efficient Code", Proceedings of the 19th National Conference of the Association for Computing Machinery,
1964</ref>

<ref name="SMALGOL">{{cite journal |last=Dewey |first=Val Schorre |title=A Syntax – Directed SMALGOL for the 1401 |journal=ACM National Conference, Denver, Colorado |date=1963}}</ref>

<ref name="TMETA">C. Stephen Carr, David A. Luther, Sherian Erdmann, ''The TREE-META Compiler-Compiler System: A Meta Compiler System for the Univac 1108 and General Electric 645'', University of Utah Technical Report RADC-TR-69-83.</ref>

}}

== Further reading ==
* {{cite journal |last1=Brooker |first1=R. A. |author-link=Tony Brooker |last2=MacCallum |first2=I. R. |last3=Morris |first3=D. |last4=Rohl |first4=J. S. |title=The compiler-compiler |journal=Annual Review in Automatic Programming |volume=3 |pages=229–275 |year=1963 |doi=10.1016/S0066-4138(63)80009-9 |url=https://www.chilton-computing.org.uk/acl/pdfs/ccPaper.pdf }}
* {{cite journal |last1=Brooker |first1=R .A. |author-link=Tony Brooker |last2=Morris |first2=D. |last3=Rohl |first3=J. S. |title=Experience with the Compiler Compiler |journal=Computer Journal |volume=9 |page=350 |date=February 1967 |doi=10.1093/comjnl/9.4.350 |access-date=2021-05-07 |doi-access=free |url=https://comjnl.oxfordjournals.org/content/9/4/345.full.pdf }}
* {{cite book |author-last=Napper |author-first=R. B. E |title=An Introduction To The Compiler Compiler |url=http://curation.cs.manchester.ac.uk/atlas/elearn.cs.man.ac.uk/_atlas/docs/An%20Introduction%20to%20the%20Compiler%20Compiler.pdf |date=December 1965}}
* {{cite thesis |last1=MacCallum |first1=I. R. |title=Some Aspects of the Implementation of the Compiler Compiler on ATLAS|url=http://www.chiltoncomputing.org.uk/acl/pdfs/IainsMscThesis.pdf |date=January 1963}}
* {{cite book |author-last=Johnson |author-first=Stephen C. |author-link=Stephen C. Johnson |title=Yacc—yet another compiler-compiler |id=Computer Science Technical Report 32 |publisher=[[Bell Laboratories]] |location=Murray Hill, New Jersey, USA |date=July 1975}}
* {{cite book |last1=McKeeman |first1=William M. |last2=Horning |first2=James J. |author-link2=Jim Horning |last3=Wortman |first3=David B. |title=A Compiler Generator |url=https://archive.org/details/compilergenerato00mcke |access-date=13 December 2012 |date=1970 |publisher=[[Prentice-Hall]] |location=Englewood Cliffs, New Jersey, USA |isbn=978-0-13-155077-3 |url-access=registration}}

== External links ==
* [http://curation.cs.manchester.ac.uk/atlas/elearn.cs.man.ac.uk/_atlas/docs/Tony%20Brooker%20and%20the%20Atlas%20Compiler%20Compiler.pdf Tony Brooker and the Atlas Compiler Compiler]
* [http://curation.cs.manchester.ac.uk/atlas/elearn.cs.man.ac.uk/_atlas/docs/An%20explanation%20of%20the%20Compiler%20Compiler%20listings.pdf An Explanation of the Compiler Compiler listings (1963)]
* [http://curation.cs.manchester.ac.uk/atlas/elearn.cs.man.ac.uk/_atlas/docs/Compiler%20Compiler%20source%20code Compiler Compiler source code] (starts around PDF page 182)
* [http://curation.cs.manchester.ac.uk/atlas/elearn.cs.man.ac.uk/_atlas/docs/Original%20Compiler%20Compiler%20flowcharts Original Compiler Compiler flowcharts]
* [https://web.archive.org/web/20041031031946/http://www.computer50.org/mark1/gethomas/manchester_autocodes.html Computer50.org], Brooker Autocodes
* [http://catalog.compilertools.net/ Catalog.compilertools.net] {{Webarchive|url=https://web.archive.org/web/20110813060626/http://catalog.compilertools.net/ |date=2011-08-13  }}, The Catalog of Compiler Construction Tools
* [http://labraj.uni-mb.si/lisa Labraj.uni-mb.si], Lisa
* [http://www.skenz.it/traduttori/ Skenz.it], Jflex and Cup resources {{in lang|it}}

{{Parsers}}

[[Category:Parser generators| ]]
[[Category:Parsing]]
[[Category:Compiler construction]]
[[Category:Metaprogramming]]
[[Category:Pattern matching programming languages]]
[[Category:Program transformation tools]]
[[Category:Extensible syntax programming languages]]
[[Category:Domain-specific programming languages]]
[[Category:Program analysis]]
[[Category:Software design]]
[[Category:Compiler theory]]