shadow

A lispy system for defining OpenGL shader programs and associated buffer objects.

Overview

Under the hood, Shadow is just a wrapper around the Varjo library used for writing shader programs, and some fluff to allow referencing shader programs by name, querying for basic information about them, modifying uniform variables throughout the lifecycle of an OpenGL application, and managing certain OpenGL buffer object types (UBO, SSBO currently).

The goal of Shadow is to be a simple solution to ease the task of writing and managing OpenGL shader programs and associated buffers.

Install

(ql:quickload :shadow)

Usage

Basic Usage

Using Shadow is not very straightforward, mostly due to the borrowing of the “Vari” language used to write shader programs, which does not have much documentation. It does however try to stay familiar and resembles Common Lisp. Additionally, there are several videos of Vari's usage created by its author.

Shader programs are written using a series of DEFUN-GPU and DEFSTRUCT-GPU forms representing GPU functions and structures respectively. As mentioned, their bodies follow the language rules of “Vari”, which is not documented here.

Each DEFUN-GPU defines a shader stage or auxillary function thereof. It takes in input arguments and uniform variables, and sends its return values to the next stage of the shader pipeline as input arguments. The vertex stage's input arguments correspond to your Vertex Array Object attributes.

A simple OpenGL shader program:

(defun-gpu foo-vert ((position :vec3) (uv :vec2) &uniform (mvp :mat4))
  (values (* mvp (vec4 position 1))
          (vec4 1 0 0 1)))

(defun-gpu foo-frag ((color :vec4))
  (values color))

This defines 2 GPU functions, foo-vert and foo-frag that will serve as a very simple program once translated and compiled.

To use this program it first must be translated from the Lisp-like “Vari” language, into GLSL. This is done with the DEFINE-SHADER macro:

(define-shader :example-program (:version 330 :primitive :points)
  (:vertex (foo-vert :vec3 :vec2))
  (:fragment (foo-frag :vec4)))

Above, we call DEFINE-SHADER with a name to call our program, :example-program, the default stage version to use, :version 330, and the OpenGL drawing primitive the vertex stage should use, :primitive :points, followed by a sequence of “stage-specs” of the form: (stage-type function-spec):

stage-type may be one of: :vertex, :tessellation-control, :tessellation-evaluation, :geometry, :fragment, or :compute.

func-spec specifies which DEFUN-GPU function to use for this stage, and is a list consisting of the function name followed by the types of all of its input arguments. The types are important because the “Vari” shader language allows the same function name to exist with different signatures, so you must be explicit in which function you want to translate to GLSL.

Issuing the call to DEFINE-SHADER produces a PROGRAM object, which includes some useful information:

The VIEW-SOURCE function can be used to retrieve the translated Varo → GLSL source for a given program and stage type:

(define-shader ...)

(view-source * :vertex)

#|
"#version 330

layout(location = 0)  in vec3 POSITION;
layout(location = 1)  in vec2 UV;

out _FROM_VERTEX_STAGE_
{
     out vec4 _VERTEX_STAGE_OUT_1;
} v_out;

uniform mat4 MVP;

void main()
{
    gl_Position = (MVP * vec4(POSITION,float(1)));
    v_out._VERTEX_STAGE_OUT_1 = vec4(float(1),float(0),float(0),float(1));
    return;
}"
T
|#

(view-source ** :fragment)

#|
"#version 330

in _FROM_VERTEX_STAGE_
{
     in vec4 _VERTEX_STAGE_OUT_1;
} v_in;

layout(location = 0)  out vec4 _FRAGMENT_STAGE_OUT_0;

void main()
{
    _FRAGMENT_STAGE_OUT_0 = v_in._VERTEX_STAGE_OUT_1;
    return;
}"
T
|#

As can be seen by the GLSL source, our vertex stage function is properly making use of the VALUES form. It takes the first value for itself, setting gl_Position, and passes all subsequent values as input arguments to the fragment stage, (vec4 1 0 0 1), which takes that for itself as the final fragment color of the pipeline.

So far, we have only translated the “Vari” shader language into the GLSL language understood by OpenGL. We still have to compile the shader stages and link the final program object on the GPU.

At this point, a valid OpenGL context is needed to continue.

To compile a program's stages and link them into a program, you can use the BUILD-SHADER-PROGRAM function:

(build-shader-program :example-program)

This will compile all of the stages previously translated to GLSL in our :example-game program, and link it into a program object on the GPU. This returns a non-zero integer on success.

Alternatively, you can compile and link all GLSL translated programs in one shot, by using the BUILD-SHADER-DICTIONARY function, which takes no arguments and returns a hash table of all program objects keyed by name.

The only thing left to do, is make use of the shader program to do your rendering. This is done by issuing calls to the various UNIFORM-* functions within the body of the WITH-SHADER-PROGRAM macro:

(with-shader-program :example-program
  (uniform-mat4 :mvp *matrix*))

Here, we specify that we want to use :example-program during rendering, modifying a single 4x4 matrix uniform value. Here *matrix* refers to an imaginary matrix that you should have created for the object you wish to render. There are quite a few UNIFORM-* functions, and the full list can be viewed in the package's exported symbols. Note that each uniform function takes the name of a uniform variable as a keyword symbol, followed by the value to modify it with.

UBO/SSBO Support

Shadow also includes support for uniform buffer objects (UBO's) and shader storage buffer objects (SSBO's).

A buffer-backed interface block in Shadow is implemented as a struct with DEFSTRUCT-GPU. Anytime a particular shader function wishes to read or write to this buffer, it must be specified in that function's signature using the &uniform part of its lambda list. To do this, you must know the name of the struct, whether you want to access a UBO or SSBO buffer, and the packing layout of that buffer (std140 or std430). For example, this function binds the symbol var using the previously defined struct, foo-block, which will be later filled as an SSBO using the layout rules of the std430 specification:

(defun foo (&uniform (var foo-block :ssbo :std430)
  ...))

This special uniform syntax must be present for each function that needs to access a buffer.

Creating block aliases

On the CPU side, we can create aliases for blocks. This is useful, because the same block name can refer to multiple blocks, even in the context of the same shader program. To create a block alias, use CREATE-BLOCK-ALIAS:

(create-block-alias <block-type> <block-id> <program-name> <block-alias>)
  • <block-type>: The keyword symbol :buffer or :uniform, depending if this block is a block which should be used with an SSBO or UBO, respectively.

  • <block-id>: The name of the block. This is always a keyword symbol, derived from the name given to the struct.

  • <program-name>: A symbol denoting the name of the program where this block can be found, as defined with DEFINE-SHADER.

  • <block-alias>: An identifier to be used to reference this block. May be a symbol, keyword symbol, or a case-sensitive string.

Deleting block aliases

It may be useful to delete a block alias. You can do so using DELETE-BLOCK-ALIAS:

(delete-block-alias <block-alias> &key unbind-block)
  • <block-alias>: An identifier to be used to reference this block. May be a symbol, keyword symbol, or a case-sensitive string.

  • <unbind-buffer>: When non-NIL, also disassociates the block from a binding point.

Referencing Blocks

To find a block object in Shadow's state, you can use FIND-BLOCK:

(find-block <block-alias>)
  • <block-alias>: A symbol, keyword symbol, or case-sensitive string denoting an alias previously defined with CREATE-BLOCK-ALIAS.

Binding Blocks

A block must be bound to a “binding point” for use. A buffer is then bound to this same binding point to associate them with each other. To bind a block to a binding point, use BIND-BLOCK:

(bind-block <block-alias> <binding-point>)
  • <block-alias>: A symbol, keyword symbol, or case-sensitive string denoting an alias previously defined with CREATE-BLOCK-ALIAS.

  • <binding-point>: An integer to bind the block to. This ranges from 1 to a driver-dependent maximum.

Unbinding Blocks

To disassociate a block from a binding point, use UNBIND-BLOCK:

(unbind-block <block-alias>)
  • <block-alias>: A symbol, keyword symbol, or case-sensitive string denoting an alias previously defined with CREATE-BLOCK-ALIAS.

Creating Buffers

To create a buffer, you first need to create a block alias as per the above instructions. You can then create a buffer which uses the layout of a particular block, using CREATE-BUFFER:

(create-buffer <buffer-name> <block-alias>)
````

* `<buffer-name>`: A symbol that can later be used as a reference to the created buffer.

* `<block-alias>`: A symbol, keyword symbol, or case-sensitive string denoting an alias previously
  defined with `CREATE-BLOCK-ALIAS`.

#### Binding Buffers

To bind a buffer to a binding point, use `BIND-BUFFER`:

```lisp
(bind-buffer <buffer-name> <binding-point>)
  • <buffer-name>: The name of a buffer that was defined with CREATE-BUFFER.

  • <binding-point>: An integer to bind the buffer to. This ranges from 1 to a driver-dependent maximum.

Unbinding Buffers

To disassociate a buffer from a binding point, use UNBIND-BUFFER:

(unbind-buffer <buffer-name>)
  • <buffer-name>: The name of a buffer that was defined with CREATE-BUFFER.

Deleting Buffers

(delete-buffer <buffer-name>)
  • <buffer-name>: The name of a buffer that was defined with CREATE-BUFFER.

License

Copyright © 2018 Michael Fiano.

Licensed under the MIT License.

Package Index

    SHADOW

    • class (

      FLOAT

      &OPTIONAL (LOW '*) (HIGH '*))
      No docstring provided.
    • class

      V-ARRAY

      No docstring provided.
    • class

      V-BOOL

      No docstring provided.
    • class

      V-BVEC2

      No docstring provided.
    • class

      V-BVEC3

      No docstring provided.
    • class

      V-BVEC4

      No docstring provided.
    • class

      V-DMAT2

      No docstring provided.
    • class

      V-DMAT3

      No docstring provided.
    • class

      V-DMAT4

      No docstring provided.
    • class

      V-DVEC2

      No docstring provided.
    • class

      V-DVEC3

      No docstring provided.
    • class

      V-DVEC4

      No docstring provided.
    • class

      V-ERROR

      No docstring provided.
    • class

      V-FLOAT

      No docstring provided.
    • class

      V-INT

      No docstring provided.
    • class

      V-IVEC2

      No docstring provided.
    • class

      V-IVEC3

      No docstring provided.
    • class

      V-IVEC4

      No docstring provided.
    • class

      V-MAT2

      No docstring provided.
    • class

      V-MAT3

      No docstring provided.
    • class

      V-MAT4

      No docstring provided.
    • class

      V-OR

      No docstring provided.
    • class

      V-RATIO

      No docstring provided.
    • class

      V-REAL

      No docstring provided.
    • class

      V-TYPE

      No docstring provided.
    • class

      V-UINT

      No docstring provided.
    • class

      V-UVEC2

      No docstring provided.
    • class

      V-UVEC3

      No docstring provided.
    • class

      V-UVEC4

      No docstring provided.
    • class

      V-VEC2

      No docstring provided.
    • class

      V-VEC3

      No docstring provided.
    • class

      V-VEC4

      No docstring provided.
    • class

      V-VOID

      No docstring provided.
    • type (

      MOD

      N)
      No docstring provided.
    • type

      NOT

      No docstring provided.
    • function (

      ABS

      NUMBER)
      Return the absolute value of the number.
    • function (

      ACOS

      NUMBER)
      Return the arc cosine of NUMBER.
    • function (

      ACOSH

      NUMBER)
      Return the hyperbolic arc cosine of NUMBER.
    • function (

      ASIN

      NUMBER)
      Return the arc sine of NUMBER.
    • function (

      ASINH

      NUMBER)
      Return the hyperbolic arc sine of NUMBER.
    • function (

      ATAN

      Y &OPTIONAL X)
      Return the arc tangent of Y if X is omitted or Y/X if X is supplied.
    • function (

      ATANH

      NUMBER)
      Return the hyperbolic arc tangent of NUMBER.
    • function (

      BIND-BLOCK

      BLOCK-ALIAS BINDING-POINT)
      Bind a block referenced by BLOCK-ALIAS to a binding point.
    • function (

      BIND-BUFFER

      BUFFER-NAME BINDING-POINT)
      Bind a buffer with name BUFFER-NAME to BINDING-POINT.
    • function (

      BUILD-SHADER-DICTIONARY

      )
      Compile all shader programs defined with MAKE-SHADER-PROGRAM.
      
      See MAKE-SHADER-PROGRAM
    • function (

      BUILD-SHADER-PROGRAM

      NAME)
      Compile the shader stages of NAME, linking them into a program. NAME refers to a previously
      defined shader program using MAKE-SHADER-PROGRAM.
      
      See MAKE-SHADER-PROGRAM
    • function (

      CONTINUE

      &OPTIONAL CONDITION)
      Transfer control to a restart named CONTINUE, or return NIL if none exists.
    • function (

      COS

      NUMBER)
      Return the cosine of NUMBER.
    • function (

      COSH

      NUMBER)
      Return the hyperbolic cosine of NUMBER.
    • function (

      CREATE-BLOCK-ALIAS

      BLOCK-TYPE BLOCK-ID PROGRAM-NAME BLOCK-ALIAS)
      No docstring provided.
    • function (

      CREATE-BUFFER

      BUFFER-NAME BLOCK-ALIAS)
      Create a buffer of the given TYPE and NAME, using the block BLOCK-ID of PROGRAM-NAME.
    • function (

      DELETE-BUFFER

      BUFFER-NAME)
      Delete the buffer having a name of BUFFER-NAME.
    • function (

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

      EXP

      NUMBER)
      Return e raised to the power NUMBER.
    • function (

      FIND-BLOCK

      BLOCK-ALIAS)
      No docstring provided.
    • function (

      FIND-PROGRAM

      PROGRAM-NAME)
      No docstring provided.
    • function (

      FLOAT

      NUMBER &OPTIONAL OTHER)
      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.
    • function (

      FLOOR

      NUMBER &OPTIONAL (DIVISOR 1))
      Return the greatest integer not greater than number, or number/divisor.
        The second returned value is (mod number divisor).
    • function (

      LENGTH

      SEQUENCE)
      Return an integer that is the length of SEQUENCE.
    • function (

      LOG

      NUMBER &OPTIONAL BASE)
      Return the logarithm of NUMBER in the base BASE, which defaults to e.
    • function (

      MAX

      NUMBER &REST MORE-NUMBERS)
      Return the greatest of its arguments; among EQUALP greatest, return
      the first.
    • function (

      MIN

      NUMBER &REST MORE-NUMBERS)
      Return the least of its arguments; among EQUALP least, return
      the first.
    • function (

      MOD

      NUMBER DIVISOR)
      Return second result of FLOOR.
    • function (

      NOT

      OBJECT)
      Return T if X is NIL, otherwise return NIL.
    • function (

      ROUND

      NUMBER &OPTIONAL (DIVISOR 1))
      Rounds number (or number/divisor) to nearest integer.
        The second returned value is the remainder.
    • function (

      SET-MODIFY-HOOK

      FUNCTION)
      Specify a function to be called when shader programs need to be updated.
    • function (

      SIN

      NUMBER)
      Return the sine of NUMBER.
    • function (

      SINH

      NUMBER)
      Return the hyperbolic sine of NUMBER.
    • function (

      SQRT

      NUMBER)
      Return the square root of NUMBER.
    • function (

      TAN

      NUMBER)
      Return the tangent of NUMBER.
    • function (

      TANH

      NUMBER)
      Return the hyperbolic tangent of NUMBER.
    • function (

      UNBIND-BLOCK

      BLOCK-ALIAS)
      Unbind a block with the alias BLOCK-ALIAS.
    • function (

      UNBIND-BUFFER

      BUFFER-NAME)
      Unbind a buffer with name BUFFER-NAME.
    • function (

      UNIFORM-FLOAT

      UNIFORM VALUE)
      Specify a float as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-FLOAT-ARRAY

      UNIFORM VALUE)
      Specify an array of floats as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-INT

      UNIFORM VALUE)
      Specify an integer as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-INT-ARRAY

      UNIFORM VALUE)
      Specify an array of integers as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-MAT2

      UNIFORM VALUE)
      Specify a mat2 as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-MAT2-ARRAY

      UNIFORM VALUE)
      Specify an array of mat2's as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-MAT3

      UNIFORM VALUE)
      Specify a mat3 as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-MAT3-ARRAY

      UNIFORM VALUE)
      Specify an array of mat3's as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-MAT4

      UNIFORM VALUE)
      Specify a mat4 as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-MAT4-ARRAY

      UNIFORM VALUE)
      Specify an array of mat4's as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-VEC2

      UNIFORM VALUE)
      Specify a vec2 as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-VEC2-ARRAY

      UNIFORM VALUE)
      Specify an array of vec2's as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-VEC3

      UNIFORM VALUE)
      Specify a vec3 as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-VEC3-ARRAY

      UNIFORM VALUE)
      Specify an array of vec3's as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-VEC4

      UNIFORM VALUE)
      Specify a vec4 as the VALUE for the uniform variable, UNIFORM.
    • function (

      UNIFORM-VEC4-ARRAY

      UNIFORM VALUE)
      Specify an array of vec4's as the VALUE for the uniform variable, UNIFORM.
    • function (

      VARI-DESCRIBE

      NAME &OPTIONAL (STREAM *STANDARD-OUTPUT*) TRY-PACKAGE-NAME)
      No docstring provided.
    • function (

      VIEW-SOURCE

      PROGRAM-NAME STAGE)
      No docstring provided.
    • function (

      WRITE-BUFFER-PATH

      BUFFER-NAME PATH VALUE)
      Write VALUE to the buffer with the name BUFFER-NAME, starting at the given PATH.
      
      PATH: A "dot-separated" keyword symbol, where each part denotes a member in the buffer's block
      layout.
      
      VALUE: A value to write, such as a scalar or matrix depending on the type of the member PATH refers
      to. To write to an array, use a sequence of values.
      
      Note: Writing to arrays which contain other aggregate types (other arrays or structures) is not
      possible. This is a design decision to allow this library to have a simple "path-based" buffer
      writing interface.
    • generic (

      KIND

      METADATA)
      No docstring provided.
    • generic (

      ORDER

      METADATA)
      No docstring provided.
    • generic (

      PRIMITIVE

      METADATA)
      No docstring provided.
    • generic (

      SPACING

      METADATA)
      No docstring provided.
    • generic (

      UNIFORMS

      OBJECT)
      No docstring provided.
    • generic (

      VERTICES

      METADATA)
      No docstring provided.
    • macro (

      %PEEK

      THING)
      No docstring provided.
    • macro (

      DEF-METADATA-INFER

      VARJO-TYPE-SPEC METADATA-KIND ENV-VAR &BODY BODY)
      `def-metadata-infer` is the older syntax for `define-metadata-infer`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      DEF-METADATA-KIND

      NAME (&KEY CONC-NAME (BINDS-TO)) &BODY SLOT-NAMES)
      `def-metadata-kind` is the older syntax for `define-metadata-kind`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      DEFINE-METADATA-INFER

      VARJO-TYPE-SPEC METADATA-KIND ENV-VAR &BODY BODY)
      `define-metadata-infer` lets you define
      
    • macro (

      DEFINE-METADATA-KIND

      NAME (&KEY CONC-NAME (BINDS-TO)) &BODY SLOT-NAMES)
      `define-metadata-kind` lets you define
      
    • macro (

      DEFINE-SHADER

      NAME (&KEY (VERSION) (PRIMITIVE)) &BODY BODY)
      Create a new shader program using the stage-specs defined in BODY.
      
      VERSION: The default version shader stages use, and can be overridden on a per-function basis.
      
      PRIMITIVE: The drawing primitive to use for the vertex stage.
    • macro (

      DEFMACRO-GPU

      NAME LAMBDA-LIST &BODY BODY)
      Define a GPU macro.
    • macro (

      DEFSTRUCT-GPU

      NAME NIL &BODY SLOTS)
      Define a GPU structure.
    • macro (

      DEFUN-GPU

      NAME ARGS &BODY BODY)
      Define a GPU function.
    • macro (

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

      V-DEF-GLSL-TEMPLATE-FUN

      NAME ARGS TRANSFORM ARG-TYPES RETURN-SPEC &KEY V-PLACE-INDEX GLSL-NAME PURE)
      `v-def-glsl-template-fun` is the older syntax for `define-glsl-template-function`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFINE-COMPILER-MACRO

      NAME LAMBDA-LIST &BODY BODY)
      `v-define-compiler-macro` is the older syntax for `define-vari-compiler-macro`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFMACRO

      NAME LAMBDA-LIST &BODY BODY)
      `v-defmacro` is the older syntax for `define-vari-macro`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFSTRUCT

      NAME CONTEXT &BODY SLOTS)
      `v-defstruct` is the older syntax for `define-vari-struct`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFTYPE

      NAME ARGS TYPE-FORM &KEY VALID-METADATA-KINDS)
      `v-deftype` is the older syntax for `define-vari-type`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFUN

      NAME ARGS &BODY BODY)
      `v-defun` is the older syntax for `define-vari-function`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      WITH-SHADER-PROGRAM

      NAME &BODY BODY)
      Run a body of code which uses (as in glUseProgram) the program identified by NAME.

    SHADOW.LANG

    • constant

      BOOLE-1

      Boole function op, makes BOOLE return integer1.
    • constant

      BOOLE-2

      Boole function op, makes BOOLE return integer2.
    • constant

      BOOLE-AND

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

      BOOLE-ANDC1

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

      BOOLE-ANDC2

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

      BOOLE-C1

      Boole function op, makes BOOLE return complement of integer1.
    • constant

      BOOLE-C2

      Boole function op, makes BOOLE return complement of integer2.
    • constant

      BOOLE-CLR

      Boole function op, makes BOOLE return 0.
    • constant

      BOOLE-EQV

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

      BOOLE-IOR

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

      BOOLE-NAND

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

      BOOLE-NOR

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

      BOOLE-ORC1

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

      BOOLE-ORC2

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

      BOOLE-SET

      Boole function op, makes BOOLE return -1.
    • constant

      BOOLE-XOR

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

      CALL-ARGUMENTS-LIMIT

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

      CHAR-CODE-LIMIT

      the upper exclusive bound on values produced by CHAR-CODE
    • constant

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

      LAMBDA-PARAMETERS-LIMIT

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

      MULTIPLE-VALUES-LIMIT

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

      NIL

      No docstring provided.
    • constant

      PI

      No docstring provided.
    • constant

      T

      No docstring provided.
    • special

      *

      the value of the most recent top level EVAL
    • special

      **

      the previous value of *
    • special

      ***

      the previous value of **
    • special

      *BREAK-ON-SIGNALS*

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

      *COMPILE-FILE-PATHNAME*

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

      *COMPILE-PRINT*

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

      *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.
    • special

      *FEATURES*

      a list of symbols that describe features provided by the
         implementation
    • special

      *LOAD-PATHNAME*

      the defaulted pathname that LOAD is currently loading
    • special

      *LOAD-PRINT*

      the default for the :PRINT argument to LOAD
    • special

      *LOAD-TRUENAME*

      the TRUENAME of the file that LOAD is currently loading
    • special

      *LOAD-VERBOSE*

      the default for the :VERBOSE argument to LOAD
    • special

      *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.
    • special

      *MODULES*

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

      *PRINT-ARRAY*

      Should the contents of arrays be printed?
    • special

      *PRINT-BASE*

      The output base for RATIONALs (including integers).
    • special

      *PRINT-CASE*

      What case should the printer should use default?
    • special

      *PRINT-CIRCLE*

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

      *PRINT-ESCAPE*

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

      *PRINT-GENSYM*

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

      *PRINT-LENGTH*

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

      *PRINT-LEVEL*

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

      *PRINT-LINES*

      The maximum number of lines to print per object.
    • special

      *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.
    • special

      *PRINT-RADIX*

      Should base be verified when printing RATIONALs?
    • special

      *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*.
    • special

      *READ-BASE*

      the radix that Lisp reads numbers in
    • special

      *READ-EVAL*

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

      *READTABLE*

      Variable bound to current readtable.
    • special

      +

      the value of the most recent top level READ
    • special

      ++

      the previous value of +
    • special

      +++

      the previous value of ++
    • special

      -

      the form currently being evaluated
    • special

      /

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

      //

      the previous value of /
    • special

      ///

      the previous value of //
    • class (

      ARRAY

      &OPTIONAL (ELEMENT-TYPE '*) (DIMENSIONS '*))
      No docstring provided.
    • class (

      BASE-STRING

      &OPTIONAL SIZE)
      No docstring provided.
    • class

      BIGNUM

      No docstring provided.
    • class (

      BIT-VECTOR

      &OPTIONAL SIZE)
      No docstring provided.
    • class

      CLASS

      No docstring provided.
    • class (

      COMPLEX

      &OPTIONAL (TYPESPEC '*))
      No docstring provided.
    • class (

      CONS

      &OPTIONAL (CAR-TYPE-SPEC '*) (CDR-TYPE-SPEC '*))
      No docstring provided.
    • class (

      DOUBLE-FLOAT

      &OPTIONAL (LOW '*) (HIGH '*))
      No docstring provided.
    • class

      FIXNUM

      No docstring provided.
    • class (

      FLOAT

      &OPTIONAL (LOW '*) (HIGH '*))
      No docstring provided.
    • class (

      FUNCTION

      &OPTIONAL (ARGS '*) (RESULT '*))
      No docstring provided.
    • class (

      INTEGER

      &OPTIONAL (LOW '*) (HIGH '*))
      No docstring provided.
    • class

      LIST

      No docstring provided.
    • class

      METHOD

      No docstring provided.
    • class

      NULL

      No docstring provided.
    • class

      NUMBER

      No docstring provided.
    • class

      PACKAGE

      the standard structure for the description of a package
    • class

      RATIO

      No docstring provided.
    • class (

      RATIONAL

      &OPTIONAL (LOW '*) (HIGH '*))
      No docstring provided.
    • class

      READTABLE

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

      REAL

      &OPTIONAL (LOW '*) (HIGH '*))
      No docstring provided.
    • class

      RESTART

      No docstring provided.
    • class (

      SIMPLE-ARRAY

      &OPTIONAL (ELEMENT-TYPE '*) (DIMENSIONS '*))
      No docstring provided.
    • class (

      SINGLE-FLOAT

      &OPTIONAL (LOW '*) (HIGH '*))
      No docstring provided.
    • class

      STREAM

      No docstring provided.
    • class (

      STRING

      &OPTIONAL SIZE)
      No docstring provided.
    • class

      SYMBOL

      No docstring provided.
    • class

      T

      No docstring provided.
    • class

      V-ARRAY

      No docstring provided.
    • class

      V-BOOL

      No docstring provided.
    • class

      V-BVEC2

      No docstring provided.
    • class

      V-BVEC3

      No docstring provided.
    • class

      V-BVEC4

      No docstring provided.
    • class

      V-DMAT2

      No docstring provided.
    • class

      V-DMAT3

      No docstring provided.
    • class

      V-DMAT4

      No docstring provided.
    • class

      V-DVEC2

      No docstring provided.
    • class

      V-DVEC3

      No docstring provided.
    • class

      V-DVEC4

      No docstring provided.
    • class

      V-ERROR

      No docstring provided.
    • class

      V-FLOAT

      No docstring provided.
    • class

      V-INT

      No docstring provided.
    • class

      V-IVEC2

      No docstring provided.
    • class

      V-IVEC3

      No docstring provided.
    • class

      V-IVEC4

      No docstring provided.
    • class

      V-MAT2

      No docstring provided.
    • class

      V-MAT3

      No docstring provided.
    • class

      V-MAT4

      No docstring provided.
    • class

      V-OR

      No docstring provided.
    • class

      V-RATIO

      No docstring provided.
    • class

      V-REAL

      No docstring provided.
    • class

      V-TYPE

      No docstring provided.
    • class

      V-UINT

      No docstring provided.
    • class

      V-UVEC2

      No docstring provided.
    • class

      V-UVEC3

      No docstring provided.
    • class

      V-UVEC4

      No docstring provided.
    • class

      V-VEC2

      No docstring provided.
    • class

      V-VEC3

      No docstring provided.
    • class

      V-VEC4

      No docstring provided.
    • class

      V-VOID

      No docstring provided.
    • class (

      VECTOR

      &OPTIONAL ELEMENT-TYPE SIZE)
      No docstring provided.
    • condition

      ERROR

      No docstring provided.
    • condition

      NIL

      No docstring provided.
    • condition

      WARNING

      No docstring provided.
    • structure

      NIL

      No docstring provided.
    • type

      *

      No docstring provided.
    • type

      AND

      No docstring provided.
    • type

      ATOM

      No docstring provided.
    • type

      BIT

      No docstring provided.
    • type

      BOOLEAN

      No docstring provided.
    • type (

      EQL

      N)
      No docstring provided.
    • type

      KEYWORD

      No docstring provided.
    • type (

      LONG-FLOAT

      &OPTIONAL LOW HIGH)
      No docstring provided.
    • type

      MEMBER

      No docstring provided.
    • type (

      MOD

      N)
      No docstring provided.
    • type

      NOT

      No docstring provided.
    • type

      OR

      No docstring provided.
    • type (

      SHORT-FLOAT

      &OPTIONAL LOW HIGH)
      No docstring provided.
    • type (

      SIGNED-BYTE

      &OPTIONAL S)
      No docstring provided.
    • type

      STANDARD-CHAR

      Type corresponding to the characters required by the standard.
    • type

      VALUES

      No docstring provided.
    • accessor (

      AREF

      ARRAY &REST SUBSCRIPTS)
      Return the element of the ARRAY specified by the SUBSCRIPTS.
    • accessor (

      BIT

      BIT-ARRAY &REST SUBSCRIPTS)
      Return the bit from the BIT-ARRAY at the specified SUBSCRIPTS.
    • accessor (

      CAAAAR

      LIST)
      Return the car of the caaar of a list.
    • accessor (

      CAAADR

      LIST)
      Return the car of the caadr of a list.
    • accessor (

      CAAAR

      LIST)
      Return the 1st object in the caar of a list.
    • accessor (

      CAADAR

      LIST)
      Return the car of the cadar of a list.
    • accessor (

      CAADDR

      LIST)
      Return the car of the caddr of a list.
    • accessor (

      CAADR

      LIST)
      Return the 1st object in the cadr of a list.
    • accessor (

      CAAR

      LIST)
      Return the car of the 1st sublist.
    • accessor (

      CADAAR

      LIST)
      Return the car of the cdaar of a list.
    • accessor (

      CADADR

      LIST)
      Return the car of the cdadr of a list.
    • accessor (

      CADAR

      LIST)
      Return the car of the cdar of a list.
    • accessor (

      CADDAR

      LIST)
      Return the car of the cddar of a list.
    • accessor (

      CADDDR

      LIST)
      Return the car of the cdddr of a list.
    • accessor (

      CADDR

      LIST)
      Return the 1st object in the cddr of a list.
    • accessor (

      CADR

      LIST)
      Return the 2nd object in a list.
    • accessor (

      CAR

      LIST)
      Return the 1st object in a list.
    • accessor (

      CDAAAR

      LIST)
      Return the cdr of the caaar of a list.
    • accessor (

      CDAADR

      LIST)
      Return the cdr of the caadr of a list.
    • accessor (

      CDAAR

      LIST)
      Return the cdr of the caar of a list.
    • accessor (

      CDADAR

      LIST)
      Return the cdr of the cadar of a list.
    • accessor (

      CDADDR

      LIST)
      Return the cdr of the caddr of a list.
    • accessor (

      CDADR

      LIST)
      Return the cdr of the cadr of a list.
    • accessor (

      CDAR

      LIST)
      Return the cdr of the 1st sublist.
    • accessor (

      CDDAAR

      LIST)
      Return the cdr of the cdaar of a list.
    • accessor (

      CDDADR

      LIST)
      Return the cdr of the cdadr of a list.
    • accessor (

      CDDAR

      LIST)
      Return the cdr of the cdar of a list.
    • accessor (

      CDDDAR

      LIST)
      Return the cdr of the cddar of a list.
    • accessor (

      CDDDDR

      LIST)
      Return the cdr of the cdddr of a list.
    • accessor (

      CDDDR

      LIST)
      Return the cdr of the cddr of a list.
    • accessor (

      CDDR

      LIST)
      Return all but the 1st two objects of a list.
    • accessor (

      CDR

      LIST)
      Return all but the first object in a list.
    • accessor (

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

      CLASS-NAME

      CLASS)
      No docstring provided.
    • accessor (

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

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

      EIGHTH

      LIST)
      Return the 8th object in a list or NIL if there is no 8th object.
    • accessor (

      ELT

      SEQUENCE INDEX)
      Return the element of SEQUENCE specified by INDEX.
    • accessor (

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

      FIFTH

      LIST)
      Return the 5th object in a list or NIL if there is no 5th object.
    • accessor (

      FILL-POINTER

      VECTOR)
      Return the FILL-POINTER of the given VECTOR.
    • accessor (

      FIND-CLASS

      SYMBOL &OPTIONAL (ERRORP T) ENVIRONMENT)
      No docstring provided.
    • accessor (

      FIRST

      LIST)
      Return the 1st object in a list or NIL if the list is empty.
    • accessor (

      FOURTH

      LIST)
      Return the 4th object in a list or NIL if there is no 4th object.
    • accessor (

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

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

      NINTH

      LIST)
      Return the 9th object in a list or NIL if there is no 9th object.
    • accessor (

      NTH

      N LIST)
      Return the nth object in a list where the car is the zero-th element.
    • accessor (

      REST

      LIST)
      Means the same as the cdr of a list.
    • accessor (

      ROW-MAJOR-AREF

      ARRAY INDEX)
      Return the element of array corresponding to the row-major index. This is
         SETFable.
    • accessor (

      SBIT

      SIMPLE-BIT-ARRAY &REST SUBSCRIPTS)
      Return the bit from SIMPLE-BIT-ARRAY at the specified SUBSCRIPTS.
    • accessor (

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

      SECOND

      LIST)
      Return the 2nd object in a list or NIL if there is no 2nd object.
    • accessor (

      SEVENTH

      LIST)
      Return the 7th object in a list or NIL if there is no 7th object.
    • accessor (

      SIXTH

      LIST)
      Return the 6th object in a list or NIL if there is no 6th object.
    • accessor (

      SLOT-VALUE

      OBJECT SLOT-NAME)
      No docstring provided.
    • accessor (

      SVREF

      SIMPLE-VECTOR INDEX)
      Return the INDEXth element of the given Simple-Vector.
    • accessor (

      SYMBOL-FUNCTION

      SYMBOL)
      Return SYMBOL's current function definition. Settable with SETF.
    • accessor (

      SYMBOL-PLIST

      SYMBOL)
      Return SYMBOL's property list.
    • accessor (

      SYMBOL-VALUE

      SYMBOL)
      Return SYMBOL's current bound value.
    • accessor (

      TENTH

      LIST)
      Return the 10th object in a list or NIL if there is no 10th object.
    • accessor (

      THIRD

      LIST)
      Return the 3rd object in a list or NIL if there is no 3rd object.
    • function (

      *

      &REST NUMBERS)
      Return the product of its arguments. With no args, returns 1.
    • function (

      +

      &REST NUMBERS)
      Return the sum of its arguments. With no args, returns 0.
    • function (

      -

      NUMBER &REST MORE-NUMBERS)
      Subtract the second and all subsequent arguments from the first;
        or with one argument, negate the first argument.
    • function (

      /

      NUMBER &REST MORE-NUMBERS)
      Divide the first argument by each of the following arguments, in turn.
        With one argument, return reciprocal.
    • function (

      /=

      NUMBER &REST MORE-NUMBERS)
      Return T if no two of its arguments are numerically equal, NIL otherwise.
    • function (

      1+

      NUMBER)
      Return NUMBER + 1.
    • function (

      1-

      NUMBER)
      Return NUMBER - 1.
    • function (

      <

      NUMBER &REST MORE-NUMBERS)
      Return T if its arguments are in strictly increasing order, NIL otherwise.
    • function (

      <=

      NUMBER &REST MORE-NUMBERS)
      Return T if arguments are in strictly non-decreasing order, NIL otherwise.
    • function (

      =

      NUMBER &REST MORE-NUMBERS)
      Return T if all of its arguments are numerically equal, NIL otherwise.
    • function (

      >

      NUMBER &REST MORE-NUMBERS)
      Return T if its arguments are in strictly decreasing order, NIL otherwise.
    • function (

      >=

      NUMBER &REST MORE-NUMBERS)
      Return T if arguments are in strictly non-increasing order, NIL otherwise.
    • function (

      ABORT

      &OPTIONAL CONDITION)
      Transfer control to a restart named ABORT, signalling a CONTROL-ERROR if
         none exists.
    • function (

      ABS

      NUMBER)
      Return the absolute value of the number.
    • function (

      ACONS

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

      ACOS

      NUMBER)
      Return the arc cosine of NUMBER.
    • function (

      ACOSH

      NUMBER)
      Return the hyperbolic arc cosine of NUMBER.
    • function (

      ADJOIN

      ITEM LIST &KEY KEY (TEST (FUNCTION EQL)) TEST-NOT)
      Add ITEM to LIST unless it is already a member
    • function (

      ADJUST-ARRAY

      ARRAY DIMENSIONS &KEY (ELEMENT-TYPE (ARRAY-ELEMENT-TYPE ARRAY)) INITIAL-ELEMENT INITIAL-CONTENTS FILL-POINTER DISPLACED-TO DISPLACED-INDEX-OFFSET)
      Adjust ARRAY's dimensions to the given DIMENSIONS and stuff.
    • function (

      ADJUSTABLE-ARRAY-P

      ARRAY)
      Return T if and only if calling ADJUST-ARRAY on ARRAY will return
         the identical object.
    • function (

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

      ALPHANUMERICP

      CHAR)
      Given a character-object argument, ALPHANUMERICP returns T if the argument
      is either numeric or alphabetic.
    • function (

      APPEND

      &REST LISTS)
      Construct a new list by concatenating the list arguments
    • function (

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

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

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

      ARRAY-DIMENSION

      ARRAY AXIS-NUMBER)
      Return the length of dimension AXIS-NUMBER of ARRAY.
    • function (

      ARRAY-DIMENSIONS

      ARRAY)
      Return a list whose elements are the dimensions of the array
    • function (

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

      ARRAY-IN-BOUNDS-P

      ARRAY &REST SUBSCRIPTS)
      Return T if the SUBSCRIPTS are in bounds for the ARRAY, NIL otherwise.
    • function (

      ARRAY-RANK

      ARRAY)
      Return the number of dimensions of ARRAY.
    • function (

      ARRAY-TOTAL-SIZE

      ARRAY)
      Return the total number of elements in the Array.
    • function (

      ARRAYP

      OBJECT)
      Return true if OBJECT is an ARRAY, and NIL otherwise.
    • function (

      ASH

      INTEGER COUNT)
      Shifts integer left by count places preserving sign. - count shifts right.
    • function (

      ASIN

      NUMBER)
      Return the arc sine of NUMBER.
    • function (

      ASINH

      NUMBER)
      Return the hyperbolic arc sine of NUMBER.
    • function (

      ASSOC

      ITEM ALIST &KEY KEY TEST TEST-NOT)
      Return the cons in ALIST whose car is equal (by a given test or EQL) to
         the ITEM.
    • function (

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

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

      ATAN

      Y &OPTIONAL X)
      Return the arc tangent of Y if X is omitted or Y/X if X is supplied.
    • function (

      ATANH

      NUMBER)
      Return the hyperbolic arc tangent of NUMBER.
    • function (

      ATOM

      OBJECT)
      Return true if OBJECT is an ATOM, and NIL otherwise.
    • function (

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

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

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

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

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

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

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

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

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

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

      BIT-VECTOR-P

      OBJECT)
      Return true if OBJECT is a BIT-VECTOR, and NIL otherwise.
    • function (

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

      BLOCK

      &REST ARGS)
      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.
    • function (

      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
    • function (

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

      BOUNDP

      SYMBOL)
      Return non-NIL if SYMBOL is bound to a value.
    • function (

      BREAK

      &OPTIONAL (DATUM "break") &REST ARGUMENTS)
      Print a message and invoke the debugger without allowing any possibility
      of condition handling occurring.
    • function (

      BUTLAST

      LIST &OPTIONAL (N 1))
      No docstring provided.
    • function (

      BYTE

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

      BYTE-POSITION

      BYTESPEC)
      Return the position part of the byte specifier bytespec.
    • function (

      BYTE-SIZE

      BYTESPEC)
      Return the size part of the byte specifier bytespec.
    • function (

      CATCH

      &REST ARGS)
      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.
    • function (

      CEILING

      NUMBER &OPTIONAL (DIVISOR 1))
      Return the smallest integer not less than number, or number/divisor.
        The second returned value is the remainder.
    • function (

      CERROR

      CONTINUE-STRING DATUM &REST ARGUMENTS)
      No docstring provided.
    • function (

      CHAR-CODE

      CHAR)
      Return the integer code of CHAR.
    • function (

      CHAR-DOWNCASE

      CHAR)
      Return CHAR converted to lower-case if that is possible.
    • function (

      CHAR-EQUAL

      CHARACTER &REST MORE-CHARACTERS)
      Return T if all of the arguments are the same character.
      Case is ignored.
    • function (

      CHAR-GREATERP

      CHARACTER &REST MORE-CHARACTERS)
      Return T if the arguments are in strictly decreasing alphabetic order.
      Case is ignored.
    • function (

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

      CHAR-LESSP

      CHARACTER &REST MORE-CHARACTERS)
      Return T if the arguments are in strictly increasing alphabetic order.
      Case is ignored.
    • function (

      CHAR-NAME

      CHAR)
      Return the name (a STRING) for a CHARACTER object.
    • function (

      CHAR-NOT-EQUAL

      CHARACTER &REST MORE-CHARACTERS)
      Return T if no two of the arguments are the same character.
      Case is ignored.
    • function (

      CHAR-NOT-GREATERP

      CHARACTER &REST MORE-CHARACTERS)
      Return T if the arguments are in strictly non-decreasing alphabetic order.
      Case is ignored.
    • function (

      CHAR-NOT-LESSP

      CHARACTER &REST MORE-CHARACTERS)
      Return T if the arguments are in strictly non-increasing alphabetic order.
      Case is ignored.
    • function (

      CHAR-UPCASE

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

      CHAR/=

      CHARACTER &REST MORE-CHARACTERS)
      Return T if no two of the arguments are the same character.
    • function (

      CHAR<

      CHARACTER &REST MORE-CHARACTERS)
      Return T if the arguments are in strictly increasing alphabetic order.
    • function (

      CHAR<=

      CHARACTER &REST MORE-CHARACTERS)
      Return T if the arguments are in strictly non-decreasing alphabetic order.
    • function (

      CHAR=

      CHARACTER &REST MORE-CHARACTERS)
      Return T if all of the arguments are the same character.
    • function (

      CHAR>

      CHARACTER &REST MORE-CHARACTERS)
      Return T if the arguments are in strictly decreasing alphabetic order.
    • function (

      CHAR>=

      CHARACTER &REST MORE-CHARACTERS)
      Return T if the arguments are in strictly non-increasing alphabetic order.
    • function (

      CHARACTER

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

      CHARACTERP

      OBJECT)
      Return true if OBJECT is a CHARACTER, and NIL otherwise.
    • function (

      CIS

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

      CLASS-OF

      X)
      No docstring provided.
    • function (

      CLEAR-INPUT

      &OPTIONAL (STREAM *STANDARD-INPUT*))
      No docstring provided.
    • function (

      CLEAR-OUTPUT

      &OPTIONAL (STREAM *STANDARD-OUTPUT*))
      No docstring provided.
    • function (

      CLRHASH

      HASH-TABLE)
      This removes all the entries from HASH-TABLE and returns the hash
      table itself.
    • function (

      CODE-CHAR

      CODE)
      Return the character with the code CODE.
    • function (

      COERCE

      OBJECT OUTPUT-TYPE-SPEC)
      Coerce the Object to an object of type Output-Type-Spec.
    • function (

      COMPILE

      NAME &OPTIONAL (DEFINITION (OR (AND (SYMBOLP NAME) (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
      that names a macro, its macro function is replaced and NAME is returned as
      primary value.
      
      Also returns a 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.
      
    • function (

      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 (:BLOCK-COMPILE *BLOCK-COMPILE-ARG*) (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.
    • function (

      COMPILE-FILE-PATHNAME

      INPUT-FILE &KEY OUTPUT-FILE &ALLOW-OTHER-KEYS)
      Return a pathname describing what file COMPILE-FILE would write to given
         these arguments.
    • function (

      COMPILED-FUNCTION-P

      OBJECT)
      Return true if OBJECT is a COMPILED-FUNCTION, and NIL otherwise.
    • function (

      COMPLEMENT

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

      COMPLEX

      REALPART &OPTIONAL (IMAGPART 0))
      Return a complex number with the specified real and imaginary components.
    • function (

      COMPLEXP

      OBJECT)
      Return true if OBJECT is a COMPLEX, and NIL otherwise.
    • function (

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

      CONCATENATE

      RESULT-TYPE &REST SEQUENCES)
      Return a new sequence of all the argument sequences concatenated together
        which shares no structure with the original argument sequences of the
        specified RESULT-TYPE.
    • function (

      CONJUGATE

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

      CONS

      SE1 SE2)
      Return a list with SE1 as the CAR and SE2 as the CDR.
    • function (

      CONSP

      OBJECT)
      Return true if OBJECT is a CONS, and NIL otherwise.
    • function (

      CONSTANTLY

      VALUE)
      Return a function that always returns VALUE.
    • function (

      CONSTANTP

      FORM &OPTIONAL ENVIRONMENT)
      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.
    • function (

      CONTINUE

      &OPTIONAL CONDITION)
      Transfer control to a restart named CONTINUE, or return NIL if none exists.
    • function (

      COPY-ALIST

      ALIST)
      Return a new association list which is EQUAL to ALIST.
    • function (

      COPY-LIST

      LIST)
      Return a new list which is EQUAL to LIST. LIST may be improper.
    • function (

      COPY-READTABLE

      &OPTIONAL (FROM-READTABLE *READTABLE*) TO-READTABLE)
      Copies FROM-READTABLE and returns the result. Uses TO-READTABLE as a target
      for the copy when provided, otherwise a new readtable is created. The
      FROM-READTABLE defaults to the standard readtable when NIL and to the current
      readtable when not provided.
    • function (

      COPY-SEQ

      SEQUENCE)
      Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.
    • function (

      COPY-STRUCTURE

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

      COPY-SYMBOL

      SYMBOL &OPTIONAL COPY-PROPS)
      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.
    • function (

      COPY-TREE

      OBJECT)
      Recursively copy trees of conses.
    • function (

      COS

      NUMBER)
      Return the cosine of NUMBER.
    • function (

      COSH

      NUMBER)
      Return the hyperbolic cosine of NUMBER.
    • function (

      COUNT

      ITEM SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY (TEST (FUNCTION EQL)) TEST-NOT)
      Return the number of elements in SEQUENCE satisfying a test with ITEM,
         which defaults to EQL.
    • function (

      COUNT-IF

      PRED SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)
      Return the number of elements in SEQUENCE satisfying PRED(el).
    • function (

      COUNT-IF-NOT

      PRED SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)
      Return the number of elements in SEQUENCE not satisfying TEST(el).
    • function (

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

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

      DELETE

      ITEM SEQUENCE &REST ARGS &KEY FROM-END (TEST (FUNCTION EQL)) TEST-NOT (START 0) END COUNT KEY)
      Return a sequence formed by destructively removing the specified ITEM from
        the given SEQUENCE.
    • function (

      DELETE-DUPLICATES

      SEQUENCE &REST ARGS &KEY (TEST (FUNCTION EQL)) TEST-NOT (START 0) END FROM-END KEY)
      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.
      
         The :TEST-NOT argument is deprecated.
    • function (

      DELETE-FILE

      FILE)
      Delete the specified FILE.
      
      If FILE is a stream, on Windows the stream is closed immediately. On Unix
      platforms 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.
    • function (

      DELETE-IF

      PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) KEY END COUNT)
      Return a sequence formed by destructively removing the elements satisfying
        the specified PREDICATE from the given SEQUENCE.
    • function (

      DELETE-IF-NOT

      PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY COUNT)
      Return a sequence formed by destructively removing the elements not
        satisfying the specified PREDICATE from the given SEQUENCE.
    • function (

      DELETE-PACKAGE

      PACKAGE-DESIGNATOR)
      Delete the package designated by PACKAGE-DESIGNATOR from the package
        system data structures.
    • function (

      DENOMINATOR

      NUMBER)
      Return the denominator of NUMBER, which must be rational.
    • function (

      DEPOSIT-FIELD

      NEWBYTE BYTESPEC INTEGER)
      Return new integer with newbyte in specified position, newbyte is not right justified.
    • function (

      DESCRIBE

      OBJECT &OPTIONAL (STREAM-DESIGNATOR *STANDARD-OUTPUT*))
      Print a description of OBJECT to STREAM-DESIGNATOR.
    • function (

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

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

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

      DIRECTORY-NAMESTRING

      PATHNAME)
      Return a string representation of the directory in PATHNAME.
    • function (

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

      DPB

      NEWBYTE BYTESPEC INTEGER)
      Return new integer with newbyte in specified position, newbyte is right justified.
    • function (

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

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

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

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

      ENOUGH-NAMESTRING

      PATHNAME &OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*))
      Return an abbreviated pathname sufficient to identify PATHNAME
      relative to DEFAULTS.
    • function (

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

      EQ

      OBJ1 OBJ2)
      Return T if OBJ1 and OBJ2 are the same object, otherwise NIL.
    • function (

      EQL

      X Y)
      No docstring provided.
    • function (

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

      EQUALP

      X Y)
      No docstring provided.
    • function (

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

      EVAL

      ORIGINAL-EXP)
      Evaluate the argument in a null lexical environment, returning the
         result or results.
    • function (

      EVAL-WHEN

      &REST ARGS)
      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).
    • function (

      EVENP

      NUMBER)
      Is this integer even?
    • function (

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

      EXP

      NUMBER)
      Return e raised to the power NUMBER.
    • function (

      EXPORT

      SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))
      Exports SYMBOLS from PACKAGE, checking that no name conflicts result.
    • function (

      EXPT

      BASE POWER)
      Return BASE raised to the POWER.
    • function (

      FBOUNDP

      NAME)
      Return true if name has a global function definition.
    • function (

      FCEILING

      NUMBER &OPTIONAL (DIVISOR 1))
      Same as CEILING, but returns first value as a float.
    • function (

      FFLOOR

      NUMBER &OPTIONAL (DIVISOR 1))
      Same as FLOOR, but returns first value as a float.
    • function (

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

      FILE-NAMESTRING

      PATHNAME)
      Return a string representation of the name in PATHNAME.
    • function (

      FILE-POSITION

      STREAM &OPTIONAL POSITION)
      No docstring provided.
    • function (

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

      FILL

      SEQUENCE ITEM &KEY (START 0) END)
      Replace the specified elements of SEQUENCE with ITEM.
    • function (

      FIND

      ITEM SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY TEST TEST-NOT)
      No docstring provided.
    • function (

      FIND-ALL-SYMBOLS

      STRING-OR-SYMBOL)
      Return a list of all symbols in the system having the specified name.
    • function (

      FIND-IF

      PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)
      No docstring provided.
    • function (

      FIND-IF-NOT

      PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)
      No docstring provided.
    • function (

      FIND-PACKAGE

      PACKAGE-DESIGNATOR)
      If PACKAGE-DESIGNATOR is a package, it is returned. Otherwise PACKAGE-DESIGNATOR
      must be a string designator, in which case the package it names is located and returned.
      
      As an SBCL extension, the current package may affect the way a package name is
      resolved: if the current package has local nicknames specified, package names
      matching those are resolved to the packages associated with them instead.
      
      Example:
      
        (defpackage :a)
        (defpackage :example (:use :cl) (:local-nicknames (:x :a)))
        (let ((*package* (find-package :example)))
          (find-package :x)) => #<PACKAGE A>
      
      See also: ADD-PACKAGE-LOCAL-NICKNAME, PACKAGE-LOCAL-NICKNAMES,
      REMOVE-PACKAGE-LOCAL-NICKNAME, and the DEFPACKAGE option :LOCAL-NICKNAMES.
    • function (

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

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

      FINISH-OUTPUT

      &OPTIONAL (STREAM *STANDARD-OUTPUT*))
      No docstring provided.
    • function (

      FLET

      &REST ARGS)
      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.
    • function (

      FLOAT

      NUMBER &OPTIONAL OTHER)
      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.
    • function (

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

      FLOAT-RADIX

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

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

      FLOATP

      OBJECT)
      Return true if OBJECT is a FLOAT, and NIL otherwise.
    • function (

      FLOOR

      NUMBER &OPTIONAL (DIVISOR 1))
      Return the greatest integer not greater than number, or number/divisor.
        The second returned value is (mod number divisor).
    • function (

      FMAKUNBOUND

      NAME)
      Make NAME have no global function definition.
    • function (

      FORCE-OUTPUT

      &OPTIONAL (STREAM *STANDARD-OUTPUT*))
      No docstring provided.
    • function (

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

      FRESH-LINE

      &OPTIONAL (STREAM *STANDARD-OUTPUT*))
      No docstring provided.
    • function (

      FROUND

      NUMBER &OPTIONAL (DIVISOR 1))
      Same as ROUND, but returns first value as a float.
    • function (

      FTRUNCATE

      NUMBER &OPTIONAL (DIVISOR 1))
      Same as TRUNCATE, but returns first value as a float.
    • function (

      FUNCALL

      FUNCTION &REST ARGUMENTS)
      Call FUNCTION with the given ARGUMENTS.
    • function (

      FUNCTION

      &REST ARGS)
      FUNCTION name
      
      Return the lexically apparent definition of the function NAME. NAME may also
      be a lambda expression.
    • function (

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

      FUNCTIONP

      OBJECT)
      Return true if OBJECT is a FUNCTION, and NIL otherwise.
    • function (

      GCD

      &REST INTEGERS)
      Return the greatest common divisor of the arguments, which must be
        integers. GCD with no arguments is defined to be 0.
    • function (

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

      GENTEMP

      &OPTIONAL (PREFIX "T") (PACKAGE (SANE-PACKAGE)))
      Creates a new symbol interned in package PACKAGE with the given PREFIX.
    • function (

      GET

      SYMBOL INDICATOR &OPTIONAL DEFAULT)
      Look on the property list of SYMBOL for the specified INDICATOR. If this
        is found, return the associated value, else return DEFAULT.
    • function (

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

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

      GET-INTERNAL-REAL-TIME

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

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

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

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

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

      GET-UNIVERSAL-TIME

      )
      Return a single integer for the current time of day in universal time
      format.
    • function (

      GETF

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

      GO

      &REST ARGS)
      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.
    • function (

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

      HASH-TABLE-COUNT

      HASH-TABLE)
      Return the number of entries in the given HASH-TABLE.
    • function (

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

      HASH-TABLE-TEST

      INSTANCE)
      Return the test HASH-TABLE was created with.
    • function (

      HOST-NAMESTRING

      PATHNAME)
      Return a string representation of the name of the host in PATHNAME.
    • function (

      IDENTITY

      THING)
      This function simply returns what was passed to it.
    • function (

      IF

      &REST ARGS)
      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.
    • function (

      IMAGPART

      NUMBER)
      Extract the imaginary part of a number.
    • function (

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

      INSPECT

      OBJECT)
      No docstring provided.
    • function (

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

      INTEGER-LENGTH

      INTEGER)
      Return the number of non-sign bits in the twos-complement representation
        of INTEGER.
    • function (

      INTEGERP

      OBJECT)
      Return true if OBJECT is an INTEGER, and NIL otherwise.
    • function (

      INTERN

      NAME &OPTIONAL (PACKAGE (SANE-PACKAGE)))
      Return a symbol in PACKAGE having the specified NAME, creating it
        if necessary.
    • function (

      INTERSECTION

      LIST1 LIST2 &KEY KEY TEST TEST-NOT)
      Return the intersection of LIST1 and LIST2.
    • function (

      INVALID-METHOD-ERROR

      METHOD FORMAT-CONTROL &REST FORMAT-ARGUMENTS)
      No docstring provided.
    • function (

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

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

      ISQRT

      N)
      Return the greatest integer less than or equal to the square root of N.
    • function (

      KEYWORDP

      OBJECT)
      Return true if Object is a symbol in the "KEYWORD" package.
    • function (

      LABELS

      &REST ARGS)
      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.
    • function (

      LAST

      LIST &OPTIONAL (N 1))
      Return the last N conses (not the last element!) of a list.
    • function (

      LCM

      &REST INTEGERS)
      Return the least common multiple of one or more integers. LCM of no
        arguments is defined to be 1.
    • function (

      LDB

      BYTESPEC INTEGER)
      Extract the specified byte from integer, and right justify result.
    • function (

      LDB-TEST

      BYTESPEC INTEGER)
      Return T if any of the specified bits in integer are 1's.
    • function (

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

      LENGTH

      SEQUENCE)
      Return an integer that is the length of SEQUENCE.
    • function (

      LET

      &REST ARGS)
      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.
    • function (

      LET*

      &REST ARGS)
      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.
    • function (

      LIST

      &REST ARGS)
      Return constructs and returns a list of its arguments.
    • function (

      LIST*

      ARG &REST OTHERS)
      Return a list of the arguments with last cons a dotted pair.
    • function (

      LIST-LENGTH

      LIST)
      Return the length of the given List, or Nil if the List is circular.
    • function (

      LISTEN

      &OPTIONAL (STREAM *STANDARD-INPUT*))
      No docstring provided.
    • function (

      LISTP

      OBJECT)
      Return true if OBJECT is a LIST, and NIL otherwise.
    • function (

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

      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 highly implementation dependent, and
      historically it used to be a no-op in SBCL -- the current approach is somewhat
      experimental and subject to change.
    • function (

      LOAD-TIME-VALUE

      &REST ARGS)
      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.
    • function (

      LOCALLY

      &REST ARGS)
      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.
    • function (

      LOG

      NUMBER &OPTIONAL BASE)
      Return the logarithm of NUMBER in the base BASE, which defaults to e.
    • function (

      LOGAND

      &REST INTEGERS)
      Return the bit-wise and of its arguments. Args must be integers.
    • function (

      LOGANDC1

      INTEGER1 INTEGER2)
      Bitwise AND (LOGNOT INTEGER1) with INTEGER2.
    • function (

      LOGANDC2

      INTEGER1 INTEGER2)
      Bitwise AND INTEGER1 with (LOGNOT INTEGER2).
    • function (

      LOGBITP

      INDEX INTEGER)
      Predicate returns T if bit index of integer is a 1.
    • function (

      LOGCOUNT

      INTEGER)
      Count the number of 1 bits if INTEGER is non-negative,
      and the number of 0 bits if INTEGER is negative.
    • function (

      LOGEQV

      &REST INTEGERS)
      Return the bit-wise equivalence of its arguments. Args must be integers.
    • function (

      LOGICAL-PATHNAME

      PATHSPEC)
      Converts the pathspec argument to a logical-pathname and returns it.
    • function (

      LOGIOR

      &REST INTEGERS)
      Return the bit-wise or of its arguments. Args must be integers.
    • function (

      LOGNAND

      INTEGER1 INTEGER2)
      Complement the logical AND of INTEGER1 and INTEGER2.
    • function (

      LOGNOR

      INTEGER1 INTEGER2)
      Complement the logical OR of INTEGER1 and INTEGER2.
    • function (

      LOGNOT

      NUMBER)
      Return the bit-wise logical not of integer.
    • function (

      LOGORC1

      INTEGER1 INTEGER2)
      Bitwise OR (LOGNOT INTEGER1) with INTEGER2.
    • function (

      LOGORC2

      INTEGER1 INTEGER2)
      Bitwise OR INTEGER1 with (LOGNOT INTEGER2).
    • function (

      LOGTEST

      INTEGER1 INTEGER2)
      Predicate which returns T if logand of integer1 and integer2 is not zero.
    • function (

      LOGXOR

      &REST INTEGERS)
      Return the bit-wise exclusive or of its arguments. Args must be integers.
    • function (

      LONG-SITE-NAME

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

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

      MACHINE-INSTANCE

      )
      Return a string giving the name of the local machine.
    • function (

      MACHINE-TYPE

      )
      Return a string describing the type of the local machine.
    • function (

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

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

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

      MACROLET

      &REST ARGS)
      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.
    • function (

      MAKE-ARRAY

      DIMENSIONS &REST ARGS &KEY (ELEMENT-TYPE T) INITIAL-ELEMENT INITIAL-CONTENTS ADJUSTABLE FILL-POINTER DISPLACED-TO DISPLACED-INDEX-OFFSET)
      No docstring provided.
    • function (

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

      MAKE-CONDITION

      TYPE &REST INITARGS)
      Make an instance of a condition object using the specified initargs.
    • function (

      MAKE-DISPATCH-MACRO-CHARACTER

      CHAR &OPTIONAL NON-TERMINATING-P (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.
    • function (

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

      MAKE-HASH-TABLE

      &KEY (TEST 'EQL) (SIZE +MIN-HASH-TABLE-SIZE+) (REHASH-SIZE 1.5) (REHASH-THRESHOLD 1) HASH-FUNCTION WEAKNESS 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.
    • function (

      MAKE-LIST

      SIZE &KEY INITIAL-ELEMENT)
      Constructs a list with size elements each set to value
    • function (

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

      MAKE-PATHNAME

      &KEY HOST DEVICE DIRECTORY NAME TYPE VERSION DEFAULTS (CASE :LOCAL))
      Makes a new pathname from the component arguments. Note that host is
      a host-structure or string.
    • function (

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

      MAKE-SEQUENCE

      RESULT-TYPE LENGTH &KEY INITIAL-ELEMENT)
      Return a sequence of the given RESULT-TYPE and LENGTH, with
        elements initialized to INITIAL-ELEMENT.
    • function (

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

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

      MAKE-STRING-OUTPUT-STREAM

      &KEY (ELEMENT-TYPE 'CHARACTER))
      Return an output stream which will accumulate all output given it for the
      benefit of the function GET-OUTPUT-STREAM-STRING.
    • function (

      MAKE-SYMBOL

      STRING)
      Make and return a new symbol with the STRING as its print name.
    • function (

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

      MAKUNBOUND

      SYMBOL)
      Make SYMBOL unbound, removing any value it may currently have.
    • function (

      MAP

      RESULT-TYPE FUNCTION FIRST-SEQUENCE &REST MORE-SEQUENCES)
      No docstring provided.
    • function (

      MAP-INTO

      RESULT-SEQUENCE FUNCTION &REST SEQUENCES)
      No docstring provided.
    • function (

      MAPC

      FUNCTION LIST &REST MORE-LISTS)
      Apply FUNCTION to successive tuples of elements of LIST and MORE-LISTS.
      Return LIST.
    • function (

      MAPCAN

      FUNCTION LIST &REST MORE-LISTS)
      Apply FUNCTION to successive tuples of elements of LIST and MORE-LISTS.
      Return NCONC of FUNCTION return values.
    • function (

      MAPCAR

      FUNCTION LIST &REST MORE-LISTS)
      Apply FUNCTION to successive tuples of elements of LIST and MORE-LISTS.
      Return list of FUNCTION return values.
    • function (

      MAPCON

      FUNCTION LIST &REST MORE-LISTS)
      Apply FUNCTION to successive tuples of CDRs of LIST and MORE-LISTS.
      Return NCONC of results.
    • function (

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

      MAPL

      FUNCTION LIST &REST MORE-LISTS)
      Apply FUNCTION to successive tuples of CDRs of LIST and MORE-LISTS.
      Return LIST.
    • function (

      MAPLIST

      FUNCTION LIST &REST MORE-LISTS)
      Apply FUNCTION to successive tuples of CDRs of LIST and MORE-LISTS.
      Return list of results.
    • function (

      MASK-FIELD

      BYTESPEC INTEGER)
      Extract the specified byte from integer,  but do not right justify result.
    • function (

      MAX

      NUMBER &REST MORE-NUMBERS)
      Return the greatest of its arguments; among EQUALP greatest, return
      the first.
    • function (

      MEMBER

      ITEM LIST &KEY KEY TEST TEST-NOT)
      Return the tail of LIST beginning with first element satisfying EQLity,
         :TEST, or :TEST-NOT with the given ITEM.
    • function (

      MEMBER-IF

      TEST LIST &KEY KEY)
      Return tail of LIST beginning with first element satisfying TEST.
    • function (

      MEMBER-IF-NOT

      TEST LIST &KEY KEY)
      Return tail of LIST beginning with first element not satisfying TEST.
    • function (

      MERGE

      RESULT-TYPE SEQUENCE1 SEQUENCE2 PREDICATE &KEY KEY)
      Merge the sequences SEQUENCE1 and SEQUENCE2 destructively into a
         sequence of type RESULT-TYPE using PREDICATE to order the elements.
    • function (

      MERGE-PATHNAMES

      PATHNAME &OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*) (DEFAULT-VERSION :NEWEST))
      Construct a filled in pathname by completing the unspecified components
         from the defaults.
    • function (

      MIN

      NUMBER &REST MORE-NUMBERS)
      Return the least of its arguments; among EQUALP least, return
      the first.
    • function (

      MINUSP

      NUMBER)
      Is this real number strictly negative?
    • function (

      MISMATCH

      SEQUENCE1 SEQUENCE2 &REST ARGS &KEY FROM-END (TEST (FUNCTION EQL)) TEST-NOT (START1 0) END1 (START2 0) END2 KEY)
      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.
    • function (

      MOD

      NUMBER DIVISOR)
      Return second result of FLOOR.
    • function (

      MUFFLE-WARNING

      &OPTIONAL CONDITION)
      Transfer control to a restart named MUFFLE-WARNING, signalling a
         CONTROL-ERROR if none exists.
    • function (

      MULTIPLE-VALUE-CALL

      &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.
    • function (

      MULTIPLE-VALUE-PROG1

      &REST ARGS)
      MULTIPLE-VALUE-PROG1 values-form form*
      
      Evaluate VALUES-FORM and then the FORMS, but return all the values of
      VALUES-FORM.
    • function (

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

      NAMESTRING

      PATHNAME)
      Construct the full (name)string form PATHNAME.
    • function (

      NBUTLAST

      LIST &OPTIONAL (N 1))
      No docstring provided.
    • function (

      NCONC

      &REST LISTS)
      Concatenates the lists given as arguments (by changing them)
    • function (

      NINTERSECTION

      LIST1 LIST2 &KEY KEY TEST TEST-NOT)
      Destructively return the intersection of LIST1 and LIST2.
    • function (

      NOT

      OBJECT)
      Return T if X is NIL, otherwise return NIL.
    • function (

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

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

      NRECONC

      X Y)
      Return (NCONC (NREVERSE X) Y).
    • function (

      NREVERSE

      SEQUENCE)
      Return a sequence of the same elements in reverse order; the argument
         is destroyed.
    • function (

      NSET-DIFFERENCE

      LIST1 LIST2 &KEY KEY TEST TEST-NOT)
      Destructively return the elements of LIST1 which are not in LIST2.
    • function (

      NSET-EXCLUSIVE-OR

      LIST1 LIST2 &KEY KEY (TEST (FUNCTION EQL)) (TEST-NOT (FUNCTION EQL)))
      Destructively return a list with elements which appear but once in LIST1
         and LIST2.
    • function (

      NSTRING-UPCASE

      STRING &KEY (START 0) END)
      No docstring provided.
    • function (

      NSUBLIS

      ALIST TREE &KEY KEY (TEST (FUNCTION EQL)) (TEST-NOT (FUNCTION EQL)))
      Substitute from ALIST into TREE destructively.
    • function (

      NSUBST

      NEW OLD TREE &KEY KEY (TEST (FUNCTION EQL)) (TEST-NOT (FUNCTION EQL)))
      Substitute NEW for subtrees matching OLD.
    • function (

      NSUBST-IF

      NEW TEST TREE &KEY KEY)
      Substitute NEW for subtrees of TREE for which TEST is true.
    • function (

      NSUBST-IF-NOT

      NEW TEST TREE &KEY KEY)
      Substitute NEW for subtrees of TREE for which TEST is false.
    • function (

      NSUBSTITUTE

      NEW OLD SEQUENCE &REST ARGS &KEY FROM-END (TEST (FUNCTION EQL)) TEST-NOT END COUNT KEY (START 0))
      Return a sequence of the same kind as SEQUENCE with the same elements
        except that all elements equal to OLD are replaced with NEW. SEQUENCE
        may be destructively modified.
    • function (

      NSUBSTITUTE-IF

      NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END COUNT KEY)
      Return a sequence of the same kind as SEQUENCE with the same elements
         except that all elements satisfying PREDICATE are replaced with NEW.
         SEQUENCE may be destructively modified.
    • function (

      NSUBSTITUTE-IF-NOT

      NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END COUNT KEY)
      Return a sequence of the same kind as SEQUENCE with the same elements
         except that all elements not satisfying PREDICATE are replaced with NEW.
         SEQUENCE may be destructively modified.
    • function (

      NTHCDR

      N LIST)
      Performs the cdr function n times on a list.
    • function (

      NULL

      OBJECT)
      Return true if OBJECT is a NULL, and NIL otherwise.
    • function (

      NUMBERP

      OBJECT)
      Return true if OBJECT is a NUMBER, and NIL otherwise.
    • function (

      NUMERATOR

      NUMBER)
      Return the numerator of NUMBER, which must be rational.
    • function (

      NUNION

      LIST1 LIST2 &KEY KEY TEST TEST-NOT)
      Destructively return the union of LIST1 and LIST2.
    • function (

      ODDP

      NUMBER)
      Is this integer odd?
    • function (

      OPEN

      FILENAME &KEY (DIRECTION :INPUT) (ELEMENT-TYPE 'BASE-CHAR) IF-EXISTS IF-DOES-NOT-EXIST (EXTERNAL-FORMAT :DEFAULT) (CLASS 'FD-STREAM))
      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.
    • function (

      PACKAGE-NAME

      PACKAGE-DESIGNATOR)
      No docstring provided.
    • function (

      PACKAGEP

      OBJECT)
      No docstring provided.
    • function (

      PAIRLIS

      KEYS DATA &OPTIONAL (ALIST 'NIL))
      Construct an association list from KEYS and DATA (adding to ALIST).
    • function (

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

      PARSE-NAMESTRING

      THING &OPTIONAL HOST (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*) &KEY (START 0) END JUNK-ALLOWED)
      No docstring provided.
    • function (

      PATHNAME

      PATHSPEC)
      Convert PATHSPEC (a pathname designator) into a pathname.
    • function (

      PATHNAME-DEVICE

      PATHNAME &KEY (CASE :LOCAL))
      Return PATHNAME's device.
    • function (

      PATHNAME-HOST

      PATHNAME &KEY (CASE :LOCAL))
      Return PATHNAME's host.
    • function (

      PATHNAME-MATCH-P

      IN-PATHNAME IN-WILDNAME)
      Pathname matches the wildname template?
    • function (

      PATHNAME-NAME

      PATHNAME &KEY (CASE :LOCAL))
      Return PATHNAME's name.
    • function (

      PATHNAME-TYPE

      PATHNAME &KEY (CASE :LOCAL))
      Return PATHNAME's type.
    • function (

      PATHNAMEP

      OBJECT)
      No docstring provided.
    • function (

      PEEK-CHAR

      &OPTIONAL PEEK-TYPE (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)
      No docstring provided.
    • function (

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

      PLUSP

      NUMBER)
      Is this real number strictly positive?
    • function (

      POSITION

      ITEM SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY TEST TEST-NOT)
      No docstring provided.
    • function (

      POSITION-IF

      PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)
      No docstring provided.
    • function (

      POSITION-IF-NOT

      PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END KEY)
      No docstring provided.
    • function (

      PPRINT

      OBJECT &OPTIONAL STREAM)
      Prettily output OBJECT preceded by a newline.
    • function (

      PPRINT-DISPATCH

      OBJECT &OPTIONAL (TABLE *PRINT-PPRINT-DISPATCH*))
      No docstring provided.
    • function (

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

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

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

      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 immediately
              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 omitted
         from the output and indentation is introduced at the beginning of the
         next line. (See PPRINT-INDENT.)
    • function (

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

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

      PRIN1

      OBJECT &OPTIONAL STREAM)
      Output a mostly READable printed representation of OBJECT on the specified
        STREAM.
    • function (

      PRIN1-TO-STRING

      OBJECT)
      Return the printed representation of OBJECT as a string with
         slashification on.
    • function (

      PRINC

      OBJECT &OPTIONAL STREAM)
      Output an aesthetic but not necessarily READable printed representation
        of OBJECT on the specified STREAM.
    • function (

      PRINC-TO-STRING

      OBJECT)
      Return the printed representation of OBJECT as a string with
        slashification off.
    • function (

      PRINT

      OBJECT &OPTIONAL STREAM)
      Output a newline, the mostly READable printed representation of OBJECT, and
        space to the specified STREAM.
    • function (

      PROBE-FILE

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

      PROCLAIM

      RAW-FORM)
      No docstring provided.
    • function (

      PROGN

      &REST ARGS)
      PROGN form*
      
      Evaluates each FORM in order, returning the values of the last form. With no
      forms, returns NIL.
    • function (

      PROGV

      &REST ARGS)
      No docstring provided.
    • function (

      PROVIDE

      MODULE-NAME)
      Adds a new module name to *MODULES* indicating that it has been loaded.
         Module-name is a string designator
    • function (

      QUOTE

      &REST ARGS)
      QUOTE value
      
      Return VALUE without evaluating it.
    • function (

      RANDOM

      ARG &OPTIONAL (STATE *RANDOM-STATE*))
      No docstring provided.
    • function (

      RASSOC

      ITEM ALIST &KEY KEY TEST TEST-NOT)
      Return the cons in ALIST whose CDR is equal (by a given test or EQL) to
         the ITEM.
    • function (

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

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

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

      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))
    • function (

      RATIONALP

      OBJECT)
      Return true if OBJECT is a RATIONAL, and NIL otherwise.
    • function (

      READ

      &OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)
      Read the next Lisp value from STREAM, and return it.
    • function (

      READ-BYTE

      STREAM &OPTIONAL (EOF-ERROR-P T) EOF-VALUE)
      No docstring provided.
    • function (

      READ-CHAR

      &OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)
      No docstring provided.
    • function (

      READ-CHAR-NO-HANG

      &OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)
      No docstring provided.
    • function (

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

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

      READ-LINE

      &OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)
      No docstring provided.
    • function (

      READ-PRESERVING-WHITESPACE

      &OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) EOF-VALUE RECURSIVE-P)
      Read from STREAM and return the value read, preserving any whitespace
         that followed the object.
    • function (

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

      READTABLEP

      OBJECT)
      No docstring provided.
    • function (

      REALP

      OBJECT)
      Return true if OBJECT is a REAL, and NIL otherwise.
    • function (

      REALPART

      NUMBER)
      Extract the real part of a number.
    • function (

      REDUCE

      FUNCTION SEQUENCE &REST ARGS &KEY KEY FROM-END (START 0) END INITIAL-VALUE)
      No docstring provided.
    • function (

      REM

      NUMBER DIVISOR)
      Return second result of TRUNCATE.
    • function (

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

      REMOVE

      ITEM SEQUENCE &REST ARGS &KEY FROM-END (TEST (FUNCTION EQL)) TEST-NOT (START 0) END COUNT KEY)
      Return a copy of SEQUENCE with elements satisfying the test (default is
         EQL) with ITEM removed.
    • function (

      REMOVE-DUPLICATES

      SEQUENCE &REST ARGS &KEY (TEST (FUNCTION EQL)) TEST-NOT (START 0) END FROM-END KEY)
      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.
    • function (

      REMOVE-IF

      PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END COUNT KEY)
      Return a copy of sequence with elements satisfying PREDICATE removed.
    • function (

      REMOVE-IF-NOT

      PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END COUNT KEY)
      Return a copy of sequence with elements not satisfying PREDICATE removed.
    • function (

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

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

      RENAME-PACKAGE

      PACKAGE-DESIGNATOR NAME &OPTIONAL NICKNAMES)
      Changes the name and nicknames for a package.
    • function (

      REPLACE

      SEQUENCE1 SEQUENCE2 &REST ARGS &KEY (START1 0) END1 (START2 0) END2)
      Destructively modifies SEQUENCE1 by copying successive elements
      into it from the SEQUENCE2.
      
      Elements are copied to the subseqeuence bounded by START1 and END1,
      from the subsequence bounded by START2 and END2. If these subsequences
      are not of the same length, then the shorter length determines how
      many elements are copied.
    • function (

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

      RESTART-NAME

      INSTANCE)
      Return the name of the given restart object.
    • function (

      RETURN-FROM

      &REST ARGS)
      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.
    • function (

      REVAPPEND

      X Y)
      Return (append (reverse x) y).
    • function (

      REVERSE

      SEQUENCE)
      Return a new sequence containing the same elements but in reverse order.
    • function (

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

      ROUND

      NUMBER &OPTIONAL (DIVISOR 1))
      Rounds number (or number/divisor) to nearest integer.
        The second returned value is the remainder.
    • function (

      RPLACA

      CONS X)
      Change the CAR of CONS to X and return the CONS.
    • function (

      RPLACD

      CONS X)
      Change the CDR of CONS to X and return the CONS.
    • function (

      SCALE-FLOAT

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

      SEARCH

      SEQUENCE1 SEQUENCE2 &REST ARGS &KEY FROM-END (TEST (FUNCTION EQL)) TEST-NOT (START1 0) END1 (START2 0) END2 KEY)
      No docstring provided.
    • function (

      SET

      SYMBOL NEW-VALUE)
      Set SYMBOL's value cell to NEW-VALUE.
    • function (

      SET-DIFFERENCE

      LIST1 LIST2 &KEY KEY TEST TEST-NOT)
      Return the elements of LIST1 which are not in LIST2.
    • function (

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

      SET-EXCLUSIVE-OR

      LIST1 LIST2 &KEY KEY TEST TEST-NOT)
      Return new list of elements appearing exactly once in LIST1 and LIST2.
    • function (

      SET-MACRO-CHARACTER

      CHAR FUNCTION &OPTIONAL NON-TERMINATINGP (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.
    • function (

      SET-PPRINT-DISPATCH

      TYPE FUNCTION &OPTIONAL (PRIORITY 0) (TABLE *PRINT-PPRINT-DISPATCH*))
      No docstring provided.
    • function (

      SET-SYNTAX-FROM-CHAR

      TO-CHAR FROM-CHAR &OPTIONAL (TO-READTABLE *READTABLE*) FROM-READTABLE)
      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.
    • function (

      SETQ

      &REST ARGS)
      No docstring provided.
    • function (

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

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

      SHORT-SITE-NAME

      )
      Return a string with the abbreviated site name, or NIL if not known.
    • function (

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

      SIGNUM

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

      SIMPLE-BIT-VECTOR-P

      OBJECT)
      Return true if OBJECT is a SIMPLE-BIT-VECTOR, and NIL otherwise.
    • function (

      SIMPLE-STRING-P

      OBJECT)
      Return true if OBJECT is a SIMPLE-STRING, and NIL otherwise.
    • function (

      SIMPLE-VECTOR-P

      OBJECT)
      Return true if OBJECT is a SIMPLE-VECTOR, and NIL otherwise.
    • function (

      SIN

      NUMBER)
      Return the sine of NUMBER.
    • function (

      SINH

      NUMBER)
      Return the hyperbolic sine of NUMBER.
    • function (

      SLEEP

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

      SLOT-BOUNDP

      OBJECT SLOT-NAME)
      No docstring provided.
    • function (

      SLOT-EXISTS-P

      OBJECT SLOT-NAME)
      No docstring provided.
    • function (

      SOFTWARE-TYPE

      )
      Return a string describing the supporting software.
    • function (

      SOFTWARE-VERSION

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

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

      SORT

      SEQUENCE PREDICATE &REST ARGS &KEY KEY)
      Destructively sort SEQUENCE. PREDICATE should return non-NIL if
         ARG1 is to precede ARG2.
    • function (

      SPECIAL-OPERATOR-P

      SYMBOL)
      If the symbol globally names a special form, return T, otherwise NIL.
    • function (

      SQRT

      NUMBER)
      Return the square root of NUMBER.
    • function (

      STABLE-SORT

      SEQUENCE PREDICATE &REST ARGS &KEY KEY)
      Destructively sort SEQUENCE. PREDICATE should return non-NIL if
         ARG1 is to precede ARG2.
    • function (

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

      STORE-VALUE

      VALUE &OPTIONAL CONDITION)
      Transfer control and VALUE to a restart named STORE-VALUE, or
      return NIL if none exists.
    • function (

      STREAMP

      STREAM)
      No docstring provided.
    • function (

      STRING

      X)
      Coerces X into a string. If X is a string, X is returned. If X is a
         symbol, its name 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.
    • function (

      STRING-DOWNCASE

      STRING &KEY (START 0) END)
      No docstring provided.
    • function (

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

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

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

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

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

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

      STRING-TRIM

      CHAR-BAG STRING)
      No docstring provided.
    • function (

      STRING-UPCASE

      STRING &KEY (START 0) END)
      No docstring provided.
    • function (

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

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

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

      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=).
    • function (

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

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

      STRINGP

      OBJECT)
      Return true if OBJECT is a STRING, and NIL otherwise.
    • function (

      SUBLIS

      ALIST TREE &KEY KEY (TEST (FUNCTION EQL)) (TEST-NOT (FUNCTION EQL)))
      Substitute from ALIST into TREE nondestructively.
    • function (

      SUBSEQ

      SEQUENCE 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.
    • function (

      SUBSETP

      LIST1 LIST2 &KEY KEY (TEST (FUNCTION EQL)) TEST-NOT)
      Return T if every element in LIST1 is also in LIST2.
    • function (

      SUBST

      NEW OLD TREE &KEY KEY (TEST (FUNCTION EQL)) (TEST-NOT (FUNCTION EQL)))
      Substitutes new for subtrees matching old.
    • function (

      SUBST-IF

      NEW TEST TREE &KEY KEY)
      Substitutes new for subtrees for which test is true.
    • function (

      SUBST-IF-NOT

      NEW TEST TREE &KEY KEY)
      Substitutes new for subtrees for which test is false.
    • function (

      SUBSTITUTE

      NEW OLD SEQUENCE &REST ARGS &KEY FROM-END (TEST (FUNCTION EQL)) TEST-NOT (START 0) COUNT END KEY)
      Return a sequence of the same kind as SEQUENCE with the same elements,
        except that all elements equal to OLD are replaced with NEW.
    • function (

      SUBSTITUTE-IF

      NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END COUNT KEY)
      Return a sequence of the same kind as SEQUENCE with the same elements
        except that all elements satisfying the PRED are replaced with NEW.
    • function (

      SUBSTITUTE-IF-NOT

      NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0) END COUNT KEY)
      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.
    • function (

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

      SXHASH

      X)
      No docstring provided.
    • function (

      SYMBOL-MACROLET

      &REST ARGS)
      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.
    • function (

      SYMBOL-NAME

      SYMBOL)
      Return SYMBOL's name as a string.
    • function (

      SYMBOL-PACKAGE

      SYMBOL)
      Return the package SYMBOL was interned in, or NIL if none.
    • function (

      SYMBOLP

      OBJECT)
      Return true if OBJECT is a SYMBOL, and NIL otherwise.
    • function (

      TAGBODY

      &REST ARGS)
      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.
    • function (

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

      TAN

      NUMBER)
      Return the tangent of NUMBER.
    • function (

      TANH

      NUMBER)
      Return the hyperbolic tangent of NUMBER.
    • function (

      TERPRI

      &OPTIONAL (STREAM *STANDARD-OUTPUT*))
      No docstring provided.
    • function (

      THE

      &REST ARGS)
      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.
    • function (

      THROW

      &REST ARGS)
      THROW tag form
      
      Do a non-local exit, return the values of FORM from the CATCH whose tag is EQ
      to TAG.
    • function (

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

      TREE-EQUAL

      X Y &KEY TEST TEST-NOT)
      Return T if X and Y are isomorphic trees with identical leaves.
    • function (

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

      TRUNCATE

      NUMBER &OPTIONAL (DIVISOR 1))
      Return number (or number/divisor) as an integer, rounded toward 0.
        The second returned value is the remainder.
    • function (

      TYPE-OF

      OBJECT)
      Return the type of OBJECT.
    • function (

      TYPEP

      OBJECT TYPE &OPTIONAL ENVIRONMENT)
      Is OBJECT of type TYPE?
    • function (

      UNEXPORT

      SYMBOLS &OPTIONAL (PACKAGE (SANE-PACKAGE)))
      Makes SYMBOLS no longer exported from PACKAGE.
    • function (

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

      UNION

      LIST1 LIST2 &KEY KEY TEST TEST-NOT)
      Return the union of LIST1 and LIST2.
    • function (

      UNREAD-CHAR

      CHARACTER &OPTIONAL (STREAM *STANDARD-INPUT*))
      No docstring provided.
    • function (

      UNUSE-PACKAGE

      PACKAGES-TO-UNUSE &OPTIONAL (PACKAGE (SANE-PACKAGE)))
      Remove PACKAGES-TO-UNUSE from the USE list for PACKAGE.
    • function (

      UNWIND-PROTECT

      &REST ARGS)
      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).
    • function (

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

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

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

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

      USE-VALUE

      VALUE &OPTIONAL CONDITION)
      Transfer control and VALUE to a restart named USE-VALUE, or
      return NIL if none exists.
    • function (

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

      VALUES

      &REST VALUES)
      Return all arguments, in order, as values.
    • function (

      VALUES-LIST

      LIST)
      Return all of the elements of LIST, in order, as values.
    • function (

      VARI-DESCRIBE

      NAME &OPTIONAL (STREAM *STANDARD-OUTPUT*) TRY-PACKAGE-NAME)
      No docstring provided.
    • function (

      VECTOR

      &REST OBJECTS)
      Construct a SIMPLE-VECTOR from the given objects.
    • function (

      VECTOR-POP

      ARRAY)
      Decrease the fill pointer by 1 and return the element pointed to by the
        new fill pointer.
    • function (

      VECTOR-PUSH

      NEW-ELEMENT ARRAY)
      Attempt to set the element of ARRAY designated by its fill pointer
         to NEW-ELEMENT, 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.
    • function (

      VECTOR-PUSH-EXTEND

      NEW-ELEMENT VECTOR &OPTIONAL MIN-EXTENSION)
      No docstring provided.
    • function (

      VECTORP

      OBJECT)
      Return true if OBJECT is a VECTOR, and NIL otherwise.
    • function (

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

      WILD-PATHNAME-P

      PATHNAME &OPTIONAL FIELD-KEY)
      Predicate for determining whether pathname contains any wildcards.
    • function (

      WRITE

      OBJECT &KEY STREAM ((: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*.
    • function (

      WRITE-BYTE

      INTEGER STREAM)
      No docstring provided.
    • function (

      WRITE-CHAR

      CHARACTER &OPTIONAL (STREAM *STANDARD-OUTPUT*))
      No docstring provided.
    • function (

      WRITE-LINE

      STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (START 0) END)
      No docstring provided.
    • function (

      WRITE-SEQUENCE

      SEQ STREAM &KEY (START 0) END)
      Write the elements of SEQ bounded by START and END to STREAM.
    • function (

      WRITE-STRING

      STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (START 0) END)
      No docstring provided.
    • function (

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

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

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

      ZEROP

      NUMBER)
      Is this number zero?
    • generic (

      ADD-METHOD

      GENERIC-FUNCTION METHOD)
      No docstring provided.
    • generic (

      CHANGE-CLASS

      INSTANCE NEW-CLASS-NAME &REST INITARGS &KEY &ALLOW-OTHER-KEYS)
      No docstring provided.
    • generic (

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

      FIND-METHOD

      GENERIC-FUNCTION QUALIFIERS SPECIALIZERS &OPTIONAL ERRORP)
      No docstring provided.
    • generic (

      INITIALIZE-INSTANCE

      INSTANCE &REST INITARGS &KEY X Y Z PRIMITIVE SPACING ORDER VERTICES KIND MAX-VERTICES DATA-STREAM HEIGHT WIDTH IMAGE-DATA COLOR-TABLE LITERAL-FUN LENGTH-FUN DISTANCE-FUN COMPRESS-FUN CALLBACK DIRECT-SLOTS IN-LAYER NAME DEFINING-METACLASS IN DIRECT-SUPERCLASSES ALLOCATION REINITIALIZE TOPMOST-CLASS RANDOM-SEED STREAM VECTOR BUFFER-SIZE SEARCH-PATH CCONV CALLING-CONVENTION CONVENTION SLUG INITIAL-SIZE INITIAL-CONTENTS LITERAL-CHAR-CODE-LIMIT SYSTEM OTHER-SYSTEMS INITFORM INITFUNCTION TYPE INITARGS DOCUMENTATION READERS WRITERS LAMBDA-LIST ARGUMENT-PRECEDENCE-ORDER &ALLOW-OTHER-KEYS)
      No docstring provided.
    • generic (

      INPUT-STREAM-P

      STREAM)
      Can STREAM perform input operations?
    • generic (

      KIND

      METADATA)
      No docstring provided.
    • generic (

      MAKE-INSTANCE

      CLASS &REST INITARGS &KEY &ALLOW-OTHER-KEYS)
      No docstring provided.
    • generic (

      MAKE-LOAD-FORM

      OBJECT &OPTIONAL ENVIRONMENT)
      No docstring provided.
    • generic (

      NO-NEXT-METHOD

      GENERIC-FUNCTION METHOD &REST ARGS)
      No docstring provided.
    • generic (

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

      ORDER

      METADATA)
      No docstring provided.
    • generic (

      PRIMITIVE

      METADATA)
      No docstring provided.
    • generic (

      PRINT-OBJECT

      OBJECT STREAM)
      No docstring provided.
    • generic (

      REINITIALIZE-INSTANCE

      INSTANCE &REST INITARGS &KEY DIRECT-SLOTS IN-LAYER IN DEFINING-METACLASS DIRECT-SUPERCLASSES LAMBDA-LIST ARGUMENT-PRECEDENCE-ORDER &ALLOW-OTHER-KEYS)
      No docstring provided.
    • generic (

      REMOVE-METHOD

      GENERIC-FUNCTION METHOD)
      No docstring provided.
    • generic (

      SHARED-INITIALIZE

      INSTANCE SLOT-NAMES &REST INITARGS &KEY DEFINING-METACLASS PROTOCOL TYPE DIRECT-SUPERCLASSES DIRECT-SLOTS DIRECT-DEFAULT-INITARGS NAME ALLOCATION ALLOCATION-CLASS QUALIFIERS LAMBDA-LIST SPECIALIZERS FUNCTION DOCUMENTATION SLOT-NAME SLOT-DEFINITION ARGUMENT-PRECEDENCE-ORDER DECLARATIONS METHOD-CLASS METHOD-COMBINATION &ALLOW-OTHER-KEYS)
      No docstring provided.
    • generic (

      SLOT-MISSING

      CLASS INSTANCE SLOT-NAME OPERATION &OPTIONAL NEW-VALUE)
      No docstring provided.
    • generic (

      SLOT-UNBOUND

      CLASS INSTANCE SLOT-NAME)
      No docstring provided.
    • generic (

      SPACING

      METADATA)
      No docstring provided.
    • generic (

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

      VERTICES

      METADATA)
      No docstring provided.
    • macro (

      %PEEK

      THING)
      No docstring provided.
    • macro (

      AND

      &REST FORMS)
      No docstring provided.
    • macro (

      ASSERT

      TEST-FORM &OPTIONAL PLACES DATUM &REST ARGUMENTS)
      Signals an error if the value of TEST-FORM is NIL. Returns NIL.
      
         Optional DATUM and ARGUMENTS can be used to change the signaled
         error condition and are interpreted as in (APPLY #'ERROR DATUM
         ARGUMENTS).
      
         Continuing from the signaled error using the CONTINUE restart will
         allow the user to alter the values of the SETFable locations
         specified in PLACES and then start over with TEST-FORM.
      
         If TEST-FORM is of the form
      
           (FUNCTION ARG*)
      
         where FUNCTION is a function (but not a special operator like
         CL:OR, CL:AND, etc.) the results of evaluating the ARGs will be
         included in the error report if the assertion fails.
    • macro (

      CALL-METHOD

      &REST ARGS)
      No docstring provided.
    • macro (

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

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

      CHECK-TYPE

      PLACE TYPE &OPTIONAL TYPE-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.
    • macro (

      COND

      &REST CLAUSES)
      No docstring provided.
    • macro (

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

      DECF

      PLACE &OPTIONAL (DELTA 1))
      The first argument is some location holding a number. This number is
        decremented by the second argument, DELTA, which defaults to 1.
    • macro (

      DECLAIM

      &REST SPECS)
      DECLAIM Declaration*
        Do a declaration or declarations for the global environment.
    • macro (

      DEF-METADATA-INFER

      VARJO-TYPE-SPEC METADATA-KIND ENV-VAR &BODY BODY)
      `def-metadata-infer` is the older syntax for `define-metadata-infer`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      DEF-METADATA-KIND

      NAME (&KEY CONC-NAME (BINDS-TO)) &BODY SLOT-NAMES)
      `def-metadata-kind` is the older syntax for `define-metadata-kind`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      DEFCLASS

      NAME DIRECT-SUPERCLASSES DIRECT-SLOTS &REST OPTIONS)
      No docstring provided.
    • macro (

      DEFCONSTANT

      NAME VALUE &OPTIONAL DOC)
      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.
    • macro (

      DEFGENERIC

      FUN-NAME LAMBDA-LIST &BODY OPTIONS)
      No docstring provided.
    • macro (

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

      DEFINE-METADATA-INFER

      VARJO-TYPE-SPEC METADATA-KIND ENV-VAR &BODY BODY)
      `define-metadata-infer` lets you define
      
    • macro (

      DEFINE-METADATA-KIND

      NAME (&KEY CONC-NAME (BINDS-TO)) &BODY SLOT-NAMES)
      `define-metadata-kind` lets you define
      
    • macro (

      DEFINE-MODIFY-MACRO

      NAME LAMBDA-LIST FUNCTION &OPTIONAL DOC-STRING)
      Creates a new read-modify-write macro like PUSH or INCF.
    • macro (

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

      DEFMACRO

      NAME LAMBDA-LIST &BODY BODY)
      Define a GPU macro.
    • macro (

      DEFMETHOD

      NAME &REST ARGS)
      No docstring provided.
    • macro (

      DEFPACKAGE

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

      DEFPARAMETER

      VAR VAL &OPTIONAL DOC)
      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.
    • macro (

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

      DEFSTRUCT

      NAME &BODY SLOTS)
      Define a GPU structure.
    • macro (

      DEFTYPE

      NAME LAMBDA-LIST &BODY BODY)
      Define a new type, with syntax like DEFMACRO.
    • macro (

      DEFUN

      NAME ARGS &BODY BODY)
      No docstring provided.
    • macro (

      DEFVAR

      VAR &OPTIONAL VAL DOC)
      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.
    • macro (

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

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

      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 alternate exit mechanism.
    • macro (

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

      DO-EXTERNAL-SYMBOLS

      (VAR &OPTIONAL (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.
    • macro (

      DO-SYMBOLS

      (VAR &OPTIONAL (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.
    • macro (

      DOLIST

      (VAR LIST &OPTIONAL (RESULT)) &BODY BODY)
      No docstring provided.
    • macro (

      DOTIMES

      (VAR COUNT &OPTIONAL (RESULT)) &BODY BODY)
      No docstring provided.
    • macro (

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

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

      FORMATTER

      CONTROL-STRING)
      No docstring provided.
    • macro (

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

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

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

      IN-PACKAGE

      STRING-DESIGNATOR)
      No docstring provided.
    • macro (

      INCF

      PLACE &OPTIONAL (DELTA 1))
      The first argument is some location holding a number. This number is
        incremented by the second argument, DELTA, which defaults to 1.
    • macro (

      LAMBDA

      ARGS &BODY BODY)
      No docstring provided.
    • macro (

      LOOP

      &REST KEYWORDS-AND-FORMS)
      No docstring provided.
    • macro (

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

      NTH-VALUE

      N FORM)
      Evaluate FORM and return the Nth value (zero based)
       without consing a temporary list of values.
    • macro (

      OR

      &REST FORMS)
      No docstring provided.
    • macro (

      POP

      PLACE)
      The argument is a location holding a list. Pops one item off the front
        of the list and returns it.
    • macro (

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

      PPRINT-LOGICAL-BLOCK

      (STREAM-SYMBOL OBJECT &REST KEYS &KEY (PREFIX) (PER-LINE-PREFIX) (SUFFIX)) &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.
    • macro (

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

      PRINT-UNREADABLE-OBJECT

      (OBJECT STREAM &KEY TYPE IDENTITY) &BODY BODY)
      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.
    • macro (

      PROG

      VARLIST &BODY BODY-DECLS)
      No docstring provided.
    • macro (

      PROG*

      VARLIST &BODY BODY-DECLS)
      No docstring provided.
    • macro (

      PROG1

      RESULT &BODY BODY)
      No docstring provided.
    • macro (

      PROG2

      FORM1 RESULT &BODY BODY)
      No docstring provided.
    • macro (

      PSETF

      &REST PAIRS)
      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.
    • macro (

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

      PUSH

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

      PUSHNEW

      OBJ PLACE &KEY KEY TEST TEST-NOT)
      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. Keyword arguments are accepted as per the ADJOIN function.
    • macro (

      REMF

      PLACE INDICATOR)
      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.
    • macro (

      RESTART-BIND

      BINDINGS &BODY FORMS)
      (RESTART-BIND ({(case-name function {keyword value}*)}*) forms)
         Executes forms in a dynamic context where the given bindings are in
         effect. Users probably want to use RESTART-CASE. A case-name of NIL
         indicates an anonymous restart. When bindings contain the same
         restart name, FIND-RESTART will find the first such binding.
    • macro (

      RESTART-CASE

      EXPRESSION &BODY CLAUSES)
      (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 form is a call to
         SIGNAL, ERROR, CERROR or WARN (or macroexpands into such) then the
         signalled condition will be associated with the new restarts.
    • macro (

      RETURN

      &OPTIONAL VALUE)
      No docstring provided.
    • macro (

      ROTATEF

      &REST ARGS)
      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.
    • macro (

      SETF

      &REST ARGS)
      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.
    • macro (

      SHIFTF

      &REST ARGS)
      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.
    • macro (

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

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

      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.)
      
      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 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.
      
         :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".
      
         :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 traced.
      
      :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 can use SB-DEBUG:ARG.
    • macro (

      TYPECASE

      KEYFORM &BODY CASES)
      TYPECASE Keyform {(Type Form*)}*
        Evaluates the Forms in the first clause for which TYPEP of Keyform and Type
        is true.
    • macro (

      UNLESS

      TEST &BODY FORMS)
      If the first argument is not true, the rest of the forms are
      evaluated as a PROGN.
    • macro (

      UNTRACE

      &REST SPECS)
      Remove tracing from the specified functions. Untraces all
      functions when called with no arguments.
    • macro (

      V-DEF-GLSL-TEMPLATE-FUN

      NAME ARGS TRANSFORM ARG-TYPES RETURN-SPEC &KEY V-PLACE-INDEX GLSL-NAME PURE)
      `v-def-glsl-template-fun` is the older syntax for `define-glsl-template-function`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFINE-COMPILER-MACRO

      NAME LAMBDA-LIST &BODY BODY)
      `v-define-compiler-macro` is the older syntax for `define-vari-compiler-macro`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFMACRO

      NAME LAMBDA-LIST &BODY BODY)
      `v-defmacro` is the older syntax for `define-vari-macro`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFSTRUCT

      NAME CONTEXT &BODY SLOTS)
      `v-defstruct` is the older syntax for `define-vari-struct`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFTYPE

      NAME ARGS TYPE-FORM &KEY VALID-METADATA-KINDS)
      `v-deftype` is the older syntax for `define-vari-type`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      V-DEFUN

      NAME ARGS &BODY BODY)
      `v-defun` is the older syntax for `define-vari-function`.
      
      This macro is still exported in order to maintain compatibility with existing
      code.
      
    • macro (

      WHEN

      TEST &BODY FORMS)
      If the first argument is true, the rest of the forms are
      evaluated as a PROGN.
    • macro (

      WITH-ACCESSORS

      SLOTS INSTANCE &BODY BODY)
      No docstring provided.
    • macro (

      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"))
      
    • macro (

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

      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 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 WITH-HASH-TABLE-ITERATOR
      for.
    • macro (

      WITH-OPEN-FILE

      (STREAM FILESPEC &REST OPTIONS) &BODY BODY)
      No docstring provided.
    • macro (

      WITH-OUTPUT-TO-STRING

      (VAR &OPTIONAL STRING &KEY (ELEMENT-TYPE)) &BODY FORMS-DECLS)
      No docstring provided.
    • macro (

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

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

      WITH-SLOTS

      SLOTS INSTANCE &BODY BODY)
      No docstring provided.
    • macro (

      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