/[cmucl]/src/general-info/net-announce.txt
ViewVC logotype

Diff of /src/general-info/net-announce.txt

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2 by ram, Fri Mar 11 14:57:43 1994 UTC revision 1.3 by ram, Fri Nov 4 07:10:59 1994 UTC
# Line 1  Line 1 
1              Release notes for CMU Common Lisp 17e, 11 March 94              Release notes for CMU Common Lisp 17f, ?? November 94
2    
3  17e is primarily a bug-fix release.  This release is also available on  17f contains bug fixes, PCL enhancements, and support for three new platforms:
4  Hewlett-Packard 700-series workstations running HP/UX version 9.x.  The main      Sun SPARC/Solaris
5  missing features on HP/UX are LOAD-FOREIGN and the Motif interface.      SGI MIPS/Iris (no load-foreign)
6        DEC Alpha/OSF1 (no Motif or load-foreign)
7    
8    The HPPA/HPux and Sun/Sunos 4.x platforms are still available.  Distributions
9    are now gzip'd, not compressed.
10    
11    Other highlights: Motif, load-foreign on Hp/Ux, image size improvements, MIT
12    loop, some documentation of some previously undocumented features.
13    
14    NOTE:
15    
16    Although the group lives on (and is working on Dylan/Gwydion), the CMU Common
17    Lisp project is no longer funded, so only minimal CL support is being done at
18    CMU.  There is a net community of CMU Common Lisp users and maintainers who
19    communicate via comp.lang.lisp and the cmucl-bugs@cs.cmu.edu mailing list.
20    This release contains patches from the net (including the major Solaris effort
21    by Caspar Dik), and also some things that were "in the pipe" (the Alpha and
22    Irixs ports.)  None of these ports has been extensively tested, and there are
23    missing parts.  As always, you get what you pay for.
24    
25  Distribution:  Distribution:
26    
# Line 13  manpower to make tapes.  These are our d Line 31  manpower to make tapes.  These are our d
31      lisp-rt2.slisp.cs.cmu.edu (128.2.217.10)      lisp-rt2.slisp.cs.cmu.edu (128.2.217.10)
32    
33  Log in with the user "anonymous" and "username@host" as password (i.e. your  Log in with the user "anonymous" and "username@host" as password (i.e. your
34  EMAIL address.)  When you log in, cd to /pub (a symbolic link to the CMU CL  EMAIL address.)  When you log in, cd USING ONE SINGLE "cd" COMMAND to
35  release area.)  If you have any trouble with FTP access, please send mail to  /afs/cs/project/clisp/release.  If you have any trouble with FTP access,
36  slisp@cs.cmu.edu.  please send mail to slisp@cs.cmu.edu.
37    
38  The most recent version is: 17e  The most recent version is: 17f
39  The old version is: 16f  The old version is: 16f
40    
41  The currently supported platforms are:  The currently supported platforms are:
42      sunos:      alpha_osf1:
43          Sun SPARC machines running the the pre-Solaris BSD SunOS system,          DEC Alpha workstations running OSF1.
         version 4.x.  
44    
45      hp700_ux90:      hp700_ux90:
46          HP 700 series machines (based on the HPPA architecture) running HP/UX          HP 700 series machines (based on the HPPA architecture) running HP/UX
47          9.x.          9.x.
48    
49  The release area holds compressed tar files with names of the form:      sgi_52:
50      <version>-<platform>.tar.Z          MIPS-based SGI workstations running Irix 5.x.
51      <version>-extra-<platform>.tar.Z  
52      <version>-runtime-<platform>.tar.Z      sun4c_411:
53            Sun SPARC machines running the the pre-Solaris BSD SunOS system,
54            version 4.x.
55    
56        sun4c_53:
57            Sun SPARC machines running Solaris/SunOS 5.x.
58    
59    
60    The release area holds gzip'ed tar files with names of the form:
61        <version>-<platform>.tar.gz
62        <version>-extra-<platform>.tar.gz
63        <version>-runtime-<platform>.tar.gz
64    
65   -- The first file holds binaries and documentation for the standard Common   -- The first file holds binaries and documentation for the standard Common
66      Lisp portion of CMU CL.  This includes our version of the PCL      Lisp portion of CMU CL.  This includes our version of the PCL
# Line 43  The release area holds compressed tar fi Line 71  The release area holds compressed tar fi
71      smaller substitute for lib/lisp.core.  See the "runtime distribution"      smaller substitute for lib/lisp.core.  See the "runtime distribution"
72      section.      section.
73    
74  The sizes of the configurations are approximately:  
75    The installed sizes of the configurations are approximately:
76      Basic: 15 megabytes      Basic: 15 megabytes
77      Basic+Extra: 24 megabytes      Basic+Extra: 24 megabytes
78      Runtime: 5.3 megabytes      Runtime: 5.3 megabytes
79    
80  For installation directions, see the section "site initialization".  For installation directions, see the section "site initialization".
81    
82  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
83  directory that is to be the root of the tree, then type:  directory that is to be the root of the tree, then type:
84      uncompress <file.tar.Z | tar xf - .      gzcat file.tar.gz | tar xf - .
85    
86  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
87  release is also available split into 2 megabyte chunks, suffixed `.0', `.1',  release is also available split into 2 megabyte chunks, suffixed `.0', `.1',
88  etc.  To extract from multiple files, use:  etc.  To extract from multiple files, use:
89      cat file.tar.Z.* | uncompress | tar xf - .      cat file.tar.gz.* | gunzip | tar xf - .
90    
91  The release area also contains source distributions and other binary  The release area also contains source distributions and other binary
92  distributions.  A listing of the current contents of the release area is in  distributions.  A listing of the current contents of the release area is in
93  FILES.  Major release announcements will be made to comp.lang.lisp.  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  
94    
 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 - .  
95    
96  Source availability:  Source availability:
97    
# Line 91  freely distributed without any licensing Line 103  freely distributed without any licensing
103    
104  The release area contains a source distribution, which is an image of all the  The release area contains a source distribution, which is an image of all the
105  source code files used to build the current version:  source code files used to build the current version:
106      <version>-source.tar.Z (5 meg)      <version>-source.tar.gz (5 meg)
107    
108  ________________________________________________________________  ________________________________________________________________
109    
110                              DETAILED RELEASE NOTES                              DETAILED RELEASE NOTES
111    
112  [Notes are also in doc/release-notes.txt]  [Notes are also in doc/release-notes.txt]
113    [Also see the README file for platform-specific notes.]
114    
115  BASIC COMMON LISP SUPPORT CODE:  Bug fixes to basic CL support:
116     -- Fixed ADJUST-ARRAY to not flame out on arrays containing a zero-length
117  Enhancements:      dimension (hence having no elements whatsoever.)
  -- 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:  
118   -- In SIGNAL, bind *break-on-signals* to NIL even before doing the type test   -- In SIGNAL, bind *break-on-signals* to NIL even before doing the type test
119      so that we don't wedge the error system if the type is malformed or      so that we don't wedge the error system if the type is malformed or
120      undefined.      undefined.
121   -- Fix arg ordering for GETF in new condition support.  Default the name   -- Fixed bugs with EOF handling in READ-LINE.
122      slot in DEFMACRO-LAMBDA-LIST-BIND-ERRORS to NIL (instead of leaving it   -- In DEFINE-CONDITION, don't warn about probable error unless both initarg
123      unbound.)      and initform are missing.
124   -- In READ-N-BYTES, only signal EOF when we read and got 0 bytes, not   -- In OPEN, fixed :direction :io :if-does-not-exist :create to actually
125      whenever read returns less than we wanted.  Also, fix the case of small      create.
126      reads with an empty buffer not to leave garbled buffer pointers if we have   -- Fix problem in LOAD-FOREIGN where (especially on SunOS), the failure to
127      to do more than one read.  These bugs mostly affect the X interface and      page-align loaded code caused errors when load-foreign was done more than
128      its users (Garnet was having problems.)      once.
129   -- Changed YES-OR-NO-P and Y-OR-N-P to force output.   -- In OUTPUT-INSTANCE, check for the layout being invalid before calling the
130   -- Fixed COUNT :TEST-NOT to actually negate the test.      print function, since the print function might error.
131   -- Fixed COERCE to call type-expand so that people can coerce to deftypes.   -- Closing composite streams (broadcast, etc.) no longer closes the component
132   -- Rename STEP to DEBUG::SET-STEP-BREAKPOINT because step is supposed to be      streams.
133      the exported step macro, not some internal routine.   -- Fixed pprint goof that didn't actually break anything, but wasted effort.
134   -- Fixed DEFPACKAGE to combine multiple use, export, and import options   -- (COERCE x 'FLOAT) now convert to a single-float (instead of being an
135      correctly.  Fixed the warning about no longer using some packages to      error.)  Also, we now check that numeric coercions actually return a value
136      actually work.      of the specified type (which they might not if the type is not a symbol,
137   -- Fixed GCD to correctly handle MOST-NEGATIVE-FIXNUM.      e.g. (coerce 0 '(complex float)).  Possibly these should "do the right
138   -- Flush Hemlock font change hack in default site-init.lisp, since it was      thing", but it seems better to error than quietly do the wrong thing.
139      causing problems.   -- Fixed a bug in FLOAT-BIGNUM-RATIO that could cause an assertion failure
140        when floating particular bignum ratios (or possibly reading particular
141  CLOS (PCL):      float values.)
142   -- Add some hacks for coercing lisp:class objects to pcl:class.  
143   -- Export MAKE-LOAD-FORM-SAVING-SLOTS, not MAKE-LOAD-FORM-DUMPING-SLOTS.  Miscellaneous enhancements:
144   -- Fix some problems with the LISP:CLASS class-precedence-list suddenly   -- LOOP is now the MIT/Symblics loop, so whatever it does is by definition
145      becoming empty when a class is redefined.      correct and The Right Thing.
146   -- Fixed SIMPLE-STRING to list STRING in the inherits list.   -- PURIFY is now exported as EXT:PURIFY.  This function can greatly improve
147        the GC performance of many large programs by moving code and static data
148        into non-collected storage.  This is a "poor man's generational GC".
149        Environment compaction now done by purify.
150     -- Some reduction in the size of the image (and of GC scanned memory) from
151        tweaks to build process.
152     -- Binary input can now be done from string streams (from David Axmark.)
153     -- Debugger no longer aborts printing of a frame when printing one arg gets an
154        error (from Harris.)
155     -- LOAD-FOREIGN support for HP/Ux (from TSM.)
156     -- Add sap-ref-64 (only on Alpha).
157     -- Changes to EVAL, ROOM and site-init to work better in a runtime core image
158        (without the compiler loaded.)
159     -- *BEFORE-SAVE-INITIALIZATIONS* is now actually done before saving.
160    
161    Compiler:
162     -- Fixed some problems with multiple values and cleanup code in byte
163        compilation.  Also added EXT:*COMPILE-PROGRESS* printout.
164     -- Fixed some problems with internal errors when a function was just
165        declared to be FUNCTION.
166     -- Now allows stream args to compile-file and doesn't attempt to constant-fold
167        pathname functions (which depend on *default-pathname-defaults*.)
168     -- Fixed a case where dead local function in top-level code could cause an
169        internal error.
170     -- Fix compiler-macro expansion to correctly handle macros that pass (by
171        returning the unmodified form.)
172     -- Fix spelling of :COMPILE-TOPLEVEL and :LOAD-TOPLEVEL in EVAL-WHEN.
173     -- If compile-file is :block-compile T, the entire file is block-compiled as a
174        unit (even if it contains embedded START-BLOCK/END-BLOCK declarations.)
175     -- Virtually all of the compiler is now compiled without type checking, giving
176        some space and speed benefit.
177    
178    CLX:
179     -- Merged with CLX R5.02 (no substantive changes).
180     -- In read-resources, trim off spaces, tabs, and "'s in #include file name
181     -- If CLX is compiled when PCL is loaded (as is now done in the binary
182        distribution), DRAWABLE, WINDOW and PIXMAP will be defined as PCL classes
183        (which can be subclasses.)  This is compatible with various CLX-based
184        toolkits.
185     -- Fix some CONS declarations to be LIST because they aren't conses on the
186        last iteration (when the body isn't executed.)
187     -- Fix incorrect slot type declaration for DISPLAY-AUTHORIZATION-DATA.
188     -- Changed holding-lock not to turn off GC, which could cause event handlers
189        and other code to run for ling periods of time without garbage collecting.
190        Instead we bind all the GC hooks to (), since it was their invocation that
191        could cause bad recursive entry of CLX.
192    
193    Hemlock:
194     -- Fixed problem in Hemlock recursive error handler (hadn't been properly
195        updated for ANSI conditions.)
196     -- Add ignore handler for client-message events.
197     -- Deleted some setting of hi::*hack-hunk-replace-line* to T, since we may
198        want it explicitly disabled in the init file.
199     -- Dylan mode now infix-oriented.
200    
201    Motif interface:
202     -- Fixed a bug in the generation of Interface.h which was preventing motifd
203        from being successfully compiled on HP/Ux, Solaris, ...
204     -- use pcl::precompile-random-code-segments to minimize run-time compilations.
205     -- Add INVOKE-TTY-DEBUGGER.  Don't try to invoke motif debugger if we didn't
206        succeed in opening a connection.
207     -- Print warning in status hook when server dies.
208     -- Made server to fflush after all output so that we see motifd output
209        when it is run on a pipe.
210     -- Fixed severely broken INSPECT-CLOS-PANE according to patch from Marco
211        Antoniotti.
212     -- Fix from Marco Antoniotti to actually remove handlers from the table in
213        remove-event-handler.
214     -- Fix to TOOLKIT-WRITE-VALUE to allow it to write either signed or unsigned
215        word integers.
216     -- Improved error recovery and internal error reporting.
217    
218    PCL:
219     -- Structure-object is now no longer shadowed in PCL.  Code that was using
220        PCL::STRUCTURE-OBJECT will now work better.
221     -- BUILT-IN-CLASS, CLASS-NAME, CLASS-OF and FIND-CLASS are once again exported
222        from PCL.  This will cause a name conflict if anyone use-package's PCL, but
223        this will at least warn about the distinction.  Probably you shouldn't
224        USE-PACKAGE PCL for this reason, but you can now say PCL:FIND-CLASS instead
225        of PCL::FIND-CLASS.  It is also possible to use SHADOW or SHADOWING-IMPORT
226        to resolve the conflict.
227   -- Fix to update-instance-for-different-class.   -- Fix to update-instance-for-different-class.
228     -- When updating arg-info slots, check to see if the value is already there.
229        This can reduce non-shared pages.
230     -- Improved handling of invalid structure instances.
231     -- Fix a problem with PCL clobbering byte functions when setting their names.
232     -- New parameterized version of use-dispatch-dfun-p which avoids pessimizing
233        GFs with many methods.
234     -- Fix to :after methods on accessor functions.  Also, fixed some problems
235        with the result of get-secondary-dispatch-function1 when there are no
236        methods.
237     -- Add compiler-macro for pcl:find-class which does lookup at load-time
238        when the name is a constant.
239     -- Definitive tweak for handling function-p in
240        compute-secondary-dispatch-function1 which avoids an infinite recursion.
241     -- When signalling an incompatible superclass error, added a hint to the
242        message to check out VALIDATE-SUPERCLASSES.
243    
244    Lisp code:
245     -- Fixed Sparc GC bug fix (L2 never scavenged.)
246     -- On all non-Mach platforms, changed the default for CMUCLLIB to be
247        /usr/local/lib/cmucl/lib.
248     -- On SunOS, added "dynamic segments" patch which prevents the "out of
249        segments" errors that could happen when a Lisp memory management table
250        overflowed.
251    
252    Build tools:
253     -- Fix compilation of motif interface to actually generate the C header files
254        Interface.h, etc.
255     -- Some changes to reduce compiler warnings
256     -- In compile-all, -clean and -noupdate have been flushed.  -clean is now
257        done by the clean-build script.
258     -- Add some scripts from David Axmark that automate the entire build process:
259            tools/variant-lisp
260            tools/build-and-install
261    
262    ________________________________________________________________
263    
264  COMPILER:   CMUCL(1)                                                           CMUCL(1)
265                                  October 15, 1991
266    
 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).  
267    
 [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.  
  -- 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.  
268    
269  Hemlock:   NAME
270   -- Add window-buffer-hook for echo area buffer to make absolutely sure we        CMU Common Lisp
     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.  
271    
272    
273  ________________________________________________________________   DESCRIPTION
274          CMU Common Lisp is public domain "industrial strength" Common Lisp
275          programming environment.  Many of the X3j13 changes have been
276          incorporated into CMU CL.  Wherever possible, this has been done so as
277          to transparently allow use of either CLtL1 or proposed ANSI CL.
278          Probably the new features most interesting to users are SETF
279          functions, LOOP and the WITH-COMPILATION-UNIT macro.
280    
281    
282     HARDWARE REQUIREMENTS
283          CMU CL is currently available for a variety of Unix workstations.  See
284          the README file for current platforms.  At least 16 megabytes of
285          memory and 25 megabytes of disk space are recommended.  As usual, more
286          is better.
287    
288    
289     OVERVIEW
290          When compared other Common Lisp implementations, CMU CL has two broad
291          advantages:
292    
293          -- The new CMU CL compiler (Python) is more sophisticated than other
294             Common Lisp compilers.  It both produces better code and is easier
295             to use.
296    
297          -- The programming environment based on the Hemlock editor is better
298             integrated than gnu-emacs based environments.  (Though you can
299             still use GNU if you want.)
300    
301          CMU CL also has significant non-technical advantages:
302    
303          -- It has good local support for CMU users, and is well integrated
304             with the CMU CS environment.
305    
306          -- It is public domain, and is freely available to non-CMU sites that
307             aren't able to afford a site-license for a commercial Lisp.
308    
309    
310    
311     COMPILER FEATURES
312          The `Advanced Compiler' chapter of the User's manual extensively
313          discusses Python's optimization capabilities (See DOCUMENTATION
314          below.)  Here are a few high points:
315    
316          -- Good efficiency and type-checking at the same time. Compiling code
317             safe gives a 2x speed reduction at worst.
318    
319          -- In safe code, type declarations are verified, allowing declarations
320             to be debugged in safe code.  When you go to compile unsafe, you
321             know the declarations are right.
322    
323          -- Full source level debugging of compiled code, including display of
324             the exact call that got an error.
325    
326          -- Good efficiency notes that tell you why an operation can't be open
327             coded or where you are number-consing, and that provide
328             unprecedented source context
329    
330          -- Block compilation, partial evaluation, lightweight functions and
331             proper tail-recursion allow low-cost use of function call
332             abstraction.
333    
334     TYPE SUPPORT
335          Important note: Even debugged programs may contain type errors that
336          remain undetected by other compilers.  When compiled with type
337          checking suppressed using the CMU Common Lisp compiler, these type
338          errors may cause said debugged programs to die strangely.  If type
339          checking is not suppressed, these programs will die with an explicit
340          type error.
341    
342          The most visible way in which Python differs from previous Common Lisp
343          compilers is that it has a greater knowledge about types and a
344          different approach to type checking.  In particular, Python implements
345          type checking which is `eager' and `precise':
346    
347          -- Eager in the sense that type checking is done immediately whenever
348             there is a declaration, rather than being delayed until the the
349             value is actually used.  For example:
350                 (let ((x ...))
351                   (declare (fixnum x))
352                   ...)
353             Here, the type of the initial value of X must be a FIXNUM or an
354             error will be signalled.
355    
356          -- Precise in the sense that the exact type specified is checked.  For
357             example, if a variable is declared to be of type (integer 3 7),
358             then the value must always be an integer between 3 and 7.
359    
360          Since Python does more type checking, programs that work fine when
361          compiled with other compilers may get type errors when compiled with
362          Python.  It is important to initially compile programs with the
363          default (safe) policy, and then test this version.  If a program with
364          an erroneous declaration is compiled with type checking suppressed
365          (due to the SAFETY optimize quality being reduced), then the type
366          error may cause obscure errors or infinite looping.  See the section
367          `Getting Existing Programs to Run' (6.6) in the compiler chapter of
368          the user manual.
369    
370          CMU CL adheres to the X3J13 function type cleanup, which means that
371          quoted lambda-lists are not of type FUNCTION, and are no longer
372          directly callable.  Use COERCE with the FUNCTION result type.
373    
374    
375     OPTIMIZATION
376          Python does many optimizations that are absent or less general in
377          other Common Lisp compilers: Proper tail recursion, lightweight
378          function call, block compilation, inter-procedural type inference,
379          global flow analysis, dynamic type inference, global register
380          allocation, stack number allocation, control optimization, integer
381          range analysis, enhanced inline expansion, multiple value optimization
382          and source-to-source transforms.
383    
384          Optimization and type-checking are controlled by the OPTIMIZE
385          declaration.  The default compilation policy is type-safe.
386    
387    
388     NUMERIC SUPPORT
389          Python is particular good at number crunching:
390    
391          -- Good inline coding of float and 32 bit integer operations, with no
392             number consing.  This includes all the hardware primitives ROUND,
393             TRUNCATE, COERCE, as well as important library routines such as
394             SCALE-FLOAT and DECODE-FLOAT.  Results that don't fit in registers
395             go on a special number stack.
396    
397          -- Full support for IEEE single and double (denorms, +-0, etc.)
398    
399          -- In block compiled code, numbers are passed as function arguments
400             and return values in registers (and without number consing.)
401    
402          -- Calls to library functions (SIN, ...) are optimized to a direct
403             call to the C library routine (with no number consing.)  On
404             hardware with direct support for such functions, these operations
405             can easily be open-coded.
406    
407          --  Substantially better bignum performance than commercial
408             implementations (2x-4x).  Bignums implemented in lisp using word
409             integers, so you can roll your own.
410    
411          Python's compiler warnings and efficiency notes are especially
412          valuable in numeric code.  50+ pages in the user manual describe
413          Python's capabilities in more detail.
414    
415    
416    
417     THE DEBUGGER
418          In addition to a Motif-based windowing interface and a basic command-
419          line interface, the debugger also has several powerful new features:
420          -- The "source" and "vsource" commands print the *precise* original
421             source form responsible for the error or pending function call.  It
422             is no longer necessary to guess which call to CAR caused some "not
423             a list" error.
424    
425          -- Variables in compiled code can be accessed by name, so the debugger
426             always evaluates forms in the lexical environment of the current
427             frame.  This variable access is robust in the presence of compiler
428             optimization --- although higher levels of optimization may make
429             variable values unavailable at some locations in the variable's
430             scope, the debugger always errs on the side of discretion, refusing
431             to display possibly incorrect values.
432    
433          -- Compiled code can be stepped, stopping at each control transfer.
434    
435          -- Integration with the Hemlock editor.  In a slave, the "edit"
436             command causes the editor edit the source for the current code
437             location.  The editor can also send non-line-mode input to the
438             debugger using C-M-H bindings.  Try apropos "debug" in Hemlock.
439    
440          See the debugger chapter in the user manual for more details.  We are
441          working on integrating the debugger with Hemlock and X windows.
442    
443    
444     THE GRAPHICAL INTERFACE
445          CMU Common Lisp has an interface to Motif which is functionally
446          similar to CLM, but works better in CMU CL.  See:
447    
448    
449                doc/motif-toolkit.doc
450                doc/motif-internals.doc
451    
452          This motif interface has been used to write the inspector and
453          graphical debugger.  There is also a Lisp control panel with a simple
454          file management facility, apropos and inspector dialogs, and controls
455          for setting global options.
456    
457          Call INTERFACE:LISP-CONTROL-PANEL to create the control panel.  When
458          INTERFACE:*INTERFACE-STYLE* is :GRAPHICS (the default) and the DISPLAY
459          environment variable is defined, the graphical inspector and debugger
460          will be invoked by INSPECT or when an error is signalled.  Possible
461          values are :GRAPHICS and :TTY.  If the value is :GRAPHICS, but there
462          is no X display, then we quietly use the TTY interface.
463    
464    
465     DOCUMENTATION
466          The CMU CL documentation is printed as tech reports, and is available
467          (at CMU) in the document room:
468    
469    
470            CMU Common Lisp User's Manual
471            Hemlock User's Manual
472            Hemlock Command Implementor's Manual
473    
474          Non-CMU users may get documentation from the doc/ directory in the
475          binary distribution:
476    
477          cmu-user.info
478                    CMU CL User's Manual in Gnu Info format.  The ``cmu-
479                    user.info-<N>'' files are subfiles.  You can either have
480                    your EMACS maintainer install this in the info root, or you
481                    can use the info ``g(...whatever.../doc/cmu-user.info)''
482                    command.
483    
484          cmu-user.ps
485                    The CMU CL User's Manual (148 pages) in postscript format.
486                    LaTeX source and DVI versions are also available.
487    
488          release-notes.txt
489                    Information on the changes between releases.
490    
491          hemlock-user.ps
492                    Postscript version of the Hemlock User's Manual (124 pages.)
493    
494          hemlock-cim.ps
495                    Postscript version of the Hemlock Command Implementor's
496                    Manual (96 pages).
497    
498    
499     SUPPORT
500          Bug reports should be sent to cmucl-bugs@cs.cmu.edu.  Please consult
501          your local CMU CL maintainer or Common Lisp expert to verify that the
502          problem really is a bug before sending to this list.
503    
504          The CMU Common Lisp project is no longer funded, so only minimal
505          support is being done at CMU.  There is a net community of who
506          communicate via comp.lang.lisp and the cmucl-bugs@cs.cmu.edu mailing
507          list.
508    
509    
510  Sun Release 4.1                                                 1   DISTRIBUTION
511          CMU Common Lisp is a public domain implementation of Common Lisp.
512          Both sources and executables are freely available via anonymous FTP;
513          this software is "as is", and has no warranty of any kind.  CMU and
514          the authors assume no responsibility for the consequences of any use
515          of this software.  See the README file in the distribution for FTP
516          instructions.
517    
 CMUCL(1)                 USER COMMANDS                   CMUCL(1)  
518    
519     ABOUT THE CMU COMMON LISP PROJECT
520          Organizationally, CMU Common Lisp was a small, mostly autonomous part
521          within the Mach operating system project.  The CMU CL project was more
522          of a tool development effort than a research project.  The project
523          started out as Spice Lisp, which provided a modern Lisp implementation
524          for use in the CMU community.  CMU CL has been under continuous
525          development since the early 1980's (concurrent with the Common Lisp
526          standardization effort.)  Most of the CMU Common Lisp implementors are
527          now working on the Gwydion environment for Dylan (see
528          http://legend.gwydion.cs.cmu.edu:8001/gwydion/.)
529    
530          CMU CL was funded by DARPA under CMU's "Research on Parallel
531          Computing" contract.  Rather than doing pure research on programming
532          languages and environments, the emphasis was on developing practical
533          programming tools.  Sometimes this required new technology, but much
534          of the work was in creating a Common Lisp environment that
535          incorporates state-of-the-art features from existing systems (both
536          Lisp and non-Lisp.)
537    
538  NAME        Because sources are freely available, CMU Common Lisp has been ported
539       CMU Common Lisp        to experimental hardware, and used as a basis for research in
540          programming language and environment construction.
541    
542    
543  DESCRIPTION   SEE ALSO
544       CMU Common Lisp is public domain "industrial strength"  Com-        lisp(1), README
545       mon Lisp programming environment.  Many of the X3j13 changes        The ``CMU Common Lisp User's Manual'',
546       have been incorporated into CMU CL.  Wherever possible, this        the ``Hemlock User's Manual'', and
547       has  been  done  so  as to transparently allow use of either        the ``Hemlock Command Implementor's Manual''
      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 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.  
   
   
 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  exten-  
      sively  discusses  Python's  optimization  capabilities (See  
      DOCUMENTATION below.)  Here are a few high points:  
   
      -- 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.  
   
      -- 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  func-  
         tions  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 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.  
   
      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  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''  

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

  ViewVC Help
Powered by ViewVC 1.1.5