Documentation: Description of *features*
Common Lisp implementations use the variable
*features* to reify information on implementation- or
environment-specific properties and functionalities. This page explains
the meaning of the features provided by CMUCL.
If present, indicates that the implementation purports to conform to
the requirements of IEEE standard for binary floating-point arithmetic.
Indicates that the implementation conforms to some particular working draft
of the X3J13 working group on the Common Lisp specification.
Indicates that the implementation purports to conform to the ANSI Common
This feature identifies the language family Common Lisp, without
specifying a particular dialect within that family.
- The implementation targets the SPARC architecture.
- The implementation generates code for the Sun4 generation of
- The implementation generates code for the SPARCstation generation of
- The implemenation generates code for the SPARC-V7 generation of SPARC
processors. This allows the fsqrt instruction to be used.
- The implementation generates code for the SPARC-V8 generation of SPARC
processors. This allows fast fixnum multiplies and divides to be used.
The implementation generates code for the SPARC-V9 generation of SPARC
processors. This allows certain extra floating-point instructions to be
- The implementation targets the x86 architecture.
- The implementation targets the HP PA-RISC architecture.
- The implementation targets the Alpha architecture.
- The implementation targets the SGI MIPS architecture.
- The implementation runs on the Solaris operating system.
- The implementation runs on the SunOS operating system.
- The implementation runs on some branch of the SVR4 family of operating
- The implementation runs on the Linux operating system.
- The implementation runs above version 2 of the GNU C library.
- The implementation runs on an operating system in the BSD family.
- The implementation runs on the FreeBSD operating system.
- The implementation runs on the Mach operating system.
- The implementation runs on the IRIX operating system.
- The implementation runs on the HPUX operating system.
- The implementation runs on some member of the Unix family of operating
Conservative garbage collector (currently only implemented for the x86
architecture). This is no longer supported on x86. Only the
generational gc is supported now. The standard garbage collector on
other platforms is stop-and-copy, based on Cheney's algorithm.
- A conservative generational garbage collector is present.
Currently available for x86, sparc, and ppc, and is the default for
- Support for multiprocessing is present.
Tells the compiler to try to reduce the size of generated code. This leads
it to byte-compile certain functions instead of generating native code.
Indicates that a random number generator based on the Mersenne Twister
algorithm is present. See the article Mersenne twister: A
623-dimensionally equidistributed uniform pseudorandom number
generator, ACM Transactions on Modeling and Computer Simulation, 1997
by Makoto Matsumoto and T. Nishimura.
Indicates that a new implementation of hash tables supporting EQUALP is
Enable VOPS to be used for operations on complex floating point numbers.
Currently only used on the SPARC and x86 ports.
Indicates that the PCL implementation of CLOS is present.
Indicates that the PCL implementation of CLOS is present, with
modifications by Gerd Moellmann.
An alias for PCL.
Indicates that a new version of the assembler is present.
- Indicates that the Python native compiler is present.
- Identifies the CMUCL implementation.
- Identifies version 17 or later of the CMUCL implementation.
- Identifies version 18 or later of the CMUCL implementation.
- Identifies version 19 or later of the CMUCL implementation.
- Similar to the :common-lisp feature.
- The implementation includes the CLX subsystem for writing X11
- The implementation includes the CLM subsystem for writing Motif
- The Hemlock editor is loaded.
- Indicates that modular arithmetic is supported. That is,
unsigned 32-bit arithmetic can be done without consing of intermediate
results if it is know that the final result is an unsigned 32-bit
number. This can be done by (logand x #xffffffff), for
- Indicates support for double-double floats. These are extended
precision floats consisting of 2 double-float numbers that allow
approximately 106 bits (32 digits) of precision
- Indicates that stack overflow checking is supported. Instead of
producing a segfault when the control stack overflows, the error is
caught instead and the user is given an opportunity to abort the
computation with causing Lisp to exit.
- Indicates that heap overflow checking is available. When the
heap is about to run out of room, Lisp throws an error that allows the
user to possibly do something before all of heap is consumed.
Deprecated features no longer used
Here is a list of some of the features that used to be available
but are no longer available. Many of these features are now standard
parts of the build.
On SPARC-V9 use conditional move instructions for min and max, which are
(probably) faster than the normal instructions since they avoid
branching. This is always true now.
Allows the compiler to infer types for many mathematical functions,
including square root, exponential and logarithmic functions, trignometric
functions and their inverses, and hyperbolic functions and their inverses.
For numeric code, this can greatly enhance efficiency by allowing the
compiler to use specialized versions of the functions instead of the
generic versions. The greatest benefit of this type inference is
determining that the result of the function is real-valued number instead
of possibly being a complex-valued number. This is always done now.
Enables list-style float type specifiers such as (single-float 0.0
1.0) to be taken into account. This is always done now.
Allows the constraint propagation phase of the compiler to apply global
flow analysis to floating point numbers, in order to obtain dynamic type
information. This is always done now.
Indicates that a new version of the Python compiler is present.
No longer used.