Package COM.INFORMATIMAGO.COMMON-LISP.LISP.STEPPER

Nicknames: COMMON-LISP-STEPPER CL-STEPPER STEPPER

Implements a Portable Common Lisp Stepper.

This package should be used instead of COMMON-LISP, and the code
recompiled or reloaded.  This will instrumentalize the functions so
that tracing and stepping is available.

To start running some code step-by-step, you can use:

    (step (some-expression)) ; note: it's cl-stepper:step, not cl:step.

Or you may use STEP-TRACE-FUNCTION, to activate tracing of some functions (that
must have been compiled with CL-STEPPER), or STEP-BREAK-ENTRY or
STEP-BREAK-EXIT to enter the stepper upon entry or exit of the named
functions.

It is also possible to run the tracer on all the code that has been
compiled with CL-STEPPER, with:

   (setf *step-mode* :trace)

Reset it with:

   (setf *step-mode* :run)

If you load a lot of packages with CL-STEPPER, you may want to set
*STEP-MAX-CALL-DEPTH* to a small integer when using *STEP-MODE*
:trace, to avoid very big output.  You may also redirect the tracing
output to a different stream setting *STEP-TRACE-OUTPUT*.

Note: when tracing a function with (step-trace-function fun), the depth is
reset while tracing that function (*step-max-call-depth* still applies
for the call tree starting from that function).


The stepper menu is:

    Step Into (s, si, RET), Step over (so), Trace (t), Run (r),
    Debugger (d), Abort (a, q)?

Step Into:

    Continue evaluating each forms and subforms step by step.

Step Over:

    Evaluate the current form in one step.

Trace:

    The code is executed, and all the instrumented code produces traces.

Run:

    The code is executed silently.

Debugger:

    The debugger is invoked with a STEP-CONDITION.  There are restarts
    installed to invoke all the stepper menu commands.

Abort:

    The evaluation of the STEP form is aborted.

With the Step Over, Trace, and Run commands,  if a function with a
break-point or an active trace is reached, it will still enter the
stepper menu again, or trace it.



To disable instrumentation of a form, you can insert (stepper disable)
declarations in the places where declarations are allowed.

   (declaim (declaration stepper)) ; for when CL-STEPPER is not used.

   (…
     (declare (stepper disable))
     …)

declarations.  Use (locally (declare (stepper disable)) …) to disable
in random places.


Similarly, to force tracing a function or a form,
use the (declare (stepper trace)) declaration.
(stepper disable) has priority over (stepper trace).



Copyright Pascal J. Bourguignon 2012 - 2015
This package is provided under the Afero General Public License 3.
See the source file for details.

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

the value of the most recent top level EVAL

Initial value: (COM.INFORMATIMAGO.LISPDOC)

the previous value of *

Initial value: NIL

the previous value of **

Initial value: NIL

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

Initial value: NIL

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

Initial value: NIL

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

Initial value: NIL

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

Initial value: NIL

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

Initial value: NIL

interactive debugging stream

Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200043A79D>

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.

Initial value: NIL

*DEFAULT-PATHNAME-DEFAULTS*

error output stream

Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200043A7DD>

a list of symbols that describe features provided by the
   implementation

Initial value: (COM.INFORMATIMAGO.PJB BORDEAUX-THREADS CLOSER-MOP THREAD-SUPPORT UIOP SPLIT-SEQUENCE COM.INFORMATIMAGO.COMMON-LISP.LISP.CL-STEPPER CL-PPCRE NEWLINE-IS-LINEFEED HAS-ASCII-CODE ...)

counter for generating unique GENSYM symbols

Initial value: 70198

the defaulted pathname that LOAD is currently loading

Initial value: NIL

the default for the :PRINT argument to LOAD

Initial value: NIL

the TRUENAME of the file that LOAD is currently loading

Initial value: NIL

the default for the :VERBOSE argument to LOAD

Initial value: NIL

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.

Initial value: FUNCALL

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

Initial value: (ASDF asdf UIOP uiop PREPARE-MCL-ENVIRONMENT SOCKETS LISPEQU CN-ENCODE JP-ENCODE VERSION ...)

*PACKAGE*

Non-NIL means that arrays should be printed using "#(...)" or
"=#nA(...)" syntax to show their contents.
If NIL, arrays other than strings are printed using "#<...>".
See also the (non-Common Lisp) variables *PRINT-SIMPLE-VECTOR*
and *PRINT-SIMPLE-BIT-VECTOR*

Initial value: T

The output base for integers and rationals.
Must be an integer between 2 and 36.

Initial value: 10

Specifies the alphabetic case in which symbols should
be printed.  Possible values include :UPCASE, :DOWNCASE and :CAPITALIZE

Initial value: UPCASE

Non-NIL means that the lisp printer should attempt to detect
circular structures, indicating them by using "#n=" and "#n#" syntax.
If this variable is false then an attempt to
output circular structure may cause unbounded output.

Initial value: NIL

Non-NIL means that the lisp printer should -attempt- to output
expressions `readably.'  When NIL the attempts to produce output
which is a little more human-readable (for example, pathnames
are represented by the characters of their namestring.)

Initial value: T

Non-NIL means that symbols with no home package should be
printed using "#:" syntax.  NIL means no prefix is printed.

Initial value: T

Specifies the length at which printing of lisp expressions
should be truncated.  NIL means that no such truncation should occur.
truncation is indicated by printing "..." instead of the
rest of the overly-long list or vector.
See also *PRINT-LEVEL*

Initial value: 10

Specifies the depth at which printing of lisp expressions
should be truncated.  NIL means that no such truncation should occur.
Truncation is indicated by printing "#" instead of the
representation of the too-deeply-nested structure.
See also *PRINT-LENGTH*

Initial value: 4

+#/NIL truncates printing after # lines

Initial value: NIL

+#/NIL miser format starts when there is less than this width left

Initial value: 40

*PRINT-PPRINT-DISPATCH*

Non-NIL means that the lisp printer should insert extra
indentation and newlines to make output more readable and `prettier.'

Initial value: NIL

Non-NIL means that the lisp printer will explicitly indicate
the output radix (see *PRINT-BASE*) which is used to print
integers and rational numbers.

Initial value: NIL

Non-NIL means that attempts to print unreadable objects
   signal PRINT-NOT-READABLE errors.  NIL doesn't.

Initial value: NIL

+#/NIL the right margin for pretty printing

Initial value: 80

query I/O stream

Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200043A79D>

*RANDOM-STATE*

the radix that Lisp reads numbers in

Initial value: 10

*READ-DEFAULT-FLOAT-FORMAT*

When nil, #. signals an error.

Initial value: T

Suppress most interpreting in the reader when T.

Initial value: NIL

*READTABLE*

default input stream

Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200043A97D>

default output stream

Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200043A81D>

The maximum depth of function calls that should be traced.  When
more than that depth of calls occur, the *step-mode* switches to
:run.

Initial value: NIL

May be :run, :function :trace or :step.

:run       don't print anything, just evaluate the forms.

:function just prints the function calls and their results.

:trace    just prints the forms and their results as they are evaluted.

:step     prints the form, then ask the user what to do (step over,
          step into, trace, run).

When break-points are implemented, :run, :function and :trace will run
until a break-point is reached.

Initial value: RUN

The package bound to *PACKAGE* while printing tracing logs.

Initial value: #<Package "COMMON-LISP-USER">

The value bound to *PRINT-CASE* while printing tracing logs.

Initial value: DOWNCASE

The value bound to *PRINT-LENGTH* while printing tracing logs.

Initial value: 10

The value bound to *PRINT-LEVEl* while printing tracing logs.

Initial value: 3

The stream where the stepper traces are written to.

Initial value: #<SYNONYM-STREAM to *TRACE-OUTPUT* #x302001A3327D>

terminal I/O stream

Initial value: #<ECHOING-TWO-WAY-STREAM input #<BASIC-CHARACTER-INPUT-STREAM UTF-8 (PIPE/0) #x30200043B99D>, output #<BASIC-CHARACTER-OUTPUT-STREAM UTF-8 (TTY/1) #x30200043B50D> #x302000445BDD>

trace output stream

Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200043A81D>

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

the value of the most recent top level READ

Initial value: (QUICKLOAD COM.INFORMATIMAGO.LISPDOC)

the previous value of +

Initial value: NIL

the previous value of ++

Initial value: NIL

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

the form currently being evaluated

Initial value: (DOC)

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

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

Initial value: ((COM.INFORMATIMAGO.LISPDOC))

the previous value of /

Initial value: NIL

the previous value of //

Initial value: NIL

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

1+

1-

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

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

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

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

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

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

Return the absolute value of the number.

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

Return the arc cosine of NUMBER.

Return the hyperbolic arc cosine of NUMBER.

ADD-METHOD

Add ITEM to LIST unless it is already a member

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

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

ALLOCATE-INSTANCE

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

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

And Form*
AND evaluates each form in sequence, from left to right.  If any form
returns NIL, AND returns NIL; otherwise, AND returns the values(s) returned
by the last form.  If there are no forms, AND returns T.

Construct a new list by concatenating the list 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

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

Return the element of the ARRAY specified by the SUBSCRIPTS.

ARITHMETIC-ERROR

ARITHMETIC-ERROR-OPERANDS

ARITHMETIC-ERROR-OPERATION

ARRAY

Return the length of dimension AXIS-NUMBER of ARRAY.

the exclusive upper bound on any given dimension of an array

Initial value: 72057594037927936

Return a list whose elements are the dimensions of the array

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

Return the type of the elements of the array

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

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

Return the number of dimensions of ARRAY.

the exclusive upper bound on the rank of an array

Initial value: 4096

ARRAY-ROW-MAJOR-INDEX

Return the total number of elements in the Array.

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

Initial value: 72057594037927936

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

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

Return the arc sine of NUMBER.

Return the hyperbolic arc sine of NUMBER.

ASSERT Test-Form [(Place*) [String Arg*]]
  If the Test-Form is not true, then signal a correctable error.  If Places
  are specified, then new values are prompted for when the error is proceeded.
  String and Args are the format string and args to the error call.

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

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

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.

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

Return the hyperbolic arc tangent of NUMBER.

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

BASE-CHAR

BASE-STRING

BIGNUM

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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

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

Boole function op, makes BOOLE return integer1.

Initial value: 2

Boole function op, makes BOOLE return integer2.

Initial value: 3

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

Initial value: 6

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

Initial value: 12

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

Initial value: 13

Boole function op, makes BOOLE return complement of integer1.

Initial value: 4

Boole function op, makes BOOLE return complement of integer2.

Initial value: 5

Boole function op, makes BOOLE return 0.

Initial value: 0

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

Initial value: 9

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

Initial value: 7

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

Initial value: 10

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

Initial value: 11

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

Initial value: 14

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

Initial value: 15

Boole function op, makes BOOLE return -1.

Initial value: 1

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

Initial value: 8

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.

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

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

BROADCAST-STREAM

BROADCAST-STREAM-STREAMS

BUILT-IN-CLASS

Returns a new list the same as List without the N last elements.

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

Return the position part of the byte specifier bytespec.

Return the size part of the byte specifier bytespec.

CAAAAR

CAAADR

CAAAR

CAADAR

CAADDR

CAADR

CAAR

CADAAR

CADADR

CADAR

CADDAR

CADDDR

CADDR

CADR

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

Initial value: 65536

CAR

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.

CATCH

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.

CDAAAR

CDAADR

CDAAR

CDADAR

CDADDR

CDADR

CDAR

CDDAAR

CDDADR

CDDAR

CDDDAR

CDDDDR

CDDDR

CDDR

CDR

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

CELL-ERROR

CELL-ERROR-NAME

CERROR

CHANGE-CLASS

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

the upper exclusive bound on values produced by CHAR-CODE

Initial value: 1114112

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

Return T if all of the arguments are the same character.
  Font, bits, and case are ignored.

Return T if the arguments are in strictly decreasing alphabetic order.
   Font, bits, and case are ignored.

Return the integer code of CHAR.

Return T if the arguments are in strictly increasing alphabetic order.
   Font, bits, and case are ignored.

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

Return T if no two of the arguments are the same character.
   Font, bits, and case are ignored.

Return T if the arguments are in strictly non-decreasing alphabetic order.
   Font, bits, and case are ignored.

Return T if the arguments are in strictly non-increasing alphabetic order.
   Font, bits, and case are ignored.

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

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

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

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

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

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

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

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

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

CHECK-TYPE Place Typespec [String]
  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.

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

CLASS

CLASS-NAME

CLASS-OF

Clear any available input from INPUT-STREAM.

CLEAR-OUTPUT

The close generic function can be applied to sockets. It releases the
operating system resources associated with the socket.

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

CODE-CHAR

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

Coerce DEFINITION (by default, the function whose name is NAME)
  to a compiled function, returning (VALUES THING WARNINGS-P FAILURE-P),
  where if NAME is NIL, THING is the result of compilation, and
  otherwise THING is NAME. When NAME is not NIL, the compiled function
  is also set into (MACRO-FUNCTION NAME) if NAME names a macro, or into
  (FDEFINITION NAME) otherwise.

Compile SRC, producing a corresponding fasl file and returning its filename.

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

COMPILED-FUNCTION

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

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

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

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

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

COMPUTE-APPLICABLE-METHODS

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.

Return a new sequence of all the argument sequences concatenated together
  which shares no structure with the original argument sequences of the
  specified OUTPUT-TYPE-SPEC.

CONCATENATED-STREAM

CONCATENATED-STREAM-STREAMS

COND

CONDITION

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

CONS

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

Return a function that always returns VALUE.

True of any Lisp object that has a constant value: types that eval to
  themselves, keywords, constants, and list whose car is QUOTE.

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

CONTROL-ERROR

Return a new association list which is EQUAL to ALIST.

Return a new list which is EQUAL to LIST.

COPY-PPRINT-DISPATCH

COPY-READTABLE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

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

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.

Recursively copy trees of conses.

Return the cosine of NUMBER.

Return the hyperbolic cosine of NUMBER.

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

Return the number of elements in SEQUENCE satisfying PRED(el).

Return the number of elements in SEQUENCE not satisfying TEST(el).

CTYPECASE Key {(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.

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

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

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

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.

DEFCLASS

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.

DEFGENERIC

Define a compiler-macro for NAME.

DEFINE-CONDITION

DEFINE-METHOD-COMBINATION

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

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

DEFINE-SYMBOL-MACRO

DEFMACRO

DEFMETHOD

Defines a new package called PACKAGE. Each of OPTIONS should be one of the 
   following: 
    (:NICKNAMES {package-name}*)
    (:SIZE <integer>)
    (:EXTERNAL-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}*)
    (:DOCUMENTATION doc-string)
   All options except SIZE and DOCUMENTATION can be used multiple 
   times.

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.

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

Define a new type, with syntax like DEFMACRO.

DEFUN

Define a global 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.

Return a sequence formed by destructively removing the specified ITEM from
  the given SEQUENCE.

The elements of SEQUENCE are examined, and if any two match, one is
   discarded.  The resulting sequence, which may be formed by destroying the
   given sequence, is returned.
   Sequences of type STR have a NEW str returned.

Delete the specified FILE.

Return a sequence formed by destructively removing the elements satisfying
  the specified PREDICATE from the given SEQUENCE.

Return a sequence formed by destructively removing the elements not
  satisfying the specified PREDICATE from the given SEQUENCE.

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

Return the denominator of NUMBER, which must be rational.

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

Print a description of the object X.

DESCRIBE-OBJECT

Bind the variables in LAMBDA-LIST to the contents of ARG-LIST.

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.

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

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.

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

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.

DIVISION-BY-ZERO

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* ({(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 [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 [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 [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.

DOCUMENTATION

DOLIST

DOTIMES

DOUBLE-FLOAT

DOUBLE-FLOAT-EPSILON

DOUBLE-FLOAT-NEGATIVE-EPSILON

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

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.

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.

ECHO-STREAM

ECHO-STREAM-INPUT-STREAM

ECHO-STREAM-OUTPUT-STREAM

ED

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

Return the element of SEQUENCE specified by INDEX.

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

END-OF-FILE

ENDP

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

Test whether the directories containing the specified file
  actually exist, and attempt to create them if they do not.
  The MODE argument is an extension to control the Unix permission
  bits.  Portable programs should avoid using the :MODE keyword
  argument.

ENSURE-GENERIC-FUNCTION

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

Return T if OBJ1 and OBJ2 represent either the same object or
numbers with the same type and value.

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.  Pathnames are EQUAL if their components are.

Just like EQUAL, but more liberal in several respects.
  Numbers may be of different types, as long as the values are identical
  after coercion.  Characters may differ in alphabetic case.  Vectors and
  arrays must have identical dimensions and EQUALP elements, but may differ
  in their type restriction.
  If one of x or y is a pathname and one is a string with the name of the
  pathname then this will return T.

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

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.

EVAL

EVAL-WHEN

Is this integer even?

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.

Return e raised to the power NUMBER.

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

Return BASE raised to the POWER.

Return true if name has a global function definition.

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

FDEFINITION

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

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

Return the file author as a string, or NIL if the author cannot be
  determined. Signal an error of type FILE-ERROR if FILE doesn't exist,
  or FILE is a wild pathname.

FILE-ERROR

FILE-ERROR-PATHNAME

FILE-LENGTH

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

FILE-POSITION

FILE-STREAM

Return the delta in STREAM's FILE-POSITION that would be caused by writing
   OBJECT to STREAM. Non-trivial only in implementations that support
   international character sets.

Return file's last modification date, or NIL if it doesn't exist.
  An error of type file-error is signaled if file is a wild pathname

Replace the specified elements of SEQUENCE with ITEM.
   !$ could be sped up by calling iv-fill, sv-fill to avoid aref overhead.

Return the FILL-POINTER of the given VECTOR.

FIND

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

FIND-CLASS

FIND-IF

FIND-IF-NOT

FIND-METHOD

FIND-PACKAGE

Return the first active restart named NAME. If NAME names a
   restart, the restart is returned if it is currently active. If no such
   restart is found, NIL is returned. It is an error to supply NIL as a
   name. If CONDITION is specified and not NIL, then only restarts
   associated with that condition (or with no condition) will be
   returned.

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.

FINISH-OUTPUT

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

FIXNUM

FLET

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-DIGITS

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

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

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

FLOATING-POINT-INEXACT

FLOATING-POINT-INVALID-OPERATION

FLOATING-POINT-OVERFLOW

FLOATING-POINT-UNDERFLOW

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

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

Make NAME have no global function definition.

FORCE-OUTPUT

FORMAT

FORMATTER

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

Output #Newline only if the OUTPUT-STREAM is not already at the
start of a line.  Return T if #Newline needed.

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

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

Call FUNCTION with the given ARGUMENTS.

FUNCTION

FUNCTION-KEYWORDS

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.

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

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

GENERIC-FUNCTION

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.

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

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

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.

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

Return the real time in the internal time format. (See
  INTERNAL-TIME-UNITS-PER-SECOND.) This is useful for finding elapsed time.

Return the run time in the internal time format. (See
  INTERNAL-TIME-UNITS-PER-SECOND.) This is useful for finding CPU usage.

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-OUTPUT-STREAM-STRING

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.

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.

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

Search the property list stored in Place for an indicator EQ to INDICATOR.
  If one is found, return the corresponding value, else return 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

The argument must be a character object. GRAPHIC-CHAR-P returns NIL if the
  argument is a Unicode control character, otherwise returns T.

(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
   { (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.

HASH-TABLE

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

HASH-TABLE-P

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

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

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.

Return the test HASH-TABLE was created with.

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

This function simply returns what was passed to it.

IF

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.

Extract the imaginary part of a number.

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.

IN-PACKAGE

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

INITIALIZE-INSTANCE

INPUT-STREAM-P

INSPECT

INTEGER

Returns 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.)

Return the number of significant bits in the absolute value of integer.

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

INTERACTIVE-STREAM-P

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

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

Initial value: 1000000

Return the intersection of LIST1 and LIST2.

INVALID-METHOD-ERROR

Enter the debugger.

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.

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.

Return the root of the nearest integer less than n which is a perfect
   square.  Argument n must be a non-negative integer

KEYWORD

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

LABELS

LAMBDA

symbols which are magical in a lambda list

Initial value: (&OPTIONAL &REST &AUX &KEY &ALLOW-OTHER-KEYS &BODY &ENVIRONMENT &WHOLE &LEXPR &LAP)

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.

Initial value: 4096

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

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

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

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

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.

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

Return an integer that is the length of SEQUENCE.

LET

LET*

LISP-IMPLEMENTATION-TYPE

LISP-IMPLEMENTATION-VERSION

Return constructs and returns a list of its arguments.

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

Return a list of all existing packages.

Return the length of the given LIST, or NIL if the LIST is circular.

LISTEN

LISTP

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

   Extension: :PRINT :SOURCE means print source as well as value

LOAD-LOGICAL-PATHNAME-TRANSLATIONS

LOAD-TIME-VALUE

LOCALLY

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

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

Return the logical AND of (LOGNOT integer1) and integer2.

Bitwise AND INTEGER1 with (LOGNOT INTEGER2).

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

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

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

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

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

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

Complement the logical AND of INTEGER1 and INTEGER2.

Complement the logical AND of INTEGER1 and INTEGER2.

Return the bit-wise logical not of integer.

Return the logical OR of (LOGNOT integer1) and integer2.

Bitwise OR INTEGER1 with (LOGNOT INTEGER2).

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

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

LONG-FLOAT

LONG-FLOAT-EPSILON

LONG-FLOAT-NEGATIVE-EPSILON

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

LOOP

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.

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

Return a string giving the name of the local machine.

Returns a string describing the type of the local machine.

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

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.

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.

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

MAKE-ARRAY

MAKE-BROADCAST-STREAM

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

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

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.

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.

Create and return a new hash table. The keywords are as follows:
     :TEST -- Indicates what kind of test to use.
     :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 (which must be greater than 0), 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.

MAKE-INSTANCE

MAKE-INSTANCES-OBSOLETE

Constructs a list with size elements each set to value

MAKE-LOAD-FORM

MAKE-LOAD-FORM-SAVING-SLOTS

Make a new package having the specified NAME, NICKNAMES, and USE
list.  INTERNAL-SIZE and EXTERNAL-SIZE are estimates for the number of
internal and external symbols which will ultimately be present in the
package.  In this implementation, the default for the USE list is the
value of the variable CCL:*MAKE-PACKAGE-USE-DEFAULTS*.

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

Make a new random state object. If STATE is not supplied, return a
  copy of the current random state. If STATE is a random state, then
  return a copy of it. If STATE is T then return a randomly
  initialized random state.

Return a sequence of the given TYPE and LENGTH, with elements initialized
  to INITIAL-ELEMENT.

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

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

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

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

MAKE-SYNONYM-STREAM

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

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

MAP

MAP-INTO

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

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

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

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

For each entry in HASH-TABLE, call the designated two-argument function
   on the key and value of the entry. Return NIL.

Apply FUNCTION to successive CDRs of list. Return NIL.

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

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

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

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

Return tail of LIST beginning with first element satisfying TEST.

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

Merge the sequences SEQUENCE1 and SEQUENCE2 destructively into a
   sequence of type RESULT-TYPE using PREDICATE to order the elements.
   If result-type specifies an array, the returned array will not be
   a complex array. Usually, result-type is either LIST, ARRAY or STRING.

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

METHOD

METHOD-COMBINATION

METHOD-COMBINATION-ERROR

METHOD-QUALIFIERS

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

Is this real number strictly negative?

The specified subsequences of SEQUENCE1 and SEQUENCE2 are compared
   element-wise. If they are of equal length and match in every element, the
   result is NIL. Otherwise, the result is a non-negative integer, the index
   within SEQUENCE1 of the leftmost position at which they fail to match; or,
   if one is shorter than and a matching prefix of the other, the index within
   SEQUENCE1 beyond the last position tested is returned. If a non-NIL
   :FROM-END argument is given, then one plus the index of the rightmost
   position in which the sequences differ is returned.

Returns second result of FLOOR.

MOST-NEGATIVE-DOUBLE-FLOAT

the fixnum closest in value to negative infinity

Initial value: -1152921504606846976

MOST-NEGATIVE-LONG-FLOAT

MOST-NEGATIVE-SHORT-FLOAT

MOST-NEGATIVE-SINGLE-FLOAT

MOST-POSITIVE-DOUBLE-FLOAT

the fixnum closest in value to positive infinity

Initial value: 1152921504606846975

MOST-POSITIVE-LONG-FLOAT

MOST-POSITIVE-SHORT-FLOAT

MOST-POSITIVE-SINGLE-FLOAT

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

MULTIPLE-VALUE-BIND

MULTIPLE-VALUE-CALL

MULTIPLE-VALUE-LIST

MULTIPLE-VALUE-PROG1

MULTIPLE-VALUE-SETQ

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

Initial value: 200

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

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

Modifies List to remove the last N elements.

Concatenates the lists given as arguments (by changing them)

NIL

Destructively return the intersection of LIST1 and LIST2.

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

NO-APPLICABLE-METHOD

NO-NEXT-METHOD

NOT

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.

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.

Return (NCONC (NREVERSE X) Y).

Return a sequence of the same elements in reverse order; the argument
   is destroyed.

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

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

NSTRING-CAPITALIZE

NSTRING-DOWNCASE

NSTRING-UPCASE

Substitute from ALIST into TRUE destructively.

Substitute NEW for subtrees matching OLD.

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

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

Return a sequence of the same kind as SEQUENCE with the same elements
  except that all elements equal to OLD are replaced with NEW. The SEQUENCE
  may be destructively modified. See manual for details.

Return a sequence of the same kind as SEQUENCE with the same elements
   except that all elements satisfying the PRED are replaced with NEW. 
   SEQUENCE may be destructively modified. See manual for details.

Return a sequence of the same kind as SEQUENCE with the same elements
   except that all elements not satisfying the TEST are replaced with NEW.
   SEQUENCE may be destructively modified. See manual for details.

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

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

Performs the cdr function n times on a list.

NULL

NUMBER

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

Return the numerator of NUMBER, which must be rational.

Destructively return the union of LIST1 and LIST2.

Is this integer odd?

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.

OPEN-STREAM-P

Or Form*
OR evaluates each Form, in sequence, from left to right.
If any Form but the last returns a non-NIL value, OR returns that
single value (without evaluating any subsequent Forms.)  If OR evaluates
the last Form, it returns all values returned by that Form.  If there
are no Forms, OR returns NIL.

OUTPUT-STREAM-P

PACKAGE

PACKAGE-ERROR

PACKAGE-ERROR-PACKAGE

PACKAGE-NAME

PACKAGE-NICKNAMES

PACKAGE-SHADOWING-SYMBOLS

PACKAGE-USE-LIST

PACKAGE-USED-BY-LIST

PACKAGEP

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

PARSE-ERROR

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.

PARSE-NAMESTRING

Convert thing (a pathname, string or stream) into a pathname.

Return PATHNAME's device.

Return PATHNAME's directory.

Return PATHNAME's host.

Pathname matches the wildname template?

Return PATHNAME's name.

Return PATHNAME's type.

Return PATHNAME's version.

PATHNAMEP

PEEK-CHAR

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.

PI

Is this real number strictly positive?

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

POSITION

POSITION-IF

POSITION-IF-NOT

Prettily output OBJECT preceded by a newline.

PPRINT-DISPATCH

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.

Specify the indentation to use in the current logical block if STREAM
   (which defaults to *STANDARD-OUTPUT*) is it 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.

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-LOGICAL-BLOCK

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

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.

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.

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

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

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

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

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

PRINT-NOT-READABLE

PRINT-NOT-READABLE-OBJECT

PRINT-OBJECT

Output OBJECT to STREAM with "#<" prefix, ">" suffix, optionally
  with object-type prefix and object-identity suffix, and executing the
  code in BODY to provide possible further output.

Return a pathname which is the truename of the file if it exists, or NIL
  otherwise. An error of type FILE-ERROR is signaled if pathname is wild.

PROCLAIM

PROG

PROG*

PROG1

PROG2

PROGN

PROGRAM-ERROR

PROGV

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

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

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

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.

QUOTE

RANDOM

RANDOM-STATE

RANDOM-STATE-P

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

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

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.

RATIO

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.

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))

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

READ

READ-BYTE

READ-CHAR

READ-CHAR-NO-HANG

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

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-LINE

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

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.

READER-ERROR

READTABLE

READTABLE-CASE

READTABLEP

REAL

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

Extract the real part of a number.

The specified Sequence is ``reduced'' using the given Function.
  See manual for details.

REINITIALIZE-INSTANCE

Returns second result of TRUNCATE.

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.

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

Return a copy of SEQUENCE with elements satisfying the test (default is
   EQL) with ITEM removed.

The elements of SEQUENCE are compared pairwise, and if any two match,
   the one occurring earlier is discarded, unless FROM-END is true, in
   which case the one later in the sequence is discarded. The resulting
   sequence is returned.

   The :TEST-NOT argument is deprecated.

Return a copy of sequence with elements such that predicate(element)
   is non-null removed

Return a copy of sequence with elements such that predicate(element)
   is null removed

REMOVE-METHOD

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 to have the specified NEW-NAME. If FILE is a stream open to a
  file, then the associated file is renamed.

Changes the name and nicknames for a package.

The target sequence is destructively modified by copying successive
   elements into it from the source sequence.

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.

Means the same as the cdr of a list.

RESTART

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

Return the name of the given restart object.

RETURN

RETURN-FROM

Return (append (reverse x) y).

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

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.

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.

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

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

RPLACA

RPLACD

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

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

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

SEARCH

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

SEQUENCE

SERIOUS-CONDITION

Set SYMBOL's value cell to NEW-VALUE.

Return the elements of LIST1 which are not in LIST2.

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

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

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-PPRINT-DISPATCH

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.

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.

SETQ

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

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.

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

SHARED-INITIALIZE

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.

SHORT-FLOAT

SHORT-FLOAT-EPSILON

SHORT-FLOAT-NEGATIVE-EPSILON

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

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.

SIGNED-BYTE

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

SIMPLE-ARRAY

SIMPLE-BASE-STRING

SIMPLE-BIT-VECTOR

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

SIMPLE-CONDITION

SIMPLE-CONDITION-FORMAT-ARGUMENTS

SIMPLE-CONDITION-FORMAT-CONTROL

SIMPLE-ERROR

SIMPLE-STRING

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

SIMPLE-TYPE-ERROR

SIMPLE-VECTOR

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

SIMPLE-WARNING

Return the sine of NUMBER.

SINGLE-FLOAT

SINGLE-FLOAT-EPSILON

SINGLE-FLOAT-NEGATIVE-EPSILON

Return the hyperbolic sine of NUMBER.

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

This function causes execution to be suspended for N seconds. N may
  be any non-negative, non-complex number.

SLOT-BOUNDP

SLOT-EXISTS-P

SLOT-MAKUNBOUND

SLOT-MISSING

SLOT-UNBOUND

SLOT-VALUE

Return a string describing the supporting software.

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

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.

Returns SEQUENCE, which has been modified to be in order.
   If sequence is a displaced array, sorts just that portion of the
   data-array which is part of SEQUENCE.

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

Return the square root of NUMBER.

Returns SEQUENCE, which has been modified to be in order.
   If sequence is a displaced array, sorts just that portion of the
   data-array which is part of SEQUENCE.

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

STANDARD-CLASS

STANDARD-GENERIC-FUNCTION

STANDARD-METHOD

STANDARD-OBJECT

STEP

DO:             Enable breaking on entry of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of function names added.

DO:             Enable breaking on exit of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of function names added.

DO:             Enable tracing of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of function names added.

DO:             Disable breaking on entry of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of step-break-entry functions remaining.

DO:             Disable breaking on exit of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of step-break-entry functions remaining.

DO:             Disable tracing of functions named by FNAMES.

FNAMES:         A list of function names.

NOTE:           The functions must have been compiled with the operators from
                the CL-STEPPER package not the CL package.

RETURN:         The list of step-traced functions remaining.

STORAGE-CONDITION

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

STREAM

STREAM-ELEMENT-TYPE

STREAM-ERROR

STREAM-ERROR-STREAM

STREAM-EXTERNAL-FORMAT

STREAMP

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-CAPITALIZE

STRING-DOWNCASE

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

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 ().

Given a set of characters (a list or string) and a string, returns
  a copy of the string with the characters in the set removed from the
  left end.

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 ().

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 ().

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 ().

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 ().

Given a set of characters (a list or string) and a string, returns
  a copy of the string with the characters in the set removed from the
  right end.

STRING-STREAM

Given a set of characters (a list or string) and a string, returns a
  copy of the string with the characters in the set removed from both
  ends.

STRING-UPCASE

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 ().

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 ().

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 ().

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

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 ().

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 ().

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

STRUCTURE-CLASS

STRUCTURE-OBJECT

STYLE-WARNING

Substitute from ALIST into TREE nondestructively.

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

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

Substitutes new for subtrees matching old.

Substitutes new for subtrees for which test is true.

Substitutes new for subtrees for which test is false.

Return a sequence of the same kind as SEQUENCE with the same elements,
  except that all elements equal to OLD are replaced with NEW. See manual
  for details.

Return a sequence of the same kind as SEQUENCE with the same elements
  except that all elements satisfying the PRED are replaced with NEW. See
  manual for details.

Return a sequence of the same kind as SEQUENCE with the same elements
  except that all elements not satisfying the PRED are replaced with NEW.
  See manual for details.

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

Computes a hash code for S-EXPR and returns it as an integer.

SYMBOL

Return the definition of NAME, even if it is a macro or a special form.
   Error if NAME doesn't have a definition.

SYMBOL-MACROLET

Return SYMBOL's name as a string.

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

Return SYMBOL's property list.

Return SYMBOL's current bound value.

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

SYNONYM-STREAM

SYNONYM-STREAM-SYMBOL

T

TAGBODY

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.

Return the tangent of NUMBER.

Return the hyperbolic tangent of NUMBER.

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

TERPRI

THE

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

THROW

Execute FORM and print timing information on *TRACE-OUTPUT*.

TRACE {Option Global-Value}* { Name | (Name {Option Value}*) }*

TRACE is a debugging tool that provides information when specified
functions are called.

Translate PATHNAME to a physical pathname, which is returned.

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

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

Return the pathname for the actual file described by PATHNAME.
  An error of type FILE-ERROR is signalled if no such file exists,
  or the pathname is wild.

  Under Unix, the TRUENAME of a broken symlink is considered to be
  the name of the broken symlink itself.

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

TWO-WAY-STREAM

TWO-WAY-STREAM-INPUT-STREAM

TWO-WAY-STREAM-OUTPUT-STREAM

TYPE-ERROR

TYPE-ERROR-DATUM

TYPE-ERROR-EXPECTED-TYPE

Return the type of OBJECT.

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

Is OBJECT of type TYPE?

UNBOUND-SLOT

UNBOUND-SLOT-INSTANCE

UNBOUND-VARIABLE

UNDEFINED-FUNCTION

Makes SYMBOLS no longer exported from 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.

Returns the union of LIST1 and LIST2.

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

UNREAD-CHAR

UNSIGNED-BYTE

Remove tracing from the specified functions. With no args, untrace all
   functions.

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

UNWIND-PROTECT

UPDATE-INSTANCE-FOR-DIFFERENT-CLASS

UPDATE-INSTANCE-FOR-REDEFINED-CLASS

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

UPGRADED-COMPLEX-PART-TYPE

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

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.

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

Return the home directory of the user as a pathname.

VALUES

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

Construct a SIMPLE-VECTOR from the given objects.

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

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.

Attempt to set the element of VECTOR designated by its fill pointer
to ELT, and increment the fill pointer by one. If the fill pointer is
too large, VECTOR is extended using adjust-array.  EXTENSION is the
minimum number of elements to add if it must be extended.

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

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.

WARNING

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

Predicate for determining whether pathname contains any wildcards.

Create a lexical environment in which the slots specified by slot-entry
are lexically available through their accessors as if they were variables.
The appropriate accessors are invoked to access the slots specified by
slot-entry. Both setf and setq can be used to set the value of the slot.

WITH-COMPILATION-UNIT ({Key Value}*) Form*
  This form affects compilations that take place within its dynamic extent. It
  is intended to be wrapped around the compilation of all files in the same
  system. These keywords 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.

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 ((function hash-table) &body body)
   provides a method of manually looping over the elements of a hash-table.
   FUNCTION 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.

Create an input string stream, provide an opportunity to perform
operations on the stream (returning zero or more values), and then close
the string stream.

STRING is evaluated first, and VAR is bound to a character input string
stream that supplies characters from the subsequence of the resulting
string bounded by start and end. BODY is executed as an implicit progn.

Use open to create a file stream to file named by filename. Filename is
the name of the file to be opened. Options are used as keyword arguments
to open.

Perform a series of operations on stream, return a value, and then
close the stream.  VAR is bound to the value of STREAM, and then BODY is
executed as an implicit progn. STREAM is automatically closed on exit
from with-open-stream, no matter whether the exit is normal or abnormal.
The stream has dynamic extent; its extent ends when the form is exited.

Create a character output stream, perform a series of operations that
may send results to this stream, and then close the stream.  BODY is
executed as an implicit progn with VAR bound to an output string stream.
All output to that string stream is saved in a string.

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

Establish a lexical environment for referring to the slots in the
instance named by the given slot-names as though they were variables.
Within such a context the value of the slot can be specified by using
its slot name, as if it were a lexically bound variable. Both setf and
setq can be used to set the value of the slot.

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

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

Write one byte, BYTE, to STREAM.

Output CHAR to OUTPUT-STREAM.

Write the characters of the subsequence of STRING bounded by START
and END to OUTPUT-STREAM then output a #Newline at end.

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

Write the characters of the subsequence of STRING bounded by START
and END to OUTPUT-STREAM.

Return the printed representation of OBJECT as a string.

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