![[image of the Head of a GNU]](/graphics/gnu-head-sm.jpg)
\magnification=833 % -*-texinfo-*- \input texinfo
----------------------------------------------------------------------
GNU's Bulletin January, 1994
The GNU's Bulletin is the semi-annual newsletter of the Free Software Foundation, bringing you news about the GNU Project.
Free Software Foundation, Inc. Telephone: +1-617-876-3296
675 Massachusetts Avenue FAX: +1-617-492-9057
Cambridge, MA 02139-3309 FAX (in Japan):
USA 0031-13-2473 (KDD)
Electronic mail: gnu@prep.ai.mit.edu 0066-3382-0158 (IDC)
GNU's Who
GNU's Bulletin
What Is the Free Software Foundation?
What Is Copyleft?
Donations Translate Into Free Software
Cygnus Matches Donations!
GNUs Flashes
What Is the LPF?
News from the LPF
Free Software Support
Project GNU Wish List
Towards a New Strategy of OS Design
Part 1 - A More Usable Approach to OS Design
The Translator Mechanism
Generic Services
Clever Filesystem Pictures
What The User Can Do
Why This Is So Different
Part 2 - A Look at Some of the Hurd's Beasts
The Authentication Server
The Process Server
Transparent FTP
Filesystems
Terminals
Executing Programs
New Processes
Asynchronous Messages
Making It Look Like Unix
Network Protocols
Second Annual GNU Seminar in Japan
GNU and other Free Software in Japan
Freely Available Texts
Project GNU Status Report
GNU Documentation
GNU Software Available Now
OCEAN Integrated-Circuit Design System
Contents of the Emacs Tape
Contents of the Languages Tape
Contents of the Utilities Tape
Contents of the Scheme Tape
Contents of the X11 Tapes
Berkeley Networking 2 Tape
VMS Emacs and VMS Compiler Tapes
Hundred Acre Consulting Expands
Source Code CD-ROM
Compiler Tools Binaries CD-ROM
Tape & CD-ROM Subscription Service
How to Get GNU Software
The Deluxe Distribution
MS-DOS Distribution
Contents of the Demacs diskettes
Contents of the DJGPP diskettes
Contents of the Selected Utilities diskettes
Contents of the Windows diskette
Free Software for Microcomputers
FSF T-shirt
Thank GNUs
Free Software Foundation Order Form
Michael Bushnell continues to work on the Hurd, while also
maintaining tar. Roland McGrath maintains make and
the GNU C library, helps with Emacs 19, and is now working on the Hurd.
Jan Brittenson is working on the Hurd network server.
Noah Friedman is our system ambiguator, release coordinator, and maintains a few programs in his copious spare time. Carl Hoffman is our fundraiser and conference organizer.
Lisa `Opus' Goldstein is our Treasurer. Robert J. Chassell is writing an Introduction to Programming in Emacs Lisp and remains on our Board of Directors. Larissa Carlson is Lisa's office assistant. Charles Hannum works on typesetting and many other jobs.
Jim Blandy has left to pursue academic interests. Melissa Weisshaus and Tom Lord have also left the FSF. All three still volunteer part-time.
Richard Stallman continues as a volunteer who does countless tasks, such as Emacs maintenance. Volunteer Len Tower remains our on-line JOAT (jack-of-all-trades), handling mailing lists and gnUSENET, information requests, etc.
Written and Edited by: Jan Brittenson, Noah S. Friedman,
and Leonard H. Tower Jr.
Illustrations by: Etienne Suvasa and Jamal Hannah
Japanese Edition by: Mieko Hikichi and Nobuyuki Hikichi
The GNU's Bulletin is published at the end of January and June of each year. Please note that there is no postal mailing list. To get a copy, send your name and address with your request to the address on the front page. Enclosing a business sized self-addressed stamped envelope ($0.52) and/or a donation of a few dollars is appreciated but not required. If you're from outside the USA, sending a mailing label rather than an envelope and enough International Reply Coupons for a package of about 100 grams is appreciated but not required. (Including a few extra International Reply Coupons for copying costs is also appreciated.)
Copyright (C) 1994 Free Software Foundation, Inc.
Permission is granted to anyone to make or distribute verbatim copies of this document, in any medium, provided that the copyright notice and permission notice are preserved and that the distributor grants the recipient permission for further redistribution as permitted by this notice.
The Free Software Foundation is dedicated to eliminating restrictions on people's right to use, copy, modify, and redistribute computer programs. We promote the development and use of free software in all areas using computers. Specifically, we are putting together a complete, integrated software system named "GNU" ("GNU's Not Unix", pronounced "guh-new") that will be upwardly compatible with Unix. Most parts of this system are already being used and distributed.
The word "free" in our name refers to freedom, not price. You may or may not pay money to get GNU software, but regardless you have two specific freedoms once you get it: first, the freedom to copy a program and give it away to your friends and co-workers; and second, the freedom to change a program as you wish, by having full access to source code. You can study the source and learn how such programs are written. You may then be able to port it, improve it, and share your changes with others. If you redistribute GNU software you may charge a distribution fee or give it away.
Other organizations distribute whatever free software happens to be available. By contrast, the Free Software Foundation concentrates on the development of new free software, working towards a GNU system complete enough to eliminate the need to purchase a proprietary system.
Besides developing GNU, the FSF distributes GNU software and manuals for a distribution fee and accepts gifts (tax-deductible in the U.S.) to support GNU development. Most of the FSF's funds come from this distribution service.
The Officers of the Foundation are: Richard M. Stallman, President, and Lisa Goldstein, Treasurer/Secretary. The Foundation Board of Directors are: Richard M. Stallman, Gerald J. Sussman, Harold Abelson, Robert J. Chassell, and Leonard H. Tower Jr.
The simplest way to make a program free is to put it in the public domain, uncopyrighted. But this permits proprietary modifications, denying others the freedom to use and redistribute improvements; it is contrary to the intent of increasing the total amount of free software. To prevent this, copyleft uses copyrights in a novel manner. Typically copyrights take away freedoms; copyleft preserves them. It is a legal instrument that requires those who pass on a program to include the rights to use, modify, and redistribute the code; the code and rights become legally inseparable.
The copyleft used by the GNU Project is made from the combination of a regular copyright notice and the GNU General Public License (GPL). The GPL is a copying license which basically says that you have the aforementioned freedoms. An alternate form, the GNU Library General Public License (LGPL), applies to a few GNU libraries. This license permits linking the libraries into proprietary executables under certain conditions. The appropriate license is included in all GNU source code distributions and many manuals. Printed copies are available upon request.
We strongly encourage you to copyleft your programs and documentation, and we have made it as simple as possible for you to do so. The details on how to apply either license appear at the end of each license.
If you appreciate Emacs, GNU CC, Ghostscript, and other free software, you may wish to help us make sure there is more in the future--remember, donations translate into more free software!
Your donation to us is tax-deductible in the United States. We gladly accept all currencies, although the U.S. dollar is the most convenient.
If your employer has a matching gifts program for charitable donations, please arrange to have your donation matched by your employer (or in some cases by Cygnus Support, see "Cygnus Matched Donations!"). If you do not know, please ask your personnel department. Also try and get the FSF listed on the any list of organizations for the matching gifts program.
$500 $250 $100 $50 other $________ Other currency:________
Circle the amount you are donating, cut out this form, and send it with your donation to:
Free Software Foundation 675 Massachusetts Avenue Cambridge, MA 02139-3309 USA
You can also charge a donation to either Visa, Mastercard, JCB, Diner's
Club, or Carte Blanche. Charges may also be emailed to
gnu@prep.ai.mit.edu or faxed to +1-617-492-9057; in Japan fax
to: 0031-13-2473 (KDD) or 0066-3382-0158 (IDC)
Card type: __________________ Expiration Date: _____________ Account Number: _____________________________________________ Your Signature: _____________________________________________
To encourage cash donations to the Free Software Foundation, Cygnus Support will continue to contribute corporate funds to FSF to accompany gifts by its employees, and by its customers and their employees.
Donations payable to the Free Software Foundation should be sent by
eligible persons to Cygnus Support, which will add its gifts and forward the
total to the FSF each quarter. The FSF will provide the contributor with a
receipt to recognize the contribution (which is tax-deductible on U.S.
tax returns). For more information, please contact Cygnus at
info@cygnus.com.
++, the X Window System, & TCP/IP networking. Field Technology
makes a donation to the Free Software Foundation for each system sold.
Contact info@fieldtech.com or +1-203-761-9363 for more
information.
ftp.cs.buffalo.edu in `/pub/sneps'.
++ class library providing Lisp-like functionality,
including automatic garbage collection. Lily is available by
anonymous FTP from sunsite.unc.edu. For more info,
write sheldon@kong.gsfc.nasa.gov.
a.cs.uiuc.edu,
write free-widgets-info@flute.cs.uiuc.edu,
or write:
The Free Widget Foundation c/o Brian Totty Department of Computer Science University of Illinois -- Urbana 1304 W. Springfield Avenue Urbana, IL 61801 USA
The League for Programming Freedom (LPF) aims to protect the freedom to write software. This freedom is threatened by "look-and-feel" interface copyright lawsuits and by software patents. The LPF does not endorse free software or the FSF.
The League's members include programmers, entrepreneurs, students, professors, and even software companies.
From the League membership form:
The League for Programming Freedom is a grass-roots organization of professors, students, business people, programmers, and users dedicated to bringing back the freedom to write programs. The League is not opposed to the legal system that Congress intended--copyright on individual programs. Our aim is to reverse the recent changes made by judges in response to special interests.
Membership dues in the League are $42 per year for programmers, managers and professionals; $10.50 for students; $21 for others.
To join, please send a check and the following information:
The League is not connected with the Free Software Foundation and is not itself a free software organization. The FSF supports the LPF because, like any software developer smaller than IBM, it is endangered by software patents. You are in danger too! It would be easy to ignore the problem until you or your employer is sued, but it is more prudent to organize before that happens.
If you haven't made up your mind yet, write to LPF for more information:
League for Programming Freedom
1 Kendall Square - #143
P.O. Box 9171
Cambridge, MA 02139
USA
Phone: +1-617-243-4091
Email: lpf@uunet.uu.net
by Christian D.. Hofstader, cdh@prep.ai.mit.edu
The US Patent and Trademark Office (PTO) will hold hearings early in 1994
on the topic of software patents. The PTO is recognizing that something is
very wrong with the current policy and is looking for input on how to
correct matters. The LPF is trying to get a representative invited to
testify, and will call for members and others concerned with these issues
to write letters to the PTO. Contact lpf@uunet.uu.net for details.
For the last few months, the LPF has been working on an amicus (friend of
the court) brief which was presented to the appeal court in the appeal of
Lotus v. Borland. The brief was directed solely at the Lotus claim to
copyright over the macro language in 123 which was allowed by Judge
Keeton in the lower court. The brief was filed on behalf of over 20
prominent computer scientists in the First Circuit Court on December 14,
1993.
The group that the LPF organized to sign the brief included such major contributors to computer science as Marvin Minsky, John McCarthy, and Robert Boyer. Bob Kohn, Borland VP and General Counsel, stated, "With this group the LPF should be able to change the course of intellectual property law. Never has such an impressive group of computer scientists been assembled."
The LPF will be making a supplemental filing in this case. If you are interested in signing or know someone who you feel would like to join the list, please forward the appropriate information to the LPF.
The Free Software Foundation does not provide any technical support. Although we create software, we leave it to others to earn a living providing support. We see programmers as providing a service, much as doctors and lawyers now do; both medical and legal knowledge are freely redistributable entities for which the practitioners charge a distribution and service fee.
We maintain a list of people who offer support and other consulting
services, called the GNU Service Directory. It is in the file
`etc/SERVICE' in the GNU Emacs distribution, `SERVICE' in the
GCC distribution and `/pub/gnu/GNUinfo/SERVICE' on anonymous FTP host
prep.ai.mit.edu. Contact us if you would like a printed copy
or wish to be listed in it.
If you find a deficiency in any GNU software, we want to know. We have
many Internet mailing lists for bug reports, announcements and questions.
They are also gatewayed into USENET news as the gnu.* newsgroups.
You can request a list of the mailing lists from either
address on the front cover.
When we receive a bug report, we usually try to fix the problem. While our bug fixes may seem like individual assistance, they are not. Our task is so large that we must focus on that which helps the community as a whole; we do not have the resources to help individuals. We may send you a patch for a bug that helps us test the fix and ensure its quality. If your bug report does not evoke a solution from us, you may still get one from another user who reads our bug report mailing lists. Otherwise, use the Service Directory.
Please do not ask us to help you install software or figure out how to use it--but do tell us how an installation script does not work or where documentation is unclear.
If you have no Internet access, you can get mail and USENET news via UUCP. Contact a local UUCP site, or a commercial UUCP site such as:
UUNET Communications Services
3110 Fairview Park Drive - Suite 570
Falls Church, VA 22042
USA
Phone: 1-800-4UUNET4 or (703) 204-8000
Fax: (703) 204-8001
E-mail: info@uunet.uu.net
A long list of commercial UUCP and Internet service providers is posted
periodically to USENET in the newsgroup news.announce.newusers
with `Subject: How to become a USENET site'.
When choosing a service provider, ask those you are considering how much they do to assist free software development, e.g. by contributing money to free software development projects or by writing free software improvements themselves for general use. By basing your decision partially on this factor, you can help encourage those who profit from free software to contribute to its growth.
Wishes for this issue are for:
gnu@prep.ai.mit.edu to make
arrangements.
gnu@prep.ai.mit.edu for the task list and coding standards.
gnu@prep.ai.mit.edu.
This article explains why FSF is developing a new operating system named the Hurd, which will be a foundation of the whole GNU system. The Hurd is built on top of CMU's Mach 3.0 kernel and uses Mach's virtual memory management and message-passing facilities. The GNU C Library will provide the Unix system call interface, and will call the Hurd for needed services it can't provide itself. The design and implementation of the Hurd is being lead by Michael Bushnell, with assistance from Richard Stallman, Roland McGrath, Jan Brittenson, and others.
The fundamental purpose of an operating system (OS) is to enable a variety of programs to share a single computer efficiently and productively. This demands memory protection, preemptively scheduled timesharing, coordinated access to I/O peripherals, and other services. In addition, an OS can allow several users to share a computer. In this case, efficiency demands services that protect users from harming each other, enable them to share without prior arrangement, and mediate access to physical devices.
On today's computer systems, programmers usually implement these goals through a large program called the kernel. Since this program must be accessible to all user programs, it is the natural place to add functionality to the system. Since the only model for process interaction is that of specific, individual services provided by the kernel, no one creates other places to add functionality. As time goes by, more and more is added to the kernel.
A traditional system allows users to add components to a kernel only if they both understand most of it and have a privileged status within the system. Testing new components requires a much more painful edit-compile-debug cycle than testing other programs. It cannot be done while others are using the system. Bugs usually cause fatal system crashes, further disrupting others' use of the system. The entire kernel is usually non-pageable. (There are systems with pageable kernels, but deciding what can be paged is difficult and error prone. Usually the mechanisms are complex, making them difficult to use even when adding simple extensions.)
Because of these restrictions, functionality which properly belongs behind the wall of a traditional kernel is usually left out of systems unless it is absolutely mandatory. Many good ideas, best done with an open/read/write interface cannot be implemented because of the problems inherent in the monolithic nature of a traditional system. Further, even among those with the endurance to implement new ideas, only those who are privileged users of their computers can do so. The software copyright system darkens the mire by preventing unlicensed people from even reading the kernel source.
Some systems have tried to address these difficulties. Smalltalk-80 and the Lisp Machine both represented one method of getting around the problem. System code is not distinguished from user code; all of the system is accessible to the user and can be changed as need be. Both systems were built around languages that facilitated such easy replacement and extension, and were moderately successful. But they both were fairly poor at insulating users and programs from each other, failing one of the principal goals of OS design.
Most projects that use the Mach 3.0 kernel carry on the hard-to-change tradition of OS design. The internal structure is different, but the same heavy barrier between user and system remains. The single-servers, while fairly easy to construct, inherit all the deficiencies of the monolithic kernels.
A multi-server divides the kernel functionality up into logical blocks with well-defined interfaces. Properly done, it is easier to make changes and add functionality. So most multi-server projects do somewhat better. Much more of the system is pageable. You can debug the system more easily. You can test new system components without interfering with other users. But the wall between user and system remains; no user can cross it without special privilege.
The GNU Hurd, by contrast, is designed to make the area of system code as limited as possible. Programs are required to communicate only with a few essential parts of the kernel; the rest of the system is replaceable dynamically. Users can use whatever parts of the remainder of the system they want, and can easily add components themselves for other users to take advantage of. No mutual trust need exist in advance for users to use each other's services, nor does the system become vulnerable by trusting the services of arbitrary users.
This has been done by identifying those system components which users must use in order to communicate with each other. One of these is responsible for identifying users' identities and is called the authentication server. In order to establish each other's identities, programs must communicate, each with an authentication server they trust. Another component establishes control over system components by the superuser, provides global bookkeeping operations, and is called the process server.
Not all user programs need to communicate with the process server; it is only necessary for programs which require its services. Likewise, the authentication server is only necessary for programs that wish to communicate their identity to another. None of the remaining services carry any special status; not the network implementation, the filesystems, the program execution mechanism (including setuid), or any others.
The Hurd uses Mach ports primarily as methods for communicating between users and servers. (A Mach port is a communication point on a Mach task where messages are sent and received.) Each port implements a particular set of protocols, representing operations that can be undertaken on the underlying object represented by the port. Some of the protocols specified by the Hurd are the I/O protocol, used for generic I/O operations; the file protocol, used for filesystem operations; the socket protocol, used for network operations; and the process protocol, used for manipulating processes et al.
Most servers are accessed by opening files. Normally, when you open a file, you create a a port associated with that file that is owned by the server that owns the directory containing the file. For example, a disk-based filesystem will normally serve a large number of ports, each of which represents an open file or directory. When a file is opened, the server creates a new port, associates it with the file, and returns the port to the calling program.
However, a file can have a translator associated with it. In this case, rather than return its own port which refers to the contents of the file, the server executes a translator program associated with that file. This translator is given a port to the actual contents of the file, and is then asked to return a port to the original user to complete the open operation.
This mechanism is used for mount by having a translator
associated with each mount point. When a program opens the mount
point, the translator (in this case, a program which understands the
disk format of the mounted filesystem) is executed and returns a port to
the program. After the translator is started, it need not be run again
unless it dies; the parent filesystem retains a port to the translator
to use in further requests.
The owner of a file can associate a translator with it without special permission. This means that any program can be specified as a translator. Obviously the system will not work properly if the translator does not implement the file protocol correctly. However, the Hurd is constructed so that the worst possible consequence is an interruptible hang.
One way to use translators is to access hierarchically structured data
using the file protocol. For example, all the complexity of the user
interface to the ftp program is removed. Users need only know
that a particular directory represents FTP and can use all the standard
file manipulation commands (e.g ls or cp) to access the
remote system, rather than learning a new set. Similarly, a simple
translator could ease the complexity of tar or gzip.
(Such transparent access would have some added cost, but it would be
convenient.)
With translators, the filesystem can act as a
rendezvous for interfaces which are not similar to files. Consider a
service which implements some version of the X protocol, using Mach
messages as an underlying transport. For each X display, a file can
be created with the appropriate program as its translator. X clients
would open that file. At that point, few file operations would be useful
(read and write, for example, would be useless), but new operations
(XCreateWindow or XDrawText) might become meaningful. In this
case, the filesystem protocol is used only to manipulate
characteristics of the node used for the rendezvous. The node need
not support I/O operations, though it should reply to any such
messages with a message_not_understood return code.
This translator technique is used to contact most of the services in the Hurd that are not structured like hierarchical filesystems. For example, the password server, which hands out authorization tags in exchange for passwords, is contacted this way. Network protocol servers are also contacted in this fashion. Roland McGrath thought up this use of translators.
In the Hurd, translators can also be used to present a filesystem-like view of another part of the filesystem, with some semantics changed. For example, it would be nice to have a filesystem that cannot itself be changed, but nonetheless records changed versions of its files elsewhere. (This could be useful for source code management.)
The Hurd will have a translator which creates a directory which is a conceptual union of other directories, with collision resolution rules of various sorts. This can be used to present a single directory to users that contains all the programs they would want to execute. There are other useful variations on this theme.
No translator gains extra privilege by virtue of being hooked into the filesystem. Translators run with the uid of the owner of the file being translated, and can only be set or changed by that owner. The I/O and filesystem protocols are carefully designed to allow their use by mutually untrusting clients and servers. Indeed, translators are just ordinary programs. The GNU C library has a variety of facilities to make common sorts of translators easier to write.
Some translators may need special privileges,
such as the password server or translators which allow setuid execution.
These translators could be run by anyone, but
only if they are set on a root-owned node would they be able
to provide all their services successfully. This is analogous to
letting any user call the reboot system call, but only honoring it if
that user is root.
What this design provides is completely novel to the Unix world. Until now, OSs have kept huge portions of their functionality in the realm of system code, thus preventing its modification and extension except in extreme need. Users cannot replace parts of the system in their programs no matter how much easier that would make their task, and system managers are loath to install random tweaks off the net into their kernels.
In the Hurd, users can change almost all of the things that are decided for them in advance by traditional systems. In combination with the tremendous control given by the Mach kernel over task address spaces and properties, the Hurd provides a system in which users will, for the first time, be able to replace parts of the system they dislike, without disrupting other users.
Most Mach-based OSs to date have mostly implemented a wider set of the same old Unix semantics in a new environment. In contrast, GNU is extending those semantics to allow users to improve, bypass, or replace them.
One of the Hurd's more central servers is the authentication server. Each port to this server identifies a user and is associated by this server with an id block. Each id block contains sets of user and group ids. Either set may be empty. This server is not the same as the password server referred to above.
The authentication server exports three services. First, it provides simple boolean operations on authentication ports: given two authentication ports, this server will provide a third port representing the union of the two sets of uids and gids. Second, this server allows any user with a uid of zero to create an arbitrary authentication port. Finally, this server provides RPCs (Remote Procedure Calls between different programs and possibly different hosts) which allow mutually untrusting clients and servers to establish their identities and pass initial information on each other. This is crucial to the security of the filesystem and I/O protocols.
Any user could write a program which implements the authentication protocol; this does not violate the system's security. When a service needs to authenticate a user, it communicates with its trusted authentication server. If that user is using a different authentication server, the transaction will fail and the server can refuse to communicate further. Because, in effect, this forces all programs on the system to use the same authentication server, we have designed its interface to make any safe operation possible, and to include no extraneous operations. (This is why there is a separate password server.)
The process server acts as an information categorization repository. There are four main services supported by this server. First, the process server keeps track of generic host-level information not handled by the Mach kernel. For example, the hostname, the hostid, and the system version are maintained by the process server. Second, this server maintains the Posix notions of sessions and process groups, to help out programs that wish to use Posix features.
Third, the process server maintains a one-to-one mapping between Mach
tasks and Hurd processes. Every task is assigned a pid. Processes can
register a message port with this server, which can then be given out to
any program which requests it. This server makes no attempt to keep
these message ports private, so user programs are expected to implement
whatever security they need themselves. (The GNU C Library provides
convenient functions for all this.) Processes can tell the process
server their current argv and envp values; this server
will then provide, on request, these vectors of arguments and
environment. This is useful for writing ps-like programs and
also makes it easier to hide or change this information. None of these
features are mandatory. Programs are free to disregard all of this and
never register themselves with the process server at all. They will,
however, still have a pid assigned.
Finally, the process server implements process collections, which are used to collect a number of process message ports at the same time. Also, facilities are provided for converting between pids, process server ports, and Mach task ports, while ensuring the security of the ports managed.
It is important to stress that the process server is optional. Because of restrictions in Mach, programs must run as root in order to identify all the tasks in the system. But given that, multiple process servers could co-exist, each with their own clients, giving their own model of the universe. Those process server features which do not require root privileges to be implemented could be done as per-user servers. The user's hands are not tied.
Transparent FTP is an intriguing idea whose time has come. The popular
ange-ftp package available for GNU Emacs makes access to FTP
files virtually transparent to all the Emacs file manipulation
functions. Transparent FTP does the same thing, but in a system wide
fashion. This server is not yet written; the details remain to be
fleshed out, and will doubtless change with experience.
In a BSD kernel, a transparent FTP filesystem would be no harder to
write than in the Hurd. But mention the idea to a BSD kernel hacker,
and the response is that "such a thing doesn't belong in the kernel".
In a sense, this is correct. It violates all the layering principles of
such systems to place such things in the kernel. The unfortunate side
effect, however, is that the design methodology (which is based on
preventing users from changing things they don't like) is being used to
prevent system designers from making things better. (Recent BSD kernels
make it possible to write a user program that provides transparent FTP.
An example is alex, but it needs to run with full root
privileges.)
In the Hurd, there are no obstacles to doing transparent FTP. A
translator will be provided for the node `/ftp'. The contents of
`/ftp' will probably not be directly listable, though further
subdirectories will be. There will be a variety of possible formats.
For example, to access files on uunet, one could cd
/ftp/ftp.uu.net:anonymous:mib@gnu. Or to access files on a remote
account, one might cd /ftp/gnu.ai.mit.edu:mib:passwd. Parts
of this command could be left out and the transparent FTP program would
read them from a user's `.netrc' file. In the last case, one might
just cd /ftp/gnu.ai.mit.edu; when the rest of the data is
already in `.netrc'.
There is no need to do a cd first--use any file command. To
find out about RFC 1097 (the Telnet Subliminal Message Option), just
type more /ftp/ftp.uu.net/inet/rfc/rfc1097. A copy command
to a local disk could be used if the RFC would be read frequently.
Ordinary filesystems are also being implemented. The initial release of the Hurd will contain a filesystem upwardly compatible with the BSD 4.4 Fast File System. In addition to the ordinary semantics, it will provide means to record translators, offer thirty-two bit user ids and group ids, and supply a new id per file, called the author of the file, which can be set by the owner arbitrarily. In addition, because users in the Hurd can have multiple uids (or even none), there is an additional set of permission bits providing access control for unknown user (no uids) as distinct from known but arbitrary user (some uids: the existing world category of file permissions).
The Network File System protocol will be implemented using 4.4 BSD as a starting point. A log-structured filesystem will also be implemented using the same ideas as in Sprite, but probably not the same format. A GNU network file protocol may be designed in time, or NFS may be extended to remove its deficiencies. There will also be various "little" filesystems, such as the MS-DOS filesystem, to help people move files between GNU and other OSs.
An I/O server will provide the terminal semantics of Posix. The GNU C Library has features for keeping track of the controlling terminal and for arranging to have proper job control signals sent at the proper times, as well as features for obeying keyboard and hangup signals.
Programs will be able to insert a terminal driver into communications
channels in a variety of ways. Servers like rlogind will be able
to insert the terminal protocol onto their network communication port.
Pseudo-terminals will not be necessary,
though they will be provided for backward compatibility with older
programs. No programs in GNU will depend on them.
Nothing about a terminal driver is forced upon users. A terminal driver allows a user to get at the underlying communications channel easily, to bypass itself on an as-needed basis or altogether, or to substitute a different terminal driver-like program. In the last case, provided the alternate program implements the necessary interfaces, it will be used by the C Library exactly as if it were the ordinary terminal driver.
Because of this flexibility, the original terminal driver will not
provide complex line editing features, restricting itself to the
behavior found in Posix and BSD. In time, there will be a
readline-based terminal driver, which will provide
complex line-editing
features for those users who want them.
The terminal driver will probably not provide good support for the high-volume, rapid data transmission required by UUCP or SLIP. Those programs do not need any of its features. Instead they will be use the underlying Mach device ports for terminals, which support moving large amounts of data efficiently.
The implementation of the execve call is spread across
three programs. The library marshals the argument and
environment vectors. It then sends a message to the file server that
holds the file to be executed. The file server checks execute
permissions and makes whatever changes it desires in the exec call. For
example, if the file is marked setuid and the fileserver has the
ability, it will change the user identification of the new
image. The file server also decides if programs which
had access to the old task should continue to have access to the new
task. If the file server is augmenting permissions, or executing an
unreadable image, then the exec needs to take place in a
new Mach task to maintain security.
After deciding the policy associated with the new image, the filesystem
calls the exec server to load the task. This server, using the
BFD (Binary File Descriptor) library, loads the image. BFD supports a
large number of object file formats; almost any supported format will
be executable. This server also handles scripts starting with
#!, running them through the indicated program.
The standard exec server also looks at the environment of the new image;
if it contains a variable EXECSERVERS then it uses the programs
specified there as exec servers instead of the system default. (This
is, of course, not done for execs that the file server has requested be
kept secure.)
The new image starts running in the GNU C Library, which sends a message to the exec server to get the arguments, environment, umask, current directory, etc. None of this additional state is special to the file or exec servers; if programs wish, they can use it in a different manner than the Library.
The fork call is implemented almost entirely in the GNU C Library. The
new task is created by Mach kernel calls. The C Library arranges to
have its image inherited properly. The new task is registered with
the process server (though this is not mandatory). The C Library
provides vectors of functions to be called at fork time: one vector to
be called before the fork, one after in the parent, and one after in
the child. (These features should not be used to replace the normal
fork-calling sequence; it is intended for libraries which need to close ports
or clean up before a fork occurs.) The C library will
implement both fork calls specified by the draft Posix.4a (the proposed
standard dealing with the threads
extension to the real-time extension).
Nothing forces the user to create new tasks this way. If a program wants to use almost the normal fork, but with some special characteristics, then it can do so. Hooks will be provided by the C Library, or the function can even be completely replaced. None of this is possible in a traditional Unix system.
As mentioned above, the process server maintains a "message port" for each task registered with it. These ports are public, and are used to send asynchronous messages to the task. Signals, for example, are sent to the message port. The signal message also provides a port as an indication that the sender should be trusted to send the signal. The GNU C Library lists a variety of ports in a table, each of which identifies a set of signals that can be sent by anyone who possesses that port. For example, if the user possesses the task's kernel port, it is allowed to send any signal. If the user possesses a special "terminal id" port, it is allowed to send the keyboard and hangup signals. Users can add arbitrary new entries into the C library's signal permissions table.
When a process's process group changes, the process server will send it a message indicating the new process group. In this case, the process server proves its authority by providing the task's kernel port.
The C library also has messages to add and delete uids currently used by
the process. If new uids are sent to the program, the library adds them
to its current set, and then exchanges messages with all the I/O servers
it knows about, proving to them its new authorization. Similarly, a
message can delete uids. In the latter case, the caller must provide
the process's task port. (You can't harm a process by giving it extra
permission, but you can harm it by taking permission away.) The Hurd
will provide user programs to send these messages to processes. For
example, the su command will be able to cause all the programs in
your current login session, to gain a new uid, rather than spawn a
subshell.
The C library will allow programs to add asynchronous messages they wish to recognize, as well as prevent recognition of the standard set.
The C Library will implement all of the calls from BSD and Posix as well as some obvious extensions to them. This enables users to replace those calls they dislike or bypass them entirely, whereas in Unix the calls must be used "as they come" with no alternatives possible.
In some environments binary compatibility will also be supported. This works by building a special version of the library which is then loaded somewhere in the address space of the process. (For example, on a VAX, it would be tucked in above the stack.) A feature of Mach, called system call redirection, is then used to trap Unix system calls and turn them into jumps into this special version of the library. (On almost all machines, the cost of such a redirection is very small; this is a highly optimized path in Mach. On a 386 it's about two dozen instructions. This is little worse than a simple procedure call.)
Many features of Unix, such as signal masks and vectors, are handled
completely by the library. This makes such features significantly
cheaper than in Unix. It is now reasonable to use sigblock extensively
to protect critical sections, rather than seeking out some other, less
expensive method.
The Hurd will have a library that will make it very easy to port 4.4 BSD protocol stacks into the Hurd. This will enable operation, virtually for free, of all the protocols supported by BSD. Currently, this includes the CCITT protocols, the TCP/IP protocols, the Xerox NS protocols, and the ISO protocols.
For optimal performance some work would be necessary to take advantage of Hurd features that provide for very high speed I/O. For most protocols this will require some thought, but not too much time. The Hurd will run the TCP/IP protocols as efficiently as possible.
As an interesting example of the flexibility of the Hurd design, consider the case of IP trailers, used extensively in BSD for performance. While the Hurd will be willing to send and receive trailers, it will gain fairly little advantage in doing so because there is no requirement that data be copied and avoiding copies for page-aligned data is irrelevant.
Wingnut and the FSF sponsored the second GNU Technical Seminar in Tokyo on December 1 and 2, 1993. Richard Stallman spoke on the GNU Project and the FSF. Jim Blandy then spoke on GNU Emacs 19. Finally Manabu Higashida spoke on Demacs (see "Free Software for Microcomputers"). Bob Myers and David Littleboy translated the English lectures into Japanese. Software Research Associates, Inc. (SRA), the SRA/Wingnut project and their staff provided help in countless ways for this seminar and the entire trip to Japan. About 70 people attended the seminar, and several Japanese publications interviewed Richard Stallman. The FSF also premiered the new edition of it's Source Code CD-ROM.
Seminars were also held at Sendai on Dec 6th, where Richard Stallman spoke; The University of Aizu on Dec 7th, where Richard Stallman and Jim Blandy spoke; and Osaka on Dec 13th where Richard Stallman and Manabu Higashida spoke. We thank all the people and organizations who helped make these seminars a reality, including the organizers, hosts, and interpreters.
The Japan Unix Society gave the FSF a booth at Unix Fair '93 in Yokohama. We thank all the volunteers and organizations who helped the FSF run this booth.
Our success at the seminars and trade shows exceeded our expectations. We received many unsolicited donations from individual supporters and users' groups, and are thankful for the number of enthusiastic volunteers who helped us. In the future we hope to appear at even more Unix events both in Japan and elsewhere. If you would like to host a seminar, or need a speaker for a conference, please contact either address on the front cover.
Mieko (h-mieko@sra.co.jp) and Nobuyuki Hikichi
(hikichi@sra.co.jp) continue to volunteer for the GNU
Project in Japan. They translate each issue of this Bulletin into
Japanese and distribute it widely, along with their translation of
the GNU General Public License Version 2. This translation of the GPL
is authorized by the FSF and is available by anonymous FTP from
srawgw.sra.co.jp in `/pub/gnu/local-fix/GPL2-j'.
They are working on a formal translation of the GNU Library General
Public License. In addition, they also solicit donations and offer GNU
software consulting.
Japanese versions of Epoch (nepoch) and MULE are available and
widely used in Japan. MULE (the MULtilingual Enhancement of GNU Emacs) can
handle many character sets at once. Eventually its features will be merged
into the FSF's version of Emacs. The FSF does not distribute nepoch,
but MULE is available (see "Source Code CD-ROM"). You can also FTP it
from sh.wide.ad.jp in `/JAPAN/mule' or
etlport.etl.go.jp in `/pub/mule'.
The Village Center, Inc. prints a Japanese translation of the GNU Emacs Lisp Reference Manual and uploads the Texinfo source to various bulletin boards. They have also published a copylefted book, Nobuyuki's and Mieko's Think GNU. This appears to be the first non-FSF copylefted publication in Japan. Part of the profits are donated to the FSF. Their address is:
Village Center, Inc. 2-2-12, Fujimi-Cho, Choufu city Tokyo 182, Japan
Addison Wesley Publishers Japan has printed a Japanese translation of the GNU Make Manual and GAWK Manual. Their address is:
Addison Wesley Publishers Japan Nichibou Bldg. 2F 1-2-2 Sarugaku-cho, Chiyoda-ku Tokyo 101, Japan
ICOT (Institute for Next Generation Computer Technology) is distributing
the fifth-generation software produced by their research efforts as free
software. This includes over 70 megabytes of programs for symbol
processing, knowledge representation, problem solving and inference, and
natural language processing. For more information, contact
irpr@icot.or.jp.
Many groups in Japan now distribute GNU software. They include JUG, a PC
user group; ASCII, a periodical and book publisher; the Fujitsu FM
Towns users group; and SRA's GNU support special group, called Wingnut,
who also purchased the first Deluxe package in Japan. (Since then, there
have been several other anonymous purchases of the Deluxe package in
Japan.) Anonymous UUCP is also available; for more info, contact
toku@dit.co.jp.
It is also easy to place orders directly with the FSF from Japan, helping
us to fund new code. We have an FSF Order Form written in Japanese, ask
japan-fsf-orders@prep.ai.mit.edu for a copy of the order form.
There are also two toll-free facsimile numbers for use in Japan (see the
front cover). We encourage you to buy tapes: every 150 tape orders allows
FSF to hire a programmer for a year to write more free software.
Freely redistributable information isn't just software. Here are a few groups providing various books, historical documents, and more.
jgoodwin@adcalc.fnal.gov.
obi.std.com.
You can also dial world.std.com with a modem (617-739-9753, 8N1)
and create an account to access this information (login as new).
Accounts on world are charged for their connect time (ask
office@world.std.com for details).
mrcnext.cso.uiuc.edu in file `/etext' and
oes.orst.edu in file `/pub/almanac/etext'. For
instructions on how to obtain text from Bitnet, send the word `HELP' in the
body of a message to BITFTP@PUCC
(BITFTP%PUCC.BITNET@mitvma.mit.edu on the Internet). Or look
at bit.listserv.gutnberg, a USENET newsgroup.
mach@cs.cmu.edu if you want to help with one
of those or start your own. Porting the GNU Hurd and GNU C Library is
easy (easier than porting GNU Emacs, certainly easier than porting GCC)
once a Mach port to a particular kind of hardware exists.
Significant progress has been made recently: the filesystem is coming up
and several other servers are running.
There are significant projects relating to the Hurd for which we need
volunteers. Experienced system programmers who are interested should send
mail to gnu@prep.ai.mit.edu.
recover-file also reinstalls the buffer's undo history; support
for variable-width fonts; support for wide character sets including all
the world's major languages; and support for display using an X toolkit.
g77)
GNU Fortran is in "private" alpha test (testing by a small group of
experts) and is not yet publicly released. Until g77 is fully
released to the public, we ask people to use f2c (a Fortran-to-C
translator) with gcc (the GNU C compiler). As g77 uses a lot
of these tools (the f2c libraries and the gcc back end),
using them and reporting any problems you find will help speed the release
of g77. For more information on f2c and gcc, see "GNU
Software Available Now."
The primary focus of the alpha test is to test the g77 front end,
since that has most of the new code. The secondary focus of the alpha
test is to test the integration between the front end and the back end.
Currently, this is where most of the bugs seem to be. The tertiary
focus is the quality of code generated by the GNU back end for Fortran.
We hope to have a g77 beta release in early spring 1994, as part of
the regular compiler distribution.
A mailing list exists for announcements about g77. To subscribe,
ask info-gnu-fortran-request@prep.ai.mit.edu. To contact the
author and maintainer of g77, write to
fortran@prep.ai.mit.edu.
cs.nyu.edu in `ftp/pub/gnat', though it is
not yet stable. Volunteers are also developing a Pascal front end.
For more information about GCC, see "GNU Software Available Now."
gnu@prep.ai.mit.edu.
malloc which
wastes less memory than the old GNU version. The GNU regular-expression
functions (regex) 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.
Version 1.06 of the GNU C Library is just out and 1.07 is in the works.
Version 1.06 includes the relocating allocator used in Emacs 19, as well as
new ports to Dynix on Sequent Symmetry, SCO & SVR4 on i386, & Solaris 2 on
SPARC. Texinfo source of the GNU C Library Reference Manual is
included. For more info, see "GNU Software Available Now."
indent which supports the GNU
indentation conventions for C code. It is more robust and also has
handy options for the most common style combinations.
A companion program to examine a C source file and find the indentation
parameters used therein is almost ready for release, but needs someone to
finish it. Please contact gnu@prep.ai.mit.edu to volunteer.
make (also see "GNU Software Available Now")
GNU make version 3.70 is released. Error reporting is improved and
many bugs have been fixed. GNU make fully complies with the POSIX.2
standard. It also supports long options, parallel command execution,
flexible implicit pattern rules, conditional execution and powerful text
manipulation functions. Version 3.64 added support for the popular
`+=' syntax for appending more text to a variable's definition.
For those with no vendor-supplied make utility at all, GNU
make comes with a shell script called `build.sh' for the
initial build. See "GNU Software Available Now."
gnuplot and for generating embedded Postscript.
If you would like to write the Texinfo manual for Oleo, contact Tom Lord,
lord+@andrew.cmu.edu. Please send bug reports regarding Oleo
to bug-oleo@prep.ai.mit.edu. See "GNU Software Available
Now."
enscript); a utility to extract the text from a Postscript
document; a much more reliable (and faster) Microsoft Windows
implementation; support for Microsoft C/C++ 7.0; drivers for many
new printers, including the SPARCprinter, and for TIFF/F (fax) file
format; many more Postscript Level 2 facilities, including most of the
color space facilities (but not patterns), and the ability to switch
between Level 1 and Level 2 dynamically.
Ghostscript accepts commands in Postscript and executes them by writing
directly to a printer, drawing on an X window, or writing to a file that
you can print later (or to a bitmap file that you can manipulate with
other graphics programs). Tim Theisen,
ghostview@cs.wisc.edu, has created Ghostview, a previewer
for multi-page files that runs on top of Ghostscript. Russell Lang,
rjl@monu1.cc.monash.edu.au, has created Ghostview for
Windows, a similar previewer that runs on Microsoft Windows.
Ghostscript includes a C-callable graphics library (for client programs
that do not want to deal with the Postscript language). It also supports
IBM PCs and compatibles with EGA, VGA, or SuperVGA graphics (but please do
not ask the FSF staff any questions about this; we do not use PCs).
The next planned Ghostscript release is 3.0, hopefully available in early
1994. It will implement the full Postscript Level 2 language except for
LZW compression, which can't be freely implemented because of software
patents. Prohibitions like this on programming is what the
League for Programming Freedom is fighting. See "What is the LPF?" for
details.
groff (also see "GNU Software Available Now")
James Clark has completed groff (GNU troff and related
programs). Written in C++, they can be compiled with GNU C++
Version 2.3 or later.
Bugs in groff will be fixed, but no major new developments are
currently planned. However, groff users are encouraged to
continue 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) and an ASCII output
class for pic so that pic can be integrated with Texinfo.
Thanks to all those who have contributed bug reports.
makeinfo, a standalone formatter, and info, a standalone
Info reader are included. Both are written in C and are independent of
GNU Emacs.
GNU is dedicated to having quality, easy-to-use on-line and printed documentation. GNU manuals are intended to explain the underlying concepts, describe how to use all the features of each program, and give examples of command use. GNU manuals are distributed as Texinfo source files, which yield both typeset hardcopy and on-line hypertext-like display via the menu-driven Info system. These manuals, source for which is provided with our software, are also available in hardcopy; see the "Free Software Foundation Order Form."
Several GNU manuals are bound as soft cover books with lay-flat bindings. This allows you to open them so they lie flat on a table without creasing the binding. Each book has an inner cloth spine and an outer cardboard cover that will not break or crease as an ordinary paperback will. The other GNU manuals are also bound so they lie flat when opened, using other technologies. See the "Free Software Foundation Order Form" for a list of each.
Edition numbers of the manual and version number of the program listed after each manual's names were current at the time this Bulletin was published.
The Emacs Manual (9th Edition for Version 19) describes editing
with GNU Emacs. It also explains advanced features, such as outline mode
and regular expression search, how to use special modes for programming in
languages like C++ and TeX, how to use the tags utility, how
to compile and correct code, and how to make your own keybindings and other
elementary customizations.
The GNU Emacs Lisp Reference Manual (Edition 2.1 for Version 19) covers this programming language in depth, including data types, control structures, functions, macros, syntax tables, searching and matching, modes, windows, keymaps, markers, byte compilation, and the operating system interface.
The Texinfo Manual (Edition 2.19 for Version 3) explains the markup language used to generate both the online Info documentation and typeset hardcopies. It tells you how to make tables, lists, chapters, nodes, indexes, cross references, how to use Texinfo mode in GNU Emacs, and how to catch mistakes.
The GAWK Manual (Edition 0.16 for Version 2.16) tells how to use
the GNU implementation of awk. It is written for someone who has
never used awk and describes all the features of this powerful
string and record manipulation language.
The Make Manual (Edition 0.43 for Version 3.68) describes GNU
make, a program used to rebuild parts of other programs. The manual
tells how to write makefiles, which specify how a program is to be
compiled and how its files depend on each other. Included are an
introductory chapter for novice users and a section about automatically
generated dependencies.
Debugging with GDB (Edition 4.09 for Version 4.9) tells how to use the GNU Debugger, run your program under debugger control, examine and alter data, modify the flow of control within a program, and use GDB through GNU Emacs.
The Bison Manual (December 1993 Edition for Version 1.23) teaches you how to write context-free grammars for the Bison program that convert into C-coded parsers. You need no prior knowledge of parser generators.
The Flex Manual (Edition 1.03 for Version 2.3.7) tells you how to
write a lexical scanner definition for the flex program to create a
C ++ or C-coded scanner that will recognize the patterns described.
You need no prior knowledge of scanner generators.
Using and Porting GNU CC (June 1993 Edition for Version 2.4) explains how to run, install and port the GNU C compiler.
The Termcap Manual (2nd Edition for Version 1.2), often described as "twice as much as you ever wanted to know about termcap," details the format of the termcap database, the definitions of terminal capabilities, and the process of interrogating a terminal description. This manual is primarily for programmers.
The Emacs Calc Manual (Edition 2.02 for Version 2.02) includes both a tutorial and a reference manual for Calc. It describes how to do ordinary arithmetic, how to use Calc for algebra, calculus and other forms of mathematics, and how to extend Calc.
The C Library Reference Manual (June 93 Edition for Version 1.07)
describes most of the facilities of the GNU C library, including both what
Unix calls "library functions" and "system calls." We are doing
limited copier runs of this manual until it becomes more stable. It is
new, and needs corrections and improvements. Please send them to
bug-glibc-manual@prep.ai.mit.edu.
We offer:
We also offer Unix software source distributions tapes in tar format
on the following media:
The contents of the reel and various cartridge tapes for Unix systems are the same (except for the RS/6000 Emacs tape, which also has executables for Emacs); only the media are different (see the "Free Software Foundation Order Form"). Source code for the manuals is included in Texinfo format. We welcome all bug reports sent to the appropriate electronic mailing list (see "Free Software Support").
Some of the files on the tapes may be compressed with gzip to
make them fit. Refer to the top-level `README' file at the
beginning of each tape for instructions on uncompressing them.
uncompress and unpack do not work!
Version numbers listed after program names, in the articles describing the contents of each media, were current at the time this Bulletin was published. When you order a distribution tape or diskette, some of the programs might be newer, and therefore the version number higher.
Key to cross reference:
GNU software currently available (see "Project GNU Status Report" for what's new features and programs are coming):
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. Eventually we
hope to turn this into a more general purpose flight simulator.
m4 macro calls. Most GNU
programs now use Autoconf--generated configure scripts.
sh and offers many extensions found in csh and
ksh. BASH has job control, csh-style command history, and
command-line editing (with Emacs and vi modes built-in and the
ability to rebind keys) via the readline library.
bc (SrcCD, UtilT)
bc is an interactive algebraic language with arbitrary precision.
GNU bc follows the POSIX 1003.2
draft
standard, with several extensions including multi-character variable names,
an else statement and full Boolean expressions.
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 actual details of a particular format. One consequence of this
design is that all programs using BFD will support formats such as a.out,
COFF, ELF & OSF-Rose. BFD comes with Texinfo documentation.
Presently BFD is not distributed separately but is included with packages
that use it, because it is not yet completely stable.
ar,
c++filt,
demangle,
gprof,
ld,
nlmconv,
nm,
objcopy,
objdump,
ranlib,
size,
strings,
&
strip.
Binutils Version 2 is completely rewritten to use the BFD library.
The GNU linker ld emits source-line numbered error messages for
multiply-defined symbols and undefined references.
nlmconv converts object files into Novell NetWare Loadable Modules.
The objdump program can disassemble code for a29k, ALPHA, H8/300,
H8/500, HP-PA, i386, i960, m68k, m88k, MIPS, SH, SPARC, & Z8000
processors, and can display other data such as symbols and relocations from
any file format understood by BFD. Also see "Project GNU Status Report".
yacc. Sources for the Bison Manual and reference card are
included.
configure script. It runs on Sun-3
(SunOS 4.1), Sun-4 (SunOS 4.1 & Solaris 2), HP 9000/300 (4.3 BSD), SONY
News 800 (NewsOS 3 or 4), MIPS DECstation (Ultrix 4), DEC Alpha (OSF/1),
i386/i486 (System V, SVR4, BSD, SCO 3.2 & SCO ODT 2.0) & Sequent Symmetry
i386 (Dynix 3). Texinfo source for the GNU C Library Reference Manual is
included. Also see "Project GNU Status Report".
gnuplot.
Stuart Cracraft
P.O. Box 2841
Laguna Hills, CA 92653
USA
Phone: (714) 770-8532
E-mail: cracraft@ai.mit.edu
cpio (UtilD, UtilT, SrcCD)
cpio is an alternative 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.
dc (UtilT, SrcCD)
dc is an RPN calculator. GNU bc does not require a separate
dc program to run. This version of dc will eventually be
merged with GNU bc.
expect and Tcl.
diff compares files showing line-by-line changes in several
flexible formats. It is much faster than traditional Unix versions.
The Diffutils distribution contains diff, diff3,
sdiff, and cmp.
flex, GAS, and
the GNU binary utilities. Full source code is provided.
DJGPP supports SVGA (up to 1024x768),
XMS & VDISK memory allocation,
himem.sys,
VCPI (e.g. QEMM, DESQview, & 386MAX), and
DPMI (e.g. Windows 3.x, OS/2, QEMM, & QDPMI).
It is available via FTP from
ftp.clarkson.edu in `/pub/msdos/djgpp'. You can
subscribe to a mailing list on DJGPP by sending your e-mail address to
djgpp-request@sun.soe.clarkson.edu. In addition, the FSF
distributes it on floppy disks and on the Compiler Tools Binaries CD-ROM.
See the description for GCC in this section for more information.
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 and 4.0), SPARC (SunOS 4.0), Sequent Symmetry (Dynix), and Atari ST.
doschk (UtilT, SrcCD)
This program is intended as 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 with 11 character filenames.
ecc (UtilT, 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.
elvis (UtilT, SrcCD)
elvis is a clone of the vi/ex Unix editor. It
supports nearly all of the vi/ex commands in both visual and
line mode. elvis runs under BSD, System V, Xenix, Minix, MS-DOS &
Atari TOS, and should be easy to port to many other systems.
es (UtilT, SrcCD)
This is an extensible shell based on rc that has
first class functions, lexical scope, an exception system, and
rich return values (i.e. functions can return values other than just
numbers). Like rc, it is great for both interactive use and for
scripting, particularly because its quoting rules are much less baroque
than the C or Bourne shells.
expect (LangT, SrcCD)
expect runs scripts to conduct dialogs with programs. It is
distributed along with Tcl and DejaGnu.
f2c (LangT, SrcCD)
f2c converts Fortran-77 source files into C or C++, which can
then be compiled with GCC.
chgrp,
chmod,
chown,
cp,
dd,
df,
dir,
du,
install,
ln,
ls,
mkdir,
mkfifo,
mknod,
mv,
mvdir,
rm,
rmdir,
touch,
&
vdir.
Only some of these are on the Selected Utilities diskettes.
find (UtilD, UtilT, SrcCD)
find is frequently used both interactively and in shell scripts to
find files which match certain criteria and perform arbitrary operations on
them. xargs and locate are also included.
finger (UtilT, SrcCD)
GNU Finger, which serves as a direct replacement for existing finger
programs, solves this problem. For sites with many hosts, a single host
may be designated as the finger server host. This host collects
information about who is logged in to other hosts at that site. If a user
at site A wants to know about users logged on at site B, a single
query to any machine at the site will return complete information.
flex (LangT, UtilD, SrcCD)
flex is a mostly-compatible replacement for the lex scanner
generator, written by Vern Paxson of the Lawrence Berkeley Laboratory.
flex generates far more efficient scanners than lex does.
Sources for the Flex Manual and reference card are included.
awk. Texinfo source for the GAWK Manual comes with the
software.
object). 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. Function-wide CSE has been written,
but needs to be cleaned up before it can be installed.
Position-independent code is supported on the 68k, i386, Hitachi Slt,
Hitachi H8/300, Clipper, 88k, SPARC & SPARClite.
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 and GNU C extensions. GNU C has
been extended to support nested functions, nonlocal gotos, and 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: a29k, Alpha, ARM, Convex cN, Clipper, Elxsi,
H8300, HP-PA (1.0 and 1.1) i370, i386, i486, i860, i960, m68k, m68020, m88k,
MIPS, ns32k, Pyramid, ROMP, RS6000, SH, SPARC, SPARClite, VAX, and we32k.
Operating systems supported include: AIX, ACIS, AOS, BSD, Clix, Ctix,
DG/UX, Dynix, Genix, HP-UX, ISC, Irix, Linux, Luna, LynxOS, Mach, Minix,
NeWSOS, OSF, OSF-Rose, RISCOS, SCO, Solaris 2, SunOS 4, SysV, Ultrix, Unos,
& VMS.
The old (version 1) machine descriptions for the Alliant, Tahoe and Spur
(as well as a new port for the Tron) do not work, but are still included in
the distribution in case someone wants to work on them.
Using the configuration scheme for GCC, building a cross-compiler is as
easy as building a compiler for the same target machine. Version 2
supports more general calling conventions: it can pass arguments "by
reference" and can preallocate the space for stack arguments. GCC 2 on
the SPARC uses the SPARC conventions for structure arguments and return
values.
Source for the GCC manual, Using and Porting GNU CC, is included
with the compiler. The manual describes how to run and install the GNU C
compiler, and how to port it to new systems. It describes new features and
incompatibilities of the compiler, but people not familiar with C will also
need a good reference on the C programming language. Also see "Project
GNU Status Report".
gdbm (LangT, UtilD, SrcCD)
The gdbm library is the GNU replacement for the traditional
dbm and ndbm libraries. It implements a database using quick
lookup by hashing. gdbm does not need sparse file formats
(unlike its Unix counterparts).
gmp (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.
gnuplot (UtilT, SrcCD)
gnuplot is an interactive program for plotting mathematical
expressions and data. It handles both curves (2 dimensions) and surfaces
(3 dimensions). Curiously, the program was neither written nor named for
the GNU Project; the name is a coincidence.
gperf (LangT, SrcCD)
gperf is a "perfect" hash-table generation utility. There are
actually two implementations of gperf, one written in C and one in
C++. Both will produce hash functions in either C or C++.
spline program;
examples of shell scripts using graph and plot; a statistics
toolkit; and the use of configure for installation.
Existing ports need retesting. Contact Rich Murphey,
Rich@rice.edu, if you can help test/port it to anything beyond
a SPARCstation.
grep/egrep/fgrep (UtilD, UtilT, SrcCD)
The [ef]grep programs are GNU's versions of the Unix programs of the
same name. They are much faster than the traditional Unix versions.
groff and mgm (UtilT, SrcCD)
groff is a document formatting system, which includes
implementations of troff, pic, eqn, tbl,
refer, the man, ms and mm macros,
as well as drivers for Postscript, TeX dvi format, and typewriter-like
devices. Also included is a modified version of the Berkeley me
macros and an enhanced version of the X11 xditview previewer.
mgm is a macro package for groff. It is almost compatible
with the DWB mm macros and has several extensions.
Also see "Project GNU Status Report".
gzip (DjgppD, EmcsT, LangT, SrcCD, UtilT)
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 have switched to another
compression program, gzip. gzip can expand LZW-compressed
files but uses a different algorithm for compression which generally
produces better results. It also uncompresses files compressed with System
V's pack program.
hello (UtilT, SrcCD)
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.
Like any truly useful program, hello provides a built-in mail
reader.
hp2xx (UtilT, SrcCD)
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 and 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).
indent (UtilD, UtilT, SrcCD)
GNU indent is a modified version of the freely-redistributable BSD
program of the same name. It formats C source according to GNU coding
standards by default, though the BSD default and other formats are
available as options. Also see "Project GNU Status Report".
ispell (UtilT, SrcCD)
Ispell is an interactive spell checker that suggests "near misses" as
replacements for unrecognized words. System and user-maintained
dictionaries can be used. Standalone and GNU Emacs interfaces are
available.
nexus.yorku.ca in
`/pub/scheme/new',
altdorf.ai.mit.edu in `/archive/scm' or
prep.ai.mit.edu in `/pub/gnu/jacal'.
The FSF is not distributing JACAL on any media. To receive an IBM PC
floppy disk with the source and executable files, send $99.00 to:
Aubrey Jaffer 84 Pleasant Street Wakefield, MA 01880 USA
less (UtilD, UtilT, SrcCD)
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 (UtilD, UtilT, SrcCD)
GNU m4 is an implementation of the traditional Unix macro processor.
It is mostly SVR4 compatible, although it has some extensions (for example,
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, EmcsT, LangT, UtilD, UtilT, SrcCD)
GNU make supports POSIX 1003.2 and has all but a few obscure
features of the BSD and System V versions of make, as well as many
of our own extensions. GNU extensions include long options, parallel
compilation, conditional execution and functions for text manipulation.
Texinfo source for the Make Manual comes with the program.
GNU make is on several of our tapes because some native
make programs lack the VPATH feature essential for using
the GNU configure system to its full extent. A shell script is included to
build GNU make on such systems. Also see "Project GNU Status
Report".
ftp.che.utexas.edu in
the directory `/pub/octave'. The files are in gzipped tar format
(see the file `README' on prep.ai.mit.edu:/pub/gnu).
The Octave distribution includes a 150+ page Texinfo manual.
p2c (LangT, SrcCD)
p2c is a Pascal-to-C translator written by Dave Gillespie. It is
intended primarily for use on 32-bit machines, though porting it to convert
code to work on 16-bit machines may be possible.
patch (UtilT, SrcCD)
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.
perl (LangT, SrcCD)
Larry Wall's perl combines the features and capabilities of
sed, awk, sh and C, as well as interfaces to all the
system calls and many C library routines. Perl Mode for editing
perl code comes with GNU Emacs 19.
ptx (UtilD, UtilT, SrcCD)
ptx is the GNU version of ptx, a permuted index generator.
Among other things, it produces readable "KWIC" (KeyWords In Context)
indexes without the need of nroff. There is an option to output
TeX code.
rc (UtilT, SrcCD)
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.
diff, RCS can
handle binary files (executables, object files, 8-bit data, etc).
Also see the entry for "CVS".
recode (UtilT, SrcCD)
recode converts files between character sets and usages. When exact
transliterations are not possible, it may get rid of the offending
characters or fall back on approximations. This program recognizes or
produces nearly 150 different character sets and is able to transliterate
files between almost any pair. Most RFC 1345 character sets are supported.
screen (UtilT, SrcCD)
screen is a terminal multiplexor that runs several separate
"screens" (ttys) on a single physical terminal. Each virtual terminal
emulates a DEC VT100 plus several ANSI X3.64 and ISO 2022 functions.
screen sessions can be detached and resumed later on a different
terminal.
sed (UtilD, UtilT, SrcCD)
sed is a stream-oriented version of ed. It is used copiously
in shell scripts. GNU sed comes with the rx library, which is a faster
version of regex.
basename,
date,
dirname,
echo,
env,
expr,
false,
groups,
id,
nice,
nohup,
printenv,
printf,
sleep,
stty,
su,
tee,
test,
true,
tty,
uname,
who,
whoami,
&
yes.
Matthias Mutz
Universitaet Passau, FMI
94030 Passau
Germany
E-mail: mutz@kirk.fmi.uni-passau.de
tar (UtilT, SrcCD)
GNU tar includes multivolume support, the ability to archive sparse
files, automatic archive compression/decompression, remote archives and
special features that allow tar to be used for incremental and full
backups. Unfortunately GNU tar implements an early draft of the
POSIX 1003.1 ustar standard which is different from the final
standard. Adding support for the new changes in a backward-compatible
fashion is not trivial.
tar on either a 1/4-inch
4-track QIC-24 cartridge or a 4mm DAT cartridge, send $210.00 to:
Northwest Computing Support Center
DR-10, Thomson Hall 35
University of Washington
Seattle, WA 98195
E-mail: unixtex@u.washington.edu
Phone: (206) 543-6259
Please make checks payable to the University of Washington. Checks must be
in U.S. Dollars, drawn on a U.S. bank.
Prepaid orders are preferred but purchase orders are acceptable;
however, purchase orders carry an extra charge of $10.00 to pay for
invoice processing.
Overseas sites: please add to the base cost $20.00 for shipment via
air parcel post, or $30.00 for shipment via courier.
Please check with the above for current prices and formats.
cat,
cksum,
comm,
csplit,
cut,
expand,
fold,
head,
join,
nl,
od,
paste,
pr,
sort,
split,
sum,
tac,
tail,
tr,
unexpand,
uniq,
&
wc.
expect and DejaGnu work with and use Tcl.
time (UtilT, SrcCD)
time is used to report statistics (usually from a shell) about the
amount of user, system and real time used by a process.
tput (UtilT, SrcCD)
tput is a portable way to allow shell scripts to use special
terminal capabilities. GNU tput uses the Termcap database, rather
than Terminfo as most implementations do.
f, g (in all
window and packet sizes), G, t and e protocols, as
well a Zmodem protocol and two new bidirectional protocols. If you have a
Berkeley sockets library, it can make TCP connections. If you have TLI
libraries, it can make TLI connections.
uuencode (UtilT, SrcCD)
Uuencode and uudecode are used to transmit binary files over
transmission mediums that do not support other than simple ASCII data.
wdiff (UtilT, SrcCD)
wdiff compares two files, finding which words have been deleted or
added to the first in order to obtain the second. We hope eventually to
integrate it, as well as some ideas from a similar program called
spiff, into future releases of GNU diff.
Delft University of Technology, the Netherlands, has developed OCEAN, a comprehensive chip design package. It includes a full set of powerful tools for synthesis and verification of semi-custom sea-of-gates and gate-array chips. OCEAN covers the back-end of the design trajectory--from circuit level, down to layout and a working chip.
OCEAN provides interactive tools for placement, routing, simulation and extraction, either automatically or manually guided. It is available as free software, with full source code, and is known to run on Linux, HP and Sun workstations under the X Window System. For import and export of data, it knows about EDIF, BLIF, SLS, GDSII, CIF, SPICE and LDM.
You can obtain OCEAN by anonymous FTP from
donau.et.tudelft.nl. For more information, contact
patrick@donau.et.tudelft.nl on the Internet.
This tape contains a Common Lisp implementation, GNU Emacs, assorted extensions that work with GNU Emacs, and a few other important utilities.
gzip 1.2.4
make 3.70
This tape contains programming tools: compilers, interpreters, and related programs (parsers, conversion programs, debuggers, etc.).
dld 3.2.3
expect 4.7.6
ecc 1.2.1
f2c 1993.04.28
flex 2.4.5
gdbm 1.7.1
gmp 1.3.2
gperf 2.1a
gzip 1.2.4
indent 1.8
make 3.70
p2c 1.20
perl 4.036
This tape consists mostly of smaller utilities and miscellaneous applications not available on the other GNU tapes.
acm 4.2
bc 1.02
cpio 2.3
dc 0.2
doschk 1.1
elvis 1.7
es 0.84
find 3.8
finger 1.37
gnuplot 3.5
grep/egrep/fgrep 2.0
gzip 1.2.4
hello 1.3
hp2xx 3.1.4
ispell 4.0
less 177
m4 1.1
make 3.70
patch 2.1
ptx 0.3
rc 1.4
recode 3.3
screen 3.5.2
sed 2.03
tar 1.11.2
time 1.6
tput 1.0
uuencode 1.0
wdiff 0.4
Scheme is a simplified, lexically-scoped dialect of Lisp. It was designed at MIT and other universities to teach students the art of programming, and to research new parallel programming constructs and compilation techniques.
This tape contains MIT Scheme 7.1, which conforms to the "Revised^4 Report On the Algorithmic Language Scheme" (MIT AI Lab Memo 848b), for which TeX source is included. It is written partly in C, but is presently hard to bootstrap. Binaries which can be used to bootstrap Scheme are available for the following systems:
If your system is not on this list and you don't enjoy the bootstrap challenge, see the "JACAL" entry in the "GNU Software Available Now."
The two X11 tapes contain Version 11, Release 5 of the MIT X Window System. The first FSF tape contains all of the core software, documentation and some contributed clients. We call this the "required" X tape since it is necessary for running X or running GNU Emacs under X. The second, "optional", FSF tape contains contributed libraries and other toolkits, the Andrew User Interface System, games, and other programs.
The X11 Required tape also contains all fixes and patches released to date. We update this tape as new fixes and patches are released.
The Berkeley "Net2" release contains the second 4.3 BSD distribution and is newer than both 4.3 BSD-Tahoe and 4.3 BSD-Reno. It includes most of the BSD software system except for a few utilities, some parts of the kernel and some library routines which your own C library is likely to provide (we have replacements on other tapes for many of the missing programs). This release also contains third party software including Kerberos and some GNU software.
We offer two VMS tapes. One has just the GNU Emacs editor (none of the other software on the Emacs Tape, described above, is included). The other has the GNU C compiler, Bison (to compile GCC), GAS (to assemble GCC's output) and some library and include files (none of the other software on the Languages Tape, described above, is included). We are not aware of a GDB port for VMS. Both VMS tapes have executables from which you can bootstrap, as the DEC VMS C compiler cannot compile GCC. Please do not ask us to devote effort to VMS support, because it is peripheral to the GNU Project.
Hundred Acre Consulting continues to provide support and development services, with its specialty being the GNU C and C++ compilers. It continues its policy of donating a percentage of its profit to the FSF. Their address is:
Hundred Acre Consulting
5301 Longley Lane, Suite D-144
Reno, NV 89511
USA
Phone: (702) 829-9700 or +1-800-245-2885
Fax: (702) 829-9926
E-mail: info@pooh.com
The Free Software Foundation has produced its third source CD-ROM. It contains the following:
acm 3.1
bc 1.02
cperf 2.1a
cpio 2.3
dc 0.2
dld 3.2.3
doschk 1.1
ecc 1.2.1
elvis 1.7
es 0.84
f2c 1993.04.28
find 3.8
finger 1.37
flex 2.3.8
gdbm 1.7.1
gmp 1.3.2
gnuplot 3.5
grep/egrep/fgrep 2.0
gzip 1.2.4
hello 1.3
hp2xx 3.1.3a
indent 1.8
ispell 4.0
less 177
libg++ 2.5.1
m4 1.1
make 3.69.1
p2c 1.20
patch 2.1
perl 4.036
ptx 0.3
rc 1.4
recode 3.2.4
screen 3.5.2
sed 1.18 & 2.03
tar 1.11.2
time 1.6
tput 1.0
uuencode 1.0
wdiff 0.04
The CD-ROM also contains Texinfo source for the GNU Emacs Lisp
Reference Manual Edition 2.02 for version 19 and a snapshot of the Emacs
Lisp Archive at Ohio State University. (You can get libraries in this
archive by UUCP (ask staff@cis.ohio-state.edu for directions)
or by anonymous FTP from archive.cis.ohio-state.edu in
`/pub/gnu/emacs/elisp-archive'.)
The contents of the MIT Scheme, VMS, and Net2 tapes are not included
The CD-ROM is in ISO 9660 format and can be mounted as a read-only file system on most operating systems. If your driver supports it you can mount the CD-ROM with "Rock Ridge" extensions and it will look just like an ordinary Unix file system, rather than one full of truncated and otherwise mangled names that fit the vanilla ISO 9660 specifications.
You can build most of this software without needing to copy the sources off the CD. Only sufficient disk space for object files and intermediate build targets is required. Except for the MIT Scheme binaries for MS-DOS and the Ghostview for Windows executable, there are no precompiled programs on this CD. You will need a C compiler (programs which need some other interpreter or compiler normally provide the C source for a bootstrapping program).
If a business is ultimately paying, the CD costs $400. It costs $100 if you, an individual, are paying out of your own pocket.
We are now offering a CD-ROM that contains executables for GNU compiler tools for some systems which lack a compiler. This will allow users of those systems to compile GNU and other free software without having to buy a proprietary compiler.
The CD-ROM is in ISO 9660 format and can be mounted as a read-only file system on most operating systems. If your driver supports it you can mount the CD-ROM with "Rock Ridge" extensions and it will look just like an ordinary Unix file system, rather than one full of truncated and otherwise mangled names that fit the vanilla ISO 9660 specifications.
We hope to have more systems included with each update of this CD-ROM. If you can help build binaries for new systems (especially for systems that don't come with a C compiler), or have a system to suggest, please contact us at either address on the front cover.
These programs:
For these platforms:
i386-msdos
hppa1.1-hp-hpux9
sparc-sun-solaris2
sparc-sun-sunos4.1
If you do not have net access, our subscription service enables you to stay current with the latest FSF developments. For a one-time cost equivalent to three tapes or CD-ROMs, we will mail you four new versions of the tape of your choice or the Source Code CD-ROM. The tapes are sent each quarter, the Source Code CD-ROMs are sent as they are issued. (The Source Code CD-ROM is currently issued twice a year, but we may issue it more frequently in the future.)
Regularly, we will send you a new version of an Emacs, Languages, Utilities, or MIT X Window System Required tape or the Source CD-ROM. The BSD Net-2, MIT Scheme, and MIT X Window System Optional tapes are not changed often enough to warrant quarterly updates. The Compiler Tools Binaries CD-ROM is so new we do not yet know if we will be offering subscriptions to it.
Since Emacs 19 is now on the Emacs Tape and the Source CD-ROM, a subscription to either will be a convenient way to keep current with Emacs 19 updates as it moves through beta-test.
A subscription is also an easy way to keep up with the regular bug fixes to the MIT X Window System. We update the X11 Required tape, as fixes and patches for the X Window System are issued throughout the year. Each new edition of the Source CD-ROM also has updated sources for the X Window System. See sections "Tape Subscriptions" and "CD-ROM Subscriptions" on the "Free Software Foundation Order Form".
All the software and publications from the Free Software Foundation are distributed with permission to copy and redistribute. The easiest way to get GNU software is to copy it from someone else who has it. You can get GNU software direct from the FSF by ordering diskettes, a tape, or a CD-ROM. Such orders provide most of the funds for the FSF staff, so please support our work by ordering if you can. See the "Free Software Foundation Order Form".
There are also third party groups who distribute our software; they do not work with us, but can provide our software in other forms. For your convenience some are listed in "Free Software for Microcomputers". Please note that the Free Software Foundation is not affiliated with them in any way and is responsible for neither the currency of their versions nor the swiftness of their responses.
If you decide to do business with one of these distributors, ask them how much they do to assist free software development, e.g. by contributing money to free software development projects or by writing free software themselves for general use. By basing your decision partially on this factor, you can help encourage those who profit from free software to contribute to its growth.
If you have Internet access and cannot access one of the hosts below, you
can get the software via anonymous FTP from GNU's distribution host
prep.ai.mit.edu (the IP address is 18.71.0.38). For
more information, get file `/pub/gnu/GETTING.GNU.SOFTWARE'.
prep is a very busy host and only allows a limited number of FTP
logins at any given time. Please use one of these other TCP/IP Internet
sites that also provide GNU software via anonymous FTP (program:
ftp, user: anonymous, password: your e-mail
address, mode: binary).
ftp.sun.ac.za.
archie.au (archie.oz for ACSnet),
cair.kaist.ac.kr,
utsun.s.u-tokyo.ac.jp,
ftp.cs.titech.ac.jp.
ftp.cs.ubc.ca.
ftp.technion.ac.il.
ugle.unit.no,
ftp.stacken.kth.se,
isy.liu.se,
ftp.luth.se,
unix.hensa.ac.uk,
ftp.mcc.ac.uk,
ftp.informatik.tu-muenchen.de,
ftp.informatik.rwth-aachen.de,
ftp.denet.dk,
ftp.eunet.ch,
nic.switch.ch,
irisa.irisa.fr
ftp.funet.fi,
ftp.win.tue.nl,
ftp.univ-lyon1.fr,
archive.eu.net.
labrea.stanford.edu,
ftp.kpc.com,
ftp.digex.net,
ftp.cs.widener.edu,
ftp.cs.columbia.edu,
vixen.cso.uiuc.edu,
wuarchive.wustl.edu,
gatekeeper.dec.com,
ftp.hawaii.edu,
cc.utah.edu (VMS GNU Emacs),
mango.rsmas.miami.edu (VMS GCC),
ftp.uu.net (under `/packages/gnu').
Those on JANET can look under src.doc.ic.ac.uk in
`/gnu'.
You can get some GNU programs via UUCP. Ohio State University posts their
UUCP instructions regularly to newsgroup comp.sources.d on
USENET. These people will send you UUCP instructions via electronic mail:
hao!scicom!qetzal!upba!ugn!nepa!denny, uunet!hutch!barber, src@contrib.de (Europe), james@bigtex.cactus.org, acornrc!bob, toku@dit.co.jp (Japan), staff@cis.ohio-state.edu
For those without Internet access, see the section "Free Software Support" for information on getting electronic mail and file transfer via UUCP.
The Free Software Foundation has been repeatedly asked to create a package that provides executables for all of our software. Usually we offer only sources. In addition to providing binaries with the source code, the Deluxe Distribution includes copies of all our printed manuals and reference cards.
The FSF Deluxe Distribution contains the binaries and sources to hundreds of different programs including GNU Emacs, the GNU C Compiler, the GNU Debugger, the complete MIT X Window System, and all the GNU utilities.
You may choose one of these machines and operating systems: HP 9000 series
300, 700 or 800 (4.3 BSD or HP-UX); RS/6000 (AIX); SONY News 68k (4.3
BSD or NewsOS 4); Sun-3, Sun-4, or SPARC (SunOS 4 or Solaris). If your
machine or system is not listed, or if a specific program has not been
ported to that machine, please call the FSF office at the phone number
below or send e-mail to gnu@prep.ai.mit.edu.
We supply the software on one of these media in Unix tar format: 1600 or 6250 bpi, 1/2 inch, reel to reel tape; Sun DC300XLP 1/4 inch cartridge, QIC-24; HP 16 track DC600HC 1/4 inch cartridge; IBM RS/6000 1/4 inch cartridge, QIC-150; Exabyte 8mm cartridge; DAT 4mm cartridge. If your computer cannot read any of these, please call us.
The manuals included are one each of the Bison, Calc, Gawk, GNU C Compiler, GNU C Library, GNU Debugger, Flex, GNU Emacs Lisp Reference, Make, Texinfo & Termcap manuals; six copies of the manual for GNU Emacs; & a packet of reference cards each for GNU Emacs, Calc, the GNU Debugger, Bison, & Flex.
In addition, every Deluxe Distribution includes CD-ROMs (in ISO 9660 format with Rock Ridge extensions) that contains sources of our software & compiler tool binaries for some systems.
The Deluxe Distribution costs $5000. It is for people who want to get everything compiled for them or who want to make a purchase that helps the FSF in a large way. To order, please fill out the "Deluxe Distribution" sections in the "Free Software Foundation Order Form" and send it to:
Free Software Foundation, Inc.
675 Massachusetts Avenue
Cambridge, MA 02139-3309
USA
Electronic mail: gnu@prep.ai.mit.edu
Phone: +1-617-876-3296
FAX: +1-617-492-9057
FAX (in Japan):
0031-13-2473 (KDD)
0066-3382-0158 (IDC)
The FSF distributes, on 3.5 inch 1.44MB diskettes, some of the GNU software ported to MS-DOS. The disks have both sources and executables.
Demacs is a version of GNU Emacs 18.55 ported to MS-DOS, with some changes from Emacs 18.57. Two versions are actually included: one which handles 8-bit character sets; and one based on an early version of MULE which handles 16-bit character sets including Kanji. We distribute them on five diskettes.
Demacs runs on Intel 80386 and 80486--based machines running MS-DOS. It is compatible with XMS memory managers and VCPI, but not yet with Microsoft Windows extended mode or other DPMI managers.
We distribute DJGPP on 22 diskettes. DJGPP requires at least 5MB of hard disk space to install, and 512K of RAM to use. See `GNU Software Available Now" for more information on DJGPP.
The GNUish MS-DOS Project releases GNU software ported to PC compatibles.
In general, this software will run on 8086 and 80286--based machines; an
80386 is not required. Some of these utilities are necessarily missing
features.
Included are:
cpio,
diff,
some file utilities,
find,
flex,
gdbm,
grep,
indent,
less,
m4,
make,
MAWK,
MicroEmacs,
ptx,
RCS,
sed,
shar,
sort,
&
Texinfo.
We are distributing versions of GNU Chess and gnuplot ported to
Microsoft Windows on a single diskette.
We do not provide support for GNU software on microcomputers because it is peripheral to the GNU Project. However, we are distributing a few such programs on tape, CD-ROM and diskette. We are also willing to publish information about groups who do support and maintain them. If you are aware of any such efforts, please send the details, including postal addresses, archive sites and mailing lists, to either address on the front cover.
See "MS-DOS Distribution" and both CD-ROM articles for more information about microcomputer software available from the FSF. Please do not ask us about any other software. The FSF does not maintain any of it and has no additional information.
Boston Computer Society 1 Kendall Square, Bldg 1400, Cambridge, MA 02139 USA Phone: (617) 252-0600
ftp.funet.fi in `/pub/amiga/gnu' (Europe).
For info on (or offers to help with) the GCC port and related projects, ask
Leonard Norrgard, vinsci@nic.funet.fi. For info on the GNU
Emacs port, ask David Gay, dgay@di.epfl.ch, or
Mark D. Henning, henning@stolaf.edu. You can get more info
via anonymous FTP in prep.ai.mit.edu:/pub/gnu/MicrosPorts/Amiga.
atari.archive.umich.edu
(maintained by Howard Chu, hyc@hanauma.jpl.nasa.gov). Ports
are discussed on USENET in
newsgroups
comp.sys.atari.st.tech & comp.sys.atari.st.
hobbes.nmsu.edu
in file `/os2/2_x/unix/gnu/gcc2_233' by FTP. To join the
mailing list, send a message to os2gcc-request@charon.mit.edu.
tsx-11.mit.edu in `/pub/linux' (USA),
nic.funet.fi in `/pub/OS/Linux' (Europe). Ask
linux-activists-request@niksula.hut.fi about their mailing
lists. See USENET newsgroup comp.os.linux.misc et al for Linux
discussions.
int86 Lisp function, machine-specific
features such as function key support, file name completion with drive
name, child processes (suspend-emacs and call-process).
Dired mode works without `ls.exe'. Anonymous FTP it from:
wuarchive.wustl.edu in `/mirrors/msdos/demacs',
utsun.s.u-tokyo.ac.jp in `/GNU/demacs' (Japan),
and ftp.funet.fi in `/pub/gnu/emacs/demacs' (Europe).
The FSF is distributing Demacs on floppies (see "MS-DOS Distribution").
info-gnu-msdos-request@sun.soe.clarkson.edu about
MS-DOS ports of GNU programs and related mailing lists. Or anonymous FTP
files `/pub/gnu/MicrosPorts/MSDOS*' on prep.ai.mit.edu.
The FSF is distributing MS-DOS ports of many GNU programs on
both
floppies
& CD
(see "MS-DOS Distribution" & "Source Code CD-ROM").
We still have our Free Software Foundation T-shirts available, designed by Cambridge artist Jamal Hannah. The front of the t-shirt has an image of a GNU hacking at a workstation with the text "GNU's Not Unix" above and the text "Free Software Foundation" below. They are available in two colors, Natural and Black. Natural is an off-white, unbleached, undyed, environment-friendly cotton, printed with black ink, and is great for tye-dyeing or displaying as is. Black is printed with white ink and is perfect for late night hacking. All shirts are thick 100% cotton, and are available in sizes M, L, XL and XXL.
The front of the t-shirt has an image of a GNU hacking at a workstation with the text "GNU's Not Unix" above and the text "Free Software Foundation" below. We have just added a copy of the GNU General Public License to the back of the t-shirt, which use to be blank.
Use the "Free Software Foundation Order Form" to order your shirt, and consider getting one as a present for your favorite hacker!
Work for something because it is good, not just because it stands a chance to succeed.
-Vaclav Havel
Thanks to all those mentioned above in "Informal GCC Consortium", "GNUs Flashes", "Project GNU Status Report", "Second Annual GNU Seminar in Japan", "GNU and other Free Software in Japan" and "GNU Software Available Now".
Thanks to the Artificial Intelligence Laboratory, Laboratory for Computer Science, and Project Athena at MIT for their invaluable assistance.
Thanks to the many companies and organizations who have brought our Deluxe Distribution package.
For their assistance in Japan, thanks to: Nobuyuki Hikichi, Mieko Hikichi, Ken'ichi Handa, Bob Myers, David Littleboy, Prof. Masayuki Ida, Japan Unix Society, Senri International Information Institute, Industrial Vitalization Center for Tohoku, The University of Aizu, and Nihon Sun User Group. Thanks to Addison Wesley Publishers Japan, A.I. Soft, Village Center, Inc., ASCII Corporation and many others in Japan, for their continued donations and support.
Thanks to the Sun Users Group, PCI, and the USENIX Association, for donating booths at their conferences. Thanx to all the volunteers who helped the GNU Project at these and other conferences. Thanks to Wired Magazine and Barry Meikle of the University of Toronto Bookstore for donating us ad space in their separate publications.
Thanks again to the Open Software Foundation for their continued support; and to Cygnus Support for assisting Project GNU in many ways. Thanks to Warren A. Hunt, Jr. and Computational Logic, Inc. for their donation and support. Thanks to Aalborg University for donating a part-time programmer. Thanks to Jamie Zawinski for his implementation of some of the X-related features in Emacs 19.
Thanks go out to all those who have either lent or donated machines, including an anonymous donor for a 4mm DAT catridge drive, IBM Corp. for an Exabyte tape drive and an RS/6000; Cygnus Support for a Sun SPARCstation; Hewlett-Packard for two 80486, six 68030 and four Spectrum computers; Brewster Kahle of Thinking Machines Corp. for a Sun-4/110; CMU's Mach Project for a Sun-3/60; Intel Corp. for their 386 machine; NeXT for their workstation; the MIT Media Laboratory for a Hewlett-Packard 68020; SONY Corp. and Software Research Associates, Inc., both of Tokyo, for three SONY News workstations; the MIT Laboratory of Computer Science for the DEC MicroVAX; the Open Software Foundation for two Compaq 386s; Delta Microsystems for an Exabyte tape drive; an anonymous donor for 5 IBM RT/PCs; Liant Software Corp. for five VT100s; Jerry Peek for a 386 machine; NCD Corporation for an X terminal; and Interleaf, Inc., Veronika Caslavsky, Paul English, Cindy Woolworth and Lisa Bergen for the loan of a scanner.
Thanks to all who have contributed ports & extensions, as well as all who have sent in other source code, documentation, & good bug reports.
Thanks to all those who sent money and offered other kinds of help.
Thanks also to all those who support us by ordering manuals, distribution tapes, diskettes, and CD-ROMs.
The creation of this bulletin is our way of thanking all who have expressed interest in what we are doing.
----------------------------------------------------------------------
-------
Free Software Foundation, Inc | |
Electronic Mail: gnu@prep.ai.mit.edu | stamp |
675 Massachusetts Avenue | |
Cambridge, MA 02139-3309 | here |
USA | |
-------
----------------------------------------------------------------------
This document was generated on 7 May 1998 using the texi2html translator version 1.52.
Please send FSF & GNU inquiries & questions to gnu@gnu.org. There are also other ways to contact the FSF.
Please send comments on these web pages to webmasters@www.gnu.org, send other questions to gnu@gnu.org.
Copyright (C) 1994 Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA
Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.