Common Lisp Package: TCR.EXTENSIBLE-SEQUENCES-USER

README:

FUNCTION

Public

* (&REST NUMBERS)

Return the product of its arguments. With no args, returns 1.

+ (&REST NUMBERS)

Return the sum of its arguments. With no args, returns 0.

- (NUMBER &REST MORE-NUMBERS)

Subtract the second and all subsequent arguments from the first; or with one argument, negate the first argument.

/ (NUMBER &REST MORE-NUMBERS)

Divide the first argument by each of the following arguments, in turn. With one argument, return reciprocal.

/= (NUMBER &REST MORE-NUMBERS)

Return T if no two of its arguments are numerically equal, NIL otherwise.

1+ (NUMBER)

Return NUMBER + 1.

1- (NUMBER)

Return NUMBER - 1.

< (NUMBER &REST MORE-NUMBERS)

Return T if its arguments are in strictly increasing order, NIL otherwise.

<= (NUMBER &REST MORE-NUMBERS)

Return T if arguments are in strictly non-decreasing order, NIL otherwise.

= (NUMBER &REST MORE-NUMBERS)

Return T if all of its arguments are numerically equal, NIL otherwise.

> (NUMBER &REST MORE-NUMBERS)

Return T if its arguments are in strictly decreasing order, NIL otherwise.

>= (NUMBER &REST MORE-NUMBERS)

Return T if arguments are in strictly non-increasing order, NIL otherwise.

ABORT (&OPTIONAL CONDITION)

Transfer control to a restart named ABORT, signalling a CONTROL-ERROR if none exists.

ABS (NUMBER)

Return the absolute value of the number.

ACONS (KEY DATUM ALIST)

Construct a new alist by adding the pair (KEY . DATUM) to ALIST.

ACOS (NUMBER)

Return the arc cosine of NUMBER.

ACOSH (NUMBER)

Return the hyperbolic arc cosine of NUMBER.

ADJOIN (ITEM LIST &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Add ITEM to LIST unless it is already a member

ADJUST-ARRAY (ARRAY DIMENSIONS &KEY (ELEMENT-TYPE (ARRAY-ELEMENT-TYPE ARRAY)) (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (INITIAL-CONTENTS NIL INITIAL-CONTENTS-P) FILL-POINTER DISPLACED-TO DISPLACED-INDEX-OFFSET)

Adjust ARRAY's dimensions to the given DIMENSIONS and stuff.

ADJUSTABLE-ARRAY-P (ARRAY)

Return T if (ADJUST-ARRAY ARRAY...) would return an array identical to the argument, this happens for complex arrays.

ALPHA-CHAR-P (CHAR)

The argument must be a character object. ALPHA-CHAR-P returns T if the argument is an alphabetic character, A-Z or a-z; otherwise NIL.

ALPHANUMERICP (CHAR)

Given a character-object argument, ALPHANUMERICP returns T if the argument is either numeric or alphabetic.

APPEND (&REST LISTS)

Construct a new list by concatenating the list arguments

APPLY (FUNCTION ARG &REST ARGUMENTS)

Apply FUNCTION to a list of arguments produced by evaluating ARGUMENTS in the manner of LIST*. That is, a list is made of the values of all but the last argument, appended to the value of the last argument, which must be a list.

APROPOS (STRING-DESIGNATOR &OPTIONAL PACKAGE EXTERNAL-ONLY)

Briefly describe all symbols which contain the specified STRING. If PACKAGE is supplied then only describe symbols present in that package. If EXTERNAL-ONLY then only describe external symbols in the specified package.

APROPOS-LIST (STRING-DESIGNATOR &OPTIONAL PACKAGE-DESIGNATOR EXTERNAL-ONLY)

Like APROPOS, except that it returns a list of the symbols found instead of describing them.

AREF (ARRAY &REST SUBSCRIPTS)

Return the element of the ARRAY specified by the SUBSCRIPTS.

ARITHMETIC-ERROR-OPERANDS (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

ARITHMETIC-ERROR-OPERATION (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

ARRAY-DIMENSION (ARRAY AXIS-NUMBER)

Return the length of dimension AXIS-NUMBER of ARRAY.

ARRAY-DIMENSIONS (ARRAY)

Return a list whose elements are the dimensions of the array

ARRAY-DISPLACEMENT (ARRAY)

Return the values of :DISPLACED-TO and :DISPLACED-INDEX-offset options to MAKE-ARRAY, or NIL and 0 if not a displaced array.

ARRAY-ELEMENT-TYPE (ARRAY)

Return the type of the elements of the array

ARRAY-HAS-FILL-POINTER-P (ARRAY)

Return T if the given ARRAY has a fill pointer, or NIL otherwise.

ARRAY-IN-BOUNDS-P (ARRAY &REST SUBSCRIPTS)

Return T if the SUBSCRIPTS are in bounds for the ARRAY, NIL otherwise.

ARRAY-RANK (ARRAY)

Return the number of dimensions of ARRAY.

ARRAY-TOTAL-SIZE (ARRAY)

Return the total number of elements in the Array.

ARRAYP (OBJECT)

Return true if OBJECT is an ARRAY, and NIL otherwise.

ASH (INTEGER COUNT)

Shifts integer left by count places preserving sign. - count shifts right.

ASIN (NUMBER)

Return the arc sine of NUMBER.

ASINH (NUMBER)

Return the hyperbolic arc sine of NUMBER.

ASSOC (ITEM ALIST &KEY KEY (TEST NIL TESTP) (TEST-NOT NIL NOTP))

Return the cons in ALIST whose car is equal (by a given test or EQL) to the ITEM.

ASSOC-IF (PREDICATE ALIST &KEY KEY)

Return the first cons in ALIST whose CAR satisfies PREDICATE. If KEY is supplied, apply it to the CAR of each cons before testing.

ASSOC-IF-NOT (PREDICATE ALIST &KEY KEY)

Return the first cons in ALIST whose CAR does not satisfy PREDICATE. If KEY is supplied, apply it to the CAR of each cons before testing.

ATAN (Y &OPTIONAL (X NIL XP))

Return the arc tangent of Y if X is omitted or Y/X if X is supplied.

ATANH (NUMBER)

Return the hyperbolic arc tangent of NUMBER.

ATOM (OBJECT)

Return true if OBJECT is an ATOM, and NIL otherwise.

BIT (BIT-ARRAY &REST SUBSCRIPTS)

Return the bit from the BIT-ARRAY at the specified SUBSCRIPTS.

BIT-AND (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGAND on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BIT-ANDC1 (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGANDC1 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BIT-ANDC2 (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGANDC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BIT-EQV (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGEQV on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BIT-IOR (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGIOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BIT-NAND (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGNAND on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BIT-NOR (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGNOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BIT-NOT (BIT-ARRAY &OPTIONAL RESULT-BIT-ARRAY)

Performs a bit-wise logical NOT on the elements of BIT-ARRAY, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. Both arrays must have the same rank and dimensions.

BIT-ORC1 (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGORC1 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BIT-ORC2 (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGORC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BIT-VECTOR-P (OBJECT)

Return true if OBJECT is a BIT-VECTOR, and NIL otherwise.

BIT-XOR (BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY)

Perform a bit-wise LOGXOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2, putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T, BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is created. All the arrays must have the same rank and dimensions.

BLOCK (NAME &REST FORMS)

BLOCK name form* Evaluate the FORMS as a PROGN. Within the lexical scope of the body, RETURN-FROM can be used to exit the form.

BOOLE (OP INTEGER1 INTEGER2)

Bit-wise boolean function on two integers. Function chosen by OP: 0 BOOLE-CLR 1 BOOLE-SET 2 BOOLE-1 3 BOOLE-2 4 BOOLE-C1 5 BOOLE-C2 6 BOOLE-AND 7 BOOLE-IOR 8 BOOLE-XOR 9 BOOLE-EQV 10 BOOLE-NAND 11 BOOLE-NOR 12 BOOLE-ANDC1 13 BOOLE-ANDC2 14 BOOLE-ORC1 15 BOOLE-ORC2

BOTH-CASE-P (CHAR)

The argument must be a character object. BOTH-CASE-P returns T if the argument is an alphabetic character and if the character exists in both upper and lower case. For ASCII, this is the same as ALPHA-CHAR-P.

BOUNDP (SYMBOL)

Return non-NIL if SYMBOL is bound to a value.

BREAK (&OPTIONAL (DATUM break) &REST ARGUMENTS)

Print a message and invoke the debugger without allowing any possibility of condition handling occurring.

BROADCAST-STREAM-STREAMS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

BYTE (SIZE POSITION)

Return a byte specifier which may be used by other byte functions (e.g. LDB).

BYTE-POSITION (BYTESPEC)

Return the position part of the byte specifier bytespec.

BYTE-SIZE (BYTESPEC)

Return the size part of the byte specifier bytespec.

CAAAAR (LIST)

Return the car of the caaar of a list.

CAAADR (LIST)

Return the car of the caadr of a list.

CAAAR (LIST)

Return the 1st object in the caar of a list.

CAADAR (LIST)

Return the car of the cadar of a list.

CAADDR (LIST)

Return the car of the caddr of a list.

CAADR (LIST)

Return the 1st object in the cadr of a list.

CAAR (LIST)

Return the car of the 1st sublist.

CADAAR (LIST)

Return the car of the cdaar of a list.

CADADR (LIST)

Return the car of the cdadr of a list.

CADAR (LIST)

Return the car of the cdar of a list.

CADDAR (LIST)

Return the car of the cddar of a list.

CADDDR (LIST)

Return the car of the cdddr of a list.

CADDR (LIST)

Return the 1st object in the cddr of a list.

CADR (LIST)

Return the 2nd object in a list.

CAR (LIST)

Return the 1st object in a list.

CATCH (TAG &BODY BODY)

CATCH tag form* Evaluate TAG and instantiate it as a catcher while the body forms are evaluated in an implicit PROGN. If a THROW is done to TAG within the dynamic scope of the body, then control will be transferred to the end of the body and the thrown values will be returned.

CDAAAR (LIST)

Return the cdr of the caaar of a list.

CDAADR (LIST)

Return the cdr of the caadr of a list.

CDAAR (LIST)

Return the cdr of the caar of a list.

CDADAR (LIST)

Return the cdr of the cadar of a list.

CDADDR (LIST)

Return the cdr of the caddr of a list.

CDADR (LIST)

Return the cdr of the cadr of a list.

CDAR (LIST)

Return the cdr of the 1st sublist.

CDDAAR (LIST)

Return the cdr of the cdaar of a list.

CDDADR (LIST)

Return the cdr of the cdadr of a list.

CDDAR (LIST)

Return the cdr of the cdar of a list.

CDDDAR (LIST)

Return the cdr of the cddar of a list.

CDDDDR (LIST)

Return the cdr of the cdddr of a list.

CDDDR (LIST)

Return the cdr of the cddr of a list.

CDDR (LIST)

Return all but the 1st two objects of a list.

CDR (LIST)

Return all but the first object in a list.

CEILING (NUMBER &OPTIONAL (DIVISOR 1))

Return the smallest integer not less than number, or number/divisor. The second returned value is the remainder.

CELL-ERROR-NAME (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

CHAR (STRING INDEX)

Given a string and a non-negative integer index less than the length of the string, returns the character object representing the character at that position in the string.

CHAR-CODE (CHAR)

Return the integer code of CHAR.

CHAR-DOWNCASE (CHAR)

Return CHAR converted to lower-case if that is possible.

CHAR-EQUAL (CHARACTER &REST MORE-CHARACTERS)

Return T if all of the arguments are the same character. Case is ignored.

CHAR-GREATERP (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly decreasing alphabetic order. Case is ignored.

CHAR-INT (CHAR)

Return the integer code of CHAR. (In SBCL this is the same as CHAR-CODE, as there are no character bits or fonts.)

CHAR-LESSP (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly increasing alphabetic order. Case is ignored.

CHAR-NAME (CHAR)

Return the name (a STRING) for a CHARACTER object.

CHAR-NOT-EQUAL (CHARACTER &REST MORE-CHARACTERS)

Return T if no two of the arguments are the same character. Case is ignored.

CHAR-NOT-GREATERP (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly non-decreasing alphabetic order. Case is ignored.

CHAR-NOT-LESSP (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly non-increasing alphabetic order. Case is ignored.

CHAR-UPCASE (CHAR)

Return CHAR converted to upper-case if that is possible. Don't convert lowercase eszet (U+DF).

CHAR/= (CHARACTER &REST MORE-CHARACTERS)

Return T if no two of the arguments are the same character.

CHAR< (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly increasing alphabetic order.

CHAR<= (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly non-decreasing alphabetic order.

CHAR= (CHARACTER &REST MORE-CHARACTERS)

Return T if all of the arguments are the same character.

CHAR> (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly decreasing alphabetic order.

CHAR>= (CHARACTER &REST MORE-CHARACTERS)

Return T if the arguments are in strictly non-increasing alphabetic order.

CHARACTER (OBJECT)

Coerce OBJECT into a CHARACTER if possible. Legal inputs are characters, strings and symbols of length 1.

CHARACTERP (OBJECT)

Return true if OBJECT is a CHARACTER, and NIL otherwise.

CIS (THETA)

Return cos(Theta) + i sin(Theta), i.e. exp(i Theta).

CLRHASH (HASH-TABLE)

This removes all the entries from HASH-TABLE and returns the hash table itself.

CODE-CHAR (CODE)

Return the character with the code CODE.

COERCE (OBJECT OUTPUT-TYPE-SPEC)

Coerce the Object to an object of type Output-Type-Spec.

COMPILE (NAME &OPTIONAL (DEFINITION (OR (MACRO-FUNCTION NAME) (FDEFINITION NAME))))

Produce a compiled function from DEFINITION. If DEFINITION is a lambda-expression, it is coerced to a function. If DEFINITION is an interpreted function, it is compiled. If DEFINITION is already a compiled function, it is used as-is. (Future versions of SBCL might try to recompile the existing definition, but this is not currently supported.) If NAME is NIL, the compiled function is returned as the primary value. Otherwise the resulting compiled function replaces existing function definition of NAME, and NAME is returned as primary value; if NAME is a symbol tha names a macro, its macro function is replaced and NAME is returned as primary value. Also returns secondary value which is true if any conditions of type WARNING occur during the compilation, and NIL otherwise. Tertiary value is true if any conditions of type ERROR, or WARNING that are not STYLE-WARNINGs occur during compilation, and NIL otherwise.

COMPILE-FILE (INPUT-FILE &KEY (OUTPUT-FILE (CFP-OUTPUT-FILE-DEFAULT INPUT-FILE)) ((VERBOSE *COMPILE-VERBOSE*) *COMPILE-VERBOSE*) ((PRINT *COMPILE-PRINT*) *COMPILE-PRINT*) (EXTERNAL-FORMAT DEFAULT) (TRACE-FILE NIL) ((BLOCK-COMPILE *BLOCK-COMPILE-ARG*) NIL) (EMIT-CFASL *EMIT-CFASL*))

Compile INPUT-FILE, producing a corresponding fasl file and returning its filename. :PRINT If true, a message per non-macroexpanded top level form is printed to *STANDARD-OUTPUT*. Top level forms that whose subforms are processed as top level forms (eg. EVAL-WHEN, MACROLET, PROGN) receive no such message, but their subforms do. As an extension to ANSI, if :PRINT is :top-level-forms, a message per top level form after macroexpansion is printed to *STANDARD-OUTPUT*. For example, compiling an IN-PACKAGE form will result in a message about a top level SETQ in addition to the message about the IN-PACKAGE form' itself. Both forms of reporting obey the SB-EXT:*COMPILER-PRINT-VARIABLE-ALIST*. :BLOCK-COMPILE Though COMPILE-FILE accepts an additional :BLOCK-COMPILE argument, it is not currently supported. (non-standard) :TRACE-FILE If given, internal data structures are dumped to the specified file, or if a value of T is given, to a file of *.trace type derived from the input file name. (non-standard) :EMIT-CFASL (Experimental). If true, outputs the toplevel compile-time effects of this file into a separate .cfasl file.

COMPILE-FILE-PATHNAME (INPUT-FILE &KEY (OUTPUT-FILE NIL OUTPUT-FILE-P) &ALLOW-OTHER-KEYS)

Return a pathname describing what file COMPILE-FILE would write to given these arguments.

COMPILED-FUNCTION-P (OBJECT)

Return true if OBJECT is a COMPILED-FUNCTION, and NIL otherwise.

COMPILER-MACRO-FUNCTION (NAME &OPTIONAL ENV)

If NAME names a compiler-macro in ENV, return the expansion function, else return NIL. Can be set with SETF when ENV is NIL.

COMPLEMENT (FUNCTION)

Return a new function that returns T whenever FUNCTION returns NIL and NIL whenever FUNCTION returns non-NIL.

COMPLEX (REALPART &OPTIONAL (IMAGPART 0))

Return a complex number with the specified real and imaginary components.

COMPLEXP (OBJECT)

Return true if OBJECT is a COMPLEX, and NIL otherwise.

COMPUTE-RESTARTS (&OPTIONAL CONDITION)

Return a list of all the currently active restarts ordered from most recently established to less recently established. If CONDITION is specified, then only restarts associated with CONDITION (or with no condition) will be returned.

CONCATENATED-STREAM-STREAMS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CONJUGATE (NUMBER)

Return the complex conjugate of NUMBER. For non-complex numbers, this is an identity.

CONS (SE1 SE2)

Return a list with SE1 as the CAR and SE2 as the CDR.

CONSP (OBJECT)

Return true if OBJECT is a CONS, and NIL otherwise.

CONSTANTLY (VALUE)

Return a function that always returns VALUE.

CONSTANTP (FORM &OPTIONAL (ENVIRONMENT NIL ENVP))

True of any FORM that has a constant value: self-evaluating objects, keywords, defined constants, quote forms. Additionally the constant-foldability of some function calls special forms is recognized. If ENVIRONMENT is provided the FORM is first macroexpanded in it.

CONTINUE (&OPTIONAL CONDITION)

Transfer control to a restart named CONTINUE, or return NIL if none exists.

COPY-ALIST (ALIST)

Return a new association list which is EQUAL to ALIST.

COPY-LIST (LIST)

Return a new list which is EQUAL to LIST. LIST may be improper.

COPY-SEQ (SEQUENCE)

Return a shallow copy of SEQUENCE.

COPY-STRUCTURE (STRUCTURE)

Return a copy of STRUCTURE with the same (EQL) slot values.

COPY-SYMBOL (SYMBOL &OPTIONAL (COPY-PROPS NIL) &AUX NEW-SYMBOL)

Make and return a new uninterned symbol with the same print name as SYMBOL. If COPY-PROPS is false, the new symbol is neither bound nor fbound and has no properties, else it has a copy of SYMBOL's function, value and property list.

COPY-TREE (OBJECT)

Recursively copy trees of conses.

COS (NUMBER)

Return the cosine of NUMBER.

COSH (NUMBER)

Return the hyperbolic cosine of NUMBER.

COUNT (ITEM SEQUENCE &KEY (START 0) END FROM-END KEY TEST TEST-NOT)

Return the number of elements in SEQUENCE satisfying a test with ITEM, which defaults to EQL.

COUNT-IF (PREDICATE SEQUENCE &KEY START END FROM-END KEY)

Return the number of elements in SEQUENCE satisfying PREDICATE.

COUNT-IF-NOT (PREDICATE SEQUENCE &KEY (START 0) END FROM-END KEY)

Return the number of elements in SEQUENCE not satisfying PREDICATE.

DECODE-FLOAT (F)

Return three values: 1) a floating-point number representing the significand. This is always between 0.5 (inclusive) and 1.0 (exclusive). 2) an integer representing the exponent. 3) -1.0 or 1.0 (i.e. the sign of the argument.)

DECODE-UNIVERSAL-TIME (UNIVERSAL-TIME &OPTIONAL TIME-ZONE)

Converts a universal-time to decoded time format returning the following nine values: second, minute, hour, date, month, year, day of week (0 = Monday), T (daylight savings time) or NIL (standard time), and timezone. Completely ignores daylight-savings-time when time-zone is supplied.

DELETE-FILE (FILE)

Delete the specified FILE. If FILE is a stream, on Windows the stream is closed immediately. On Unix plaforms the stream remains open, allowing IO to continue: the OS resources associated with the deleted file remain available till the stream is closed as per standard Unix unlink() behaviour.

DELETE-PACKAGE (PACKAGE-DESIGNATOR)

Delete the package designated by PACKAGE-DESIGNATOR from the package system data structures.

DENOMINATOR (NUMBER)

Return the denominator of NUMBER, which must be rational.

DEPOSIT-FIELD (NEWBYTE BYTESPEC INTEGER)

Return new integer with newbyte in specified position, newbyte is not right justified.

DESCRIBE (OBJECT &OPTIONAL (STREAM-DESIGNATOR *STANDARD-OUTPUT*))

Print a description of OBJECT to STREAM-DESIGNATOR.

DIGIT-CHAR (WEIGHT &OPTIONAL (RADIX 10))

All arguments must be integers. Returns a character object that represents a digit of the given weight in the specified radix. Returns NIL if no such character exists.

DIGIT-CHAR-P (CHAR &OPTIONAL (RADIX 10))

If char is a digit in the specified radix, returns the fixnum for which that digit stands, else returns NIL.

DIRECTORY (PATHSPEC &KEY (RESOLVE-SYMLINKS T))

Return a list of PATHNAMEs, each the TRUENAME of a file that matched the given pathname. Note that the interaction between this ANSI-specified TRUENAMEing and the semantics of the Unix filesystem (symbolic links..) means this function can sometimes return files which don't have the same directory as PATHNAME. If :RESOLVE-SYMLINKS is NIL, don't resolve symbolic links in matching filenames.

DIRECTORY-NAMESTRING (PATHNAME)

Return a string representation of the directories used in the pathname.

DISASSEMBLE (OBJECT &KEY (STREAM *STANDARD-OUTPUT*) (USE-LABELS T))

Disassemble the compiled code associated with OBJECT, which can be a function, a lambda expression, or a symbol with a function definition. If it is not already compiled, the compiler is called to produce something to disassemble.

DPB (NEWBYTE BYTESPEC INTEGER)

Return new integer with newbyte in specified position, newbyte is right justified.

DRIBBLE (&OPTIONAL PATHNAME &KEY (IF-EXISTS APPEND))

With a file name as an argument, dribble opens the file and sends a record of further I/O to that file. Without an argument, it closes the dribble file, and quits logging.

ECHO-STREAM-INPUT-STREAM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ECHO-STREAM-OUTPUT-STREAM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

ED (&OPTIONAL X)

Starts the editor (on a file or a function if named). Functions from the list *ED-FUNCTIONS* are called in order with X as an argument until one of them returns non-NIL; these functions are responsible for signalling a FILE-ERROR to indicate failure to perform an operation on the file system.

EIGHTH (LIST)

Return the 8th object in a list or NIL if there is no 8th object.

ELT (SEQUENCE INDEX)

Returns the element of SEQUENCE specified by INDEX.

SETFELT (NEW-VALUE SEQUENCE INDEX)

Modifies SEQUENCE at INDEX.

ENCODE-UNIVERSAL-TIME (SECOND MINUTE HOUR DATE MONTH YEAR &OPTIONAL TIME-ZONE)

The time values specified in decoded format are converted to universal time, which is returned.

ENDP (OBJECT)

This is the recommended way to test for the end of a proper list. It returns true if OBJECT is NIL, false if OBJECT is a CONS, and an error for any other type of OBJECT.

ENOUGH-NAMESTRING (PATHNAME &OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*))

Return an abbreviated pathname sufficent to identify the pathname relative to the defaults.

ENSURE-DIRECTORIES-EXIST (PATHSPEC &KEY VERBOSE (MODE 511))

Test whether the directories containing the specified file actually exist, and attempt to create them if they do not. The MODE argument is a CMUCL/SBCL-specific extension to control the Unix permission bits.

EQ (OBJ1 OBJ2)

Return T if OBJ1 and OBJ2 are the same object, otherwise NIL.

EQUAL (X Y)

Return T if X and Y are EQL or if they are structured components whose elements are EQUAL. Strings and bit-vectors are EQUAL if they are the same length and have identical components. Other arrays must be EQ to be EQUAL.

ERROR (DATUM &REST ARGUMENTS)

Invoke the signal facility on a condition formed from DATUM and ARGUMENTS. If the condition is not handled, the debugger is invoked.

EVAL (ORIGINAL-EXP)

Evaluate the argument in a null lexical environment, returning the result or results.

EVAL-WHEN (SITUATIONS &REST FORMS)

EVAL-WHEN (situation*) form* Evaluate the FORMS in the specified SITUATIONS (any of :COMPILE-TOPLEVEL, :LOAD-TOPLEVEL, or :EXECUTE, or (deprecated) COMPILE, LOAD, or EVAL).

EVENP (NUMBER)

Is this integer even?

EVERY (PRED FIRST-SEQ &REST MORE-SEQS)

Apply PREDICATE to the 0-indexed elements of the sequences, then possibly to those with index 1, and so on. Return NIL as soon as any invocation of PREDICATE returns NIL, or T if every invocation is non-NIL.

EXP (NUMBER)

Return e raised to the power NUMBER.

EXPORT (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Exports SYMBOLS from PACKAGE, checking that no name conflicts result.

EXPT (BASE POWER)

Return BASE raised to the POWER.

FBOUNDP (NAME)

Return true if name has a global function definition.

FCEILING (NUMBER &OPTIONAL (DIVISOR 1))

Same as CEILING, but returns first value as a float.

FDEFINITION (NAME)

Return name's global function definition taking care to respect any encapsulations and to return the innermost encapsulated definition. This is SETF'able.

FFLOOR (NUMBER &OPTIONAL (DIVISOR 1))

Same as FLOOR, but returns first value as a float.

FIFTH (LIST)

Return the 5th object in a list or NIL if there is no 5th object.

FILE-AUTHOR (PATHSPEC)

Return the author of the file specified by PATHSPEC. Signal an error of type FILE-ERROR if no such file exists, or if PATHSPEC is a wild pathname.

FILE-ERROR-PATHNAME (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

FILE-NAMESTRING (PATHNAME)

Return a string representation of the name used in the pathname.

FILE-WRITE-DATE (PATHSPEC)

Return the write date of the file specified by PATHSPEC. An error of type FILE-ERROR is signaled if no such file exists, or if PATHSPEC is a wild pathname.

FILL-POINTER (VECTOR)

Return the FILL-POINTER of the given VECTOR.

FIND (ITEM SEQUENCE &KEY (START 0) END FROM-END KEY TEST TEST-NOT)

Returns the first (or, if FROM-END is non-nil, last) element in SEQUENCE which satisfies a test with ITEM, which defaults to EQL.

FIND-ALL-SYMBOLS (STRING-OR-SYMBOL)

Return a list of all symbols in the system having the specified name.

FIND-IF (PREDICATE SEQUENCE &KEY (START 0) END FROM-END KEY)

Returns the first (or, if FROM-END is non-nil, last) element in SEQUENCE which satisfies PREDICATE.

FIND-IF-NOT (PREDICATE SEQUENCE &KEY (START 0) END FROM-END KEY)

Returns the first (or, if FROM-END is non-nil, last) element in SEQUENCE which does not satisfy PREDICATE.

FIND-RESTART (IDENTIFIER &OPTIONAL CONDITION)

Return the first restart identified by IDENTIFIER. If IDENTIFIER is a symbol, then the innermost applicable restart with that name is returned. If IDENTIFIER is a restart, it is returned if it is currently active. Otherwise NIL is returned. If CONDITION is specified and not NIL, then only restarts associated with that condition (or with no condition) will be returned.

FIND-SYMBOL (NAME &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Return the symbol named STRING in PACKAGE. If such a symbol is found then the second value is :INTERNAL, :EXTERNAL or :INHERITED to indicate how the symbol is accessible. If no symbol is found then both values are NIL.

FIRST (LIST)

Return the 1st object in a list or NIL if the list is empty.

FLET (DEFINITIONS &BODY BODY)

FLET ({(name lambda-list declaration* form*)}*) declaration* body-form* Evaluate the BODY-FORMS with local function definitions. The bindings do not enclose the definitions; any use of NAME in the FORMS will refer to the lexically apparent function definition in the enclosing environment.

FLOAT (NUMBER &OPTIONAL (OTHER NIL OTHERP))

Converts any REAL to a float. If OTHER is not provided, it returns a SINGLE-FLOAT if NUMBER is not already a FLOAT. If OTHER is provided, the result is the same float format as OTHER.

FLOAT-PRECISION (F)

Return a non-negative number of significant digits in its float argument. Will be less than FLOAT-DIGITS if denormalized or zero.

FLOAT-RADIX (X)

Return (as an integer) the radix b of its floating-point argument.

FLOAT-SIGN (FLOAT1 &OPTIONAL (FLOAT2 (FLOAT 1 FLOAT1)))

Return a floating-point number that has the same sign as FLOAT1 and, if FLOAT2 is given, has the same absolute value as FLOAT2.

FLOATP (OBJECT)

Return true if OBJECT is a FLOAT, and NIL otherwise.

FLOOR (NUMBER &OPTIONAL (DIVISOR 1))

Return the greatest integer not greater than number, or number/divisor. The second returned value is (mod number divisor).

FMAKUNBOUND (NAME)

Make NAME have no global function definition.

FORMAT (DESTINATION CONTROL-STRING &REST FORMAT-ARGUMENTS)

Provides various facilities for formatting output. CONTROL-STRING contains a string to be output, possibly with embedded directives, which are flagged with the escape character "~". Directives generally expand into additional text to be output, usually consuming one or more of the FORMAT-ARGUMENTS in the process. A few useful directives are: ~A or ~nA Prints one argument as if by PRINC ~S or ~nS Prints one argument as if by PRIN1 ~D or ~nD Prints one argument as a decimal integer ~% Does a TERPRI ~& Does a FRESH-LINE where n is the width of the field in which the object is printed. DESTINATION controls where the result will go. If DESTINATION is T, then the output is sent to the standard output stream. If it is NIL, then the output is returned in a string as the value of the call. Otherwise, DESTINATION must be a stream to which the output will be sent. Example: (FORMAT NIL "The answer is ~D." 10) => "The answer is 10." FORMAT has many additional capabilities not described here. Consult the manual for details.

FOURTH (LIST)

Return the 4th object in a list or NIL if there is no 4th object.

FROUND (NUMBER &OPTIONAL (DIVISOR 1))

Same as ROUND, but returns first value as a float.

FTRUNCATE (NUMBER &OPTIONAL (DIVISOR 1))

Same as TRUNCATE, but returns first value as a float.

FUNCALL (FUNCTION &REST ARGUMENTS)

Call FUNCTION with the given ARGUMENTS.

FUNCTION (THING)

FUNCTION name Return the lexically apparent definition of the function NAME. NAME may also be a lambda expression.

FUNCTION-LAMBDA-EXPRESSION (FUN)

Return (VALUES DEFINING-LAMBDA-EXPRESSION CLOSURE-P NAME), where DEFINING-LAMBDA-EXPRESSION is NIL if unknown, or a suitable argument to COMPILE otherwise, CLOSURE-P is non-NIL if the function's definition might have been enclosed in some non-null lexical environment, and NAME is some name (for debugging only) or NIL if there is no name.

FUNCTIONP (OBJECT)

Return true if OBJECT is a FUNCTION, and NIL otherwise.

GCD (&REST INTEGERS)

Return the greatest common divisor of the arguments, which must be integers. Gcd with no arguments is defined to be 0.

GENSYM (&OPTIONAL (THING G))

Creates a new uninterned symbol whose name is a prefix string (defaults to "G"), followed by a decimal number. Thing, when supplied, will alter the prefix if it is a string, or be used for the decimal number if it is a number, of this symbol. The default value of the number is the current value of *gensym-counter* which is incremented each time it is used.

GENTEMP (&OPTIONAL (PREFIX T) (PACKAGE (SANE-PACKAGE)))

Creates a new symbol interned in package PACKAGE with the given PREFIX.

GET (SYMBOL INDICATOR &OPTIONAL (DEFAULT NIL))

Look on the property list of SYMBOL for the specified INDICATOR. If this is found, return the associated value, else return DEFAULT.

GET-DECODED-TIME

Return nine values specifying the current time as follows: second, minute, hour, date, month, year, day of week (0 = Monday), T (daylight savings times) or NIL (standard time), and timezone.

GET-DISPATCH-MACRO-CHARACTER (DISP-CHAR SUB-CHAR &OPTIONAL (RT-DESIGNATOR *READTABLE*))

Return the macro character function for SUB-CHAR under DISP-CHAR or NIL if there is no associated function.

GET-INTERNAL-REAL-TIME

Return the real time ("wallclock time") since startup in the internal time format. (See INTERNAL-TIME-UNITS-PER-SECOND.)

GET-INTERNAL-RUN-TIME

Return the run time used by the process in the internal time format. (See INTERNAL-TIME-UNITS-PER-SECOND.) This is useful for finding CPU usage. Includes both "system" and "user" time.

GET-MACRO-CHARACTER (CHAR &OPTIONAL (RT-DESIGNATOR *READTABLE*))

Return the function associated with the specified CHAR which is a macro character, or NIL if there is no such function. As a second value, return T if CHAR is a macro character which is non-terminating, i.e. which can be embedded in a symbol name.

GET-PROPERTIES (PLACE INDICATOR-LIST)

Like GETF, except that INDICATOR-LIST is a list of indicators which will be looked for in the property list stored in PLACE. Three values are returned, see manual for details.

GET-SETF-EXPANSION (FORM &OPTIONAL ENVIRONMENT)

Return five values needed by the SETF machinery: a list of temporary variables, a list of values with which to fill them, a list of temporaries for the new values, the setting function, and the accessing function.

GET-UNIVERSAL-TIME

Return a single integer for the current time of day in universal time format.

GETF (PLACE INDICATOR &OPTIONAL (DEFAULT NIL))

Search the property list stored in PLACE for an indicator EQ to INDICATOR. If one is found, return the corresponding value, else return DEFAULT.

GETHASH (KEY HASH-TABLE &OPTIONAL DEFAULT)

Finds the entry in HASH-TABLE whose key is KEY and returns the associated value and T as multiple values, or returns DEFAULT and NIL if there is no such entry. Entries can be added using SETF.

GO (TAG)

GO tag Transfer control to the named TAG in the lexically enclosing TAGBODY. This is constrained to be used only within the dynamic extent of the TAGBODY.

GRAPHIC-CHAR-P (CHAR)

The argument must be a character object. GRAPHIC-CHAR-P returns T if the argument is a printing character (space through ~ in ASCII), otherwise returns NIL.

HASH-TABLE-COUNT (HASH-TABLE)

Return the number of entries in the given HASH-TABLE.

HASH-TABLE-REHASH-SIZE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HASH-TABLE-REHASH-THRESHOLD (INSTANCE)

Return the rehash-threshold HASH-TABLE was created with.

HASH-TABLE-SIZE (HASH-TABLE)

Return a size that can be used with MAKE-HASH-TABLE to create a hash table that can hold however many entries HASH-TABLE can hold without having to be grown.

HASH-TABLE-TEST (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

HOST-NAMESTRING (PATHNAME)

Return a string representation of the name of the host in the pathname.

IDENTITY (THING)

This function simply returns what was passed to it.

IF (TEST THEN &OPTIONAL ELSE)

IF predicate then [else] If PREDICATE evaluates to true, evaluate THEN and return its values, otherwise evaluate ELSE and return its values. ELSE defaults to NIL.

IMAGPART (NUMBER)

Extract the imaginary part of a number.

IMPORT (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Make SYMBOLS accessible as internal symbols in PACKAGE. If a symbol is already accessible then it has no effect. If a name conflict would result from the importation, then a correctable error is signalled.

INTEGER-DECODE-FLOAT (X)

Return three values: 1) an integer representation of the significand. 2) the exponent for the power of 2 that the significand must be multiplied by to get the actual value. This differs from the DECODE-FLOAT exponent by FLOAT-DIGITS, since the significand has been scaled to have all its digits before the radix point. 3) -1 or 1 (i.e. the sign of the argument.)

INTEGER-LENGTH (INTEGER)

Return the number of non-sign bits in the twos-complement representation of INTEGER.

INTEGERP (OBJECT)

Return true if OBJECT is an INTEGER, and NIL otherwise.

INTERN (NAME &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Return a symbol in PACKAGE having the specified NAME, creating it if necessary.

INTERSECTION (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Return the intersection of LIST1 and LIST2.

INVOKE-DEBUGGER (CONDITION)

Enter the debugger.

INVOKE-RESTART (RESTART &REST VALUES)

Calls the function associated with the given restart, passing any given arguments. If the argument restart is not a restart or a currently active non-nil restart name, then a CONTROL-ERROR is signalled.

INVOKE-RESTART-INTERACTIVELY (RESTART)

Calls the function associated with the given restart, prompting for any necessary arguments. If the argument restart is not a restart or a currently active non-NIL restart name, then a CONTROL-ERROR is signalled.

ISQRT (N)

Return the greatest integer less than or equal to the square root of N.

KEYWORDP (OBJECT)

Return true if Object is a symbol in the "KEYWORD" package.

LABELS (DEFINITIONS &BODY BODY)

LABELS ({(name lambda-list declaration* form*)}*) declaration* body-form* Evaluate the BODY-FORMS with local function definitions. The bindings enclose the new definitions, so the defined functions can call themselves or each other.

LAST (LIST &OPTIONAL (N 1))

Return the last N conses (not the last element!) of a list.

LCM (&REST INTEGERS)

Return the least common multiple of one or more integers. LCM of no arguments is defined to be 1.

LDB (BYTESPEC INTEGER)

Extract the specified byte from integer, and right justify result.

LDB-TEST (BYTESPEC INTEGER)

Return T if any of the specified bits in integer are 1's.

LDIFF (LIST OBJECT)

Return a new list, whose elements are those of LIST that appear before OBJECT. If OBJECT is not a tail of LIST, a copy of LIST is returned. LIST must be a proper list or a dotted list.

LENGTH (SEQUENCE)

Returns an integer that is the length of SEQUENCE.

LET (BINDINGS &BODY BODY)

LET ({(var [value]) | var}*) declaration* form* During evaluation of the FORMS, bind the VARS to the result of evaluating the VALUE forms. The variables are bound in parallel after all of the VALUES forms have been evaluated.

LET* (BINDINGS &BODY BODY)

LET* ({(var [value]) | var}*) declaration* form* Similar to LET, but the variables are bound sequentially, allowing each VALUE form to reference any of the previous VARS.

LIST (&REST ARGS)

Return constructs and returns a list of its arguments.

LIST* (ARG &REST OTHERS)

Return a list of the arguments with last cons a dotted pair.

LIST-ALL-PACKAGES

Return a list of all existing packages.

LIST-LENGTH (LIST)

Return the length of the given List, or Nil if the List is circular.

LISTP (OBJECT)

Return true if OBJECT is a LIST, and NIL otherwise.

LOAD (PATHSPEC &KEY (VERBOSE *LOAD-VERBOSE*) (PRINT *LOAD-PRINT*) (IF-DOES-NOT-EXIST T) (EXTERNAL-FORMAT DEFAULT))

Load the file given by FILESPEC into the Lisp environment, returning T on success.

LOAD-LOGICAL-PATHNAME-TRANSLATIONS (HOST)

Reads logical pathname translations from SYS:SITE;HOST.TRANSLATIONS.NEWEST, with HOST replaced by the supplied parameter. Returns T on success. If HOST is already defined as logical pathname host, no file is loaded and NIL is returned. The file should contain a single form, suitable for use with (SETF LOGICAL-PATHNAME-TRANSLATIONS). Note: behaviour of this function is higly implementation dependent, and historically it used to be a no-op in SBcL -- the current approach is somewhat experimental and subject to change.

LOAD-TIME-VALUE (FORM &OPTIONAL READ-ONLY-P)

Arrange for FORM to be evaluated at load-time and use the value produced as if it were a constant. If READ-ONLY-P is non-NIL, then the resultant object is guaranteed to never be modified, so it can be put in read-only storage.

LOCALLY (&BODY BODY)

LOCALLY declaration* form* Sequentially evaluate the FORMS in a lexical environment where the DECLARATIONS have effect. If LOCALLY is a top level form, then the FORMS are also processed as top level forms.

LOG (NUMBER &OPTIONAL (BASE NIL BASE-P))

Return the logarithm of NUMBER in the base BASE, which defaults to e.

LOGAND (&REST INTEGERS)

Return the bit-wise and of its arguments. Args must be integers.

LOGANDC1 (INTEGER1 INTEGER2)

Bitwise AND (LOGNOT INTEGER1) with INTEGER2.

LOGANDC2 (INTEGER1 INTEGER2)

Bitwise AND INTEGER1 with (LOGNOT INTEGER2).

LOGBITP (INDEX INTEGER)

Predicate returns T if bit index of integer is a 1.

LOGCOUNT (INTEGER)

Count the number of 1 bits if INTEGER is positive, and the number of 0 bits if INTEGER is negative.

LOGEQV (&REST INTEGERS)

Return the bit-wise equivalence of its arguments. Args must be integers.

LOGICAL-PATHNAME (PATHSPEC)

Converts the pathspec argument to a logical-pathname and returns it.

LOGICAL-PATHNAME-TRANSLATIONS (HOST)

Return the (logical) host object argument's list of translations.

SETFLOGICAL-PATHNAME-TRANSLATIONS (TRANSLATIONS HOST)

Set the translations list for the logical host argument.

LOGIOR (&REST INTEGERS)

Return the bit-wise or of its arguments. Args must be integers.

LOGNAND (INTEGER1 INTEGER2)

Complement the logical AND of INTEGER1 and INTEGER2.

LOGNOR (INTEGER1 INTEGER2)

Complement the logical AND of INTEGER1 and INTEGER2.

LOGNOT (NUMBER)

Return the bit-wise logical not of integer.

LOGORC1 (INTEGER1 INTEGER2)

Bitwise OR (LOGNOT INTEGER1) with INTEGER2.

LOGORC2 (INTEGER1 INTEGER2)

Bitwise OR INTEGER1 with (LOGNOT INTEGER2).

LOGTEST (INTEGER1 INTEGER2)

Predicate which returns T if logand of integer1 and integer2 is not zero.

LOGXOR (&REST INTEGERS)

Return the bit-wise exclusive or of its arguments. Args must be integers.

LONG-SITE-NAME

Return a string with the long form of the site name, or NIL if not known.

LOWER-CASE-P (CHAR)

The argument must be a character object; LOWER-CASE-P returns T if the argument is a lower-case character, NIL otherwise.

MACHINE-INSTANCE

Return a string giving the name of the local machine.

MACHINE-TYPE

Return a string describing the type of the local machine.

MACHINE-VERSION

Return a string describing the version of the computer hardware we are running on, or NIL if we can't find any useful information.

MACRO-FUNCTION (SYMBOL &OPTIONAL ENV)

If SYMBOL names a macro in ENV, returns the expansion function, else returns NIL. If ENV is unspecified or NIL, use the global environment only.

MACROEXPAND (FORM &OPTIONAL ENV)

Repetitively call MACROEXPAND-1 until the form can no longer be expanded. Returns the final resultant form, and T if it was expanded. ENV is the lexical environment to expand in, or NIL (the default) for the null environment.

MACROEXPAND-1 (FORM &OPTIONAL ENV)

If form is a macro (or symbol macro), expand it once. Return two values, the expanded form and a T-or-NIL flag indicating whether the form was, in fact, a macro. ENV is the lexical environment to expand in, which defaults to the null environment.

MACROLET (DEFINITIONS &REST BODY)

MACROLET ({(name lambda-list form*)}*) body-form* Evaluate the BODY-FORMS in an environment with the specified local macros defined. NAME is the local macro name, LAMBDA-LIST is a DEFMACRO style destructuring lambda list, and the FORMS evaluate to the expansion.

MAKE-CONCATENATED-STREAM (&REST STREAMS)

Return a stream which takes its input from each of the streams in turn, going on to the next at EOF.

MAKE-CONDITION (TYPE &REST ARGS)

Make an instance of a condition object using the specified initargs.

MAKE-DISPATCH-MACRO-CHARACTER (CHAR &OPTIONAL (NON-TERMINATING-P NIL) (RT *READTABLE*))

Cause CHAR to become a dispatching macro character in readtable (which defaults to the current readtable). If NON-TERMINATING-P, the char will be non-terminating.

MAKE-ECHO-STREAM (INPUT-STREAM OUTPUT-STREAM)

Return a bidirectional stream which gets its input from INPUT-STREAM and sends its output to OUTPUT-STREAM. In addition, all input is echoed to the output stream.

MAKE-HASH-TABLE (&KEY (TEST 'EQL) (SIZE +MIN-HASH-TABLE-SIZE+) (REHASH-SIZE 1.5) (REHASH-THRESHOLD 1) (HASH-FUNCTION NIL) (WEAKNESS NIL) (SYNCHRONIZED))

Create and return a new hash table. The keywords are as follows: :TEST Determines how keys are compared. Must a designator for one of the standard hash table tests, or a hash table test defined using SB-EXT:DEFINE-HASH-TABLE-TEST. Additionally, when an explicit HASH-FUNCTION is provided (see below), any two argument equivalence predicate can be used as the TEST. :SIZE A hint as to how many elements will be put in this hash table. :REHASH-SIZE Indicates how to expand the table when it fills up. If an integer, add space for that many elements. If a floating point number (which must be greater than 1.0), multiply the size by that amount. :REHASH-THRESHOLD Indicates how dense the table can become before forcing a rehash. Can be any positive number <=1, with density approaching zero as the threshold approaches 0. Density 1 means an average of one entry per bucket. :HASH-FUNCTION If NIL (the default), a hash function based on the TEST argument is used, which then must be one of the standardized hash table test functions, or one for which a default hash function has been defined using SB-EXT:DEFINE-HASH-TABLE-TEST. If HASH-FUNCTION is specified, the TEST argument can be any two argument predicate consistent with it. The HASH-FUNCTION is expected to return a non-negative fixnum hash code. :WEAKNESS When :WEAKNESS is not NIL, garbage collection may remove entries from the hash table. The value of :WEAKNESS specifies how the presence of a key or value in the hash table preserves their entries from garbage collection. Valid values are: :KEY means that the key of an entry must be live to guarantee that the entry is preserved. :VALUE means that the value of an entry must be live to guarantee that the entry is preserved. :KEY-AND-VALUE means that both the key and the value must be live to guarantee that the entry is preserved. :KEY-OR-VALUE means that either the key or the value must be live to guarantee that the entry is preserved. NIL (the default) means that entries are always preserved. :SYNCHRONIZED If NIL (the default), the hash-table may have multiple concurrent readers, but results are undefined if a thread writes to the hash-table concurrently with another reader or writer. If T, all concurrent accesses are safe, but note that CLHS 3.6 (Traversal Rules and Side Effects) remains in force. See also: SB-EXT:WITH-LOCKED-HASH-TABLE. This keyword argument is experimental, and may change incompatibly or be removed in the future.

MAKE-LIST (SIZE &KEY INITIAL-ELEMENT)

Constructs a list with size elements each set to value

MAKE-PACKAGE (NAME &KEY (USE 'NIL) NICKNAMES (INTERNAL-SYMBOLS 10) (EXTERNAL-SYMBOLS 10))

Make a new package having the specified NAME, NICKNAMES, and USE list. :INTERNAL-SYMBOLS and :EXTERNAL-SYMBOLS are estimates for the number of internal and external symbols which will ultimately be present in the package. The default value of USE is implementation-dependent, and in this implementation it is NIL.

MAKE-PATHNAME (&KEY HOST (DEVICE NIL DEVP) (DIRECTORY NIL DIRP) (NAME NIL NAMEP) (TYPE NIL TYPEP) (VERSION NIL VERSIONP) DEFAULTS (CASE LOCAL))

Makes a new pathname from the component arguments. Note that host is a host-structure or string.

MAKE-RANDOM-STATE (&OPTIONAL STATE)

Make a random state object. The optional STATE argument specifies a seed for deterministic pseudo-random number generation. As per the Common Lisp standard, - If STATE is NIL or not supplied, return a copy of the default *RANDOM-STATE*. - If STATE is a random state, return a copy of it. - If STATE is T, return a randomly initialized state (using operating-system provided randomness where available, otherwise a poor substitute based on internal time and pid). See SB-EXT:SEED-RANDOM-STATE for a SBCL extension to this functionality.

MAKE-STRING (COUNT &KEY (ELEMENT-TYPE 'CHARACTER) ((INITIAL-ELEMENT FILL-CHAR)))

Given a character count and an optional fill character, makes and returns a new string COUNT long filled with the fill character.

MAKE-STRING-INPUT-STREAM (STRING &OPTIONAL (START 0) END)

Return an input stream which will supply the characters of STRING between START and END in order.

MAKE-STRING-OUTPUT-STREAM (&KEY (ELEMENT-TYPE 'CHARACTER) &AUX (BUFFER (MAKE-STRING *STRING-OUTPUT-STREAM-BUFFER-INITIAL-SIZE*)))

Return an output stream which will accumulate all output given it for the benefit of the function GET-OUTPUT-STREAM-STRING.

MAKE-SYMBOL (STRING)

Make and return a new symbol with the STRING as its print name.

MAKE-TWO-WAY-STREAM (INPUT-STREAM OUTPUT-STREAM)

Return a bidirectional stream which gets its input from INPUT-STREAM and sends its output to OUTPUT-STREAM.

MAKUNBOUND (SYMBOL)

Make SYMBOL unbound, removing any value it may currently have.

MAPC (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive elements of lists. Return the second argument.

MAPCAN (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive elements of LIST. Return NCONC of FUNCTION results.

MAPCAR (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive elements of LIST. Return list of FUNCTION return values.

MAPCON (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive CDRs of lists. Return NCONC of results.

MAPHASH (FUNCTION-DESIGNATOR HASH-TABLE)

For each entry in HASH-TABLE, call the designated two-argument function on the key and value of the entry. Return NIL. Consequences are undefined if HASH-TABLE is mutated during the call to MAPHASH, except for changing or removing elements corresponding to the current key. The applies to all threads, not just the current one -- even for synchronized hash-tables. If the table may be mutated by another thread during iteration, use eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the MAPHASH call.

MAPL (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive CDRs of list. Return NIL.

MAPLIST (FUNCTION LIST &REST MORE-LISTS)

Apply FUNCTION to successive CDRs of list. Return list of results.

MASK-FIELD (BYTESPEC INTEGER)

Extract the specified byte from integer, but do not right justify result.

MAX (NUMBER &REST MORE-NUMBERS)

Return the greatest of its arguments; among EQUALP greatest, return the first.

MEMBER (ITEM LIST &KEY KEY (TEST NIL TESTP) (TEST-NOT NIL NOTP))

Return the tail of LIST beginning with first element satisfying EQLity, :TEST, or :TEST-NOT with the given ITEM.

MEMBER-IF (TEST LIST &KEY KEY)

Return tail of LIST beginning with first element satisfying TEST.

MEMBER-IF-NOT (TEST LIST &KEY KEY)

Return tail of LIST beginning with first element not satisfying TEST.

MERGE-PATHNAMES (PATHNAME &OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*) (DEFAULT-VERSION NEWEST))

Construct a filled in pathname by completing the unspecified components from the defaults.

MIN (NUMBER &REST MORE-NUMBERS)

Return the least of its arguments; among EQUALP least, return the first.

MINUSP (NUMBER)

Is this real number strictly negative?

MOD (NUMBER DIVISOR)

Return second result of FLOOR.

MUFFLE-WARNING (&OPTIONAL CONDITION)

Transfer control to a restart named MUFFLE-WARNING, signalling a CONTROL-ERROR if none exists.

MULTIPLE-VALUE-CALL (FUN &REST ARGS)

MULTIPLE-VALUE-CALL function values-form* Call FUNCTION, passing all the values of each VALUES-FORM as arguments, values from the first VALUES-FORM making up the first argument, etc.

MULTIPLE-VALUE-PROG1 (VALUES-FORM &REST FORMS)

MULTIPLE-VALUE-PROG1 values-form form* Evaluate VALUES-FORM and then the FORMS, but return all the values of VALUES-FORM.

NAME-CHAR (NAME)

Given an argument acceptable to STRING, NAME-CHAR returns a character whose name is that string, if one exists. Otherwise, NIL is returned.

NAMESTRING (PATHNAME)

Construct the full (name)string form of the pathname.

NCONC (&REST LISTS)

Concatenates the lists given as arguments (by changing them)

NINTERSECTION (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Destructively return the intersection of LIST1 and LIST2.

NINTH (LIST)

Return the 9th object in a list or NIL if there is no 9th object.

NOT (OBJECT)

Return T if X is NIL, otherwise return NIL.

NOTANY (PRED FIRST-SEQ &REST MORE-SEQS)

Apply PREDICATE to the 0-indexed elements of the sequences, then possibly to those with index 1, and so on. Return NIL as soon as any invocation of PREDICATE returns a non-NIL value, or T if the end of any sequence is reached.

NOTEVERY (PRED FIRST-SEQ &REST MORE-SEQS)

Apply PREDICATE to 0-indexed elements of the sequences, then possibly to those with index 1, and so on. Return T as soon as any invocation of PREDICATE returns NIL, or NIL if every invocation is non-NIL.

NRECONC (X Y)

Return (NCONC (NREVERSE X) Y).

NREVERSE (SEQUENCE)

Destructively reverse SEQUENCE.

NSET-DIFFERENCE (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Destructively return the elements of LIST1 which are not in LIST2.

NSET-EXCLUSIVE-OR (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Destructively return a list with elements which appear but once in LIST1 and LIST2.

NSUBLIS (ALIST TREE &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Substitute from ALIST into TRUE destructively.

NSUBST (NEW OLD TREE &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Substitute NEW for subtrees matching OLD.

NSUBST-IF (NEW TEST TREE &KEY KEY)

Substitute NEW for subtrees of TREE for which TEST is true.

NSUBST-IF-NOT (NEW TEST TREE &KEY KEY)

Substitute NEW for subtrees of TREE for which TEST is false.

NTH (N LIST)

Return the nth object in a list where the car is the zero-th element.

NTHCDR (N LIST)

Performs the cdr function n times on a list.

NULL (OBJECT)

Return true if OBJECT is a NULL, and NIL otherwise.

NUMBERP (OBJECT)

Return true if OBJECT is a NUMBER, and NIL otherwise.

NUMERATOR (NUMBER)

Return the numerator of NUMBER, which must be rational.

NUNION (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Destructively return the union of LIST1 and LIST2.

ODDP (NUMBER)

Is this integer odd?

OPEN (FILENAME &KEY (DIRECTION INPUT) (ELEMENT-TYPE 'BASE-CHAR) (IF-EXISTS NIL IF-EXISTS-GIVEN) (IF-DOES-NOT-EXIST NIL IF-DOES-NOT-EXIST-GIVEN) (EXTERNAL-FORMAT DEFAULT) &AUX (DIRECTION DIRECTION) (IF-DOES-NOT-EXIST IF-DOES-NOT-EXIST) (IF-EXISTS IF-EXISTS))

Return a stream which reads from or writes to FILENAME. Defined keywords: :DIRECTION - one of :INPUT, :OUTPUT, :IO, or :PROBE :ELEMENT-TYPE - the type of object to read or write, default BASE-CHAR :IF-EXISTS - one of :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE, :OVERWRITE, :APPEND, :SUPERSEDE or NIL :IF-DOES-NOT-EXIST - one of :ERROR, :CREATE or NIL See the manual for details.

PACKAGE-ERROR-PACKAGE (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

PAIRLIS (KEYS DATA &OPTIONAL (ALIST 'NIL))

Construct an association list from KEYS and DATA (adding to ALIST).

PARSE-INTEGER (STRING &KEY (START 0) END (RADIX 10) JUNK-ALLOWED)

Examine the substring of string delimited by start and end (default to the beginning and end of the string) It skips over whitespace characters and then tries to parse an integer. The radix parameter must be between 2 and 36.

PATHNAME (PATHSPEC)

Convert PATHSPEC (a pathname designator) into a pathname.

PATHNAME-DEVICE (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's device.

PATHNAME-DIRECTORY (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's directory.

PATHNAME-HOST (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's host.

PATHNAME-MATCH-P (IN-PATHNAME IN-WILDNAME)

Pathname matches the wildname template?

PATHNAME-NAME (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's name.

PATHNAME-TYPE (PATHNAME &KEY (CASE LOCAL))

Return PATHNAME's type.

PATHNAME-VERSION (PATHNAME)

Return PATHNAME's version.

PHASE (NUMBER)

Return the angle part of the polar representation of a complex number. For complex numbers, this is (atan (imagpart number) (realpart number)). For non-complex positive numbers, this is 0. For non-complex negative numbers this is PI.

PLUSP (NUMBER)

Is this real number strictly positive?

PPRINT (OBJECT &OPTIONAL STREAM)

Prettily output OBJECT preceded by a newline.

PPRINT-FILL (STREAM LIST &OPTIONAL (COLON? T) ATSIGN?)

Output LIST to STREAM putting :FILL conditional newlines between each element. If COLON? is NIL (defaults to T), then no parens are printed around the output. ATSIGN? is ignored (but allowed so that PPRINT-FILL can be used with the ~/.../ format directive.

PPRINT-INDENT (RELATIVE-TO N &OPTIONAL STREAM)

Specify the indentation to use in the current logical block if STREAM (which defaults to *STANDARD-OUTPUT*) is a pretty-printing stream and do nothing if not. (See PPRINT-LOGICAL-BLOCK.) N is the indentation to use (in ems, the width of an ``m'') and RELATIVE-TO can be either: :BLOCK - Indent relative to the column the current logical block started on. :CURRENT - Indent relative to the current column. The new indentation value does not take effect until the following line break.

PPRINT-LINEAR (STREAM LIST &OPTIONAL (COLON? T) ATSIGN?)

Output LIST to STREAM putting :LINEAR conditional newlines between each element. If COLON? is NIL (defaults to T), then no parens are printed around the output. ATSIGN? is ignored (but allowed so that PPRINT-LINEAR can be used with the ~/.../ format directive.

PPRINT-NEWLINE (KIND &OPTIONAL STREAM)

Output a conditional newline to STREAM (which defaults to *STANDARD-OUTPUT*) if it is a pretty-printing stream, and do nothing if not. KIND can be one of: :LINEAR - A line break is inserted if and only if the immediatly containing section cannot be printed on one line. :MISER - Same as LINEAR, but only if ``miser-style'' is in effect. (See *PRINT-MISER-WIDTH*.) :FILL - A line break is inserted if and only if either: (a) the following section cannot be printed on the end of the current line, (b) the preceding section was not printed on a single line, or (c) the immediately containing section cannot be printed on one line and miser-style is in effect. :MANDATORY - A line break is always inserted. When a line break is inserted by any type of conditional newline, any blanks that immediately precede the conditional newline are ommitted from the output and indentation is introduced at the beginning of the next line. (See PPRINT-INDENT.)

PPRINT-TAB (KIND COLNUM COLINC &OPTIONAL STREAM)

If STREAM (which defaults to *STANDARD-OUTPUT*) is a pretty-printing stream, perform tabbing based on KIND, otherwise do nothing. KIND can be one of: :LINE - Tab to column COLNUM. If already past COLNUM tab to the next multiple of COLINC. :SECTION - Same as :LINE, but count from the start of the current section, not the start of the line. :LINE-RELATIVE - Output COLNUM spaces, then tab to the next multiple of COLINC. :SECTION-RELATIVE - Same as :LINE-RELATIVE, but count from the start of the current section, not the start of the line.

PPRINT-TABULAR (STREAM LIST &OPTIONAL (COLON? T) ATSIGN? TABSIZE)

Output LIST to STREAM tabbing to the next column that is an even multiple of TABSIZE (which defaults to 16) between each element. :FILL style conditional newlines are also output between each element. If COLON? is NIL (defaults to T), then no parens are printed around the output. ATSIGN? is ignored (but allowed so that PPRINT-TABULAR can be used with the ~/.../ format directive.

PRIN1 (OBJECT &OPTIONAL STREAM)

Output a mostly READable printed representation of OBJECT on the specified STREAM.

PRIN1-TO-STRING (OBJECT)

Return the printed representation of OBJECT as a string with slashification on.

PRINC (OBJECT &OPTIONAL STREAM)

Output an aesthetic but not necessarily READable printed representation of OBJECT on the specified STREAM.

PRINC-TO-STRING (OBJECT)

Return the printed representation of OBJECT as a string with slashification off.

PRINT (OBJECT &OPTIONAL STREAM)

Output a newline, the mostly READable printed representation of OBJECT, and space to the specified STREAM.

PROBE-FILE (PATHSPEC)

Return the truename of PATHSPEC if the truename can be found, or NIL otherwise. See TRUENAME for more information.

PROGN (&REST FORMS)

PROGN form* Evaluates each FORM in order, returning the values of the last form. With no forms, returns NIL.

PROVIDE (MODULE-NAME)

Adds a new module name to *MODULES* indicating that it has been loaded. Module-name is a string designator

QUOTE (THING)

QUOTE value Return VALUE without evaluating it.

RASSOC (ITEM ALIST &KEY KEY (TEST NIL TESTP) (TEST-NOT NIL NOTP))

Return the cons in ALIST whose CDR is equal (by a given test or EQL) to the ITEM.

RASSOC-IF (PREDICATE ALIST &KEY KEY)

Return the first cons in ALIST whose CDR satisfies PREDICATE. If KEY is supplied, apply it to the CDR of each cons before testing.

RASSOC-IF-NOT (PREDICATE ALIST &KEY KEY)

Return the first cons in ALIST whose CDR does not satisfy PREDICATE. If KEY is supplied, apply it to the CDR of each cons before testing.

RATIONAL (X)

RATIONAL produces a rational number for any real numeric argument. This is more efficient than RATIONALIZE, but it assumes that floating-point is completely accurate, giving a result that isn't as pretty.

RATIONALIZE (X)

Converts any REAL to a RATIONAL. Floats are converted to a simple rational representation exploiting the assumption that floats are only accurate to their precision. RATIONALIZE (and also RATIONAL) preserve the invariant: (= x (float (rationalize x) x))

RATIONALP (OBJECT)

Return true if OBJECT is a RATIONAL, and NIL otherwise.

READ (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVE-P NIL))

Read the next Lisp value from STREAM, and return it.

READ-DELIMITED-LIST (ENDCHAR &OPTIONAL (INPUT-STREAM *STANDARD-INPUT*) RECURSIVE-P)

Read Lisp values from INPUT-STREAM until the next character after a value's representation is ENDCHAR, and return the objects as a list.

READ-FROM-STRING (STRING &OPTIONAL (EOF-ERROR-P T) EOF-VALUE &KEY (START 0) END PRESERVE-WHITESPACE)

The characters of string are successively given to the lisp reader and the lisp object built by the reader is returned. Macro chars will take effect.

READ-PRESERVING-WHITESPACE (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVE-P NIL))

Read from STREAM and return the value read, preserving any whitespace that followed the object.

READ-SEQUENCE (SEQ STREAM &KEY (START 0) END)

Destructively modify SEQ by reading elements from STREAM. That part of SEQ bounded by START and END is destructively modified by copying successive elements into it from STREAM. If the end of file for STREAM is reached before copying all elements of the subsequence, then the extra elements near the end of sequence are not updated, and the index of the next element is returned.

REALP (OBJECT)

Return true if OBJECT is a REAL, and NIL otherwise.

REALPART (NUMBER)

Extract the real part of a number.

REM (NUMBER DIVISOR)

Return second result of TRUNCATE.

REMHASH (KEY HASH-TABLE)

Remove the entry in HASH-TABLE associated with KEY. Return T if there was such an entry, or NIL if not.

REMPROP (SYMBOL INDICATOR)

Look on property list of SYMBOL for property with specified INDICATOR. If found, splice this indicator and its value out of the plist, and return the tail of the original list starting with INDICATOR. If not found, return () with no side effects. NOTE: The ANSI specification requires REMPROP to return true (not false) or false (the symbol NIL). Portable code should not rely on any other value.

RENAME-FILE (FILE NEW-NAME)

Rename FILE to have the specified NEW-NAME. If FILE is a stream open to a file, then the associated file is renamed.

RENAME-PACKAGE (PACKAGE-DESIGNATOR NAME &OPTIONAL (NICKNAMES NIL))

Changes the name and nicknames for a package.

REQUIRE (MODULE-NAME &OPTIONAL PATHNAMES)

Loads a module, unless it already has been loaded. PATHNAMES, if supplied, is a designator for a list of pathnames to be loaded if the module needs to be. If PATHNAMES is not supplied, functions from the list *MODULE-PROVIDER-FUNCTIONS* are called in order with MODULE-NAME as an argument, until one of them returns non-NIL. User code is responsible for calling PROVIDE to indicate a successful load of the module.

REST (LIST)

Means the same as the cdr of a list.

RESTART-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RETURN-FROM (NAME &OPTIONAL VALUE)

RETURN-FROM block-name value-form Evaluate the VALUE-FORM, returning its values from the lexically enclosing block BLOCK-NAME. This is constrained to be used only within the dynamic extent of the block.

REVAPPEND (X Y)

Return (append (reverse x) y).

REVERSE (SEQUENCE)

Return a new sequence containing the same elements but in reverse order.

ROOM (&OPTIONAL (VERBOSITY DEFAULT))

Print to *STANDARD-OUTPUT* information about the state of internal storage and its management. The optional argument controls the verbosity of output. If it is T, ROOM prints out a maximal amount of information. If it is NIL, ROOM prints out a minimal amount of information. If it is :DEFAULT or it is not supplied, ROOM prints out an intermediate amount of information.

ROUND (NUMBER &OPTIONAL (DIVISOR 1))

Rounds number (or number/divisor) to nearest integer. The second returned value is the remainder.

ROW-MAJOR-AREF (ARRAY INDEX)

Return the element of array corressponding to the row-major index. This is SETF'able.

RPLACA (CONS X)

Change the CAR of CONS to X and return the CONS.

RPLACD (CONS X)

Change the CDR of CONS to X and return the CONS.

SBIT (SIMPLE-BIT-ARRAY &REST SUBSCRIPTS)

Return the bit from SIMPLE-BIT-ARRAY at the specified SUBSCRIPTS.

SCALE-FLOAT (F EX)

Return the value (* f (expt (float 2 f) ex)), but with no unnecessary loss of precision or overflow.

SCHAR (STRING INDEX)

SCHAR returns the character object at an indexed position in a string just as CHAR does, except the string must be a simple-string.

SECOND (LIST)

Return the 2nd object in a list or NIL if there is no 2nd object.

SET (SYMBOL NEW-VALUE)

Set SYMBOL's value cell to NEW-VALUE.

SET-DIFFERENCE (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Return the elements of LIST1 which are not in LIST2.

SET-DISPATCH-MACRO-CHARACTER (DISP-CHAR SUB-CHAR FUNCTION &OPTIONAL (RT-DESIGNATOR *READTABLE*))

Cause FUNCTION to be called whenever the reader reads DISP-CHAR followed by SUB-CHAR.

SET-EXCLUSIVE-OR (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Return new list of elements appearing exactly once in LIST1 and LIST2.

SET-MACRO-CHARACTER (CHAR FUNCTION &OPTIONAL (NON-TERMINATINGP NIL) (RT-DESIGNATOR *READTABLE*))

Causes CHAR to be a macro character which invokes FUNCTION when seen by the reader. The NON-TERMINATINGP flag can be used to make the macro character non-terminating, i.e. embeddable in a symbol name.

SET-SYNTAX-FROM-CHAR (TO-CHAR FROM-CHAR &OPTIONAL (TO-READTABLE *READTABLE*) (FROM-READTABLE NIL))

Causes the syntax of TO-CHAR to be the same as FROM-CHAR in the optional readtable (defaults to the current readtable). The FROM-TABLE defaults to the standard Lisp readtable when NIL.

SEVENTH (LIST)

Return the 7th object in a list or NIL if there is no 7th object.

SHADOW (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Make an internal symbol in PACKAGE with the same name as each of the specified SYMBOLS. If a symbol with the given name is already present in PACKAGE, then the existing symbol is placed in the shadowing symbols list if it is not already present.

SHADOWING-IMPORT (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Import SYMBOLS into package, disregarding any name conflict. If a symbol of the same name is present, then it is uninterned.

SHORT-SITE-NAME

Return a string with the abbreviated site name, or NIL if not known.

SIGNAL (DATUM &REST ARGUMENTS)

Invokes the signal facility on a condition formed from DATUM and ARGUMENTS. If the condition is not handled, NIL is returned. If (TYPEP condition *BREAK-ON-SIGNALS*) is true, the debugger is invoked before any signalling is done.

SIGNUM (NUMBER)

If NUMBER is zero, return NUMBER, else return (/ NUMBER (ABS NUMBER)).

SIMPLE-BIT-VECTOR-P (OBJECT)

Return true if OBJECT is a SIMPLE-BIT-VECTOR, and NIL otherwise.

SIMPLE-CONDITION-FORMAT-ARGUMENTS (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

SIMPLE-CONDITION-FORMAT-CONTROL (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

SIMPLE-STRING-P (OBJECT)

Return true if OBJECT is a SIMPLE-STRING, and NIL otherwise.

SIMPLE-VECTOR-P (OBJECT)

Return true if OBJECT is a SIMPLE-VECTOR, and NIL otherwise.

SIN (NUMBER)

Return the sine of NUMBER.

SINH (NUMBER)

Return the hyperbolic sine of NUMBER.

SIXTH (LIST)

Return the 6th object in a list or NIL if there is no 6th object.

SLEEP (SECONDS)

This function causes execution to be suspended for SECONDS. SECONDS may be any non-negative real number.

SOFTWARE-TYPE

Return a string describing the supporting software.

SOFTWARE-VERSION

Return a string describing version of the supporting software, or NIL if not available.

SOME (PRED FIRST-SEQ &REST MORE-SEQS)

Apply PREDICATE to the 0-indexed elements of the sequences, then possibly to those with index 1, and so on. Return the first non-NIL value encountered, or NIL if the end of any sequence is reached.

SPECIAL-OPERATOR-P (SYMBOL)

If the symbol globally names a special form, return T, otherwise NIL.

SQRT (NUMBER)

Return the square root of NUMBER.

STANDARD-CHAR-P (CHAR)

The argument must be a character object. STANDARD-CHAR-P returns T if the argument is a standard character -- one of the 95 ASCII printing characters or <return>.

STORE-VALUE (VALUE &OPTIONAL CONDITION)

Transfer control and VALUE to a restart named STORE-VALUE, or return NIL if none exists.

STREAM-ERROR-STREAM (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

STRING (X)

Coerces X into a string. If X is a string, X is returned. If X is a symbol, X's pname is returned. If X is a character then a one element string containing that character is returned. If X cannot be coerced into a string, an error occurs.

STRING-EQUAL (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings (string1 and string2), and optional integers start1, start2, end1 and end2, compares characters in string1 to characters in string2 (using char-equal).

STRING-GREATERP (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is lexicographically greater than the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().

STRING-LESSP (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is lexicographically less than the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().

STRING-NOT-EQUAL (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is not lexicographically equal to the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().

STRING-NOT-GREATERP (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is lexicographically less than or equal to the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().

STRING-NOT-LESSP (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is lexicographically greater than or equal to the second string, returns the longest common prefix (using char-equal) of the two strings. Otherwise, returns ().

STRING/= (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is not lexicographically equal to the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().

STRING< (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is lexicographically less than the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().

STRING<= (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is lexicographically less than or equal to the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().

STRING= (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings (string1 and string2), and optional integers start1, start2, end1 and end2, compares characters in string1 to characters in string2 (using char=).

STRING> (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is lexicographically greater than the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().

STRING>= (STRING1 STRING2 &KEY (START1 0) END1 (START2 0) END2)

Given two strings, if the first string is lexicographically greater than or equal to the second string, returns the longest common prefix (using char=) of the two strings. Otherwise, returns ().

STRINGP (OBJECT)

Return true if OBJECT is a STRING, and NIL otherwise.

SUBLIS (ALIST TREE &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Substitute from ALIST into TREE nondestructively.

SUBSEQ (SEQ START &OPTIONAL END)

Return a copy of a subsequence of SEQUENCE starting with element number START and continuing to the end of SEQUENCE or the optional END.

SETFSUBSEQ (NEW-SUBSEQ SEQ START &OPTIONAL END)

Destructively replace the elements of SEQ between the bounding indices START and END with elements from NEW-SUBSEQ.

SUBSETP (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Return T if every element in LIST1 is also in LIST2.

SUBST (NEW OLD TREE &KEY KEY (TEST #'EQL TESTP) (TEST-NOT #'EQL NOTP))

Substitutes new for subtrees matching old.

SUBST-IF (NEW TEST TREE &KEY KEY)

Substitutes new for subtrees for which test is true.

SUBST-IF-NOT (NEW TEST TREE &KEY KEY)

Substitutes new for subtrees for which test is false.

SUBTYPEP (TYPE1 TYPE2 &OPTIONAL ENVIRONMENT)

Return two values indicating the relationship between type1 and type2. If values are T and T, type1 definitely is a subtype of type2. If values are NIL and T, type1 definitely is not a subtype of type2. If values are NIL and NIL, it couldn't be determined.

SVREF (SIMPLE-VECTOR INDEX)

Return the INDEX'th element of the given Simple-Vector.

SYMBOL-FUNCTION (SYMBOL)

Return SYMBOL's current function definition. Settable with SETF.

SYMBOL-MACROLET (MACROBINDINGS &BODY BODY)

SYMBOL-MACROLET ({(name expansion)}*) decl* form* Define the NAMES as symbol macros with the given EXPANSIONS. Within the body, references to a NAME will effectively be replaced with the EXPANSION.

SYMBOL-NAME (SYMBOL)

Return SYMBOL's name as a string.

SYMBOL-PACKAGE (SYMBOL)

Return the package SYMBOL was interned in, or NIL if none.

SYMBOL-PLIST (SYMBOL)

Return SYMBOL's property list.

SYMBOL-VALUE (SYMBOL)

Return SYMBOL's current bound value.

SYMBOLP (OBJECT)

Return true if OBJECT is a SYMBOL, and NIL otherwise.

SYNONYM-STREAM-SYMBOL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TAGBODY (&REST STATEMENTS)

TAGBODY {tag | statement}* Define tags for use with GO. The STATEMENTS are evaluated in order, skipping TAGS, and NIL is returned. If a statement contains a GO to a defined TAG within the lexical scope of the form, then control is transferred to the next statement following that tag. A TAG must be an integer or a symbol. A STATEMENT must be a list. Other objects are illegal within the body.

TAILP (OBJECT LIST)

Return true if OBJECT is the same as some tail of LIST, otherwise returns false. LIST must be a proper list or a dotted list.

TAN (NUMBER)

Return the tangent of NUMBER.

TANH (NUMBER)

Return the hyperbolic tangent of NUMBER.

TENTH (LIST)

Return the 10th object in a list or NIL if there is no 10th object.

THE (VALUE-TYPE FORM)

Specifies that the values returned by FORM conform to the VALUE-TYPE. CLHS specifies that the consequences are undefined if any result is not of the declared type, but SBCL treats declarations as assertions as long as SAFETY is at least 2, in which case incorrect type information will result in a runtime type-error instead of leading to eg. heap corruption. This is however expressly non-portable: use CHECK-TYPE instead of THE to catch type-errors at runtime. THE is best considered an optimization tool to inform the compiler about types it is unable to derive from other declared types.

THIRD (LIST)

Return the 3rd object in a list or NIL if there is no 3rd object.

THROW (TAG RESULT)

THROW tag form Do a non-local exit, return the values of FORM from the CATCH whose tag is EQ to TAG.

TRANSLATE-LOGICAL-PATHNAME (PATHNAME &KEY)

Translate PATHNAME to a physical pathname, which is returned.

TRANSLATE-PATHNAME (SOURCE FROM-WILDNAME TO-WILDNAME &KEY)

Use the source pathname to translate the from-wildname's wild and unspecified elements into a completed to-pathname based on the to-wildname.

TREE-EQUAL (X Y &KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Return T if X and Y are isomorphic trees with identical leaves.

TRUENAME (PATHSPEC)

If PATHSPEC is a pathname that names an existing file, return a pathname that denotes a canonicalized name for the file. If pathspec is a stream associated with a file, return a pathname that denotes a canonicalized name for the file associated with the stream. An error of type FILE-ERROR is signalled if no such file exists or if the file system is such that a canonicalized file name cannot be determined or if the pathname is wild. Under Unix, the TRUENAME of a symlink that links to itself or to a file that doesn't exist is considered to be the name of the broken symlink itself.

TRUNCATE (NUMBER &OPTIONAL (DIVISOR 1))

Return number (or number/divisor) as an integer, rounded toward 0. The second returned value is the remainder.

TWO-WAY-STREAM-INPUT-STREAM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TWO-WAY-STREAM-OUTPUT-STREAM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

TYPE-ERROR-DATUM (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

TYPE-ERROR-EXPECTED-TYPE (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

TYPE-OF (OBJECT)

Return the type of OBJECT.

TYPEP (OBJECT TYPE &OPTIONAL ENVIRONMENT)

Is OBJECT of type TYPE?

UNBOUND-SLOT-INSTANCE (CONDITION)

Return the offending thread that the THREAD-ERROR pertains to.

UNEXPORT (SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Makes SYMBOLS no longer exported from PACKAGE.

UNINTERN (SYMBOL &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Makes SYMBOL no longer present in PACKAGE. If SYMBOL was present then T is returned, otherwise NIL. If PACKAGE is SYMBOL's home package, then it is made uninterned.

UNION (LIST1 LIST2 &KEY KEY (TEST #'EQL TESTP) (TEST-NOT NIL NOTP))

Return the union of LIST1 and LIST2.

UNUSE-PACKAGE (PACKAGES-TO-UNUSE &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Remove PACKAGES-TO-UNUSE from the USE list for PACKAGE.

UNWIND-PROTECT (PROTECTED &BODY CLEANUP)

UNWIND-PROTECT protected cleanup* Evaluate the form PROTECTED, returning its values. The CLEANUP forms are evaluated whenever the dynamic scope of the PROTECTED form is exited (either due to normal completion or a non-local exit such as THROW).

UPGRADED-ARRAY-ELEMENT-TYPE (SPEC &OPTIONAL ENVIRONMENT)

Return the element type that will actually be used to implement an array with the specifier :ELEMENT-TYPE Spec.

UPGRADED-COMPLEX-PART-TYPE (SPEC &OPTIONAL ENVIRONMENT)

Return the element type of the most specialized COMPLEX number type that can hold parts of type SPEC.

UPPER-CASE-P (CHAR)

The argument must be a character object; UPPER-CASE-P returns T if the argument is an upper-case character, NIL otherwise.

USE-PACKAGE (PACKAGES-TO-USE &OPTIONAL (PACKAGE (SANE-PACKAGE)))

Add all the PACKAGES-TO-USE to the use list for PACKAGE so that the external symbols of the used packages are accessible as internal symbols in PACKAGE.

USE-VALUE (VALUE &OPTIONAL CONDITION)

Transfer control and VALUE to a restart named USE-VALUE, or return NIL if none exists.

USER-HOMEDIR-PATHNAME (&OPTIONAL HOST)

Return the home directory of the user as a pathname. If the HOME environment variable has been specified, the directory it designates is returned; otherwise obtains the home directory from the operating system. HOST argument is ignored by SBCL.

VALUES (&REST VALUES)

Return all arguments, in order, as values.

VALUES-LIST (LIST)

Return all of the elements of LIST, in order, as values.

VECTOR (&REST OBJECTS)

Construct a SIMPLE-VECTOR from the given objects.

VECTOR-POP (ARRAY)

Decrease the fill pointer by 1 and return the element pointed to by the new fill pointer.

VECTOR-PUSH (NEW-EL ARRAY)

Attempt to set the element of ARRAY designated by its fill pointer to NEW-EL, and increment the fill pointer by one. If the fill pointer is too large, NIL is returned, otherwise the index of the pushed element is returned.

VECTORP (OBJECT)

Return true if OBJECT is a VECTOR, and NIL otherwise.

WARN (DATUM &REST ARGUMENTS)

Warn about a situation by signalling a condition formed by DATUM and ARGUMENTS. While the condition is being signaled, a MUFFLE-WARNING restart exists that causes WARN to immediately return NIL.

WILD-PATHNAME-P (PATHNAME &OPTIONAL FIELD-KEY)

Predicate for determining whether pathname contains any wildcards.

WRITE (OBJECT &KEY ((STREAM STREAM) *STANDARD-OUTPUT*) ((ESCAPE *PRINT-ESCAPE*) *PRINT-ESCAPE*) ((RADIX *PRINT-RADIX*) *PRINT-RADIX*) ((BASE *PRINT-BASE*) *PRINT-BASE*) ((CIRCLE *PRINT-CIRCLE*) *PRINT-CIRCLE*) ((PRETTY *PRINT-PRETTY*) *PRINT-PRETTY*) ((LEVEL *PRINT-LEVEL*) *PRINT-LEVEL*) ((LENGTH *PRINT-LENGTH*) *PRINT-LENGTH*) ((CASE *PRINT-CASE*) *PRINT-CASE*) ((ARRAY *PRINT-ARRAY*) *PRINT-ARRAY*) ((GENSYM *PRINT-GENSYM*) *PRINT-GENSYM*) ((READABLY *PRINT-READABLY*) *PRINT-READABLY*) ((RIGHT-MARGIN *PRINT-RIGHT-MARGIN*) *PRINT-RIGHT-MARGIN*) ((MISER-WIDTH *PRINT-MISER-WIDTH*) *PRINT-MISER-WIDTH*) ((LINES *PRINT-LINES*) *PRINT-LINES*) ((PPRINT-DISPATCH *PRINT-PPRINT-DISPATCH*) *PRINT-PPRINT-DISPATCH*) ((SUPPRESS-ERRORS *SUPPRESS-PRINT-ERRORS*) *SUPPRESS-PRINT-ERRORS*))

Output OBJECT to the specified stream, defaulting to *STANDARD-OUTPUT*.

WRITE-SEQUENCE (SEQ STREAM &KEY (START 0) (END NIL))

Write the elements of SEQ bounded by START and END to STREAM.

WRITE-TO-STRING (OBJECT &KEY ((ESCAPE *PRINT-ESCAPE*) *PRINT-ESCAPE*) ((RADIX *PRINT-RADIX*) *PRINT-RADIX*) ((BASE *PRINT-BASE*) *PRINT-BASE*) ((CIRCLE *PRINT-CIRCLE*) *PRINT-CIRCLE*) ((PRETTY *PRINT-PRETTY*) *PRINT-PRETTY*) ((LEVEL *PRINT-LEVEL*) *PRINT-LEVEL*) ((LENGTH *PRINT-LENGTH*) *PRINT-LENGTH*) ((CASE *PRINT-CASE*) *PRINT-CASE*) ((ARRAY *PRINT-ARRAY*) *PRINT-ARRAY*) ((GENSYM *PRINT-GENSYM*) *PRINT-GENSYM*) ((READABLY *PRINT-READABLY*) *PRINT-READABLY*) ((RIGHT-MARGIN *PRINT-RIGHT-MARGIN*) *PRINT-RIGHT-MARGIN*) ((MISER-WIDTH *PRINT-MISER-WIDTH*) *PRINT-MISER-WIDTH*) ((LINES *PRINT-LINES*) *PRINT-LINES*) ((PPRINT-DISPATCH *PRINT-PPRINT-DISPATCH*) *PRINT-PPRINT-DISPATCH*) ((SUPPRESS-ERRORS *SUPPRESS-PRINT-ERRORS*) *SUPPRESS-PRINT-ERRORS*))

Return the printed representation of OBJECT as a string.

Y-OR-N-P (&OPTIONAL FORMAT-STRING &REST ARGUMENTS)

Y-OR-N-P prints the message, if any, and reads characters from *QUERY-IO* until the user enters y or Y as an affirmative, or either n or N as a negative answer. It asks again if you enter any other characters.

YES-OR-NO-P (&OPTIONAL FORMAT-STRING &REST ARGUMENTS)

YES-OR-NO-P is similar to Y-OR-N-P, except that it clears the input buffer, beeps, and uses READ-LINE to get the strings YES or NO.

ZEROP (NUMBER)

Is this number zero?

Undocumented

SETFAREF (NEW-VALUE ARRAY &REST SUBSCRIPTS)

ARRAY-ROW-MAJOR-INDEX (ARRAY &REST SUBSCRIPTS)

SETFBIT (NEW-VALUE BIT-ARRAY &REST SUBSCRIPTS)

BUTLAST (LIST &OPTIONAL (N 1))

SETFCAAAAR (G4 G5)

SETFCAAADR (G6 G7)

SETFCAAAR (G8 G9)

SETFCAADAR (G10 G11)

SETFCAADDR (G12 G13)

SETFCAADR (G14 G15)

SETFCAAR (G16 G17)

SETFCADAAR (G18 G19)

SETFCADADR (G20 G21)

SETFCADAR (G22 G23)

SETFCADDAR (G24 G25)

SETFCADDDR (G26 G27)

SETFCADDR (G28 G29)

SETFCADR (G30 G31)

SETFCAR (G32 G33)

SETFCDAAAR (G34 G35)

SETFCDAADR (G36 G37)

SETFCDAAR (G38 G39)

SETFCDADAR (G40 G41)

SETFCDADDR (G42 G43)

SETFCDADR (G44 G45)

SETFCDAR (G46 G47)

SETFCDDAAR (G48 G49)

SETFCDDADR (G50 G51)

SETFCDDAR (G52 G53)

SETFCDDDAR (G54 G55)

SETFCDDDDR (G56 G57)

SETFCDDDR (G58 G59)

SETFCDDR (G60 G61)

SETFCDR (G62 G63)

CERROR (CONTINUE-STRING DATUM &REST ARGUMENTS)

SETFCHAR (G64 G65 G66)

CLASS-OF (X)

CLEAR-INPUT (&OPTIONAL (STREAM *STANDARD-INPUT*))

CLEAR-OUTPUT (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

SETFCOMPILER-MACRO-FUNCTION (FUNCTION NAME &OPTIONAL ENV)

CONCATENATE (RESULT-TYPE &REST SEQUENCES)

SETFCONCATENATED-STREAM-STREAMS (NEW-VALUE INSTANCE)

COPY-PPRINT-DISPATCH (&OPTIONAL (TABLE *PRINT-PPRINT-DISPATCH*))

COPY-READTABLE (&OPTIONAL (FROM-READTABLE *READTABLE*) TO-READTABLE)

DELETE (ITEM SEQUENCE &KEY FROM-END (TEST #'EQL) TEST-NOT (START 0) END (KEY #'IDENTITY))

DELETE-DUPLICATES (SEQUENCE &KEY FROM-END (TEST #'EQL) TEST-NOT (START 0) END (KEY #'IDENTITY))

DELETE-IF (PREDICATE SEQUENCE &KEY FROM-END (START 0) END (KEY #'IDENTITY))

DELETE-IF-NOT (PREDICATE SEQUENCE &KEY FROM-END (START 0) END (KEY #'IDENTITY))

DROP-WHILE (PREDICATE SEQUENCE &KEY KEY (START 0) END FROM-END RESULT-TYPE)

SETFEIGHTH (G67 G68)

ENSURE-GENERIC-FUNCTION (FUN-NAME &REST ALL-KEYS &KEY ENVIRONMENT DEFINITION-SOURCE &ALLOW-OTHER-KEYS)

EQL (X Y)

EQUALP (X Y)

SETFFDEFINITION (G72 G73)

SETFFIFTH (G74 G75)

FILE-LENGTH (STREAM)

FILE-POSITION (STREAM &OPTIONAL POSITION)

FILE-STRING-LENGTH (STREAM OBJECT)

FILL (SEQUENCE ITEM &KEY (START 0) END)

SETFFILL-POINTER (G76 G77)

FIND-CLASS (SYMBOL &OPTIONAL (ERRORP T) ENVIRONMENT)

SETFFIND-CLASS (NEW-VALUE NAME &OPTIONAL ERRORP ENVIRONMENT)

FIND-PACKAGE (PACKAGE-DESIGNATOR)

FINISH-OUTPUT (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

SETFFIRST (G78 G79)

FLOAT-DIGITS (F)

FORCE-OUTPUT (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

SETFFOURTH (G80 G81)

FRESH-LINE (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

GET-OUTPUT-STREAM-STRING (STREAM)

SETFGETHASH (NEW-VALUE KEY TABLE &OPTIONAL DEFAULT)

HASH-TABLE-P (OBJECT)

INSPECT (OBJECT)

INVALID-METHOD-ERROR (METHOD FORMAT-CONTROL &REST FORMAT-ARGUMENTS)

SETFLDB (G82 G83 G84)

LISP-IMPLEMENTATION-TYPE

LISP-IMPLEMENTATION-VERSION

LISTEN (&OPTIONAL (STREAM *STANDARD-INPUT*))

SETFMACRO-FUNCTION (FUNCTION SYMBOL &OPTIONAL ENVIRONMENT)

MAKE-ARRAY (DIMENSIONS &KEY (ELEMENT-TYPE T) (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (INITIAL-CONTENTS NIL INITIAL-CONTENTS-P) ADJUSTABLE FILL-POINTER DISPLACED-TO DISPLACED-INDEX-OFFSET)

MAKE-BROADCAST-STREAM (&REST STREAMS)

MAKE-LOAD-FORM-SAVING-SLOTS (OBJECT &KEY (SLOT-NAMES NIL SLOT-NAMES-P) ENVIRONMENT)

MAKE-SEQUENCE (RESULT-TYPE SIZE &KEY (INITIAL-ELEMENT NIL IEP))

MAKE-SYNONYM-STREAM (SYMBOL)

MAP (RESULT-TYPE FUNCTION &REST SEQUENCES)

MAP-INTO (RESULT-SEQUENCE FUNCTION &REST SEQUENCES)

MAP-INTO-SUBSEQ (SEQUENCE FUNCTION &KEY START END FROM-END KEY)

SETFMASK-FIELD (G85 G86 G87)

MERGE (RESULT-TYPE SEQUENCE1 SEQUENCE2 PREDICATE &KEY (KEY #'IDENTITY))

METHOD-COMBINATION-ERROR (FORMAT-CONTROL &REST FORMAT-ARGUMENTS)

MISMATCH (SEQUENCE1 SEQUENCE2 &KEY FROM-END (TEST #'EQL) TEST-NOT (KEY #'IDENTITY) (START1 0) (START2 0) END1 END2)

NBUTLAST (LIST &OPTIONAL (N 1))

SETFNINTH (G88 G89)

NSTRING-CAPITALIZE (STRING &KEY (START 0) END)

NSTRING-DOWNCASE (STRING &KEY (START 0) END)

NSTRING-UPCASE (STRING &KEY (START 0) END)

NSUBSTITUTE (NEW OLD SEQUENCE &KEY FROM-END (TEST #'EQL) TEST-NOT (START 0) END COUNT (KEY #'IDENTITY))

NSUBSTITUTE-IF (NEW PREDICATE SEQUENCE &KEY FROM-END (START 0) END COUNT (KEY #'IDENTITY))

NSUBSTITUTE-IF-NOT (NEW PREDICATE SEQUENCE &KEY FROM-END (START 0) END COUNT (KEY #'IDENTITY))

SETFNTH (G90 G91 G92)

PACKAGE-NAME (PACKAGE-DESIGNATOR)

PACKAGE-NICKNAMES (PACKAGE-DESIGNATOR)

PACKAGE-SHADOWING-SYMBOLS (PACKAGE-DESIGNATOR)

PACKAGE-USE-LIST (PACKAGE-DESIGNATOR)

PACKAGE-USED-BY-LIST (PACKAGE-DESIGNATOR)

PACKAGEP (OBJECT)

PARSE-NAMESTRING (THING &OPTIONAL HOST (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*) &KEY (START 0) END JUNK-ALLOWED)

PATHNAMEP (OBJECT)

PEEK-CHAR (&OPTIONAL (PEEK-TYPE NIL) (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)

POSITION (ITEM SEQUENCE &KEY FROM-END (TEST #'EQL) TEST-NOT (START 0) END (KEY #'IDENTITY))

POSITION-IF (PREDICATE SEQUENCE &KEY FROM-END (START 0) END (KEY #'IDENTITY))

POSITION-IF-NOT (ITEM SEQUENCE &KEY FROM-END (START 0) END (KEY #'IDENTITY))

PPRINT-DISPATCH (OBJECT &OPTIONAL (TABLE *PRINT-PPRINT-DISPATCH*))

PROCLAIM (RAW-FORM)

PROGV (VARS VALS &BODY BODY)

RANDOM (ARG &OPTIONAL (STATE *RANDOM-STATE*))

RANDOM-STATE-P (OBJECT)

READ-BYTE (STREAM &OPTIONAL (EOF-ERROR-P T) EOF-VALUE)

READ-CHAR (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)

READ-CHAR-NO-HANG (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)

READ-LINE (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)

READTABLE-CASE (READTABLE)

SETFREADTABLE-CASE (CASE READTABLE)

READTABLEP (OBJECT)

REDUCE (FUNCTION SEQUENCE &KEY (KEY #'IDENTITY) FROM-END (START 0) END INITIAL-VALUE)

REMOVE (ITEM SEQUENCE &KEY FROM-END (TEST #'EQL) TEST-NOT (START 0) END (KEY #'IDENTITY))

REMOVE-DUPLICATES (SEQUENCE &KEY FROM-END (TEST #'EQL) TEST-NOT (START 0) END (KEY #'IDENTITY))

REMOVE-IF (PREDICATE SEQUENCE &KEY FROM-END (START 0) END (KEY #'IDENTITY))

REMOVE-IF-NOT (PREDICATE SEQUENCE &KEY FROM-END (START 0) END (KEY #'IDENTITY))

REPLACE (SEQUENCE1 SEQUENCE2 &KEY (START1 0) END1 (START2 0) END2)

SETFREST (G93 G94)

SETFROW-MAJOR-AREF (G95 G96 G97)

SETFSBIT (NEW-VALUE BIT-ARRAY &REST SUBSCRIPTS)

SETFSCHAR (G98 G99 G100)

SETFSECOND (G101 G102)

SET-PPRINT-DISPATCH (TYPE FUNCTION &OPTIONAL (PRIORITY 0) (TABLE *PRINT-PPRINT-DISPATCH*))

SETQ (&WHOLE SOURCE &REST THINGS)

SETFSEVENTH (G103 G104)

SETFSIXTH (G105 G106)

SLOT-BOUNDP (OBJECT SLOT-NAME)

SLOT-EXISTS-P (OBJECT SLOT-NAME)

SLOT-MAKUNBOUND (OBJECT SLOT-NAME)

SLOT-VALUE (OBJECT SLOT-NAME)

SORT (SEQUENCE PREDICATE &KEY (KEY #'IDENTITY))

SPLIT-SEQUENCE (ITEM SEQUENCE &KEY (START 0) END FROM-END KEY TEST TEST-NOT)

STABLE-SORT (SEQUENCE PREDICATE &KEY (KEY #'IDENTITY))

STREAM-EXTERNAL-FORMAT (STREAM)

STREAMP (STREAM)

STRING-CAPITALIZE (STRING &KEY (START 0) END)

STRING-DOWNCASE (STRING &KEY (START 0) END)

STRING-LEFT-TRIM (CHAR-BAG STRING)

STRING-RIGHT-TRIM (CHAR-BAG STRING)

STRING-TRIM (CHAR-BAG STRING)

STRING-UPCASE (STRING &KEY (START 0) END)

SUBSTITUTE (NEW OLD SEQUENCE &KEY FROM-END (TEST #'EQL) TEST-NOT (START 0) END COUNT (KEY #'IDENTITY))

SUBSTITUTE-IF (NEW PREDICATE SEQUENCE &KEY FROM-END (START 0) END COUNT (KEY #'IDENTITY))

SUBSTITUTE-IF-NOT (NEW PREDICATE SEQUENCE &KEY FROM-END (START 0) END COUNT (KEY #'IDENTITY))

SETFSVREF (G107 G108 G109)

SXHASH (X)

SETFSYMBOL-FUNCTION (NEW-VALUE SYMBOL)

SETFSYMBOL-PLIST (G110 G111)

SETFSYMBOL-VALUE (G112 G113)

TAKE-WHILE (PREDICATE SEQUENCE &KEY KEY (START 0) END FROM-END RESULT-TYPE)

SETFTENTH (G114 G115)

TERPRI (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

SETFTHIRD (G116 G117)

UNREAD-CHAR (CHARACTER &OPTIONAL (STREAM *STANDARD-INPUT*))

VECTOR-PUSH-EXTEND (NEW-ELEMENT VECTOR &OPTIONAL (MIN-EXTENSION (LET ((LENGTH (LENGTH VECTOR))) (MIN (1+ LENGTH) (- ARRAY-DIMENSION-LIMIT LENGTH)))))

WRITE-BYTE (INTEGER STREAM)

WRITE-CHAR (CHARACTER &OPTIONAL (STREAM *STANDARD-OUTPUT*))

WRITE-LINE (STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (START 0) END)

WRITE-STRING (STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (START 0) END)

MACRO

Public

ASSERT (TEST-FORM &OPTIONAL PLACES DATUM &REST ARGUMENTS)

Signals an error if the value of test-form is nil. Continuing from this error using the CONTINUE restart will allow the user to alter the value of some locations known to SETF, starting over with test-form. Returns NIL.

CASE (KEYFORM &BODY CASES)

CASE Keyform {({(Key*) | Key} Form*)}* Evaluates the Forms in the first clause with a Key EQL to the value of Keyform. If a singleton key is T then the clause is a default clause.

CCASE (KEYFORM &BODY CASES)

CCASE Keyform {({(Key*) | Key} Form*)}* Evaluates the Forms in the first clause with a Key EQL to the value of Keyform. If none of the keys matches then a correctable error is signalled.

CHECK-TYPE (PLACE TYPE &OPTIONAL TYPE-STRING &ENVIRONMENT ENV)

Signal a restartable error of type TYPE-ERROR if the value of PLACE is not of the specified type. If an error is signalled and the restart is used to return, this can only return if the STORE-VALUE restart is invoked. In that case it will store into PLACE and start over.

CTYPECASE (KEYFORM &BODY CASES)

CTYPECASE Keyform {(Type Form*)}* Evaluates the Forms in the first clause for which TYPEP of Keyform and Type is true. If no form is satisfied then a correctable error is signalled.

DECF (PLACE &OPTIONAL (DELTA 1) &ENVIRONMENT ENV)

The first argument is some location holding a number. This number is decremented by the second argument, DELTA, which defaults to 1.

DECLAIM (&REST SPECS)

DECLAIM Declaration* Do a declaration or declarations for the global environment.

DEFCONSTANT (NAME VALUE &OPTIONAL DOCUMENTATION)

Define a global constant, saying that the value is constant and may be compiled into code. If the variable already has a value, and this is not EQL to the new value, the code is not portable (undefined behavior). The third argument is an optional documentation string for the variable.

DEFINE-COMPILER-MACRO (NAME LAMBDA-LIST &BODY BODY)

Define a compiler-macro for NAME.

DEFINE-CONDITION (NAME (&REST PARENT-TYPES) (&REST SLOT-SPECS) &BODY OPTIONS)

DEFINE-CONDITION Name (Parent-Type*) (Slot-Spec*) Option* Define NAME as a condition type. This new type inherits slots and its report function from the specified PARENT-TYPEs. A slot spec is a list of: (slot-name :reader <rname> :initarg <iname> {Option Value}* The DEFINE-CLASS slot options :ALLOCATION, :INITFORM, [slot] :DOCUMENTATION and :TYPE and the overall options :DEFAULT-INITARGS and [type] :DOCUMENTATION are also allowed. The :REPORT option is peculiar to DEFINE-CONDITION. Its argument is either a string or a two-argument lambda or function name. If a function, the function is called with the condition and stream to report the condition. If a string, the string is printed. Condition types are classes, but (as allowed by ANSI and not as described in CLtL2) are neither STANDARD-OBJECTs nor STRUCTURE-OBJECTs. WITH-SLOTS and SLOT-VALUE may not be used on condition objects.

DEFINE-MODIFY-MACRO (NAME LAMBDA-LIST FUNCTION &OPTIONAL DOC-STRING)

Creates a new read-modify-write macro like PUSH or INCF.

DEFINE-SETF-EXPANDER (ACCESS-FN LAMBDA-LIST &BODY BODY)

Syntax like DEFMACRO, but creates a setf expander function. The body of the definition must be a form that returns five appropriate values.

DEFPACKAGE (PACKAGE &REST OPTIONS)

Defines a new package called PACKAGE. Each of OPTIONS should be one of the following: (NICKNAMES {package-name}*) (SIZE <integer>) (SHADOW {symbol-name}*) (SHADOWING-IMPORT-FROM <package-name> {symbol-name}*) (USE {package-name}*) (IMPORT-FROM <package-name> {symbol-name}*) (INTERN {symbol-name}*) (EXPORT {symbol-name}*) (IMPLEMENT {package-name}*) (LOCK boolean) (DOCUMENTATION doc-string) All options except SIZE, LOCK, and :DOCUMENTATION can be used multiple times.

DEFPARAMETER (VAR VAL &OPTIONAL (DOC NIL DOCP))

Define a parameter that is not normally changed by the program, but that may be changed without causing an error. Declare the variable special and sets its value to VAL, overwriting any previous value. The third argument is an optional documentation string for the parameter.

DEFSETF (ACCESS-FN &REST REST)

Associates a SETF update function or macro with the specified access function or macro. The format is complex. See the manual for details.

DEFSTRUCT (NAME-AND-OPTIONS &REST SLOT-DESCRIPTIONS)

DEFSTRUCT {Name | (Name Option*)} {Slot | (Slot [Default] {Key Value}*)} Define the structure type Name. Instances are created by MAKE-<name>, which takes &KEY arguments allowing initial slot values to the specified. A SETF'able function <name>-<slot> is defined for each slot to read and write slot values. <name>-p is a type predicate. Popular DEFSTRUCT options (see manual for others): (:CONSTRUCTOR Name) (:PREDICATE Name) Specify the name for the constructor or predicate. (:CONSTRUCTOR Name Lambda-List) Specify the name and arguments for a BOA constructor (which is more efficient when keyword syntax isn't necessary.) (:INCLUDE Supertype Slot-Spec*) Make this type a subtype of the structure type Supertype. The optional Slot-Specs override inherited slot options. Slot options: :TYPE Type-Spec Asserts that the value of this slot is always of the specified type. :READ-ONLY {T | NIL} If true, no setter function is defined for this slot.

DEFTYPE (&WHOLE FORM NAME LAMBDA-LIST &BODY BODY)

Define a new type, with syntax like DEFMACRO.

DEFUN (&ENVIRONMENT ENV NAME ARGS &BODY BODY)

Define a function at top level.

DEFVAR (VAR &OPTIONAL (VAL NIL VALP) (DOC NIL DOCP))

Define a special variable at top level. Declare the variable SPECIAL and, optionally, initialize it. If the variable already has a value, the old value is not clobbered. The third argument is an optional documentation string for the variable.

DESTRUCTURING-BIND (LAMBDA-LIST EXPRESSION &BODY BODY)

Bind the variables in LAMBDA-LIST to the corresponding values in the tree structure resulting from the evaluation of EXPRESSION.

DO (VARLIST ENDLIST &BODY BODY)

DO ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* Iteration construct. Each Var is initialized in parallel to the value of the specified Init form. On subsequent iterations, the Vars are assigned the value of the Step form (if any) in parallel. The Test is evaluated before each evaluation of the body Forms. When the Test is true, the Exit-Forms are evaluated as a PROGN, with the result being the value of the DO. A block named NIL is established around the entire expansion, allowing RETURN to be used as an alternate exit mechanism.

DO* (VARLIST ENDLIST &BODY BODY)

DO* ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* Iteration construct. Each Var is initialized sequentially (like LET*) to the value of the specified Init form. On subsequent iterations, the Vars are sequentially assigned the value of the Step form (if any). The Test is evaluated before each evaluation of the body Forms. When the Test is true, the Exit-Forms are evaluated as a PROGN, with the result being the value of the DO. A block named NIL is established around the entire expansion, allowing RETURN to be used as an laternate exit mechanism.

DO-ALL-SYMBOLS ((VAR &OPTIONAL RESULT-FORM) &BODY BODY-DECLS)

DO-ALL-SYMBOLS (VAR [RESULT-FORM]) {DECLARATION}* {TAG | FORM}* Executes the FORMs once for each symbol in every package with VAR bound to the current symbol.

DO-EXTERNAL-SYMBOLS ((VAR &OPTIONAL (PACKAGE '*PACKAGE*) RESULT-FORM) &BODY BODY-DECLS)

DO-EXTERNAL-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECL}* {TAG | FORM}* Executes the FORMs once for each external symbol in the given PACKAGE with VAR bound to the current symbol.

DO-SYMBOLS ((VAR &OPTIONAL (PACKAGE '*PACKAGE*) RESULT-FORM) &BODY BODY-DECLS)

DO-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECLARATION}* {TAG | FORM}* Executes the FORMs at least once for each symbol accessible in the given PACKAGE with VAR bound to the current symbol.

ECASE (KEYFORM &BODY CASES)

ECASE Keyform {({(Key*) | Key} Form*)}* Evaluates the Forms in the first clause with a Key EQL to the value of Keyform. If none of the keys matches then an error is signalled.

ETYPECASE (KEYFORM &BODY CASES)

ETYPECASE Keyform {(Type Form*)}* Evaluates the Forms in the first clause for which TYPEP of Keyform and Type is true. If no form is satisfied then an error is signalled.

HANDLER-BIND (BINDINGS &BODY FORMS)

(HANDLER-BIND ( {(type handler)}* ) body) Executes body in a dynamic context where the given handler bindings are in effect. Each handler must take the condition being signalled as an argument. The bindings are searched first to last in the event of a signalled condition.

HANDLER-CASE (FORM &REST CASES)

(HANDLER-CASE form { (type ([var]) body) }* ) Execute FORM in a context with handlers established for the condition types. A peculiar property allows type to be :NO-ERROR. If such a clause occurs, and form returns normally, all its values are passed to this clause as if by MULTIPLE-VALUE-CALL. The :NO-ERROR clause accepts more than one var specification.

IGNORE-ERRORS (&REST FORMS)

Execute FORMS handling ERROR conditions, returning the result of the last form, or (VALUES NIL the-ERROR-that-was-caught) if an ERROR was handled.

INCF (PLACE &OPTIONAL (DELTA 1) &ENVIRONMENT ENV)

The first argument is some location holding a number. This number is incremented by the second argument, DELTA, which defaults to 1.

LOOP-FINISH

Cause the iteration to terminate "normally", the same as implicit termination by an iteration driving clause, or by use of WHILE or UNTIL -- the epilogue code (if any) will be run, and any implicitly collected result will be returned as the value of the LOOP.

NTH-VALUE (N FORM)

Evaluate FORM and return the Nth value (zero based). This involves no consing when N is a trivial constant integer.

POP (PLACE &ENVIRONMENT ENV)

The argument is a location holding a list. Pops one item off the front of the list and returns it.

PPRINT-EXIT-IF-LIST-EXHAUSTED

Cause the closest enclosing use of PPRINT-LOGICAL-BLOCK to return if its list argument is exhausted. Can only be used inside PPRINT-LOGICAL-BLOCK, and only when the LIST argument to PPRINT-LOGICAL-BLOCK is supplied.

PPRINT-LOGICAL-BLOCK ((STREAM-SYMBOL OBJECT &KEY (PREFIX NIL PREFIXP) (PER-LINE-PREFIX NIL PER-LINE-PREFIX-P) (SUFFIX SUFFIXP)) &BODY BODY)

Group some output into a logical block. STREAM-SYMBOL should be either a stream, T (for *TERMINAL-IO*), or NIL (for *STANDARD-OUTPUT*). The printer control variable *PRINT-LEVEL* is automatically handled.

PPRINT-POP

Return the next element from LIST argument to the closest enclosing use of PPRINT-LOGICAL-BLOCK, automatically handling *PRINT-LENGTH* and *PRINT-CIRCLE*. Can only be used inside PPRINT-LOGICAL-BLOCK. If the LIST argument to PPRINT-LOGICAL-BLOCK was NIL, then nothing is popped, but the *PRINT-LENGTH* testing still happens.

PSETF (&REST ARGS &ENVIRONMENT ENV)

This is to SETF as PSETQ is to SETQ. Args are alternating place expressions and values to go into those places. All of the subforms and values are determined, left to right, and only then are the locations updated. Returns NIL.

PSETQ (&REST PAIRS)

PSETQ {var value}* Set the variables to the values, like SETQ, except that assignments happen in parallel, i.e. no assignments take place until all the forms have been evaluated.

PUSH (OBJ PLACE &ENVIRONMENT ENV)

Takes an object and a location holding a list. Conses the object onto the list, returning the modified list. OBJ is evaluated before PLACE.

PUSHNEW (OBJ PLACE &REST KEYS &KEY KEY TEST TEST-NOT &ENVIRONMENT ENV)

Takes an object and a location holding a list. If the object is already in the list, does nothing; otherwise, conses the object onto the list. Returns the modified list. If there is a :TEST keyword, this is used for the comparison.

REMF (PLACE INDICATOR &ENVIRONMENT ENV)

Place may be any place expression acceptable to SETF, and is expected to hold a property list or (). This list is destructively altered to remove the property specified by the indicator. Returns T if such a property was present, NIL if not.

RESTART-BIND (BINDINGS &BODY FORMS)

Executes forms in a dynamic context where the given restart bindings are in effect. Users probably want to use RESTART-CASE. When clauses contain the same restart name, FIND-RESTART will find the first such clause.

RESTART-CASE (EXPRESSION &BODY CLAUSES &ENVIRONMENT ENV)

(RESTART-CASE form {(case-name arg-list {keyword value}* body)}*) The form is evaluated in a dynamic context where the clauses have special meanings as points to which control may be transferred (see INVOKE-RESTART). When clauses contain the same case-name, FIND-RESTART will find the first such clause. If Expression is a call to SIGNAL, ERROR, CERROR or WARN (or macroexpands into such) then the signalled condition will be associated with the new restarts.

ROTATEF (&REST ARGS &ENVIRONMENT ENV)

Takes any number of SETF-style place expressions. Evaluates all of the expressions in turn, then assigns to each place the value of the form to its right. The rightmost form gets the value of the leftmost. Returns NIL.

SETF (&REST ARGS &ENVIRONMENT ENV)

Takes pairs of arguments like SETQ. The first is a place and the second is the value that is supposed to go into that place. Returns the last value. The place argument may be any of the access forms for which SETF knows a corresponding setting form.

SHIFTF (&WHOLE FORM &REST ARGS &ENVIRONMENT ENV)

One or more SETF-style place expressions, followed by a single value expression. Evaluates all of the expressions in turn, then assigns the value of each expression to the place on its left, returning the value of the leftmost.

STEP (FORM)

The form is evaluated with single stepping enabled. Function calls outside the lexical scope of the form can be stepped into only if the functions in question have been compiled with sufficient DEBUG policy to be at least partially steppable.

TIME (FORM)

Execute FORM and print timing information on *TRACE-OUTPUT*. On some hardware platforms estimated processor cycle counts are included in this output; this number is slightly inflated, since it includes the pipeline involved in reading the cycle counter -- executing (TIME NIL) a few times will give you an idea of the overhead, and its variance. The cycle counters are also per processor, not per thread: if multiple threads are running on the same processor, the reported counts will include cycles taken up by all threads running on the processor where TIME was executed. Furthermore, if the operating system migrates the thread to another processor between reads of the cycle counter, the results will be completely bogus. Finally, the counter is cycle counter, incremented by the hardware even when the process is halted -- which is to say that cycles pass normally during operations like SLEEP.

TRACE (&REST SPECS)

TRACE {Option Global-Value}* {Name {Option Value}*}* TRACE is a debugging tool that provides information when specified functions are called. In its simplest form: (TRACE NAME-1 NAME-2 ...) The NAMEs are not evaluated. Each may be a symbol, denoting an individual function, or a string, denoting all functions fbound to symbols whose home package is the package with the given name. Options allow modification of the default behavior. Each option is a pair of an option keyword and a value form. Global options are specified before the first name, and affect all functions traced by a given use of TRACE. Options may also be interspersed with function names, in which case they act as local options, only affecting tracing of the immediately preceding function name. Local options override global options. By default, TRACE causes a printout on *TRACE-OUTPUT* each time that one of the named functions is entered or returns. (This is the basic, ANSI Common Lisp behavior of TRACE.) As an SBCL extension, the :REPORT SB-EXT:PROFILE option can be used to instead cause information to be silently recorded to be inspected later using the SB-EXT:PROFILE function. The following options are defined: :REPORT Report-Type If Report-Type is TRACE (the default) then information is reported by printing immediately. If Report-Type is SB-EXT:PROFILE, information is recorded for later summary by calls to SB-EXT:PROFILE. If Report-Type is NIL, then the only effect of the trace is to execute other options (e.g. PRINT or BREAK). :CONDITION Form :CONDITION-AFTER Form :CONDITION-ALL Form If :CONDITION is specified, then TRACE does nothing unless Form evaluates to true at the time of the call. :CONDITION-AFTER is similar, but suppresses the initial printout, and is tested when the function returns. :CONDITION-ALL tries both before and after. This option is not supported with :REPORT PROFILE. :BREAK Form :BREAK-AFTER Form :BREAK-ALL Form If specified, and Form evaluates to true, then the debugger is invoked at the start of the function, at the end of the function, or both, according to the respective option. :PRINT Form :PRINT-AFTER Form :PRINT-ALL Form In addition to the usual printout, the result of evaluating Form is printed at the start of the function, at the end of the function, or both, according to the respective option. Multiple print options cause multiple values to be printed. :WHEREIN Names If specified, Names is a function name or list of names. TRACE does nothing unless a call to one of those functions encloses the call to this function (i.e. it would appear in a backtrace.) Anonymous functions have string names like "DEFUN FOO". This option is not supported with :REPORT PROFILE. :ENCAPSULATE {:DEFAULT | T | NIL} If T, the tracing is done via encapsulation (redefining the function name) rather than by modifying the function. :DEFAULT is the default, and means to use encapsulation for interpreted functions and funcallable instances, breakpoints otherwise. When encapsulation is used, forms are *not* evaluated in the function's lexical environment, but SB-DEBUG:ARG can still be used. :METHODS {T | NIL} If T, any function argument naming a generic function will have its methods traced in addition to the generic function itself. :FUNCTION Function-Form This is a not really an option, but rather another way of specifying what function to trace. The Function-Form is evaluated immediately, and the resulting function is instrumented, i.e. traced or profiled as specified in REPORT. :CONDITION, :BREAK and :PRINT forms are evaluated in a context which mocks up the lexical environment of the called function, so that SB-DEBUG:VAR and SB-DEBUG:ARG can be used. The -AFTER and -ALL forms are evaluated in the null environment.

TYPECASE (KEYFORM &BODY CASES)

TYPECASE Keyform {(Type Form*)}* Evaluates the Forms in the first clause for which TYPEP of Keyform and Type is true.

UNLESS (TEST &BODY FORMS)

If the first argument is not true, the rest of the forms are evaluated as a PROGN.

UNTRACE (&REST SPECS)

Remove tracing from the specified functions. Untraces all functions when called with no arguments.

WHEN (TEST &BODY FORMS)

If the first argument is true, the rest of the forms are evaluated as a PROGN.

WITH-COMPILATION-UNIT (OPTIONS &BODY BODY)

Affects compilations that take place within its dynamic extent. It is intended to be eg. wrapped around the compilation of all files in the same system. Following options are defined: :OVERRIDE Boolean-Form One of the effects of this form is to delay undefined warnings until the end of the form, instead of giving them at the end of each compilation. If OVERRIDE is NIL (the default), then the outermost WITH-COMPILATION-UNIT form grabs the undefined warnings. Specifying OVERRIDE true causes that form to grab any enclosed warnings, even if it is enclosed by another WITH-COMPILATION-UNIT. :POLICY Optimize-Declaration-Form Provides dynamic scoping for global compiler optimization qualities and restrictions, limiting effects of subsequent OPTIMIZE proclamations and calls to SB-EXT:RESTRICT-COMPILER-POLICY to the dynamic scope of BODY. If OVERRIDE is false, specified POLICY is merged with current global policy. If OVERRIDE is true, current global policy, including any restrictions, is discarded in favor of the specified POLICY. Supplying POLICY NIL is equivalent to the option not being supplied at all, ie. dynamic scoping of policy does not take place. This option is an SBCL-specific experimental extension: Interface subject to change. :SOURCE-NAMESTRING Namestring-Form Attaches the value returned by the Namestring-Form to the internal debug-source information as the namestring of the source file. Normally the namestring of the input-file for COMPILE-FILE is used: this option can be used to provide source-file information for functions compiled using COMPILE, or to override the input-file of COMPILE-FILE. If both an outer and an inner WITH-COMPILATION-UNIT provide a SOURCE-NAMESTRING, the inner one takes precedence. Unaffected by :OVERRIDE. This is an SBCL-specific extension. :SOURCE-PLIST Plist-Form Attaches the value returned by the Plist-Form to internal debug-source information of functions compiled in within the dynamic extent of BODY. Primarily for use by development environments, in order to eg. associate function definitions with editor-buffers. Can be accessed using SB-INTROSPECT:DEFINITION-SOURCE-PLIST. If an outer WITH-COMPILATION-UNIT form also provide a SOURCE-PLIST, it is appended to the end of the provided SOURCE-PLIST. Unaffected by :OVERRIDE. This is an SBCL-specific extension. Examples: ;; Prevent proclamations from the file leaking, and restrict ;; SAFETY to 3 -- otherwise uses the current global policy. (with-compilation-unit (:policy '(optimize)) (restrict-compiler-policy 'safety 3) (load "foo.lisp")) ;; Using default policy instead of the current global one, ;; except for DEBUG 3. (with-compilation-unit (:policy '(optimize debug) :override t) (load "foo.lisp")) ;; Same as if :POLICY had not been specified at all: SAFETY 3 ;; proclamation leaks out from WITH-COMPILATION-UNIT. (with-compilation-unit (:policy nil) (declaim (optimize safety)) (load "foo.lisp"))

WITH-CONDITION-RESTARTS (CONDITION-FORM RESTARTS-FORM &BODY BODY)

Evaluates the BODY in a dynamic environment where the restarts in the list RESTARTS-FORM are associated with the condition returned by CONDITION-FORM. This allows FIND-RESTART, etc., to recognize restarts that are not related to the error currently being debugged. See also RESTART-CASE.

WITH-HASH-TABLE-ITERATOR ((NAME HASH-TABLE) &BODY BODY)

WITH-HASH-TABLE-ITERATOR ((name hash-table) &body body) Provides a method of manually looping over the elements of a hash-table. NAME is bound to a generator-macro that, within the scope of the invocation, returns one or three values. The first value tells whether any objects remain in the hash table. When the first value is non-NIL, the second and third values are the key and the value of the next object. Consequences are undefined if HASH-TABLE is mutated during execution of BODY, except for changing or removing elements corresponding to the current key. The applies to all threads, not just the curren one -- even for synchronized hash-tables. If the table may be mutated by another thread during iteration, use eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the WITH-HASH-TABLE-ITERATOR for.

WITH-PACKAGE-ITERATOR ((MNAME PACKAGE-LIST &REST SYMBOL-TYPES) &BODY BODY)

Within the lexical scope of the body forms, MNAME is defined via macrolet such that successive invocations of (MNAME) will return the symbols, one by one, from the packages in PACKAGE-LIST. SYMBOL-TYPES may be any of :INHERITED :EXTERNAL :INTERNAL.

WITH-SIMPLE-RESTART ((RESTART-NAME FORMAT-STRING &REST FORMAT-ARGUMENTS) &BODY FORMS)

(WITH-SIMPLE-RESTART (restart-name format-string format-arguments) body) If restart-name is not invoked, then all values returned by forms are returned. If control is transferred to this restart, it immediately returns the values NIL and T.

WITH-STANDARD-IO-SYNTAX (&BODY BODY)

Bind the reader and printer control variables to values that enable READ to reliably read the results of PRINT. These values are: *PACKAGE* the COMMON-LISP-USER package *PRINT-ARRAY* T *PRINT-BASE* 10 *PRINT-CASE* :UPCASE *PRINT-CIRCLE* NIL *PRINT-ESCAPE* T *PRINT-GENSYM* T *PRINT-LENGTH* NIL *PRINT-LEVEL* NIL *PRINT-LINES* NIL *PRINT-MISER-WIDTH* NIL *PRINT-PPRINT-DISPATCH* the standard pprint dispatch table *PRINT-PRETTY* NIL *PRINT-RADIX* NIL *PRINT-READABLY* T *PRINT-RIGHT-MARGIN* NIL *READ-BASE* 10 *READ-DEFAULT-FLOAT-FORMAT* SINGLE-FLOAT *READ-EVAL* T *READ-SUPPRESS* NIL *READTABLE* the standard readtable SB-EXT:*SUPPRESS-PRINT-ERRORS* NIL

Undocumented

AND (&REST FORMS)

CALL-METHOD (&REST ARGS)

COND (&REST CLAUSES)

DEFCLASS (&ENVIRONMENT ENV NAME DIRECT-SUPERCLASSES DIRECT-SLOTS &REST OPTIONS)

DEFGENERIC (FUN-NAME LAMBDA-LIST &BODY OPTIONS)

DEFINE-METHOD-COMBINATION (&WHOLE FORM &REST ARGS)

DEFINE-SYMBOL-MACRO (NAME EXPANSION)

DEFMACRO (NAME LAMBDA-LIST &REST BODY)

DEFMETHOD (&REST ARGS)

DOLIST ((VAR LIST &OPTIONAL (RESULT NIL)) &BODY BODY &ENVIRONMENT ENV)

DOTIMES ((VAR COUNT &OPTIONAL (RESULT NIL)) &BODY BODY)

FORMATTER (CONTROL-STRING)

IN-PACKAGE (STRING-DESIGNATOR)

LAMBDA (&WHOLE WHOLE ARGS &BODY BODY)

LOOP (&ENVIRONMENT ENV &REST KEYWORDS-AND-FORMS)

MULTIPLE-VALUE-BIND (VARS VALUE-FORM &BODY BODY)

MULTIPLE-VALUE-LIST (VALUE-FORM)

MULTIPLE-VALUE-SETQ (VARS VALUE-FORM)

OR (&REST FORMS)

PROG (VARLIST &BODY BODY-DECLS)

PROG* (VARLIST &BODY BODY-DECLS)

PROG1 (RESULT &BODY BODY)

PROG2 (FORM1 RESULT &BODY BODY)

RETURN (&OPTIONAL (VALUE NIL))

WITH-ACCESSORS (SLOTS INSTANCE &BODY BODY)

WITH-INPUT-FROM-STRING ((VAR STRING &KEY INDEX START END) &BODY FORMS-DECLS)

WITH-OPEN-FILE ((STREAM FILESPEC &REST OPTIONS) &BODY BODY)

WITH-OPEN-STREAM ((VAR STREAM) &BODY FORMS-DECLS)

WITH-OUTPUT-TO-STRING ((VAR &OPTIONAL STRING &KEY (ELEMENT-TYPE ''CHARACTER)) &BODY FORMS-DECLS)

WITH-SLOTS (SLOTS INSTANCE &BODY BODY)

GENERIC-FUNCTION

Public

CLOSE (STREAM &KEY ABORT)

Close the given STREAM. No more I/O may be performed, but inquiries may still be made. If :ABORT is true, an attempt is made to clean up the side effects of having created the stream.

DOCUMENTATION (SLOTD DOC-TYPE)

Return the documentation string of Doc-Type for X, or NIL if none exists. System doc-types are VARIABLE, FUNCTION, STRUCTURE, TYPE, SETF, and T. Function documentation is stored separately for function names and objects: DEFUN, LAMBDA, &co create function objects with the specified documentation strings. (SETF (DOCUMENTATION NAME 'FUNCTION) STRING) sets the documentation string stored under the specified name, and (SETF (DOCUMENTATION FUNC T) STRING) sets the documentation string stored in the function object. (DOCUMENTATION NAME 'FUNCTION) returns the documentation stored under the function name if any, and falls back on the documentation in the function object if necessary.

INPUT-STREAM-P (STREAM)

Can STREAM perform input operations?

INTERACTIVE-STREAM-P (STREAM)

Is STREAM an interactive stream?

OPEN-STREAM-P (STREAM)

Return true if STREAM is not closed. A default method is provided by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been called on the stream.

OUTPUT-STREAM-P (STREAM)

Can STREAM perform output operations?

STREAM-ELEMENT-TYPE (STREAM)

Return a type specifier for the kind of object returned by the STREAM. The class FUNDAMENTAL-CHARACTER-STREAM provides a default method which returns CHARACTER.

Undocumented

ADD-METHOD (GENERIC-FUNCTION METHOD)

ALLOCATE-INSTANCE (CLASS &REST INITARGS)

CHANGE-CLASS (INSTANCE NEW-CLASS-NAME &REST INITARGS &ALLOW-OTHER-KEYS)

SETFCLASS-NAME (NEW-VALUE CLASS)

COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION ARGUMENTS)

DESCRIBE-OBJECT (X STREAM)

SETFDOCUMENTATION (NEW-VALUE SLOTD DOC-TYPE)

FIND-METHOD (GENERIC-FUNCTION QUALIFIERS SPECIALIZERS &OPTIONAL ERRORP)

FUNCTION-KEYWORDS (METHOD)

INITIALIZE-INSTANCE (INSTANCE &REST INITARGS &KEY ARGUMENT-PRECEDENCE-ORDER (LAMBDA-LIST NIL LAMBDA-LIST-P) (CLOSE-DIR-P NIL) PATH FILE NAME DIRECTORY TERMS READER SUB-READERS OFFSET POSITION POSITIONS (CONVENTION CALLING-CONVENTION) (CALLING-CONVENTION CCONV CALLING-CONVENTION-P) (CCONV CDECL CCONV-P) SEARCH-PATH NAME INITIAL-CONTENTS CONTAINER-TYPE (ROOT *RBT-EMPTY-NODE*) CONTAINER LINES CHAINED-HANDLER URI PROPERTIES SIZE INITIAL-SIZE (TEST 'EQ) (DIMENSIONS 2) (MAX-SIZE 1000) QUERY SEARCHER (CREATE-P NIL) (CREATE-IF-MISSING-P NIL) READERS STARTS TERM INFO TERM-POSITIONS SEGMENT LITERAL-CHAR-CODE-LIMIT &ALLOW-OTHER-KEYS)

MAKE-INSTANCE (CLASS &REST INITARGS &ALLOW-OTHER-KEYS)

MAKE-INSTANCES-OBSOLETE (CLASS)

MAKE-LOAD-FORM (OBJECT &OPTIONAL ENVIRONMENT)

NO-APPLICABLE-METHOD (GENERIC-FUNCTION &REST ARGS)

NO-NEXT-METHOD (GENERIC-FUNCTION METHOD &REST ARGS)

REINITIALIZE-INSTANCE (INSTANCE &REST INITARGS &KEY DIRECT-SUPERCLASSES (LAMBDA-LIST NIL LAMBDA-LIST-P) (ARGUMENT-PRECEDENCE-ORDER NIL APO-P) &ALLOW-OTHER-KEYS)

REMOVE-METHOD (GENERIC-FUNCTION METHOD)

SHARED-INITIALIZE (INSTANCE SLOT-NAMES &REST INITARGS &KEY (METHOD-COMBINATION NIL METHOD-COMBINATION-SUPPLIED-P) (METHOD-CLASS NIL METHOD-CLASS-SUPPLIED-P) DOCUMENTATION DECLARATIONS ARGUMENT-PRECEDENCE-ORDER (LAMBDA-LIST NIL LAMBDA-LIST-P) (NAME NIL NAMEP) SLOT-DEFINITION SLOT-NAME DEFINITION-SOURCE DIRECT-DEFAULT-INITARGS (DIRECT-SLOTS NIL DIRECT-SLOTS-P) (DIRECT-SUPERCLASSES NIL DIRECT-SUPERCLASSES-P) PROTOCOL TYPE FORCE FORCE-NOT (ALLOCATION INSTANCE) ALLOCATION-CLASS QUALIFIERS SPECIALIZERS FUNCTION ((METHOD-CELL METHOD-CELL)) &ALLOW-OTHER-KEYS)

SLOT-MISSING (CLASS INSTANCE SLOT-NAME OPERATION &OPTIONAL NEW-VALUE)

SLOT-UNBOUND (CLASS INSTANCE SLOT-NAME)

UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (PREVIOUS CURRENT &REST INITARGS)

UPDATE-INSTANCE-FOR-REDEFINED-CLASS (INSTANCE ADDED-SLOTS DISCARDED-SLOTS PROPERTY-LIST &REST INITARGS)

SLOT-ACCESSOR

Public

Undocumented

CLASS-NAME (CLASS)

METHOD-QUALIFIERS (M)

VARIABLE

Public

* (&REST NUMBERS)

the value of the most recent top level EVAL

**

the previous value of *

***

the previous value of **

*BREAK-ON-SIGNALS*

When (TYPEP condition *BREAK-ON-SIGNALS*) is true, then calls to SIGNAL will enter the debugger prior to signalling that condition.

*COMPILE-FILE-PATHNAME*

The defaulted pathname of the file currently being compiled, or NIL if not compiling.

*COMPILE-FILE-TRUENAME*

The TRUENAME of the file currently being compiled, or NIL if not compiling.

*COMPILE-PRINT*

The default for the :PRINT argument to COMPILE-FILE.

*COMPILE-VERBOSE*

The default for the :VERBOSE argument to COMPILE-FILE.

*DEBUG-IO*

interactive debugging stream

*DEBUGGER-HOOK*

This is either NIL or a function of two arguments, a condition and the value of *DEBUGGER-HOOK*. This function can either handle the condition or return which causes the standard debugger to execute. The system passes the value of this variable to the function because it binds *DEBUGGER-HOOK* to NIL around the invocation.

*ERROR-OUTPUT*

error output stream

*FEATURES*

a list of symbols that describe features provided by the implementation

*GENSYM-COUNTER*

counter for generating unique GENSYM symbols

*LOAD-PATHNAME*

the defaulted pathname that LOAD is currently loading

*LOAD-PRINT*

the default for the :PRINT argument to LOAD

*LOAD-TRUENAME*

the TRUENAME of the file that LOAD is currently loading

*LOAD-VERBOSE*

the default for the :VERBOSE argument to LOAD

*MACROEXPAND-HOOK*

The value of this variable must be a designator for a function that can take three arguments, a macro expander function, the macro form to be expanded, and the lexical environment to expand in. The function should return the expanded form. This function is called by MACROEXPAND-1 whenever a runtime expansion is needed. Initially this is set to FUNCALL.

*MODULES*

This is a list of module names that have been loaded into Lisp so far. It is used by PROVIDE and REQUIRE.

*PACKAGE*

the current package

*PRINT-ARRAY*

Should the contents of arrays be printed?

*PRINT-BASE*

The output base for RATIONALs (including integers).

*PRINT-CASE*

What case should the printer should use default?

*PRINT-CIRCLE*

Should we use #n= and #n# notation to preserve uniqueness in general (and circularity in particular) when printing?

*PRINT-ESCAPE*

Should we print in a reasonably machine-readable way? (possibly overridden by *PRINT-READABLY*)

*PRINT-GENSYM*

Should #: prefixes be used when printing symbols with null SYMBOL-PACKAGE?

*PRINT-LENGTH*

How many elements at any level should be printed before abbreviating with "..."?

*PRINT-LEVEL*

How many levels should be printed before abbreviating with "#"?

*PRINT-LINES*

The maximum number of lines to print per object.

*PRINT-MISER-WIDTH*

If the remaining space between the current column and the right margin is less than this, then print using ``miser-style'' output. Miser style conditional newlines are turned on, and all indentations are turned off. If NIL, never use miser mode.

*PRINT-PPRINT-DISPATCH*

The pprint-dispatch-table that controls how to pretty-print objects.

*PRINT-PRETTY*

Should pretty printing be used?

*PRINT-RADIX*

Should base be verified when printing RATIONALs?

*PRINT-READABLY*

If true, all objects will be printed readably. If readable printing is impossible, an error will be signalled. This overrides the value of *PRINT-ESCAPE*.

*PRINT-RIGHT-MARGIN*

The position of the right margin in ems (for pretty-printing).

*QUERY-IO*

query I/O stream

*READ-BASE*

the radix that Lisp reads numbers in

*READ-EVAL*

If false, then the #. read macro is disabled.

*READ-SUPPRESS*

Suppress most interpreting in the reader when T.

*READTABLE*

Variable bound to current readtable.

*STANDARD-INPUT*

default input stream

*STANDARD-OUTPUT*

default output stream

*TERMINAL-IO*

terminal I/O stream

*TRACE-OUTPUT*

trace output stream

+ (&REST NUMBERS)

the value of the most recent top level READ

++

the previous value of +

+++

the previous value of ++

- (NUMBER &REST MORE-NUMBERS)

the form currently being evaluated

/ (NUMBER &REST MORE-NUMBERS)

a list of all the values returned by the most recent top level EVAL

//

the previous value of /

///

the previous value of //

Undocumented

*DEFAULT-PATHNAME-DEFAULTS*

*RANDOM-STATE*

*READ-DEFAULT-FLOAT-FORMAT*

CLASS

Public

PACKAGE

the standard structure for the description of a package

READTABLE

A READTABLE is a data structure that maps characters into syntax types for the Common Lisp expression reader.

Undocumented

ARRAY

BASE-STRING

BIGNUM

BIT-VECTOR

BROADCAST-STREAM

BUILT-IN-CLASS

CHARACTER (OBJECT)

CLASS

COMPLEX (REALPART &OPTIONAL (IMAGPART 0))

CONCATENATED-STREAM

CONS (SE1 SE2)

DOUBLE-FLOAT

ECHO-STREAM

FILE-STREAM

FIXNUM

FLOAT (NUMBER &OPTIONAL (OTHER NIL OTHERP))

FUNCTION (THING)

GENERIC-FUNCTION

HASH-TABLE

INTEGER

LIST (&REST ARGS)

LOGICAL-PATHNAME (PATHSPEC)

METHOD

METHOD-COMBINATION

NULL (OBJECT)

NUMBER

PATHNAME (PATHSPEC)

RANDOM-STATE

RATIO

RATIONAL (X)

REAL

RESTART

SEQUENCE

SIMPLE-ARRAY

SIMPLE-BASE-STRING

SIMPLE-BIT-VECTOR

SIMPLE-STRING

SIMPLE-VECTOR

SINGLE-FLOAT

STANDARD-CLASS

STANDARD-GENERIC-FUNCTION

STANDARD-METHOD

STANDARD-OBJECT

STREAM

STRING (X)

STRING-STREAM

STRUCTURE-CLASS

STRUCTURE-OBJECT

SYMBOL

SYNONYM-STREAM

T

TWO-WAY-STREAM

VECTOR (&REST OBJECTS)

CONDITION

Public

Undocumented

ARITHMETIC-ERROR

CELL-ERROR

CONDITION

CONTROL-ERROR

DIVISION-BY-ZERO

END-OF-FILE

ERROR (DATUM &REST ARGUMENTS)

FILE-ERROR

FLOATING-POINT-INEXACT

FLOATING-POINT-INVALID-OPERATION

FLOATING-POINT-OVERFLOW

FLOATING-POINT-UNDERFLOW

PACKAGE-ERROR

PARSE-ERROR

PROGRAM-ERROR

READER-ERROR

SERIOUS-CONDITION

SIMPLE-CONDITION

SIMPLE-ERROR

SIMPLE-TYPE-ERROR

SIMPLE-WARNING

STORAGE-CONDITION

STREAM-ERROR

STYLE-WARNING

TYPE-ERROR

UNBOUND-SLOT

UNBOUND-VARIABLE

UNDEFINED-FUNCTION

WARNING

CONSTANT

Public

ARRAY-DIMENSION-LIMIT

the exclusive upper bound on any given dimension of an array

ARRAY-RANK-LIMIT

the exclusive upper bound on the rank of an array

ARRAY-TOTAL-SIZE-LIMIT

the exclusive upper bound on the total number of elements in an array

BOOLE-1

Boole function op, makes BOOLE return integer1.

BOOLE-2

Boole function op, makes BOOLE return integer2.

BOOLE-AND

Boole function op, makes BOOLE return logand of integer1 and integer2.

BOOLE-ANDC1

Boole function op, makes BOOLE return logandc1 of integer1 and integer2.

BOOLE-ANDC2

Boole function op, makes BOOLE return logandc2 of integer1 and integer2.

BOOLE-C1

Boole function op, makes BOOLE return complement of integer1.

BOOLE-C2

Boole function op, makes BOOLE return complement of integer2.

BOOLE-CLR

Boole function op, makes BOOLE return 0.

BOOLE-EQV

Boole function op, makes BOOLE return logeqv of integer1 and integer2.

BOOLE-IOR

Boole function op, makes BOOLE return logior of integer1 and integer2.

BOOLE-NAND

Boole function op, makes BOOLE return log nand of integer1 and integer2.

BOOLE-NOR

Boole function op, makes BOOLE return lognor of integer1 and integer2.

BOOLE-ORC1

Boole function op, makes BOOLE return logorc1 of integer1 and integer2.

BOOLE-ORC2

Boole function op, makes BOOLE return logorc2 of integer1 and integer2.

BOOLE-SET

Boole function op, makes BOOLE return -1.

BOOLE-XOR

Boole function op, makes BOOLE return logxor of integer1 and integer2.

CALL-ARGUMENTS-LIMIT

The exclusive upper bound on the number of arguments which may be passed to a function, including &REST args.

CHAR-CODE-LIMIT

the upper exclusive bound on values produced by CHAR-CODE

INTERNAL-TIME-UNITS-PER-SECOND

The number of internal time units that fit into a second. See GET-INTERNAL-REAL-TIME and GET-INTERNAL-RUN-TIME.

LAMBDA-LIST-KEYWORDS

A list of symbols used as lambda list keywords in SBCL.

LAMBDA-PARAMETERS-LIMIT

The exclusive upper bound on the number of parameters which may be specifed in a given lambda list. This is actually the limit on required and &OPTIONAL parameters. With &KEY and &AUX you can get more.

MOST-NEGATIVE-FIXNUM

the fixnum closest in value to negative infinity

MOST-POSITIVE-FIXNUM

the fixnum closest in value to positive infinity

MULTIPLE-VALUES-LIMIT

The exclusive upper bound on the number of multiple VALUES that you can return.

Undocumented

DOUBLE-FLOAT-EPSILON

DOUBLE-FLOAT-NEGATIVE-EPSILON

LEAST-NEGATIVE-DOUBLE-FLOAT

LEAST-NEGATIVE-LONG-FLOAT

LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT

LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT

LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT

LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT

LEAST-NEGATIVE-SHORT-FLOAT

LEAST-NEGATIVE-SINGLE-FLOAT

LEAST-POSITIVE-DOUBLE-FLOAT

LEAST-POSITIVE-LONG-FLOAT

LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT

LEAST-POSITIVE-NORMALIZED-LONG-FLOAT

LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT

LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT

LEAST-POSITIVE-SHORT-FLOAT

LEAST-POSITIVE-SINGLE-FLOAT

LONG-FLOAT-EPSILON

LONG-FLOAT-NEGATIVE-EPSILON

MOST-NEGATIVE-DOUBLE-FLOAT

MOST-NEGATIVE-LONG-FLOAT

MOST-NEGATIVE-SHORT-FLOAT

MOST-NEGATIVE-SINGLE-FLOAT

MOST-POSITIVE-DOUBLE-FLOAT

MOST-POSITIVE-LONG-FLOAT

MOST-POSITIVE-SHORT-FLOAT

MOST-POSITIVE-SINGLE-FLOAT

PI

SHORT-FLOAT-EPSILON

SHORT-FLOAT-NEGATIVE-EPSILON

SINGLE-FLOAT-EPSILON

SINGLE-FLOAT-NEGATIVE-EPSILON

T