SB-EXT

SIMD-PACK-512 names the built-in-class #<BUILT-IN-CLASS SB-EXT:SIMD-PACK-512>:
  Class precedence-list: SIMD-PACK-512, T
  Direct superclasses: T
  No subclasses.
  Sealed.
  No direct slots.

SIMD-PACK-512 names a primitive type-specifier:
  Lambda-list: (&OPTIONAL (ELEMENT-TYPE-SPEC (QUOTE *)))

GET-TIME-OF-DAY names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL
                 (VALUES (SIGNED-BYTE 64) (SIGNED-BYTE 64) &OPTIONAL))
  Documentation:
    Return the number of seconds and microseconds since the beginning of
    the UNIX epoch (January 1st 1970.)
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;UNIX.LISP

• Called by
  • RT/TRACING::%%GET-TIME-USEC
  • RT/TRACING::%%START-CLOCK
  • OBJ/TIME::GET-CURRENT-TIMETAG
  • UNIX-TIME
  • OBJ/TIME::%GET-CURRENT-TIME

PROCESS-INPUT names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Documentation:
    The input stream of the process or NIL.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

(SETF PROCESS-INPUT) names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (T SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

• Called by
  • UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM
  • GNUPLOT-SEND
  • CLI/TOOLS/TERM::INIT-TMUX-CONTROLLER

PROCESS-P names a compiled function:
  A predicate for SB-IMPL::PROCESS
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    T if OBJECT is a PROCESS, NIL otherwise.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

NATIVE-PATHNAME names a compiled function:
  Lambda-list: (PATHSPEC)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Documentation:
    Convert PATHSPEC (a pathname designator) into a pathname, assuming
    the operating system native pathname conventions.
  Source file: SYS:SRC;CODE;TARGET-PATHNAME.LISP

STEP-FORM-CONDITION names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:STEP-FORM-CONDITION>:
  Documentation:
    Condition signalled by code compiled with
    single-stepping information when about to execute a form.
    STEP-CONDITION-FORM holds the form. Associated with this condition are
    always the restarts STEP-INTO, STEP-NEXT, and STEP-CONTINUE.
  Class precedence-list: STEP-FORM-CONDITION, STEP-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STEP-CONDITION
  No subclasses.
  Direct slots:
    SB-KERNEL::ARGS
      Initargs: :ARGS
      Readers: STEP-CONDITION-ARGS

DEPRECATION-CONDITION-RUNTIME-ERROR names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

%MAKE-SIMD-PACK-256-SINGLE names a compiled function:
  Lambda-list: (A B C D E F G H)
  Declared type: (FUNCTION
                  (SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                   SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT)
                  (VALUES (SB-EXT:SIMD-PACK-256 SINGLE-FLOAT) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

*MUFFLED-WARNINGS* names a special variable:
  Value: SB-KERNEL:UNINTERESTING-REDEFINITION
  Documentation:
    A type that ought to specify a subtype of WARNING.  Whenever a
    warning is signaled, if the warning is of this type and is not
    handled by any other handler, it will be muffled.

FOLD-IDENTICAL-CODE names a compiled function:
  Lambda-list: (&KEY AGGRESSIVE PRESERVE-DOCSTRINGS (PRINT NIL))
  Derived type: (FUNCTION
                 (&KEY (:AGGRESSIVE T) (:PRESERVE-DOCSTRINGS T) (:PRINT T))
                 (VALUES NULL &OPTIONAL))
  Source file: SYS:SRC;CODE;ICF.LISP

DESCRIBE-COMPILER-POLICY names a compiled function:
  Lambda-list: (&OPTIONAL SPEC)
  Derived type: (FUNCTION (&OPTIONAL T) (VALUES &OPTIONAL))
  Documentation:
    Print all global optimization settings, augmented by SPEC.
  Source file: SYS:SRC;CODE;DESCRIBE-POLICY.LISP

DEFINE-SOURCE-CONTEXT names a macro:
  Lambda-list: (NAME LAMBDA-LIST &BODY BODY)
  Documentation:
    DEFINE-SOURCE-CONTEXT Name Lambda-List Form*
    This macro defines how to extract an abbreviated source context from the
    Named form when it appears in the compiler input. Lambda-List is a DEFMACRO
    style lambda-list used to parse the arguments. The Body should return a
    list of subforms suitable for a "~{~S ~}" format string.
  Source file: SYS:SRC;COMPILER;IR1REPORT.LISP

DEPRECATION-CONDITION-VERSION names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

STRING-TO-OCTETS names a compiled function:
  Lambda-list: (STRING &KEY (EXTERNAL-FORMAT DEFAULT) (START 0) END
                       NULL-TERMINATE)
  Declared type: (FUNCTION
                  (STRING &KEY (:EXTERNAL-FORMAT T) (:START (UNSIGNED-BYTE 44))
                          (:END (OR NULL (UNSIGNED-BYTE 44)))
                          (:NULL-TERMINATE T))
                  (VALUES (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) &OPTIONAL))
  Derived type: (FUNCTION
                 (STRING &KEY (:START T) (:END T) (:EXTERNAL-FORMAT T)
                         (:NULL-TERMINATE T))
                 (VALUES (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) &OPTIONAL))
  Documentation:
    Return an octet vector that is STRING encoded according to EXTERNAL-FORMAT.
    
    If EXTERNAL-FORMAT is given, it must designate an external format.
    
    If given, START and END must be bounding index designators and
    designate a subsequence of STRING that should be encoded.
    
    If NULL-TERMINATE is true, the returned octet vector ends with an
    additional 0 element that does not correspond to any part of STRING.
    
    If some of the characters of STRING (or the subsequence bounded by
    START and END) cannot be encoded by EXTERNAL-FORMAT an error of a
    subtype of SB-INT:CHARACTER-ENCODING-ERROR is signaled.
    
    Note that for some values of EXTERNAL-FORMAT and NULL-TERMINATE the
    length of the returned vector may be different from the length of
    STRING (or the subsequence bounded by START and END).
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;OCTETS.LISP

• Called by
  • (MAKE-SOCKADDR-FOR (LOCAL-ABSTRACT-SOCKET))
  • (MAKE-SOCKADDR-FOR (LOCAL-SOCKET))
  • (SOCKET-SEND (SOCKET T T))
  • (SOCKADDR-UN-PATH)
  • SB-POSIX:MKDTEMP
  • SB-POSIX:MKSTEMP
  • SB-POSIX:MKTEMP
  • (DIRENT-NAME)
  • SB-MD5:MD5SUM-STRING
  • SKEL/MPK/DB:UPDATE-MUSIC-METADATA
  • (SERIALIZE (CONTAINERFILE (EQL BYTES)))
  • (INSERT-KEY (RDB T STRING))
  • (INSERT-KEY (RDB STRING T))
  • (INSERT-KEY (RDB STRING STRING))
  • (INSERT-KEY (RDB-DATABASE T STRING))
  • (INSERT-KEY (RDB-DATABASE STRING T))
  • (INSERT-KEY (RDB-DATABASE STRING STRING))
  • (GET-KEY (RDB-WBWI STRING))
  • (PUT-KEY (RDB-WBWI STRING STRING))
  • (GET-VAL (RDB STRING))
  • (PUT-KEY (RDB STRING STRING))
  • RDB::SET-TRANSACTION-NAME-RAW
  • RDB::TRANSACTIONDB-PUT-CF-STR-RAW
  • RDB::TRANSACTIONDB-PUT-KV-STR-RAW
  • RDB::TRANSACTIONDB-GET-CF-STR-RAW
  • RDB::TRANSACTIONDB-GET-KV-STR-RAW
  • RDB::SST-PUT-STR-RAW
  • RDB::MERGE-CF-STR-RAW
  • RDB::PUT-CF-STR-RAW
  • RDB::GET-CF-STR-RAW
  • RDB::MERGE-KV-STR-RAW
  • RDB::GET-KV-STR-RAW
  • RDB::PUT-KV-STR-RAW
  • (EVALUATE (STRING RECORD-BATCH))
  • NET/SRV/http::SEND-UNKNOWN-PROTOCOL-RESPONSE
  • NET/SRV/http::SEND-BAD-REQUEST-RESPONSE
  • NET/SRV/http::SEND-HTTP-RESPONSE
  • NET/SRV/http::START-HTTP-OUTPUT
  • NET/REQ::REQ
  • NET/REQ::ENSURE-SOCKS5-CONNECTED
  • NET/REQ::BUILD-COOKIE-HEADERS
  • NET/REQ::WRITE-MULTIPART-CONTENT
  • NET/REQ::CONVERT-TO-OCTETS
  • NET/REQ::WRITE-CONNECT-HEADER
  • NET/REQ::WRITE-HEADER
  • NET/REQ::WRITE-HEADER-VALUE
  • NET/REQ::WRITE-HEADER-FIELD
  • NET/REQ::WRITE-FIRST-LINE
  • (AUTHENTICATOR-CHALLENGE (DBUS-SHA1-COOKIE-AUTHENTICATOR T))
  • NET/PROTO/SWANK::SLIME-NET-SEND
  • NET/CODEC/DBUS::PACK-STRING
  • NET/CORE::%SOCKADDR
  • CRY/JWT:HS256-DIGEST
  • CRY/JWT::BASE64-ENCODE
  • CRY/PASSWORD:MAKE-PASSWORD-HASH
  • (WRITE-GNU-LONG-NAME-ENTRY (T T))
  • (WRITE-GNU-LONG-LINK-NAME-ENTRY (T T))
  • DAT/TAR::ATTRIBUTE-PAIR-TO-OCTETS
  • (WRITE-FILE-ENTRY (T T))
  • DAT/TAR::GNU-HEADER-WRITE-%%PADDING-TO-BUFFER
  • DAT/TAR::GNU-HEADER-WRITE-LONGNAMES-TO-BUFFER
  • DAT/TAR::GNU-HEADER-WRITE-GNAME-TO-BUFFER
  • DAT/TAR::GNU-HEADER-WRITE-UNAME-TO-BUFFER
  • DAT/TAR::GNU-HEADER-WRITE-VERSION-TO-BUFFER
  • DAT/TAR::GNU-HEADER-WRITE-MAGIC-TO-BUFFER
  • DAT/TAR::GNU-HEADER-WRITE-LINKNAME-TO-BUFFER
  • DAT/TAR::GNU-HEADER-WRITE-NAME-TO-BUFFER
  • DAT/TAR::USTAR-HEADER-WRITE-%%PADDING-TO-BUFFER
  • DAT/TAR::USTAR-HEADER-WRITE-PREFIX-TO-BUFFER
  • DAT/TAR::USTAR-HEADER-WRITE-GNAME-TO-BUFFER
  • DAT/TAR::USTAR-HEADER-WRITE-UNAME-TO-BUFFER
  • DAT/TAR::USTAR-HEADER-WRITE-LINKNAME-TO-BUFFER
  • DAT/TAR::USTAR-HEADER-WRITE-NAME-TO-BUFFER
  • DAT/TAR::V7-HEADER-WRITE-%%PADDING-TO-BUFFER
  • DAT/TAR::V7-HEADER-WRITE-LINKNAME-TO-BUFFER
  • DAT/TAR::V7-HEADER-WRITE-NAME-TO-BUFFER
  • (WRITE-ENTRY-DATA (TAR-FILE T T))
  • DAT/PARQUET::TCOMPACT-ENCODE-STRING
  • (STREAM-WRITE-STRING (STATIC-STREAM T))
  • OBJ/UUID::DIGEST-UUID
  • URL-ENCODE
  • (KEYCTL-KDF-PARAMS-OTHERINFO)
  • (KEYCTL-KDF-PARAMS-HASHNAME)
  • SWANK/RPC::ENCODING-ERROR
  • SWANK/RPC:WRITE-MESSAGE
  • HEX-STRING
  • CLONE-STRINGS

MOST-POSITIVE-WORD names a constant variable:
  Value: 18446744073709551615
  Documentation:
    The most positive integer that is of type SB-EXT:WORD.

• Referenced by
  • SB-SPROF::EXTRACT-TRACES
  • DEC-COUNTER
  • INC-COUNTER

IMPLICIT-GENERIC-FUNCTION-WARNING names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:IMPLICIT-GENERIC-FUNCTION-WARNING>:
  Class precedence-list: IMPLICIT-GENERIC-FUNCTION-WARNING, STYLE-WARNING,
                         WARNING, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STYLE-WARNING
  No subclasses.
  Direct slots:
    SB-KERNEL::NAME
      Initargs: :NAME
      Readers: IMPLICIT-GENERIC-FUNCTION-NAME

SINGLE-FLOAT-NEGATIVE-INFINITY names a constant variable:
  Value: #.SINGLE-FLOAT-NEGATIVE-INFINITY

%MAKE-SIMD-PACK-UB64 names a compiled function:
  Lambda-list: (LOW HIGH)
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64))
                  (VALUES (SB-EXT:SIMD-PACK (UNSIGNED-BYTE 64)) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

%SIMD-PACK-DOUBLES names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES DOUBLE-FLOAT DOUBLE-FLOAT &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

%MAKE-SIMD-PACK-512-UB32 names a compiled function:
  Lambda-list: (P0 P1 P2 P3 P4 P5 P6 P7 P8 P9 P10 P11 P12 P13 P14 P15)
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                   (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                   (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                   (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                   (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                   (UNSIGNED-BYTE 32))
                  (VALUES (SB-EXT:SIMD-PACK-512 (UNSIGNED-BYTE 32)) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

PROCESS-EXIT-CODE names a compiled function:
  Lambda-list: (PROCESS)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Documentation:
    The exit code or the signal of a stopped process.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

• Called by
  • (PERFORM (COMPILE-OP GROVEL-CONSTANTS-FILE))
  • SB-GROVEL::RUN-C-COMPILER
  • UIOP/LAUNCH-PROGRAM:WAIT-PROCESS
  • UIOP/LAUNCH-PROGRAM::%PROCESS-STATUS
  • (ID (HG-REPO))
  • (VC-CLONE (HG-REPO T))
  • (VC-RUN (HG-REPO STRING))
  • (VC-INIT (HG-REPO))
  • (VC-ADDREMOVE (GIT-REPO))
  • (VC-REMOVE (GIT-REPO))
  • (VC-ADD (GIT-REPO))
  • (VC-COMMIT (GIT-REPO T))
  • (VC-PUSH (GIT-REPO))
  • (VC-PULL (GIT-REPO))
  • (VC-CLONE (GIT-REPO T))
  • (VC-INIT (GIT-REPO))
  • RUN-DOT
  • CLI/TOOLS/FS::RUN-RCLONE
  • CLI/TOOLS/FS::RUN-BTRFS
  • CLI/TOOLS/MAIL::RUN-OFFLINEIMAP*
  • CLI/TOOLS/MAIL::RUN-NOTMUCH*
  • CLI/TOOLS/MEDIA::RUN-PICARD
  • CLI/TOOLS/MEDIA::RUN-WIREPLUMBER
  • RUN-MPV
  • RUN-FFMPEG
  • CLI/TOOLS/MEDIA::RUN-FLAMEGRAPH.PL
  • CLI/TOOLS/NET::RUN-RSYNC
  • RUN-TRANSMISSION-DAEMON
  • RUN-TRANSMISSION-REMOTE
  • RUN-CADDY*
  • YTDL-JSON
  • YTDL-LIST
  • YTDL-USER-AGENT
  • YTDL-EXTRACTORS
  • RUN-YTDL
  • CLI/TOOLS/NET::RUN-NMAP*
  • RUN-EASYRSA
  • CLI/TOOLS/NET::RUN-DNSMASQ
  • CLI/TOOLS/NET::RUN-WG*
  • RUN-IP
  • RUN-BROWSER
  • RUN-CORE
  • RUN-SBCL
  • RUN-BUSCTL
  • RUN-MACHINECTL
  • RUN-USERDBCTL
  • RUN-HOMECTL
  • RUN-LOGINCTL
  • RUN-RESOLVECTL
  • RUN-NETWORKCTL
  • RUN-JOURNALCTL
  • RUN-SYSTEMCTL
  • QEMU-IMG
  • RUN-QEMU
  • CLI/TOOLS/VIRT::RUN-MKARCHISO
  • RUN-BUILDAH
  • RUN-PODMAN
  • RUN-XVFB-RUN
  • CLI/TOOLS/BUILD::RUN-NPX
  • RUN-GO
  • CLI/TOOLS/BUILD::RUN-UV
  • RUN-RUSTUP
  • RUN-CARGO
  • RUN-MESON
  • RUN-NINJA
  • RUN-CMAKE
  • RUN-MAKE
  • RUN-LLDB
  • RUN-GDB
  • RUN-NVCC
  • RUN-LD
  • RUN-CC
  • CLI/TOOLS/PACMAN::RUN-MAKEPKG
  • CLI/TOOLS/PACMAN::RUN-MKARCHROOT
  • RUN-PACMAN
  • RUN-TMUX
  • RUN-FBTERM
  • RUN-SCRIPTREPLAY
  • RUN-SCRIPT
  • STD/DEFSYS::COMPILE-GROVEL-COMPONENT

*INLINE-EXPANSION-LIMIT* names a special variable:
  Value: 50
  Documentation:
    an upper limit on the number of inline function calls that will be expanded
    in any given code object (single function or block compilation)

DOUBLE-FLOAT-POSITIVE-INFINITY names a constant variable:
  Value: #.DOUBLE-FLOAT-POSITIVE-INFINITY

PACKAGE-IMPLEMENTS-LIST names a compiled function:
  Lambda-list: (PACKAGE)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Documentation:
    Returns the packages that PACKAGE is an implementation package
    of. Signals an error if PACKAGE is not a valid package designator.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • (PUBLISH (PACKAGE-DOCUMENTATION))
  • ENSURE-PACKAGE

ENABLE-DEBUGGER names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES &OPTIONAL))
  Documentation:
    Restore the debugger if it has been turned off by DISABLE-DEBUGGER.
  Source file: SYS:SRC;CODE;DEBUG.LISP

• Called by
  • SKEL/CLI::START-SKEL
  • SKEL/MPK/CLI::START-MPK
  • SKEL/HOMER/CLI::START-HOMER
  • SKEL/PACKY/CLI::START-PACKY
  • (BACKGROUND-SAVE-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (SAVE-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)

SEARCH-ROOTS names a compiled function:
  Lambda-list: (WEAK-POINTERS &KEY (CRITERION OLDEST)
                (IGNORE (QUOTE (* ** *** / // ///))) (PRINT T))
  Declared type: (FUNCTION
                  ((OR LIST SB-EXT:WEAK-POINTER) &KEY
                   (:CRITERION (MEMBER :STATIC :PSEUDO-STATIC :OLDEST))
                   (:IGNORE LIST) (:PRINT (MEMBER :VERBOSE NIL T)))
                  *)
  Derived type: (FUNCTION
                 ((OR LIST SB-EXT:WEAK-POINTER) &KEY
                  (:CRITERION (MEMBER :STATIC :PSEUDO-STATIC :OLDEST))
                  (:IGNORE LIST) (:PRINT (MEMBER :VERBOSE NIL T)))
                 (VALUES &OPTIONAL LIST))
  Documentation:
    Find roots keeping the targets of WEAK-POINTERS alive.
    
    WEAK-POINTERS must be a single SB-EXT:WEAK-POINTER or a list of those,
    pointing to objects for which roots should be searched.
    
    CRITERION determines just how rooty (how deep) a root must be in order
    to be considered. Possible values are:
    
    - :OLDEST
    
        This says we can stop upon seeing an object in the oldest gen to
        GC, or older. This is the easiest test to satisfy.
    
    - :PSEUDO-STATIC
    
        This is usually the same as :OLDEST, unless the oldest gen to GC
        has been decreased.
    
    - :STATIC
    
        To find a root of an image-backed object, you want to stop only at
        a truly :STATIC object.
    
    IGNORE is a list of objects to treat as if nonexistent in the heap.
    It can often be useful for finding a path to an interned symbol other than
    through its package by specifying the package as an ignored object.
    
    PRINT controls whether discovered paths should be returned or
    printed. Possible values are
    
    - :VERBOSE
    
        Return no values. Print discovered paths using a verbose format
        with each node of each path on a separate line.
    
    - true (other than :VERBOSE)
    
        Return no values. Print discovered paths using a compact format
        with all nodes of each path on a single line.
    
    - NIL
    
        Do not print any output. Instead return the discovered paths as a
        list of lists. Each list has the form
    
            (TARGET . (ROOT NODE*))
    
        where TARGET is one of the target of one of the WEAK-POINTERS.
    
        ROOT is a description of the root at which the path starts and has
        one of the following forms:
    
        - :STATIC
    
            If the root of the path is a non-collectible heap object.
    
        - :PINNED
    
            If an unknown thread stack pins the root of the path.
    
        - ((THREAD-NAME | THREAD-OBJECT) SYMBOL CURRENTP)
    
            If the path begins at a special binding of SYMBOL in a thread.
            CURRENTP is a BOOLEAN indicating whether the value is current
            or shadowed by another binding.
    
        - ((THREAD-NAME | THREAD-OBJECT) GUESSED-PC)
    
            If the path begins at a lexical variable in the function whose
            code contains GUESSED-PC.
    
        Each NODE in the remainder of the path is a cons (OBJECT . SLOT)
        indicating that the slot at index SLOT in OBJECT references the
        next path node.
    
    Experimental: subject to change without prior notice.
  Source file: SYS:SRC;CODE;TRACEROOT.LISP

COMPARE-AND-SWAP names a macro:
  Lambda-list: (PLACE OLD NEW)
  Documentation:
    Atomically stores NEW in PLACE if OLD matches the current value of PLACE.
    Two values are considered to match if they are EQ. Returns the previousvalue
    of PLACE: if the returned value is EQ to OLD, the swap was carried out.
    
    PLACE must be an CAS-able place. Built-in CAS-able places are accessorforms
    whose CAR is one of the following:
    
     CAR, CDR, FIRST, REST, SVREF, SYMBOL-PLIST, SYMBOL-VALUE, SLOT-VALUE
     SB-MOP:STANDARD-INSTANCE-ACCESS, SB-MOP:FUNCALLABLE-STANDARD-INSTANCE-ACCESS,
    
    or the name of a DEFSTRUCT created accessor for a slot whose storage type
    is not raw. (Refer to the the "Efficiency" chapter of the manual
    for the list of raw slot types.  Future extensions to this macro may allow
    it to work on some raw slot types.)
    
    In case of SLOT-VALUE, if the slot is unbound, SLOT-UNBOUND is calledunless
    OLD is EQ to SB-PCL:+SLOT-UNBOUND+ in which case SB-PCL:+SLOT-UNBOUND+ is
    returned and NEW is assigned to the slot. Additionally, the results are
    unspecified if there is an applicable method on either
    SB-MOP:SLOT-VALUE-USING-CLASS, (SETF SB-MOP:SLOT-VALUE-USING-CLASS), or
    SB-MOP:SLOT-BOUNDP-USING-CLASS.
    
    Additionally, the PLACE can be a anything for which a CAS-function has
    been defined.
  Source file: SYS:SRC;CODE;MACROS.LISP

• Macroexpanded by
  • SB-CONCURRENCY:DEQUEUE
  • SB-CONCURRENCY:ENQUEUE

*EXIT-TIMEOUT* names a special variable:
  Declared type: (OR REAL NULL)
  Value: 60
  Documentation:
    Default amount of seconds, if any, EXIT should wait for other
    threads to finish after terminating them. Default value is 60. NIL
    means to wait indefinitely.

*DERIVE-FUNCTION-TYPES* names a special variable:
  Value: NIL
  Documentation:
    Should the compiler assume that function types will never change,
    so that it can use type information inferred from current definitions
    to optimize code which uses those definitions? Setting this true
    gives non-ANSI, early-CMU-CL behavior. It can be useful for improving
    the efficiency of stable code.

DEPRECATION-CONDITION-NAMESPACE names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

OCTETS-TO-STRING names a compiled function:
  Lambda-list: (VECTOR &KEY (EXTERNAL-FORMAT DEFAULT) (START 0) END)
  Declared type: (FUNCTION
                  ((VECTOR (UNSIGNED-BYTE 8)) &KEY (:EXTERNAL-FORMAT T)
                   (:START (UNSIGNED-BYTE 44))
                   (:END (OR NULL (UNSIGNED-BYTE 44))))
                  (VALUES SIMPLE-STRING &OPTIONAL))
  Documentation:
    Return a string obtained by decoding VECTOR according to EXTERNAL-FORMAT.
    
    If EXTERNAL-FORMAT is given, it must designate an external format.
    
    If given, START and END must be bounding index designators and
    designate a subsequence of VECTOR that should be decoded.
    
    If some of the octets of VECTOR (or the subsequence bounded by START
    and END) cannot be decoded by EXTERNAL-FORMAT an error of a subtype of
    SB-INT:CHARACTER-DECODING-ERROR is signaled.
    
    Note that for some values of EXTERNAL-FORMAT the length of the
    returned string may be different from the length of VECTOR (or the
    subsequence bounded by START and END).
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;OCTETS.LISP

• Called by
  • SB-POSIX:MKDTEMP
  • SB-POSIX:MKSTEMP
  • SB-POSIX:MKTEMP
  • SKEL/MPK/DB:GET-METADATA*
  • SK-LOG-LIST
  • ORGAN/DB::OG-VALUES
  • (GET-VAL (RDB STRING))
  • RDB::TRANSACTION-NAME-RAW
  • RDB::TRANSACTIONDB-GET-CF-STR-RAW
  • RDB::TRANSACTIONDB-GET-KV-STR-RAW
  • RDB::ITER-VAL-STR-RAW
  • RDB::ITER-KEY-STR-RAW
  • RDB::GET-CF-STR-RAW
  • RDB::GET-KV-STR-RAW
  • (EXEC (HASH-AGGREGATE-EXEC))
  • NET/SRV/http::RAW-POST-DATA
  • NET/REQ::DECODE-BODY
  • NET/REQ::DETECT-CHARSET-FROM-HTML
  • PARSE-SET-COOKIE-HEADER
  • NET/COOKIE::PARSE-COOKIE-DATE
  • NET/PROTO/DBUS::PARSE-AUTHENTICATION-RESPONSE
  • NET/PROTO/DBUS::UNESCAPE-SERVER-ADDRESSES-STRING
  • MAKE-MULTIPART-PARSER
  • NET/PROTO/SWANK::SLIME-NET-READ
  • NET/CODEC/DBUS::UNPACK-STRING
  • (SERIALIZE (TLV (EQL STRING)))
  • CRY/JWT:JWT-DECODE
  • (SLOT-UNBOUND (T GNU-LONG-NAME-ENTRY (EQL LONG-NAME)))
  • (SLOT-UNBOUND (T GNU-LONG-LINK-NAME-ENTRY (EQL LONG-LINK-NAME)))
  • DAT/TAR:READ-ATTRIBUTE
  • DAT/TAR::READ-ATTRIBUTE-LENGTH
  • DAT/TAR::GNU-HEADER-READ-%%PADDING-FROM-BUFFER
  • DAT/TAR::GNU-HEADER-READ-LONGNAMES-FROM-BUFFER
  • DAT/TAR::GNU-HEADER-READ-GNAME-FROM-BUFFER
  • DAT/TAR::GNU-HEADER-READ-UNAME-FROM-BUFFER
  • DAT/TAR::GNU-HEADER-READ-VERSION-FROM-BUFFER
  • DAT/TAR::GNU-HEADER-READ-MAGIC-FROM-BUFFER
  • DAT/TAR::GNU-HEADER-READ-LINKNAME-FROM-BUFFER
  • DAT/TAR::GNU-HEADER-READ-NAME-FROM-BUFFER
  • DAT/TAR::USTAR-HEADER-READ-%%PADDING-FROM-BUFFER
  • DAT/TAR::USTAR-HEADER-READ-PREFIX-FROM-BUFFER
  • DAT/TAR::USTAR-HEADER-READ-GNAME-FROM-BUFFER
  • DAT/TAR::USTAR-HEADER-READ-UNAME-FROM-BUFFER
  • DAT/TAR::USTAR-HEADER-READ-LINKNAME-FROM-BUFFER
  • DAT/TAR::USTAR-HEADER-READ-NAME-FROM-BUFFER
  • DAT/TAR::V7-HEADER-READ-%%PADDING-FROM-BUFFER
  • DAT/TAR::V7-HEADER-READ-LINKNAME-FROM-BUFFER
  • DAT/TAR::V7-HEADER-READ-NAME-FROM-BUFFER
  • DAT/ASN1:DECODE-ASN1-TIME
  • (DECODE-ASN1-STRING (T (EQL 30)))
  • (DECODE-ASN1-STRING (T (EQL 20)))
  • (DECODE-ASN1-STRING (T (EQL 28)))
  • (DECODE-ASN1-STRING (T (EQL 12)))
  • (DECODE-ASN1-STRING (T (EQL 19)))
  • (DECODE-ASN1-STRING (T (EQL 22)))
  • URL-DECODE
  • SWANK/RPC:READ-PACKET
  • UTF8-TO-STRING

WEAK-POINTER-VALUE names a compiled function:
  Lambda-list: (WEAK-POINTER)
  Derived type: (FUNCTION (SB-EXT:WEAK-POINTER) (VALUES T BOOLEAN &OPTIONAL))
  Documentation:
    If WEAK-POINTER is valid, return the value of WEAK-POINTER and T.
    If the referent of WEAK-POINTER has been garbage collected,
    returns the values NIL and NIL.
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;WEAK.LISP

• Called by
  • SB-INTROSPECT:MAP-ROOT
  • SB-INTROSPECT::COLLECT-XREF
  • OBJ/CACHE::MAP-CACHE
  • GET-CACHE
  • (UPGRADE-ALL-MEMORY-INSTANCES (STORE))
  • (EMACS-INSPECT (WEAK-POINTER))
  • DEEP-SIZE

WITHOUT-PACKAGE-LOCKS names a macro:
  Lambda-list: (&BODY BODY)
  Documentation:
    Ignores all runtime package lock violations during the execution of
    body. Body can begin with declarations.
  Source file: SYS:SRC;CODE;PACKAGE.LISP

• Macroexpanded by
  • SB-GMP:UNINSTALL-GMP-FUNS
  • SB-GMP:INSTALL-GMP-FUNS
  • SB-SPROF::ENABLE-CALL-COUNTING-FOR-FUNCTION
  • SB-SPROF::DISABLE-CALL-COUNTING
  • SWANK::MONKEY-PATCH-STREAM-PRINTING

GET-BYTES-CONSED names a compiled function:
  Lambda-list: ()
  Declared type: (FUNCTION NIL (VALUES UNSIGNED-BYTE &OPTIONAL))
  Documentation:
    Return the number of bytes consed since the program began. Typically
    this result will be a consed bignum, so if you have an
    application (e.g. profiling) which can't tolerate the overhead of
    consing bignums, you'll probably want either to hack in at a lower
    level (as the code in the SB-PROFILE package does), or to design a
    more microefficient interface and submit it as a patch.
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;GC.LISP

PROCESS-PLIST names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Documentation:
    A place for clients to stash things.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

(SETF PROCESS-PLIST) names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (T SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

PACKAGE-LOCKED-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:PACKAGE-LOCKED-ERROR>:
  Documentation:
    Subtype of SB-EXT:PACKAGE-LOCK-VIOLATION. An error of this type is
    signalled when an operation on a package violates a package lock.
  Class precedence-list: PACKAGE-LOCKED-ERROR, PACKAGE-LOCK-VIOLATION,
                         PACKAGE-ERROR, ERROR, SERIOUS-CONDITION,
                         SB-INT:REFERENCE-CONDITION, SIMPLE-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: PACKAGE-LOCK-VIOLATION
  No subclasses.
  No direct slots.

WITH-LOCKED-HASH-TABLE names a macro:
  Lambda-list: ((HASH-TABLE) &BODY BODY)
  Documentation:
    Limits concurrent accesses to HASH-TABLE for the duration of BODY.
    If HASH-TABLE is synchronized, BODY will execute with exclusive
    ownership of the table. If HASH-TABLE is not synchronized, BODY will
    execute with other WITH-LOCKED-HASH-TABLE bodies excluded -- exclusion
    of hash-table accesses not surrounded by WITH-LOCKED-HASH-TABLE is
    unspecified.
  Source file: SYS:SRC;CODE;TARGET-EXTENSIONS.LISP

%SIMD-PACK-256-DOUBLES names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT
                          &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

ADD-IMPLEMENTATION-PACKAGE names a compiled function:
  Lambda-list: (PACKAGES-TO-ADD &OPTIONAL (PACKAGE *PACKAGE*))
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES LIST &OPTIONAL))
  Documentation:
    Adds PACKAGES-TO-ADD as implementation packages of PACKAGE. Signals
    an error if PACKAGE or any of the PACKAGES-TO-ADD is not a valid
    package designator.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • ENSURE-PACKAGE

%SIMD-PACK-256-UB64S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64)
                          (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

SEED-RANDOM-STATE names a compiled function:
  Lambda-list: (&OPTIONAL STATE)
  Declared type: (FUNCTION
                  (&OPTIONAL
                   (OR BOOLEAN RANDOM-STATE UNSIGNED-BYTE
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*))))
                  (VALUES RANDOM-STATE &OPTIONAL))
  Derived type: (FUNCTION (&OPTIONAL T) (VALUES RANDOM-STATE &OPTIONAL))
  Documentation:
    Make a random state object. The optional STATE argument specifies a seed
    for deterministic pseudo-random number generation.
    
    As per the Common Lisp standard for MAKE-RANDOM-STATE,
    
    - 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).
    
    As a supported SBCL extension, we also support receiving as a seed anobject
    of the following types:
    
    - (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))
    - UNSIGNED-BYTE
    
    While we support arguments of any size and will mix the provided bits into
    the random state, it is probably overkill to provide more than 256 bitsworth
    of actual information.
    
    This particular SBCL version also accepts an argument of the followingtype:
    (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*))
    
    This particular SBCL version uses the popular MT19937 PRNG algorithm, andits
    internal state only effectively contains about 19937 bits of information.
    <http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html>
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;TARGET-RANDOM.LISP

%SIMD-PACK-UB32S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

DYNAMIC-SPACE-SIZE names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Documentation:
    Size of the dynamic space in bytes.
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;GC.LISP

*EFFICIENCY-NOTE-LIMIT* names a special variable:
  Declared type: (OR NULL (UNSIGNED-BYTE 44))
  Value: 2
  Documentation:
    This is the maximum number of possible optimization alternatives will be
    mentioned in a particular efficiency note. NIL means no limit.

NAME-CONFLICT names a compiled function:
  Lambda-list: (PACKAGE FUNCTION DATUM &REST SYMBOLS)
  Derived type: (FUNCTION (T T T &REST T) *)
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

NAME-CONFLICT names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:NAME-CONFLICT>:
  Class precedence-list: NAME-CONFLICT, SB-INT:REFERENCE-CONDITION,
                         PACKAGE-ERROR, ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION, PACKAGE-ERROR
  No subclasses.
  Direct slots:
    FUNCTION
      Initargs: :FUNCTION
      Readers: NAME-CONFLICT-FUNCTION
    SB-IMPL::DATUM
      Initargs: :DATUM
      Readers: NAME-CONFLICT-DATUM
    SB-IMPL::SYMBOLS
      Initargs: :SYMBOLS
      Readers: NAME-CONFLICT-SYMBOLS

TIMER names the structure-class #<STRUCTURE-CLASS SB-EXT:TIMER>:
  Documentation:
    Timer type. Do not rely on timers being structs as it may change in
    future versions.
  Class precedence-list: TIMER, STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STRUCTURE-OBJECT
  No subclasses.
  Sealed.
  Slots:
    SB-IMPL::NAME
      Type: T
      Initform: NIL
    FUNCTION
      Type: T
      Initform: NIL
    SB-IMPL::EXPIRE-TIME
      Type: (OR NULL REAL)
      Initform: 1
    SB-IMPL::REPEAT-INTERVAL
      Type: (OR NULL (REAL 0))
      Initform: NIL
    SB-IMPL::CATCH-UP
      Type: BOOLEAN
      Initform: NIL
    SB-IMPL::THREAD
      Type: (OR SB-THREAD:THREAD BOOLEAN)
      Initform: NIL
    SB-IMPL::INTERRUPT-FUNCTION
      Type: (OR NULL FUNCTION)
      Initform: NIL
    SB-IMPL::CANCEL-FUNCTION
      Type: (OR NULL FUNCTION)
      Initform: NIL

FILE-EXISTS names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:FILE-EXISTS>:
  Class precedence-list: FILE-EXISTS, SB-INT:SIMPLE-FILE-ERROR,
                         SIMPLE-CONDITION, FILE-ERROR, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:SIMPLE-FILE-ERROR
  No subclasses.
  No direct slots.

%SIMD-PACK-512-UB16S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

%SIMD-PACK-512-SB32S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (SIGNED-BYTE 32) (SIGNED-BYTE 32) (SIGNED-BYTE 32)
                          (SIGNED-BYTE 32) (SIGNED-BYTE 32) (SIGNED-BYTE 32)
                          (SIGNED-BYTE 32) (SIGNED-BYTE 32) (SIGNED-BYTE 32)
                          (SIGNED-BYTE 32) (SIGNED-BYTE 32) (SIGNED-BYTE 32)
                          (SIGNED-BYTE 32) (SIGNED-BYTE 32) (SIGNED-BYTE 32)
                          (SIGNED-BYTE 32) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

SET-MACRO-POLICY names a compiled function:
  Lambda-list: (LIST)
  Derived type: (FUNCTION (T) (VALUES SB-C:POLICY &OPTIONAL))
  Source file: SYS:SRC;COMPILER;POLICY.LISP

PROCESS-OUTPUT names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Documentation:
    The output stream of the process or NIL.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

(SETF PROCESS-OUTPUT) names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (T SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

• Called by
  • UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM
  • (ID (HG-REPO))
  • (ID (GIT-REPO))
  • NOTMUCH-ADDRESS
  • NOTMUCH-COUNT
  • NOTMUCH-SHOW
  • NOTMUCH-SEARCH
  • CLI/TOOLS/NET::RUN-WG*
  • RUN-IP
  • RUN-BROWSER
  • RUN-LD
  • CLI/TOOLS/TERM::INIT-TMUX-CONTROLLER
  • SUDO-P

UNENCAPSULATED-FUNCTION names a compiled function:
  Lambda-list: (FUNCTION)
  Derived type: (FUNCTION (T) (VALUES FUNCTION &OPTIONAL))
  Documentation:
    Return the innermost function within any encapsulations of the
    function designated by FUNCTION. The identity of the returned
    function is not affected by encapsulations.
    
    Note that the unencapsulated function may be EQ to the designated
    function even in the presence of encapsulations. For generic
    functions, this is currently always the case.
  Source file: SYS:SRC;CODE;FDEFINITION.LISP

• Called by
  • FUNCTION-LAMBDA-LIST
  • SB-INTROSPECT:FIND-DEFINITION-SOURCES-BY-NAME

POSIX-GETENV names a compiled function:
  Lambda-list: (NAME)
  Declared type: (FUNCTION (T) (VALUES (OR SIMPLE-STRING NULL) &OPTIONAL))
  Documentation:
    Return the value part of the environment string name=value which
    corresponds to NAME, or NIL if there is none. See getenv(3).
  Source file: SYS:SRC;CODE;UNIX.LISP

• Called by
  • SB-GROVEL::RUN-C-COMPILER
  • UIOP/OS:GETENV
  • SET-TERMINAL

GLOBAL names an SBCL-specific declaration.

%SIMD-PACK-512-SB64S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (SIGNED-BYTE 64) (SIGNED-BYTE 64) (SIGNED-BYTE 64)
                          (SIGNED-BYTE 64) (SIGNED-BYTE 64) (SIGNED-BYTE 64)
                          (SIGNED-BYTE 64) (SIGNED-BYTE 64) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

WITH-UNLOCKED-PACKAGES names a macro:
  Lambda-list: ((&REST PACKAGES) &BODY FORMS)
  Documentation:
    Unlocks PACKAGES for the dynamic scope of the body. Signals an
    error if any of PACKAGES is not a valid package designator.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

%SIMD-PACK-SB32S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES (SIGNED-BYTE 32) (SIGNED-BYTE 32) (SIGNED-BYTE 32)
                          (SIGNED-BYTE 32) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

READTABLE-NORMALIZATION names a compiled function:
  Lambda-list: (READTABLE)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Returns T if READTABLE normalizes symbols to SB-MANUAL::@NFKC, and NIL
    otherwise. The READTABLE-NORMALIZATION of the standard readtable is T.
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;READER.LISP

(SETF READTABLE-NORMALIZATION) names a compiled function:
  Lambda-list: (NEW-VALUE READTABLE)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Sets the READTABLE-NORMALIZATION of the given READTABLE to NEW-VALUE.
    Pass T to make READTABLE normalize symbols to NFKC (the default behavior),
    and NIL to suppress normalization.
  Source file: SYS:SRC;CODE;READER.LISP

WITH-TIMEOUT names a macro:
  Lambda-list: (EXPIRES &BODY BODY)
  Documentation:
    Execute the body, asynchronously interrupting it and signalling a TIMEOUT
    condition after at least EXPIRES seconds have passed.
    
    Note that it is never safe to unwind from an asynchronous condition.Consider:
    
        (defun call-with-foo (function)
          (let (foo)
            (unwind-protect
               (progn
                 (setf foo (get-foo))
                 (funcall function foo))
             (when foo
               (release-foo foo)))))
    
    If TIMEOUT occurs after GET-FOO has executed, but before the
    assignment, then RELEASE-FOO will be missed. While individual sites
    like this can be made proof against asynchronous unwinds, this doesn't
    solve the fundamental issue, as all the frames potentially unwound
    through need to be proofed, which includes both system and application
    code -- and in essence proofing everything will make the system
    uninterruptible.
  Source file: SYS:SRC;CODE;TIMER.LISP

• Macroexpanded by
  • NET/PROTO/DNS::TRY-SERVER

SET-SBCL-SOURCE-LOCATION names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Documentation:
    Initialize the SYS logical host based on PATHNAME, which should
    be the top-level directory of the SBCL sources. This will replace any
    existing translations for "SYS:SRC;", "SYS:CONTRIB;", and
    "SYS:OUTPUT;". Other "SYS:" translations are preserved.
  Source file: SYS:SRC;CODE;TARGET-PATHNAME.LISP

ARRAY-STORAGE-VECTOR names a compiled function:
  Lambda-list: (ARRAY)
  Declared type: (FUNCTION (ARRAY) (VALUES (SIMPLE-ARRAY * (*)) &OPTIONAL))
  Documentation:
    Returns the underlying storage vector of ARRAY, which must be a non-displaced array.
    
    In SBCL, if ARRAY is a of type (SIMPLE-ARRAY * (*)), it is its own storage
    vector. Multidimensional arrays, arrays with fill pointers, and adjustable
    arrays have an underlying storage vector with the same ARRAY-ELEMENT-TYPEas
    ARRAY, which this function returns.
    
    > _Note_: the underlying vector is an implementation detail. Even
    > though this function exposes it, changes in the implementation may
    > cause this function to be removed without further warning.
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;ARRAY.LISP

• Called by
  • OCTET-VECTOR-POINTER
  • FLOAT-ARRAY-POINTER
  • DOUBLE-ARRAY-POINTER

PROCESS-STATUS-HOOK names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Documentation:
    A function that is called when PROCESS changes its status.
    The function is called with PROCESS as its only argument.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

(SETF PROCESS-STATUS-HOOK) names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (T SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

BYTES-CONSED-BETWEEN-GCS names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Documentation:
    The amount of memory that will be allocated before the next garbage
    collection is initiated. This can be set with SETF.
    
    On GENCGC platforms this is the nursery size, and defaults to 5% of dynamic
    space size.
    
    Note that currently, changes to this value are lost when saving core.
  Source file: SYS:SRC;CODE;GC.LISP

(SETF BYTES-CONSED-BETWEEN-GCS) names a compiled function:
  Lambda-list: (VAL)
  Derived type: (FUNCTION ((UNSIGNED-BYTE 62))
                 (VALUES (UNSIGNED-BYTE 62) &OPTIONAL))
  Source file: SYS:SRC;CODE;GC.LISP

HASH-TABLE-WEAKNESS names a compiled function:
  Lambda-list: (HT)
  Derived type: (FUNCTION (T) (VALUES SYMBOL &OPTIONAL))
  Documentation:
    Return the WEAKNESS of HASH-TABLE which is one of NIL, :KEY,
    :VALUE, :KEY-AND-VALUE, :KEY-OR-VALUE.
  Source file: SYS:SRC;CODE;TARGET-HASH-TABLE.LISP

• Called by
  • (HASH-TABLE-WEAKNESS IN /home/ellis/src/core/lib/swank/sbcl.lisp)

LIST-ALL-TIMERS names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES LIST &OPTIONAL))
  Documentation:
    Return a list of all timers in the system.
  Source file: SYS:SRC;CODE;TIMER.LISP

ATOMIC-INCF names a macro:
  Lambda-list: (PLACE &OPTIONAL (DIFF 1))
  Documentation:
    Atomically increments PLACE by DIFF, and returns the value of PLACE before
    the increment.
    
    PLACE must access one of the following:
    
    - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 64)
      or AREF of a (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*))
      The type SB-EXT:WORD can be used for these purposes.
    
    - CAR or CDR (respectively FIRST or REST) of a CONS.
    
    - a variable defined using DEFGLOBAL with a proclaimed type of FIXNUM.
      Macroexpansion is performed on PLACE before expanding ATOMIC-INCF.
    
    Incrementing is done using modular arithmetic, which is well-defined
    over two different domains:
    
     - For structures and arrays, the operation accepts and produces
       an (UNSIGNED-BYTE 64), and DIFF must be of type (SIGNED-BYTE 64).
       ATOMIC-INCF of #xFFFFFFFFFFFFFFFF by one results in #x0 being stored inPLACE.
    
     - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM.
       ATOMIC-INCF of #x3FFFFFFFFFFFFFFF by one results in #x-4000000000000000
       being stored in PLACE.
    
    DIFF defaults to 1.
    
    EXPERIMENTAL: Interface subject to change.
  Source file: SYS:SRC;CODE;MACROS.LISP

• Macroexpanded by
  • RT/TRACING::GET-CURRENT-TIME-USEC*
  • INC-COUNTER

FLOAT-NAN-P names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (FLOAT) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Return true if the float X is a NaN (Not a Number).
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;FLOAT.LISP

• Called by
  • (FLOAT-NAN-P IN /home/ellis/src/core/lib/swank/sbcl.lisp)

INVALID-FASL names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:INVALID-FASL>:
  Class precedence-list: INVALID-FASL, ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: ERROR
  Direct subclasses: SB-FASL::FASL-HEADER-MISSING,
                     SB-FASL::INVALID-FASL-FEATURES,
                     SB-FASL::INVALID-FASL-IMPLEMENTATION,
                     SB-FASL::INVALID-FASL-VERSION, SB-FASL::INVALID-FASL-HEADER
  Direct slots:
    STREAM
      Initargs: :STREAM
      Readers: SB-FASL::INVALID-FASL-STREAM
    SB-FASL::EXPECTED
      Initargs: :EXPECTED
      Readers: SB-FASL::INVALID-FASL-EXPECTED

*STACK-ALLOCATE-DYNAMIC-EXTENT* names a special variable:
  Value: T
  Documentation:
    If true (the default), the compiler believes DYNAMIC-EXTENT declarations
    and stack allocates otherwise inaccessible parts of the object whenever
    possible.

%MAKE-SIMD-PACK-256-UB64 names a compiled function:
  Lambda-list: (A B C D)
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64)
                   (UNSIGNED-BYTE 64))
                  (VALUES (SB-EXT:SIMD-PACK-256 (UNSIGNED-BYTE 64)) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

SIMD-PACK names the built-in-class #<BUILT-IN-CLASS SB-EXT:SIMD-PACK>:
  Class precedence-list: SIMD-PACK, T
  Direct superclasses: T
  No subclasses.
  Sealed.
  No direct slots.

SIMD-PACK names a primitive type-specifier:
  Lambda-list: (&OPTIONAL (ELEMENT-TYPE-SPEC (QUOTE *)))

%SIMD-PACK-SB16S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

HEAP-ALLOCATED-P names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T)
                 (VALUES (MEMBER :STATIC NIL :READ-ONLY :IMMOBILE :DYNAMIC)
                         &OPTIONAL))
  Source file: SYS:SRC;CODE;GC.LISP

• Called by
  • SB-INTROSPECT:ALLOCATION-INFORMATION
  • LISP-OBJECT-INFO

*SAVE-HOOKS* names a global variable:
  Declared type: LIST
  Declared always-bound.
  Value: (SB-GMP:UNINSTALL-GMP-FUNS SWANK/BACKEND:DEINIT-LOG-OUTPUT
                                    EXIT-THREAD-POOLS STD/THREAD::EXIT-WORKERS)
  Documentation:
    A list of function designators which are called in an unspecified
    order before creating a saved core image.
    
    Unused by SBCL itself: reserved for user and applications.

• Set by
  • SB-GMP:UNLOAD-GMP
  • SB-GMP:LOAD-GMP
• Referenced by
  • SB-GMP:UNLOAD-GMP
  • SB-GMP:LOAD-GMP

*MODULE-PROVIDER-FUNCTIONS* names a special variable:
  Value: (STD/DEFSYS::MODULE-PROVIDE-SYSTEM ASDF/OPERATE:MODULE-PROVIDE-ASDF
                                            SB-IMPL::MODULE-PROVIDE-CONTRIB)
  Documentation:
    See REQUIRE.

• Set by
  • (INIT ((EQL SYS)))
• Referenced by
  • (INIT ((EQL SYS)))

STEP-INTO names a compiled function:
  Lambda-list: (CONDITION)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Transfers control to the STEP-INTO restart associated with the
    condition, stepping into the current form. Signals a CONTROL-ERROR if
    the restart does not exist.
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

*BLOCK-COMPILE-DEFAULT* names a special variable:
  Declared type: (MEMBER :SPECIFIED T NIL)
  Value: NIL
  Documentation:
    The default value for the :Block-Compile argument to COMPILE-FILE.

GENERATION-BYTES-ALLOCATED names a compiled function:
  Lambda-list: (GENERATION)
  Derived type: (FUNCTION ((MOD 7)) (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Documentation:
    Number of bytes allocated to GENERATION currently. Available on GENCGC
    platforms only.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;GC.LISP

QUIT names a compiled function:
  Lambda-list: (&KEY RECKLESSLY-P (UNIX-STATUS 0))
  Derived type: (FUNCTION (&KEY (:RECKLESSLY-P T) (:UNIX-STATUS T)) *)
  Documentation:
    Calls (SB-EXT:EXIT :CODE UNIX-STATUS :ABORT RECKLESSLY-P),
    see documentation for SB-EXT:EXIT.
  Source file: SYS:SRC;CODE;COLD-INIT.LISP

• Called by
  • INSTALL-REPL
  • STD/CORE::HANDLE-SERIOUS-CONDITION

MAKE-TIMER names a compiled function:
  A constructor for SB-EXT:TIMER
  Lambda-list: (FUNCTION &KEY NAME (THREAD *CURRENT-THREAD*))
  Derived type: (FUNCTION
                 (T &KEY (:NAME T) (:THREAD (OR SB-THREAD:THREAD BOOLEAN)))
                 (VALUES SB-EXT:TIMER &OPTIONAL))
  Documentation:
    Create a timer that runs FUNCTION when triggered.
    
    If a THREAD is supplied, FUNCTION is run in that thread. If THREAD is
    T, a new thread is created for FUNCTION each time the timer is
    triggered. If THREAD is NIL, FUNCTION is run in an unspecified thread.
    
    When THREAD is not T, SB-THREAD:INTERRUPT-THREAD is used to run
    FUNCTION and the ordering guarantees of SB-THREAD:INTERRUPT-THREAD
    apply. In that case, FUNCTION runs with interrupts disabled but
    WITH-INTERRUPTS is allowed.
  Source file: SYS:SRC;CODE;TIMER.LISP

• Called by
  • NET/PROTO/DNS::TRY-SERVER
  • (RUN-OBJECT (SCHEDULED-TASK))
  • RUN-WITH-TIMER

PROCESS-PID names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::PROCESS)
                 (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Documentation:
    The pid of the child process.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

• Called by
  • UIOP/LAUNCH-PROGRAM:PROCESS-INFO-PID

MAP-DIRECTORY names a compiled function:
  Lambda-list: (FUNCTION DIRECTORY &KEY (FILES T) (DIRECTORIES T)
                (CLASSIFY-SYMLINKS T) (ERRORP T))
  Derived type: (FUNCTION
                 (T (OR STRING PATHNAME SYNONYM-STREAM FILE-STREAM) &KEY
                  (:FILES T) (:DIRECTORIES T) (:CLASSIFY-SYMLINKS T)
                  (:ERRORP T))
                 *)
  Documentation:
    Map over entries in DIRECTORY. Keyword arguments specify which entries to
    map over, and how:
    
     :FILES
        If true, call FUNCTION with the pathname of each file in DIRECTORY.
        Defaults to T.
    
     :DIRECTORIES
       If true, call FUNCTION with a pathname for each subdirectory ofDIRECTORY.
       If :AS-FILES, the pathname used is a pathname designating thesubdirectory
       as a file in DIRECTORY. Otherwise the pathname used is a directory
       pathname. Defaults to T.
    
     :CLASSIFY-SYMLINKS
       If true, the decision to call FUNCTION with the pathname of a symboliclink
       depends on the resolution of the link: if it points to a directory, itis
       considered a directory entry, otherwise a file entry. If false, all
       symbolic links are considered file entries. In both cases the pathnameused
       for the symbolic link is not fully resolved, but names it as animmediate
       child of DIRECTORY. Defaults to T.
    
     :ERRORP
       If true, signal an error if DIRECTORY does not exist, cannot be read,etc.
       Defaults to T.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;FILESYS.LISP

• Called by
  • TREE-SITTER:TREE-SITTER-LANGUAGE-FILES

CANCEL-FINALIZATION names a compiled function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Documentation:
    Cancel all finalizations for OBJECT, returning T if it had a finalizer.
  Source file: SYS:SRC;CODE;FINAL.LISP

• Called by
  • (SOCKET-CLOSE (SOCKET))
  • (SOCKET-MAKE-STREAM (SOCKET))

%SIMD-PACK-256-UB32S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

*EVALUATOR-MODE* names a special variable:
  Declared type: (MEMBER :INTERPRET :COMPILE)
  Declared always-bound.
  Value: :COMPILE
  Documentation:
    Toggle between different evaluator implementations. If set to :COMPILE,
    an implementation of EVAL that calls the compiler will be used. If set
    to :INTERPRET, an interpreter will be used.

TIMEOUT names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:TIMEOUT>:
  Documentation:
    Signaled when an operation does not complete within an allotted timebudget.
  Class precedence-list: TIMEOUT, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SERIOUS-CONDITION
  Direct subclasses: SB-SYS:DEADLINE-TIMEOUT, SB-SYS:IO-TIMEOUT
  Direct slots:
    SB-KERNEL::SECONDS
      Initargs: :SECONDS
      Initform: 'NIL
      Readers: SB-KERNEL::TIMEOUT-SECONDS

ENABLE-PACKAGE-LOCKS names an SBCL-specific declaration.

WITH-CURRENT-SOURCE-FORM names a macro:
  Lambda-list: ((&REST FORMS) &BODY BODY)
  Documentation:
    In a macroexpander, indicate that FORMS are being processed by BODY.
    
    FORMS are usually sub-forms of the whole form passed to the expander.
    
    If more than one form is supplied, FORMS should be ordered by
    specificity, with the most specific form first. This allows the
    compiler to try and obtain a source path using subsequent elements of
    FORMS if it fails for the first one.
    
    Indicating the processing of sub-forms lets the compiler report
    precise source locations in case conditions are signaled during the
    execution of BODY.
    
    NOTE: This interface is experimental and subject to change.
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Macroexpanded by
  • (CHECKED-COMPILE-AND-ASSERT)

*INSPECTED* names a special variable:
  Currently unbound.
  Documentation:
    the value currently being inspected in CL:INSPECT

PROCESS-PTY names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Documentation:
    The pty stream of the process or NIL.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

(SETF PROCESS-PTY) names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (T SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

SCHEDULE-TIMER names a compiled function:
  Lambda-list: (TIMER TIME &KEY REPEAT-INTERVAL ABSOLUTE-P
                (CATCH-UP NIL CATCH-UP-P))
  Derived type: (FUNCTION
                 (T T &KEY (:REPEAT-INTERVAL T) (:ABSOLUTE-P T) (:CATCH-UP T))
                 (VALUES &OPTIONAL))
  Documentation:
    Schedule TIMER to be triggered at TIME. If ABSOLUTE-P then TIME is
    universal time, but non-integral values are also allowed, else TIME is
    measured as the number of seconds from the current time.
    
    If REPEAT-INTERVAL is given, TIMER is automatically rescheduled upon
    expiry.
    
    If REPEAT-INTERVAL is non-NIL, the Boolean CATCH-UP controls whether
    TIMER will "catch up" by repeatedly calling its function without
    delay in case calls are missed because of a clock discontinuity such
    as a suspend and resume cycle of the computer. The default is NIL,
    i.e. do not catch up.
  Source file: SYS:SRC;CODE;TIMER.LISP

• Called by
  • NET/PROTO/DNS::TRY-SERVER
  • (RUN-OBJECT (SCHEDULED-TASK))
  • RUN-WITH-TIMER

*USERINIT-PATHNAME-FUNCTION* names a global variable:
  Declared always-bound.
  Value: #<FUNCTION SB-IMPL::USERINIT-PATHNAME>
  Documentation:
    Designator for a function of zero arguments called to obtain a
    pathname designator or a stream for the default userinit file, or NIL.
    If the function returns NIL, no userinit file is used unless one has
    been specified on the command-line.

• Set by
  • MAKE-TOPLEVEL-INIT
• Referenced by
  • STD/CORE::SYS-CONFIG-PATH
  • STD/CORE::USER-CONFIG-PATH

*AFTER-GC-HOOKS* names a global variable:
  Declared always-bound.
  Value: NIL
  Documentation:
    Called after each garbage collection, except for garbage collections
    triggered during thread exits. In a multithreaded environment these hooksmay
    run in any thread.

%SIMD-PACK-256-SB16S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

NATIVE-NAMESTRING names a compiled function:
  Lambda-list: (PATHNAME &KEY AS-FILE)
  Derived type: (FUNCTION
                 ((OR STRING PATHNAME SYNONYM-STREAM FILE-STREAM) &KEY
                  (:AS-FILE T))
                 *)
  Documentation:
    Construct the full native (name)string form of PATHNAME.  For
    file systems whose native conventions allow directories to be
    indicated as files, if AS-FILE is true and the name, type, and
    version components of PATHNAME are all NIL or :UNSPECIFIC,
    construct a string that names the directory according to the file
    system's syntax for files.
  Source file: SYS:SRC;CODE;TARGET-PATHNAME.LISP

• Called by
  • (MAKE-SOCKADDR-FOR (LOCAL-ABSTRACT-SOCKET))
  • SB-POSIX:FILENAME
  • UIOP/FILESYSTEM:PROBE-FILE*
  • NATIVE-NAMESTRING
  • UIOP/OS:CHDIR
  • SB-COVER:REPORT
  • NET/REQ::MAKE-SSL-STREAM
  • FILE-SIZE-IN-OCTETS
  • PATHNAME-EXECUTABLE-P
  • STD/OS::GET-FILE-KIND

%SIMD-PACK-512-DOUBLES names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT
                          DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT
                          &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

%SIMD-PACK-256-SB64S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES (SIGNED-BYTE 64) (SIGNED-BYTE 64) (SIGNED-BYTE 64)
                          (SIGNED-BYTE 64) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

*PRINT-VECTOR-LENGTH* names a special variable:
  Declared type: (OR UNSIGNED-BYTE NULL)
  Declared always-bound.
  Value: 200
  Documentation:
    Like *PRINT-LENGTH* but works on strings and bit-vectors.
    Does not affect the cases that are already controlled by *PRINT-LENGTH*

• Bound by
  • SWANK::%%CONDITION-MESSAGE
  • SWANK:EVAL-FOR-EMACS
• Referenced by
  • SWANK::%%CONDITION-MESSAGE
  • SWANK:EVAL-FOR-EMACS
  • PRINTER-STATUS

STEP-VALUES-CONDITION names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:STEP-VALUES-CONDITION>:
  Documentation:
    Condition signalled by code compiled with
    single-stepping information after executing a form.
    STEP-CONDITION-FORM holds the form, and STEP-CONDITION-RESULT holds
    the values returned by the form as a list. No associated restarts.
  Class precedence-list: STEP-VALUES-CONDITION,
                         SB-KERNEL::STEP-RESULT-CONDITION, STEP-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL::STEP-RESULT-CONDITION
  No subclasses.
  No direct slots.

PRINT-UNREADABLY names a compiled function:
  Lambda-list: (&OPTIONAL CONDITION)
  Derived type: (FUNCTION (&OPTIONAL T) *)
  Documentation:
    Transfer control to a restart named SB-EXT:PRINT-UNREADABLY, or
    return NIL if none exists.
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

TRULY-THE names a special operator:
  Lambda-list: (VALUE-TYPE FORM)
  Documentation:
    Specifies that the values returned by FORM conform to the
    VALUE-TYPE, and causes the compiler to trust this information
    unconditionally.
    
    Consequences are undefined if any result is not of the declared type
    -- typical symptoms including memory corruptions. Use with great
    care.
  Source file: SYS:SRC;COMPILER;IR1-TRANSLATORS.LISP

(SETF TRULY-THE) has a complex setf-expansion:
  Lambda-list: (TYPE PLACE)
  (undocumented)
  Source file: SYS:SRC;CODE;DEFSETFS.LISP

GENERATION-NUMBER-OF-GCS-BEFORE-PROMOTION names a compiled function:
  Lambda-list: (GENERATION)
  Derived type: (FUNCTION ((MOD 7)) (VALUES (SIGNED-BYTE 32) &OPTIONAL))
  Documentation:
    Number of times garbage collection is done on GENERATION before
    automatic promotion to the next generation is triggered. Default is 1. Canbe
    assigned to using SETF. Available on GENCGC platforms only.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;GC.LISP

(SETF GENERATION-NUMBER-OF-GCS-BEFORE-PROMOTION) names a compiled function:
  Lambda-list: (VALUE GENERATION)
  Derived type: (FUNCTION (T (MOD 7)) (VALUES (SIGNED-BYTE 32) &OPTIONAL))
  Source file: SYS:SRC;CODE;GC.LISP

MAKE-WEAK-VECTOR names a compiled function:
  Lambda-list: (LENGTH &KEY (INITIAL-CONTENTS NIL CONTENTS-P)
                       (INITIAL-ELEMENT NIL ELEMENT-P))
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 44) &KEY (:INITIAL-ELEMENT T)
                   (:INITIAL-CONTENTS T))
                  (VALUES SIMPLE-VECTOR &OPTIONAL))
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;WEAK.LISP

WEAK-VECTOR-P names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;WEAK.LISP

STEP-CONTINUE names a compiled function:
  Lambda-list: (CONDITION)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Transfers control to the STEP-CONTINUE restart associated with
    the condition, continuing execution without stepping. Signals a
    CONTROL-ERROR if the restart does not exist.
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

%MAKE-SIMD-PACK-UB32 names a compiled function:
  Lambda-list: (W X Y Z)
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                   (UNSIGNED-BYTE 32))
                  (VALUES (SB-EXT:SIMD-PACK (UNSIGNED-BYTE 32)) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

PROCESS-ERROR names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Documentation:
    The error stream of the process or NIL.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

(SETF PROCESS-ERROR) names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (T SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

• Called by
  • UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM
  • CLI/TOOLS/PACMAN::RUN-MAKEPKG
  • CLI/TOOLS/PACMAN::RUN-MKARCHROOT
  • RUN-PACMAN

ALWAYS-BOUND names an SBCL-specific declaration.

GET-CAS-EXPANSION names a compiled function:
  Lambda-list: (PLACE &OPTIONAL ENVIRONMENT)
  Derived type: (FUNCTION (T &OPTIONAL T) *)
  Documentation:
    Analogous to GET-SETF-EXPANSION. Returns the following six values:
    
    * list of temporary variables
    
    * list of value-forms whose results those variable must be bound
    
    * temporary variable for the old value of PLACE
    
    * temporary variable for the new value of PLACE
    
    * form using the aforementioned temporaries which performs the
      compare-and-swap operation on PLACE
    
    * form using the aforementioned temporaries with which to perform avolatile
      read of PLACE
    
    Example:
    
        (get-cas-expansion '(car x))
        ; => (#:CONS871), (X), #:OLD872, #:NEW873,
        ;    (SB-KERNEL:%COMPARE-AND-SWAP-CAR #:CONS871 #:OLD872 :NEW873).
        ;    (CAR #:CONS871)
    
        (defmacro my-atomic-incf (place &optional (delta 1) &environment env)
          (multiple-value-bind (vars vals old new cas-form read-form)
              (get-cas-expansion place env)
           (let ((delta-value (gensym "DELTA")))
             `(let* (,@(mapcar 'list vars vals)
                     (,old ,read-form)
                     (,delta-value ,delta)
                     (,new (+ ,old ,delta-value)))
                (loop until (eq ,old (setf ,old ,cas-form))
                      do (setf ,new (+ ,old ,delta-value)))
                ,new))))
    
    EXPERIMENTAL: Interface subject to change.
  Source file: SYS:SRC;CODE;MACROS.LISP

IMPLICIT-GENERIC-FUNCTION-NAME names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

DEFCONSTANT-UNEQL-NEW-VALUE names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

%SIMD-PACK-512-SINGLES names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                          SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                          SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                          SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                          &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

GENERATION-NUMBER-OF-GCS names a compiled function:
  Lambda-list: (GENERATION)
  Derived type: (FUNCTION ((MOD 7)) (VALUES (SIGNED-BYTE 32) &OPTIONAL))
  Documentation:
    Number of times garbage collection has been done on GENERATION without
    promotion. Available on GENCGC platforms only.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;GC.LISP

*COMPILE-PROGRESS* names a special variable:
  Value: NIL
  Documentation:
    When this is true, the compiler prints to *STANDARD-OUTPUT* progress
    information about the phases of compilation of each function. (This
    is useful mainly in large block compilations.)

UNKNOWN-KEYWORD-ARGUMENT names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:UNKNOWN-KEYWORD-ARGUMENT>:
  Class precedence-list: UNKNOWN-KEYWORD-ARGUMENT, PROGRAM-ERROR, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: PROGRAM-ERROR
  No subclasses.
  Direct slots:
    SB-KERNEL::NAME
      Initargs: :NAME
      Readers: UNKNOWN-KEYWORD-ARGUMENT-NAME

PROCESS-CORE-DUMPED names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Documentation:
    T if a core image was dumped by the process.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

(SETF PROCESS-CORE-DUMPED) names a compiled function:
  An accessor for SB-IMPL::PROCESS
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (T SB-IMPL::PROCESS) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

%SIMD-PACK-256-UB8S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

PACKAGE-IMPLEMENTED-BY-LIST names a compiled function:
  Lambda-list: (PACKAGE)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Documentation:
    Returns a list containing the implementation packages of
    PACKAGE. Signals an error if PACKAGE is not a valid package designator.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • (PUBLISH (PACKAGE-DOCUMENTATION))

CODE-DELETION-NOTE names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:CODE-DELETION-NOTE>:
  Documentation:
    A condition type signalled when the compiler deletes code that the user
    has written, having proved that it is unreachable.
  Class precedence-list: CODE-DELETION-NOTE, SB-INT:SIMPLE-COMPILER-NOTE,
                         SIMPLE-CONDITION, COMPILER-NOTE, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:SIMPLE-COMPILER-NOTE
  No subclasses.
  No direct slots.

%SIMD-PACK-SB64S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES (SIGNED-BYTE 64) (SIGNED-BYTE 64) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

EXIT names a compiled function:
  Lambda-list: (&KEY CODE ABORT (TIMEOUT *EXIT-TIMEOUT*))
  Declared type: (FUNCTION
                  (&KEY (:CODE (OR NULL (SIGNED-BYTE 32)))
                   (:TIMEOUT (OR REAL NULL)) (:ABORT T))
                  NIL)
  Derived type: (FUNCTION
                 (&KEY (:CODE (OR NULL (SIGNED-BYTE 32))) (:ABORT T)
                  (:TIMEOUT T))
                 NIL)
  Documentation:
    Terminates the process, causing SBCL to exit with CODE. CODE
    defaults to 0 when ABORT is false, and 1 when it is true.
    
    When ABORT is false (the default), current thread is first unwound,
    *EXIT-HOOKS* are run, other threads are terminated, and standard
    output streams are flushed before SBCL calls exit(3) -- at which point
    atexit(3) functions will run. If multiple threads call EXIT with ABORT
    being false, the first one to call it will complete the protocol.
    
    When ABORT is true, SBCL exits immediately by calling _exit(2)
    without unwinding stack, or calling exit hooks. Note that _exit(2)
    does not call atexit(3) functions unlike exit(3).
    
    Recursive calls to EXIT cause EXIT to behave as if ABORT was true.
    
    TIMEOUT controls waiting for other threads to terminate when ABORT is
    NIL. Once current thread has been unwound and *EXIT-HOOKS* have been
    run, spawning new threads is prevented and all other threads are
    terminated by calling SB-THREAD:TERMINATE-THREAD on them. The system
    then waits for them to finish using SB-THREAD:JOIN-THREAD, waiting at
    most a total TIMEOUT seconds for all threads to join. Those threads
    that do not finish in time are simply ignored while the exit protocol
    continues. TIMEOUT defaults to *EXIT-TIMEOUT*, which in turn defaults
    to 60. TIMEOUT NIL means to wait indefinitely.
    
    Note that TIMEOUT applies only to SB-THREAD:JOIN-THREAD, not
    *EXIT-HOOKS*. Since SB-THREAD:TERMINATE-THREAD is asynchronous,
    getting multithreaded application termination with complex cleanups
    right using it can be tricky. To perform an orderly synchronous
    shutdown use an exit hook instead of relying on implicit thread
    termination.
    
    Consequences are unspecified if serious conditions occur during EXIT
    excepting errors from *EXIT-HOOKS*, which cause warnings and stop
    execution of the hook that signaled, but otherwise allow the exit
    process to continue normally.
  Source file: SYS:SRC;CODE;COLD-INIT.LISP

EXIT names the structure-class #<STRUCTURE-CLASS SB-EXT:EXIT>:
  Class precedence-list: EXIT, SB-C::VALUED-NODE, SB-C::NODE,
                         SB-INT:SSET-ELEMENT, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-C::VALUED-NODE
  No subclasses.
  Sealed.
  Slots:
    NUMBER
      Type: (OR SB-INT:INDEX NULL)
      Initform: (WHEN (BOUNDP 'SB-C:*COMPILATION*)
                  (INCF (SB-C::SSET-COUNTER SB-C:*COMPILATION*)))
    SB-C::REOPTIMIZE
      Type: BOOLEAN
      Initform: T
    SB-C::NEXT
      Type: (OR SB-C::CTRAN NULL)
      Initform: NIL
    SB-C::PREV
      Type: (OR SB-C::CTRAN NULL)
      Initform: NIL
    SB-KERNEL:LEXENV
      Type: SB-KERNEL:LEXENV
      Initform: SB-C:*LEXENV*
    SB-C::SOURCE-PATH
      Type: LIST
      Initform: SB-C::*CURRENT-PATH*
    SB-C::TAIL-P
      Type: BOOLEAN
      Initform: NIL
    SB-C::DERIVED-TYPE
      Type: SB-KERNEL:CTYPE
      Initform: SB-KERNEL:*WILD-TYPE*
    SB-C::LVAR
      Type: (OR SB-C::LVAR NULL)
      Initform: NIL
    SB-C::ENTRY
      Type: (OR SB-C::ENTRY NULL)
      Initform: NIL
    SB-C::VALUE
      Type: (OR SB-C::LVAR NULL)
      Initform: NIL
    SB-C::NLX-INFO
      Type: (OR SB-C::NLX-INFO NULL)
      Initform: NIL

• Called by
  • SB-ACLREPL::PROCESS-CMD
  • SB-ACLREPL::EXIT-CMD
  • QUIT
  • SKEL/CLI::START-SKEL
  • SKEL/MPK/CLI::START-MPK
  • SKEL/HOMER/CLI::START-HOMER
  • SKEL/PACKY/CLI::START-PACKY
  • (QUIT-LISP IN /home/ellis/src/core/lib/swank/sbcl.lisp)

%MAKE-SIMD-PACK-SINGLE names a compiled function:
  Lambda-list: (X Y Z W)
  Declared type: (FUNCTION
                  (SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT)
                  (VALUES (SB-EXT:SIMD-PACK SINGLE-FLOAT) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

• Called by
  • SB-SIMD-SSE::%F32.4-VALUES

DEFCONSTANT-UNEQL-NAME names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

UNLOCK-PACKAGE names a compiled function:
  Lambda-list: (PACKAGE)
  Derived type: (FUNCTION (T) (VALUES (MEMBER T) &OPTIONAL))
  Documentation:
    Unlocks PACKAGE and returns T. Has no effect if PACKAGE was already
    unlocked. Signals an error if PACKAGE is not a valid package designator.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • RT/TRACING::UNINSTALL-TRACING-OVERRIDES
  • RT/TRACING::INSTALL-TRACING-OVERRIDES

%SIMD-PACK-512-SB16S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) (SIGNED-BYTE 16)
                          (SIGNED-BYTE 16) (SIGNED-BYTE 16) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

UNMUFFLE-CONDITIONS names an SBCL-specific declaration.

SHORT-FLOAT-POSITIVE-INFINITY names a constant variable:
  Value: #.SINGLE-FLOAT-POSITIVE-INFINITY

DEPRECATED names an SBCL-specific declaration.

*FORCIBLY-TERMINATE-THREADS-ON-EXIT* names a global variable:
  Declared always-bound.
  Value: T

SPIN-LOOP-HINT names a compiled function:
  Lambda-list: ()
  Declared type: (FUNCTION NIL (VALUES &OPTIONAL))
  Documentation:
    Hints the processor that the current thread is spin-looping.
  Known attributes: always-translatable
  Source file: SYS:SRC;CODE;STUBS.LISP

DISABLE-DEBUGGER names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES &OPTIONAL))
  Documentation:
    When invoked, this function will turn off both the SBCL debugger
    and LDB (the low-level debugger).  See also ENABLE-DEBUGGER.
  Source file: SYS:SRC;CODE;DEBUG.LISP

• Called by
  • SKEL/CLI::START-SKEL
  • SKEL/MPK/CLI::START-MPK
  • SKEL/HOMER/CLI::START-HOMER
  • SKEL/PACKY/CLI::START-PACKY
  • (BACKGROUND-SAVE-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (SAVE-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)

TIMER-NAME names a compiled function:
  Lambda-list: (TIMER)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Documentation:
    Return the name of TIMER.
  Source file: SYS:SRC;CODE;TIMER.LISP

MUFFLE-CONDITIONS names an SBCL-specific declaration.

DEPRECATION-CONDITION-SOFTWARE names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

*DISASSEMBLE-ANNOTATE* names a special variable:
  Value: NIL
  Documentation:
    Annotate DISASSEMBLE output with source code.

NAME-CONFLICT-SYMBOLS names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

%SIMD-PACK-512-UB32S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                          (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

DEFCONSTANT-UNEQL-OLD-VALUE names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

WORD names a type-specifier:
  Lambda-list: ()
  Expansion: (UNSIGNED-BYTE 64)

WORD names an alien type:
  Expansion: #<ALIEN-TYPE (UNSIGNED 64)>

REMOVE-PACKAGE-LOCAL-NICKNAME names a compiled function:
  Lambda-list: (OLD-NICKNAME &OPTIONAL (PACKAGE-DESIGNATOR (SANE-PACKAGE)))
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    If the designated package had OLD-NICKNAME as a local nickname for
    another package, it is removed. Returns true if the nickname existed andwas
    removed, and NIL otherwise.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

READTABLE-BASE-CHAR-PREFERENCE names a compiled function:
  Lambda-list: (READTABLE)
  Derived type: (FUNCTION (T)
                 (VALUES (MEMBER :SYMBOLS :BOTH :STRINGS NIL) &OPTIONAL))
  Documentation:
    Returns :SYMBOLS, :STRINGS, :BOTH, or NIL, depending on whether the
    reader should try to intern a base-string when reading a symbol name,
    respectively produce a base-string when reading a quoted string, or in both
    cases, or neither. The preference applies when a symbol-name or string
    contains only BASE-CHAR characters. An (ARRAY CHARACTER (*)) can always
    be interned (returned, respectively) as required. The default is :SYMBOLS.
  Source file: SYS:SRC;CODE;READER.LISP

(SETF READTABLE-BASE-CHAR-PREFERENCE) names a compiled function:
  Lambda-list: (NEW-VALUE READTABLE)
  Derived type: (FUNCTION ((MEMBER :SYMBOLS :BOTH :STRINGS NIL) T)
                 (VALUES (MEMBER :SYMBOLS :BOTH :STRINGS NIL) &OPTIONAL))
  Documentation:
    Sets the READTABLE-BASE-CHAR-PREFERENCE of the given READTABLE.
  Source file: SYS:SRC;CODE;READER.LISP

PACKAGE-LOCKED-P names a compiled function:
  Lambda-list: (PACKAGE)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Returns T when PACKAGE is locked, NIL otherwise. Signals an error
    if PACKAGE doesn't designate a valid package.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • (PUBLISH (PACKAGE-DOCUMENTATION))

LOCK-PACKAGE names a compiled function:
  Lambda-list: (PACKAGE)
  Derived type: (FUNCTION (T) (VALUES (MEMBER T) &OPTIONAL))
  Documentation:
    Locks PACKAGE and returns T. Has no effect if PACKAGE was already
    locked. Signals an error if PACKAGE is not a valid package designator.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • RT/TRACING::UNINSTALL-TRACING-OVERRIDES
  • RT/TRACING::INSTALL-TRACING-OVERRIDES
  • ENSURE-PACKAGE

SIMD-PACK-256 names the built-in-class #<BUILT-IN-CLASS SB-EXT:SIMD-PACK-256>:
  Class precedence-list: SIMD-PACK-256, T
  Direct superclasses: T
  No subclasses.
  Sealed.
  No direct slots.

SIMD-PACK-256 names a primitive type-specifier:
  Lambda-list: (&OPTIONAL (ELEMENT-TYPE-SPEC (QUOTE *)))

%MAKE-SIMD-PACK-DOUBLE names a compiled function:
  Lambda-list: (LOW HIGH)
  Declared type: (FUNCTION (DOUBLE-FLOAT DOUBLE-FLOAT)
                  (VALUES (SB-EXT:SIMD-PACK DOUBLE-FLOAT) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

*PRINT-CIRCLE-NOT-SHARED* names a special variable:
  Declared always-bound.
  Value: NIL
  Documentation:
    If this variable and *PRINT-CIRCLE* are both T only circular
    structures are printed with #n#.

• Bound by
  • SWANK::%%CONDITION-MESSAGE
  • SWANK:EVAL-FOR-EMACS
  • FORMAT-SLOTS
  • PRINT-SLOTS

COMPILE-FILE-LINE names a macro:
  Lambda-list: ()
  Documentation:
    Return line# and column# of this macro invocation as multiple values.
  Source file: SYS:SRC;COMPILER;TARGET-MAIN.LISP

%MAKE-SIMD-PACK-512-UB64 names a compiled function:
  Lambda-list: (A B C D E F G H)
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64)
                   (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64)
                   (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64))
                  (VALUES (SB-EXT:SIMD-PACK-512 (UNSIGNED-BYTE 64)) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

STEP-NEXT names a compiled function:
  Lambda-list: (CONDITION)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Transfers control to the STEP-NEXT restart associated with the
    condition, executing the current form without stepping and continuing
    stepping with the next form. Signals CONTROL-ERROR if the restart does
    not exist.
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

DEFCONSTANT-UNEQL names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:DEFCONSTANT-UNEQL>:
  Class precedence-list: DEFCONSTANT-UNEQL, SB-INT:REFERENCE-CONDITION, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION, ERROR
  No subclasses.
  Direct slots:
    SB-KERNEL::NAME
      Initargs: :NAME
      Readers: DEFCONSTANT-UNEQL-NAME
    SB-KERNEL::OLD-VALUE
      Initargs: :OLD-VALUE
      Readers: DEFCONSTANT-UNEQL-OLD-VALUE
    SB-KERNEL::NEW-VALUE
      Initargs: :NEW-VALUE
      Readers: DEFCONSTANT-UNEQL-NEW-VALUE

DEPRECATION-CONDITION-NAME names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

SAVE-LISP-AND-DIE names a compiled function:
  Lambda-list: (CORE-FILE-NAME &KEY
                (TOPLEVEL (FUNCTION TOPLEVEL-INIT) TOPLEVEL-SUPPLIED)
                (EXECUTABLE NIL) (SAVE-RUNTIME-OPTIONS NIL)
                (CALLABLE-EXPORTS NIL) (PURIFY T) (ROOT-STRUCTURES NIL)
                (ENVIRONMENT-NAME auxiliary) (COMPRESSION NIL))
  Derived type: (FUNCTION
                 (T &KEY (:TOPLEVEL T) (:EXECUTABLE T)
                  (:SAVE-RUNTIME-OPTIONS T) (:CALLABLE-EXPORTS T) (:PURIFY T)
                  (:ROOT-STRUCTURES T) (:ENVIRONMENT-NAME T) (:COMPRESSION T))
                 (VALUES NULL &OPTIONAL))
  Documentation:
    Save a "core image", i.e. enough information to restart a Lisp
    process later in the same state, in the file of the specified name.
    Only global state is preserved: the stack is unwound in the process.
    
    The following &KEY arguments are defined:
    
    - :TOPLEVEL
    
        The function to run when the created core file is resumed. The
        default function handles command line toplevel option
        processing (see SB-MANUAL:@TOPLEVEL-OPTIONS) and runs the top
        level read-eval-print loop. This function returning is equivalent
        to (SB-EXT:EXIT :CODE 0) being called.
    
        TOPLEVEL functions should always provide an ABORT restart:
        otherwise code they call will run without one.
    
    - :EXECUTABLE
    
        If true, arrange to combine the SBCL runtime and the core image to
        create a standalone executable. If false (the default), the core
        image will not be executable on its own. Executable images always
        behave as if they were passed the --noinform runtime option.
         If :EXECUTABLE is :ELF-OBJECT, then the resulting core will be
         wrapped in a .o which requires further linking. (EXPERIMENTAL)
    
    - :SAVE-RUNTIME-OPTIONS
    
        If true, values of runtime options --dynamic-space-size and
        --control-stack-size that were used to start SBCL are stored in
        the standalone executable, and restored when the executable is
        run. This also inhibits normal runtime option processing, causing
        all command line arguments to be passed to the toplevel. If
        :ACCEPT-RUNTIME-OPTIONS then --dynamic-space-size and
        --control-stack-size are still processed by the runtime.
        Meaningless if :EXECUTABLE is NIL.
    
    - :CALLABLE-EXPORTS
    
        This should be a list of symbols to be initialized to the
        appropriate alien callables on startup. All exported symbols
        should be present as global symbols in the symbol table of the
        runtime before the saved core is loaded. When this list is
        non-empty, the :TOPLEVEL argument cannot be supplied.
    
    - :PURIFY
    
        If true (the default), then some objects in the restarted core
        will be memory-mapped as read-only. Among those objects are
        numeric vectors that were determined to be compile-time constants,
        and any immutable values according to the language specification
        such as symbol names.
    
    - :ROOT-STRUCTURES
    
        This should be a list of the main entry points in any newly loaded
        systems. This need not be supplied, but locality and/or GC
        performance may be better if they are. This has two different but
        related meanings: If :PURIFY is true - and only for cheneygc - the
        root structures are those which anchor the set of objects moved
        into static space. On gencgc - and only on platforms supporting
        immobile code - these are the functions and/or function-names
        which commence a depth-first scan of code when reordering based on
        the statically observable call chain. The complete set of
        reachable objects is not affected per se. This argument is
        meaningless if neither enabling precondition holds.
    
    - :ENVIRONMENT-NAME
    
        This has no purpose; it is accepted only for legacy compatibility.
    
    - :COMPRESSION
    
        This is only meaningful if the runtime was built with the
        :SB-CORE-COMPRESSION feature enabled. If NIL (the default),
        saves to uncompressed core files. If :SB-CORE-COMPRESSION was
        enabled at build-time, the argument may also be an integer from -7
        to 22, corresponding to zstd compression levels, or T (which is
        equivalent to the default compression level, 9).
    
    - :APPLICATION-TYPE
    
        Present only on Windows and is meaningful only with :EXECUTABLE T.
        Specifies the subsystem of the executable, :CONSOLE or :GUI.
        The notable difference is that :GUI doesn't automatically create
        a console window. The default is :CONSOLE.
    
    The save/load process changes the values of some global variables:
    
    - *STANDARD-OUTPUT*, *DEBUG-IO*, etc
    
        Everything related to open streams is necessarily changed, since
        the OS won't let us preserve a stream across save and load.
    
    - *DEFAULT-PATHNAME-DEFAULTS*
    
        This is reinitialized to reflect the working directory where the
        saved core is loaded.
    
    SAVE-LISP-AND-DIE interacts with SB-ALIEN:LOAD-SHARED-OBJECT: see its
    documentation for details.
    
    On threaded platforms only a single thread may remain running after
    SB-EXT:*SAVE-HOOKS* have run. Applications using multiple threads can
    be SAVE-LISP-AND-DIE friendly by registering a save-hook that quits
    any additional threads, and an init-hook that restarts them.
    
    This implementation is not as polished and painless as you might like:
    
    - It corrupts the current Lisp image enough that the current process
      needs to be killed afterwards. This can be worked around by forking
      another process that saves the core.
    
    - There is absolutely no binary compatibility of core images between
      different runtime support programs. Even runtimes built from the
      same sources at different times are treated as incompatible for this
      purpose.
    
    This isn't because we like it this way, but just because there don't
    seem to be good quick fixes for either limitation and no one has been
    sufficiently motivated to do lengthy fixes.
  Source file: SYS:SRC;CODE;SAVE.LISP

• Called by
  • UIOP/IMAGE:DUMP-IMAGE
  • (BACKGROUND-SAVE-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (SAVE-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SAVE-LISP
  • SAVE-LISP-TREE-SHAKE-AND-DIE

REMOVE-IMPLEMENTATION-PACKAGE names a compiled function:
  Lambda-list: (PACKAGES-TO-REMOVE &OPTIONAL (PACKAGE *PACKAGE*))
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES LIST &OPTIONAL))
  Documentation:
    Removes PACKAGES-TO-REMOVE from the implementation packages of
    PACKAGE. Signals an error if PACKAGE or any of the PACKAGES-TO-REMOVE
    is not a valid package designator.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

*INVOKE-DEBUGGER-HOOK* names a special variable:
  Value: NIL
  Documentation:
    This is either NIL or a designator for a function of two arguments,
    to be run when the debugger is about to be entered. The function is
    run with *INVOKE-DEBUGGER-HOOK* bound to NIL to minimize
    recursive errors, and receives as arguments the condition that
    triggered debugger entry and the previous value of
    *INVOKE-DEBUGGER-HOOK*.
    
    This mechanism is an SBCL extension similar to the standard *DEBUGGER-HOOK*.
    In contrast to *DEBUGGER-HOOK*, it is observed by INVOKE-DEBUGGER even when
    called by BREAK.

• Set by
  • SWANK/SBCL::SET-BREAK-HOOK
• Bound by
  • SWANK/SBCL::CALL-WITH-BREAK-HOOK

PRIMITIVE-OBJECT-SIZE names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Documentation:
    Return number of bytes of heap or stack directly consumed by OBJECT
  Source file: SYS:SRC;CODE;GC.LISP

• Called by
  • SB-INTROSPECT::LARGEST-OBJECTS
  • SB-INTROSPECT::OBJECT-SIZE
  • DEEP-SIZE

DEFGLOBAL names a macro:
  Lambda-list: (NAME VALUE &OPTIONAL (DOC NIL))
  Documentation:
    Defines NAME as a global variable that is always bound. VALUE is evaluated
    and assigned to NAME both at compile- and load-time, but only if NAME isnot
    already bound.
    
    Global variables share their values between all threads, and cannot be
    locally bound, declared special, defined as constants, and neither bound
    nor defined as symbol macros.
    
    See also the declarations SB-EXT:GLOBAL and SB-EXT:ALWAYS-BOUND.
  Source file: SYS:SRC;CODE;MACROS.LISP

ADD-PACKAGE-LOCAL-NICKNAME names a compiled function:
  Lambda-list: (LOCAL-NICKNAME ACTUAL-PACKAGE &OPTIONAL
                (PACKAGE-DESIGNATOR (SANE-PACKAGE)))
  Derived type: (FUNCTION (T T &OPTIONAL T) (VALUES PACKAGE &OPTIONAL))
  Documentation:
    Adds LOCAL-NICKNAME for ACTUAL-PACKAGE in the designated package,defaulting
    to current package. LOCAL-NICKNAME must be a string designator, and
    ACTUAL-PACKAGE must be a package designator.
    
    Returns the designated package.
    
    Signals a continuable error if LOCAL-NICKNAME is already a package
    local nickname for a different package, or if LOCAL-NICKNAME is one of
    "CL", "COMMON-LISP", "KEYWORD", or if LOCAL-NICKNAME is a
    global name or nickname for the package to which the nickname would be
    added.
    
    When in the designated package, calls to FIND-PACKAGE with the LOCAL-NICKNAME
    will return the package the designated ACTUAL-PACKAGE instead. This also
    affects all implied calls to FIND-PACKAGE, including those performed by the
    reader.
    
    When printing a package prefix for a symbol with a package local nickname,
    local nickname is used instead of the real name in order to preserve
    print-read consistency.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • ENSURE-PACKAGE

EVAL-TLF names a compiled function:
  Lambda-list: (ORIGINAL-EXP TLF-INDEX &OPTIONAL LEXENV)
  Derived type: (FUNCTION (T T &OPTIONAL T) *)
  Source file: SYS:SRC;CODE;EVAL.LISP

%MAKE-SIMD-PACK-512-DOUBLE names a compiled function:
  Lambda-list: (A B C D E F G H)
  Declared type: (FUNCTION
                  (DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT
                   DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT)
                  (VALUES (SB-EXT:SIMD-PACK-512 DOUBLE-FLOAT) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

%MAKE-SIMD-PACK-512-SINGLE names a compiled function:
  Lambda-list: (A B C D E F G H I J K L M N P Q)
  Declared type: (FUNCTION
                  (SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                   SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                   SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                   SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT)
                  (VALUES (SB-EXT:SIMD-PACK-512 SINGLE-FLOAT) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

LATE-DEPRECATION-WARNING names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:LATE-DEPRECATION-WARNING>:
  Documentation:
    This warning is signaled when the use of a variable,
    function, type, etc. in :LATE deprecation is detected at
    compile-time. The use will work at run-time with no warning or
    error.
  Class precedence-list: LATE-DEPRECATION-WARNING, WARNING,
                         DEPRECATION-CONDITION, SB-INT:REFERENCE-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: WARNING, DEPRECATION-CONDITION
  No subclasses.
  No direct slots.

TYPEXPAND-ALL names a compiled function:
  Lambda-list: (TYPE-SPECIFIER &OPTIONAL ENV)
  Derived type: (FUNCTION (T &OPTIONAL (OR SB-C::ABSTRACT-LEXENV NULL)) *)
  Documentation:
    Takes and expands a type specifier recursively like
    SB-CLTL2:MACROEXPAND-ALL.
  Source file: SYS:SRC;CODE;TYPEP.LISP

DECIMAL-WITH-GROUPED-DIGITS-WIDTH names a compiled function:
  Lambda-list: (VALUE &KEY (COMMA-INTERVAL 3))
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 44) &KEY
                   (:COMMA-INTERVAL (INTEGER 1 17592186044415)))
                  (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Source file: SYS:SRC;CODE;ROOM.LISP

TYPEXPAND names a compiled function:
  Lambda-list: (TYPE-SPECIFIER &OPTIONAL ENV)
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES T BOOLEAN &OPTIONAL))
  Documentation:
    Takes and expands a type specifier repeatedly like MACROEXPAND.
    Returns two values: the expansion, and a boolean that is true when
    expansion happened.
  Source file: SYS:SRC;CODE;TYPE.LISP

NAME-CONFLICT-DATUM names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

PACKAGE-LOCK-VIOLATION names a compiled function:
  Lambda-list: (PACKAGE &KEY (SYMBOL NIL SYMBOL-P) FORMAT-CONTROL
                FORMAT-ARGUMENTS)
  Derived type: (FUNCTION
                 (T &KEY (:SYMBOL T) (:FORMAT-CONTROL T) (:FORMAT-ARGUMENTS T))
                 (VALUES (OR CONS (MEMBER T)) &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

PACKAGE-LOCK-VIOLATION names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:PACKAGE-LOCK-VIOLATION>:
  Documentation:
    Subtype of CL:PACKAGE-ERROR. A subtype of this error is signalled
    when a package-lock is violated.
  Class precedence-list: PACKAGE-LOCK-VIOLATION, PACKAGE-ERROR, ERROR,
                         SERIOUS-CONDITION, SB-INT:REFERENCE-CONDITION,
                         SIMPLE-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: PACKAGE-ERROR, SB-INT:REFERENCE-CONDITION,
                       SIMPLE-CONDITION
  Direct subclasses: SYMBOL-PACKAGE-LOCKED-ERROR, PACKAGE-LOCKED-ERROR
  Direct slots:
    SB-KERNEL::CURRENT-PACKAGE
      Initform: '*PACKAGE*
      Readers: SB-KERNEL::PACKAGE-LOCK-VIOLATION-IN-PACKAGE

MAYBE-INLINE names an SBCL-specific declaration.

READER-PACKAGE-DOES-NOT-EXIST names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:READER-PACKAGE-DOES-NOT-EXIST>:
  Class precedence-list: READER-PACKAGE-DOES-NOT-EXIST,
                         SB-INT:SIMPLE-READER-PACKAGE-ERROR,
                         SB-INT:SIMPLE-READER-ERROR, READER-ERROR, PARSE-ERROR,
                         STREAM-ERROR, PACKAGE-DOES-NOT-EXIST,
                         SB-KERNEL:SIMPLE-PACKAGE-ERROR, SIMPLE-CONDITION,
                         PACKAGE-ERROR, ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:SIMPLE-READER-PACKAGE-ERROR,
                       PACKAGE-DOES-NOT-EXIST
  No subclasses.
  No direct slots.

UNKNOWN-KEYWORD-ARGUMENT-NAME names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

GENERATION-MINIMUM-AGE-BEFORE-GC names a compiled function:
  Lambda-list: (GENERATION)
  Derived type: (FUNCTION ((MOD 7)) (VALUES DOUBLE-FLOAT &OPTIONAL))
  Documentation:
    Minimum average age of objects allocated to GENERATION before that
    generation is may be garbage collected. Default is 0.75. See also
    GENERATION-AVERAGE-AGE. Can be assigned to using SETF. Available on GENCGC
    platforms only.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;GC.LISP

(SETF GENERATION-MINIMUM-AGE-BEFORE-GC) names a compiled function:
  Lambda-list: (VALUE GENERATION)
  Derived type: (FUNCTION (T (MOD 7)) (VALUES DOUBLE-FLOAT &OPTIONAL))
  Source file: SYS:SRC;CODE;GC.LISP

*GC-REAL-TIME* names a special variable:
  Declared type: (UNSIGNED-BYTE 44)
  Value: 15683993
  Documentation:
    Total real time spent doing garbage collection (as reported by
    GET-INTERNAL-REAL-TIME.) Initialized to zero on startup.

*INIT-HOOKS* names a global variable:
  Declared type: LIST
  Declared always-bound.
  Value: (SB-MPFR::LOAD-MPFR SB-GMP:LOAD-GMP
                             SB-SIMD-INTERNALS::UPDATE-IDISPATCH-INDICES)
  Documentation:
    A list of function designators which are called in an unspecified
    order when a saved core image starts up, after the system itself has
    been initialized, but before non-user threads such as the finalizer
    thread have been started.
    
    Unused by SBCL itself: reserved for user and applications.

• Set by
  • SB-MPFR::LOAD-MPFR
  • SB-GMP:UNLOAD-GMP
  • SB-GMP:LOAD-GMP
• Referenced by
  • SB-MPFR::LOAD-MPFR
  • SB-GMP:UNLOAD-GMP
  • SB-GMP:LOAD-GMP

%SIMD-PACK-256-SB8S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

*DEFAULT-C-STRING-EXTERNAL-FORMAT* names a special variable:
  Value: :UTF-8

• Referenced by
  • SB-POSIX:MKDTEMP
  • SB-POSIX:MKSTEMP
  • SB-POSIX:MKTEMP

*RUNTIME-PATHNAME* names a global variable:
  Declared always-bound.
  Value: #P"/usr/bin/core"
  Documentation:
    The absolute pathname of the running SBCL runtime.

• Referenced by
  • SWANK/SBCL::RUNTIME-PATHNAME

WEAK-POINTER-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • SB-INTROSPECT:MAP-ROOT
  • DEEP-SIZE

PROCESS-STATUS names a compiled function:
  Lambda-list: (PROCESS)
  Derived type: (FUNCTION (T)
                 (VALUES (MEMBER :RUNNING :STOPPED :EXITED :SIGNALED)
                         &OPTIONAL))
  Documentation:
    Return the current status of PROCESS.  The result is one of :RUNNING,
    :STOPPED, :EXITED, :SIGNALED.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

PROCESS-STATUS names a type-specifier:
  Lambda-list: ()
  Expansion: (MEMBER :RUNNING :STOPPED :EXITED :SIGNALED)

• Called by
  • UIOP/LAUNCH-PROGRAM:WAIT-PROCESS
  • UIOP/LAUNCH-PROGRAM::%PROCESS-STATUS

CAS names a macro:
  Lambda-list: (PLACE OLD NEW)
  Documentation:
    Synonym for COMPARE-AND-SWAP.
    
    Additionally DEFUN, DEFGENERIC, DEFMETHOD, FLET, and LABELS can be alsoused to
    define CAS-functions analogously to SETF-functions:
    
        (defvar *foo* nil)
    
        (defun (cas foo) (old new)
          (cas (symbol-value '*foo*) old new))
    
    First argument of a CAS function is the expected old value, and the second
    argument of is the new value. Note that the system provides no automatic
    atomicity for CAS functions, nor can it verify that they are atomic: it isup
    to the implementor of a CAS function to ensure its atomicity.
    
    EXPERIMENTAL: Interface subject to change.
  Source file: SYS:SRC;CODE;MACROS.LISP

• Macroexpanded by
  • SB-CONCURRENCY:DEQUEUE
  • SB-CONCURRENCY:ENQUEUE
  • SB-SPROF::CALL-WITH-EACH-PROFILE-BUFFER
  • POP-SPIN-QUEUE
  • PUSH-SPIN-QUEUE

*SYSINIT-PATHNAME-FUNCTION* names a global variable:
  Declared always-bound.
  Value: #<FUNCTION SB-IMPL::SYSINIT-PATHNAME>
  Documentation:
    Designator for a function of zero arguments called to obtain a
    pathname designator for the default sysinit file, or NIL. If the
    function returns NIL, no sysinit file is used unless one has been
    specified on the command-line.

• Set by
  • MAKE-TOPLEVEL-INIT

PACKAGE-LOCALLY-NICKNAMED-BY-LIST names a compiled function:
  Lambda-list: (PACKAGE-DESIGNATOR)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Documentation:
    Returns a list of packages which have a local nickname for the designated
    package.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • (PUBLISH (PACKAGE-DOCUMENTATION))

SIMD-PACK-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • SB-SIMD-NEON:S64.2!
  • SB-SIMD-NEON:S32.4!
  • SB-SIMD-NEON:S16.8!
  • SB-SIMD-NEON:S8.16!
  • SB-SIMD-NEON:U64.2!
  • SB-SIMD-NEON:U32.4!
  • SB-SIMD-NEON:U16.8!
  • SB-SIMD-NEON:U8.16!
  • SB-SIMD-NEON:F64.2!
  • SB-SIMD-NEON:F32.4!
  • SB-SIMD-NEON::S64!
  • SB-SIMD-NEON::S32!
  • SB-SIMD-NEON::S16!
  • SB-SIMD-NEON::S8!
  • SB-SIMD-NEON:U64!
  • SB-SIMD-NEON:U32!
  • SB-SIMD-NEON:U16!
  • SB-SIMD-NEON:U8!
  • SB-SIMD-NEON:F64!
  • SB-SIMD-NEON:F32!
  • SB-SIMD-AVX2:S64.2!
  • SB-SIMD-AVX2:S32.4!
  • SB-SIMD-AVX2:S16.8!
  • SB-SIMD-AVX2:S8.16!
  • SB-SIMD-AVX2:U64.2!
  • SB-SIMD-AVX2:U32.4!
  • SB-SIMD-AVX2:U16.8!
  • SB-SIMD-AVX2:U8.16!
  • SB-SIMD-AVX:S64.4!
  • SB-SIMD-AVX:S32.8!
  • SB-SIMD-AVX:S16.16!
  • SB-SIMD-AVX:S8.32!
  • SB-SIMD-AVX:S64.2!
  • SB-SIMD-AVX:S32.4!
  • SB-SIMD-AVX:S16.8!
  • SB-SIMD-AVX:S8.16!
  • SB-SIMD-AVX:U64.4!
  • SB-SIMD-AVX:U32.8!
  • SB-SIMD-AVX:U16.16!
  • SB-SIMD-AVX:U8.32!
  • SB-SIMD-AVX:U64.2!
  • SB-SIMD-AVX:U32.4!
  • SB-SIMD-AVX:U16.8!
  • SB-SIMD-AVX:U8.16!
  • SB-SIMD-AVX:F64.4!
  • SB-SIMD-AVX:F32.8!
  • SB-SIMD-AVX:F64.2!
  • SB-SIMD-AVX:U64!
  • SB-SIMD-AVX:U32!
  • SB-SIMD-AVX:U16!
  • SB-SIMD-AVX:U8!
  • SB-SIMD-AVX:F64!
  • SB-SIMD-AVX:F32!
  • SB-SIMD-SSE2:S64.2!
  • SB-SIMD-SSE2:S32.4!
  • SB-SIMD-SSE2:S16.8!
  • SB-SIMD-SSE2:S8.16!
  • SB-SIMD-SSE2:U64.2!
  • SB-SIMD-SSE2:U32.4!
  • SB-SIMD-SSE2:U16.8!
  • SB-SIMD-SSE2:U8.16!
  • SB-SIMD-SSE2:F64.2!
  • SB-SIMD-SSE2:U64!
  • SB-SIMD-SSE2:U32!
  • SB-SIMD-SSE2:U16!
  • SB-SIMD-SSE2:U8!
  • SB-SIMD-SSE2:F64!
  • SB-SIMD-SSE:F32!

*GC-RUN-TIME* names a special variable:
  Declared type: (UNSIGNED-BYTE 44)
  Value: 15635310
  Documentation:
    Total CPU time spent doing garbage collection (as reported by
    GET-INTERNAL-RUN-TIME.) Initialized to zero on startup. It is safe to bind
    this to zero in order to measure GC time inside a certain section of code,but
    doing so may interfere with results reported by eg. TIME.

• Set by
  • UIOP/IMAGE:DUMP-IMAGE
• Referenced by
  • STD/COMP::RUNTIME*

PACKAGE-DOES-NOT-EXIST names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:PACKAGE-DOES-NOT-EXIST>:
  Class precedence-list: PACKAGE-DOES-NOT-EXIST, SB-KERNEL:SIMPLE-PACKAGE-ERROR,
                         SIMPLE-CONDITION, PACKAGE-ERROR, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL:SIMPLE-PACKAGE-ERROR
  Direct subclasses: READER-PACKAGE-DOES-NOT-EXIST
  No direct slots.

ATOMIC-POP names a macro:
  Lambda-list: (PLACE)
  Documentation:
    Like POP, but atomic. PLACE may be read multiple times before
    the operation completes -- the write does not occur until such time
    that no other thread modified PLACE between the read and the write.
    
    Works on all CASable places.
  Source file: SYS:SRC;CODE;MACROS.LISP

• Macroexpanded by
  • SB-SPROF::CALL-WITH-EACH-PROFILE-BUFFER

%SIMD-PACK-256-UB16S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

RUN-PROGRAM names a compiled function:
  Lambda-list: (PROGRAM ARGS &KEY (ENV NIL ENV-P)
                (ENVIRONMENT
                 (WHEN ENV-P (UNIX-ENVIRONMENT-SBCL-FROM-CMUCL ENV))
                 ENVIRONMENT-P)
                (WAIT T) SEARCH PTY INPUT IF-INPUT-DOES-NOT-EXIST OUTPUT
                (IF-OUTPUT-EXISTS ERROR) (ERROR OUTPUT) (IF-ERROR-EXISTS ERROR)
                STATUS-HOOK (EXTERNAL-FORMAT DEFAULT) DIRECTORY PRESERVE-FDS
                USE-POSIX-SPAWN)
  Derived type: (FUNCTION
                 (T T &KEY (:ENV T) (:ENVIRONMENT T) (:WAIT T) (:SEARCH T)
                  (:PTY T) (:INPUT T) (:IF-INPUT-DOES-NOT-EXIST T) (:OUTPUT T)
                  (:IF-OUTPUT-EXISTS T) (:ERROR T) (:IF-ERROR-EXISTS T)
                  (:STATUS-HOOK T) (:EXTERNAL-FORMAT T) (:DIRECTORY T)
                  (:PRESERVE-FDS T) (:USE-POSIX-SPAWN T))
                 (VALUES (OR NULL SB-IMPL::PROCESS) &OPTIONAL))
  Documentation:
    RUN-PROGRAM creates a new process specified by PROGRAM.
    ARGS is a list of strings to be passed literally to the new program.
    In POSIX environments, this list becomes the array supplied as the second
    parameter to the execv() or execvp() system call, each list elementbecoming
    one array element. The strings should not contain shell escaping, as thereis
    no shell involvement. Further note that while conventionally the process
    receives its own pathname in argv[0], that is automatic, and the 0th string
    should not be present in ARGS.
    
    The program arguments and the environment are encoded using the
    default external format for streams.
    
    RUN-PROGRAM will return a PROCESS structure. See the CMU Common Lisp
    Users Manual for details about the PROCESS structure.
    
    Notes about Unix environments (as in the :ENVIRONMENT and :ENV args):
    
    - The SBCL implementation of RUN-PROGRAM, like Perl and many other
      programs, but unlike the original CMU CL implementation, copies the
      Unix environment by default.
    
    - Running Unix programs from a setuid process, or in any other
      situation where the Unix environment is under the control of someone
      else, is a mother lode of security problems. If you are
      contemplating doing this, read about it first. (The Perl community
      has a lot of good documentation about this and other security issues
      in script-like programs.)
    
    The &KEY arguments have the following meanings:
    
    - :ENVIRONMENT
    
        A list of STRINGs describing the new Unix environment
        (as in "man environ"). The default is to copy the environment of
        the current process.
    
    - :ENV
    
        An alternative lossy representation of the new Unix environment,
        for compatibility with CMU CL.
    
    - :SEARCH
    
        Look for PROGRAM in each of the directories in the child's $PATH
        environment variable. Otherwise an absolute pathname is required.
    
    - :WAIT
    
        If non-NIL (default), wait until the created process finishes. If
        NIL, continue running Lisp until the program finishes.
    
    - :PTY (not supported on win32)
    
        Either T, NIL, or a stream. Unless NIL, the subprocess is
        established under a PTY. If :PTY is a stream, all output to this
        pty is sent to this stream, otherwise the PROCESS-PTY slot is
        filled in with a stream connected to pty that can read output and
        write input.
    
    - :INPUT
    
        Either T, NIL (the default), a pathname, a stream, or :STREAM.
    
        - T: the standard input for the current process is inherited.
        - NIL: /dev/null (nul on win32) is used.
        - Pathname: the specified file is used.
        - Stream: all the input is read from that stream and sent to the
          subprocess.
        - :STREAM: the PROCESS-INPUT slot is filled in with a stream that
          sends its output to the process.
    
    - :IF-INPUT-DOES-NOT-EXIST (when :INPUT is the name of a file)
    
        It is one of:
    
        - :ERROR to generate an error
        - :CREATE to create an empty file
        - NIL (the default) to return NIL from RUN-PROGRAM
    
    - :OUTPUT
    
        Either T, NIL (the default), a pathname, a stream, or :STREAM.
    
        - T: the standard output for the current process is inherited.
        - NIL: /dev/null (nul on win32) is used.
        - Pathname: the specified file is used.
        - Stream: all the output from the process is written to this stream.
        - :STREAM: the PROCESS-OUTPUT slot is filled in with a stream that
          can be read to get the output.
    
    - :ERROR
    
        Same as :OUTPUT, additionally accepts :OUTPUT, making all error
        output routed to the same place as normal output. Defaults to
        :OUTPUT.
    
    - :IF-OUTPUT-EXISTS (when :OUTPUT is the name of a file)
    
        It is one of:
    
        - :ERROR (the default) to generate an error
        - :SUPERSEDE to supersede the file with output from the program
        - :APPEND to append output from the program to the file
        - NIL to return NIL from RUN-PROGRAM, without doing anything
    
    - :IF-ERROR-EXISTS
    
        Same as :IF-OUTPUT-EXISTS, controlling :ERROR output to files.
        Ignored when :ERROR :OUTPUT. Defaults to :ERROR.
    
    - :STATUS-HOOK
    
        This is a function the system calls whenever the status of the
        process changes. The function takes the process as an argument.
    
    - :EXTERNAL-FORMAT
    
        The external-format to use for :INPUT, :OUTPUT, and :ERROR :STREAMs.
    
    - :DIRECTORY
    
        Specifies the directory in which the program should be run.
        NIL (the default) means the directory is unchanged.
    
    - :PRESERVE-FDS
    
        A sequence of file descriptors which should remain open in the child
        process.
    
    Windows specific options:
    
    - :ESCAPE-ARGUMENTS (default T)
    
        Controls escaping of the arguments passed to CreateProcess.
    
    - :WINDOW (default NIL)
    
        When NIL, the subprocess decides how it will display its window.
        The following options control how the subprocess window should be
        displayed: :HIDE, :SHOW-NORMAL, :SHOW-MAXIMIZED,
        :SHOW-MINIMIZED, :SHOW-NO-ACTIVATE, :SHOW-MIN-NO-ACTIVE,
        :SHOW-NA.
    
        > _Note_: console application subprocesses may or may not display
        > a console window depending on whether the SBCL runtime is itself
        > a console or GUI application. Invoke cmd /c start to
        > consistently display a console window or use the :WINDOW
        > :HIDE option to consistently hide the console window.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

• Called by
  • SB-ACLREPL::SHELL-CMD
  • (PERFORM (COMPILE-OP GROVEL-CONSTANTS-FILE))
  • SB-GROVEL::RUN-C-COMPILER
  • UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM
  • SKEL/MPK/MPD:ENSURE-MPD
  • (BUILD (ARCHISO-CONFIG))
  • HG-FAST-EXPORT
  • RUN-HG-COMMAND
  • RUN-GIT-COMMAND
  • (START (CADDY-SERVICE))
  • ENSURE-SUDO
  • CALL-WITH-SUDO
  • RUN-DOT
  • OPEN-GNUPLOT
  • CLI/TOOLS/FS::RUN-RCLONE
  • CLI/TOOLS/FS::RUN-BTRFS
  • CLI/TOOLS/MAIL::RUN-OFFLINEIMAP*
  • CLI/TOOLS/MAIL::%NOTMUCH
  • CLI/TOOLS/MEDIA::RUN-PICARD
  • CLI/TOOLS/MEDIA::RUN-WIREPLUMBER
  • RUN-MPV
  • RUN-FFMPEG
  • CLI/TOOLS/MEDIA::RUN-FLAMEGRAPH.PL
  • CLI/TOOLS/NET::RUN-RSYNC
  • RUN-TRANSMISSION-DAEMON
  • RUN-TRANSMISSION-REMOTE
  • RUN-CADDY*
  • YTDL-JSON
  • YTDL-LIST
  • YTDL-USER-AGENT
  • YTDL-EXTRACTORS
  • RUN-YTDL
  • CLI/TOOLS/NET::RUN-NMAP*
  • RUN-EASYRSA
  • CLI/TOOLS/NET::RUN-DNSMASQ
  • CLI/TOOLS/NET::RUN-WG*
  • RUN-IP
  • RUN-BROWSER
  • RUN-CORE
  • RUN-SBCL
  • RUN-PERF
  • RUN-BUSCTL
  • RUN-MACHINECTL
  • RUN-USERDBCTL
  • RUN-HOMECTL
  • RUN-LOGINCTL
  • RUN-RESOLVECTL
  • RUN-NETWORKCTL
  • RUN-JOURNALCTL
  • RUN-SYSTEMCTL
  • QEMU-SYSTEM
  • QEMU-IMG
  • RUN-QEMU
  • RUN-ARCHISO
  • CLI/TOOLS/VIRT::RUN-MKARCHISO
  • RUN-BUILDAH
  • RUN-PODMAN
  • RUN-XVFB-RUN
  • CLI/TOOLS/BUILD::RUN-NPX
  • RUN-GO
  • CLI/TOOLS/BUILD::RUN-UV
  • RUN-RUSTUP
  • RUN-CARGO
  • RUN-MESON
  • RUN-NINJA
  • RUN-CMAKE
  • RUN-MAKE
  • RUN-LLDB
  • RUN-GDB
  • RUN-NVCC
  • RUN-LD
  • RUN-CC
  • CLI/TOOLS/PACMAN::RUN-MAKEPKG
  • CLI/TOOLS/PACMAN::RUN-MKARCHROOT
  • RUN-PACMAN
  • CLI/TOOLS/TERM::RUN-TMUX-CONTROLLER
  • RUN-TMUX
  • RUN-FBTERM
  • RUN-SCRIPTREPLAY
  • RUN-SCRIPT
  • RUN-TERM
  • #$-reader
  • RUN-EMACS
  • RUN-EMACSCLIENT
  • IO/DISK:LIST-DISKS
  • STD/DEFSYS::COMPILE-GROVEL-COMPONENT
  • DISABLE-ECHO
  • ENABLE-ECHO
  • GROUP-ADD
  • USER-ADD
  • SUDO-P

FLOAT-DENORMALIZED-P names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Return true if the float X is denormalized.
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;FLOAT.LISP

*ENCLOSING-SOURCE-CUTOFF* names a special variable:
  Declared type: UNSIGNED-BYTE
  Value: 1
  Documentation:
    The maximum number of enclosing non-original source forms (i.e. from
    macroexpansion) that we print in full. For additional enclosing forms, we
    print only the CAR.

PACKAGE-LOCKED-ERROR-SYMBOL names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Documentation:
    Return the symbol that caused the SYMBOL-PACKAGE-LOCKED-ERROR
    condition.
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

TYPEXPAND-1 names a compiled function:
  Lambda-list: (TYPE-SPECIFIER &OPTIONAL ENV)
  Derived type: (FUNCTION
                 ((OR CONS SYMBOL SB-KERNEL:CLASSOID CLASS) &OPTIONAL
                  (OR SB-C::ABSTRACT-LEXENV NULL))
                 (VALUES T BOOLEAN &OPTIONAL))
  Documentation:
    Takes and expands a type specifier once like MACROEXPAND-1.
    Returns two values: the expansion, and a boolean that is true when
    expansion happened.
  Source file: SYS:SRC;CODE;TYPE.LISP

• Called by
  • SWANK::INSPECT-TYPE-SPECIFIER

DEPRECATION-CONDITION names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:DEPRECATION-CONDITION>:
  Documentation:
    Superclass for deprecation-related error and warning
    conditions.
  Class precedence-list: DEPRECATION-CONDITION, SB-INT:REFERENCE-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION
  Direct subclasses: DEPRECATION-ERROR, FINAL-DEPRECATION-WARNING,
                     LATE-DEPRECATION-WARNING, EARLY-DEPRECATION-WARNING
  Direct slots:
    SB-KERNEL::NAMESPACE
      Initargs: :NAMESPACE
      Readers: DEPRECATION-CONDITION-NAMESPACE
    SB-KERNEL::NAME
      Initargs: :NAME
      Readers: DEPRECATION-CONDITION-NAME
    SB-KERNEL::REPLACEMENTS
      Initargs: :REPLACEMENTS
      Readers: DEPRECATION-CONDITION-REPLACEMENTS
    SB-KERNEL::SOFTWARE
      Initargs: :SOFTWARE
      Readers: DEPRECATION-CONDITION-SOFTWARE
    SB-KERNEL::VERSION
      Initargs: :VERSION
      Readers: DEPRECATION-CONDITION-VERSION
    SB-KERNEL::RUNTIME-ERROR
      Initargs: :RUNTIME-ERROR
      Initform: 'NIL
      Readers: DEPRECATION-CONDITION-RUNTIME-ERROR

WEAK-POINTER names the built-in-class #<BUILT-IN-CLASS SB-EXT:WEAK-POINTER>:
  Class precedence-list: WEAK-POINTER, T
  Direct superclasses: T
  No subclasses.
  Sealed.
  No direct slots.

*DEFAULT-SOURCE-EXTERNAL-FORMAT* names a special variable:
  Declared always-bound.
  Value: :DEFAULT

DEPRECATION-ERROR names a compiled function:
  Lambda-list: (SOFTWARE VERSION NAMESPACE NAME REPLACEMENTS)
  Declared type: (FUNCTION (T T T T T) NIL)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

DEPRECATION-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:DEPRECATION-ERROR>:
  Documentation:
    This error is signaled at run-time when an attempt is made to use
    a thing that is in :FINAL deprecation, i.e. call a function or access
    a variable.
  Class precedence-list: DEPRECATION-ERROR, ERROR, SERIOUS-CONDITION,
                         DEPRECATION-CONDITION, SB-INT:REFERENCE-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: ERROR, DEPRECATION-CONDITION
  No subclasses.
  No direct slots.

GC-LOGFILE names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES T &OPTIONAL))
  Documentation:
    Return the pathname used to log garbage collections. Can be SETF.
    Default is NIL, meaning collections are not logged. If non-null, the
    designated file is opened before and after each collection, and generation
    statistics are appended to it.
  Source file: SYS:SRC;CODE;GC.LISP

(SETF GC-LOGFILE) names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T)
                 (VALUES (OR STRING PATHNAME SYNONYM-STREAM FILE-STREAM NULL)
                         &OPTIONAL))
  Source file: SYS:SRC;CODE;GC.LISP

FLOAT-TRAPPING-NAN-P names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Return true if the float X is a trapping NaN (Not a Number).
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;FLOAT.LISP

%SIMD-PACK-256-SINGLES names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                          SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                          &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

*EFFICIENCY-NOTE-COST-THRESHOLD* names a special variable:
  Declared type: (UNSIGNED-BYTE 44)
  Value: 5
  Documentation:
    This is the minimum cost difference between the chosen implementation and
    the next alternative that justifies an efficiency note.

ASSERT-VERSION->= names a compiled function:
  Lambda-list: (&REST SUBVERSIONS)
  Derived type: (FUNCTION * (VALUES NULL &OPTIONAL))
  Documentation:
    Asserts that the current SBCL is of version equal to or greater than
    the version specified in the arguments.  A continuable error is signaled
    otherwise.
    
    The arguments specify a sequence of subversion numbers in big endian order.
    They are compared lexicographically with the runtime version, and versions
    are treated as though trailed by an unbounded number of 0s.
    
    For example, (ASSERT-VERSION->= 1 1 4) asserts that the current SBCL
    is version 1.1.4[.0.0...] or greater, and (ASSERT-VERSION->= 1) that
    it is version 1[.0.0...] or greater.
  Source file: SYS:SRC;CODE;TARGET-MISC.LISP

• Called by
  • SWANK/SBCL::SBCL-VERSION>=
  • (DWORD-INST)

FLOAT-INFINITY-P names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (FLOAT) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Return true if the float X is an infinity (+ or -).
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;FLOAT.LISP

• Called by
  • (FLOAT-INFINITY-P IN /home/ellis/src/core/lib/swank/sbcl.lisp)

%SIMD-PACK-SINGLES names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT
                          &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

*EXIT-HOOKS* names a global variable:
  Declared type: LIST
  Declared always-bound.
  Value: (EXIT-THREAD-POOLS STD/THREAD::EXIT-WORKERS)
  Documentation:
    A list of function designators which are called in an unspecified
    order when SBCL process exits.
    
    Unused by SBCL itself: reserved for user and applications.
    
    Using (SB-EXT:EXIT :ABORT T), or calling exit(3) directly circumvents
    these hooks.

SYMBOL-PACKAGE-LOCKED-ERROR names the condition-class #<SB-PCL::CONDITION-CLASSSB-EXT:SYMBOL-PACKAGE-LOCKED-ERROR>:
  Documentation:
    Subtype of SB-EXT:PACKAGE-LOCK-VIOLATION. An error of this type is
    signalled when an operation on a symbol violates a package lock. The
    symbol that caused the violation is accessed by the function
    SB-EXT:PACKAGE-LOCKED-ERROR-SYMBOL.
  Class precedence-list: SYMBOL-PACKAGE-LOCKED-ERROR, PACKAGE-LOCK-VIOLATION,
                         PACKAGE-ERROR, ERROR, SERIOUS-CONDITION,
                         SB-INT:REFERENCE-CONDITION, SIMPLE-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: PACKAGE-LOCK-VIOLATION
  No subclasses.
  Direct slots:
    SYMBOL
      Initargs: :SYMBOL
      Readers: PACKAGE-LOCKED-ERROR-SYMBOL

*DEBUG-PRINT-VARIABLE-ALIST* names a special variable:
  Value: NIL
  Documentation:
    an association list describing new bindings for special variables
    to be used within the debugger. Eg.
    
     ((*PRINT-LENGTH* . 10) (*PRINT-LEVEL* . 6) (*PRINT-PRETTY* . NIL))
    
    The variables in the CAR positions are bound to the values in the CDR
    during the execution of some debug commands. When evaluating arbitrary
    expressions in the debugger, the normal values of the printer control
    variables are in effect.
    
    Initially empty, *DEBUG-PRINT-VARIABLE-ALIST* is typically used to
    provide bindings for printer control variables.

ATOMIC-UPDATE names a macro:
  Lambda-list: (PLACE UPDATE-FN &REST ARGUMENTS)
  Documentation:
    Updates PLACE atomically to the value returned by calling function
    designated by UPDATE-FN with ARGUMENTS and the previous value of PLACE.
    
    PLACE may be read and UPDATE-FN evaluated and called multiple times beforethe
    update succeeds: atomicity in this context means that the value of PLACEdid
    not change between the time it was read, and the time it was replaced withthe
    computed value.
    
    PLACE can be any place supported by SB-EXT:COMPARE-AND-SWAP.
    
    Examples:
    
        ;;; Conses T to the head of FOO-LIST.
        (defstruct foo list)
        (defvar *foo* (make-foo))
        (atomic-update (foo-list *foo*) #'cons t)
    
        (let ((x (cons :count 0)))
           (mapc #'sb-thread:join-thread
                 (loop repeat 1000
                       collect (sb-thread:make-thread
                                (lambda ()
                                  (loop repeat 1000
                                        do (atomic-update (cdr x) #'1+)
                                           (sleep 0.00001))))))
           ;; Guaranteed to be (:COUNT . 1000000) -- if you replace
           ;; atomic update with (INCF (CDR X)) above, the result becomes
           ;; unpredictable.
           x)
  Source file: SYS:SRC;CODE;MACROS.LISP

SINGLE-FLOAT-POSITIVE-INFINITY names a constant variable:
  Value: #.SINGLE-FLOAT-POSITIVE-INFINITY

%SIMD-PACK-512-UB8S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

DEFINE-HASH-TABLE-TEST names a macro:
  Lambda-list: (NAME HASH-FUNCTION)
  Documentation:
    Defines NAME as a new kind of hash table test for use with the :TEST
    argument to MAKE-HASH-TABLE, and associates a default HASH-FUNCTION withit.
    
    NAME must be a symbol naming a global two argument equivalence predicate.
    Afterwards both 'NAME and #'NAME can be used with :TEST argument. In both
    cases HASH-TABLE-TEST will return the symbol NAME.
    
    HASH-FUNCTION must be a symbol naming a global hash function consistentwith
    the predicate, or be a LAMBDA form implementing one in the current lexical
    environment. The hash function must compute the same hash code for any two
    objects for which NAME returns true, and subsequent calls with alreadyhashed
    objects must always return the same hash code.
    
    > _Note_: The :HASH-FUNCTION keyword argument to MAKE-HASH-TABLE can
    > be used to override the specified default hash-function.
    
    Attempting to define NAME in a locked package as hash-table test causes a
    package lock violation.
    
    Examples:
    
    ;; We want to use objects of type FOO as keys (by their
    ;; names.) EQUALP would work, but would make the names
    ;; case-insensitive -- which we don't want.
    (defstruct foo (name nil :type (or null string)))
    
    ;; Define an equivalence test function and a hash function.
    (defun foo-name= (f1 f2) (equal (foo-name f1) (foo-name f2)))
    (defun sxhash-foo-name (f) (sxhash (foo-name f)))
    
    (define-hash-table-test foo-name= sxhash-foo-name)
    
    ;; #'foo-name would work too.
    (defun make-foo-table () (make-hash-table :test 'foo-name=))
    
    (defun == (x y) (= x y))
    
    (define-hash-table-test ==
      (lambda (x)
        ;; Hash codes must be consistent with test, so
        ;; not (SXHASH X), since
        ;;   (= 1 1.0)                   => T
        ;;   (= (SXHASH 1) (SXHASH 1.0)) => NIL
        ;; Note: this doesn't deal with complex numbers or
        ;; bignums too large to represent as double floats.
        (sxhash (coerce x 'double-float))))
    
    ;; #'== would work too
    (defun make-number-table () (make-hash-table :test '==))
  Source file: SYS:SRC;CODE;TARGET-HASH-TABLE.LISP

FREEZE-TYPE names an SBCL-specific declaration.

%SIMD-PACK-SB8S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

STEP-CONDITION names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:STEP-CONDITION>:
  Documentation:
    Common base class of single-stepping conditions.
    STEP-CONDITION-FORM holds a string representation of the form being
    stepped.
  Class precedence-list: STEP-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CONDITION
  Direct subclasses: SB-DEBUG::STEP*-CONDITION, STEP-FINISHED-CONDITION,
                     SB-KERNEL::STEP-RESULT-CONDITION, STEP-FORM-CONDITION
  Direct slots:
    SB-KERNEL:FORM
      Initargs: :FORM
      Readers: STEP-CONDITION-FORM

*STEPPER-HOOK* names a special variable:
  Value: SB-IMPL::SINGLE-STEP
  Documentation:
    Customization hook for alternative single-steppers.
    *STEPPER-HOOK* is bound to NIL prior to calling the bound function
    with the STEP-CONDITION as argument.

• Bound by
  • (CALL-WITH-DEBUGGER-HOOK IN /home/ellis/src/core/lib/swank/sbcl.lisp)

INTERACTIVE-EVAL names a compiled function:
  Lambda-list: (FORM &KEY (EVAL (FUNCTION EVAL)))
  Derived type: (FUNCTION (T &KEY (:EVAL T)) *)
  Documentation:
    Evaluate FORM, returning whatever it returns and adjusting ***, **, *,
    +++, ++, +, ///, //, /, and -.
  Source file: SYS:SRC;CODE;TOPLEVEL.LISP

• Called by
  • SB-ACLREPL::REP-ONE

FINAL-DEPRECATION-WARNING names the condition-class #<SB-PCL::CONDITION-CLASSSB-EXT:FINAL-DEPRECATION-WARNING>:
  Documentation:
    This warning is signaled when the use of a variable,
    function, type, etc. in :FINAL deprecation is detected at
    compile-time. An error will be signaled at run-time.
  Class precedence-list: FINAL-DEPRECATION-WARNING, WARNING,
                         DEPRECATION-CONDITION, SB-INT:REFERENCE-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: WARNING, DEPRECATION-CONDITION
  No subclasses.
  No direct slots.

%SIMD-PACK-UB8S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8) (UNSIGNED-BYTE 8)
                          (UNSIGNED-BYTE 8) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

STACK-ALLOCATED-P names a compiled function:
  Lambda-list: (X &OPTIONAL ALL-THREADS)
  Derived type: (FUNCTION (T &OPTIONAL T)
                 (VALUES (OR SB-THREAD:THREAD NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;DEBUG.LISP

• Called by
  • SB-INTROSPECT:ALLOCATION-INFORMATION

%SIMD-PACK-256-SB32S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-256)
                  (VALUES (SIGNED-BYTE 32) (SIGNED-BYTE 32) (SIGNED-BYTE 32)
                          (SIGNED-BYTE 32) (SIGNED-BYTE 32) (SIGNED-BYTE 32)
                          (SIGNED-BYTE 32) (SIGNED-BYTE 32) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

SIMD-PACK-256-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • SB-SIMD-AVX2:S64.2!
  • SB-SIMD-AVX2:S32.4!
  • SB-SIMD-AVX2:S16.8!
  • SB-SIMD-AVX2:S8.16!
  • SB-SIMD-AVX2:U64.2!
  • SB-SIMD-AVX2:U32.4!
  • SB-SIMD-AVX2:U16.8!
  • SB-SIMD-AVX2:U8.16!
  • SB-SIMD-AVX:S64.4!
  • SB-SIMD-AVX:S32.8!
  • SB-SIMD-AVX:S16.16!
  • SB-SIMD-AVX:S8.32!
  • SB-SIMD-AVX:S64.2!
  • SB-SIMD-AVX:S32.4!
  • SB-SIMD-AVX:S16.8!
  • SB-SIMD-AVX:S8.16!
  • SB-SIMD-AVX:U64.4!
  • SB-SIMD-AVX:U32.8!
  • SB-SIMD-AVX:U16.16!
  • SB-SIMD-AVX:U8.32!
  • SB-SIMD-AVX:U64.2!
  • SB-SIMD-AVX:U32.4!
  • SB-SIMD-AVX:U16.8!
  • SB-SIMD-AVX:U8.16!
  • SB-SIMD-AVX:F64.4!
  • SB-SIMD-AVX:F32.8!
  • SB-SIMD-AVX:F32.4!
  • SB-SIMD-AVX:U64!
  • SB-SIMD-AVX:U32!
  • SB-SIMD-AVX:U16!
  • SB-SIMD-AVX:U8!
  • SB-SIMD-AVX:F64!
  • SB-SIMD-AVX:F32!

*UNDEFINED-WARNING-LIMIT* names a special variable:
  Value: 3
  Documentation:
    If non-null, then an upper limit on the number of unknown function or type
    warnings that the compiler will print for any given name in a single
    compilation. This prevents excessive amounts of output when the real
    problem is a missing definition (as opposed to a typo in the use.)

%MAKE-SIMD-PACK-256-UB32 names a compiled function:
  Lambda-list: (P0 P1 P2 P3 P4 P5 P6 P7)
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                   (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32)
                   (UNSIGNED-BYTE 32) (UNSIGNED-BYTE 32))
                  (VALUES (SB-EXT:SIMD-PACK-256 (UNSIGNED-BYTE 32)) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-256.LISP

COMPILER-NOTE names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:COMPILER-NOTE>:
  Documentation:
    Root of the hierarchy of conditions representing information discovered
    by the compiler that the user might wish to know, but which does not merit
    a STYLE-WARNING (or any more serious condition).
  Class precedence-list: COMPILER-NOTE, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CONDITION
  Direct subclasses: SB-INT:SIMPLE-COMPILER-NOTE
  No direct slots.

COMPILE-FILE-POSITION names a macro:
  Lambda-list: ()
  Documentation:
    Return character position of this macro invocation or NIL if unavailable.
  Source file: SYS:SRC;COMPILER;TARGET-MAIN.LISP

SIMD-PACK-512-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

%MAKE-SIMD-PACK-256-DOUBLE names a compiled function:
  Lambda-list: (A B C D)
  Declared type: (FUNCTION
                  (DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT)
                  (VALUES (SB-EXT:SIMD-PACK-256 DOUBLE-FLOAT) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

%SIMD-PACK-UB64S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

*COMPILER-PRINT-VARIABLE-ALIST* names a special variable:
  Value: NIL
  Documentation:
    An association list describing new bindings for special variables
    to be used by the compiler for error-reporting, etc.
    E.g. ((*PRINT-LENGTH* . 10) (*PRINT-LEVEL* . 6) (*PRINT-PRETTY* .
    NIL)).
    
    The variables in the CAR positions are bound to the values in the CDR
    during the execution of some debug commands. When evaluating arbitrary
    expressions in the debugger, the normal values of the printer control
    variables are in effect.
    
    Initially empty, *COMPILER-PRINT-VARIABLE-ALIST* is typically used
    to specify bindings for printer control variables.

STEP-CONDITION-ARGS names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

%SIMD-PACK-UB16S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16)
                          (UNSIGNED-BYTE 16) (UNSIGNED-BYTE 16) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK.LISP

FINALIZE names a compiled function:
  Lambda-list: (OBJECT FUNCTION &KEY DONT-SAVE)
  Declared type: (FUNCTION (T (OR FUNCTION SYMBOL) &KEY (:DONT-SAVE T)) *)
  Derived type: (FUNCTION (T (OR FUNCTION SYMBOL) &KEY (:DONT-SAVE T))
                 (VALUES T &OPTIONAL))
  Documentation:
    Arrange for the designated FUNCTION to be called when there
    are no more references to OBJECT, including references in FUNCTION
    itself.
    
    If DONT-SAVE is true, the finalizer will be cancelled when
    SAVE-LISP-AND-DIE is called: this is useful for finalizers
    deallocating system memory, which might otherwise be called with
    addresses from the old image.
    
    In a multithreaded environment FUNCTION may be called in any
    thread. In both single and multithreaded environments FUNCTION
    may be called in any dynamic scope: consequences are unspecified
    if FUNCTION is not fully re-entrant.
    
    Errors from FUNCTION are handled and cause a WARNING to be
    signalled in whichever thread the FUNCTION was called in.
    
    Examples:
    
    ;;; GOOD, assuming RELEASE-HANDLE is re-entrant.
    (let* ((handle (get-handle))
           (object (make-object handle)))
     (finalize object (lambda () (release-handle handle)))
     object)
    
    ;;; BAD, finalizer refers to object being finalized, causing
    ;;; it to be retained indefinitely!
    (let* ((handle (get-handle))
           (object (make-object handle)))
      (finalize object
                (lambda ()
                  (release-handle (object-handle object)))))
    
    ;;; BAD, not re-entrant!
    (defvar *rec* nil)
    
    (defun oops ()
     (when *rec*
       (error "recursive OOPS"))
     (let ((*rec* t))
       (gc))) ; or just cons enough to cause one
    
    (progn
      (finalize "oops" #'oops)
      (oops)) ; GC causes re-entry to #'oops due to the finalizer
              ; -> ERROR, caught, WARNING signalled
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;FINAL.LISP

• Called by
  • (SOCKET-ACCEPT (SOCKET))
  • (SET-DATABASE-BACKEND-OPTION (RDB-DATABASE (EQL CLOSE) (EQL AUTO)))
  • (SET-DATABASE-BACKEND-OPTION (RDB (EQL CLOSE) (EQL AUTO)))
  • NET/REQ::REQ
  • (SHARED-INITIALIZE AFTER (SOCKET T))
  • DAT/TTF::ARRANGE-FINALIZATION
  • (GET-CACHE)

INHIBIT-WARNINGS names an optimization policy quality:
  (undocumented)

*DEFAULT-EXTERNAL-FORMAT* names a special variable:
  Declared always-bound.
  Value: :UTF-8
  Documentation:
    Most functions interacting with external formats (OPEN, notably)
    use this default.

• Referenced by
  • NET/REQ::REQ
  • NET/REQ::CHARSET-TO-ENCODING
  • URL-DECODE
  • URL-DECODE-PARAMS
  • URL-ENCODE
  • URL-ENCODE-PARAMS

PROCESS-CLOSE names a compiled function:
  Lambda-list: (PROCESS)
  Derived type: (FUNCTION (T) (VALUES SB-IMPL::PROCESS &OPTIONAL))
  Documentation:
    Close all streams connected to PROCESS, stop maintaining the
    status slot. After PROCESS-CLOSE, PROCESS-ALIVE-P and
    PROCESS-EXIT-CODE can return stale information about a process, so
    should not be used.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

GENERATION-BYTES-CONSED-BETWEEN-GCS names a compiled function:
  Lambda-list: (GENERATION)
  Derived type: (FUNCTION ((MOD 7)) (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Documentation:
    Number of bytes that can be allocated to GENERATION before that
    generation is considered for garbage collection. This value is meaninglessfor
    generation 0 (the nursery): see BYTES-CONSED-BETWEEN-GCS instead. Defaultis
    5% of the dynamic space size divided by the number of non-nurserygenerations.
    Can be assigned to using SETF. Available on GENCGC platforms only.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;GC.LISP

(SETF GENERATION-BYTES-CONSED-BETWEEN-GCS) names a compiled function:
  Lambda-list: (VALUE GENERATION)
  Derived type: (FUNCTION (T (MOD 7)) (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Source file: SYS:SRC;CODE;GC.LISP

SYMBOL-GLOBAL-VALUE names a compiled function:
  Lambda-list: (SYMBOL)
  Declared type: (FUNCTION (SYMBOL) (VALUES T &OPTIONAL))
  Documentation:
    Return the SYMBOL's current global value. Identical to SYMBOL-VALUE,
    in single-threaded builds: in multithreaded builds bound values are
    distinct from the global value. Can also be SETF.
  Source file: SYS:SRC;CODE;SYMBOL.LISP

(SETF SYMBOL-GLOBAL-VALUE) has setf-expansion: SB-KERNEL:SET-SYMBOL-GLOBAL-VALUE

PRINT-SYMBOL-WITH-PREFIX names a compiled function:
  Lambda-list: (STREAM SYMBOL &OPTIONAL COLON AT)
  Derived type: (FUNCTION (T T &OPTIONAL T T) (VALUES T &OPTIONAL))
  Documentation:
    For use with ~/: Write SYMBOL to STREAM as if it is not accessible from
    the current package.
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

*ED-FUNCTIONS* names a special variable:
  Declared type: LIST
  Value: (#<FUNCTION RUN-EMACSCLIENT> #<FUNCTION RUN-EMACS>)
  Documentation:
    See ED.

PARSE-NATIVE-NAMESTRING names a compiled function:
  Lambda-list: (THING &OPTIONAL HOST (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*)
                &KEY (START 0) END JUNK-ALLOWED AS-DIRECTORY)
  Derived type: (FUNCTION
                 ((OR STRING PATHNAME SYNONYM-STREAM FILE-STREAM) &OPTIONAL
                  (OR STRING CONS SB-KERNEL:HOST (MEMBER :UNSPECIFIC NIL))
                  (OR STRING PATHNAME SYNONYM-STREAM FILE-STREAM) &KEY
                  (:START (UNSIGNED-BYTE 44))
                  (:END (OR NULL (UNSIGNED-BYTE 44))) (:JUNK-ALLOWED T)
                  (:AS-DIRECTORY T))
                 (VALUES (OR PATHNAME NULL) (OR NULL (UNSIGNED-BYTE 44))
                         &OPTIONAL))
  Documentation:
    Convert THING into a pathname, using the native conventions
    appropriate for the pathname host HOST, or if not specified the
    host of DEFAULTS.  If THING is a string, the parse is bounded by
    START and END, and error behaviour is controlled by JUNK-ALLOWED,
    as with PARSE-NAMESTRING.  For file systems whose native
    conventions allow directories to be indicated as files, if
    AS-DIRECTORY is true, return a pathname denoting THING as a
    directory.
  Source file: SYS:SRC;CODE;TARGET-PATHNAME.LISP

• Called by
  • PARSE-NATIVE-NAMESTRING
  • UIOP/OS:GETCWD
  • NET/SRV/http::PARSE-PATH
  • (FILENAME-TO-PATHNAME IN /home/ellis/src/core/lib/swank/sbcl.lisp)

DELETE-FILE-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:DELETE-FILE-ERROR>:
  Class precedence-list: DELETE-FILE-ERROR, SB-INT:SIMPLE-FILE-ERROR,
                         SIMPLE-CONDITION, FILE-ERROR, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:SIMPLE-FILE-ERROR
  No subclasses.
  No direct slots.

*SUPPRESS-PRINT-ERRORS* names a special variable:
  Value: NIL
  Documentation:
    Suppress printer errors when the condition is of the type designated bythis
    variable: an unreadable object representing the error is printed instead.

• Bound by
  • FORMAT-SLOTS
  • PRINT-SLOTS
• Referenced by
  • FORMAT-SLOTS
  • PRINT-SLOTS

STEP-FINISHED-CONDITION names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:STEP-FINISHED-CONDITION>:
  Documentation:
    Condition signaled when STEP returns.
  Class precedence-list: STEP-FINISHED-CONDITION, STEP-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STEP-CONDITION
  No subclasses.
  No direct slots.

DELETE-DIRECTORY names a compiled function:
  Lambda-list: (PATHSPEC &KEY RECURSIVE)
  Derived type: (FUNCTION
                 ((OR STRING PATHNAME SYNONYM-STREAM FILE-STREAM) &KEY
                  (:RECURSIVE T))
                 *)
  Documentation:
    Deletes the directory designated by PATHSPEC (a pathname designator).
    Returns the truename of the directory deleted.
    
    If RECURSIVE is false (the default), signals an error unless the directoryis
    empty. If RECURSIVE is true, first deletes all files and subdirectories. If
    RECURSIVE is true and the directory contains symbolic links, the links are
    deleted, not the files and directories they point to.
    
    Signals an error if PATHSPEC designates a file or a symbolic link insteadof a
    directory, or if the directory could not be deleted for any reason.
    
    Both
    
        (DELETE-DIRECTORY "/tmp/foo")
        (DELETE-DIRECTORY "/tmp/foo/")
    
    delete the "foo" subdirectory of "/tmp", or signal an error if
    it does not exist or if it is a file or a symbolic link.
  Source file: SYS:SRC;CODE;FILESYS.LISP

• Called by
  • UIOP/FILESYSTEM:DELETE-DIRECTORY-TREE
  • UIOP/FILESYSTEM:DELETE-EMPTY-DIRECTORY
  • SKEL/CORE::SKEL-PROJECT-CLEAN
  • (VC-EXPORT (HG-REPO))
  • DELETE-DIRECTORIES
  • PROBE-DELETE-DIRECTORY

SHORT-FLOAT-NEGATIVE-INFINITY names a constant variable:
  Value: #.SINGLE-FLOAT-NEGATIVE-INFINITY

VALID-TYPE-SPECIFIER-P names a compiled function:
  Lambda-list: (TYPE-SPECIFIER &OPTIONAL ENV)
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Returns T if TYPE-SPECIFIER is a valid type specifier, otherwise NIL.
    
    There may be different metrics on what constitutes a "valid type
    specifier" depending on context. If this function does not suit your
    exact need, you may be able to craft a particular solution using a
    combination of DEFINED-TYPE-NAME-P and the TYPEXPAND functions.
    
    The definition of "valid type specifier" employed by this function
    is based on the following mnemonic:
    
              "Would TYPEP accept it as second argument?"
    
    Except that unlike TYPEP, this function fully supports compound
    FUNCTION type specifiers, and the VALUES type specifier, too.
    
    In particular, VALID-TYPE-SPECIFIER-P will return NIL if
    TYPE-SPECIFIER is not a class, not a symbol that is known to name a
    type specifier, and not a cons that represents a known compound type
    specifier in a syntactically and recursively correct way.
    
    Examples:
    
      (valid-type-specifier-p '(cons * *))     => T
      (valid-type-specifier-p '#:foo)          => NIL
      (valid-type-specifier-p '(cons * #:foo)) => NIL
      (valid-type-specifier-p '(cons 1 *)      => NIL
    
    Experimental.
  Source file: SYS:SRC;CODE;TYPEP.LISP

• Called by
  • (TYPE-SPECIFIER-P IN /home/ellis/src/core/lib/swank/sbcl.lisp)

HASH-TABLE-SYNCHRONIZED-P names a compiled function:
  Lambda-list: (HT)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Returns T if HASH-TABLE is synchronized.
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;TARGET-HASH-TABLE.LISP

DEFINED-TYPE-NAME-P names a compiled function:
  Lambda-list: (NAME &OPTIONAL ENV)
  Derived type: (FUNCTION (SYMBOL &OPTIONAL T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Returns T if NAME is known to name a type specifier, otherwise NIL.
  Source file: SYS:SRC;CODE;TYPEP.LISP

GENERATION-AVERAGE-AGE names a compiled function:
  Lambda-list: (GENERATION)
  Derived type: (FUNCTION ((MOD 7)) (VALUES DOUBLE-FLOAT &OPTIONAL))
  Documentation:
    Average age of memory allocated to GENERATION: average number of times
    objects allocated to the generation have seen younger objects promoted toit.
    Available on GENCGC platforms only.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;GC.LISP

PACKAGE-LOCAL-NICKNAMES names a compiled function:
  Lambda-list: (PACKAGE-DESIGNATOR)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Documentation:
    Returns an alist of (LOCAL-NICKNAME . ACTUAL-PACKAGE) describing the
    nicknames local to the designated package.
    
    When in the designated package, calls to FIND-PACKAGE with any of the
    local-nicknames will return the corresponding actual-package instead. This
    also affects all implied calls to FIND-PACKAGE, including those performedby
    the reader.
    
    When printing a package prefix for a symbol with a package local nickname,the
    local nickname is used instead of the real name in order to preserve
    print-read consistency.
    
    Experimental: interface subject to change.
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • (PUBLISH (PACKAGE-DOCUMENTATION))
  • (PACKAGE-LOCAL-NICKNAMES IN /home/ellis/src/core/lib/swank/sbcl.lisp)

DOUBLE-FLOAT-NEGATIVE-INFINITY names a constant variable:
  Value: #.DOUBLE-FLOAT-NEGATIVE-INFINITY

LONG-FLOAT-NEGATIVE-INFINITY names a constant variable:
  Value: #.DOUBLE-FLOAT-NEGATIVE-INFINITY

*CORE-PATHNAME* names a global variable:
  Declared always-bound.
  Value: #P"/usr/bin/core"
  Documentation:
    The absolute pathname of the running SBCL core.

*ON-PACKAGE-VARIANCE* names a special variable:
  Declared type: LIST
  Value: (:WARN T)
  Documentation:
    Specifies behavior when redefining a package using DEFPACKAGE and the
    definition is in variance with the current state of the package.
    
    The value should be of the form:
    
        (:warn [t | packages-names] :error [t | package-names])
    
    specifying which packages get which behaviour -- with T signifying the
    default unless otherwise specified. If default is not specified, :WARN
    is used.
    
    - :WARN keeps as much state as possible and causes SBCL to signal a
      full warning.
    
    - :ERROR causes SBCL to signal an error when the variant DEFPACKAGE
      form is executed, with restarts provided for user to specify what
      action should be taken.
    
    Example:
    
        (setf *on-package-variance* '(:warn (:swank :swank-backend) :error t))
    
    specifies to signal a warning if SWANK package is in variance, and an
    error otherwise.

MAKE-WEAK-POINTER names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES SB-EXT:WEAK-POINTER &OPTIONAL))
  Documentation:
    Allocate and return a weak pointer which points to OBJECT.
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;WEAK.LISP

• Called by
  • SB-INTROSPECT::COLLECT-XREF
  • (GET-CACHE)
  • (DESIGNATE-ORACLE (THREAD-POOL THREAD))

PROCESS-WAIT names a compiled function:
  Lambda-list: (PROCESS &OPTIONAL CHECK-FOR-STOPPED)
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES T &OPTIONAL))
  Documentation:
    Wait for PROCESS to quit running for some reason. When
    CHECK-FOR-STOPPED is T, also returns when PROCESS is stopped. Returns
    PROCESS.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

• Called by
  • UIOP/LAUNCH-PROGRAM:WAIT-PROCESS

WAIT-FOR names a macro:
  Lambda-list: (TEST-FORM &KEY TIMEOUT)
  Documentation:
    Wait until TEST-FORM evaluates to true, then return its primary value.
    If TIMEOUT is provided, waits at most approximately TIMEOUT seconds before
    returning NIL.
    
    If WITH-DEADLINE has been used to provide a global deadline, signals a
    DEADLINE-TIMEOUT if TEST-FORM doesn't evaluate to true before the
    deadline.
    
    Experimental: subject to change without prior notice.
  Source file: SYS:SRC;CODE;TARGET-THREAD.LISP

• Macroexpanded by
  • STD/THREAD::PROCESS-ALL-INTERRUPTS

ATOMIC-DECF names a macro:
  Lambda-list: (PLACE &OPTIONAL (DIFF 1))
  Documentation:
    Atomically decrements PLACE by DIFF, and returns the value of PLACE before
    the decrement.
    
    PLACE must access one of the following:
    
    - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 64) or AREF
      of a (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*)) (the type
      SB-EXT:WORD can be used for these purposes)
    
    - CAR or CDR (respectively FIRST or REST) of a CONS,
    
    - a variable defined using DEFGLOBAL with a proclaimed type of FIXNUM.
    
    Macroexpansion is performed on PLACE before expanding ATOMIC-DECF.
    
    Decrementing is done using modular arithmetic,
    which is well-defined over two different domains:
    
     - For structures and arrays, the operation accepts and produces
       an (UNSIGNED-BYTE 64), and DIFF must be of type (SIGNED-BYTE
       64). ATOMIC-DECF of #x0 by one results in #xFFFFFFFFFFFFFFFF beingstored in
       PLACE.
    
     - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM.
       ATOMIC-DECF of #x-4000000000000000 by one results in #x3FFFFFFFFFFFFFFFbeing stored in
       PLACE.
    
    DIFF defaults to 1.
    
    EXPERIMENTAL: Interface subject to change.
  Source file: SYS:SRC;CODE;MACROS.LISP

• Macroexpanded by
  • DEC-COUNTER

DISABLE-PACKAGE-LOCKS names an SBCL-specific declaration.

TIMER-SCHEDULED-P names a compiled function:
  Lambda-list: (TIMER &KEY (DELTA 0))
  Derived type: (FUNCTION (T &KEY (:DELTA T)) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    See if TIMER will still need to be triggered after DELTA seconds
    from now. For timers with a repeat interval it returns true.
  Source file: SYS:SRC;CODE;TIMER.LISP

UNSCHEDULE-TIMER names a compiled function:
  Lambda-list: (TIMER)
  Derived type: (FUNCTION (T) (VALUES &OPTIONAL))
  Documentation:
    Cancel TIMER. Once this function returns it is guaranteed that
    TIMER shall not be triggered again and there are no unfinished
    triggers.
  Source file: SYS:SRC;CODE;TIMER.LISP

• Called by
  • NET/PROTO/DNS::TRY-SERVER

%SIMD-PACK-512-SB8S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) (SIGNED-BYTE 8) (SIGNED-BYTE 8)
                          (SIGNED-BYTE 8) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

DEFINE-LOAD-TIME-GLOBAL names a macro:
  Lambda-list: (NAME VALUE &OPTIONAL (DOC NIL))
  Documentation:
    Defines NAME as a global variable that is always bound. VALUE is evaluated
    and assigned to NAME at load-time, but only if NAME is not already bound.
    
    Attempts to read NAME at compile-time will signal an UNBOUND-VARIABLE error
    unless it has otherwise been assigned a value.
    
    See also DEFGLOBAL which assigns the VALUE at compile-time too.
  Source file: SYS:SRC;CODE;MACROS.LISP

POSIX-ENVIRON names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES LIST &OPTIONAL))
  Documentation:
    Return the Unix environment as a list of SIMPLE-STRINGs. See man environ.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

FILE-DOES-NOT-EXIST names the condition-class #<SB-PCL::CONDITION-CLASS SB-EXT:FILE-DOES-NOT-EXIST>:
  Class precedence-list: FILE-DOES-NOT-EXIST, SB-INT:SIMPLE-FILE-ERROR,
                         SIMPLE-CONDITION, FILE-ERROR, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:SIMPLE-FILE-ERROR
  No subclasses.
  No direct slots.

DEPRECATION-CONDITION-REPLACEMENTS names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

NAME-CONFLICT-FUNCTION names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

RESTRICT-COMPILER-POLICY names a compiled function:
  Lambda-list: (&OPTIONAL QUALITY (MIN 0) (MAX 3))
  Derived type: (FUNCTION (&OPTIONAL T (UNSIGNED-BYTE 2) (UNSIGNED-BYTE 2))
                 (VALUES LIST LIST &OPTIONAL))
  Documentation:
    Assign a minimum value to an optimization quality. QUALITY is the name of
    the optimization quality to restrict, MIN (defaulting to zero) is the
    minimum allowed value, and MAX (defaults to 3) is the maximum.
    
    Returns the alist describing the current policy restrictions.
    
    If QUALITY is NIL or not given, nothing is done.
    
    Otherwise, if MIN is zero or MAX is 3 or neither are given, any
    existing restrictions of QUALITY are removed.
    
    See also :POLICY option in WITH-COMPILATION-UNIT.
  Source file: SYS:SRC;COMPILER;POLICY.LISP

• Called by
  • (COMPILER-POLICY)
  • SWANK/SBCL::COMPILER-POLICY

%SIMD-PACK-512-UB64S names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64)
                          (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64)
                          (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64)
                          (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;SIMD-PACK-512.LISP

PROCESS-ALIVE-P names a compiled function:
  Lambda-list: (PROCESS)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Return T if PROCESS is still alive, NIL otherwise. Can return a false
    positive on a closed process.
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

• Called by
  • PROCESS-ALIVE-P

PROCESS-KILL names a compiled function:
  Lambda-list: (PROCESS SIGNAL &OPTIONAL (WHOM PID))
  Derived type: (FUNCTION (T T &OPTIONAL T)
                 (VALUES BOOLEAN &OPTIONAL (SIGNED-BYTE 32)))
  Documentation:
    Hand SIGNAL to PROCESS. If WHOM is :PID, use the kill Unix system call. If
    WHOM is :PROCESS-GROUP, use the killpg(1) Unix system call.
    Returns T if successful, otherwise returns NIL and error
    number (two values).
  Source file: SYS:SRC;CODE;RUN-PROGRAM.LISP

• Called by
  • UIOP/LAUNCH-PROGRAM::%POSIX-SEND-SIGNAL
  • (STOP (CADDY-SERVICE))

*POSIX-ARGV* names a special variable:
  Value: ("/usr/bin/skel" "make" "build-docs")
  Documentation:
    A list of strings related to the UNIX command line (argv in C).
    
    SB-MANUAL:@RUNTIME-OPTIONS are processed and removed by the runtime.
    The default toplevel (see SB-EXT:SAVE-LISP-AND-DIE) also removes the
    SB-MANUAL:@TOPLEVEL-OPTIONS that it processes.

• Referenced by
  • UIOP/IMAGE:RAW-COMMAND-LINE-ARGUMENTS
  • SKEL/CLI::START-SKEL
  • SKEL/MPK/CLI::START-MPK
  • SKEL/HOMER/CLI::START-HOMER
  • ARGS
  • ARG0
  • (COMMAND-LINE-ARGS IN /home/ellis/src/core/lib/swank/sbcl.lisp)

STEP-CONDITION-FORM names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Documentation:
    Form associated with the STEP-CONDITION.
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

CALL-WITH-TIMING names a compiled function:
  Lambda-list: (TIMER FUNCTION &REST ARGUMENTS)
  Dynamic-extent arguments: positional=(0 1)
  Declared type: (FUNCTION ((OR FUNCTION SYMBOL) (OR FUNCTION SYMBOL) &REST T)
                  *)
  Documentation:
    Calls FUNCTION with ARGUMENTS, and gathers timing information about it.
    Then calls TIMER with keyword arguments describing the informationcollected.
    Calls TIMER even if FUNCTION performs a non-local transfer of control.Finally
    returns values returned by FUNCTION.
    
      :USER-RUN-TIME-US
          User run time in microseconds.
    
      :SYSTEM-RUN-TIME-US
          System run time in microseconds.
    
      :REAL-TIME-MS
          Real time in milliseconds.
    
      :GC-RUN-TIME-MS
          GC run time in milliseconds (included in user and system run time.)
    
      :GC-REAL-TIME-MS
          GC real time in milliseconds.
    
      :PROCESSOR-CYCLES
          Approximate number of processor cycles used. (Omitted  if notsupported on
          the platform -- currently available on x86 and x86-64 only.)
    
      :EVAL-CALLS
          Number of calls to EVAL. (Omitted if zero.)
    
      :LAMBDAS-CONVERTED
          Number of (potentially compiler introduced) lambdas converted to
          IR. (Omitted if zero.)
    
      :PAGE-FAULTS
          Number of page faults. (Omitted if zero.)
    
      :BYTES-CONSED
          Approximate number of bytes consed.
    
      :ABORTED
          True if FUNCTION caused a non-local transfer of control. (Omitted if
          NIL.)
    
    EXPERIMENTAL: Interface subject to change.
  Known attributes: call
  Source file: SYS:SRC;CODE;TIME.LISP

• Called by
  • SWANK:IO-SPEED-TEST

LONG-FLOAT-POSITIVE-INFINITY names a constant variable:
  Value: #.DOUBLE-FLOAT-POSITIVE-INFINITY

GC names a compiled function:
  Lambda-list: (&KEY (FULL NIL) (GEN 0) &ALLOW-OTHER-KEYS)
  Derived type: (FUNCTION (&KEY (:FULL T) (:GEN T) &ALLOW-OTHER-KEYS)
                 (VALUES NULL &OPTIONAL))
  Documentation:
    Initiate a garbage collection.
    
    The default is to initiate a nursery collection, which may in turn
    trigger a collection of one or more older generations as well. If FULL
    is true, all generations are collected. If GEN is provided, it can be
    used to specify the oldest generation guaranteed to be collected.
  Source file: SYS:SRC;CODE;GC.LISP

• Called by
  • SB-INTROSPECT::COLLECT-XREF
  • SAVE-LISP-TREE-SHAKE-AND-DIE

EARLY-DEPRECATION-WARNING names the condition-class #<SB-PCL::CONDITION-CLASSSB-EXT:EARLY-DEPRECATION-WARNING>:
  Documentation:
    This warning is signaled when the use of a variable,
    function, type, etc. in :EARLY deprecation is detected at
    compile-time. The use will work at run-time with no warning or
    error.
  Class precedence-list: EARLY-DEPRECATION-WARNING, STYLE-WARNING, WARNING,
                         DEPRECATION-CONDITION, SB-INT:REFERENCE-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STYLE-WARNING, DEPRECATION-CONDITION
  No subclasses.
  No direct slots.

STEP-CONDITION-RESULT names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Documentation:
    Return values associated with STEP-VALUES-CONDITION as a list.
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

ATOMIC-PUSH names a macro:
  Lambda-list: (OBJ PLACE)
  Documentation:
    Like PUSH, but atomic. PLACE may be read multiple times before
    the operation completes -- the write does not occur until such time
    that no other thread modified PLACE between the read and the write.
    
    Works on all CASable places.
  Source file: SYS:SRC;CODE;MACROS.LISP

• Macroexpanded by
  • RT/TRACING::%TRACE-END-BREAKPOINT-FUN
  • RT/TRACING::%TRACE-START-BREAKPOINT-FUN