-*- text -*- Last modified Thu Mar 21 18:57:21 1996
This is an incomplete and probably out-of-date list of all the packages
distributed on prep.ai.mit.edu and its mirror sites with a brief description
explaining what each one is.
More information about these programs can typically be found in the GNU
Bulletin. To receive a copy, write to gnu@prep.ai.mit.edu.
Problems with the contents of this file (or problems pertaining to the
packaging of these programs, e.g. if a file is corrupted) should be sent to
gnu@prep.ai.mit.edu. Bug reports for the programs themselves should
go to the appropriate address indicated in the instructions with that
program and its source code.
Because the unix `compress' utility is patented (by two separate patents,
in fact), we cannot use it; it is not free software. Therefore, the GNU
Project has chosen a new compression utility, `gzip', which is free of any
known software patents and which tends to compress better anyway. Files
compressed with this new compression program end in `.gz' (as opposed to
`compress'-compressed files, which end in `.Z'). Gzip can uncompress
`compress'-compressed files and SVR4 `pack' files (which end in `.z').
This is possible because the various decompression algorithms are not
patented---only compression is.
The gzip program is available from any GNU mirror site in shar, tar, or
gzipped tar format (for those who already have a prior version of gzip and
want faster data transmission). It works on virtually every unix system,
MSDOS, OS/2, and VMS.
Filenames below ending with "/" are directories. Other entries are plain
files.
COPYING-1.0
Version 1 of the GNU General Public License.
COPYING-2.0
Version 2 of the GNU General Public License.
COPYING.LIB-2.0
Version 2 of the GNU General Public Library License (there is no
version 1).
GNUinfo/
General files of interest about the GNU Project, most of them included in
the GNU Emacs distribution.
MailingListArchives/
Archives of the GNU mailing lists (most of which are also gatewayed to
the various gnu.* newsgroups).
MicrosPorts/
The GNU Project is not directly interested in integrating or
maintaining ports of GNU software to many micro-computer systems, like
Amiga's or MSDOS, because of limited resources. However, a few files
with pointers to people who do maintain GNU software for these other
systems are available in this directory.
ProgramIndex
A file with an index of which package each GNU program is in.
The rest of this file is the articles ``Forthcoming GNUs'' and ``GNU
Software'' from the most recent GNU's Bulletin. They contain
descriptions of our software. For more infomation on FSF's tapes,
diskettes and CD-ROMs see the file
/pub/gnu/GNUinfo/ORDERS
FTPable from prep.ai.mit.edu or one of its mirror sites.
----------------------------------------------------------------------
GNU Software
************
All our software is available via FTP; see *Note How to Get GNU Software::.
We also offer software on various media and printed documentation:
* *Note CD-ROMs::.
* *Note Tapes::.
* *Note MS-DOS Diskettes::.
* *Note Documentation::, which includes manuals and reference cards.
In these articles describing the contents of each medium, the version number
listed after each program name was current when we published this Bulletin.
When you order a distribution tape, diskette, or newer CD-ROM, some of the
programs may be newer and therefore the version number higher. See the *note
Free Software Foundation Order Form::., for ordering information.
Some of the contents of our tape and FTP distributions are compressed. We
have software on our tapes and FTP sites to uncompress these files. Due to
patent troubles with `compress', we use another compression program, `gzip'.
(Such prohibitions on software development are fought by the League for
Programming Freedom; *note What Is the LPF::., for details.)
GNU `make' is on several of our tapes because some system vendors supply no
`make' utility at all and some native `make' programs lack the `VPATH'
feature essential for using the GNU configure system to its full extent. The
GNU `make' sources have a shell script to build `make' itself on such systems.
We welcome all bug reports and enhancements sent to the appropriate
electronic mailing list (*note Free Software Support::.).
Configuring GNU Software
------------------------
We are using, Autoconf, a uniform scheme for configuring GNU software
packages in order to compile them (see "Autoconf" below, in this article).
The goal is to have all GNU software support the same alternatives for naming
machine and system types.
Ultimately, it will be possible to configure and build the entire system all
at once, eliminating the need to configure each individual package separately.
You can also specify both the host and target system to build
cross-compilation tools. Most GNU programs now use Autoconf-generated
configure scripts.
GNU Software currently available
--------------------------------
For future programs and features, see *Note Forthcoming GNUs::.
Key to cross reference:
BinCD
December 1994 Binaries CD-ROM
DjgpD
Djgpp Diskettes
DosBC
MS-DOS Book with CD-ROM
EmcsD
Emacs Diskettes
LangT
Languages Tape
LiteT
4.4BSD-Lite Tape
LspEmcT
Lisps/Emacs Tape
SchmT
Scheme Tape
SrcCD
December 1995 Source CD-ROMs
UtilD
Selected Utilities Diskettes
UtilT
Utilities Tape
VMSCmpT
VMS Compiler Tape
VMSEmcsT
VMS Emacs Tape
WdwsD
Windows Diskette
X11OptT
X11 Optional Tape
X11ReqT
X11 Required Tape
[FSFman] shows that we sell a manual for that package. [FSFrc] shows we sell
a reference card for that package. To order them, see the *note Free
Software Foundation Order Form::.. *Note Documentation::, for more
information on the manuals. Source code for each manual or reference card is
included with each package.
* `acm' (SrcCD, UtilT)
`acm' is a LAN-oriented, multiplayer aerial combat simulation that runs
under the X Window System. Players engage in air to air combat against
one another using heat seeking missiles and cannons. We are working on
a more accurate simulation of real airplane flight characteristics.
* apache (SrcCD)
Apache is an HTTP server designed as a plug-in replacement for version
1.3 or 1.4 of the NCSA server. It fixes numerous bugs in the NCSA
server and includes many frequently requested new features, and has an
API which allows it to be extended to meet users' needs more easily.
* Autoconf (SrcCD, UtilT)
Autoconf produces shell scripts which automatically configure source code
packages. These scripts adapt the packages to many kinds of Unix-like
systems without manual user intervention. Autoconf creates a script for
a package from a template file which lists the operating system features
which the package can use, in the form of `m4' macro calls. Autoconf
requires GNU `m4' to operate, but the resulting configure scripts it
generates do not.
* BASH (SrcCD, UtilT)
GNU's shell, BASH (Bourne Again SHell), is compatible with the Unix `sh'
and offers many extensions found in `csh' and `ksh'. BASH has job
control, `csh'-style command history, command-line editing (with Emacs
and `vi' modes built-in, and the ability to rebind keys) via the
`readline' library. BASH conforms to the POSIX 1003.2-1992 standard.
* `bc' (DosBC, SrcCD, UtilT)
`bc' is an interactive algebraic language with arbitrary precision
numbers. GNU `bc' follows the POSIX 1003.2-1992 standard, with several
extensions including multi-character variable names, an `else'
statement, and full Boolean expressions. The RPN calculator `dc' is now
distributed as part of the same package, but GNU `bc' is not implemented
as a `dc' preprocessor.
* BFD (BinCD, DjgpD, DosBC, LangT, SrcCD)
The Binary File Descriptor library allows a program which operates on
object files (e.g., `ld' or GDB) to support many different formats in a
clean way. BFD provides a portable interface, so that only BFD needs to
know the details of a particular format. One result is that all
programs using BFD will support formats such as a.out, COFF, and ELF.
BFD comes with Texinfo source for a manual (not yet published on paper).
At present, BFD is not distributed separately; it is included with
packages that use it.
* Binutils (BinCD, DjgpD, DosBC, LangT, SrcCD; `gas' only on VMSCmpT)
Binutils includes these programs: `ar', `c++filt', `demangle', `gas',
`gprof', `ld', `nlmconv', `nm', `objcopy', `objdump', `ranlib', `size',
`strings', & `strip'.
Binutils version 2 uses the BFD library. The GNU assembler, `gas',
supports the a29k, Alpha, H8/300, H8/500, HP-PA, i386, i960, m68k, m88k,
MIPS, NS32K, SH, SPARC, Tahoe, Vax and Z8000 CPUs, and attempts to be
compatible with many other assemblers for UNIX and embedded systems. It
can produce mixed C-and-assembly listings, and includes a macro facility
similar to that in some other assemblers. GNU's linker `ld' emits
source-line numbered error messages for multiply-defined symbols and
undefined references, and interprets a superset of AT&T's Linker Command
Language, which gives control over where segments are placed in memory.
`nlmconv' converts object files into Novell NetWare Loadable Modules.
`objdump' can disassemble code for most of the CPUs listed above, and
can display other data (e.g., symbols and relocations) from any file
format read by BFD.
* Bison (BinCD,DjgpD,DosBC,LangT,SrcCD,VMSCmpT)[FSFman,FSFrc]
Bison is an upwardly compatible replacement for the parser generator
`yacc'. Texinfo source for the `Bison Manual' and reference card are
included. *Note Documentation::.
A recent policy change allows non-free programs to use Bison-generated
parsers. *Note Conditions for Using Bison::.
* C Library (BinCD, LangT, SrcCD) [FSFman]
The GNU C library supports ANSI C-1989, POSIX 1003.1-1990 and most of the
functions in POSIX 1003.2-1992. It is upwardly compatible with 4.4BSD
and includes many System V functions, plus GNU extensions.
The C Library performs many functions of the Unix system calls in the
GNU/Hurd. Mike Haertel has written a fast `malloc' which wastes less
memory than the old GNU version. The GNU regular-expression functions
(`regex' and `rx') now nearly conform to the POSIX 1003.2 standard.
GNU `stdio' lets you define new kinds of streams, just by writing a few
C functions. The `fmemopen' function uses this to open a stream on a
string, which can grow as necessary. You can define your own `printf'
formats to use a C function you have written. For example, you can
safely use format strings from user input to implement a `printf'-like
function for another programming language. Extended `getopt' functions
are already used to parse options, including long options, in many GNU
utilities.
The C Library runs on Sun-3 (SunOS 4.1), Sun-4 (SunOS 4.1 or Solaris 2),
HP 9000/300 (4.3BSD), SONY News 800 (NewsOS 3 or 4), MIPS DECstation
(Ultrix 4), DEC Alpha (OSF/1), i386/i486/Pentium (System V, SVR4, BSD,
SCO 3.2, & SCO ODT 2.0), Sequent Symmetry i386 (Dynix 3), & SGI (Irix
4). *Note Forthcoming GNUs::. Texinfo source for the
`GNU C Library Reference Manual' is included (*note Documentation::..
* C++ Library (BinCD, DjgpD, DosBC, LangT, SrcCD)
The GNU C++ library (libg++) contains an extensive collection of C++
"forest" classes, an IOStream library for input/output routines, and
support tools for use with G++. Supported classes include: Obstacks,
multiple-precision Integers and Rationals, Complex numbers, arbitrary
length Strings, BitSets, and BitStrings.
The distribution also includes the libstdc++ library. This implements
library facilities defined by the forthcoming ANSI/ISO C++ standard,
including a port of the Standard Template Library.
* Calc (DosBC, LspEmcT, SrcCD) [FSFman, FSFrc]
Calc (written by Dave Gillespie in Emacs Lisp) is an extensible, advanced
desk calculator & mathematical tool that runs as part of GNU Emacs. You
can use Calc just as a simple four-function calculator, but it has many
more features including: choice of algebraic or RPN (stack-based) entry;
logarithmic, trigonometric, & financial functions; arbitrary precision;
complex numbers; vectors; matrices; dates; times; infinities; sets;
algebraic simplification; differentiation & integration. It outputs to
`gnuplot', & comes with source for a manual & reference card (*note
Documentation::.).
* `cfengine' (SrcCD, UtilT)
`cfengine' is used for maintaining site-wide configuration of a
heterogeneous Unix network using a simple high level language. Its
appearance is similar to `rdist', but also allows many more operations
to be performed automatically. See Mark Burgess, "A Site Configuration
Engine", `Computing Systems', Vol. 8, No. 3 (ask `office@usenix.org' how
to get a copy).
* Chess (SrcCD, UtilT, WdwsD)
GNU Chess enables most modern computers to play a full game of chess. It
supports a plain terminal interface, a curses interface, and a spiffy X
Window interface via `xboard'.
Improvements this past year include fixes to the game analyzer, book, &
hash table; smartening up draw and mate; improved thinking on opponent's
time; Autoconf installation; a makefile for Windows NT compilation;
forward pruning; unlimited quiescence captures; improved evaluation;
improved null & time control logic; & repetition-detection.
GNU Chess was originated by Stuart Cracraft. Improvements & rewrites are
from John Stanback, Cha Kong Sian, Mike McGann, and many others.
Send bugs to `bug-gnu-chess@prep.ai.mit.edu' & general comments to
`info-gnu-chess@prep.ai.mit.edu'.
* CLISP (LspEmcT, SrcCD)
CLISP is a Common Lisp implementation by Bruno Haible and Michael Stoll.
It mostly supports the Lisp described by `Common LISP: The Language (2nd
edition)' and the ANSI Common Lisp standard. CLISP includes an
interpreter, a byte-compiler, a large subset of CLOS, a foreign language
interface, and, for some machines, a screen editor. The user interface
language (English, German, French) is choosable at run time. Major
packages that run in CLISP include CLX & Garnet. CLISP needs only 2 MB
of memory & runs on many microcomputers (including MS-DOS systems, OS/2,
Windows NT, Amiga 500-4000, Acorn RISC PC) & Unix-like systems
(GNU/Linux, Sun4, SVR4, SGI, HP-UX, DEC Alpha, NeXTStep, & others).
* Common Lisp **Note Forthcoming GNUs::* (LspEmcT, SrcCD)
GNU Common Lisp (GCL, formerly known as Kyoto Common Lisp) is a compiler
& interpreter for Common Lisp. GCL is very portable & extremely
efficient on a wide class of applications, & compares favorably in
performance with commercial Lisps on several large theorem-prover &
symbolic algebra systems. GCL supports the CLtL1 specification but is
moving towards the proposed ANSI standard.
GCL compiles to C & then uses the native optimizing C compiler (e.g.,
GCC). A function with a fixed number of args & one value turns into a C
function of the same number of args, returning one value--so GCL is
maximally efficient on such calls. Its conservative garbage collector
gives great freedom to the C compiler to put Lisp values in registers.
It has a source level Lisp debugger for interpreted code & displays
source code in an Emacs window. Its profiler (based on the C profiling
tools) counts function calls & the time spent in each function.
There is now a built-in interface to the Tk widget system. It runs in a
separate process, so users may monitor progress on Lisp computations or
interact with running computations via a windowing interface.
There is also an Xlib interface via C (xgcl-2)® CLX runs with GCL, as
does PCL (see "PCL" later in this article). *Note Forthcoming GNUs::,
for plans regarding GCL or for recent developments.
GCL version 2.2 is released under the GNU Library General Public License.
* CLX (LspEmcT, SrcCD)
CLX is an X Window interface library for GCL.
* `cpio' (DosBC, SrcCD, UtilD, UtilT)
`cpio' is an archive program with all the features of SVR4 `cpio',
including support for the final POSIX 1003.1 `ustar' standard. `mt', a
program to position magnetic tapes, is included with `cpio'.
* CVS (SrcCD, UtilT)
CVS, the Concurrent Version System, manages software revision & release
control at a multi-developer, multi-directory, multi-group site. It
works best with RCS versions 4 and above, but will parse older RCS
formats, losing some of CVS's fancier features. (See Berliner, Brian,
"CVS-II: Parallelizing Software Development," `Proceedings of the Winter
1990 USENIX Association Conference'; ask `office@usenix.org' how to get
a copy.)
* DejaGnu (LangT, SrcCD)
DejaGnu is a framework to test programs with a single front end for all
tests. The framework's flexibility & consistency makes it easy to write
tests.
DejaGnu comes with `expect', which runs scripts to conduct dialogs with
programs.
* Diffutils (DjgpD, DosBC, SrcCD, UtilT)
GNU `diff' compares files showing line-by-line changes in several
flexible formats. It is much faster than traditional Unix versions. The
Diffutils package contains `diff', `diff3', `sdiff', & `cmp'. Recent
improvements include more consistent handling of character sets and a
new `diff' option to do all input/output in binary; this is useful on
some non-POSIX hosts. Plans for the Diffutils package include support
for internationalization (e.g., error messages in Chinese) and for some
non-Unix PC environments.
* DJGPP (BinCD, DjgpD, DosBC)
DJ Delorie has ported GCC/G++ (see "GCC" in this article) to i386s
running MS-DOS. DJGPP has a 32-bit i386 DOS extender with a symbolic
debugger; development libraries; & ports of Bison, `flex', & Binutils.
Full source code is provided. It needs at least 5MB of hard disk space
to install & 512K of RAM to use. It supports SVGA (up to 1024x768), XMS
& VDISK memory allocation, `himem.sys', VCPI (e.g., QEMM, DESQview, &
386MAX), & DPMI (e.g., Windows 3.x, OS/2, QEMM, & QDPMI).
The FSF offers it on the *Note Compiler Tools Binaries CD-ROM::, and on
the *Note DJGPP Diskettes::. FTP from `oak.oakland.edu' in
`/simtel/vendors/djgpp/' (or another SimTel mirror site).
To join a DJGPP users mailing list, ask
`djgpp-request@sun.soe.clarkson.edu'.
* `dld' (LangT, SrcCD)
`dld' is a dynamic linker written by W. Wilson Ho. Linking your program
with the `dld' library allows you to dynamically load object files into
the running binary. Currently supported are VAX (Ultrix), Sun 3 (SunOS
3.4 & 4.0), SPARC (SunOS 4.0), Sequent Symmetry (Dynix), & Atari ST.
* `doschk' (DosBC, SrcCD, UtilT)
This program is a utility to help software developers ensure that their
source file names are distinguishable on System V platforms with
14-character filenames and on MS-DOS systems with 8+3 character
filenames.
* `ecc' (LangT, SrcCD)
`ecc' is a Reed-Solomon error correction checking program, which can
correct three byte errors in a block of 255 bytes and detect more severe
errors. Contact `paulf@stanford.edu' for more information.
* `ed' (SrcCD, UtilT)
`ed' is the standard text editor. It is line-oriented and can be used
interactively or in scripts.
* Elib (DosBC, LspEmcT, SrcCD)
Elib is a small library of Emacs Lisp functions, including routines for
using AVL trees and doubly-linked lists.
* Elisp archive (SrcCD)
This is a snapshot of Ohio State's GNU Emacs Lisp FTP Archive. FTP it
from `archive.cis.ohio-state.edu' in `/pub/gnu/emacs/elisp-archive'.
* Emacs **Note Forthcoming GNUs:: for future plans.*
In 1975, Richard Stallman developed the first Emacs, an extensible,
customizable real-time display editor & computing environment. GNU Emacs
is his second implementation. It offers true Lisp--smoothly integrated
into the editor--for writing extensions & provides an interface to the X
Window System. It runs on Unix, MS-DOS, & Windows NT. In addition to
its powerful native command set, Emacs has extensions which emulate the
editors vi & EDT (Digital's VMS editor). Emacs has many other features
which make it a full computing support environment. Source for the `GNU
Emacs Manual' & a reference card comes with the software. Sources for
the `GNU Emacs Lisp Reference Manual' & `Programming in Emacs Lisp: An
Introduction' are distributed in separate packages. *Note
Documentation::.
* Emacs 18 (LspEmcT, SrcCD, VMSEmcsT) [FSFrc]
Emacs 18.59 is the last release of version 18 from the FSF. We no longer
maintain it. It supports these Unix systems that Emacs 19 doesn't
support (please help port Emacs 19 to these systems): Alliant FX/80,
Altos 3068, Amdahl (UTS), AT&T (3Bs & 7300 PC), CCI 5/32 & 6/32,
Celerity, Digital (VAX VMS), Dual, Encore (APC, DPC, & XPC), HLH Orion
(original & 1/05), ISI (Optimum V, 80386), Masscomp, NCR Tower 32 (SVR2
& SVR3), Nixdorf Targon 31, Nu (TI & LMI), pfa50, Plexus, Prime EXL,
Stride (system rel. 2), Tahoe, Tandem Integrity S2, Tektronix 16000,
Triton 88, Ustation E30 (SS5E), Whitechapel (MG1), & Wicat.
* Emacs 19 (DosBC, EmcsD, LspEmcT, SrcCD) [FSFman(s), FSFrc]
Emacs 19 works with character-only terminals & with the X Window System
(with or without an X toolkit). New features in Emacs 19 include:
multiple X windows ("frames" to Emacs), with a separate X window for the
minibuffer or a minibuffer attached to each X window; property lists
associated with regions of text in a buffer; multiple fonts & colors
defined by those properties; simplified/improved processing of function
keys, mouse clicks, and mouse movement; X selection processing,
including clipboard selections; hooks to be run if the point or mouse
moves outside a certain range; menu bars and popup menus defined by
keymaps; scrollbars; before- and after-change hooks; a source-level
debugger for Emacs Lisp programs; floating point numbers; improved
buffer allocation, including returning storage to the system when a
buffer is killed; interfacing with the X resource manager; many updated
libraries; integrated support for version control systems (RCS, CVS, &
SCCS); Autoconf based configuration; and support for European character
sets.
Recent features include the ability to open frames on more than one X
display from a single Emacs job, operation on MS-DOS, MS Windows, and
Windows NT, displaying multiple views of an outline at the same time,
support for the Athena & Motif widgets, version control support for CVS
and for multiple branches, text properties for formatting text, commands
to edit text properties and save them in files, and GNU-standard
long-named command line options.
Emacs 19.30 works on: Acorn RISC (RISCiX); Alliant FX/2800 (BSD); Alpha
(OSF/1); Apollo (DomainOS); Bull DPX/2 2nn & 3nn (SysV.3) & sps7
(SysV.2); Clipper; Convex (BSD); Cubix QBx (SysV); Data General Aviion
(DGUX); DEC MIPS (Ultrix 4.2, OSF/1, not VMS); Elxsi 6400 (SysV); Gould
Power Node & NP1 (4.2 & 4.3BSD); Harris Night Hawk 1200, 3000, 4000 &
5000 (cxux); Honeywell XPS100 (SysV); HP 9000 series 200, 300, 700, 800
(but not 500) (4.3BSD; HP-UX 7, 8, 9); Intel i386/i486/Pentium
(GNU/Linux, 386BSD, AIX, BSDI/386, FreeBSD, Esix, ISC, MS-DOS (*note
MS-DOS Diskettes::., & *Note MS-DOS Book with CD-ROM::), NetBSD,
SCO3.2v4, Solaris, SysV, Xenix, WindowsNT); IBM RS/6000 (AIX 3.2) &
RT/PC (AIX, BSD); Motorola Delta 147 & 187 (SysV.3, SysV.4, m88kbcs);
National Semiconductor 32K (Genix); NeXT (BSD, Mach 2 w/ NeXTStep 3.0);
Paragon (OSF/1); Prime EXL (SysV); Pyramid (BSD); Sequent Symmetry (BSD,
ptx); Siemens RM400 & RM600 (SysV); SGI Iris 4D (Irix 4.x & 5.x); Sony
News/RISC (NewsOS); Stardent i860 (SysV); Sun 3 & 4, SPARC 1, 1+, 2, 10,
Classic (SunOS 4.0, 4.1, Solaris 2.0-2.3); Tadpole 68k (SysV); Tektronix
XD88 (SysV.3) & 4300 (BSD); & Titan P2 & P3 (SysV).
Other configurations supported by Emacs 18 should work with few changes
in Emacs 19; as users tell us more about their experiences with different
systems, we will augment the list. Also see *Note Forthcoming GNUs::.
* `es' (SrcCD, UtilT)
`es' is an extensible shell (based on `rc') with first class functions,
lexical scope, exceptions and rich return values (i.e., functions can
return values other than just numbers). `es''s extensibility comes from
the ability to modify and extend the shell's built-in services, such as
path searching and redirection. Like `rc', it is great for both
interactive use and scripting, particularly since its quoting rules are
much less baroque than the C and Bourne shells.
* `f2c' (LangT, SrcCD)
`f2c' converts Fortran-77 source into C or C++, which can be compiled
with GCC or G++. Get bug fixes by FTP from site `netlib.att.com' or by
email from `netlib@research.att.com'. See the file
`/netlib/f2c/readme.Z' for a summary. Also see the GNU Fortran item
later in this article, and in *Note Forthcoming GNUs::.
* `ffcall' (SrcCD)
`ffcall' is a C library for implementing foreign function calls in
embedded interpreters by Bill Triggs and Bruno Haible. It allows C
functions with arbitrary argument lists and return types to be called or
emulated (callbacks).
* Fileutils (DosBC, SrcCD, UtilT)
The Fileutils work on files: `chgrp', `chmod', `chown', `cp', `dd', `df',
`dir', `du', `install', `ln', `ls', `mkdir', `mkfifo', `mknod', `mv',
`rm', `rmdir', `sync', `touch', & `vdir'.
* Findutils (DosBC, SrcCD, UtilT)
`find' is frequently used both interactively and in shell scripts to
find files which match certain criteria and perform arbitrary operations
on them. Also included are `locate', which scans a database for file
names that match a pattern, and `xargs', which applies a command to a
list of files.
* Finger (SrcCD, UtilT)
GNU Finger has more features than other finger programs. For sites with
many hosts, a single host may be designated as the finger "server" host
and other hosts at that site configured as finger "clients". The server
host collects information about who is logged in on the clients. To
finger a user at a GNU Finger site, a query to any of its client hosts
gets useful information. GNU Finger supports many customization
features, including user output filters and site programmable output for
special target names.
* `flex' (BinCD, DjgpD, DosBC, LangT, SrcCD, UtilD) [FSFman, FSFrc]
`flex' is a replacement for the `lex' scanner generator. `flex' was
written by Vern Paxson of the Lawrence Berkeley Laboratory and generates
far more efficient scanners than `lex' does. Sources for the `Flex
Manual' and reference card are included (*note Documentation::.).
* Fortran (`g77') **Note Forthcoming GNUs::* (LangT, SrcCD)
GNU Fortran (`g77'), developed by Craig Burley, is available for public
beta testing on the Internet. For now, `g77' produces code that is
mostly object-compatible with `f2c' & uses the same run-time library
(`libf2c').
* Fontutils (SrcCD, UtilT)
The Fontutils convert between font formats, create fonts for use with
Ghostscript or TeX (starting with a scanned type image & converting the
bitmaps to outlines), et al. It includes: `bpltobzr', `bzrto',
`charspace', `fontconvert', `gsrenderfont', `imageto', `imgrotate',
`limn', & `xbfe'.
* GAWK (DosBC, LangT, SrcCD) [FSFman]
GAWK is upwardly compatible with the latest POSIX specification of
`awk'. It also provides several useful extensions not found in other
`awk' implementations. Texinfo source for the `GAWK Manual' comes with
the software (*note Documentation::.).
* GCC (BinCD, DjgpD, DosBC, LangT, SrcCD, VMSCmpT) [FSFman]
Version 2 of the GNU C Compiler supports the languages C, C++, and
Objective-C; the source file name suffix or a compiler option selects
the language. Objective-C support was donated by NeXT. The runtime
support needed to run Objective-C programs is now distributed with GCC
(this does not include any Objective-C classes aside from `object', but
see "GNUstep" in *Note Forthcoming GNUs::). As much as possible, G++ is
kept compatible with the evolving draft ANSI standard, but not with
`cfront' (AT&T's compiler), which has been diverging from ANSI.
The GNU C Compiler is a fairly portable optimizing compiler which
performs automatic register allocation, common sub-expression
elimination, invariant code motion from loops, induction variable
optimizations, constant propagation and copy propagation, delayed
popping of function call arguments, tail recursion elimination,
integration of inline functions and frame pointer elimination,
instruction scheduling, loop unrolling, filling of delay slots, leaf
function optimization, optimized multiplication by constants, a certain
amount of common subexpression elimination (CSE) between basic blocks
(though not all of the supported machine descriptions provide for
scheduling or delay slots), a feature for assigning attributes to
instructions, and many local optimizations that are automatically
deduced from the machine description.
GCC can open-code most arithmetic on 64-bit values (type `long long
int'). It supports extended floating point (type `long double') on the
68k; other machines will follow.
GCC supports full ANSI C, traditional C, & GNU C extensions (including:
nested functions support, nonlocal gotos, & taking the address of a
label).
GCC can generate a.out, COFF, ELF, & OSF-Rose files when used with a
suitable assembler. It can produce debugging information in these
formats: BSD stabs, COFF, ECOFF, ECOFF with stabs, & DWARF.
GCC generates code for many CPUs, including the a29k, Alpha ARM AT&T
DSP1610 Clipper Convex cN Elxsi Fujitsu Gmicro i370, i860, i960,
MIL-STD-1750a, MIPS, ns32k, PDP-11, Pyramid, ROMP, RS/6000, SH, SPUR,
Tahoe, VAX, & we32k. Position-independent code is generated for the
Clipper, Hitachi H8/300, HP-PA (1.0 & 1.1), i386/i486/Pentium, m68k,
m88k, SPARC, & SPARClite.
Operating systems supported include: GNU/Hurd, GNU/Linux, ACIS, AIX, AOS,
BSD, Clix, Concentrix, Ctix, DG/UX, Dynix, FreeBSD, Genix, HP-UX, Irix,
ISC, Luna, LynxOS, Minix, NetBSD, NewsOS, NeXTStep, OS/2, OSF, OSF-Rose,
RISCOS, SCO, Solaris 2, SunOS 4, System/370, SysV, Ultrix, Unos, VMS, &
Windows/NT.
Using the configuration scheme for GCC, building a cross-compiler is as
easy as building a native compiler.
Version 1 of GCC, G++, & libg++ are no longer maintained.
Texinfo source for the `Using and Porting GNU CC' manual, is included
with GCC (*note Documentation::.).
*Note Forthcoming GNUs::, for plans for later releases of GCC.
* GDB (BinCD, DjgpD, DosBC, LangT, SrcCD) [FSFman, FSFrc]
GDB, the GNU DeBugger, is a source-level debugger for C, C++, & Fortran.
GDB can debug both C and C++ programs, and will work with executables
produced by many different compilers; however, C++ debugging will have
some limitations if you do not use GCC.
GDB has a command line user interface, and Emacs has a GDB mode. Two X
interfaces (not distributed or maintained by the FSF) are: `gdbtk' (FTP
it from `ftp.cygnus.com' in directory `/pub/gdb'); and `xxgdb' (FTP it
from `ftp.x.org' in directory `/contrib/utilities').
Executable files and symbol tables are read via the BFD library, which
allows a single copy of GDB to debug programs with multiple object file
formats (e.g., a.out, COFF, ELF). Other features include a rich command
language, remote debugging over serial lines or TCP/IP, and watchpoints
(breakpoints triggered when the value of an expression changes).
GDB uses a standard remote interface to a simulator library which (so
far) has simulators for the Hitachi H8/300, H8/500, Super-H, & Zilog
Z8001/2.
GDB can perform cross-debugging. To say that GDB "targets" a platform
means it can perform native or cross-debugging for it. To say that GDB
can "host" a given platform means that it can be built on it, but cannot
necessarily debug native programs.
GDB can:
* "target" & "host": Amiga 3000 (Amix), DEC Alpha (OSF/1), DECstation
3100 & 5000 (Ultrix), HP 9000/300 (BSD, HP-UX), HP 9000/700 (HP-UX
9, 10), i386 (GNU/Hurd, GNU/Linux, BSD, FreeBSD, LynxOS, NetBSD,
SCO), IBM RS/6000 (AIX, LynxOS), Motorola Delta m88k (System V,
CX/UX), PC532 (NetBSD), Motorola m68k MVME-167 (LynxOS), NCR 3000
(SVR4), SGI (Irix V3, V4, V5), SONY News (NewsOS 3.x), SPARC
(LynxOS, NetBSD, Solaris, & SunOS 4.1 ) Sun-3 (SunOS 4.1), &
Ultracomputer (a29k running Sym1).
* "target", but not "host": AMD 29000 (COFF & a.out), Hitachi H8/300,
Hitachi SH, i386 (a.out, COFF, OS/9000), i960 (Nindy, VxWorks),
m68k/m68332 (a.out, COFF, VxWorks), MIPS (ELF, IDT ecoff), Fujitsu
SPARClite (a.out, COFF), & Z8000.
* "host", but not "target": IBM RT/PC (AIX), HP/Apollo 68k (BSD), &
Apple Macintosh (MacOS).
Sources for the manual, `Debugging with GDB', and a reference card are
included (*note Documentation::.).
* `gdbm' (LangT, SrcCD, UtilD)
`gdbm' is the GNU replacement for the traditional `dbm' and `ndbm'
libraries. It implements a database using quick lookup by hashing.
`gdbm' does not ordinarily make sparse files (unlike its Unix and BSD
counterparts).
* `gettext' (LangT, SrcCD)
The GNU `gettext' tool set contains everything maintainers need to
internationalize a package for messages, tools that help translators
localize messages to their native language, once a package has been
internationalized. *Note Help the GNU Translation Project::.
* Ghostscript (DosBC, SrcCD, UtilT)
The GNU release of Ghostscript is an interpreter for the Postscript
graphics language (*note Forthcoming GNUs::., for future plans).
The current version of GNU Ghostscript is 2.6.2. Features include the
ability to use the fonts provided by the platform on which Ghostscript
runs (X Window System & Microsoft (MS) Windows), resulting in much
better-looking screen displays; improved text file printing (like
`enscript'); a utility to extract the text from a Postscript language
document; a much more reliable (and faster) MS Windows implementation;
support for MS C/C++ 7.0; drivers for many new printers ( e.g. the
SPARCprinter), & for TIFF/F (Fax) file format; many more Postscript Level
2 facilities, including most of the color space facilities (but not
patterns); & the ability to switch between Level 1 & Level 2
dynamically. Version 2.6.2 adds a LaserJet 4 driver & several important
bug fixes to version 2.6.1.
Ghostscript executes commands in the Postscript language by writing
directly to a printer, drawing on an X window, or writing to files for
printing later or manipulating with other graphics programs.
Ghostscript includes a C-callable graphics library (for client programs
that do not want to deal with the Postscript language). It also supports
i386/i486/Pentiums running MS-DOS with EGA, VGA or SuperVGA graphics (but
please do *not* ask the FSF staff any questions about this; we do not
use MS-DOS).
* Ghostview (DosBC, SrcCD, UtilT)
Tim Theisen, `ghostview@cs.wisc.edu', created Ghostview, a previewer for
multi-page files with an X Window interface. Ghostview & Ghostscript
work together; Ghostview creates a viewing window & Ghostscript draws in
it.
* GIT (SrcCD, UtilT)
GIT is a set of interactive tools: an extensible file system browser, an
ASCII/hex file viewer, a process viewer/killer, & other related
utilities & shell scripts. It can be used to increase the speed &
efficiency of many daily tasks, such as copying & moving files &
directories, invoking editors, compressing/uncompressing files, creating
& expanding archives, compiling programs, sending mail, etc. It looks
nice, has colors (if the standard ANSI color sequences are supported), &
is user-friendly.
* `gmp' **Note Forthcoming GNUs::* (LangT, SrcCD)
GNU `mp' is a library for arbitrary precision arithmetic on signed
integers and rational numbers. It has a rich set of functions with a
regular interface.
* GN (SrcCD)
GN is a gopher/HTTP server. It recognizes whether the request came from
an HTTP (World Wide Web) or gopher client and responds accordingly.
* Gnans (SrcCD)
Gnans is a program (and language) for the numerical study of
deterministic and stochastic dynamical systems. The dynamical systems
may evolve in continuous or discrete time. Gnans has graphical &
command line interfaces.
* GNATS (SrcCD, UtilT)
GNATS (GNats: A Tracking System, not to be confused with GNAT, The GNU
Ada Translator) is a bug-tracking system. It is based upon the paradigm
of a central site or organization which receives problem reports and
negotiates their resolution by electronic mail. Although it has been
used primarily as a software bug-tracking system so far, it is
sufficiently generalized that it could be used for handling system
administration issues, project management, or any number of other
applications.
* `gnuplot' (SrcCD, UtilT, WdwsD)
`gnuplot' is an interactive program for plotting mathematical
expressions and data. It plots both curves (2 dimensions) & surfaces (3
dimensions). Curiously, it was neither written nor named for the GNU
Project; the name is a coincidence. Various GNU programs use `gnuplot'.
* `gnuserv' (LspEmcT, SrcCD)
`gnuserv' is a enhanced version of Emacs' `emacsclient' program. It
lets the user direct a running Emacs to edit files or evaluate arbitrary
Emacs Lisp constructs from another process.
* GnuGo (SrcCD, UtilT)
GnuGo plays the game of Go (Wei-Chi); version 1.2 was released with minor
changes for portability, but it is not yet very sophisticated.
* `gperf' (LangT, SrcCD)
`gperf' generates perfect hash tables. The C version is in package
cperf. The C++ version is in libg++. Both produce hash functions in
either C or C++.
* Graphics (SrcCD, UtilT)
GNU Graphics produces x-y plots from ASCII or binary data. It outputs
in Postscript, Tektronix 4010 compatible, and Unix device-independent
"plot" formats. It has a previewer for the X Window System. Features
include a `spline' interpolation program; examples of shell scripts
using `graph' and `plot'; a statistics toolkit; and output in TekniCAD
TDA and ln03 file formats. Email bugs or queries to Rich Murphey,
`Rich@lamprey.utmb.edu'.
* grep (DosBC, SrcCD, UtilT)
This package has GNU `grep', `egrep', and `fgrep', which find lines that
match entered patterns. They are much faster than the traditional Unix
versions.
* Groff (DjgpD, DosBC, SrcCD, UtilT)
Groff is a document formatting system based on a device-independent
version of `troff' & includes: `eqn', `nroff', `pic', `refer', `tbl',
`troff'; the `man', `ms', & `mm' macros; & drivers for Postscript, TeX
`dvi' format, and typewriter-like devices. Groff's `mm' macro package
is almost compatible with the DWB `mm' macros with several extensions.
Also included is a modified version of the Berkeley `me' macros and an
enhanced version of the X11 `xditview' previewer. A driver for the
LaserJet 4 series of printers is currently in test. Written in C++,
these programs can be compiled with GNU C++ Version 2.5 or later.
Groff users are encouraged to contribute enhancements. Most needed are
complete Texinfo documentation, a `grap' emulation (a `pic' preprocessor
for typesetting graphs), a page-makeup postprocessor similar to `pm'
(see `Computing Systems', Vol. 2, No. 2; ask `office@usenix.org' how to
get a copy), and an ASCII output class for `pic' to integrate `pic' with
Texinfo. Questions and bug reports from users who have read the
documentation provided with Groff can be sent to
`bug-groff@prep.ai.mit.edu'.
* `gzip' (DjgpD, DosBC, LangT, LspEmcT, SrcCD, UtilT)
`gzip' can expand LZW-compressed files but uses another, unpatented
algorithm for compression which generally produces better results. It
also expands files compressed with System V's `pack' program.
* `hello' (DosBC, SrcCD, UtilT)
The GNU `hello' program produces a familiar, friendly greeting. It
allows non-programmers to use a classic computer science tool which would
otherwise be unavailable to them. Because it is protected by the GNU
General Public License, users are free to share and change it. `hello'
is also a good example of a program that meets the GNU coding standards.
Like any truly useful program, `hello' contains a built-in mail reader.
* `hp2xx' (SrcCD, UtilT)
GNU `hp2xx' reads HP-GL files, decomposes all drawing commands into
elementary vectors, and converts them into a variety of vector and raster
output formats. It is also an HP-GL previewer. Currently supported
vector formats include encapsulated Postscript, Uniplex RGIP, Metafont,
various special TeX-related formats, and simplified HP-GL (line drawing
only) for imports. Raster formats supported include IMG, PBM, PCX, &
HP-PCL (including Deskjet & DJ5xxC support). Previewers work under X11
(Unix), OS/2 (PM & full screen), & MS-DOS (SVGA, VGA, & HGC).
* HylaFAX (SrcCD, UtilT)
HylaFAX (once named FlexFAX) is a facsimile system for Unix systems. It
supports sending, receiving, & polled retrieval of facsimile, as well as
transparent shared data use of the modem.
Details are available on the World Wide Web at:
`http://www.vix.com/hylafax/'.
* Hyperbole (LspEmcT, SrcCD)
Hyperbole, written by Bob Weiner in Emacs Lisp, is an open, efficient,
programmable information management & hypertext system, intended for
everyday work on any platform supported by Emacs.
* `indent' (DosBC, LangT, SrcCD, UtilD)
GNU `indent' formats C source code into the GNU indentation style. It
also has options to output BSD, K&R, or your own special style. GNU
`indent' is more robust & provides more functionality than other such
programs, including handling C++ comments. It runs on a number of
systems, including DOS & VMS.
The next version will also format C++ source code.
* Ispell (DosBC, SrcCD, UtilT)
Ispell is an interactive spell checker that suggests "near misses" to
replace unrecognized words. System & user-maintained dictionaries for
multiple languages can be used. Standalone & Emacs interfaces are
available.
Previously, the FSF had its own version of Ispell ("Ispell 4.0"), but
has dropped it for a parallel branch that has had more development
("Ispell 3.1"). (Ispell 3 was an earlier release by the original Ispell
author, but others have since made it more sophisticated.)
* JACAL *Not available from the FSF except by FTP*
JACAL is a symbolic mathematics system for the manipulation and
simplification of algebraic equations and expressions. New in JACAL is
multivariate factoring from Michael Thomas `(mjt@octavia.anu.edu.au)'.
See JACAL's documentation at `http://www-swiss.ai.mit.edu/~jaffer/'.
JACAL is written in Scheme using the SLIB portable Scheme Library. It
comes with SCM, an IEEE P1178 & R4RS compliant version of Scheme written
in C® SCM runs on Amiga, Atari-ST, MS-DOS, OS/2, NOS/VE, Unicos, VMS,
Unix, & similar systems.
The FSF is not distributing JACAL on any physical media. To get an IBM
PC floppy disk with the freely redistributable source & executable
files, send $99.00 to:
Aubrey Jaffer
84 Pleasant Street
Wakefield, MA 01880-1846
USA
* `less' (DosBC, SrcCD, UtilD, UtilT)
`less' is a display paginator similar to `more' and `pg', but with
various features (such as the ability to scroll backwards) that most
pagers lack.
* `m4' (DosBC, SrcCD, UtilD, UtilT)
GNU `m4' is an implementation of the traditional Unix macro processor.
It is mostly SVR4 compatible, although it has some extensions (e.g.,
handling more than 9 positional parameters to macros). `m4' also has
built-in functions for including files, running shell commands, doing
arithmetic, etc.
* `make' (BinCD,DjgpD,DosBC,LangT,LspEmcT,SrcCD,UtilD,UtilT)[FSFman]
GNU `make' supports POSIX 1003.2 and has all but a few obscure features
of the BSD and System V versions of `make'. GNU extensions include long
options, parallel compilation, flexible implicit pattern rules,
conditional execution, & powerful text manipulation functions. Texinfo
source for the `Make Manual' comes with the program (*note
Documentation::.).
* MandelSpawn (SrcCD, UtilT)
A parallel Mandelbrot generation program for the X Window System.
* Midnight Commander (`mc') (SrcCD, UtilT)
The Midnight Commander is a user friendly and colorful Unix file manager
and shell, useful to novice and guru alike. It has a built-in virtual
file system that allows the user to manipulate files inside tar files
(both regular and compressed) or files on remote machines using the FTP
protocol.
* `mkisofs' (SrcCD, UtilT)
`mkisofs' is a pre-mastering program to generate an ISO 9660 file system.
It takes a snapshot of a directory tree, and makes a binary image which
corresponds to an ISO 9660 file system when written to a block device.
It can also generate the System Use Sharing Protocol records of the Rock
Ridge Interchange Protocol (used to further describe the files in an ISO
9660 file system to a Unix host; it provides information such as longer
filenames, uid/gid, permissions, and device nodes).
Also included is `cdwrite', which can take an image from `mkisofs' and
write it to a Phillips CD recorder system attached to a GNU/Linux system.
* mtools (SrcCD, UtilT)
mtools is a set of public domain programs to allow Unix systems to read,
write, and manipulate files on an MS-DOS file system (usually a
diskette).
* MULE (DosBC, EmcsD, LspEmcT, SrcCD)
MULE is a MULtilingual Enhancement to GNU Emacs. MULE text buffers can
contain a mix of characters from many languages including: Japanese,
Chinese, Korean, Vietnamese, Thai, modern European languages (including
Greek & Russian), Arabic, & Hebrew. MULE also provides input methods
for all of them. MULE is being merged into GNU Emacs. *Note GNU &
Other Free Software in Japan::, for more information about MULE.
* `ncurses' (LangT, SrcCD)
`ncurses' is an implementation of the Unix `curses' library for
developing screen based programs that are terminal independent.
* NetHack (SrcCD, UtilT)
NetHack is a Rogue-like adventure game supporting character & X displays.
* NIH Class Library (LangT, SrcCD)
The NIH Class Library (once known as "OOPS", Object-Oriented Program
Support) is a portable collection of C++ classes (similar to those in
Smalltalk-80) written in C++ by Keith Gorlen of the National Institutes
of Health (NIH).
* `nvi' (SrcCD, UtilT)
`nvi' is a free implementation of the `vi'/`ex' Unix editor. It has
most of the functionality of the original `vi'/`ex', except "open" mode
& the `lisp' option, which will be added. Enhancements over `vi'/`ex'
include split screens with multiple buffers, handling 8-bit data,
infinite file & line lengths, tag stacks, infinite undo, & extended
regular expressions. It runs under GNU/Linux, BSD, NetBSD, FreeBSD,
BSDI, AIX, HP-UX, DGUX, IRIX, PSF, PTX, Solaris, SunOS, Ultrix, and
Unixware, & should port easily to other systems.
* Oaklisp (SrcCD)
Oaklisp is a fast, portable, object-oriented Scheme with first class
types.
* Objective-C Library **Note Forthcoming GNUs::* (LangT, SrcCD)
Our Objective-C Class Library (`libobjects') has general-purpose,
non-graphical Objective-C objects written by Andrew McCallum & other
volunteers. It includes collection classes for using groups of objects
& C types, I/O streams, coders for formatting objects & C types to
streams, ports for network packet transmission, distributed objects
(remote object messaging), string classes, exceptions, pseudo-random
number generators, & time handling facilities. It also includes the
foundation classes for the GNUstep project; over 70 of them have already
been implemented. The library is known to work on i386/i486/Pentiums,
m68k, SPARC, MIPS, HPPA, & RS/6000. Send queries & bug reports to
`mccallum@gnu.ai.mit.edu'.
* OBST (LangT, SrcCD)
OBST is a persistent object management system with bindings to C++.
OBST supports incremental loading of methods. Its graphical tools
require the X Window System. It features a hands-on tutorial including
sample programs. It compiles with G++, and should install easily on
most Unix platforms.
* Octave (LangT, SrcCD)
Octave is a high-level language similar to MATLAB, primarily intended
for numerical computations. It has a convenient command line interface
for solving linear & nonlinear problems numerically.
Octave does arithmetic for real and complex scalars and matrices, solves
sets of nonlinear algebraic equations, integrates systems of ordinary
differential & differential-algebraic equations, and integrates
functions over finite & infinite intervals. Two- & three-dimensional
plotting is available using `gnuplot'.
Send queries and bug reports to: `bug-octave@bevo.che.wisc.edu'.
Texinfo source is included for a 220+ page Octave manual, not yet
published by the FSF.
* Oleo (SrcCD, UtilT)
Oleo is a spreadsheet program (better for you than the more expensive
spreadsheets). It supports the X Window System and character-based
terminals, and can output Embedded Postscript renditions of spreadsheets.
Keybindings should be familiar to Emacs users and are configurable.
Oleo supports multiple variable-width fonts when used under the X Window
System or outputting to Postscript devices.
* `p2c' (LangT, SrcCD)
`p2c' is Dave Gillespie's Pascal-to-C translator. It inputs many
different dialects (HP, ISO, Turbo, VAX, et al.) and generates readable,
maintainable, portable C.
* `patch' (DosBC, SrcCD, UtilT)
`patch' is our version of Larry Wall's program to take `diff''s output
and apply those differences to an original file to generate the modified
version.
* PCL (LspEmcT, SrcCD)
PCL is a free implementation of a large subset of CLOS, the Common Lisp
Object System. It runs under both GCL and CLISP, mentioned above.
* `perl' (DosBC, LangT, SrcCD)
Larry Wall's `perl' combines the features and capabilities of `sed',
`awk', `sh', and C® It also provides interfaces to the Unix system
calls and many C library routines.
* `pine' (SrcCD, UtilT)
`pine' is a friendly menu-driven electronic mail manager and user
interface .
* `ptx' **Note Forthcoming GNUs::* (SrcCD, UtilD, UtilT)
GNU `ptx' is our version of the traditional permuted index generator.
It handles multiple input files at once, produces TeX compatible output,
and generates readable "KWIC" (KeyWords In Context) indexes without
using `nroff'.
It does not yet handle input files that do not fit in memory all at once.
* `rc' (SrcCD, UtilT)
`rc' is a shell that features a C-like syntax (much more so than `csh')
and far cleaner quoting rules than the C or Bourne shells. It's
intended to be used interactively, but is also great for writing
scripts. It inspired the shell `es'.
* RCS (SrcCD, UtilD, UtilT)
RCS, the Revision Control System, is used for version control &
management of software projects. Used with GNU `diff', RCS can handle
binary files (executables, object files, 8-bit data, etc). RCS now
conforms to GNU configuration standards and to POSIX 1003.1b-1993. Also
see the CVS item above.
* `recode' **Note Forthcoming GNUs::* (SrcCD, UtilT)
GNU `recode' converts files between character sets and usages. When
exact transliterations are not possible, it may delete the offending
characters or fall back on approximations. This program recognizes or
outputs nearly 150 different character sets and is able to transliterate
files between almost any pair. Most RFC 1345 character sets are
supported.
* `regex' (LangT, SrcCD)
The GNU regular expression library supports POSIX.2, except for
internationalization features. It is included in many GNU programs which
do regular expression matching & is available separately. An alternate
regular expression package, `rx', is faster than `regex' in most cases &
will replace `regex' over time.
* `rx' (LangT, SrcCD)
Tom Lord has written `rx', a new regular expression library which is
faster than the older GNU `regex' library. It is now being distributed
with `sed' and `tar'. `rx' will be used in the next releases of `m4'
and `ptx'.
* SAOimage (SrcCD, UtilT)
SAOimage is an X-based astronomical image viewer. It reads data images
and displays them with a pseudocolor colormap. There is full interactive
control of the colormap, reading, and writing of colormaps, etc.
* Scheme *For more information, see *Note Scheme Tape::* (SrcCD, SchmT)
* `screen' (SrcCD, UtilT)
`screen' is a terminal multiplexer that runs several separate "screens"
(ttys) on a single character-based terminal. Each virtual terminal
emulates a DEC VT100 plus several ISO 2022 and ISO 6429 (ECMA 48, ANSI
X3.64) functions, including color. Arbitrary keyboard input translation
is also supported. `screen' sessions can be detached and resumed later
on a different terminal type. Output in detached sessions is saved for
later viewing.
* `sed' (DjgpD, DosBC, SrcCD, UtilD, UtilT)
`sed' is a stream-oriented version of `ed'. It comes with the `rx'
library.
* Sharutils (SrcCD, UtilT)
`shar' makes so-called shell archives out of many files, preparing them
for transmission by electronic mail services; `unshar' helps unpack
these shell archives after reception. `uuencode' and `uudecode' are
POSIX compliant implementations of a pair of programs to transform files
into a format that can be safely transmitted across a 7-bit ASCII link.
* Shellutils (DosBC, SrcCD, UtilT)
They are: `basename', `date', `dirname', `echo', `env', `expr', `false',
`groups', `hostname', `id', `logname', `nice', `nohup', `pathchk',
`printenv', `printf', `pwd', `sleep', `stty', `su', `tee', `test',
`true', `tty', `uname', `users', `who', `whoami', & `yes'.
* Shogi (SrcCD, UtilT)
Shogi is a Japanese game similar to Chess; a major difference is that
captured pieces can be returned into play.
GNU Shogi is a variant of GNU Chess; it implements the same features &
similar heuristics. As a new feature, sequences of partial board
patterns can be introduced to help the program play toward specific
opening patterns. It has both character and X display interfaces.
It is primarily supported by Matthias Mutz on behalf of the FSF.
* SIPP (SrcCD)
SIPP is a library for creating photorealistic renderings of 3D scenes.
A scene is built up of objects which can be transformed with rotation,
translation, and scaling. The objects form hierarchies where each object
can have arbitrarily many subobjects and subsurfaces. A surface is a
number of connected polygons which are rendered with either Phong,
Gouraud, or flat shading. The library supports programmable shaders and
texture mapping with textures in up to 3 dimensions and automatic
interpolation of texture coordinates. A scene can be illuminated by an
arbitrary number of light sources. The lights from some of them are
capable of casting shadows of objects.
* Smalltalk *Also see *Note Forthcoming GNUs::* (LangT,SrcCD)
GNU Smalltalk is an interpreted object-oriented programming language
system written in highly portable C® It has been ported to many Unix,
DOS, & other OSes. Features include a binary image save capability, the
ability to call user-written C code with parameters, an Emacs editing
mode, a version of the X protocol invocable from Smalltalk, optional
byte-code compilation and/or execution tracing, & automatically loaded
per-user initialization files. It implements all of the classes &
protocol in the book "Smalltalk-80: The Language", except for the
graphic user interface (GUI) related classes.
* SNePS (SrcCD)
SNePS is the Semantic Network Processing System. It is an
implementation of a fully intensional theory of propositional knowledge
representation and reasoning. SNePS runs under CLISP or GCL.
* Spinner (SrcCD)
Spinner is a modularized, object oriented, non-forking World Wide Web
server with high performance and throughput.
* Superopt (LangT, SrcCD)
Superopt is a function sequence generator that uses an exhaustive
generate-and-test approach to find the shortest instruction sequence for
a given function. You provide a function as input, a CPU to generate
code for, and how many instructions you want. Its use in GCC is
described in the `ACM SIGPLAN PLDI'92 Proceedings'. It supports: SPARC,
m68k, m68020, m88k, IBM POWER and PowerPC, AMD 29k, Intel x86 and 960,
Pyramid, DEC Alpha, Hitachi SH, & HP-PA.
* `tar' (DosBC, SrcCD, UtilT)
GNU `tar' includes multi-volume support, the ability to archive sparse
files, compression/decompression, remote archives, and special features
that allow `tar' to be used for incremental and full backups. GNU `tar'
uses an early draft of the POSIX 1003.1 `ustar' format which is
different from the final version. This will be corrected in the future.
* Termcap Library (SrcCD, UtilT) [FSFman]
The GNU Termcap library is a drop-in replacement for `libtermcap.a' on
any system. It does not place an arbitrary limit on the size of Termcap
entries, unlike most other Termcap libraries. Included is source for the
`Termcap Manual' in Texinfo format (*note Documentation::.).
* Termutils (SrcCD, UtilT)
The Termutils package contains programs for controlling terminals.
`tput' is a portable way for shell scripts to use special terminal
capabilities. `tabs' is a program to set hardware terminal tab settings.
* TeX (DosBC, SrcCD)
TeX is a document formatting system that handles complicated
typesetting, including mathematics. It is GNU's standard text formatter.
The University of Washington maintains & supports a tape distribution of
TeX for Unix systems. The core material is Karl Berry's `web2c' TeX
package. Sources are available via anonymous ftp; retrieval
instructions are in `/pub/tex/unixtex.ftp' on `ftp.cs.umb.edu'. If you
receive any installation support from the University of Washington,
consider sending them a donation.
To order a full distribution written in `tar' on either a 1/4inch
4-track QIC-24 cartridge or a 4mm DAT cartridge, send $210.00 to:
Pierre A. MacKay
Department of Classics
DH-10, Denny Hall 218
University of Washington
Seattle, WA 98195
USA
Electronic-Mail: `mackay@cs.washington.edu'
Telephone: +1-206-543-2268
Please make checks payable to: `University of Washington'. Do not
specify any other payee. That causes accounting problems. Checks must
be in U.S. dollars, drawn on a U.S. bank. Only prepaid orders can be
handled. Overseas sites: please add to the base cost $20.00 to ship via
air parcel post or $30.00 to ship via courier. Please check with the
above for current prices & formats.
* Texinfo (DjgpD,DosBC,LangT,LspEmcT,SrcCD,UtilD,UtilT)[FSFman]
Texinfo is a set of utilities (`makeinfo', `info', `texi2dvi',
`texindex', `tex2patch', & `fixfonts') which generate both printed
manuals & online hypertext documentation (called "Info"), & can read
online Info documents. Version 3 has both Emacs Lisp & standalone
programs written in C or shell script. Texinfo mode for Emacs enables
easy editing & updating of Texinfo files. Source for the `Texinfo
Manual' is included (*note Documentation::.).
* Textutils (DosBC, SrcCD, UtilT)
The Textutils programs manipulate textual data. They include: `cat',
`cksum', `comm', `csplit', `cut', `expand', `fmt', `fold', `head',
`join', `md5sum', `nl', `od', `paste', `pr', `sort', `split', `sum',
`tac', `tail', `tr', `unexpand', `uniq', and `wc'.
* Tile Forth (LangT, SrcCD)
Tile Forth is a 32-bit implementation of the Forth-83 standard written
in C, allowing it to be easily ported to new systems and extended with
any C-function (graphics, windowing, etc).
Many documented Forth libraries are available, including ones for
top-down parsing, multi-threads, & object oriented programming.
* `time' (SrcCD, UtilT)
`time' reports (usually from a shell) the user, system, & real time used
by a process. On some systems it also reports memory usage, page
faults, etc.
* `ucblogo' (LangT, SrcCD)
`ucblogo' implements the classic teaching language, Logo.
* UUCP (SrcCD, UtilT)
GNU's UUCP system (written by Ian Lance Taylor) supports the `f', `g',
`v' (all window & packet sizes), `G', `t', `e', Zmodem, & two new
bidirectional (`i' & `j') protocols. With a BSD sockets library, it can
make TCP connections. With TLI libraries, it can make TLI connections.
Source is included for a manual (not yet published by the FSF).
* W3 (LspEmcT, SrcCD)
W3 (written by William Perry in Emacs Lisp) is an extensible, advanced
World Wide Web browser that runs as part of GNU Emacs. It understands
many protocols: FTP, gopher, HTML, SMTP, Telnet, WAIS, et al.
* `wdiff' (DosBC, SrcCD, UtilT)
`wdiff' is a front-end to GNU `diff'. It compares two files, finding
the words deleted or added to the first to make the second. It has many
output formats and works well with terminals and pagers. `wdiff' is
very useful when two texts differ only by a few words and paragraphs
have been refilled.
* X11 *For details, see *Note X11 Tapes::* (SrcCD, X11OptT, X11ReqT)
* `xboard', `xshogi' (SrcCD, UtilT)
`xboard' is an X Window interface to GNU Chess. `xshogi' is an X Window
interface to GNU Shogi. They use the R4 Athena widgets and Xt
Intrinsics to provide an interactive referee for managing a game between
a user & a computer opponent, or between two computers. You can also use
`xboard' without GNU Chess to play through games in files or to play
through games manually (force mode); in this case, moves aren't
validated.
* `xgrabsc' (SrcCD)
`xgrabsc' is a screen capture program similar to `xwd' but providing
more ways of selecting the part of the screen to capture and different
types of output: Postscript, color Postscript, xwd, bitmap, pixmap, and
puzzle.
* `Ygl' (SrcCD, UtilT)
`Ygl' emulates a subset of SGI's GL (Graphics Language) library under
X11 on GNU/Linux with XFree, AIX 3.2, ConvexOS, HP-UX, SunOS, et al. It
has most two-dimensional graphics routines, the queue device & query
routines, double buffering, RGB mode with dithering, FORTRAN bindings,
at al.
----------------------------------------------------------------------
Forthcoming GNUs
****************
Information about the current status of released GNU programs can be found in
*Note GNU Software::. Here is some news of future plans.
* GNU C Library (For current status, *note GNU Software::..)
While there has not been a new release of our C library in some time, a
great deal of work is going on; we hope for a new release in the next few
months. Much of Roland's recent work has focused on support for
GNU/Hurd, where the library does much more work than in Unix (*note What
Is the Hurd::.). He has also been working closely with Ulrich Drepper
on support for GNU/Linux; we intend a future release of the GNU C
library to compatibly supersede the heavily modified version now used
with GNU/Linux. The new release will add several new functions
traditionally found in Unix systems & some small new GNU extensions, as
well as major new internationalization support. Ulrich Drepper has
contributed to the library a great deal in the last few months, by
writing new floating-point printing/reading functions that are perfectly
accurate & much faster than the old code. He has also written a
complete set of internationalization features including
POSIX.2-compatible `locale' & `localedef' programs, & catalogs for
displaying program messages in languages other than English. The
library now builds as a shared library for systems that use the ELF
object file format. Included is the run-time loader `ld.so' which sets
up the shared libraries when a program runs; it works now with the Hurd
& Linux kernels, and is easy to port to other ELF systems such as SVR4 &
Solaris 2.
* GNU Emacs (For current status, *note GNU Software::.)
Future versions of Emacs will save the undo history in a file (which
allows you to undo older changes in the history), and will also have
support for variable-width fonts, wide character sets, and the world's
major languages. Our long term plan is to move it in the direction of a
WYSIWYG word processor & make it easier for beginners to use.
* GNUstep (Also see "Objective-C Library" in *Note GNU Software::)
OpenStep is an object-oriented application programming interface
specification being proposed as an open object standard. Since its
announcement over two years ago, there has been much interest in a GNU
implementation, named GNUstep. Work has begun on GNUstep, starting from
a library written in Objective-C. Much remains to be done to bring this
library close to the OpenStep specifications. Volunteers should contact
`office@gnustep.org'. Check `http://www.gnustep.org/gnustep' for more
info.
* `recode' (For current status, *note GNU Software::.)
The next `recode' release should give more flexible control over
encodings of charsets, offer MIME conversions, & handle ISO-10646
(Unicode). It will install a library & support files to help work
towards internationalizing GNU.
* GUILE
GNU's Ubiquitous Extension Language is an SCM-based library which
programmers can use to make any ordinary C program extensible. (For
info on SCM, see "JACAL" in *Note GNU Software::.)
GUILE already includes a POSIX.1 interface, an SCSH-like library, a
module system, a Tk interface, & a byte-code interpreter; support for
Emacs Lisp & a more C-like language is coming.
Get snapshots from `ftp.cygnus.com:/pub/lord'.
* `ptx' (For current status, *note GNU Software::.)
The next release of `ptx' should offer contextualized support for SGML
texts, as the first step towards a major overhaul for that package.
* GNU Common Lisp (For current status, *note GNU Software::.)
Version 2.2 of GNU Common Lisp (GCL) was released in November '95. It
now includes a graphical interface to the Tk widget system. All
documentation is now Texinfo-based, with built-in regexp matching used
to access the documentation. A first pass at the Common Lisp condition
system is also included. Some new ports include DEC Alpha and ELF for
GNU/Linux. Volunteers to help with the move to the ANSI standard are
most welcome; contact `schelter@math.utexas.edu'.
* C Interpreter
We hope to add interpreter facilities to our compiler and debugger. This
task is partly finished. GCC has generated byte code for all supported
languages, but that support is in flux at this time. A new effort to
finish this work has begun. To make this work usable, we need to enhance
GDB to load the byte code dynamically. We would also like support for
compiling just a few selected functions in a file. Due to limited
resources, the FSF cannot fund this. Interested volunteers should
contact `gnu@prep.ai.mit.edu'.
* GCC (For current status, *note GNU Software::.)
New front ends for GCC are being developed for Pascal and Chill. See the
GNU Fortran and GNAT items in this article for news on those front ends.
* GNAT: The GNU Ada Translator *Not yet available from the FSF*
A front end for much of Ada 95 (GNAT: The GNU Ada Translator) is
available via anonymous FTP from `cs.nyu.edu' in `/pub/gnat'. SGI and
Digital have chosen GNU Ada as the Ada compiler for certain systems.
News about GNAT is posted to the USENET newsgroup `comp.lang.ada'.
* GNU Fortran (For info on `f2c' & GCC, *note GNU Software::.)
The GNU Fortran (`g77') front end is stable, but work is needed to bring
its overall packaging, feature set, & performance up to the levels the
Fortran community expects. Tasks to be done include: improving
documentation & diagnostics; speeding up compilation, especially for
large initialized data tables; implementing `INTEGER*2', `INTEGER*8', &
similar features; allowing intrinsics in `PARAMETER' statements; &
providing debug information on `COMMON' & `EQUIVALENCE' variables. We
don't know when these things will be done, but hope some will be
finished in the coming months. You can speed progress by working on
them or by offering funding.
A mailing list exists for announcements about `g77'. To subscribe, ask
`info-gnu-fortran-request@prep.ai.mit.edu'. To contact the developer of
`g77' or get current status, write or finger `fortran@gnu.ai.mit.edu'.
* Ghostscript (For current status, *note GNU Software::.)
Ghostscript 3.0 will be distributed by the FSF soon. It will implement
nearly the full Postscript Level 2 language except for LZW compression,
which can't be freely implemented because of software patents.
(Prohibitions on programming like this are what the League for
Programming Freedom is fighting. *Note What Is the LPF::, for details.)
* `gmp' (For current status, *note GNU Software::.)
The next version of the GNU `mp' library, 2.0, will have arbitrary
precision floating point arithmetic, and expanded support for integer and
rational number arithmetic. `gmp' 2.0 is up to 4 times faster than
previous versions. In particular, the speed of multiplication, division,
and GCD has improved.
* Smalltalk (For current status, *note GNU Software::.)
The next release, version 1.2, will use Autoconf. It will have
substantial performance improvements & memory requirement reductions,
more control over memory allocation, ability to use the Smalltalk
interpreter as a C callable library, better X Window System interfaces,
ability to represent and manipulate C data structures in Smalltalk,
conditional compilation facilities, large integer support, an advanced
GUI-based class browsing system, better TCP/IP interfaces, exception
support, weak references, & finalization support. It will run on UNIX,
DOS, & Windows NT.
* The Dictionary Project
The FSF has a copy of the unabridged `Century Dictionary', now in the
public domain, and we are planning to put it online. We tried OCR, but
it wasn't reliable enough.
Russell Nelson is coordinating the project. Volunteers have entered
close to fifty pages so far, but the project needs more help; to
volunteer, send mail to `dictionary@gnu.ai.mit.edu' or contact the FSF.
----------------------------------------------------------------------
best -gnu@prep.ai.mit.edu
Member, League for Programming Freedom,
ask: lpf@uunet.uu.net, surf: http://www.lpf.org