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.

Standardized

:ieee-floating-point

If present, indicates that the implementation purports to conform to the requirements of IEEE standard for binary floating-point arithmetic.

:x3j13

Indicates that the implementation conforms to some particular working draft of the X3J13 working group on the Common Lisp specification.

:ansi-cl

Indicates that the implementation purports to conform to the ANSI Common Lisp specification.

:common-lisp

This feature identifies the language family Common Lisp, without specifying a particular dialect within that family.

Platform-related

:sparc

The implementation targets the SPARC architecture.

:sun4

The implementation generates code for the Sun4 generation of SPARC processors.

:sparcstation

The implementation generates code for the SPARCstation generation of SPARC processors.

:sparc-v7

The implemenation generates code for the SPARC-V7 generation of SPARC processors. This allows the fsqrt instruction to be used.

:sparc-v8

The implementation generates code for the SPARC-V8 generation of SPARC processors. This allows fast fixnum multiplies and divides to be used.

:sparc-v9

The implementation generates code for the SPARC-V9 generation of SPARC processors. This allows certain extra floating-point instructions to be generated.

:x86

The implementation targets the x86 architecture.

:hppa

The implementation targets the HP PA-RISC architecture.

:alpha

The implementation targets the Alpha architecture.

:sgi

The implementation targets the SGI MIPS architecture.

:solaris

The implementation runs on the Solaris operating system.

:sunos

The implementation runs on the SunOS operating system.

:svr4

The implementation runs on some branch of the SVR4 family of operating systems.

:linux

The implementation runs on the Linux operating system.

:glibc2

The implementation runs above version 2 of the GNU C library.

:bsd

The implementation runs on an operating system in the BSD family.

:freebsd

The implementation runs on the FreeBSD operating system.

:mach

The implementation runs on the Mach operating system.

:irix

The implementation runs on the IRIX operating system.

:hpux

The implementation runs on the HPUX operating system.

:unix

The implementation runs on some member of the Unix family of operating systems.

Implementation-specific

:cgc

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.

:gencgc

A conservative generational garbage collector is present. Currently available for x86, sparc, and ppc, and is the default for these.

:mp

Support for multiprocessing is present.

:small

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.

:random-mt19937

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.

:hash-new

Indicates that a new implementation of hash tables supporting EQUALP is present.

:complex-fp-vops

Enable VOPS to be used for operations on complex floating point numbers. Currently only used on the SPARC and x86 ports.

:pcl

Indicates that the PCL implementation of CLOS is present.

:gerds-pcl

Indicates that the PCL implementation of CLOS is present, with modifications by Gerd Moellmann.

:portable-commonloops

An alias for PCL.

:pcl-structures

??

:new-assembler

Indicates that a new version of the assembler is present.

:python

Indicates that the Python native compiler is present.

:cmu

Identifies the CMUCL implementation.

:cmu17

Identifies version 17 or later of the CMUCL implementation.

:cmu18

Identifies version 18 or later of the CMUCL implementation.

:cmu19

Identifies version 19 or later of the CMUCL implementation.

:common

Similar to the :common-lisp feature.

:clx

The implementation includes the CLX subsystem for writing X11 programs.

:clm

The implementation includes the CLM subsystem for writing Motif applications.

:hemlock

The Hemlock editor is loaded.

:modular-arith

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 example.

:double-double

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

:stack-checking

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.

:heap-overflow-check

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.

:fast-maxmin

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.

:propagate-fun-type

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.

:propagate-float-type

Enables list-style float type specifiers such as (single-float 0.0 1.0) to be taken into account. This is always done now.

:constrain-float-type

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.

:new-compiler

Indicates that a new version of the Python compiler is present. No longer used.