Chapter 1 Introduction

CMUCL is a free, high-performance implementation of the Common Lisp programming language which runs on most major Unix platforms. It mainly conforms to the ANSI Common Lisp standard. Here is a summary of its main features:

a sophisticated native-code compiler which is capable of powerful type inferences, and generates code competitive in speed with C compilers.
generational garbage collection and multiprocessing capability on the x86 ports.
a foreign function interface which allows interfacing with C code and system libraries, including shared libraries on most platforms, and direct access to Unix system calls.
support for interprocess communication and remote procedure calls.
an implementation of CLOS, the Common Lisp Object System, which includes multimethods and a metaobject protocol.
a graphical source-level debugger using a Motif interface, and a code profiler.
an interface to the X11 Window System (CLX), and a sophisticated graphical widget library (Garnet).
programmer-extensible input and output streams.
an Emacs-like editor implemented in Common Lisp.
public domain: free, with full source code and no strings attached (and no warranty). Like GNU/Linux and the *BSD operating systems, CMUCL is maintained and improved by a team of volunteers collaborating over the Internet.

This user's manual contains only implementation-specific information about CMUCL. Users will also need a separate manual describing the Common Lisp standard, for example, the Hyperspec at www.xanalys.com

In addition to the language itself, this document describes a number of useful library modules that run in CMUCL. Hemlock, an Emacs-like text editor, is included as an integral part of the CMUCL environment. Two documents describe Hemlock: the Hemlock User's Manual, and the Hemlock Command Implementor's Manual.

1.1 Distribution and Support

CMUCL is developed and maintained by a group of volunteers who collaborate over the internet. Sources and binary releases for the various supported platforms can be obtained from www.cons.org/cmucl. These pages describe how to download by FTP or CVS.

A number of mailing lists are available for users and developers; please see the web site for more information.

1.2 Command Line Options

The command line syntax and environment is described in the lisp(1) man page in the man/man1 directory of the distribution. See also cmucl(1). Currently CMUCL accepts the following switches:

-batch

specifies batch mode, where all input is directed from standard-input. An error code of 0 is returned upon encountering an EOF and 1 otherwise.

-quiet

enters quiet mode. This implies setting the variables *load-verbose*, *compile-verbose*, *compile-print*, *compile-progress*, *require-verbose* and *gc-verbose* to NIL, and disables the printing of the startup banner.

-core

requires an argument that should be the name of a core file. Rather than using the default core file, which is searched in a number of places, according to the initial value of the library: search-list, the specified core file is loaded. This switch overrides the value of the CMUCLCORE environment variable, if present.

-lib

requires an argument that should be the path to the CMUCL library directory, which is going to be used to initialize the library: search-list, among other things. This switch overrides the value of the CMUCLLIB environment variable, if present.

-dynamic-space-size

requires an argument that should be the number of megabytes (1048576 bytes) that should be allocated to the heap. If not specified, a platform-specific default is used. The actual maximum allowed heap size is platform-specific.

Currently, this option is only available for the x86 and sparc platforms.

-edit

specifies to enter Hemlock. A file to edit may be specified by placing the name of the file between the program name (usually lisp) and the first switch.

-eval

accepts one argument which should be a Lisp form to evaluate during the start up sequence. The value of the form will not be printed unless it is wrapped in a form that does output.

-hinit

accepts an argument that should be the name of the hemlock init file to load the first time the function ed is invoked. The default is to load hemlock-init.object-type, or if that does not exist, hemlock-init.lisp from the user's home directory. If the file is not in the user's home directory, the full path must be specified.

-init

accepts an argument that should be the name of an init file to load during the normal start up sequence. The default is to load init.object-type or, if that does not exist, init.lisp from the user's home directory. If the file is not in the user's home directory, the full path must be specified.

-noinit

accepts no arguments and specifies that an init file should not be loaded during the normal start up sequence. Also, this switch suppresses the loading of a hemlock init file when Hemlock is started up with the -edit switch.

-nositeinit

accepts no arguments and specifies that the site init file should not be loaded during the normal start up sequence.

-load

accepts an argument which should be the name of a file to load into Lisp before entering Lisp's read-eval-print loop.

-slave

specifies that Lisp should start up as a islave Lisp and try to connect to an editor Lisp. The name of the editor to connect to must be specified—to find the editor's name, use the Hemlock “Accept Slave Connections” command. The name for the editor Lisp is of the form:

    machine-name:socket

where machine-name is the internet host name for the machine and socket is the decimal number of the socket to connect to.

For more details on the use of the -edit and -slave switches, see the Hemlock User's Manual.

Arguments to the above switches can be specified in one of two ways: switch=value or switch<space>value. For example, to start up the saved core file mylisp.core use either of the following two commands:

   lisp -core=mylisp.core
   lisp -core mylisp.core

1.3 Credits

CMUCL was developed at the Computer Science Department of Carnegie Mellon University. The work was a small autonomous part within the Mach microkernel-based operating system project, and started more as 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. CMUCL has been under continual development since the early 1980's (concurrent with the Common Lisp standardization effort). Most of the CMU Common Lisp implementors went on to work on the Gwydion environment for Dylan. The CMU team was lead by Scott E. Fahlman, the Python compiler was written by Robert MacLachlan.

CMUCL's CLOS implementation is derived from the PCL reference implementation written at Xerox PARC:

Copyright (c) 1985, 1986, 1987, 1988, 1989, 1990 Xerox Corporation.
All rights reserved.

Use and copying of this software and preparation of derivative works based upon this software are permitted. Any distribution of this software or derivative works must comply with all applicable United States export control laws.

This software is made available AS IS, and Xerox Corporation makes no warranty about the software, its performance or its conformity to any specification.

Its implementation of the LOOP macro was derived from code from Symbolics, which was derived from code written at MIT:

Portions of LOOP are Copyright (c) 1986 by the Massachusetts Institute of Technology.
All Rights Reserved.

Permission to use, copy, modify and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the M.I.T. copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The names "M.I.T." and "Massachusetts Institute of Technology" may not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. Notice must be given in supporting documentation that copying distribution is by permission of M.I.T. M.I.T. makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty.

Portions of LOOP are Copyright (c) 1989, 1990, 1991, 1992 by Symbolics, Inc.
All Rights Reserved.

Permission to use, copy, modify and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the Symbolics copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The name "Symbolics" may not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. Notice must be given in supporting documentation that copying distribution is by permission of Symbolics. Symbolics makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty.

Symbolics, CLOE Runtime, and Minima are trademarks, and CLOE, Genera, and Zetalisp are registered trademarks of Symbolics, Inc.

The CLX code is copyrighted by Texas Instruments Incorporated:

Copyright (C) 1987 Texas Instruments Incorporated.

Permission is granted to any individual or institution to use, copy, modify, and distribute this software, provided that this complete copyright and permission notice is maintained, intact, in all copies and supporting documentation.

Texas Instruments Incorporated provides this software "as is" without express or implied warranty.

CMUCL 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). Archives of the project are available online.

The project funding stopped in 1994, so support at Carnegie Mellon University has been discontinued. All code and documentation developed at CMU was released into the public domain. The project continues as a group of users and developers collaborating over the Internet. The currently active maintainers are:

Marco Antoniotti
Martin Cracauer
Rob MacLachlan
Pierre Mai
Eric Marsden
Gerd Moellman
Tim Moore
Raymond Toy
Peter Van Eynde
Paul Werkowski

In particular, Paul Werkowski and Douglas Crosher completed the port for the x86 architecture for FreeBSD. Peter VanEnyde took the FreeBSD port and created a Linux version. Other people who have contributed to the development of CMUCL since 1981 are

David Axmark
Miles Bader
Rick Busdiecker
Bill Chiles
Douglas Thomas Crosher
Casper Dik
Ted Dunning
Scott Fahlman
Mike Garland
Paul Gleichauf
Sean Hallgren
Richard Harris
Joerg-Cyril Hoehl
Chris Hoover
John Kolojejchick
Todd Kaufmann
Simon Leinen
Sandra Loosemore
William Lott
Dave McDonald
Tim Moore
Skef Wholey

Countless others have contributed to the project by sending in bug reports, bug fixes, new features.

This manual is based on CMU Technical Report CMU-CS-92-161, edited by Robert A. MacLachlan, dated July 1992. Other contributors include Raymond Toy, Paul Werkowski and Eric Marsden. The Hierarchical Packages chapter is based on documentation written by Franz. Inc, and is used with permission. The remainder of the document is in the public domain.