From 0b4dedd68d6f316149d0da5bbaebc5c3b1d44884 Mon Sep 17 00:00:00 2001
From: ram <ram>
Date: Fri, 4 Nov 1994 07:11:23 +0000
Subject: [PATCH] update for 17f.

---
 general-info/beta-release-notes.txt | 165 ++++-
 general-info/net-announce.txt       | 894 ++++++++++++++--------------
 2 files changed, 611 insertions(+), 448 deletions(-)

diff --git a/general-info/beta-release-notes.txt b/general-info/beta-release-notes.txt
index 8186d88b7..d634ecaaf 100644
--- a/general-info/beta-release-notes.txt
+++ b/general-info/beta-release-notes.txt
@@ -1,4 +1,167 @@
-	    Release notes for CMU Common Lisp 17e, 19 September 93
+	    Release notes for CMU Common Lisp 17f, ?? November 94
+
+17f contains bug fixes, PCL enhancements, and support for three new platforms:
+    Sun SPARC/Solaris
+    SGI MIPS/Iris (no load-foreign)
+    DEC Alpha/OSF1 (no Motif or load-foreign)
+
+The HPPA/HPux and Sun/Sunos 4.x platforms are still available.  Distributions
+are now gzip'd, not compressed.
+
+Other highlights: Motif, load-foreign on Hp/Ux, image size improvements, MIT
+loop, some documentation of some previously undocumented features.
+
+[Also see the README file for platform-specific notes.]
+
+Bug fixes to basic CL support:
+ -- Fixed ADJUST-ARRAY to not flame out on arrays containing a zero-length
+    dimension (hence having no elements whatsoever.)
+ -- In SIGNAL, bind *break-on-signals* to NIL even before doing the type test
+    so that we don't wedge the error system if the type is malformed or
+    undefined.
+ -- Fixed bugs with EOF handling in READ-LINE.
+ -- In DEFINE-CONDITION, don't warn about probable error unless both initarg
+    and initform are missing.
+ -- In OPEN, fixed :direction :io :if-does-not-exist :create to actually
+    create.
+ -- Fix problem in LOAD-FOREIGN where (especially on SunOS), the failure to
+    page-align loaded code caused errors when load-foreign was done more than
+    once.
+ -- In OUTPUT-INSTANCE, check for the layout being invalid before calling the
+    print function, since the print function might error.
+ -- Closing composite streams (broadcast, etc.) no longer closes the component
+    streams. 
+ -- Fixed pprint goof that didn't actually break anything, but wasted effort.
+ -- (COERCE x 'FLOAT) now convert to a single-float (instead of being an
+    error.)  Also, we now check that numeric coercions actually return a value
+    of the specified type (which they might not if the type is not a symbol,
+    e.g. (coerce 0 '(complex float)).  Possibly these should "do the right
+    thing", but it seems better to error than quietly do the wrong thing.
+ -- Fixed a bug in FLOAT-BIGNUM-RATIO that could cause an assertion failure
+    when floating particular bignum ratios (or possibly reading particular
+    float values.)
+
+Miscellaneous enhancements:
+ -- LOOP is now the MIT/Symblics loop, so whatever it does is by definition
+    correct and The Right Thing.
+ -- PURIFY is now exported as EXT:PURIFY.  This function can greatly improve
+    the GC performance of many large programs by moving code and static data
+    into non-collected storage.  This is a "poor man's generational GC".
+    Environment compaction now done by purify.
+ -- Some reduction in the size of the image (and of GC scanned memory) from
+    tweaks to build process.
+ -- Binary input can now be done from string streams (from David Axmark.)
+ -- Debugger no longer aborts printing of a frame when printing one arg gets an
+    error (from Harris.)
+ -- LOAD-FOREIGN support for HP/Ux (from TSM.)
+ -- Add sap-ref-64 (only on Alpha).
+ -- Changes to EVAL, ROOM and site-init to work better in a runtime core image
+    (without the compiler loaded.)
+ -- *BEFORE-SAVE-INITIALIZATIONS* is now actually done before saving.
+
+Compiler:
+ -- Fixed some problems with multiple values and cleanup code in byte
+    compilation.  Also added EXT:*COMPILE-PROGRESS* printout.
+ -- Fixed some problems with internal errors when a function was just
+    declared to be FUNCTION.
+ -- Now allows stream args to compile-file and doesn't attempt to constant-fold
+    pathname functions (which depend on *default-pathname-defaults*.)
+ -- Fixed a case where dead local function in top-level code could cause an
+    internal error.
+ -- Fix compiler-macro expansion to correctly handle macros that pass (by
+    returning the unmodified form.)
+ -- Fix spelling of :COMPILE-TOPLEVEL and :LOAD-TOPLEVEL in EVAL-WHEN.
+ -- If compile-file is :block-compile T, the entire file is block-compiled as a
+    unit (even if it contains embedded START-BLOCK/END-BLOCK declarations.)
+ -- Virtually all of the compiler is now compiled without type checking, giving
+    some space and speed benefit.
+
+CLX:
+ -- Merged with CLX R5.02 (no substantive changes).  
+ -- In read-resources, trim off spaces, tabs, and "'s in #include file name
+ -- If CLX is compiled when PCL is loaded (as is now done in the binary
+    distribution), DRAWABLE, WINDOW and PIXMAP will be defined as PCL classes
+    (which can be subclasses.)  This is compatible with various CLX-based
+    toolkits.
+ -- Fix some CONS declarations to be LIST because they aren't conses on the
+    last iteration (when the body isn't executed.)
+ -- Fix incorrect slot type declaration for DISPLAY-AUTHORIZATION-DATA.
+ -- Changed holding-lock not to turn off GC, which could cause event handlers
+    and other code to run for ling periods of time without garbage collecting.
+    Instead we bind all the GC hooks to (), since it was their invocation that
+    could cause bad recursive entry of CLX.
+
+Hemlock:
+ -- Fixed problem in Hemlock recursive error handler (hadn't been properly
+    updated for ANSI conditions.)
+ -- Add ignore handler for client-message events.
+ -- Deleted some setting of hi::*hack-hunk-replace-line* to T, since we may
+    want it explicitly disabled in the init file.
+ -- Dylan mode now infix-oriented.
+
+Motif interface:
+ -- Fixed a bug in the generation of Interface.h which was preventing motifd 
+    from being successfully compiled on HP/Ux, Solaris, ...
+ -- use pcl::precompile-random-code-segments to minimize run-time compilations.
+ -- Add INVOKE-TTY-DEBUGGER.  Don't try to invoke motif debugger if we didn't
+    succeed in opening a connection.
+ -- Print warning in status hook when server dies.
+ -- Made server to fflush after all output so that we see motifd output
+    when it is run on a pipe.
+ -- Fixed severely broken INSPECT-CLOS-PANE according to patch from Marco
+    Antoniotti. 
+ -- Fix from Marco Antoniotti to actually remove handlers from the table in
+    remove-event-handler.
+ -- Fix to TOOLKIT-WRITE-VALUE to allow it to write either signed or unsigned
+    word integers.
+ -- Improved error recovery and internal error reporting.
+
+PCL:
+ -- Structure-object is now no longer shadowed in PCL.  Code that was using
+    PCL::STRUCTURE-OBJECT will now work better.
+ -- BUILT-IN-CLASS, CLASS-NAME, CLASS-OF and FIND-CLASS are once again exported
+    from PCL.  This will cause a name conflict if anyone use-package's PCL, but
+    this will at least warn about the distinction.  Probably you shouldn't
+    USE-PACKAGE PCL for this reason, but you can now say PCL:FIND-CLASS instead
+    of PCL::FIND-CLASS.  It is also possible to use SHADOW or SHADOWING-IMPORT
+    to resolve the conflict.
+ -- Fix to update-instance-for-different-class.
+ -- When updating arg-info slots, check to see if the value is already there.
+    This can reduce non-shared pages.
+ -- Improved handling of invalid structure instances.
+ -- Fix a problem with PCL clobbering byte functions when setting their names.
+ -- New parameterized version of use-dispatch-dfun-p which avoids pessimizing
+    GFs with many methods.
+ -- Fix to :after methods on accessor functions.  Also, fixed some problems
+    with the result of get-secondary-dispatch-function1 when there are no
+    methods.
+ -- Add compiler-macro for pcl:find-class which does lookup at load-time
+    when the name is a constant.
+ -- Definitive tweak for handling function-p in
+    compute-secondary-dispatch-function1 which avoids an infinite recursion. 
+ -- When signalling an incompatible superclass error, added a hint to the
+    message to check out VALIDATE-SUPERCLASSES.
+
+Lisp code:
+ -- Fixed Sparc GC bug fix (L2 never scavenged.)
+ -- On all non-Mach platforms, changed the default for CMUCLLIB to be
+    /usr/local/lib/cmucl/lib.
+ -- On SunOS, added "dynamic segments" patch which prevents the "out of
+    segments" errors that could happen when a Lisp memory management table
+    overflowed.
+
+Build tools:
+ -- Fix compilation of motif interface to actually generate the C header files
+    Interface.h, etc.
+ -- Some changes to reduce compiler warnings
+ -- In compile-all, -clean and -noupdate have been flushed.  -clean is now
+    done by the clean-build script. 
+ -- Add some scripts from David Axmark that automate the entire build process:
+	tools/variant-lisp
+	tools/build-and-install
+
+
+	    Release notes for CMU Common Lisp 17e, 11 March 94
 
 17e is primarily a bug-fix release.  This release is also available on
 Hewlett-Packard 700-series workstations running HP/UX version 9.x.  
diff --git a/general-info/net-announce.txt b/general-info/net-announce.txt
index da0bd150b..196e7b1a7 100644
--- a/general-info/net-announce.txt
+++ b/general-info/net-announce.txt
@@ -1,8 +1,26 @@
-	    Release notes for CMU Common Lisp 17e, 11 March 94
+	    Release notes for CMU Common Lisp 17f, ?? November 94
 
-17e is primarily a bug-fix release.  This release is also available on
-Hewlett-Packard 700-series workstations running HP/UX version 9.x.  The main
-missing features on HP/UX are LOAD-FOREIGN and the Motif interface.
+17f contains bug fixes, PCL enhancements, and support for three new platforms:
+    Sun SPARC/Solaris
+    SGI MIPS/Iris (no load-foreign)
+    DEC Alpha/OSF1 (no Motif or load-foreign)
+
+The HPPA/HPux and Sun/Sunos 4.x platforms are still available.  Distributions
+are now gzip'd, not compressed.
+
+Other highlights: Motif, load-foreign on Hp/Ux, image size improvements, MIT
+loop, some documentation of some previously undocumented features.
+
+NOTE:
+
+Although the group lives on (and is working on Dylan/Gwydion), the CMU Common
+Lisp project is no longer funded, so only minimal CL support is being done at
+CMU.  There is a net community of CMU Common Lisp users and maintainers who
+communicate via comp.lang.lisp and the cmucl-bugs@cs.cmu.edu mailing list.
+This release contains patches from the net (including the major Solaris effort
+by Caspar Dik), and also some things that were "in the pipe" (the Alpha and
+Irixs ports.)  None of these ports has been extensively tested, and there are
+missing parts.  As always, you get what you pay for.
 
 Distribution:
 
@@ -13,26 +31,36 @@ manpower to make tapes.  These are our distribution machines:
     lisp-rt2.slisp.cs.cmu.edu (128.2.217.10)
 
 Log in with the user "anonymous" and "username@host" as password (i.e. your
-EMAIL address.)  When you log in, cd to /pub (a symbolic link to the CMU CL
-release area.)  If you have any trouble with FTP access, please send mail to
-slisp@cs.cmu.edu.
+EMAIL address.)  When you log in, cd USING ONE SINGLE "cd" COMMAND to
+/afs/cs/project/clisp/release.  If you have any trouble with FTP access,
+please send mail to slisp@cs.cmu.edu.
 
-The most recent version is: 17e
+The most recent version is: 17f
 The old version is: 16f
 
 The currently supported platforms are:
-    sunos:
-        Sun SPARC machines running the the pre-Solaris BSD SunOS system,
-        version 4.x.
+    alpha_osf1:
+	DEC Alpha workstations running OSF1.
 
     hp700_ux90:
         HP 700 series machines (based on the HPPA architecture) running HP/UX
         9.x.
 
-The release area holds compressed tar files with names of the form:
-    <version>-<platform>.tar.Z
-    <version>-extra-<platform>.tar.Z
-    <version>-runtime-<platform>.tar.Z
+    sgi_52:
+	MIPS-based SGI workstations running Irix 5.x.
+
+    sun4c_411:
+        Sun SPARC machines running the the pre-Solaris BSD SunOS system,
+        version 4.x.
+
+    sun4c_53:
+	Sun SPARC machines running Solaris/SunOS 5.x.
+
+
+The release area holds gzip'ed tar files with names of the form:
+    <version>-<platform>.tar.gz
+    <version>-extra-<platform>.tar.gz
+    <version>-runtime-<platform>.tar.gz
 
  -- The first file holds binaries and documentation for the standard Common
     Lisp portion of CMU CL.  This includes our version of the PCL
@@ -43,43 +71,27 @@ The release area holds compressed tar files with names of the form:
     smaller substitute for lib/lisp.core.  See the "runtime distribution"
     section.
 
-The sizes of the configurations are approximately:
+
+The installed sizes of the configurations are approximately:
     Basic: 15 megabytes
     Basic+Extra: 24 megabytes
     Runtime: 5.3 megabytes
 
 For installation directions, see the section "site initialization".
 
-FTP compressed tar archives in binary mode.  To extract, "cd" to the
+FTP gzip'ed tar archives in binary mode.  To extract, "cd" to the
 directory that is to be the root of the tree, then type:
-    uncompress <file.tar.Z | tar xf - .
+    gzcat file.tar.gz | tar xf - .
 
-If poor network connections make it difficult to transfer a 7 meg file, the
+If poor network connections make it difficult to transfer a 6 meg file, the
 release is also available split into 2 megabyte chunks, suffixed `.0', `.1',
 etc.  To extract from multiple files, use:
-    cat file.tar.Z.* | uncompress | tar xf - .
+    cat file.tar.gz.* | gunzip | tar xf - .
 
 The release area also contains source distributions and other binary
 distributions.  A listing of the current contents of the release area is in
 FILES.  Major release announcements will be made to comp.lang.lisp.
-CMU Common Lisp is only available via anonymous FTP.  We don't have the
-manpower to make tapes.  These are our distribution machines:
-    lisp-sun1.slisp.cs.cmu.edu (128.2.250.58)
-    lisp-rt1.slisp.cs.cmu.edu (128.2.217.9)
-    lisp-rt2.slisp.cs.cmu.edu (128.2.217.10)
-
-Log in with the user "anonymous" and "username@host" as password (i.e. your
-EMAIL address.)  When you log in, cd to /pub (a symbolic link to the CMU CL
-release area.)  If you have any trouble with FTP access, please send mail to
-slisp@cs.cmu.edu.
-
-The release area holds compressed tar files with names of the form:
-    <version>-<machine>_<os>.tar.Z
-    <version>-extra-<machine>_<os>.tar.Z
 
-FTP compressed tar archives in binary mode.  To extract, "cd" to the
-directory that is to be the root of the tree, then type:
-    uncompress <file.tar.Z | tar xf - .
 
 Source availability:
 
@@ -91,457 +103,445 @@ freely distributed without any licensing agreement or fee.
 
 The release area contains a source distribution, which is an image of all the
 source code files used to build the current version:
-    <version>-source.tar.Z (5 meg)
+    <version>-source.tar.gz (5 meg)
 
 ________________________________________________________________
 
 			    DETAILED RELEASE NOTES
 
 [Notes are also in doc/release-notes.txt]
+[Also see the README file for platform-specific notes.]
 
-BASIC COMMON LISP SUPPORT CODE:
-
-Enhancements:
- -- The function EXT:PURIFY is now exported.  This was formerly only
-    documented as usable via the :PURIFY argument to SAVE-LISP.  Great
-    improvements in GC runtime and memory use can be obtained when PURIFY is
-    called after loading in large amounts of code or creating large
-    datastructures that are unlikely to become garbage.
- -- EXT:PURIFY (and thus (EXT:SAVE-LISP ... :PURIFY T) now compact the
-    hashtables representing the global namespace.  Formerly this feature was
-    undocumented and only used during the initial system build.
- -- There is now a "runtime" version of the Lisp image which omits the
-    compiler and loads some other code byte compiled, giving a 60% size
-    reduction.  See README file, "Runtime distribution" section.
- -- Changed the byte-function and byte-closure funcallable-instances to use
-    &more args instead of a &rest arg (eliminating the main source of
-    grautitous consing in byte code.)
- -- Allow pretty-printer to work without compiler loaded.
- -- Improved (and thus changed) the SXHASH of lists and other composite
-    objects.
- -- Added to *FEATURES* all of the ANSI CL features that seemed plausible.
-    Any non-ANSI compliance is now a bug, not a feature...
- -- Picked up Miles' changes to apropos and apropos-list that allows one to
-    supply NIL for the package, meaning all packages.
-
-Bug fixes:
+Bug fixes to basic CL support:
+ -- Fixed ADJUST-ARRAY to not flame out on arrays containing a zero-length
+    dimension (hence having no elements whatsoever.)
  -- In SIGNAL, bind *break-on-signals* to NIL even before doing the type test
     so that we don't wedge the error system if the type is malformed or
-    undefined. 
- -- Fix arg ordering for GETF in new condition support.  Default the name
-    slot in DEFMACRO-LAMBDA-LIST-BIND-ERRORS to NIL (instead of leaving it
-    unbound.)
- -- In READ-N-BYTES, only signal EOF when we read and got 0 bytes, not
-    whenever read returns less than we wanted.  Also, fix the case of small
-    reads with an empty buffer not to leave garbled buffer pointers if we have
-    to do more than one read.  These bugs mostly affect the X interface and
-    its users (Garnet was having problems.)
- -- Changed YES-OR-NO-P and Y-OR-N-P to force output.
- -- Fixed COUNT :TEST-NOT to actually negate the test.
- -- Fixed COERCE to call type-expand so that people can coerce to deftypes.
- -- Rename STEP to DEBUG::SET-STEP-BREAKPOINT because step is supposed to be
-    the exported step macro, not some internal routine.
- -- Fixed DEFPACKAGE to combine multiple use, export, and import options
-    correctly.  Fixed the warning about no longer using some packages to
-    actually work.
- -- Fixed GCD to correctly handle MOST-NEGATIVE-FIXNUM.
- -- Flush Hemlock font change hack in default site-init.lisp, since it was
-    causing problems.
-
-CLOS (PCL):
- -- Add some hacks for coercing lisp:class objects to pcl:class.
- -- Export MAKE-LOAD-FORM-SAVING-SLOTS, not MAKE-LOAD-FORM-DUMPING-SLOTS.
- -- Fix some problems with the LISP:CLASS class-precedence-list suddenly
-    becoming empty when a class is redefined.
- -- Fixed SIMPLE-STRING to list STRING in the inherits list.
- -- Fix to update-instance-for-different-class.
+    undefined.
+ -- Fixed bugs with EOF handling in READ-LINE.
+ -- In DEFINE-CONDITION, don't warn about probable error unless both initarg
+    and initform are missing.
+ -- In OPEN, fixed :direction :io :if-does-not-exist :create to actually
+    create.
+ -- Fix problem in LOAD-FOREIGN where (especially on SunOS), the failure to
+    page-align loaded code caused errors when load-foreign was done more than
+    once.
+ -- In OUTPUT-INSTANCE, check for the layout being invalid before calling the
+    print function, since the print function might error.
+ -- Closing composite streams (broadcast, etc.) no longer closes the component
+    streams. 
+ -- Fixed pprint goof that didn't actually break anything, but wasted effort.
+ -- (COERCE x 'FLOAT) now convert to a single-float (instead of being an
+    error.)  Also, we now check that numeric coercions actually return a value
+    of the specified type (which they might not if the type is not a symbol,
+    e.g. (coerce 0 '(complex float)).  Possibly these should "do the right
+    thing", but it seems better to error than quietly do the wrong thing.
+ -- Fixed a bug in FLOAT-BIGNUM-RATIO that could cause an assertion failure
+    when floating particular bignum ratios (or possibly reading particular
+    float values.)
+
+Miscellaneous enhancements:
+ -- LOOP is now the MIT/Symblics loop, so whatever it does is by definition
+    correct and The Right Thing.
+ -- PURIFY is now exported as EXT:PURIFY.  This function can greatly improve
+    the GC performance of many large programs by moving code and static data
+    into non-collected storage.  This is a "poor man's generational GC".
+    Environment compaction now done by purify.
+ -- Some reduction in the size of the image (and of GC scanned memory) from
+    tweaks to build process.
+ -- Binary input can now be done from string streams (from David Axmark.)
+ -- Debugger no longer aborts printing of a frame when printing one arg gets an
+    error (from Harris.)
+ -- LOAD-FOREIGN support for HP/Ux (from TSM.)
+ -- Add sap-ref-64 (only on Alpha).
+ -- Changes to EVAL, ROOM and site-init to work better in a runtime core image
+    (without the compiler loaded.)
+ -- *BEFORE-SAVE-INITIALIZATIONS* is now actually done before saving.
+
+Compiler:
+ -- Fixed some problems with multiple values and cleanup code in byte
+    compilation.  Also added EXT:*COMPILE-PROGRESS* printout.
+ -- Fixed some problems with internal errors when a function was just
+    declared to be FUNCTION.
+ -- Now allows stream args to compile-file and doesn't attempt to constant-fold
+    pathname functions (which depend on *default-pathname-defaults*.)
+ -- Fixed a case where dead local function in top-level code could cause an
+    internal error.
+ -- Fix compiler-macro expansion to correctly handle macros that pass (by
+    returning the unmodified form.)
+ -- Fix spelling of :COMPILE-TOPLEVEL and :LOAD-TOPLEVEL in EVAL-WHEN.
+ -- If compile-file is :block-compile T, the entire file is block-compiled as a
+    unit (even if it contains embedded START-BLOCK/END-BLOCK declarations.)
+ -- Virtually all of the compiler is now compiled without type checking, giving
+    some space and speed benefit.
+
+CLX:
+ -- Merged with CLX R5.02 (no substantive changes).  
+ -- In read-resources, trim off spaces, tabs, and "'s in #include file name
+ -- If CLX is compiled when PCL is loaded (as is now done in the binary
+    distribution), DRAWABLE, WINDOW and PIXMAP will be defined as PCL classes
+    (which can be subclasses.)  This is compatible with various CLX-based
+    toolkits.
+ -- Fix some CONS declarations to be LIST because they aren't conses on the
+    last iteration (when the body isn't executed.)
+ -- Fix incorrect slot type declaration for DISPLAY-AUTHORIZATION-DATA.
+ -- Changed holding-lock not to turn off GC, which could cause event handlers
+    and other code to run for ling periods of time without garbage collecting.
+    Instead we bind all the GC hooks to (), since it was their invocation that
+    could cause bad recursive entry of CLX.
 
+Hemlock:
+ -- Fixed problem in Hemlock recursive error handler (hadn't been properly
+    updated for ANSI conditions.)
+ -- Add ignore handler for client-message events.
+ -- Deleted some setting of hi::*hack-hunk-replace-line* to T, since we may
+    want it explicitly disabled in the init file.
+ -- Dylan mode now infix-oriented.
 
-COMPILER:
-
-Enhancements:
- -- Added a type inference method for LOG's result type.
- -- Added support for "more args" which are like rest args, but don't cons.
-    This is used for calling into annd out of byte-compiled core and in the
-    PROFILE package.
- -- Increase *inline-expansion-limit* from 50 to 200.  Change "inline
-    expansion count exceeded" warning to be a note.  Don't inline expand in
-    interpreted code.
-
-Bug fixes:
- -- Allow stream arg to compile-file.
- -- Changed assert-definition-type to quietly ignore non function-types.
- -- Allow stream arg to compile-file.
- -- Deleted incorrect type declaration in process-1-ftype-proclamation.
-    Deleted test for function-type-p around call to assert-definition-type,
-    since this is now folded into the function.  Previously several calls
-    weren't doing this necessary check.
- -- Fix a problem where spurious argument types could be inferred for optional
-    arguments in byte-compiled code (caused yes-or-no-p to fail.)
- -- Fixed an internal error related to tail local calls.
- -- Fixed assertion failure about COMPONENT-NEW-FUNCTIONS with some inline
-    expansions. 
- -- Fixed (TYPEP X '(REAL ...)) to actually test against REAL, not NUMBER.
- -- Fixed a problem where top-level MULTIPLE-VALUE-CALL forms could cause an
-    assertion falure. 
- -- Don't try to compile flow-graph components that are unreachable.  This
-    avoids some internal errors when unreachable local functions are
-    deleted.
- -- Fix problem with byte-compiling PROGV getting an internal compiler error.
-
-
-EXTENSIONS:
-
-Misc extensions:
- -- Added an executable-only optional to EXT:UNIX-NAMESTRING so that we can
-    expand path:foo into the first executable in the path named foo, not just
-    the first file
- -- Changed RUN-PROGRAM to only try to run executables, and to flame out if it
-    can't be found in path:.
- -- Profile: use &more instead of &rest to avoid consing the &rest arg list.
-    Fixed PROFILE:REPORT-TIME to not choke if any of the function names are
-    not symbols (e.g. setf functions).
-
-[NOTE: Motif server doesn't work on HP yet.]
 Motif interface:
- -- Added an optional STYLE arg to the graphical inspector to make the
-    function consistent with its doc string (as well as the old inspector).
- -- Tried to make starting the Motif server more robust, or at least give some
-    intelligible error message.
- -- Added some extra protection against recursive invocation of the windowing
-    debugger.
- -- Don't try to invoke motif debugger if we didn't succeed in opening a
-    connection. 
+ -- Fixed a bug in the generation of Interface.h which was preventing motifd 
+    from being successfully compiled on HP/Ux, Solaris, ...
+ -- use pcl::precompile-random-code-segments to minimize run-time compilations.
+ -- Add INVOKE-TTY-DEBUGGER.  Don't try to invoke motif debugger if we didn't
+    succeed in opening a connection.
  -- Print warning in status hook when server dies.
- -- Made server fflush after all output so that we see output when it is run
-    on a pipe.
+ -- Made server to fflush after all output so that we see motifd output
+    when it is run on a pipe.
+ -- Fixed severely broken INSPECT-CLOS-PANE according to patch from Marco
+    Antoniotti. 
+ -- Fix from Marco Antoniotti to actually remove handlers from the table in
+    remove-event-handler.
+ -- Fix to TOOLKIT-WRITE-VALUE to allow it to write either signed or unsigned
+    word integers.
+ -- Improved error recovery and internal error reporting.
+
+PCL:
+ -- Structure-object is now no longer shadowed in PCL.  Code that was using
+    PCL::STRUCTURE-OBJECT will now work better.
+ -- BUILT-IN-CLASS, CLASS-NAME, CLASS-OF and FIND-CLASS are once again exported
+    from PCL.  This will cause a name conflict if anyone use-package's PCL, but
+    this will at least warn about the distinction.  Probably you shouldn't
+    USE-PACKAGE PCL for this reason, but you can now say PCL:FIND-CLASS instead
+    of PCL::FIND-CLASS.  It is also possible to use SHADOW or SHADOWING-IMPORT
+    to resolve the conflict.
+ -- Fix to update-instance-for-different-class.
+ -- When updating arg-info slots, check to see if the value is already there.
+    This can reduce non-shared pages.
+ -- Improved handling of invalid structure instances.
+ -- Fix a problem with PCL clobbering byte functions when setting their names.
+ -- New parameterized version of use-dispatch-dfun-p which avoids pessimizing
+    GFs with many methods.
+ -- Fix to :after methods on accessor functions.  Also, fixed some problems
+    with the result of get-secondary-dispatch-function1 when there are no
+    methods.
+ -- Add compiler-macro for pcl:find-class which does lookup at load-time
+    when the name is a constant.
+ -- Definitive tweak for handling function-p in
+    compute-secondary-dispatch-function1 which avoids an infinite recursion. 
+ -- When signalling an incompatible superclass error, added a hint to the
+    message to check out VALIDATE-SUPERCLASSES.
+
+Lisp code:
+ -- Fixed Sparc GC bug fix (L2 never scavenged.)
+ -- On all non-Mach platforms, changed the default for CMUCLLIB to be
+    /usr/local/lib/cmucl/lib.
+ -- On SunOS, added "dynamic segments" patch which prevents the "out of
+    segments" errors that could happen when a Lisp memory management table
+    overflowed.
+
+Build tools:
+ -- Fix compilation of motif interface to actually generate the C header files
+    Interface.h, etc.
+ -- Some changes to reduce compiler warnings
+ -- In compile-all, -clean and -noupdate have been flushed.  -clean is now
+    done by the clean-build script. 
+ -- Add some scripts from David Axmark that automate the entire build process:
+	tools/variant-lisp
+	tools/build-and-install
 
-Hemlock:
- -- Add window-buffer-hook for echo area buffer to make absolutely sure we
-    can't change the eacho area window to point to another buffer.
- -- Give a sensible error message if we can't find the slave utility (e.g.
-    lisp) to run.
- -- Restored the behavior of scribe-file to cd to the directory of the .mss
-    file before running scribe.
- -- Change default fonts to be courier, flushing all mention of 8x13.
-    Remove font-setting in default site-init file, since it was causing
-    problems.
- -- Add FILE-POSITION method for region streams so that the compiler's read
-    error recovery works for "Editor Compile Defun", etc.
- -- When reading a file, set BUFFER-WRITABLE to T before doing anything so
-    that we don't get spurious read-only errors.
+________________________________________________________________
 
+ CMUCL(1)                                                           CMUCL(1)
+                              October 15, 1991
+
+
+
+ NAME
+      CMU Common Lisp
+
+
+ DESCRIPTION
+      CMU Common Lisp is public domain "industrial strength" Common Lisp
+      programming environment.  Many of the X3j13 changes have been
+      incorporated into CMU CL.  Wherever possible, this has been done so as
+      to transparently allow use of either CLtL1 or proposed ANSI CL.
+      Probably the new features most interesting to users are SETF
+      functions, LOOP and the WITH-COMPILATION-UNIT macro.
+
+
+ HARDWARE REQUIREMENTS
+      CMU CL is currently available for a variety of Unix workstations.  See
+      the README file for current platforms.  At least 16 megabytes of
+      memory and 25 megabytes of disk space are recommended.  As usual, more
+      is better.
+
+
+ OVERVIEW
+      When compared other Common Lisp implementations, CMU CL has two broad
+      advantages:
+
+      -- The new CMU CL compiler (Python) is more sophisticated than other
+         Common Lisp compilers.  It both produces better code and is easier
+         to use.
+
+      -- The programming environment based on the Hemlock editor is better
+         integrated than gnu-emacs based environments.  (Though you can
+         still use GNU if you want.)
+
+      CMU CL also has significant non-technical advantages:
+
+      -- It has good local support for CMU users, and is well integrated
+         with the CMU CS environment.
+
+      -- It is public domain, and is freely available to non-CMU sites that
+         aren't able to afford a site-license for a commercial Lisp.
+
+
+
+ COMPILER FEATURES
+      The `Advanced Compiler' chapter of the User's manual extensively
+      discusses Python's optimization capabilities (See DOCUMENTATION
+      below.)  Here are a few high points:
+
+      -- Good efficiency and type-checking at the same time. Compiling code
+         safe gives a 2x speed reduction at worst.
+
+      -- In safe code, type declarations are verified, allowing declarations
+         to be debugged in safe code.  When you go to compile unsafe, you
+         know the declarations are right.
+
+      -- Full source level debugging of compiled code, including display of
+         the exact call that got an error.
+
+      -- Good efficiency notes that tell you why an operation can't be open
+         coded or where you are number-consing, and that provide
+         unprecedented source context
+
+      -- Block compilation, partial evaluation, lightweight functions and
+         proper tail-recursion allow low-cost use of function call
+         abstraction.
+
+ TYPE SUPPORT
+      Important note: Even debugged programs may contain type errors that
+      remain undetected by other compilers.  When compiled with type
+      checking suppressed using the CMU Common Lisp compiler, these type
+      errors may cause said debugged programs to die strangely.  If type
+      checking is not suppressed, these programs will die with an explicit
+      type error.
+
+      The most visible way in which Python differs from previous Common Lisp
+      compilers is that it has a greater knowledge about types and a
+      different approach to type checking.  In particular, Python implements
+      type checking which is `eager' and `precise':
+
+      -- Eager in the sense that type checking is done immediately whenever
+         there is a declaration, rather than being delayed until the the
+         value is actually used.  For example:
+             (let ((x ...))
+               (declare (fixnum x))
+               ...)
+         Here, the type of the initial value of X must be a FIXNUM or an
+         error will be signalled.
+
+      -- Precise in the sense that the exact type specified is checked.  For
+         example, if a variable is declared to be of type (integer 3 7),
+         then the value must always be an integer between 3 and 7.
+
+      Since Python does more type checking, programs that work fine when
+      compiled with other compilers may get type errors when compiled with
+      Python.  It is important to initially compile programs with the
+      default (safe) policy, and then test this version.  If a program with
+      an erroneous declaration is compiled with type checking suppressed
+      (due to the SAFETY optimize quality being reduced), then the type
+      error may cause obscure errors or infinite looping.  See the section
+      `Getting Existing Programs to Run' (6.6) in the compiler chapter of
+      the user manual.
+
+      CMU CL adheres to the X3J13 function type cleanup, which means that
+      quoted lambda-lists are not of type FUNCTION, and are no longer
+      directly callable.  Use COERCE with the FUNCTION result type.
+
+
+ OPTIMIZATION
+      Python does many optimizations that are absent or less general in
+      other Common Lisp compilers: Proper tail recursion, lightweight
+      function call, block compilation, inter-procedural type inference,
+      global flow analysis, dynamic type inference, global register
+      allocation, stack number allocation, control optimization, integer
+      range analysis, enhanced inline expansion, multiple value optimization
+      and source-to-source transforms.
+
+      Optimization and type-checking are controlled by the OPTIMIZE
+      declaration.  The default compilation policy is type-safe.
 
-________________________________________________________________
 
-Sun Release 4.1                                                 1
+ NUMERIC SUPPORT
+      Python is particular good at number crunching:
 
-CMUCL(1)                 USER COMMANDS                   CMUCL(1)
+      -- Good inline coding of float and 32 bit integer operations, with no
+         number consing.  This includes all the hardware primitives ROUND,
+         TRUNCATE, COERCE, as well as important library routines such as
+         SCALE-FLOAT and DECODE-FLOAT.  Results that don't fit in registers
+         go on a special number stack.
 
+      -- Full support for IEEE single and double (denorms, +-0, etc.)
 
+      -- In block compiled code, numbers are passed as function arguments
+         and return values in registers (and without number consing.)
 
-NAME
-     CMU Common Lisp
+      -- Calls to library functions (SIN, ...) are optimized to a direct
+         call to the C library routine (with no number consing.)  On
+         hardware with direct support for such functions, these operations
+         can easily be open-coded.
 
+      --  Substantially better bignum performance than commercial
+         implementations (2x-4x).  Bignums implemented in lisp using word
+         integers, so you can roll your own.
 
-DESCRIPTION
-     CMU Common Lisp is public domain "industrial strength"  Com-
-     mon Lisp programming environment.  Many of the X3j13 changes
-     have been incorporated into CMU CL.  Wherever possible, this
-     has  been  done  so  as to transparently allow use of either
-     CLtL1 or proposed ANSI CL.  Probably the new  features  most
-     interesting  to users are SETF functions, LOOP and the WITH-
-     COMPILATION-UNIT macro.
+      Python's compiler warnings and efficiency notes are especially
+      valuable in numeric code.  50+ pages in the user manual describe
+      Python's capabilities in more detail.
 
 
-HARDWARE REQUIREMENTS
-     CMU CL is currently available for Sparcstations and  DECsta-
-     tions (pmaxes) running Mach (or OSF/1).  We are beta-testing
-     a SunOS SPARC version and an IBM RT Mach version.  At  least
-     16  megabytes  of  memory and 25 megabytes of disk space are
-     recommended.  As usual, more is better.
+
+ THE DEBUGGER
+      In addition to a Motif-based windowing interface and a basic command-
+      line interface, the debugger also has several powerful new features:
+      -- The "source" and "vsource" commands print the *precise* original
+         source form responsible for the error or pending function call.  It
+         is no longer necessary to guess which call to CAR caused some "not
+         a list" error.
+
+      -- Variables in compiled code can be accessed by name, so the debugger
+         always evaluates forms in the lexical environment of the current
+         frame.  This variable access is robust in the presence of compiler
+         optimization --- although higher levels of optimization may make
+         variable values unavailable at some locations in the variable's
+         scope, the debugger always errs on the side of discretion, refusing
+         to display possibly incorrect values.
+
+      -- Compiled code can be stepped, stopping at each control transfer.
+
+      -- Integration with the Hemlock editor.  In a slave, the "edit"
+         command causes the editor edit the source for the current code
+         location.  The editor can also send non-line-mode input to the
+         debugger using C-M-H bindings.  Try apropos "debug" in Hemlock.
+
+      See the debugger chapter in the user manual for more details.  We are
+      working on integrating the debugger with Hemlock and X windows.
+
+
+ THE GRAPHICAL INTERFACE
+      CMU Common Lisp has an interface to Motif which is functionally
+      similar to CLM, but works better in CMU CL.  See:
+
+
+            doc/motif-toolkit.doc
+            doc/motif-internals.doc
+
+      This motif interface has been used to write the inspector and
+      graphical debugger.  There is also a Lisp control panel with a simple
+      file management facility, apropos and inspector dialogs, and controls
+      for setting global options.
+
+      Call INTERFACE:LISP-CONTROL-PANEL to create the control panel.  When
+      INTERFACE:*INTERFACE-STYLE* is :GRAPHICS (the default) and the DISPLAY
+      environment variable is defined, the graphical inspector and debugger
+      will be invoked by INSPECT or when an error is signalled.  Possible
+      values are :GRAPHICS and :TTY.  If the value is :GRAPHICS, but there
+      is no X display, then we quietly use the TTY interface.
 
 
-OVERVIEW
-     When compared other Common Lisp implementations, CMU CL  has
-     two broad advantages:
+ DOCUMENTATION
+      The CMU CL documentation is printed as tech reports, and is available
+      (at CMU) in the document room:
 
-     -- The new CMU CL compiler (Python)  is  more  sophisticated
-        than  other  Common  Lisp  compilers.   It  both produces
-        better code and is easier to use.
 
-     -- The programming environment based on the  Hemlock  editor
-        is  better  integrated than gnu-emacs based environments.
-        (Though you can still use GNU if you want.)
+        CMU Common Lisp User's Manual
+        Hemlock User's Manual
+        Hemlock Command Implementor's Manual
 
-     CMU CL also has significant non-technical advantages:
+      Non-CMU users may get documentation from the doc/ directory in the
+      binary distribution:
 
-     -- It has good local support for  CMU  users,  and  is  well
-        integrated with the CMU CS environment.
+      cmu-user.info
+                CMU CL User's Manual in Gnu Info format.  The ``cmu-
+                user.info-<N>'' files are subfiles.  You can either have
+                your EMACS maintainer install this in the info root, or you
+                can use the info ``g(...whatever.../doc/cmu-user.info)''
+                command.
 
-     -- It is public domain, and is freely available  to  non-CMU
-        sites  that  aren't  able  to afford a site-license for a
-        commercial Lisp.
+      cmu-user.ps
+                The CMU CL User's Manual (148 pages) in postscript format.
+                LaTeX source and DVI versions are also available.
 
+      release-notes.txt
+                Information on the changes between releases.
 
+      hemlock-user.ps
+                Postscript version of the Hemlock User's Manual (124 pages.)
 
-COMPILER FEATURES
-     The `Advanced Compiler' chapter of the User's manual  exten-
-     sively  discusses  Python's  optimization  capabilities (See
-     DOCUMENTATION below.)  Here are a few high points:
+      hemlock-cim.ps
+                Postscript version of the Hemlock Command Implementor's
+                Manual (96 pages).
 
-     -- Good efficiency and type-checking at the same time.  Com-
-        piling code safe gives a 2x speed reduction at worst.
 
-     -- In safe code, type declarations  are  verified,  allowing
-        declarations to be debugged in safe code.  When you go to
-        compile unsafe, you know the declarations are right.
+ SUPPORT
+      Bug reports should be sent to cmucl-bugs@cs.cmu.edu.  Please consult
+      your local CMU CL maintainer or Common Lisp expert to verify that the
+      problem really is a bug before sending to this list.
 
-     -- Full source level debugging of compiled  code,  including
-        display of the exact call that got an error.
+      The CMU Common Lisp project is no longer funded, so only minimal
+      support is being done at CMU.  There is a net community of who
+      communicate via comp.lang.lisp and the cmucl-bugs@cs.cmu.edu mailing
+      list.
 
-     -- Good efficiency notes that  tell  you  why  an  operation
-        can't  be open coded or where you are number-consing, and
-        that provide unprecedented source context
 
-     -- Block compilation, partial evaluation, lightweight  func-
-        tions  and  proper  tail-recursion  allow low-cost use of
-        function call abstraction.
+ DISTRIBUTION
+      CMU Common Lisp is a public domain implementation of Common Lisp.
+      Both sources and executables are freely available via anonymous FTP;
+      this software is "as is", and has no warranty of any kind.  CMU and
+      the authors assume no responsibility for the consequences of any use
+      of this software.  See the README file in the distribution for FTP
+      instructions.
+
+
+ ABOUT THE CMU COMMON LISP PROJECT
+      Organizationally, CMU Common Lisp was a small, mostly autonomous part
+      within the Mach operating system project.  The CMU CL project was more
+      of a tool development effort than a research project.  The project
+      started out as Spice Lisp, which provided a modern Lisp implementation
+      for use in the CMU community.  CMU CL has been under continuous
+      development since the early 1980's (concurrent with the Common Lisp
+      standardization effort.)  Most of the CMU Common Lisp implementors are
+      now working on the Gwydion environment for Dylan (see
+      http://legend.gwydion.cs.cmu.edu:8001/gwydion/.)
 
-TYPE SUPPORT
-     Important note: Even  debugged  programs  may  contain  type
-     errors that remain undetected by other compilers.  When com-
-     piled with type checking suppressed  using  the  CMU  Common
-     Lisp  compiler,  these  type  errors may cause said debugged
-     programs  to  die  strangely.   If  type  checking  is   not
-     suppressed,  these  programs  will die with an explicit type
-     error.
+      CMU CL was funded by DARPA under CMU's "Research on Parallel
+      Computing" contract.  Rather than doing pure research on programming
+      languages and environments, the emphasis was on developing practical
+      programming tools.  Sometimes this required new technology, but much
+      of the work was in creating a Common Lisp environment that
+      incorporates state-of-the-art features from existing systems (both
+      Lisp and non-Lisp.)
 
-     The most visible way in which Python differs  from  previous
-     Common  Lisp  compilers  is  that it has a greater knowledge
-     about types and a different approach to type  checking.   In
-     particular, Python implements type checking which is `eager'
-     and `precise':
+      Because sources are freely available, CMU Common Lisp has been ported
+      to experimental hardware, and used as a basis for research in
+      programming language and environment construction.
 
-     -- Eager in the sense that type checking is done immediately
-        whenever  there  is  a  declaration,  rather  than  being
-        delayed until the the value is actually used.  For  exam-
-        ple:
-            (let ((x ...))
-              (declare (fixnum x))
-              ...)
-        Here, the type of the initial value of X must be a FIXNUM
-        or an error will be signalled.
 
-     -- Precise in the sense that the  exact  type  specified  is
-        checked.  For example, if a variable is declared to be of
-        type (integer 3 7), then the  value  must  always  be  an
-        integer between 3 and 7.
-
-     Since Python does more type  checking,  programs  that  work
-     fine  when compiled with other compilers may get type errors
-     when compiled with Python.  It  is  important  to  initially
-     compile  programs  with  the default (safe) policy, and then
-     test this version.  If a program with an erroneous  declara-
-     tion  is  compiled with type checking suppressed (due to the
-     SAFETY optimize quality being reduced), then the type  error
-     may  cause obscure errors or infinite looping.  See the sec-
-     tion `Getting Existing Programs to Run' (6.6)  in  the  com-
-     piler chapter of the user manual.
-
-     CMU CL adheres to the X3J13  function  type  cleanup,  which
-     means that quoted lambda-lists are not of type FUNCTION, and
-     are no longer directly callable.  Use COERCE with the  FUNC-
-     TION result type.
-
-
-OPTIMIZATION
-     Python does many optimizations that are absent or less  gen-
-     eral  in other Common Lisp compilers: Proper tail recursion,
-     lightweight  function  call,   block   compilation,   inter-
-     procedural  type  inference,  global  flow analysis, dynamic
-     type inference, global  register  allocation,  stack  number
-     allocation,  control  optimization,  integer range analysis,
-     enhanced inline expansion, multiple value  optimization  and
-     source-to-source transforms.
-
-     Optimization and type-checking are controlled by the  OPTIM-
-     IZE  declaration.   The  default compilation policy is type-
-     safe.
-
-
-NUMERIC SUPPORT
-     Python is particular good at number crunching:
-
-     -- Good inline coding of float and  32  bit  integer  opera-
-        tions,  with  no  number  consing.  This includes all the
-        hardware primitives ROUND, TRUNCATE, COERCE, as  well  as
-        important   library  routines  such  as  SCALE-FLOAT  and
-        DECODE-FLOAT.  Results that don't fit in registers go  on
-        a special number stack.
-
-     -- Full support for IEEE single and  double  (denorms,  +-0,
-        etc.)
-
-     -- In block compiled code, numbers are  passed  as  function
-        arguments  and  return  values  in registers (and without
-        number consing.)
-
-     -- Calls to library functions (SIN, ...) are optimized to  a
-        direct  call  to  the  C  library routine (with no number
-        consing.)  On hardware with direct support for such func-
-        tions, these operations can easily be open-coded.
-
-     --  Substantially better bignum performance than  commercial
-        implementations  (2x-4x).   Bignums  implemented  in lisp
-        using word integers, so you can roll your own.
-
-     Python's compiler warnings and efficiency  notes  are  espe-
-     cially  valuable  in  numeric  code.   50+ pages in the user
-     manual describe Python's capabilities in more detail.
-
-
-
-THE DEBUGGER
-     In addition to a basic command-line interface, the  debugger
-     also has several powerful new features:
-
-     -- The "source" and "vsource" commands print  the  *precise*
-        original source form responsible for the error or pending
-        function call.  It is no longer necessary to guess  which
-        call to CAR caused some "not a list" error.
-
-     -- Variables in compiled code can be accessed  by  name,  so
-        the  debugger  always  evaluates  forms  in  the  lexical
-        environment of the current frame.  This  variable  access
-        is  robust  in  the presence of compiler optimization ---
-        although higher levels of optimization may make  variable
-        values  unavailable  at  some locations in the variable's
-        scope, the debugger always errs on the  side  of  discre-
-        tion, refusing to display possibly incorrect values.
-
-     -- Integration with the Hemlock editor.   In  a  slave,  the
-        "edit"  command causes the editor edit the source for the
-        current code location.  The editor  can  also  send  non-
-        line-mode  input  to  the  debugger using C-M-H bindings.
-        Try apropos "debug" in Hemlock.
-
-     See the  debugger  chapter  in  the  user  manual  for  more
-     details.   We  are  working on integrating the debugger with
-     Hemlock and X windows.
-
-
-THE INTERPRETER
-     As far as Common Lisp semantics are concerned, there  is  no
-     interpreter;  this is effectively a compile-only implementa-
-     tion.  Forms typed to the read-eval-print loop or passed  to
-     EVAL  are in effect compiled before being run.  In implemen-
-     tation, there is an interpreter,  but  it  operates  on  the
-     internal representation produced by the compiler's font-end.
-
-     It is not recommended that programs be debugged  by  running
-     the whole program interpreted, since Python and the debugger
-     eliminate the main reasons for debugging  using  the  inter-
-     preter:
-
-     -- Compiled code does much more error checking  than  inter-
-        preted code.
-
-     -- It is as easy to debug compiled code as interpreted code.
-
-     Note that the debugger does not  currently  support  single-
-     stepping.  Also, the interpreter's pre-processing freezes in
-     the macro definitions in effect at the time  an  interpreted
-     function  is  defined.   Until we implement automatic repro-
-     cessing when macros are redefined, it is  necessary  to  re-
-     evaluate  the definition of an interpreted function to cause
-     new macro definitions to be noticed.
-
-
-DOCUMENTATION
-     The CMU CL documentation is printed as tech reports, and  is
-     available (at CMU) in the document room:
-
-
-       CMU Common Lisp User's Manual
-       Hemlock User's Manual
-       Hemlock Command Implementor's Manual
-
-     Non-CMU users may get documentation from the doc/  directory
-     in the binary distribution:
-
-     cmu-user.info
-               CMU CL User's Manual  in  Gnu  Info  format.   The
-               ``cmu-user.info-<N>'' files are subfiles.  You can
-               either have your EMACS maintainer install this  in
-               the   info   root,   or   you  can  use  the  info
-               ``g(...whatever.../doc/cmu-user.info)'' command.
-
-     cmu-user.ps
-               The CMU CL User's Manual (148 pages) in postscript
-               format.   LaTeX  source  and DVI versions are also
-               available.
-
-     release-notes.txt
-               Information on the changes between releases.
-
-     hemlock-user.ps
-               Postscript version of the  Hemlock  User's  Manual
-               (124 pages.)
-
-     hemlock-cim.ps
-               Postscript  version   of   the   Hemlock   Command
-               Implementor's Manual (96 pages).
-
-SUPPORT
-     Bug reports should be sent to cmucl-bugs@cs.cmu.edu.  Please
-     consult  your  local CMU CL maintainer or Common Lisp expert
-     to verify that the problem really is a bug before sending to
-     this list.
-
-     We have insufficient staffing to provide  extensive  support
-     to people outside of CMU.  We are looking for university and
-     industrial affiliates to help us with  porting  and  mainte-
-     nance  for  hardware and software that is not widely used at
-     CMU.
-
-
-DISTRIBUTION
-     CMU Common Lisp is a public domain implementation of  Common
-     Lisp.  Both sources and executables are freely available via
-     anonymous FTP; this software is "as is", and has no warranty
-     of  any  kind.  CMU and the authors assume no responsibility
-     for the consequences of any use of this software.   See  the
-     README file in the distribution for FTP instructions.
-
-
-ABOUT THE CMU COMMON LISP PROJECT
-     Organizationally, CMU Common Lisp is a small,  mostly  auto-
-     nomous  part  within the Mach operating system project.  CMU
-     CL is more of a tool development effort than a research pro-
-     ject.  The project started out as Spice Lisp, which provided
-     a modern Lisp implementation for use in the  CMU  community.
-     CMU CL has been under continuous development since the early
-     1980's (concurrent  with  the  Common  Lisp  standardization
-     effort.)
-
-     CMU CL is funded by DARPA under CMU's "Research on  Parallel
-     Computing"  contract.   Rather  than  doing pure research on
-     programming languages and  environments,  our  emphasis  has
-     been  on  developing practical programming tools.  Sometimes
-     this has required new technology, but much of the  work  has
-     been in creating a Common Lisp environment that incorporates
-     state-of-the-art features from existing systems  (both  Lisp
-     and non-Lisp.)
-
-     Because sources are freely available, CMU  Common  Lisp  has
-     been  ported  to  experimental hardware, and used as a basis
-     for research in programming language  and  environment  con-
-     struction.
-
-
-SEE ALSO
-     lisp(1), README
-     The ``CMU Common Lisp User's Manual'',
-     the ``Hemlock User's Manual'', and
-     the ``Hemlock Command Implementor's Manual''
+ SEE ALSO
+      lisp(1), README
+      The ``CMU Common Lisp User's Manual'',
+      the ``Hemlock User's Manual'', and
+      the ``Hemlock Command Implementor's Manual''
-- 
GitLab