Content deleted Content added
m Clean up duplicate template arguments using findargdups |
m →Variants: HTTP to HTTPS for SourceForge |
||
| (41 intermediate revisions by 32 users not shown) | |||
Line 4:
{{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 [[
The most common type of compiler-compiler is
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
== Variants ==
Line 21:
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.
Line 27:
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 [
===Metacompilers===
{{blockquote|Metacompilers reduce the task of writing compilers by automating the aspects that are the same regardless of the
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.
Line 41:
====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 [[
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.
Line 51:
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
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"/>
Line 66:
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
Many similar systems immediately followed.{{citation needed|date=May 2020}}
Line 78:
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
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.
Line 92:
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]].
==Schorre metalanguages==
Line 103:
A syntax equation:
<pre><name> = <body>;</pre>
is a compiled ''test'' function returning ''success'' or ''failure''.
Defining a programming language analytically top down is natural. For example, a program could be defined as:
Line 137:
{{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
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
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
* '''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.
Line 160:
...</pre>
The code to process a given [[Tree (data structure)|tree]] included the features of a general purpose programming language, plus a form: <stuff>, 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 ().
<pre> expr_gen(ADD[expr_gen(x),expr_gen(y)]) =>
<AR + (x*16)+y;>
Line 177:
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.
<pre>
(x)=> return load(getreg(), x);
Line 186:
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
*
* [[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]]
Line 226:
== References and notes ==
{{
<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="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
<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="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="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>▼
<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="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="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="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="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="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
<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="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="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=George>George J. E. (1967a). Syntax Analyzer, Recognizer, Parser and Semantic interpretation System, Stanford Linear Accelerator Center, 15 November 1967.</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="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>
▲<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>
}}
Line 256 ⟶ 272:
== 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}}
| |||