Search the FAQ Archives

3 - A - B - C - D - E - F - G - H - I - J - K - L - M
N - O - P - Q - R - S - T - U - V - W - X - Y - Z
faqs.org - Internet FAQ Archives

Catalog of compilers, interpreters, and other language tools [p4of5]

( Part1 - Part2 - Part3 - Part4 - Part5 )
[ Usenet FAQs | Web FAQs | Documents | RFC Index | Forum archive ]
Archive-name: compilers/free/part4
Last-modified: 2000/02/08
Version: 10.3

See reader questions & answers on this topic! - Help others by sharing your knowledge
concurrent, parallel, and simulation languages
-------------------------------------------------------------------------------
category:	concurrent, parellel, and simulation languages
description:	This is a fairly broad category of languages.  Most of the
		implementations in this set are not good enough to be used in
		production systems.  Some are.	In addition to those listed
		below, see:
lref:		Concurrent Clean
lref:		Concurrent ML
lref:		EuLisp
lref:		Parallaxis
lref:		Maisie
lref:		uC++
lref:		MeldC
lref:		pm2
lref:		Simula 67
iref:		(Tcl) MTtcl - Multi-threaded Tcl

language:	ABCL/1 (An object-Based Concurrent Language)
package:	ABCL/1
version:	?
parts:		?
author:		Akinori Yonezawa, ABCL Group now at Department of Information
		Science, the University of Tokyo
location:	ftp://camille.is.s.u-tokyo.ac.jp/pub/abcl1/
description:	Asynchronous message passing to objects.
reference:	"ABCL: An Object-Oriented Concurrent System", Edited by
		Akinori Yonezawa, The MIT Press, 1990, (ISBN 0-262-24029-7)
restriction:	no commercial use, must return license agreement
requires:	Common Lisp
contact:	abcl@is.s.u-tokyo.ac.jp
updated:	1990/05/23

language:	ABCL ???
package:	ABCL/R2
version:	?
parts:		?
author:		masuhara@is.s.u-tokyo.ac.jp, matsu@is.s.u-tokyo.ac.jp,
		takuo@is.s.u-tokyo.ac.jp, yonezawa@is.s.u-tokyo.ac.jp
location:	ftp://camille.is.s.u-tokyo.ac.jp/pub/abclr2/
description:	ABCL/R2 is an object-oriented concurrent reflective language
		based on Hybrid Group Architecture.  As a reflective language,
		an ABCL/R2 program can dynamically control its own behavior,
		such as scheduling policy, from within user-program.  An an
		object-oriented concurrent language, this system has almost all
		functions of ABCL/1.
requires:	Common Lisp
updated:	1993/01/28

language:	ALLOY
package:	ALLOY
version:	2.0?
parts:		interpreter, documentation, examples
author:		Thanasis Mitsolides <mitsolid@cs.nyu.edu>
location:	ftp://cs.nyu.edu/pub/local/alloy/*
description:	ALLOY is a higher level parallel programming language
		appropriate for programming massively parallel computing
		systems.  It is based on a combination of ideas from
		functional, object oriented and logic programming languages.
		The result is a language that can directly support
		functional, object oriented and logic programming styles
		in a unified and controlled framework.	Evaluating modes
		support serial or parallel execution, eager or lazy
		evaluation, non-determinism or multiple solutions etc.
		ALLOY is simple as it only requires 29 primitives in all
		(half of which for Object Oriented Programming support).
ports:		sparc, ?
updated:	1991/06/11

language:	Cellang (Cellular Automata)
package:	Cellular
version:	2.0
parts:		byte-code compiler, runtime, viewer
author:		J Dana Eckart <dana@rucs.faculty.cs.runet.edu>
location:	comp.sources.unix, volume 26
description:	A system for cellular automata programming.
updated:	1993/04/03

language:	Hermes
package:	IBM Watson prototype Hermes system
version:	0.8alpha patchlevel 01
parts:		bytecode compiler, compiler(bytecode->C), runtime
author:		Andy Lowry <lowry@watson.ibm.com>
location:	ftp://software.watson.ibm.com/pub/hermes/
description:	Hermes is a very-high-level integrated language and
		system for implementation of large systems and
		distributed applications, as well as for
		general-purpose programming.  It is an imperative,
		strongly typed, process-oriented language.  Hermes
		hides distribution and heterogeneity from the
		programmer.  The programmer sees a single abstract
		machine containing processes that communicate using
		calls or sends.	 The compiler, not the programmer,
		deals with the complexity of data structure layout,
		local and remote communication, and interaction with
		the operating system.  As a result, Hermes programs are
		portable and easy to write.  Because the programming
		paradigm is simple and high level, there are many
		opportunities for optimization which are not present in
		languages which give the programmer more direct control
		over the machine.
reference:	Strom, Bacon, Goldberg, Lowry, Yellin, Yemini. Hermes: A
		 Language for Distributed Computing. Prentice-Hall, Englewood
		 Cliffs, NJ.  1991.  ISBN: O-13-389537-8.
ports:		RS6000 Sun-4 NeXT IBM-RT/bsd4.3 (Sun-3 and Convex soon)
discussion:	comp.lang.hermes
updated:	1992/03/22

language:	ICC++ (Illinois Concert C++) and CA (Concurrent Aggregates)
package:	Illinois Concert System
version:	3.0
parts:		compiler(->C++), interpreter, symbolic debugger, parallel
		runtime simulator, parallel implementation on TMC CM5,
		Cray T3D
author:		Various, concert@red-herring.cs.uiuc.edu
location:	http://www-csag.cs.uiuc.edu/projects/concert.html
description:	The Concert System incorporates global analysis for
		parallel object-oriented languages, including
		aggressive concrete type inference.  In addition, it
		include an extremely lightweight communication and
		threading library (compiler-supported).	 The
		implementation supports both a parallel C++ and
		a simple parallel object-oriented language called
		Concurrent aggregates.
conformance:	ICC++ and CA documentation available from the web site.
reference:	Andrew Chien, et. al. The Concert System -- Compiler and
		Runtime Support for Efficient Fine-Grained Concurrent
		Object-Oriented Programs, Department of Computer Science,
		University of Illinois, Urbana, Illinois, Technical
		Report UIUCDCS-R-93-1815, June 1993.
		(Others are available also)
bugs:		concert@red-herring.cs.uiuc.edu
restriction:	redistribution is restricted
announcements:	where new releases are announced
contact:	Andrew Chien   achien@cs.uiuc.edu
updated:	1995/05/07  Version 3.0
lref:		C++

language:	OCCAM 2 (A parallel, concurrent, distributed language)
package:	D7202-oc / TDS
version:	?
parts:		compiler & full toolset system
author:		INMOS Ltd.
location:	ftp://unix.hensa.ac.uk/pub/parallel/occam/compilers/
		http://www.hensa.ac.uk/parallel/occam/compilers/inmos/index.html
description:	An old version of the INMOS OCCAM compiler & toolset, made
		freely avaiable by INMOS Ltd.  OCCAM is a language for
		designed to express concurrent algorithms and their
		implementation on a network of processing components.
conformance:	The original implementation of OCCAM 2
reference:	"OCCAM 2 reference manual", INMOS ltd, Prentice-Hall
		International, ISBN 0-13-629312-3
features:	produces object code for the INMOS transputer (but see
		KROC entry)
restriction:	Research purposes only. NO support will be provided by
		INMOS Ltd.
requires:	C & occam compiler (Sun4, PC, & Transputer binaries available)
ports:		Sun3, Sun4, PC, INMOS transputer. (Most UNIXes?)
portability:	produces object code for the INMOS transputer (but see KROC
		entry)
status:		Not developed, UNSUPPORTED.
discussion:	comp.sys.transputer
contact:	Dave Beckett <djb1@ukc.ac.uk>
updated:	1-Mar-94

language:	OCCAM 2 (A parallel, concurrent, distributed language)
package:	KROC (Kent Retargetable Occam Compiler)
version:	0.1 Beta
parts:		compiler, run-time kernel, documentation
author:		David Wood, Professor Peter Welch
location:	ftp://unix.hensa.ac.uk/pub/parallel/occam/projects/occam-for-all/
		http://www.hensa.ac.uk/parallel/occam/projects/occam-for-all/kroc/
description:	KROC is a portable OCCAM compiler system that enables OCCAM to
		run on non-transputer platforms (initially SunOS/SPARC(TM)
		workstations).	KROC works by translating code produced by an
		INMOS OCCAM Toolset compiler into the native assembler for the
		target architecture and linking in a small (< 2K bytes) kernel
		that provides the process scheduling and message-passing
		functionality of the transputer micro-code.  Therefore, you
		will need an OCCAM Toolset compiler (see requires:).
features:	-initialy available as Sun4 (SunOS) binary.
		+A source release will follow.
reference:	"OCCAM 2 reference manual", INMOS ltd, Prentice-Hall
		 International, ISBN 0-13-629312-3
		"Transputer Instruction Set - A Compiler Writers Guide", INMOS
		 Ltd, Prentice-Hall, ISBN 0-13-929100-8
restriction:	?
requires:	INMOS OCCAM compiler D7202 from:
		ftp://unix.hensa.ac.uk/pub/parallel/occam/compilers/inmos/oc
ports:		Sun4 (DEC Alpha and Motorola PowerPC to follow)
portability:	Sparc processor only at present
status:		actively developed, supported
discussion:	comp.sys.transputer, <ofa-com-request@ukc.ac.uk>
contact:	Occam For All Team <ofa-bugs@ukc.ac.uk>
updated:	4-May-1995

language:	OCCAM 2 (A parallel, concurrent, distributed language)
package:	SPOC (Southampton Portable Occam Compiler)
version:	1.1
parts:		compiler(->C), run-time system, documentation, tools, examples
author:		Denis Nicole <dan@ecs.soton.ac.uk>,
		Sean Wykes <smw@ecs.soton.ac.uk>,
		Mark Debbage <md@pact.srf.ac.uk>,
		Mark Hill <mbh@pact.srf.ac.uk>
location:	ftp://ftp.ecs.soton.ac.uk/pub/occam/
		ftp://unix.hensa.ac.uk/pub/parallel/occam/compilers/
		http://www.hensa.ac.uk/parallel/occam/compilers/spoc/index.html
description:	supports the OCCAM 2 programming language.
conformance:	Full implementation of OCCAM 2
reference:	"OCCAM 2 reference manual", INMOS ltd, Prentice-Hall
		International, ISBN 0-13-629312-3
features:	The system generates ANSI-C code, implementing efficient
		portable concurrency running on a single target processor.
		Supports cross-linking with NAG Fortran-90 compiler.
restriction:	GPL'ed
requires:	C compiler, gmd compiler tools (available with compiler
		sources) (Sun4 binaries available)
ports:		Sun3, Sun4
portability:	? Should work on most UNIXes
status:		actively developed, supported
discussion:	comp.sys.transputer
contact:	Dr Denis A Nicole <dan@ecs.soton.ac.uk>
updated:	1-March-1994

language:	PCN
package:	PCN
version:	2.0
parts:		compiler?, runtime, linker, libraries, tools, debugger,
		profiler, tracer
author:		Ian Foster <foster@mcs.anl.gov>, Steve Tuecke
		<tuecke@mcs.anl.gov>, and others
location:	ftp://info.mcs.anl.gov/pub/pcn/pcn_v2.0.tar.Z
description:	PCN is a parallel programming system designed to improve
		the productivity of scientists and engineers using parallel
		computers.  It provides a simple language for specifying
		concurrent algorithms, interfaces to Fortran and C, a
		portable toolkit that allows applications to be developed
		on a workstation or small parallel computer and run
		unchanged on supercomputers, and integrated debugging and
		performance analysis tools.  PCN was developed at Argonne
		National Laboratory and the California Institute of
		Technology.  It has been used to develop a wide variety of
		applications, in areas such as climate modeling, fluid
		dynamics, computational biology, chemistry, and circuit
		simulation.
ports:		(workstation nets): Sun4, NeXT, RS/6000, SGI
		(multicomputers): iPSC/860, Touchstone DELTA
		(shared memory multiprocessors): Symmetry/Dynix
contact:	<pcn@mcs.anl.gov>
updated:	1993/02/12

language:	LOOPN
package:	LOOPN
version:	?
parts:		compiler?, simulator
author:		?
location:	ftp://ftp.utas.edu.au/departments/computer_sci*/loopn.tar.Z
description:	I wish to announce the availability of a compiler, simulator
		and associated source control for an object-oriented petri net
		language called LOOPN.	In LOOPN, a petri net is an extension
		of coloured timed petri nets.  The extension means firstly that
		token types are classes.  In other words, they consist of both
		data fields and functions, they can be declared by inheriting
		from other token types, and they can be used polymorphically.
		The object-oriented extensions also mean that module or subnet
		types are classes.  LOOPN has been developed over a period of
		about 5 years at the University of Tasmania, where it has been
		used in teaching computer simulation and the modelling of
		network protocols.  A petri net is a directed, bipartite graph;
		nodes are either places (represented by circles) or transitions
		(represented by rectangles).  A net is marked by placing tokens
		on places.  When all the places pointing to a transition (the
		input places) have a token, the net may be fired by removing a
		token from each input place and adding a token to each place
		pointed to by the transition (the output places).  Petri nets
		are used to model concurrent systems, particularly in the
		network protocol area.
contact:	Charles Lakos <charles@probitas.cs.utas.edu.au>
updated:	1992/12/20

language:	Simula
package:	Lund Simula
version:	4.07
parts:		?
author:		?
location:	ftp://rascal.ics.utexas.edu/misc/mac/programming/+_Simula/
description:	?
contact:	Lund Software House AB / Box 7056 / S-22007 Lund, Sweden
updated:	1992/05/22

language:	SR (Synchronizing Resources)
package:	sr
version:	2.0
parts:		?, documentation, tests
author:		?
location:	ftp://cs.arizona.edu/sr/
description:	SR is a language for writing concurrent programs.
		The main language constructs are resources and
		operations.  Resources encapsulate processes and
		variables they share; operations provide the primary
		mechanism for process interaction.  SR provides a novel
		integration of the mechanisms for invoking and
		servicing operations.  Consequently, all of local and
		remote procedure call, rendezvous, message passing,
		dynamic process creation, multicast, and semaphores are
		supported.
reference:	"The SR Programming Language: Concurrency in Practice",
		 by Gregory R. Andrews and Ronald A. Olsson, Benjamin/Cummings
		 Publishing Company, 1993, ISBN 0-8053-0088-0
ports:		Sun-4, Sun-3, Decstation, SGI Iris, HP PA, HP 9000/300,
		NeXT, Sequent Symmetry, DG AViiON, RS/6000, Multimax,
		Apollo, and others.
discussion:	info-sr-request@cs.arizona.edu
contact:	sr-project@cs.arizona.edu
updated:	1992/09/01

language:	UNITY
package:	MasPar Unity
version:	1.0
parts:		translator(UNITY->MPL), documentation
author:		Martin Huber, University of Karlsruhe, Germany
location:	ftp://SanFrancisco.ira.uka.de/pub/maspar/
description:	?
contact:	Lutz Prechelt <prechelt@ira.uka.de>
updated:	?

language:	UNITY
package:	HOL-UNITY
version:	2.1
parts:		verification tool
author:		?
location:	?
description:	?
contact:	Flemming Andersen <fa@tfl.dk> ?
updated:	?

Forth family languages
-------------------------------------------------------------------------------
category:	Forth family languages
description:	These are the stack-based postfix languages, usually
		interpreted, descended from the FORTH language originally
		developed for telescope control.
lref:		Postscript
iref:		(mc6809) 6809, E-Forth

language:	Forth
package:	TILE Forth
version:	2.1
parts:		interpreter
author:		Mikael Patel <mip@sectra.se>
location:	ftp tile-forth-2.1.tar.Z from a GNU archive site
description:	Forth interpreter in C; many Forth libraries
conformance:	Forth83
restriction:	shareware/GPL
ports:		unix
updated:	1991/11/13

language:	Forth
package:	cforth
version:	?
parts:		interpreter
author:		?
location:	comp.sources.unix archive volume 1
description:	?
updated:	?

language:	Forth
package:	pfe (Portable Forth Environment)
version:	0.9.14
parts:		?
author:		Dirk Zoller <whereabouts-unknown>
location:	ftp://ftp.taygeta.com/pub/Forth/Compilers/native/unix/
description:	A Forth development system that tries to be correct,
		complete, portable, usable and simple.	It doesn't try too
		hard to be fast.
conformance:	all dpANS word sets
ports:		Runs on several Unix-like operating systems and on
		MS-DOS and OS/2. Makefiles readily provided for AIX,
		FreeBSD, Linux, HP-UX, Ultrix, DOS and OS/2.
		DOS and OS/2 executables included (with EMX DOS extender).
		Written in ANSI-C using Posix extensions and termcap.
		Compiles with GNU-C and several OS-specific compilers.
restriction:	Freely Redistributable
portability:	high
updated:	1996/05/02

language:	Forth
package:	gforth
version:	0.2.1
author:		Anton Ertl
location:	ftp://prep.ai.mit.edu/pub/gnu/
		and
		http://www.complang.tuwien.ac.at/forth/gforth/gforth-0.2.1.tar.gz
description:	Gforth is a fast and portable implementation of the ANS
		Forth language. It works nicely with the Emacs editor,
		offers some nice features such as input completion and
		history and a powerful locals facility, and it even has
		(the beginnings of) a manual. Gforth employs traditional
		implementation techniques.  Gforth is distributed under
		the GNU General Public license (see COPYING).  Gforth runs
		under Unix and DOS and should not be hard to port to other
		systems supported by GCC. This version has been tested
		successfully on the following platforms: i486-unknown-linuxaout,
		i586-unknown-linux, alpha-dec-osf3.2, mips-dec-ultrix4.3,
		sparc-sun-sunos4.1.4, sparc-unknown-netbsd1.2 (configured
		with ac_cv_sizeof_long_long=0, see INSTALL),
		hppa1.1-hp-hpux9.05, hppa1.1-hp-hpux10.20, Windows 95 using
		DJGPP 2.0, and OS/2 3.0 using EMX 0.9c, the latter with manual
		help to finish compilation.
updated:	1997/01/13

language:	Forth
package:	F68K
version:	?
parts:		?
author:		?
location:	ftp://archive.umich.edu/atari/Languages/
description:	a portable Forth system for Motorola 68k computers
ports:		Atari ST/TT, Amiga, Sinclair QL and OS9
portability:	very high for 68000 based systems
contact:	Joerg Plewe <joerg.plewe@mpi-dortmund.mpg.de>
updated:	1992/12/14

language:	Forth
package:	51forth
version:	?
parts:		?
author:		Scott Gehmlich
location:	ftp giovanni/51forth.zip from [130.123.96.9] ?
description:	source and documentation for a 8051 subroutine-
		threaded forth
contact:	?
updated:	1993/04/03

language:	Forth
package:	M4th
version:	?
parts:		interpreter, kernel, editor, application (8086 assembler),
		hypertext-based documentation, decompiler
author:		Nils M. Holm <fs29@rummelplatz.uni-mannheim.de>
location:	ftp://ftp.uni-stuttgart.de/pub/systems/pc/lang/forth/m4th10.zip
description:	A small Forth implementation
ports:		MSDOS.
updated:	1994/06/28

language:	Forth
package:	ThisForth
version:	1.0.0.d
author:		Will Baden <wilbaden@netcom.com>
location:	ftp://ftp.taygeta.com/pub/Forth/Compilers/native/unix/
description:	This Forth was written to try out Standard (ANS) Forth,
		to integrate macro processing with Forth, to be able to use
		Forth in a conventional environment and to have Forth as an
		interpretive shell and scripting language for applications.
features:
		+ Integrated macro processing
		+ Input/output re-assignment 
		+ Portable implementation
		+ Easy extensibility	
		+ Pinhole optimization
requires:	M4 and an ANSI C compiler.
ports:		Macintosh, PowerMac, MIPS, SUN, SGI, 32-bit DOS
updated:	1995/02

language:	Mops
package:	Mops
version:	3.2
parts:		compiler, assembler, documentation, editor
author:		Michael Hore <mikeh@zeta.org.au>
location:	ftp://ftp.taygeta.com/pub/Forth/Compilers/native/mac/Mops/
		ftp://astro.uchicago.edu/pub/MAC/Yerk
description:	Like Yerk, Mops is descended from the ex-commercial
		object-oriented language Neon. Mops features an
		optimizing native-code compiler; it is much faster
		than Yerk, but less compatible with Neon. Mops
		includes extensions such as multiple inheritance.
conformance:	Includes a prologue for ANSI Forth.
features:	+ classes for all the standard Mac interface items
		+ can produce double-clickable applications
		+ extremely fast edit-compile cycle
		+ includes a PowerPC assembler
ports:		Macintosh
updated:	1998/07

language:	Kevo (Forth-like)
package:	kevo
version:	0.9b6
parts:		interpreter, demo programs, user's guide, papers
author:		Antero Taivalsaari <tsaari@cs.uta.fi>
location:	ftp://cs.uta.fi/pub/kevo/
description:	Kevo is a prototype-based object-oriented language for
		Macintosh Kevo features a unique prototype-based object model
		(which is based neither on classes nor Self-style delegation),
		multitasking (both preemptive and cooperative), dynamic memory
		management, and an icon-based object browser and editor modeled
		loosely after Mac Finder. Kevo has been built around a portable
		threaded code interpreter, and is syntactically a close
		derivative of Forth.
ports:		Macintosh
contact:	kevo-interest@ursamajor.uvic.ca
updated:	1993/05/18

language:	Yerk
package:	Yerk
version:	3.68
parts:		interpreter, assembler, documentation, decompiler
author:		Bob Loewenstein
location:	ftp://astro.uchicago.edu/pub/astro/MAC/Yerk
description:	Yerk is an object oriented derivative of Forth.
		It was originally known as Neon, developed and sold
		as a product by Kriya Systems from 1985 to 1989.
		The language features many system classes and objects for mac
		interfacing:
		windows, controls, events, files, arrays, ordered-columns,
		menus,hierarchical and popup menus, handles, strings,
		mouse,quickdraw, modal dialogs, offscreen bitmaps, vbl,
		time manager, etc.
features:	+ defaulted early binding, with ability to late bind in almost any circumstance
		+ objects may be instantiated on the heap (dynamically)
		+ inheritance (not multiple)
		+ floating point (SANE)
		+ module (overlay) creation that are loaded only when necessary
		+ modules may be purged from application heap memory.
updated:	1996/03/19


compiler generators and related tools
-------------------------------------------------------------------------------
category:	compiler generators and related tools
description:	Yacc, and the rest of its family

language:	ABC
package:	Grammar analysis tools
version:	1
parts:		analysis tools, samples, documentation
author:		Steven Pemberton <Steven.Pemberton@cwi.nl>
location:	ftp://ftp.cwi.nl/pub/abc/examples/grammar/*
		or http://www.cwi.nl/~steven/abc/examples/grammar
description:	Grammar analysis program written in ABC (q.v.) for
		answering such questions as "what are the start
		symbols of all rules", "what symbols can follow this
		symbol", "which rules are left recursive", and so on.
		Includes a grammar of ISO Pascal.
reference:	Ftp://archive includes an article explaining the package.
ports:		unix, MSDOS, atari, mac
contact:	Steven.Pemberton@cwi.nl
updated:	1993/07/05

language:	? attribute grammar ?
package:	Alpha
version:	pre-release
parts:		semantic-analysis generator?, documentation(german)
author:		Andreas Koschinsky <koschins@cs.tu-berlin.de>
location:	from author
description:	I have written a compiler generator. The generator is called
		Alpha and uses attribute grammars as specification calculus.
		Alpha is the result of a thesis at Technische Universitaet
		Berlin. I am looking for someone who would like to test and use
		Alpha.	Alpha generates compilers from a compiler
		specification. This specification describes a compiler in
		terminology of attribute grammars. Parser and Scanner are
		generated by means of Bison and Flex.  Alpha generates an
		ASE-evaluator (Jazayeri and Walter).  The documentation is in
		german since it is a thesis at a german university.
updated:	1993/02/16

language:	attribute-grammar extension of Yacc and Lex
package:	Ox
version:	G1.01
parts:		Yacc/Lex/C preprocessor, tutorial, reference manual,
		man page, examples, Ox-ready parsers (C, C++, Pascal, Ada,
		Fortran)
author:		Kurt Bischoff <bischoff@cs.iastate.edu>
location:	ftp://ftp.cs.iastate.edu/pub/ox/*
description:	Ox generalizes the function of Yacc in the way that attribute
		grammars generalize context-free grammars.  Ordinary Yacc and
		Lex specifications may be augmented with definitions of
		synthesized and inherited attributes written in C syntax.  Ox
		checks these specifications for consistency and completeness,
		and generates from them a program that builds and decorates
		attributed parse trees.	 Ox accepts a most general class of
		attribute grammars.  The user may specify postdecoration
		traversals for easy ordering of side effects such as code
		generation.  Ox handles the tedious and error-prone details of
		writing code for parse-tree management, so its use eases
		problems of security and maintainability associated with that
		aspect of translator development.  Ox is a preprocessor,
		and extends the syntax and semantics of Yacc, Lex, and C.
reference:	Most compiler textbooks have descriptions of attribute
		grammars.
features:	LALR(1), semantic-analyzer generation.
bugs:		none known.  Report bugs to ox-project@cs.iastate.edu.
restriction:	Use of Ox is free.  Ox-generated code is the property of
		the Ox user.
ports:		Unix
contact:	ox-request@cs.iastate.edu
updated:	1993/11/14

language:	attribute grammar
package:	Rie
version:	1.0.6
parts:		compiler generator, attribute evaluator generator
author:		Masataka Sassa, Kazuhiro Kuroishi, Teruhisa Hirai and
		Yoshiki Ohshima
location:	ftp://ftp.is.titech.ac.jp/pub/Rie/*
description:	Rie is a yet another compiler generator which is based on
		a one-pass attribute grammar called ECLR-attributed grammar.
		ECLR-attributed grammar is a superset of LR-attributed
		grammar, and the generated compiler can evaluate both
		inherited and synthesized attributes in parallel with LR
		parsing without creating a parse tree.	The style of the
		Rie description is derived from Yacc, but the semantic
		section of a production may contain attribution rules.
		Because the specification is based on attribute grammar,
		user can integrate syntax and semantics in one description.
		Rie also accepts shorthand notations, context conditions
		and `local' attributes, which are useful to write actual
		compilers.
		The generated compiler is only 1.8 times slower than a
		handwritten compiler.  Rie generates an attribute evaluator
		in C source.
		The package includes sample descriptions of PL/0 compiler
		and of a sample of simple semantic analyzer, and documentation.
reference:	Sassa, M., Ishizuka, H., and Nakata, I.:
		Rie, a Compiler Generator Based on a One-Pass
		Attribute Grammar, Res. Rep. C-107, Dept. of Inf.
		Sci., Tokyo Institute of Technology
		(Now, only a printed version is available.  Contact
		rie-info@is.titech.ac.jp.  Electric version will be
		available from ftp://ftp.is.titech.ac.jp/pub/Rie/Papers/* .)
bugs:		Bug reports are welcome to rie-comments@is.titech.ac.jp.
restriction:	Rie is implemented by modifying Bison, so Rie must be
		also covered by GNU General Public License version 2
		and Bison's restriction.
requires:	C compiler
ports:		UNIX, DOS, etc. (same as bison) and Sharp X68000
status:		We hope that it is stable
contact:	rie-info@is.titech.ac.jp>
updated:	1995/09/20

language:	BNF (Extended, actually a regular right part grammar)
package:	Gray
version:	4
parts:		parser generator, documentation, examples
author:		Martin Anton Ertl <anton@mips.complang.tuwien.ac.at>
how to get:	ftp://server.complang.tuwien.ac.at/pub/forth/gray4.tar.gz
		ftp://server.complang.tuwien.ac.at/pub/forth/gray4.zip
description:	Gray is a parser generator written in Forth.  It takes
		grammars in an extended BNF and produces executable Forth
		code for recursive descent parsers.
restrictions:	Copyleft
requires:	ANS Forth
conformance:	ANS Forth with some environmental dependences (see README)
status:		supported
ports:		Several ANS Forth Systems; mail author for old versions
		running on Tile.
updated:	1994/08/08

language:	BNF (??)
package:	ZUSE
version:	?
parts:		parser generator(?)
author:		Arthur Pyster
location:	? Univ Calif at Santa Barbara ?
description:	ll(1) paser generator
requires:	Pascal
updated:	1986/09/23

language:	BNF (??)
package:	FMQ
version:	?
parts:		paser generator w/error corrector generator
author:		Jon Mauney
location:	ftp://csczar.ncsu.edu
description:	?
status:		?
contact:	?
updated:	1990/03/31

language:	BNF (??)
package:	ATS (Attribute Translation System)
version:	?
parts:		?
author:		? University of Saskatchewan ?
location:	?
description:	generates table-driven LL(1) parsers with full insert-only
		error recovery.	 It also handles full left-attribute semantic
		handling, which is a dream compared to using YACC's parser
		actions.
status:		?
contact:	? (suggested: Dave Bocking <bocking@cs.usask.ca>)
updated:	1988/11/29

language:	BNF (Extended)
package:	PCCTS (Purdue Compiler-Construction Tool Set)
version:	1.33
parts:		scanner generator, parser generator (pred-LL(k)),
		documentation, tutorial
author:		Terence J. Parr <parrt@parr-research.com>,
		Will E. Cohen <cohenw@ecn.purdue.edu>,
		Henry G. Dietz <hankd@ecn.purdue.edu>,
		Russell W. Quong <quong@ecn.purdue.edu>
location:	ftp://ftp.parr-research.com/pub/pccts/
    UK:		ftp://src.doc.ic.ac.uk/computing/programming/languages/tools/pccts/
description:	PCCTS is similar to a highly integrated version of
		YACC and LEX; where ANTLR (ANother Tool for Language
		Recognition) corresponds to YACC and DLG (DFA-based
		Lexical analyzer Generator) functions like LEX.
		PCCTS grammars contain specifications for lexical and
		syntactic analysis with selective backtracking
		("infinite lookahead"), semantic predicates,
		intermediate-form construction and sophisticated
		parser exception handling.  Rules may employ Extended BNF
		(EBNF) grammar constructs and may define parameters,
		return values and local variables. Languages described in
		PCCTS are recognized via predicated-LL(k) parsers
		constructed in pure, human-readable, C/C++ code; the C++
		programming interface is very good.  The documentation is
		complete, but distributed over an original manual plus
		multiple release notes.	 A book is in the works and should
		be available 1Q 1996.
		A recently-developed PCCTS-based C++ parser is available
		at the ftp://site; it is an *initial* release and was
		derived from the grammar built by NeXT, Inc..
restriction:	The tool is totally public domain--it has no legal
		restrictions on its use or incorporation into commercial
		applications.
ports:		Unix, DOS, Windows, OS/2, Macintosh, NeXT
portability:	very high
discussion:	comp.compilers.tools.pccts
contact:	Terence J. Parr <parrt@acm.org>
updated:	1995/10/05

language:	Antlr 1.33 (PCCTS Development Tools)
package:	USQAGMS
version:	1998.02.02
parts:		Grammar merger, documentation, additional small
		tools including Word Perfect grammar extraction macro.
author:		Ron House <house@usq.edu.au>
location:	httpd://www.sci.usq.edu.au/staff/house/usqagms/usqagms-manual.html
description:	USQAGMS is a grammar merger that combines actions
		from an old/obsolescent grammar with rules from an
		updated grammar. It is intended to assist language
		designers who are writing a compiler in parallel
		with making changes to the grammar.
conformance:	Processes Antlr 1.33 (PCCTS Development Tools) grammars.
bugs:		Ron House <house@usq.edu.au>
restriction:	Setting up for your language is a bit fiddly, but it saves heaps of work thereafter.
requires:	Antlr 1.33 (PCCTS Development Tools)
		The grammar extraction macro requires Word Perfect (not an essential component).
ports:		Linux.
portability:	Should work on any Unix.
status:		Not officially supported, but I want to fix any bugs you might find.
announcements:	On web site and comp.compilers.tools.pccts.
contact:	Ron House <house@usq.edu.au>
updated:	1998/02/02

language:	BNF (very extended), yacc
package:	PRE-CC Xtended
version:	2.30
parts:		library, parser generator (LL(oo)), translator(yacc->)
author:		Peter Breuer
location:	ftp://ftp.comlab.ox.ac.uk/pub/Programs/preccx.tar.Z (Unix)
		ftp://ftp.comlab.ox.ac.uk/pub/Programs/preccx.msdos (MS-DOS)
		ftp://ftp.comlab.ox.ac.uk/pub/Documents/techpapers/Jonathan.Bowen/preccx-uug.ps.Z
		(more recent versions available by subscription)
		URL: http://www.comlab.ox.ac.uk/archive/redo/precc.html
description:	PRECCX is an infinite-lookahead compiler compiler for context
		dependent grammars.  The generated code is ANSI C.
		Specification scripts are in very EBNF with inherited and
		synthetic attributes allowed. Scripts can be compiled in
		separate modules, and linked together later.  Meta-production
		rules allowed.	The technology is essentially LL(oo) with
		optimizations. A converter for yacc scripts is available.
reference:	"The PRECC Compiler-Compiler" by P.T. Breuer and J.P. Bowen.
		 In E. Davies and A. Findlay (eds.),
		 Proc. UKUUG/SUKUG Joint New Year 1993 Conference,
		 St. Cross Centre, Oxford, UK, 6-8 January 1993,
		 ISBN 1 873611 06 4 (UKUUG), 0 9520700 0 6 (SUKUG)
		 UKUUG/SUKUG Secretariat, Owles Hall, Buntingford,
		 Herts SG9 9PL, UK, pp 167-182, 1993.
		"A PREttier Compiler-Compiler: Generating Higher Order
		 Parsers in C"	P.T. Breuer and J.P. Bowen.
		 Oxford University Computing Laboratory Technical Report
		 PRG-TR-20-92, 25pp, November 1992. Accepted by
		 Software - Practice and Experience, 1994.
		 ftp://ftp.comlab.ox.ac.uk/pub/Documents/techreports/TR-20-92.ps.Z
ports:		unix, MS-DOS
contact:	Peter Breuer <ptb@comlab.ox.ac.uk>,
		Jonathan Bowen <bowen@comlab.ox.ac.uk>
updated:	1994/06/02

language:	BNF (??)
package:	LLGen
version:	?
parts:		parser generator
author:		? Fischer and LeBlanc ?
location:	? ftp://csczar.ncsu.edu ?
description:	LL(1) parser generator
conformance:	subset of FMQ
reference:	"Crafting A Compiler", by Fischer and LeBlanc
status:		?
contact:	?
updated:	1990/03/31

language:	BNF
package:	wacco
version:	1.1, July 91
parts:		parser generator
author:		Parag Patel (parag@netcom.com, parag@sde.hp.com)
location:	comp.sources.misc volume ?
description:	Wacco is a recursive descent LL(1) parser generator that
		generates C++ code.  Its syntax is similar to YACC
		with a lot of sugaring.	 It can also do attribute-driven
		parsing.  The source is bootstrapped wacco code.
ports:		HP-UX s300 and s800, Sparc, and 4.3BSD (on HP)
portability:	Host machine must be 32 bits.
contact:	?
updated:	?

language:	BNF (Extended), BNF (yacc)
package:	GMD Toolbox for Compiler Construction (aka Cocktail)
version:	9209
parts:		lalr: parser generator (LALR(1) -> C, Modula-2),
		ell : parser generator (LL(1) -> C, Modula-2),
		rex : scanner generator (-> C, Modula-2),
		bnf : translator (Extended BNF -> BNF),
		y2l : translator (BNF (yacc) -> Extended BNF),
		ast : abstract syntax tree generator,
		ag  : attribute-evaluator generator,
		puma: transformation of abstract syntax tree using
		      pattern-matching
		documentation, examples
author:		Josef Grosch <grosch@cocolab.sub.com> and others
location:	ftp://ftp.gmd.de/gmd/cocktail
		ftp://ftp.rus.uni-stuttgart.de/pub/unix/programming/compilerbau
		ftp://ftp.th-darmstadt.de/pub/programming/languages/compiler-compiler/cocktail
		ftp://src.doc.ic.ac.uk/languages/tools/
		ftp://gatekeeper.dec.com/.3/plan/
    OS/2:	ftp.eb.ele.tue.nl/pub/src/cocktail/dos-os2.zoo
description:	A huge set of compiler building tools.
requires:	(MS-DOS and MS-Windows only) DJ Delorie's DOS extender (go32)
		(OS/2 only) emx programming environment for OS/2
ports:		Unix, Linux, MS-DOS, MS-Windows, OS/2
portability:	very high
status:		version 9209 is unsupported, Cocktail is actively developed,
		versions 9401 and higher are commercial
discussion:	subscribe to Cocktail using listserv@eb.ele.tue.nl
support:	Josef Grosch <grosch@cocolab.sub.com>
contact:	Josef Grosch <grosch@cocolab.sub.com>
    OS/2:	Willem Jan Withagen <wjw@eb.ele.tue.nl>
updated:	1992/10/01

language:	BNF (??)
package:	T-gen
version:	2.1
parts:		parser generator, documentation, ?
author:		Justin Graver <graver@comm.mot.com>
location:	ftp://st.cs.uiuc.edu/pub/st80_r41/T-gen2.1/*
description:	T-gen is a general-purpose object-oriented tool for the
		automatic generation of string-to-object translators.
		It is written in Smalltalk and lives in the Smalltalk
		programming environment.  T-gen supports the generation
		of both top-down (LL) and bottom-up (LR) parsers, which
		will automatically generate derivation trees, abstract
		syntax trees, or arbitrary Smalltalk objects.  The simple
		specification syntax and graphical user interface are
		intended to enhance the learning, comprehension, and
		usefulness of T-gen.
requires:	Smalltalk-80
ports:		ParcPlace Objectworks/Smalltalk 4.0 & 4.1
updated:	1992/10/18

language:	BNF
package:	Eli
version:	4.1.0
parts:		scanner generator (regular expressions->C, C++),
		parser generator (LALR->C, C++), attribute evaluator
		generator (LIDO->C, C++), definition table generator
		(PDL->C, C++), tree pattern-matcher generator (OIL->C,
		C++), pattern-based text generator (PTG->C, C++),
		unparser generator (Idem), command-line processing
		generator (CLP->C, C++), literate programming
		(FunnelWeb), integrated high-level debugger (Noosa),
		library with solutions for common tasks (ModLib),
		online and printable documentation
author:		William Waite <waite@cs.colorado.edu>
		Basim Kadhim <kadhim@cs.colorado.edu>
		Uwe Kastens <uwe@uni-paderborn.de>
		Matthias Jung <mjung@uni-paderborn.de>
		Peter Pfahler <peter@uni-paderborn.de>
		Anthony Sloane <tony@cs.jcu.edu.au>
location:	http://www.cs.colorado.edu/~eliuser
		http://www.uni-paderborn.de/project-hp/eli.html
		http://www.cs.jcu.edu.au/~tony/eli.html
description:	Eli is a fully integrated environment for the
		automatic generation of processors of structured text.
		It transparently utilises off-the-shelf tools and
		libraries with specialized language processors to
		generate complete processors quickly and reliably.
		It simplifies the development of new special-purpose
		languages, implementation of existing languages on
		new hardware and extension of the constructs and
		features of existing languages.
bugs:		<elibugs@cs.colorado.edu>
restriction:	Eli is under the Free Software Foundation's General
		Public License.	 Code generated by Eli has no
		restrictions except that the dynamic memory allocation
		module (obstack) is covered by FSF's Library General
		Public License.
requires:	High-level debugging requires Tcl/Tk (at least
		versions 7.6/4.2).
ports:		SunOS (4.1.2, 5.4, 5.5), OSF1 (V3.0, V4.0), Linux
		(2.0.30 ELF), IRIX (5.3, 6.3), HP-UX (A.09.05)
portability:	Portable to most Unix systems using FSF's autoconf
		support.
status:		active, supported
discussion:	<eli@cs.colorado.edu>
		(join at <eli-request@cs.colorado.edu>)
help:		<elibugs@cs.colorado.edu>
announcements:	comp.compilers, <eli@cs.colorado.edu>
contact:	<compiler@cs.colorado.edu>
		<compiler@uni-paderborn.de>
		<tony@cs.jcu.edu.au>
updated:	1997/10/6

language:	BNF
package:	tom (demo for Tomita Parsing algorithm)
version:	1
parts:		parser generator, parser interpreter, examples, documentation
author:		Mark Hopkins <mark@omnifest.uwm.edu>
location:	iecc.com in pub/files/tomita.tar.gz
		alt.sources archive from October 4, 1993.
description:	An implementation of the Tomita parsing algorithm using
		LR(0) tables and dynamic programming.
reference:	Kluwer '91, _Generalized LR Parsing_, Tomita ed., 0-7923-9201-9
		"The Tomita Parsing Algorithm ...", comp.compilers May 20, 1994
features:	Cyclic context free grammars are processed.
portability:	System independent
updated:	1994/10/03

language:	BNF (yacc)
package:	NewYacc
version:	1.0
parts:		parser generator, documenation
author:		Jack Callahan <callahan@mimsy.cs.umd.edu>
location:	ftp://flubber.cs.umd.edu/src/newyacc.1.0.*.Z
description:	[someone want to fill it in? --ed]
reference:	see Dec 89 CACM for a brief overview of NewYacc.
updated:	1992/02/10

language:	BNF (yacc)
package:	bison
version:	1.22
parts:		parser generator, documentation
author:		Robert Corbett and Richard Stallman
location:	ftp bison-1.16.tar.Z from a GNU archive site
description:	?
bugs:		bug-gnu-utils@prep.ai.mit.edu
restriction:	!! will apply the GNU General Public License to *your* code !!
ports:		unix, atari, ?
updated:	1993/09/14

language:	BNF (yacc), Lex
package:	Bison++ and Flex++
version:	1.21-8 (bison), 2.3.8-7 (flex), 5 (flex++bison++misc)
parts:		translator, documentation, postscript, examples, DOS binary
author:		Alain Coetmeur <coetmeur@icdc.fr>
location:	cse.unl.edu in ~ftp/pub/nandy/c++/tools/LATEST/*
    Europe:	mirrored on ftp.th-darmstadt.de
description:	A retargeting of bison-1 and flex 2.3 to C++, able to
		generate classes.  As with Bison and Flex, these two tools
		are independent but designed for mutual compatibility.
		The version numbering has been changed for consistency with
		Flex and Bison, so versions of flex3.0.x and bison2.x of this
		package are are actually earlier versions, not later.
		Examples are provided to help in getting started.
conformance:	Mostly compatible with flex2.3 and bison 1 in C, apart
		from the ability to generate classes.
features:	Almost all symbol names can be redefined, parsers can be
		shared in C and C++ in the same headers... very extensible...
		flex++ support IOSTREAM and STDIO in C++.
bugs:		Contact coetmeur@icdc.fr (current author and maintainer).
restriction:	GNU License for bison++. Same as flex for flex++.
ports:		SUNOS4, DOS, and same ports as Flex/Bison, Windows NT (tested)
portability:	Larger memory model required on DOS (DOS binary supplied).
status:		active, supported, might not support flex 2.4
discussion:	coetmeur@icdc.fr, news: comp.compiler, or comp.lang.c++
help:		coetmeur@icdc.fr, news: comp.compiler, or comp.lang.c++
		for substantial problems.
support:	see help, no commercial support. (volunteer ?)
announcements:	mail list locally maintained by coetmeur@icdc.fr,
		news: comp.compiler comp.lang.c++
updated:	1994/02/07
lref:		C
lref:		C++
lref:		Lex
lref:		yacc

language:	BNF (yacc)
package:	bison-A2.3
version:	2.3 (corresponds to gnu bison 1.22)
parts:		parser generator, C-parser, C++parser, documentation
author:		Fred Hansen <wjh+@cmu.edu>
location:	ftp://ftp.andrew.cmu.edu/pub/AUIS/bison/bison-A2.2.tar.gz
		also in contrib/andrew on the XV11R6 distribution in
		directories overhead/bison, overhead/mkparser (but not the
		C++ version of the parser)
description:	This is the standard gnu bison with a number of improvments:
		license-free parsers for C and C++, only one external symbol
		for each grammar, permits multiple grammars per application,
		better error reports on the grammar.
conformance:	grammars are the same as bison and yacc; but run-time errors
		are handled differently, so semantic rules must be changed
features:	tokens in the grammar can be expressed as ">=" instead of GE
bugs:		send bugs to info-andrew-bugs@andrew.cmu.edu
restriction:	none (unless you use the native gnu-bison parser)
ports:		has been tested on most Unix platforms
portability:	generation of names for temp files is system dependent.
discussion:	info-andrew@andrew.cmu.edu   (mirrored to comp.soft-sys.andrew)
support:	supported by the Andrew Consortium
contributions:	your organization is invited to join the Andrew Consortium
		info-andrew-request@andrew.cmu.edu
updated:	1994/05/09

language:	BNF (Yacc like description languages)
package:	Compiler Construction Tool Set (aka COCOM or Russian Armoury)
version:	0.9
parts:		+Ammunition: reusable packages
		+Sprut : internal representation description translator (C, C++)
		+Nona : code selector description translator (C, C++)
		+Oka : pipeline hazards description translator (C,C++)
		      and basic block scheduler (C, C++)
		+Shilka : keywords description translator (C, C++) for
			 for fast recognizing keywords
		+Msta : syntax description translator (now only C) for
		       description of parsers and scanners (LR(k), LALR(k)).
		       documentation, examples
author:		Vladimir N. Makarov <vmakarov@usa.net>
location:	http://www.geocities.com/SiliconValley/Lab/4557
description:	A set of compiler building tools.
ports:		Unix, Linux
portability:	very high (GNU configure)
status:		COCOM is actively developed
support:	Vladimir N. Makarov <vmakarov@usa.net>
contact:	Vladimir N. Makarov <vmakarov@usa.net>
updated:	1998/01/05

language:	BNF (yacc)
package:	? jaccl ?
version:	?
parts:		parser generator
author:		Dave Jones <djones@megatest.uucp>
location:	?
description:	a LR(1) parser generator
updated:	1989/09/08

language:	BNF (yacc)
package:	byacc (Berkeley Yacc)
version:	1.9
parts:		parser generator
author:		Robert Corbett <Robert.Corbett@eng.sun.com>
location:	ftp://vangogh.CS.Berkeley.EDU/pub/byacc.tar.1.9.Z
description:	probably the best yacc variant around.	Previously known as
		Zoo, and before that, as Zeus.
updated:	1993/02/22

language:	BNF (yacc)
package:	yacc
version:	1.9.1
parts:		parser_generator
author:		Todd Dukes (ladco@tab.com)
location:	sunsite.unc.edu/pub/Linux/devel/lang/compiler_tools
description:	Yacc is a parser generator. It reads an input file that
		describes a grammar and generates C code that implements that
		grammar. It is designed to work well with 'lex' compatible
		lexers. Flex is a good program for generating these lexers.
		This version has improved support for C++. Yacc 1.9 generated C
		code that caused warnings and errors when compiled with C++.
		Minor changes were made in the declarations in the skeleton
		file to eliminate these warnings and errors.
updated:	?

language:	BNF (yacc), Lex
package:	Lex/Yacc for Turbo Pascal uploaded
version:	?
parts:		parser generator, scanner generator, documentation?
author:		?
location:	ftp://iecc.com/pub/file/lyprg.zip.
description:	Lex and Yacc retargeted to Pascal.
contact:	? dpoole@hydrogen.oscs.montana.edu (David Poole)
updated:	1993/07/02

language:	BNF (yacc), Ada
package:	aflex-ayacc
version:	1.2a
parts:		parser generator (Ada), scanner generator (Ada)
author:		IRUS (Irvine Research Unit in Software)
location:	ftp://liege.ics.uci.edu/pub/irus/
description:	Lex and Yacc equivalents that produce Ada output
announcements:	irus-software-request@ics.uci.edu
contact:	irus-software-request@ics.uci.edu
updated:	1993/01/06

language:	BNF (yacc), Perl
package:	perl-byacc
version:	1.8.2
parts:		parser-generator(perl)
author:		Rick Ohnemus <Rick_Ohnemus@Sterling.COM>
location:	ftp://ftp.sterling.com/local/perl-byacc.tar.Z
description:	A modified version of byacc that generates perl code.  Has '-p'
		switch so multiple parsers can be used in one program (C or
		perl).
portability:	Should work on most (?) Unix systems.  Also works with
		SAS/C 6.x on AMIGAs.
updated:	1993/01/24

language:	BNF (yacc), Standard ML
package:	New SML-Yacc and SML-Lex
version:	??
parts:		??
author:		Andrew Appel <appel@tyrolia.princeton.edu>
location:	princeton.edu/pub/ml, files mlyacc94.tar.Z, lexgen94.tar.Z.
description:	??
updated:	1994/05/23

language:	BNF (variant), Icon
package:	Ibpag2 (Icon-Based Parser Generation System 2)
version:	1.2
parts:		parser generator (Icon, SLR(1))
author:		Richard L. Goerwitz <goer@midway.uchicago.edu>
location:	comp.sources.misc volume 44
description:	Ibpag2 is a parser generator for Icon.	It does most
		of what you would expect.  Latest version can handle both
		SLR(1) and even GLR (Tomita) grammars.
ports:		unix
portability:	? (Unix dependencies?)
updated:	1994/09/25

language:	BNF ?, Gofer
package:	Ratatosk (?)
version:	?
parts:		parser generatr (Gofer)
author:		Torben AEgidius Mogensen <torbenm@diku.dk>
location:	ftp://ftp.diku.dk/pub/diku/dists/Ratatosk.tar.Z
description:	Ratatosk is a SLR parser generator in Gofer (a Haskell variant)
		that generates purely functional parsers (also in Gofer). Even
		though the sematic value of a production is a function of the
		attributes of its right-hand side (and thus apparently purely
		synthesized), inherited attributes are easily simulated by
		using higher order functions.
ports:		?
updated:	?

language:	BNF
package:	lalr.ss - An LALR(1) parser generator
version:	0.9
parts:		parser generator (->Scheme)
author:		Mark Johnson <mj@cs.brown.edu>
location:	ftp new/lalr.shar from the Scheme Repository
description:	A LALR(1) parser generator in and for Scheme.
requires:	Scheme
updated:	1993/05/24

language:	BURS ?
package:	Iburg
version:	?
parts:		parser generator?
author:		Christopher W. Fraser <cwf@research.att.com>, David R. Hanson
		<drh@princeton.edu>, Todd A. Proebsting <todd@cs.arizona.edu>
location:	ftp://ftp.cs.princeton.edu/pub/iburg.tar.Z
description:	Iburg is a program that generates a fast tree parser.  It is
		compatible with Burg. Both programs accept a cost-augmented
		tree grammar and emit a C program that discovers an optimal
		parse of trees in the language described by the grammar. They
		have been used to construct fast optimal instruction selectors
		for use in code generation.  Burg uses BURS; Iburg's matchers
		do dynamic programming at compile time.
updated:	1993/02/10

language:	BNF variant, Python
package:	kwParsing ?
version:	?
parts:		parser generator
author:		Aaron Watters <aaron@vienna.njit.edu>
location:	ftp://ftp.markv.com/pub/python/
description:	A parser generator written in Python for Python.  This package
		may be appropriate for experimental translators, code
		generators, interpreters, or compilers; for instructinal
		purposes; among other possibility.  The documentation gives a
		brief introduction to the conventions and basic ideas of
		parsing.
updated:	1994/09/24

language:	Candle, IDL (Interface Description Language)
package:	Scorpion System
version:	6.0
parts:		software development environment for developing
		software development environments, documentation
author:		University of Arizona
location:	ftp://cs.arizona.edu/scorpion/*
description:	20 tools that can be used to construct specialized
		programming environments.
		The Scorpion Project was started by Prof. Richard
		Snodgrass as an outgrowth of the SoftLab Project (which pro-
		duced the IDL Toolkit) that he started when he was at the
		University of North Carolina.  The Scorpion Project is
		directed by him at the University of Arizona and by Karen
		Shannon at the University of North Carolina at Chapel Hill.
reference:	"The Interface Description Language: Definition and Use,"
		by Richard Snodgrass, Computer Science Press, 1989,
		ISBN 0-7167-8198-0
ports:		Sun-3, Sun-4, Vax, Decstation, Iris, Sequent, HP9000
discussion:	info-scorpion-request@cs.arizona.edu
contact:	scorpion-project@cs.arizona.edu
updated:	1993/11/04

language:	COCOL (EBNF variant)
package:	COCO/R
version:	1.39 (Modula, Pascal, Oberon)
parts:		parser generator(LL(1))
author:		Hanspeter Moessenboeck <moessenboeck@ssw.uni-linz.ac.at>
		Port to Modula-2 done by Marc Brandis, Christof Brass
		and Pat Terry <cspt@cs.ru.ac.za>
		Port to Turbo Pascal done by Pat Terry and Volker Pohlers
		<pohlers@escher.hrz.fh-stralsund.de>
location:	ftp://ftp.inf.ethz.ch:/pub/software/Coco
		ftp://ftp.psg.com:/pub/modula-2/
		ftp://cs.ru.ac.za:/pub/
		ftp://ftp.fit.qut.edu.au:/pub/
description:	Coco/R generates recursive descent parsers and their
		associated scanners from attributed grammars.  Coco/R can
		bootstrap itself to generate its own driver, parser, scanner,
		and semantic evaluator from the attributed grammar CR.ATG.
		This grammar thus serves as an an example of how to write
		compiler descriptions for Coco.	 There are also other simpler
		examples showing its use.
reference:	_A compiler generator for microcomputers_, by Rechenberg
		and Moessenboeck (Prentice Hall, 1989, 0-13-155136-1)
bugs:		MS-DOS related versions: Pat Terry <cspt@cs.ru.ac.za>
		Other: Hanspeter Moessenboeck
		       <moessenboeck@ssw.uni-linz.ac.at>
requires:	Oberon, Modula-2, or Turbo Pascal
ports:		MS-DOS: TopSpeed Modula-2; FST 2.0; FST 3.1 - 3.5;
		StonyBrook QuickMod 2.2; Logitech 3.03; Turbo Pascal.
		Macintosh: Apple MacMeth.
		Unix/Linux/FreeBSD: Mocka, Gardens Point.
status:		Oberon version is freely available.  Modula-2 version is
		free to academic sites; commercial use requires a license
updated:	1995/11/01

language:	COCOL (EBNF variant)
package:	Coco/R for C
version:	1.05
author:		Francisco Arzu <farzu@uvg.edu.gt>
location:	ftp://cs.ru.ac.za:/pub/coco/
description:	This is a C version of Professor Moessenboeck's Coco/R.
		Coco/R generates recursive descent parsers and their
		associated scanners from attributed grammars. Semantic
		attributes and semantic actions are a dream compared to
		YACC's and Lex's ones. There are many examples showing
		its use, including itself (it can bootstrap itself to
		generate its own driver, parser, scanner, and semantic
		evaluator from the attributed grammar CR.ATG) and a
		simple C like language which uses Iburg to generate
		intel 80x86 assemble language.
parts:		parser generator(LL(1)), scanner generator, documentation,
examples
bugs:		Francisco Arzu <farzu@uvg.edu.gt>
requires:	Standard C compiler
ports:		Many UNIX systems(Linux, UnixWare, SunOS, IBM AIX, HP-UX, etc)
		MS-DOS and OS/2
restrictions:	Next release will be under the GNU General Public License
updated:	1995/11/01
lref:		C

language:	EAG (Extended Affix Grammar)
package:	EAG
version:	first public release
parts:		recognizer generator, transduccer generator,
		translator generator, editor generator, documentation
author:		Marc Seutter <marcs@cs.kun.nl>
location:	ftp://hades.cs.kun.nl/pub/eag/
description:	The Extended Affix Grammar formalism, or EAG for short, is a
		formalism for describing both the context free and the context
		sensitive syntax of languages.	EAG is a member of the family
		of two-level grammars. They are very closely related to
		two-level van Wijngaarden grammars.  The EAG compiler will
		generate either a recognizer or a transducer or a translator
		or a syntax directed editor for a language described in the EAG
		formalism.
updated:	1993/09/14

language:	EBNF
package:	ETO
version:	test version
parts:		parser, postscript document, examples
author:		Lin Li <china@bernina.ethz.ch>
location:	FTP://fi.ethz.ch/pub/ETO/eto-09.*
description:	ETO is an object oriented universal syntax checker.  It takes
		an EBNF specification for a language and then uses it on an
		input file to check its syntax.
updated:	1994/06/03

language:	lex
package:	flex
version:	2.5.2
parts:		scanner generator
author:		Vern Paxson <vern@ee.lbl.gov>
location:	ftp://ftp.ee.lbl.gov/flex-2.5.2.tar.Z or from a GNU archive site
description:	A POSIX-compliant "lex" scanner generator.
bugs:		vern@ee.lbl.gov or bug-gnu-utils@prep.ai.mit.edu
updated:	1995/04/28

language:	Regular Expressions
package:	re2c
version:	alpha
parts:		translator (re->c)
author:		?? peter@csg.uwaterloo.ca
location:	ftp://csg.uwaterloo.ca/pub/peter/
description:	A regular expression to C converter.
updated:	?? 1994/04/29

language:	Pascal, Lisp, APL, Scheme, SASL, CLU, Smalltalk, Prolog
package:	Tim Budd's C++ implementation of Kamin's interpreters
version:	?
parts:		interpretors, documentation
author:		Tim Budd <budd@cs.orst.edu>
location:	? ftp://cs.orst.edu/pub/budd/kamin/
description:	a set of interpretors written as subclasses based on
		"Programming Languages, An Interpreter-Based Approach",
		by Samuel Kamin.
requires:	C++
status:		?
contact:	Tim Budd <budd@fog.cs.orst.edu>
updated:	1991/09/12

language:	Relation Grammar
package:	rl
version:	?
parts:		?
author:		Kent Wittenburg <kentw@bellcore.com>
location:	flash.bellcore.com/rl/*
description:	The RL files contain code for defining Relational Grammars and
		using them in a bottom-up parser to recognize and/or parse
		expressions in Relational Languages.  The approach is a
		simplification of that described in Wittenburg, Weitzman, and
		Talley (1991), Unification-Based Grammars and Tabular Parsing
		for Graphical Languages, Journal of Visual Languages and
		Computing 2:347-370.
		This code is designed to support the definition and parsing of
		Relational Languages, which are characterized as sets of
		objects standing in user-defined relations.  Correctness and
		completeness is independent of the order in which the input is
		given to the parser.  Data to be parsed can be in many forms as
		long as an interface is supported for queries and predicates
		for the relations used in grammar productions.	To date, this
		software has been used to parse recursive pen-based input such
		as math expressions and flowcharts; to check for data
		integrity and design conformance in databases; to
		automatically generate constraints in drag-and-drop style
		graphical interfaces; and to generate graphical displays by
		parsing relational data and generating output code.
requires:	Common Lisp
ports:		Allegro Common Lisp 4.1, Macintosh Common Lisp 2.0
updated:	1992/10/31

language:	S/SL (Syntax Semantic Language)
package:	ssl
version:	?
parts:		parser bytecode compiler, runtime
author:		Rick Holt, Jim Cordy <cordy@qucis.queensu.ca> (language),
		Rayan Zachariassen <rayan@cs.toronto.edu> (C implementation)
location:	ftp://neat.cs.toronto.edu/pub/
description:	A better characterization is that S/SL is a language
		explicitly designed for making efficient recusive-descent
		parsers.  Unlike most other languages, practicially the
		LEAST expensive thing you can do in S/SL is recur.  A
		small language that defines input/output/error token
		names (& values), semantic operations (which are really
		escapes to a programming language but allow good
		abstration in the pseudo-code), and a pseudo-code
		program that defines a grammar by the token stream the
		program accepts.  Alternation, control flow, and
		1-symbol lookahead constructs are part of the
		language.  What I call an S/SL "implementation", is a
		program that compiles this S/SL pseudo-code into a
		table (think byte-codes) that is interpreted by the
		S/SL table-walker (interpreter).  I think the pseudo-code
		language is LR(1), and that the semantic mechanisms turn it
		into LR(N) relatively easily.
		+ more powerful and cleaner than yac
		- slower than yacc
reference:	Cordy, J.R. and Holt, R.C. [1980] Specification of S/SL:
		 Syntax/Semantic Language, Computer Systems Research
		 Institute, University of Toronto.
		"An Introduction to S/SL: Syntax/Semantic Language" by
		 R.C. Holt, J.R. Cordy, and D.B. Wortman, in ACM Transactions
		 on Programming Languages and Systems (TOPLAS), Vol 4, No.
		2, April 1982, Pages 149-178.
updated:	1989/09/25

language:	TXL
package:	TXL: Tree Transformation Language
version:	7.4
parts:		translator, documentation, tutorial, examples
author:		Jim Cordy <cordy@qucis.queensu.ca>
location:	ftp://ftp.qucis.queensu.ca/pub/txl/*
description:	TXL is a language for performing source to source
		transformations and is well suited for rapidly prototyping
		new languages and language processors.	It has also been used to
		prototype specification languages, command languages, and more
		traditional program transformation tasks such as constant
		folding, type inference, source optimization and reverse
		engineering.  TXL takes as input an arbitrary context-free
		grammar in extended BNF-like notation, and a set of
		show-by-example transformation rules to be applied to inputs
		parsed using the grammar.  TXL is a functional/rule-based
		hybrid programming language, using the paradigm of structural
		transformation.
reference:	Several listed in software documentation
updated:	1993/08/04

language:	BNF (extended)
package:	SORCERER: A Simple Tree Parser and Rewrite Generator
version:	1.00B15
parts:		translator, documentation, tutorial, examples
author:		Terence Parr <parrt@parr-research.com>,
		Aaron Sawdey <sawdey@lcse.umn.edu>,
		Gary Funck <gary@intrepid.com>
location:	ftp://ftp.parr-research.com/pub/pccts/sorcerer/
		ftp://ftp.uu.net/languages/tools/pccts/
	UK:	ftp://src.doc.ic.ac.uk/computing/programming/languages/tools/pccts/
	Europe: ftp://ftp.th-darmstadt.de/pub/programming/languages/compiler-compiler/pccts/
description:	SORCERER is more suitable for the class of translation problems
		lying between those solved by code-generator generators and by
		full source-to-source translator generators.  SORCERER
		generates simple, flexible, top-down, tree parsers that, in
		contrast to code-generators, may execute actions at any point
		during a tree walk.  SORCERER accepts extended BNF notation,
		allows predicates to direct the tree walk with semantic and
		syntactic context information, and does not rely on any
		particular intermediate form, parser generator, or other
		pre-existing application. Both C and C++ based tree
		walkers can be generated. SORCERER is well integrated
		with PCCTS (soon SORCERER will be distributed with PCCTS).
reference:	Several listed in software documentation.
		A book will available first quarter 1996; a pre-release
		version is available at the ftp site.
discussion:	Usenet newsgroup comp.compilers.tools.pccts
help:		newsgroup
support:	actively supported, from newsgroup and Parr Research
		Corporation <parrt@parr-research.com>.
updated:	1995/09/01

language:	Attribute Grammars
package:	The FNC-2 Attribute Grammar System
version:	1.14
parts:		FNC-2: the Olga compiler and attribute evaluator generator;
		ATC: a generator of abstract tree constructors driven by
		  bottom-up parsers, with two flavours, one on top of
		  SYNTAX, and one on top of Lex and Yacc;
		PPAT: a generator of unparsers of attributed abstract
		  trees, based on the TeX-like notion of nested boxes
		  of text.
author:		Martin Jourdan, Didier Parigot and students
location:	http://www-rocq.inria.fr/charme/FNC-2/index.html
		ftp://ftp.inria.fr/INRIA/Projects/ChLoE/FNC-2/
description:	The FNC-2 system is a modern AG-processing system that
		aims at production-quality by providing the following
		qualities:
		+ Efficiency:
		  The generated evaluators, based on the visit-sequence
		  paradigm, are completely deterministic; furthermore,
		  this paradigm allows to apply very effective space
		  optimization techniques. The evaluators are hence
		  basically as efficient in time and space as hand-written
		  programs using a tree as internal data structure.
		+ Expressive power:
		  This efficiency is not achieved at the expense of
		  expressive power since FNC-2 accepts AGs in the very
		  broad class of strongly non-circular AGs.
		+ Easiness of use:
		  Olga, the input language of FNC-2, enforces a high degree
		  of programming safety, reliability and productivity.
		  It provides powerful constructions for modularity and
		  reusability.
		+ It contains the following sub-languages:
		  attributed abstract syntaxes ASX;
		  attribute grammars;
		  declaration and definition modules.
		+ Versatility:
		  The generated evaluators can be interfaced with many
		  other tools and produced in many variations:
		  Several modes of attribute evaluation:
		  exhaustive; incremental; concurrent (on shared-memory
		  multiprocessor machines).
		+ Several implementation languages:
		  C (standalone);
		  Lisp	(on top of the http://www-rocq.inria.fr/charme/FNC-2/centaurfnc2.html
		  C/fSDL (for the <A HREF="http://www-rocq.inria.fr/charme/FNC-2/cosyfnc2.html"> CoSy </A>
compilation platform);
		  ML (Caml).
		In addition, FNC-2 is the testbed for an active research team.
ports:		Unix
status:		active
contact:	<Didier.Parigot@inria.fr> or <Martin.Jourdan@inria.fr>
updated:	1995

language:	Ml4 (extended EBNF)
package:	Depot4
version:	1.6
parts:		translator generator (->Java), documentation, examples
author:		Juergen Lampe <lampe@math.tu-dresden.de>
location:	ftp ftp.math.tu-dresden.de/Depot4/
description:	Depot4 generates recursive descent parsers and
		translators.
		Ml4 is a true extension of N.Wirth's EBNF. It features a
		unique translation=20
		centred description, which makes it especially useful
		for people not educated in compiler construction.
		The Ml4 translator can bootstrap itself, thus serving as
		an example.
		Although translators are generated in a certain host
		language, their description is totally independent from this.
		Depot4 is intended for domain specific language implementation.
reference:	 "An Extensible Translator-Generator for Use in Branch
		Software Construction",
		J. Comp. and Inform. 2, 1 (1996), pp. 1057-1067
		 "A Generator for Dynamically Extensible Translators" in
		Proc. of JMLC'97 Joint Modular Languages Conference
		(Linz, 1997), pp. 75-87.
		 "A tool for syntax directed software design" J. of Systems
		Architecture 43 (1997), pp. 199-202.
features:	+ easy to capture recursive translator description
		+ rule based modularization (simplifies test)
		+ monitor/trace tools
		+ unbounded lookahead possible
		+ interface to other software
		+ extensible
		+ convenient standard user interface
bugs:		lampe@math.tu-dresden.de
requires:	Java Virtual Machine supporting JDK 1.0.2
portability:	no futher restrictions
status:		active
help:		online manual at
		http://www.math.tu-dresden.de/wir/staff/lampe/Dp4Doc/UM.html
support:	lampe@math.tu-dresden.de
updated:	1997/06

language:	Ml4 (extended EBNF)
package:	Depot4/Oberon
version:	1.6
parts:		translator generator (->Oberon), documentation, examples
author:		Juergen Lampe <lampe@math.tu-dresden.de>
location:	ftp ftp.math.tu-dresden.de/Depot4/
description:	A Oberon version of Depot4
		Accepts exactly the same language as Depot4/Java, cross
		translation, i.e. generation of translators in Java (and vice
		versa) possible
reference:	"An Oberon-Based Implementation Tool" in "Advances in
		Modular Languages" P. Schulthess
		(ed), Universit=8Atsverl., Ulm, 1994, ISBN 3-89559-220-X,
		pp. 303-312.
requires:	ETHZ Oberon V4
ports:		Oberon/F resp. Component Pascal
		ETHZ Oberon System3 possible
help:		online manual at
		http://www.math.tu-dresden.de/wir/staff/lampe/Dp4Doc/UM.html
support:	lampe@math.tu-dresden.de
updated:	1997/06

language:	ANSI C, K&R C
package:	CDG - C Documentation Generator
version:	1.1
parts:		documentation, document generator (all in one file)
author:		Peter Knoppers <knop@duteca.et.tudelft.nl>
location:	http://cardit.et.tudelft.nl/~knop/cdg11.tar.gz
		(Anonymous ftp not supported; use your WWW-browser and save
		it in a file.)
description:	Cdg reads a set of C-source files and generates a two-column
		listing of those sources where all lines are numbered. After
		the listing part comes a three-column cross-reference table
		which gives for each identifier a list of line-numbers where
		this identifier occurs in the source listing part.
		This format resembles the format that John Lions used in
		"Source Code and Commentary on UNIX level 6".
conformance:	Should operate on all K&R and ANSI C programs. There are
		some restrictions on the placement of matching #ifdef, #else
		and #endif directives, or else the way an identifier is used
		may be incorrectly determined.
features:	+ Non-C sources can be included in the output
		- Non-C sources will not be cross-referenced
		+ Long lines are folded in the output and marked as such
		+ Customizable footer for copyright or other messages
		+ Cross reference list distinguishes definition versus use
		  of an identifier
		+ Possibility to exclude certain identifiers
		+ Can save a list of all identifiers with linenumbers
		+ Identifiers can be included or excluded from the cross-
		  reference listing depending on their use
		+ PostScript output can be generated for A4 or US Letter size
		  paper, on the non-PostScript printers only A4 is supported.
bugs:		None known (except the restriction mentioned under
		"conformance").
restriction:	GNU conditions
requires:	Unix, ANSI-C compiler (preferably gcc) (to build it), sort(1),
		PostScript printer, or HP DeskJet 500 or LaserJet printer,
		or GhostScript plus almost any popular printer.
ports:		Linux
portability:	Little experience at this time, should be quite portable.
status:		Works fine for the author...
discussion:	Email the author.
help:		Email the author.
support:	Email the author.
announcements:	http://cardit.et.tudelft.nl/~knop
cref:		C variants
cref:		unix tool building
cref:		programming in the large
updated:	1996/08/06

mathematical tools and languages
-------------------------------------------------------------------------------
category:	mathematical tools and languages
description:	These are either special-purpose languages and tools, or
		general purpose languages and tools that have traditionally
		been used for mathematical and scientific computing task.
lref:		Fortran
lref:		PCN
lref:		CLP
lref:		SISAL 1.2


language:	Algea language (math manipulation - MATLAB-like)
package:	Algea
version:	3.4.0
parts:		?
author:		Scott Hunziker <ksh@eskimo.com> and Mike Brennan
location:	http://www.eskimo.com/~ksh/algae/index.html
		http://axams1.bo.infn.it:9999/algae
		ftp://ftp.eskimo.com/u/k/ksh/algae
restriction:	GPL
requires:	gcc
ports:		UNIX (Linux Only?)
status:		Active
discussion:	To join the Algea list email algae-list-request@eskimo.com
description:	Algae is an interpreted language for numerical analysis. Algae
		borrows ideas from languages like MATLAB, APL, and C, but it was
		developed in response to a need for a free, efficient, and
		versatile high-level language with large problem capability.
updated:	1998/05

language:	APL
package:	I-APL
version:	?
parts:		?
author:		?
location:	ftp://watserv1.waterloo.edu/languages/apl/
description:	?
updated:	1992/07/06

language:	APL
package:	APLWEB
version:	?
parts:		translator(web->apl), translator(web->TeX)
author:		Dr. Christoph von Basum <CvB@erasmus.hrz.uni-bielefeld.de>
location:	ftp://watserv1.uwaterloo.ca/languages/apl/aplweb/*
description:	[Should this be listed with the Web entries? -- Ed.]
updated:	1992/12/07

language:	APL
iref:		(APL) Tim Budd's C++ implementation of Kamin's interpreters

language:	J
package:	J-mode
version:	?
parts:		emacs macros
author:		?
location:	ftp://think.com/pub/j/gmacs/j-interaction-mode.el
description:	add on to J
updated:	1991/03/04

language:	RLaB language (math manipulation - MATLAB-like)
package:	RLaB
version:	1.18d
parts:		interpreter, libraries, documentation
author:		Ian Searle <ians@eskimo.com>
location:	ftp://evans.ee.adfa.oz.au/pub/RLaB/
    US:		ftp://csi.jpl.nasa.gov/pub/matlab/
description:	RLaB is a "MATLAB-like" matrix-oriented programming
		language/toolbox.  RLaB focuses on creating a good experimental
		environment (or laboratory) in which to do matrix math
		Currently RLaB has numeric scalars and matrices (real and
		complex), and string scalars, and matrices. RLaB also contains
		a list variable type, which is a heterogeneous associative
		array.
bugs:		Ian Searle <ians@eskimo.com>
restriction:	GNU General Public License
requires:	GNUPLOT, lib[IF]77.a (from f2c)
ports:		many unix, OS/2, Amiga
updated:	1995/03/16

language:	Octave language (math manipulation - MATLAB-like)
package:	Octave
version:	2.0.13
parts:		interpreter, libraries, documentation
author:		John W. Eaton
location:	ftp://ftp.che.utexas.edu/pub/octave
		also, any GNU archive site (see archive listing below)
description:	Octave is a high-level language, primarily intended for
		numerical computations.	 It provides a convenient command line
		interface for solving linear and nonlinear problems
		numerically.
		Octave can do arithmetic for real and complex scalars and
		matrices, solve sets of nonlinear algebraic equations,
		integrate functions over finite and infinite intervals, and
		integrate systems of ordinary differential and
		differential-algebraic equations.
bugs:		bug-octave@che.utexas.edu
restriction:	GNU General Public License
requires:	g++ 2.7.2 or later, a recent version of GNU Make, GNU libstdc++
ports:		Linux, Digital Unix, HP-UX, SunOS, OS/2, and Windows NT/95
updated:	1998/5/21

language:	FUDGIT language (math manipulation)
package:	FUDGIT
version:	2.27
parts:		interpreter
author:		Martin-D. Lacasse
location:	ftp://tsx-11.mit.edu/pub/linux/sources/usr.bin/
description:	FUDGIT is a double-precision multi-purpose fitting program.  It
		can manipulate complete columns of numbers in the form of
		vector arithmetic. FUDGIT is also an expression language
		interpreter understanding most of C grammar except pointers.
		Morever, FUDGIT is a front end for any plotting program
		supporting commands from stdin. It is a nice mathematical
		complement to GNUPLOT, for example.  Ported to Linux by
		Thomas Koenig
requires:	GNUPLOT
ports:		AIX, HPUX, Linux, IRIX, NeXT, SunOS, Ultrix
updated:	1993/02/22

language:	Unix BC (arbitrary-precision arithmetic language)
package:	C-BC
version:	1.1
parts:		bytecode compiler, interpreter, documentation, examples
author:		Mark Hopkins <mark@omnifest.uwm.edu>
location:	alt.sources (10/04/93), or contact author by E-mail.
description:	A strongly typed version of BC with expanded C-like syntax,
		more base types, with ability to form array and pointer types
		of any dimension and to allocate/free arrays at run-time.
conformance:	Most POSIX-BC features supported, except functions must be
		declared consistently and declared before first use.  String
		handling slightly different.
reference:	C-BC implementation notes contained with software documentation
requires:	ANSI-C compiler
ports:		DOS, Unix
portability:	No system dependent features present.
updated:	1993/08/23

language:	Unix BC (arbitrary-precision arithmetic language)
package:	GNU BC
version:	1.02
parts:		parser (yacc), interpreter, BC math library
author:		Philip A. Nelson <phil@cs.wwu.edu>
location:	ftp bc-1.02.tar.Z from a GNU archive site
description:	BC is an arbitrary precision numeric processing language with a
		C-like syntax that traditionally provided a front-end to DC.
		This version, however, is self-contained and internally
		executes its own compiled code (unrelated to DC code).
conformance:	Superset of POSIX BC (P10003.2/D11), with a POSIX-only mode.
restriction:	Source code falls under the GNU CopyLeft.
requires:	vsprintf and vfprintf routines
ports:		Unix (BSD, System V, MINIX, POSIX)
updated:	?

language:	Calc?  (symbolic math calculator)
package:	Calc
version:	2.02
parts:		interpreter, emacs mode, documentation
author:		Dave Gillespie <daveg@cs.caltech.edu>
location:	ftp calc-2.02.tar.z from a GNU archive site
description:	Calc is an extensible, advanced desk calculator and
		mathematical tool written in Emacs Lisp that runs as part of
		GNU Emacs.  It is accompanied by the "Calc Manual", which
		serves as both a tutorial and a reference.  If you wish, you
		can use Calc as only a simple four-function calculator, but it
		also provides additional features including choice of algebraic
		or RPN (stack-based) entry, logarithms, trigonometric and
		financial functions, arbitrary precision, complex numbers,
		vectors, matrices, dates, times, infinities, sets, algebraic
		simplification, differentiation, and integration.
bugs:		?
updated:	?

language:	C-like caluculator
package:	Arbitrary precision calculator
version:	1.26.4
parts:		interpreter
author:		David I. Bell <dbell@canb.auug.org.au>
location:	ftp://ftp.uu.net/pub/calc
description:	Arbitrary precision C-like calculator [similar to BC? --ed]
ports:		Linux
updated:	1993/06/15

language:	Unix DC (arbitrary-precision arithmetic language)
package:	GNU DC
version:	0.2
parts:		interpreter
author:		?
location:	ftp dc-0.2.tar.Z from a GNU archive site
description:	DC is the language for an arbitrary precision postfix
		calculator.  This version is a subset of DC that handles all
		the Unix DC operations, except the (undocumented) array
		operations.
status:		Attempting integration with GNU BC.
updated:	1993/05/21

language:	Fortran
package:	f2c
version:	1993.04.28
parts:		translator (to C), postscript documentation, man pages,
		support libraries.
author:		S. I. Feldman, D. M. Gay, M. W. Maimone and N. L. Schryer
location:	ftp from netlib@netlib.bell-labs.com:netlib/f2c/src/*
description:	translator (Fortran 77 to ANSI C or C++)
bugs:		D. M. Gay <dmg@research.bell-labs.com>
updated:	1993 April 27

language:	GNU Fortran
package:	g77
version:	0.5.17
parts:		compiler, documentation, libraries.
author:		Craig Burley <burley@gnu.ai.mit.edu>
location:	ftp g77-0.5.17.tar.gz from any GNU site
description:	GNU Fortran is a free replacement for the UNIX f77
		Fortran compiler, and is currently in beta testing.
requires:	To build it requires the GNU CC source distribution,
		Version 2.6.3 through 2.7.
bugs:		<fortran@gnu.ai.mit.edu>
updated:	1995/11/22

language:	Fortran
package:	Floppy
version:	?
parts:		?
author:		?
location:	ffccc in comp.sources.misc archive volume 12
description:	?
contact:	?
updated:	1992/08/04

language:	Fortran
package:	Flow
version:	?
parts:		?
author:		Julian James Bunn <julian@vxcrna.cxern.ch>
location:	comp.sources.misc archive volume 31
description:	The Flow program is a companion to Floppy, it allows the user
		to produce various reports on the structure of Fortran
		77 code, such as flow diagrams and common block tables.
requires:	Floppy
ports:		VMS, Unix, CMS
updated:	?

language:	Fortran (HPF)
package:	Adaptor (Automatic DAta Parallelism TranslatOR)
version:	3.0
parts:		preprocessor, library, documentation
author:		?
location:	ftp://ftp.gmd.de/GMD/adaptor/
description:	Adaptor is a tool that transforms data parallel
		programs written in Fortran with array extensions,
		parallel loops, and  layout directives	to parallel
		programs with explicit message passing.
		ADAPTOR is not a compiler but a source to source
		transformation that generates Fortran 77 host and
		node programs with message passing.  The new
		generated source codes have to be compiled by the
		compiler of the parallel machine.
reference:	http://www.gmd.de/SCAI/lab/adaptor/adaptor_home.html
ports:		CM-5, iPCS/860, Meiko CS1/CS2, KSR 1, SGI, Alliant,
		network of Suns, or RS/6000s
contact:	Thomas Brandes <brandes@gmd.de>
updated:	1995/06

language:	Fortran, C
package:	cfortran.h
version:	2.6
parts:		macros, documentation, examples
author:		Burkhard Burow
location:	ftp://zebra.desy.de/cfortran/*
description:	cfortran.h is an easy-to-use powerful bridge between
		C and FORTRAN. It provides a completely transparent, machine
		independent interface between C and FORTRAN routines and
		global data.
		cfortran.h provides macros which allow the C preprocessor to
		translate a simple description of a C (Fortran) routine or
		global data into a Fortran (C) interface.
reference:	reviewed in RS/Magazine November 1992 and
		a user's experiences with cfortran.h are to be described
		in the 1/93 issue of Computers in Physics.
ports:		VAX VMS or Ultrix, DECstation, Silicon Graphics, IBM RS/6000,
		Sun, CRAY, Apollo, HP9000, LynxOS, f2c, NAG f90.
portability:	high
contact:	burow@vxdesy.cern.ch
updated:	1992/04/12

language:	Fortran
package:	fsplit
version:	?
parts:		?
author:		?
location:	?
description:	a tool to split up monolithic fortran programs
updated:	?

language:	Fortran
package:	?
version:	?
parts:		?
author:		Steve Mccrea <mccrea@gdwest.gd.com>
location:	?
description:	a tool to split up monolithic fortran programs
requires:	new awk
updated:	?

language:	Fortran
package:	Fortran77 -> Fortran90 converter
version:	? 1
parts:		translator(Fortran 77 -> Fortran 90), documentation?
author:		metcalf@cernvm.cern.ch <Michael Metcalf>
location:	ftp://jkr.cc.rl.ac.uk/pub/MandR/convert.f90
description:	A Fortran77 to Fortran90 translator.  There's a number of
		significant differences between the two Fortrans that makes
		a package like this useful.
updated:	1993/07/17

language:	Fortran
package:	F-curses
version:	?
parts:		library
author:		Wade Schauer <sal!wade@sactoh0.sac.ca.us>
location:	comp.sources.misc volume 44
description:	F-curses (C) is a library of Fortran and C routines that gives
		Fortran programmers tranparent access to the curses library (a
		C library).
restriction:	shareware
ports:		UNIX, MS-DOS
updated:	1994/10/10

language:	Fortran
iref:		(Fortran) Stanford Base SUIF Compiler Package (``basesuif'')

language:	Fortran
package:	?
version:	?
parts:		semantic analyser
author:		?
location:	http://www.nag.co.uk:70/
description:	Fortran 90 semantic analyser
updated:	?

language:	J
package:	J from ISI
version:	6
parts:		interpreter, tutorial
author:		Kenneth E. Iverson and Roger Hui <hui@yrloc.ipsa.reuter.com>
location:	ftp://watserv1.waterloo.edu/languages/apl/j/
description:	J was designed and developed by Ken Iverson and Roger Hui.  It
		is similar to the language APL, departing from APL in using
		using the ASCII alphabet exclusively, but employing a spelling
		scheme that retains the advantages of the special alphabet
		required by APL. It has added features and control structures
		that extend its power beyond standard APL.  Although it can be
		used as a conventional procedural programming language, it can
		also be used as a pure functional programming language.
ports:		Dec, NeXT, SGI, Sun-3, Sun-4, VAX, RS/6000, MIPS, Mac, Acorn
		IBM-PC, Atari, 3b1, Amiga
updated:	1992/10/31

language:	Ratfor
package:	? ratfor ?
version:	?
parts:		translator(Ratfor->Fortran IV)
author:		Brian Kernighan and P.J. Plauger (wrote the book anyway)
location:	comp.sources.unix archives volume 13
description:	Ratfor is a front end language for Fortran.  It was designed
		to give structured control structures to Fortran.  It is
		mainly of historical significance.
updated:	?

language:	Y (cross between C and Ratfor)
package:	y+po
version:	?
parts:		compiler
author:		Jack W. Davidson and Christopher W. Fraser
location:	ftp://ftp.cs.princeton.edu/pub/y+po.tar.Z
description:	Davidson/Fraser peephole optimizer PO [1-3] [where the GCC RTL
		idea and other optimization ideas came from] along with the Y
		compiler [cross between C+ratfor] is ftpable from
		ftp.cs.princeton.edu: /pub/y+po.tar.Z.	It is a copy of the
		original distribution from the University of Arizona during the
		early 80's, totally unsupported, almost forgotten [do not bug
		the authors] old code, possibly of interest to
		compiler/language hackers.
reference:	Jack W. Davidson and Christopher W. Fraser, "The Design and
		 Application of a Retargetable Peephole Optimizer", TOPLAS,
		 Apr.  1980.
		Jack W. Davidson, "Simplifying Code Through Peephole
		 Optimization" Technical Report TR81-19, The University of
		 Arizona, Tucson, AZ, 1981.
		Jack W. Davidson and Christopher W. Fraser, "Register
		 Allocation and Exhaustive Peephole Optimization"
		 Software-Practice and Experience, Sep. 1984.
status:		history
updated:	?

language:	ZPL
package:	ZPL
version:	?
parts:		compiler,language documents, sample code
author:		L. Snyder, C. Lin, B. Chamberlain, S-E. Choi, E. Lewis,
		J. Secosky, D. Weathersby
location:	http://www.cs.washington.edu/research/zpl/
description:	ZPL is a new array programming language designed from first
		principles for fast execution on both sequential and parallel
		computers.  ZPL benefits from recent parallel compiler
		research, though code from existing sequential Fortran and C
		programs can often be reused.  Programmers with scientific
		computing experience can learn ZPL in a few hours.
discussion:	zpl-info@cs.washington.edu
updated:	1997/07/01

electrical engineering languages
-------------------------------------------------------------------------------
category:	electrical engineering languages
description:	These are languages used for simulating, designing, and
		specifying circuits.

language:	CASE-DSP (Computer Aided Software Eng. for Digital Signal Proc)
package:	Ptolemy
version:	0.6
parts:		grahpical algorithm layout, code generator, simulator
author:		?
location:	ftp://ptolemy.eecs.berkeley.edu/pub/ptolemy/ptolemy0.6/
description:	Ptolemy provides a highly flexible foundation for the
		specification, simulation, and rapid prototyping of systems.
		It is an object oriented framework within which diverse models
		of computation can co-exist and interact.  For example, using
		Ptolemy a data-flow system can be easily connected to a
		hardware simulator which in turn may be connected to a
		discrete-event system, etc.  Because of this, Ptolemy can be
		used to model entire systems.
		In addition, Ptolemy now has code generation capabilities.
		from a flow graph description, Ptolemy can generate both C code
		and DSP assembly code for rapid prototyping.  Note that code
		generation is not yet complete, and is included in the current
		release for demonstration purposes only.
requires:	C++, C
ports:		Sun-4, MIPS/Ultrix; DSP56001, DSP96002. FreeBSD
status:		active research project
discussion:	ptolemy-hackers-request@ohm.berkeley.edu
contact:	ptolemy@ohm.berkeley.edu
updated:	1996/05/28

language:	EDIF (Electronic Design Interchange Format)
package:	Berkeley EDIF200
version:	7.6
parts:		translator-building toolkit
author:		Wendell C. Baker and Prof A. Richard Newton of the Electronics
		Research Laboratory, Department of Electrical Engineering and
		Computer Sciences at the University of California, Berkeley, CA
location:	?? ftp://ic.berkeley.edu/pub/ ??
description:	?
restriction:	no-profit w/o permission
ports:		?
updated:	1990/07

language:	SAOL, SASL (the MPEG-4 Structured Audio Orchestra Language and
		Structured Audio Score Language)
package:	saolc
version:	0.5
parts:		parser, interpreter, grammar, core opcode implementation
author:		Eric Scheirer, MIT Media Laboratory
location:	http://sound.media.mit.edu/~eds/mpeg4
description:	SAOL is an audio processing and digital synthesis and effects
		language.  It is part of the MPEG-4 standard, and allows the
		flexible description of synthesizers and effects-processing
		algorithms within than toolset.
		SAOL is historically related to Csound and other "Music N" 
		languages, but is more flexible and easy to use than these.
		While maintaining features such as the instrument/score 
		distinction and dual-rate processing, it adds user-defined
		opcodes, more well-defined rate semantics, more lexical
		flexibility, and an improved syntax.
references:	forthcoming
conformance:	This implementation is being developed as the official
		Reference Software for the Structured Audio component of
		ISO 14496 (MPEG-4).  
features:	
		- non-real time performance (unless your machine is much faster than my SGI Octane)
		+ implements user-defined opcodes as macro expansion
		+ standalone mode as well as bitstream processing
bugs:		many known and being worked on.
restrictions:	source code is released to the public domain
requires:	C compiler only; lex/yacc to rebuild parser
		not much fun without audio capability 
ports:		At least SGI, Alpha, NT, Win95, Linux, and SunOS systems
portability:	Word length and byte-order independent
status:		Under active development
Discussion:	saol-dev-request@media.mit.edu to be added to the SAOL developers' mailing list
Help:		Eric Scheirer <eds@media.mit.edu>
Support:	Eric Scheirer <eds@media.mit.edu>
Announcements:	http://sound.media.mit.edu/~eds/mpeg4 and the mailing list
Contact:	Eric Scheirer <eds@media.mit.edu>
Updated:	07/1997

language:	SPAM Compiler
package:	SPAM
version:	?
parts:		?
author:		?
location:	http://www.ee.princeton.edu/spam
description:	The SPAM Compiler is a retargetable optimizing compiler
		for embedded fixed- point DSP processors.  SPAM is built
		on top of the SUIF Compiler, which serves as the "front and
		middle"-end.  The back-end of the SPAM Compiler consists of
		two components.	 The first component is a set of data
		structures that store the various representations of the source
		program (e.g. calling graph, control-flow graphs, expression DAGs).
		The second component is a suite of retargetable algorithms that
		perform code generation and machine-dependent code optimization.
updated:	?


language:	Verilog, XNF
package:	XNF to Verilog Translator
version:	?
parts:		translator(XNF->Verilog)
author:		M J Colley <martin@essex.ac.uk>
location:	ftp://ftp.caltech.edu/pub/dank/ ?
description:	This program was written by a postgraduate student as part
		of his M.Sc course, it was designed to form part a larger
		system operating with the Cadence Edge 2.1 framework. This
		should be born in mind when considering the construction
		and/or operation of the program.
		[If anyone knows the current location of this program please
		let me know - ed (6/98)].
updated:	?

language:	VHDL
package:	ALLIANCE
version:	1.1
parts:		compiler, simulator, tools and environment, documentation
author:		?
location:	ftp://ftp.ibp.fr/ibp/softs/masi/alliance/
description:	ALLIANCE 1.1 is a complete set of CAD tools for teaching
		Digital CMOS VLSI Design in Universities. It includes VHDL
		compiler and simulator, logic synthesis tools, automatic place
		and route, etc...  ALLIANCE is the result of a ten years effort
		at University Pierre et Marie Curie (PARIS VI, France).
ports:		Sun4, also not well supported: Mips/Ultrix, 386/SystemV
discussion:	alliance-request@masi.ibp.fr
contact:	cao-vlsi@masi.ibp.fr
updated:	1993/02/16

language:	VHDL
package:	VHDL Object Model (VOM)
version:	1.0
parts:		parser
author:		David Benz <dbenz@thor.ece.uc.edu> and
		Phillip Baraona <pbaraona@thor.ece.uc.edu>
location:	ftp://thor.ece.uc.edu/pub/vhdl/tools/
description:	VOM 1.0 is an object-oriented syntactic specification for VHDL
		written using the REFINE software design and synthesis
		environment.  In simpler terms, it is a VHDL parser which builds
		an object tree from VHDL source code.
		If you are interested in transforming VHDL into some other form
		(source code, whatever) you might be interested in this. The
		parse tree (in the form of an object tree) is provided, you would
		just need to add your own transformations.
		VOM isn't complete. The semantic information is not included
		(type checking, certain syntactic-rules, etc.). VOM 1.0 should
		parse most VHDL programs.  However, it will not detect errors
		such as a wait statement in a process statement with an
		explicit sensitivity list.
updated:	1994/11/01

--
Send compilers articles to compilers@iecc.com, meta-mail to
compilers-request@iecc.com.  Archives at http://www.iecc.com/compilers

User Contributions:

Comment about this article, ask questions, or add new information about this topic:

CAPTCHA




Part1 - Part2 - Part3 - Part4 - Part5

[ Usenet FAQs | Web FAQs | Documents | RFC Index ]

Send corrections/additions to the FAQ Maintainer:
free-compilers@idiom.com (David Muir Sharnoff)





Last Update March 27 2014 @ 02:11 PM