SB-INT

NEQ names a compiled function:
  Lambda-list: (X Y)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Called by
  • VARIABLE-INFORMATION
  • FUNCTION-INFORMATION
  • SB-SPROF:START-PROFILING
  • SB-SPROF:START-SAMPLING

CLOSED-SAVED-STREAM-ERROR names the condition-class #<SB-PCL::CONDITION-CLASSSB-INT:CLOSED-SAVED-STREAM-ERROR>:
  Class precedence-list: SB-INT:CLOSED-SAVED-STREAM-ERROR,
                         SB-INT:CLOSED-STREAM-ERROR, STREAM-ERROR, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:CLOSED-STREAM-ERROR
  No subclasses.
  No direct slots.

COMMA-KIND names a compiled function:
  An accessor for SB-IMPL::COMMA
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::COMMA) (VALUES (MOD 3) &OPTIONAL))
  Source file: SYS:SRC;CODE;BACKQ.LISP

COPY-LIST-MACRO names a macro:
  Lambda-list: (INPUT &KEY CHECK-PROPER-LIST)
  Source file: SYS:SRC;CODE;MACROS.LISP

TWO-ARG-CHAR-NOT-LESSP names a compiled function:
  Lambda-list: (C1 C2)
  Declared type: (FUNCTION (CHARACTER CHARACTER) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;TARGET-CHAR.LISP

CONSTANT-FORM-VALUE names a compiled function:
  Lambda-list: (FORM &OPTIONAL (ENVIRONMENT NIL ENVP))
  Derived type: (FUNCTION (T &OPTIONAL T) *)
  Documentation:
    Returns the value of the constant FORM in ENVIRONMENT. Behaviour
    is undefined unless CONSTANTP has been first used to determine the
    constantness of the FORM in ENVIRONMENT.
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;COMPILER;EARLY-CONSTANTP.LISP

• Called by
  • IO/STATIC::EVAL-CONSTANT

ENSURE-HEAP-LIST names a compiled function:
  Lambda-list: (LIST)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;LIST.LISP

TAB-CHAR-CODE names a constant variable:
  Value: 9

FORM-TRACKING-STREAM-OBSERVER names a compiled function:
  An accessor for SB-INT:FORM-TRACKING-STREAM
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-INT:FORM-TRACKING-STREAM)
                 (VALUES FUNCTION &OPTIONAL))
  Source file: SYS:SRC;CODE;FD-STREAM.LISP

(SETF FORM-TRACKING-STREAM-OBSERVER) names a compiled function:
  An accessor for SB-INT:FORM-TRACKING-STREAM
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (FUNCTION SB-INT:FORM-TRACKING-STREAM)
                 (VALUES FUNCTION &OPTIONAL))
  Source file: SYS:SRC;CODE;FD-STREAM.LISP

WEAK-VECTOR-REF names a macro:
  Lambda-list: (VECTOR INDEX)
  Source file: SYS:SRC;COMPILER;ARRAY-TRAN.LISP

• Macroexpanded by
  • SB-COVER::REFRESH-COVERAGE-BITS
  • SB-COVER:RESET-COVERAGE

HASHSET-MUTEX names a compiled function:
  An accessor for SB-IMPL::ROBINHOOD-HASHSET
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::ROBINHOOD-HASHSET)
                 (VALUES (OR NULL SB-THREAD:MUTEX) &OPTIONAL))
  Source file: SYS:SRC;CODE;HASHSET.LISP

(SETF HASHSET-MUTEX) names a compiled function:
  An accessor for SB-IMPL::ROBINHOOD-HASHSET
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION
                 ((OR NULL SB-THREAD:MUTEX) SB-IMPL::ROBINHOOD-HASHSET)
                 (VALUES (OR NULL SB-THREAD:MUTEX) &OPTIONAL))
  Source file: SYS:SRC;CODE;HASHSET.LISP

PACKAGE-AT-VARIANCE names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:PACKAGE-AT-VARIANCE>:
  Class precedence-list: SB-INT:PACKAGE-AT-VARIANCE, SB-INT:REFERENCE-CONDITION,
                         SIMPLE-WARNING, SIMPLE-CONDITION, WARNING, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION, SIMPLE-WARNING
  No subclasses.
  No direct slots.

MIX names a compiled function:
  Lambda-list: (X Y)
  Declared type: (FUNCTION ((UNSIGNED-BYTE 62) (UNSIGNED-BYTE 62))
                  (VALUES (UNSIGNED-BYTE 62) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;STRING-HASH.LISP

*RECOGNIZED-DECLARATIONS* names a global variable:
  Declared always-bound.
  Value: (INTERACTIVE METHOD-PROPERTIES SB-PCL::%VARIABLE-REBINDING
                      SB-PCL::%PARAMETER SB-PCL::%CLASS DEPRECATED ALWAYS-BOUND
                      GLOBAL DISABLE-PACKAGE-LOCKS ENABLE-PACKAGE-LOCKS
                      UNMUFFLE-CONDITIONS MUFFLE-CONDITIONS SB-C::TLAB)

• Referenced by
  • DECLARATION-INFORMATION

ENCAPSULATE names a compiled function:
  Lambda-list: (NAME TYPE FUNCTION)
  Derived type: (FUNCTION (T T T) *)
  Source file: SYS:SRC;CODE;FDEFINITION.LISP

• Called by
  • (WRAP IN /home/ellis/src/core/lib/swank/sbcl.lisp)

MAP-HASHSET names a compiled function:
  Lambda-list: (FUNCTION HASHSET)
  Dynamic-extent arguments: positional=(0)
  Derived type: (FUNCTION (T T) (VALUES NULL &OPTIONAL))
  Source file: SYS:SRC;CODE;HASHSET.LISP

CIRCULAR-LIST-ERROR names a compiled function:
  Lambda-list: (LIST)
  Declared type: (FUNCTION (T) NIL)
  Source file: SYS:SRC;CODE;SEQ.LISP

DESCRIPTOR-SAP names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES SB-SYS:SYSTEM-AREA-POINTER &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;SHARE-VM.LISP

WITH-FLOAT-TRAPS-MASKED names a macro:
  Lambda-list: (TRAPS &BODY BODY)
  Source file: SYS:SRC;CODE;FLOAT-TRAP.LISP

FORMAT-ARGS-MISMATCH names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:FORMAT-ARGS-MISMATCH>:
  Class precedence-list: SB-INT:FORMAT-ARGS-MISMATCH,
                         SB-INT:REFERENCE-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION
  Direct subclasses: SB-INT:FORMAT-TOO-MANY-ARGS-WARNING,
                     SB-INT:FORMAT-TOO-FEW-ARGS-WARNING
  No direct slots.

GENSYMIFY* names a compiled function:
  Lambda-list: (&REST THINGS)
  Derived type: (FUNCTION * (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

BELL-CHAR-CODE names a constant variable:
  Value: 7

STRUCTURE-INITARG-NOT-KEYWORD names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:STRUCTURE-INITARG-NOT-KEYWORD>:
  Class precedence-list: SB-INT:STRUCTURE-INITARG-NOT-KEYWORD,
                         SB-INT:REFERENCE-CONDITION, SIMPLE-STYLE-WARNING,
                         SIMPLE-CONDITION, STYLE-WARNING, WARNING, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION, SIMPLE-STYLE-WARNING
  No subclasses.
  No direct slots.

*KEYWORD-PACKAGE* names a symbol macro:
  Expansion: #<PACKAGE "KEYWORD">

NAMED-LET names a macro:
  Lambda-list: (NAME BINDS &BODY BODY)
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Macroexpanded by
  • SB-SPROF:START-PROFILING
  • SCHEDULE-WORK
  • WRAP-ERROR
  • WRAP-CONDITION

+NIL-PACKED-INFOS+ names a global variable:
  Declared always-bound.
  Value: #<SB-INT:PACKED-INFO len=1 {120005CB33}>

XSET-EVERY names a compiled function:
  Lambda-list: (PREDICATE XSET)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;XSET.LISP

SSET-ADJOIN names a compiled function:
  Lambda-list: (ELEMENT SET)
  Declared type: (FUNCTION (SB-INT:SSET-ELEMENT SB-INT:SSET)
                  (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;COMPILER;SSET.LISP

ONCE-ONLY names a macro:
  Lambda-list: (SPECS &BODY BODY)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Macroexpanded by
  • (FRLOCK-WRITE)
  • (FRLOCK-READ)
  • (WITH-SOCKET-FD-AND-ADDR)
  • (%DEFPKG*)

*EOF-OBJECT* names a global variable:
  Declared always-bound.
  Value: #:EOF-OBJECT

• Referenced by
  • SB-COVER::READ-AND-RECORD-SOURCE-MAP
  • SB-COVER::READ-AND-RECORD-SOURCE-MAPS

%MACROEXPAND-1 names a compiled function:
  Lambda-list: (FORM &OPTIONAL ENV)
  Declared type: (FUNCTION (T &OPTIONAL (OR SB-C::ABSTRACT-LEXENV NULL))
                  (VALUES T &OPTIONAL BOOLEAN))
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;MACROEXPAND.LISP

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

LINE/COL-FROM-CHARPOS names a compiled function:
  Lambda-list: (STREAM &OPTIONAL
                (CHARPOS (FORM-TRACKING-STREAM-CURRENT-CHAR-POS STREAM)))
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES CONS &OPTIONAL))
  Source file: SYS:SRC;CODE;FD-STREAM.LISP

CROSS names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;UNCROSS.LISP

DEPRECATION-INFO-VERSION names a compiled function:
  An accessor for SB-INT:DEPRECATION-INFO
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-INT:DEPRECATION-INFO) (VALUES STRING &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Called by
  • SB-CLTL2::MAYBE-DEPRECATION-ENTRY

WITH-PROGRESSIVE-TIMEOUT names a macro:
  Lambda-list: ((NAME &KEY SECONDS) &BODY BODY)
  Documentation:
    Binds NAME as a local function for BODY. Each time #'NAME is called, it
    returns SECONDS minus the time that has elapsed since BODY was entered, or
    zero if more time than SECONDS has elapsed. If SECONDS is NIL, #'NAME
    returns NIL each time.
  Source file: SYS:SRC;CODE;TARGET-THREAD.LISP

INFO-NUMBER names a type-specifier:
  Lambda-list: ()
  Expansion: (UNSIGNED-BYTE 6)

LISTEN-SKIP-WHITESPACE names a compiled function:
  Lambda-list: (&OPTIONAL (STREAM *STANDARD-INPUT*))
  Derived type: (FUNCTION (&OPTIONAL T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;READER.LISP

• Called by
  • DAT/BIB::READ-BIBTEX-ENTRY

PROMISE-READY-P names a compiled function:
  Lambda-list: (PROMISE)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

RUBOUT-CHAR-CODE names a constant variable:
  Value: 127

WITH-SYSTEM-MUTEX names a macro:
  Lambda-list: ((MUTEX &KEY WITHOUT-GCING ALLOW-WITH-INTERRUPTS) &BODY BODY)
  Source file: SYS:SRC;CODE;SYSMACS.LISP

• Macroexpanded by
  • SB-INTROSPECT:MAP-ROOT
  • SB-POSIX:FORK
  • SB-SPROF:START-PROFILING
  • SB-SPROF::CALL-WITH-EACH-PROFILE-BUFFER

FORM-TRACKING-STREAM names the structure-class #<STRUCTURE-CLASS SB-INT:FORM-TRACKING-STREAM>:
  Class precedence-list: SB-INT:FORM-TRACKING-STREAM, SB-SYS:FD-STREAM,
                         FILE-STREAM, SB-KERNEL:ANSI-STREAM, STREAM,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-SYS:FD-STREAM
  No subclasses.
  Slots:
    SB-IMPL::IN-BUFFER
      Type: (OR SB-KERNEL:ANSI-STREAM-IN-BUFFER NULL)
      Initform: NIL
    SB-IMPL::CIN-BUFFER
      Type: (OR SB-IMPL::ANSI-STREAM-CIN-BUFFER NULL)
      Initform: NIL
    SB-IMPL::CSIZE-BUFFER
      Type: (OR SB-IMPL::ANSI-STREAM-CSIZE-BUFFER NULL)
      Initform: NIL
    SB-IMPL::IN-INDEX
      Type: (INTEGER 0 512)
      Initform: SB-IMPL::+ANSI-STREAM-IN-BUFFER-LENGTH+
    SB-IMPL::IN
      Type: FUNCTION
      Initform: #'SB-KERNEL:ILL-IN
    SB-IMPL::BIN
      Type: FUNCTION
      Initform: #'SB-KERNEL:ILL-BIN
    SB-IMPL::N-BIN
      Type: (SB-INT:SFUNCTION
             (STREAM
              (OR (SB-KERNEL:SIMPLE-UNBOXED-ARRAY (*))
                  SB-SYS:SYSTEM-AREA-POINTER)
              (OR SB-IMPL::ANSI-STREAM-CSIZE-BUFFER NULL) SB-INT:INDEX
              SB-INT:INDEX &OPTIONAL T)
             SB-INT:INDEX)
      Initform: #'SB-KERNEL:ILL-BIN
    SB-IMPL::COUT
      Type: (SB-INT:SFUNCTION * T)
      Initform: #'SB-KERNEL:ILL-OUT
    SB-IMPL::BOUT
      Type: (SB-INT:SFUNCTION * T)
      Initform: #'SB-KERNEL:ILL-BOUT
    SB-IMPL::SOUT
      Type: (SB-INT:SFUNCTION * T)
      Initform: #'SB-KERNEL:ILL-OUT
    SB-IMPL::MISC
      Type: (FUNCTION (STREAM (INTEGER 0 17) T) *)
      Initform: #'SB-IMPL::TRACKING-STREAM-MISC
    SB-IMPL::INPUT-CHAR-POS
      Type: (OR NULL (OR (INTEGER -512 0) SB-INT:INDEX))
      Initform: (- SB-IMPL::+ANSI-STREAM-IN-BUFFER-LENGTH+)
    SB-IMPL::NAME
      Type: T
      Initform: NIL
    SB-IMPL::FILE
      Type: T
      Initform: NIL
    SB-IMPL::ORIGINAL
      Type: (OR SIMPLE-STRING NULL)
      Initform: NIL
    SB-IMPL::DELETE-ORIGINAL
      Type: T
      Initform: NIL
    SB-IMPL::ELEMENT-SIZE
      Type: SB-INT:INDEX
      Initform: 1
    SB-IMPL::ELEMENT-TYPE
      Type: T
      Initform: 'BASE-CHAR
    SB-IMPL::ELEMENT-MODE
      Type: SB-IMPL::STREAM-ELEMENT-MODE
      Initform: :BIVALENT
    SB-IMPL::FD
      Type: FIXNUM
      Initform: -1
    SB-IMPL::FD-TYPE
      Type: KEYWORD
      Initform: :UNKNOWN
    SB-IMPL::BUFFERING
      Type: (MEMBER :FULL :LINE :NONE)
      Initform: :FULL
    SB-IMPL::SYNCHRONIZE-OUTPUT
      Type: T
      Initform: NIL
    SB-IMPL::OUTPUT-COLUMN
      Type: (OR (AND UNSIGNED-BYTE SB-INT:INDEX) NULL)
      Initform: NIL
    LISTEN
      Type: (MEMBER NIL T :EOF)
      Initform: NIL
    SB-IMPL::SERVE-EVENTS
      Type: BOOLEAN
      Initform: NIL
    SB-IMPL::INSTEAD
      Type: (ARRAY CHARACTER (*))
      Initform: (MAKE-ARRAY 0 :ELEMENT-TYPE 'CHARACTER :ADJUSTABLE T
                            :FILL-POINTER T)
    SB-IMPL::IBUF
      Type: (OR SB-IMPL::BUFFER NULL)
      Initform: NIL
    SB-IMPL::EOF-FORCED-P
      Type: (MEMBER T NIL)
      Initform: NIL
    SB-IMPL::OBUF
      Type: (OR SB-IMPL::BUFFER NULL)
      Initform: NIL
    SB-IMPL::OUTPUT-QUEUE
      Type: T
      Initform: NIL
    SB-IMPL::HANDLER
      Type: T
      Initform: NIL
    TIMEOUT
      Type: (OR SINGLE-FLOAT NULL)
      Initform: NIL
    PATHNAME
      Type: (OR PATHNAME NULL)
      Initform: NIL
    SB-IMPL::EXTERNAL-FORMAT
      Type: T
      Initform: :LATIN-1
    SB-IMPL::CHAR-SIZE
      Type: (OR FIXNUM FUNCTION)
      Initform: 1
    SB-IMPL::REPLACEMENT
      Type: (OR NULL CHARACTER STRING (SIMPLE-ARRAY (UNSIGNED-BYTE 8) 1))
      Initform: NIL
    SB-IMPL::OUTPUT-BYTES
      Type: FUNCTION
      Initform: #'SB-KERNEL:ILL-OUT
    FILE-POSITION
      Type: (OR (AND UNSIGNED-BYTE SB-INT:INDEX) (MEMBER -1 -2 -3))
      Initform: -1
    SB-IMPL::OBSERVER
      Type: FUNCTION
      Initform: (LAMBDA (SB-IMPL::X SB-IMPL::Y SB-IMPL::Z)
                  (DECLARE (IGNORE SB-IMPL::X SB-IMPL::Y SB-IMPL::Z)))
    SB-IMPL::NEWLINES
      Type: T
      Initform: (MAKE-ARRAY 10 :FILL-POINTER 0 :ADJUSTABLE T)
    SB-IMPL::LAST-NEWLINE
      Type: (INTEGER 0 512)
      Initform: SB-IMPL::+ANSI-STREAM-IN-BUFFER-LENGTH+
    SB-IMPL::FORM-START-BYTE-POS
      Type: T
      Initform: NIL
    SB-IMPL::FORM-START-CHAR-POS
      Type: T
      Initform: NIL

BINARY-OUTPUT-STREAM-P names a generic function:
  Lambda-list: (STREAM)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Does STREAM perform binary output operations?
  Method-combination: STANDARD
  Methods:
    (BINARY-OUTPUT-STREAM-P (FUNDAMENTAL-BINARY-OUTPUT-STREAM))
    (BINARY-OUTPUT-STREAM-P (FUNDAMENTAL-STREAM))
    (BINARY-OUTPUT-STREAM-P (ANSI-STREAM))
  Source file: SYS:SRC;PCL;GRAY-STREAMS.LISP

PACK-CLOSURE-EXTRA-VALUES names a compiled function:
  Lambda-list: (NAME DOCSTRING)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;SIMPLE-FUN.LISP

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

SYMBOLICATE! names a compiled function:
  Lambda-list: (PACKAGE &REST THINGS)
  Derived type: (FUNCTION (T &REST T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

INVALID-ARRAY-ERROR names a compiled function:
  Lambda-list: (ARRAY)
  Declared type: (FUNCTION (ARRAY) NIL)
  Source file: SYS:SRC;CODE;ARRAY.LISP

INVALID-ARRAY-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:INVALID-ARRAY-ERROR>:
  Class precedence-list: SB-INT:INVALID-ARRAY-ERROR, SB-INT:REFERENCE-CONDITION,
                         TYPE-ERROR, ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION, TYPE-ERROR
  No subclasses.
  No direct slots.

*SETF-MACRO-FUNCTION-HOOK* names a special variable:
  Value: (#<FUNCTION SB-DEBUG::MAYBE-RETRACE-FUNCTION>)
  Documentation:
    A list of functions that (SETF MACRO-FUNCTION) invokes before storing thenew
    value. The functions take the macro name and the new value.

ARRAY-BOUNDING-INDICES-BAD-ERROR names a compiled function:
  Lambda-list: (ARRAY START END)
  Declared type: (FUNCTION (T T T) NIL)
  Known attributes: no-verify-arg-count
  Source file: SYS:SRC;CODE;SEQ.LISP

• Called by
  • IRONCLAD::UPDATE-DIGEST-FROM-VECTOR

MIXF names a macro:
  Lambda-list: (PLACE Y)
  Source file: SYS:SRC;CODE;DEFSETFS.LISP

SSET-MEMBER names a compiled function:
  Lambda-list: (ELEMENT SET)
  Declared type: (FUNCTION (SB-INT:SSET-ELEMENT SB-INT:SSET)
                  (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;COMPILER;SSET.LISP

CONSTANTLY-NIL names a compiled function:
  Lambda-list: UNKNOWN
  Derived type: FUNCTION
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

MAKE-GENSYM-LIST names a compiled function:
  Lambda-list: (N &OPTIONAL NAME)
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES LIST &OPTIONAL))
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Called by
  • (FRLOCK-READ)

DELAY names a macro:
  Lambda-list: (FORM)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

DELAY names the structure-class #<STRUCTURE-CLASS SB-INT:DELAY>:
  Class precedence-list: SB-INT:DELAY, CAST, SB-C::VALUED-NODE, SB-C::NODE,
                         SB-INT:SSET-ELEMENT, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CAST
  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::ASSERTED-TYPE
      Type: SB-KERNEL:CTYPE
      Initform: SB-KERNEL:*WILD-TYPE*
    SB-C::TYPE-TO-CHECK
      Type: SB-KERNEL:CTYPE
      Initform: SB-KERNEL:*WILD-TYPE*
    SB-C::%TYPE-CHECK
      Type: (MEMBER T :EXTERNAL NIL)
      Initform: NIL
    SB-C::VALUE
      Type: SB-C::LVAR
      Initform: (SB-INT:MISSING-ARG)
    SB-C::CONTEXT
      Type: T
      Initform: NIL
    SB-C::SILENT-CONFLICT
      Type: (OR BOOLEAN (EQL :STYLE-WARNING))
      Initform: NIL

DX-FLET names a macro:
  Lambda-list: (FUNCTIONS &BODY FORMS)
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Macroexpanded by
  • SB-CAPSTONE::TRY-LOAD-SHARED-OBJECT
  • SB-MPFR::%LOAD-MPFR
  • SB-MPFR::TRY-LOAD-SHARED-OBJECT
  • SB-GMP::%LOAD-GMP
  • SB-GMP::TRY-LOAD-SHARED-OBJECT
  • SB-ACLREPL::REPL-PROMPT-FUN
  • SB-ACLREPL::REMOVE-ALIAS
  • SB-SIMD-INTERNALS:FILTER-FUNCTION-RECORDS
  • SB-SIMD-INTERNALS:SIMD-FUNCTION-RECORD-P
  • SB-SIMD-INTERNALS:SCALAR-FUNCTION-RECORD-P
  • SB-SIMD-INTERNALS:FILTER-VALUE-RECORDS
  • SB-SIMD-INTERNALS::UPDATE-IDISPATCH-INDICES
  • SB-SIMD-INTERNALS::UPDATE-IDISPATCH-INDEX
  • (PRINT-OBJECT (PRINTABLE T))
  • (ROTATE-BYTE)
  • SB-INTROSPECT:MAP-ROOT
  • SB-INTROSPECT::FIND-FUNCTION-DEFINITION-SOURCE
  • SB-INTROSPECT:FIND-DEFINITION-SOURCES-BY-NAME
  • SB-CONCURRENCY:WAIT-ON-GATE
  • SB-CONCURRENCY:CLOSE-GATE
  • SB-CONCURRENCY:OPEN-GATE
  • (PRINT-OBJECT (GATE T))
  • SB-CONCURRENCY:RECEIVE-PENDING-MESSAGES
  • RECEIVE-MESSAGE-NO-HANG
  • SB-CONCURRENCY:RECEIVE-MESSAGE
  • SEND-MESSAGE
  • (PRINT-OBJECT (MAILBOX T))
  • SB-CONCURRENCY:GRAB-FRLOCK-WRITE-LOCK
  • GET-HOST-BY-NAME
  • (SOCKET-PEERSTRING (LOCAL-SOCKET))
  • (SOCKET-NAMESTRING (LOCAL-SOCKET))
  • (SOCKET-PEERSTRING (INET6-SOCKET))
  • (SOCKET-NAMESTRING (INET6-SOCKET))
  • (SOCKET-PEERSTRING (INET-SOCKET))
  • (SOCKET-NAMESTRING (INET-SOCKET))
  • (SOCKET-CLOSE (SOCKET))
  • (SOCKET-SEND (SOCKET T T))
  • (SOCKET-RECEIVE (SOCKET T T))
  • (SOCKET-NAME (SOCKET))
  • (SOCKET-PEERNAME (SOCKET))
  • (SOCKET-CONNECT (SOCKET))
  • (SOCKET-ACCEPT (SOCKET))
  • (SOCKET-BIND (SOCKET))
  • SB-POSIX:GETGRGID
  • SB-POSIX:GETGRNAM
  • SB-POSIX:GETPWUID
  • SB-POSIX:GETPWNAM
  • SB-POSIX:FORK
  • SB-POSIX:STRTOD
  • (PRINT-OBJECT (STRUCTURED-TYPE T))
  • (PRINT-OBJECT (VALUE-SLOT T))
  • ASDF/BACKWARD-INTERFACE:RUN-SHELL-COMMAND
  • ASDF/SOURCE-REGISTRY:VALIDATE-SOURCE-REGISTRY-DIRECTIVE
  • ASDF/SOURCE-REGISTRY::PROCESS-SOURCE-REGISTRY-CACHE
  • (TRIVIAL-SYSTEM-P (SYSTEM))
  • ASDF/FIND-SYSTEM::DEFINITION-DEPENDENCIES-UP-TO-DATE-P
  • (PERFORM (DEFINE-OP SYSTEM))
  • ASDF/OPERATE::RESTART-UPGRADED-ASDF
  • ASDF/PLAN:ACTION-UP-TO-DATE-P
  • (PRINT-OBJECT (FORCING T))
  • ASDF/SYSTEM-REGISTRY:MAP-SYSTEMS
  • ASDF/SYSTEM-REGISTRY:REGISTERED-SYSTEMS*
  • (PRINT-OBJECT (COMPONENT T))
  • UIOP/CONFIGURATION:LOCATION-DESIGNATOR-P
  • UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-DIRECTORY
  • UIOP/LAUNCH-PROGRAM::REQUIRES-ESCAPING-P
  • CHECK-DEFERRED-WARNINGS
  • PRINT-BACKTRACE
  • UIOP/IMAGE:DIE
  • UIOP/STREAM:CALL-WITH-TEMPORARY-FILE
  • UIOP/STREAM:SAFE-FORMAT!
  • UIOP/STREAM:FINISH-OUTPUTS
  • CALL-WITH-SAFE-IO-SYNTAX
  • DELETE-FILE-IF-EXISTS
  • UIOP/FILESYSTEM:TRUENAMIZE
  • SUBDIRECTORIES
  • DIRECTORY-FILES
  • UIOP/FILESYSTEM:FILTER-LOGICAL-DIRECTORY-RESULTS
  • UIOP/FILESYSTEM:PROBE-FILE*
  • UIOP/FILESYSTEM:SAFE-FILE-WRITE-DATE
  • UIOP/FILESYSTEM:TRUENAME*
  • UIOP/PATHNAME:ENSURE-DIRECTORY-PATHNAME
  • UIOP/OS:PARSE-WINDOWS-SHORTCUT
  • FEATUREP
  • (PRINT-OBJECT (DEPRECATED-FUNCTION-CONDITION T))
  • UIOP/UTILITY:MATCH-CONDITION-P
  • ENSURE-FUNCTION
  • UIOP/UTILITY:LOAD-UIOP-DEBUG-UTILITY
  • ENSURE-PACKAGE
  • PACKAGE-DEFINITION-FORM
  • SB-COVER:RESTORE-COVERAGE-FROM-FILE
  • SB-COVER:MERGE-COVERAGE-FROM-FILE
  • SB-COVER:SAVE-COVERAGE-IN-FILE
  • SB-COVER:SAVE-COVERAGE
  • SB-COVER::GET-LOCATIONS
  • SB-COVER::READ-AND-RECORD-SOURCE-MAPS
  • SB-SPROF:START-PROFILING
  • SB-SPROF::PRINT-CYCLES
  • SB-SPROF::COLLECT-NODES
  • (PRINT-OBJECT (CALL T))
  • (PRINT-OBJECT (NODE T))
  • (PRINT-OBJECT (CALL-GRAPH T))
  • SB-SPROF::CALL-WITH-EACH-PROFILE-BUFFER
  • SB-SPROF::MAP-ALL-PC-LOCS
  • SKEL/CLI::START-SKEL
  • SKEL/MPK/CLI::START-MPK
  • (PRINT-OBJECT (METRO T))
  • SKEL/MPK::MPK-MUSIC-METADATA-SCAN-PARALLEL
  • SKEL/MPK:METADATA-SCAN-DIRECTORY
  • SKEL/MPK/MPD:ENSURE-MPD
  • SKEL/HOMER/CLI::START-HOMER
  • (PRINT-OBJECT (HOME-CONFIG T))
  • (PRINT-OBJECT (KRYPT-CONFIG T))
  • SKEL/PACKY/CLI::START-PACKY
  • (PRINT-OBJECT (PACKAGE-ID T))
  • (PRINT-OBJECT (PROJECT-CONTAINERFILE T))
  • SKEL/COMP/shell::PARSE-PKGBUILD-VALUE
  • (PRINT-OBJECT (EMACS-COMPONENT T))
  • (PRINT-OBJECT (PYTHON-SYSTEM T))
  • (PRINT-OBJECT (RUST-SYSTEM T))
  • (PRINT-OBJECT (SKEL-SERVICE T))
  • SKEL/CORE::SK-MULTI-RECIPE-P
  • (PRINT-OBJECT (SKEL-PROJECT T))
  • DSP/AUD:CHROMAPRINT
  • DSP/AV:MEDIA-FILE-STREAM-COUNT
  • DSP/AV:MEDIA-FILE-CODECS
  • DSP/AV:MEDIA-FILE-FORMAT
  • DSP/AV:MEDIA-FILE-METADATA
  • MATH/UTIL::ARCH-EXISTS-P
  • SYSTEM-DOCUMENTATION
  • PACKAGE-DOCUMENTATION
  • READ-FILE-OUTLINE
  • DOC::READ-FILE-HEADLINE
  • (PUBLISH (SYMBOL-DOCUMENTATION))
  • CLASSIFY-SYMBOL
  • FUZZY-MATCH
  • (DBSCAN (DOCUMENT-COLLECTION))
  • (COSINE-SIMILARITY (SEARCH-DOCUMENT SEARCH-DOCUMENT))
  • (DICTIONARY (SEARCH-DOCUMENT))
  • UPDATE-REPO
  • VC/HG::PARSE-HG-URI
  • (PRINT-OBJECT (GIT-REPO T))
  • ORGAN/DB::OG-VALUES
  • ORGAN/GRAPH::EXTRACT-EXTERNAL-NODE
  • (PRINT-OBJECT (ORG-HEADLINE T))
  • ORGAN:UUID-OCTETS*
  • (PRINT-OBJECT (ORGAN-ERROR T))
  • (PRINT-OBJECT (RDB-CONFIG T))
  • (CURSOR-NEXT-NODUP (RDB-DUP-CURSOR))
  • (DELETE-KEY (T RDB-DUP-BTREE))
  • ((SETF GET-VALUE) (T T RDB-DUP-BTREE))
  • (EXISTSP (T RDB-DUP-BTREE))
  • (GET-VALUE (T RDB-DUP-BTREE))
  • (CURSOR-PPREV-NODUP (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PPREV-NODUP)
  • (CURSOR-PNEXT-NODUP (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PNEXT-NODUP)
  • (CURSOR-PNEXT-DUP (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PNEXT-DUP)
  • (CURSOR-PREV-NODUP (RDB-SECONDARY-CURSOR))
  • (CURSOR-NEXT-NODUP (RDB-SECONDARY-CURSOR))
  • (CURSOR-NEXT-DUP (RDB-SECONDARY-CURSOR))
  • (CURSOR-DELETE (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-DELETE)
  • (CURSOR-PGET-BOTH-RANGE (RDB-SECONDARY-CURSOR T T))
  • (BODY IN CURSOR-PGET-BOTH-RANGE)
  • (CURSOR-PGET-BOTH (RDB-SECONDARY-CURSOR T T))
  • (BODY IN CURSOR-PGET-BOTH)
  • (CURSOR-PSET-RANGE (RDB-SECONDARY-CURSOR T))
  • (BODY IN CURSOR-PSET-RANGE)
  • (CURSOR-PSET (RDB-SECONDARY-CURSOR T))
  • (BODY IN CURSOR-PSET)
  • (CURSOR-PPREV (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PPREV)
  • (CURSOR-PNEXT (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PNEXT)
  • (CURSOR-PLAST (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PLAST)
  • (CURSOR-PFIRST (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PFIRST)
  • (CURSOR-PCURRENT (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PCURRENT)
  • (CURSOR-PUT (RDB-CURSOR T))
  • (CURSOR-DELETE (RDB-CURSOR))
  • (CURSOR-GET-BOTH-RANGE (RDB-CURSOR T T))
  • (CURSOR-GET-BOTH (RDB-CURSOR T T))
  • (CURSOR-SET-RANGE (RDB-CURSOR T))
  • (CURSOR-SET (RDB-CURSOR T))
  • (CURSOR-PREV (RDB-CURSOR))
  • (CURSOR-NEXT (RDB-CURSOR))
  • (CURSOR-LAST (RDB-CURSOR))
  • (CURSOR-FIRST (RDB-CURSOR))
  • (CURSOR-CURRENT (RDB-CURSOR))
  • (GET-PRIMARY-KEY (T BTREE-INDEX))
  • (GET-VALUE (T RDB-BTREE-INDEX))
  • (DELETE-KEY (T RDB-INDEXED-BTREE))
  • (BODY IN DELETE-KEY)
  • ((SETF GET-VALUE) (T T RDB-INDEXED-BTREE))
  • (POPULATE (RDB-INDEXED-BTREE T))
  • (BODY IN POPULATE)
  • (DELETE-KEY (T RDB-BTREE))
  • ((SETF GET-VALUE) (T T RDB-BTREE))
  • (EXISTSP (T RDB-BTREE))
  • (BODY IN EXISTSP)
  • (GET-VALUE (T RDB-BTREE))
  • (BODY IN GET-VALUE)
  • (PRINT-OBJECT (RDB T))
  • (PRINT-OBJECT (SST-FILE-WRITER T))
  • NET/SRV/http::WAKE-TCP-SERVICE-FOR-SHUTDOWN
  • (PROCESS-CONNECTION (HTTP-SERVICE T))
  • NET/SRV/http::GET-HTTP-REQUEST-DATA
  • NET/SRV/http::PARSE-PATH
  • (SERVICE-LOG-ACCESS (HTTP-SERVICE))
  • (PROCESS-CONNECTION (UDP-SERVICE T))
  • CALL-WITH-REQUEST-COUNT-INCF
  • (STOP (NET-SERVICE))
  • (ACCEPT (NET-SERVICE))
  • (SERVICE-LOG-MESSAGE (NET-SERVICE T T))
  • (PRINT-OBJECT (NET-SERVICE T))
  • (CREATE-REQUEST-WORKER-THREAD (THREAD-PER-CONNECTION-ENGINE T))
  • WAIT-FOR-FREE-CONNECTION
  • SEND-SERVICE-UNAVAILABLE-RESPONSE
  • RESET-SESSIONS
  • START-SESSION
  • SESSION-GC
  • REMOVE-SESSION
  • NET/REQ::REQ
  • NET/REQ:CLEAR-CONNECTION-POOL
  • NET/REQ::STEAL-CONNECTION
  • NET/REQ::PUSH-CONNECTION
  • (PRINT-OBJECT (LRU-POOL T))
  • (PRINT-OBJECT (LRU-POOL-ELT T))
  • NET/REQ::DECODE-BODY
  • PARSE-SET-COOKIE-HEADER
  • NET/COOKIE::PARSE-COOKIE-DATE
  • (APPLY-HANDLER (DBUS-METHOD-HANDLER DBUS-METHOD-CALL-MESSAGE CONNECTION))
  • (APPLY-HANDLER (DBUS-SIGNAL-HANDLER DBUS-SIGNAL-MESSAGE CONNECTION))
  • (PRINT-OBJECT (DBUS-SIGNAL T))
  • (PRINT-OBJECT (DBUS-PROPERTY T))
  • (PRINT-OBJECT (DBUS-METHOD T))
  • (PRINT-OBJECT (DBUS-INTERFACE T))
  • (PRINT-OBJECT (OBJECT T))
  • (PRINT-OBJECT (STANDARD-SERVER-ADDRESS T))
  • (CONNECT (T LIST))
  • HTTP-MULTIPART-PARSE
  • MAKE-HTTP-PARSER
  • (CALLBACK-NOTIFY)
  • (CALLBACK-DATA)
  • EVAL-REPEATEDLY-ASYNC-STATE
  • NET/PROTO/CREW::RECORD-ASYNC-RESULT
  • NET/PROTO/CREW::ASYNC-RESULTS-LOOP
  • EVAL-FORM-REPEATEDLY
  • NET/PROTO/CREW::RECORD-REPEATED-RESULT
  • NET/PROTO/CREW::FIND-EVAL
  • NET/PROTO/CREW::REMOVE-EVAL
  • NET/PROTO/CREW::ADD-EVAL
  • PARALLEL-REDUCE
  • NET/PROTO/CREW::DISPATCH-WORK
  • NET/PROTO/CREW::ENSURE-CAUGHT-UP-THEN-EVALUATE
  • NET/PROTO/CREW::UNEVALUATED-REPLAY-FORMS
  • NET/PROTO/CREW::ADD-EVALUATED-FORM
  • NET/PROTO/CREW::HANDLE-CONNECTION-CLOSED
  • (WITH-MUTEX-THUNK IN HANDLE-CONNECTION-CLOSED)
  • NET/PROTO/CREW::ALLOCATE-WORKER-AND-EVALUATE
  • NET/PROTO/CREW::FREE-WORKER
  • NET/PROTO/CREW::ALLOCATE-WORKER
  • NET/PROTO/CREW::RECONNECT-WORKERS
  • NET/PROTO/CREW::DISCONNECT-WORKERS
  • (PRINT-OBJECT (CREW-WORKER-POOL T))
  • SLIME-CLOSE
  • NET/PROTO/SWANK::SLIME-DISPATCH-EVENTS
  • SLIME-EVAL
  • NET/PROTO/SWANK::SLIME-NET-READ
  • NET/PROTO/SWANK::SLIME-DISPATCH-EVENT
  • NET/PROTO/SWANK::SLIME-NET-CONNECT
  • NET/PROTO/SWANK::SLIME-SEND
  • NET/PROTO/SWANK::SLIME-NET-SEND
  • NET/PROTO/SWANK::FIND-CONNECTION-FOR-THREAD-ID
  • NET/PROTO/SWANK::REMOVE-OPEN-CONNECTION
  • NET/PROTO/SWANK::ADD-OPEN-CONNECTION
  • HOSTNAME
  • RESOLVE
  • NET/PROTO/DNS::TRY-SERVER
  • (INTROSPECTION-DOCUMENT (CHILD-OBJECT-MIXIN))
  • (COLLECT-HANDLERS-BY-INTERFACE (DBUS-OBJECT))
  • (PRINT-OBJECT (DBUS-STANDARD-MESSAGE T))
  • NET/CODEC/DBUS::VALID-BODY-P
  • NET/CODEC/DBUS::VALID-DICT-ENTRY-P
  • NET/CODEC/DBUS::VALID-STRUCT-P
  • NET/CODEC/DBUS::VALID-ARRAY-P
  • NET/CODEC/DBUS::VALID-SIGNATURE-P
  • (PRINT-OBJECT (DBUS-TYPE T))
  • NET/CORE::PORT-OPEN-P
  • INSTALL-REPL
  • FORMEDIT
  • LINEDIT
  • CLI/LINEDIT::CHECK-LOGICAL-PATHNAME
  • CLI/LINEDIT::EOF-HANDLER
  • (PRINT-OBJECT (TERMINFO T))
  • CLI/SPARK::AT-LEAST-TWO-CHARS-P
  • UPDATE!
  • CRY/TLS::VALIDATE-VERIFY-LOCATION
  • (STREAM-READ-SEQUENCE (SSL-STREAM T))
  • (STREAM-READ-BYTE (SSL-STREAM))
  • (PRINT-OBJECT (SSL-STREAM T))
  • CRY/TLS:ENSURE-SSL
  • (INIT ((EQL SSL)))
  • PARSE/YACC::PRINT-ACTION
  • PARSE/YACC::PRINT-GOTO-GRAPH
  • PARSE/YACC::PRINT-STATES
  • PARSE/YACC::PRINT-KERNEL
  • PARSE/YACC::PRINT-ITEM
  • PARSE/YACC::SEQUENCE-DERIVES-EPSILON
  • PARSE/YACC::DERIVES-EPSILON*
  • PARSE/YACC::PRINT-PRODUCTION
  • PARSE/BYTES::CHECK-MATCH-CASES
  • PARSE/BYTES::CHECK-SKIP-ELEMS
  • (PRINT-OBJECT (FLAMEGRAPH-NODE T))
  • (POST-PROCESS-ARG (SEQUENCE))
  • (POST-PROCESS-ARG (T))
  • RT/TRACING::%TRACE-START-BREAKPOINT-FUN
  • RT::DO-TESTS-CONCURRENTLY
  • (PRINT-OBJECT (TEST-SUITE T))
  • (PRINT-OBJECT (TEST T))
  • (PRINT-OBJECT (TEST-OBJECT T))
  • (PRINT-OBJECT (TEST-RESULT T))
  • DAT/TTF:CACHE-FONT-FILE
  • DAT/TTF::ARRANGE-FINALIZATION
  • (PRINT-OBJECT (GLYPH T))
  • (PRINT-OBJECT (CONTROL-POINT T))
  • (PRINT-OBJECT (NAME-ENTRY T))
  • (PRINT-OBJECT (TABLE-INFO T))
  • DAT/GIF::STREAM-POSITION
  • (PRINT-OBJECT (MIDI-MESSAGE T))
  • (PRINT-OBJECT (TAR-ENTRY T))
  • DAT/TAR::MAKE-COMPRESSION-STREAM
  • DAT/TAR::DETECT-TYPE
  • DAT/TAR::INJECTOR-FUNCTION-NAME
  • DAT/TAR::EXTRACTOR-FUNCTION-NAME
  • (PRINT-OBJECT (ARFF T))
  • DAT/TOML::TOML-PARSE-DATETIME
  • DAT/TOML::TOML-READ-NUMBER-OR-DATETIME
  • (PRINT-OBJECT (TOML-OBJECT T))
  • DAT/INI::DESKTOP-ENTRY-IN-CATEGORIES-P
  • DAT/HTML::SAME-CASE-P
  • DAT/HTML::ESCAPE-CHAR-P
  • DAT/HTML:XML-ESCAPE-NAME
  • (%PROCESS-CHARACTERS ((EQL IN-BODY) T))
  • (PRINT-OBJECT (TEXT-NODE T))
  • (PRINT-OBJECT (NODE T))
  • (PRINT-OBJECT (DOCUMENT T))
  • DAT/SVG:PARSE-SVG-STRING
  • DAT/XML:XML-PARSE
  • (JSON-WRITE (AST))
  • (JSON-WRITE (HASH-TABLE))
  • (JSON-WRITE (LIST))
  • (JSON-WRITE (VECTOR))
  • (PRINT-OBJECT (JSON-OBJECT T))
  • DAT/CSV::PARSE-NUMBER-NO-ERROR
  • DAT/ASN1::ASN1-TELETEX-STRING-P
  • DAT/ASN1::ASN1-PRINTABLE-STRING-P
  • DAT/ASN1::ASN1-IASTRING-P
  • (PRINT-OBJECT (IMAGE-STREAM T))
  • (PRINT-OBJECT (IMAGE T))
  • (PRINT-OBJECT (CANVAS T))
  • LOG-PIPE
  • (MSG (LOGGER T))
  • LOG::LOGGER-LOOP
  • (PRINT-OBJECT (LOGGER T))
  • LOG::LOG-SYNC
  • (HARVEST-EVENTS (EPOLL-MULTIPLEXER T))
  • (UNMONITOR-FD (EPOLL-MULTIPLEXER T))
  • (UPDATE-FD (EPOLL-MULTIPLEXER T T T))
  • (MONITOR-FD (EPOLL-MULTIPLEXER T))
  • (PRINT-OBJECT (EPOLL-MULTIPLEXER T))
  • IO/KBD:GET-KEYBOARDS
  • (PRINT-OBJECT (BZIP2-STATE T))
  • (PRINT-OBJECT (INFLATE-STATE T))
  • (INITIALIZE-INSTANCE AFTER (BLOCK-STREAM))
  • DELETE-STREAM-FILE
  • IO/STATIC::CANONICALIZE-ARGS
  • (INITIALIZE-INSTANCE AFTER (PEEKING-INPUT-STREAM))
  • IO/SOCKET::GET-INTERFACE-BY-NAME
  • IO/SOCKET::GET-INTERFACE-BY-INDEX
  • IO/SYS:WAIT-UNTIL-FD-READY
  • (PRINT-OBJECT (IO-TIMER T))
  • OBJ/CACHE::MAP-CACHE
  • (UPGRADE-ALL-MEMORY-INSTANCES (STORE))
  • (EMPTYP (BTREE))
  • OBJ/STORE::GET-UNIQUE-VALUES
  • (UNCACHE-STORE-SCHEMA (STORE T))
  • (UPDATE-STORE-SCHEMA (STORE T))
  • (GET-STORE-SCHEMA (STORE T))
  • (DROP-INSTANCE (STORED))
  • (STORE-RECREATE-INSTANCE (STORE T))
  • (PRINT-OBJECT (STORE T))
  • (PRINT-OBJECT (STORED-OBJECT-SCHEMA T))
  • (PRINT-OBJECT (SECRET T))
  • (PRINT-OBJECT (PROJECT-COMPONENT T))
  • (PRINT-OBJECT (SIMPLE-RULE T))
  • (PRINT-OBJECT (RULE T))
  • (PRINT-OBJECT (PROJECT T))
  • (PRINT-OBJECT (PROJECT-METADATA T))
  • (PRINT-OBJECT (UPGRADABLE-SCHEMA T))
  • (PRINT-OBJECT (OBJECT-SCHEMA T))
  • (PRINT-OBJECT (SIMPLE-SCHEMA T))
  • (PRINT-OBJECT (SCHEMA T))
  • (PRINT-OBJECT (TIMEZONE T))
  • REREAD-TIMEZONE-REPOSITORY
  • BASE-COLOR-PALETTE-P
  • OBJ/BTREE::MAP-INDEX-FROM-END
  • OBJ/BTREE::MAP-INDEX-FROM-START
  • MAP-INDEX-VALUES
  • OBJ/BTREE::MAP-BTREE-FROM-END
  • OBJ/BTREE::MAP-BTREE-FROM-START
  • OBJ/BTREE::MAP-BTREE-VALUES
  • OBJ/BTREE::COMPARE-EQUAL
  • OBJ/BTREE::COMPARE<
  • OBJ/BTREE::COMPARE<=
  • (DROP-BTREE (BTREE))
  • (REMOVE-KV (T T DUP-BTREE))
  • (PRINT-OBJECT (PERMUTATION T))
  • (PRINT-OBJECT (GRAPH-ACCESSOR T))
  • OBJ/TENSOR::COERCEABLE?
  • REWRITE-URLS
  • OBJ/URL::READ-ATTRIBUTE
  • OBJ/URL::READ-DELIMITED-STRING
  • OBJ/URL::READ-UNTIL
  • OBJ/URL::READ-WHILE
  • URL-ENCODE-PARAMS
  • (PRINT-OBJECT (ID T))
  • OBJ/META/MIX::DEFINE-MIXIN
  • OBJ/META/STORED::GEN-DERIVED-FN-WRAPPER
  • OBJ/META/STORED::GEN-DERIVED-SYM-WRAPPER
  • OBJ/META/STORED::COMPILE-DERIVED-FN
  • OBJ/META/STORED::CACHED-SLOT-SPECIFICATION-P
  • OBJ/META/STORED::SUPERCLASS-MEMBER-P
  • OBJ/META/STORED::ENSURE-CLASS-INHERITS-FROM
  • (OPTIMIZE-FUNCTION-CALL (FAST-GENERIC-FUNCTION STATIC-CALL-SIGNATURE))
  • (REINITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (INITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (EXTERNALIZABLE-OBJECT-P (STATIC-CALL-SIGNATURE))
  • (PRINT-OBJECT (STATIC-CALL-SIGNATURE T))
  • OBJ/META/SEALED::TYPE-PROTOTYPE-PAIRS
  • (SPECIALIZER-PROTOTYPE (CLASS))
  • (METAOBJECT-SEALABLE-P (POTENTIALLY-SEALABLE-METHOD))
  • (SHARED-INITIALIZE (SEALABLE-METAOBJECT-MIXIN (EQL T)))
  • (DOMAIN-SUBSETP (DOMAIN DOMAIN))
  • (DOMAIN-INTERSECTIONP (DOMAIN DOMAIN))
  • (DOMAIN-EQUAL (DOMAIN DOMAIN))
  • (PRINT-OBJECT (DOMAIN T))
  • TREE-SITTER:LIST-TS-LANGS
  • SWANK-MACROSTEP::COLLECT-MACRO-FORMS-IN-CONTEXT
  • SWANK-MACROSTEP::MACROEXPAND-1-IN-CONTEXT
  • SWANK-MACROSTEP:MACRO-FORM-P
  • (PRINT-OBJECT (TRACE-ENTRY T))
  • SWANK-MREPL::SPAWN-LISTENER-THREAD
  • SWANK::MACRO-INDENTATION
  • (MENU-CHOICES-FOR-PRESENTATION (PATHNAME))
  • SWANK:LOOKUP-PRESENTED-OBJECT
  • SWANK::MAKE-FILE-STREAM-ISPEC
  • (EMACS-INSPECT (INTEGER))
  • (MAKE-SYMBOLS-LISTING ((EQL CLASSIFICATION) T))
  • SWANK::INSPECT-TYPE-SPECIFIER
  • SWANK::PRINT-VARIABLE-TO-STRING
  • SWANK::EXTRA-KEYWORDS/CHANGE-CLASS
  • SWANK::EXTRA-KEYWORDS/MAKE-INSTANCE
  • SWANK::CLASS-FROM-CLASS-NAME-FORM
  • SWANK::DECODED-ARGLIST-TO-TEMPLATE-STRING
  • SWANK::DECODED-ARGLIST-TO-STRING
  • SWANK::PRINT-DECODED-ARGLIST-AS-TEMPLATE
  • SWANK::PRINT-DECODED-ARGLIST
  • SWANK::EXTENDED-AUTODOC-OPERATOR-P
  • SWANK::TRANSPOSE-LISTS
  • SWANK::MAKE-COMPOUND-PREFIX-MATCHER
  • SWANK::DETERMINE-CASE
  • SWANK::COMPLETION-OUTPUT-SYMBOL-CONVERTER
  • SWANK::COMPLETION-OUTPUT-CASE-CONVERTER
  • SWANK-REPL::REPL-LOOP
  • SWANK-REPL::MAKE-OUTPUT-FUNCTION
  • SWANK-REPL::OPEN-STREAMS
  • CLASSIFY-SYMBOL
  • SWANK:FLOW-CONTROL-TEST
  • SWANK:MAKE-OUTPUT-FUNCTION-FOR-TARGET
  • SWANK::INDENTATION-CACHE-LOOP
  • SWANK:DEBUG-NTH-THREAD
  • (EMACS-INSPECT (HASH-TABLE))
  • SWANK:XREF
  • SWANK:PROFILE-BY-SUBSTRING
  • SWANK:OPERATOR-ARGLIST
  • SWANK::FIND-SWANK-MODULE
  • SWANK::FRAME-TO-STRING
  • SWANK::FORMAT-RESTARTS-FOR-EMACS
  • SWANK::%%CONDITION-MESSAGE
  • SWANK::SLDB-LOOP
  • SWANK:SWANK-DEBUGGER-HOOK
  • SWANK:INVOKE-SLIME-DEBUGGER
  • SWANK:INSPECT-IN-EMACS
  • SWANK:ED-IN-EMACS
  • SWANK::TO-LINE
  • SWANK::FORMAT-VALUES-FOR-ECHO-AREA
  • SWANK::PARSE-PACKAGE
  • SWANK:TO-STRING
  • (PRINT-OBJECT (UNREADABLE-RESULT T))
  • SWANK::READ-NON-BLOCKING
  • SWANK::SIMPLE-REPL
  • SWANK::SIMPLE-SERVE-REQUESTS
  • SWANK::DISPATCH-INTERRUPT-EVENT
  • SWANK::CLEANUP-CONNECTION-THREADS
  • SWANK::EVENT-MATCH-P
  • SWANK::SPAWN-WORKER-THREAD
  • SWANK::READ-LOOP
  • SWANK::CLOSE-CONNECTION%
  • SWANK::HANDLE-REQUESTS
  • SWANK::DECODE-MESSAGE
  • SWANK::ACCEPT-CONNECTIONS
  • SWANK::SOCKET-QUEST
  • SWANK::%STOP-SERVER
  • SWANK::ASCII-STRING-P
  • SWANK::LOG-EVENT
  • SWANK::SAFE-BACKTRACE
  • SWANK/RPC::PRIN1-TO-STRING-FOR-EMACS
  • SWANK/RPC::ENCODING-ERROR
  • SWANK/RPC:WRITE-MESSAGE
  • SWANK/RPC::READ-FORM
  • SWANK/RPC:READ-PACKET
  • SWANK/RPC:READ-MESSAGE
  • SWANK/SBCL::SBCL-VERSION>=
  • (EXEC-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (FIND-REGISTERED IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (REGISTER-THREAD IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (RECEIVE-IF IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (SEND IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (WAKE-THREAD IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::MAILBOX
  • (CALL-WITH-LOCK-HELD IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (PROFILED-FUNCTIONS IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::CODE-LOCATION-HAS-DEBUG-BLOCK-INFO-P
  • (FRAME-CALL IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::DEFINITION-SOURCE-FILE-LOCATION
  • (SWANK-COMPILE-STRING IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::COMPILER-NOTE-LOCATION
  • ACCEPT
  • SWANK/SBCL::SIGIO-HANDLER
  • (INSTALL-SIGINT-HANDLER IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (BUFFER-FIRST-CHANGE IN /home/ellis/src/core/lib/swank/source-file-cache.lisp)
  • SWANK/SOURCE-PATH-PARSER::CHECK-SOURCE-PATH
  • SWANK/SOURCE-PATH-PARSER::READ-AND-RECORD-SOURCE-MAP
  • SWANK/SOURCE-PATH-PARSER::MAKE-SOURCE-RECORDING-READTABLE
  • SWANK/SOURCE-PATH-PARSER::MAKE-SHARPDOT-READER
  • (DEFIMPLEMENTATION)
  • (DEFINTERFACE)
  • SWANK::HANDLE-SWANK-LOAD-ERROR
  • IRONCLAD:PBKDF2-HASH-PASSWORD-TO-COMBINED-STRING
  • (PRNG-RANDOM-DATA (T OS-PRNG))
  • IRONCLAD::FEED-FIFO
  • (PRINT-OBJECT (HMAC T))
  • (PRINT-OBJECT (ENCRYPTION-MODE T))
  • (MAKE-CIPHER)
  • IRONCLAD::%DEFCIPHER
  • (PRINT-OBJECT (CIPHER-INFO T))
  • (DWORD-INST)
  • STD/DEFSYS::COMPONENT-RECOMPILE-P
  • STD/DEFSYS::COMPONENT-RELOAD-P
  • (PRINT-OBJECT (TEST-SYSTEM T))
  • (PRINT-OBJECT (SYSTEM T))
  • STD/DEFSYS::%LOAD-PROTO
  • STD/DEFSYS::FIND-SUBMODULE
  • (PRINT-OBJECT (COMPONENT T))
  • STD/OS::%GET-FILE-KIND
  • LIST-ALL-GROUPS
  • LIST-ALL-USERS
  • STD/PRINT::ROTATE-ROWS-TO-COLUMNS
  • (PRINT-OBJECT (JOB T))
  • (PRINT-OBJECT (TASK T))
  • (DEFPTYPED)
  • (DEFPUN)
  • STD/ASYNC::DELETE-REGISTERED-NAMES
  • STD/ASYNC::SYMBOLICATE/NO-INTERN
  • STD/ASYNC::REPLACE-ERROR
  • AWAIT
  • (MSG (VECTOR SYNC-MESSAGE))
  • (PRINT-OBJECT (THREAD-POOL T))
  • STD/THREAD::FILL-WORKERS
  • STD/THREAD::REPLACE-WORKER
  • UPDATE-LIMITER-COUNT
  • FIND-WORK
  • STD/THREAD::MAYBE-WAKE-WORKER
  • (PRINT-OBJECT (WORKER T))
  • STD/THREAD::KILL-ERRORS
  • STD/THREAD::REMOVE-THREAD-WRAPPER
  • (THREAD-WRAPPER)
  • STD/THREAD::%GET-THREAD-WRAPPER
  • STD/THREAD::PROCESS-ALL-INTERRUPTS
  • KILL-THREAD
  • TIMED-JOIN-THREAD
  • STD/THREAD::CALL-WITH-TRACKED-ERROR
  • STD/SEQ::CALL-WITH-VECTOR-QUEUE-LOCK
  • STD/SEQ::CALL-WITH-CONS-QUEUE-LOCK
  • (PRINT-OBJECT (PQUEUE T))
  • (PRINT-OBJECT (FIB-HEAP T))
  • (PRINT-OBJECT (HNODE T))
  • PEEK-CONS-QUEUE
  • CONS-QUEUE-EMPTY-P
  • STD/SEQ::CONS-QUEUE-COUNT
  • STD/SEQ::TRY-POP-CONS-QUEUE
  • POP-CONS-QUEUE
  • PUSH-CONS-QUEUE
  • STD/SEQ::PEEK-VECTOR-QUEUE
  • STD/SEQ::VECTOR-QUEUE-FULL-P
  • STD/SEQ::VECTOR-QUEUE-EMPTY-P
  • STD/SEQ::VECTOR-QUEUE-COUNT
  • STD/SEQ::POP-VECTOR-QUEUE
  • STD/SEQ::PUSH-VECTOR-QUEUE
  • STARTS-WITH-ONE-OF-P
  • CHECK-DEFERRED-WARNINGS
  • STD/COMP::%CHECKED-COMPILE-AND-ASSERT-ONE-CASE
  • STD/ALIEN::C-NAME-FROM-LISP
  • (PRINT-OBJECT (MESSAGE T))
  • (MOVE-ELEMENT (PIPE T T))
  • (INSERT-ELEMENT (PIPE ELEMENT T))
  • (INSERT-ELEMENT (PIPE ARRAY T))
  • (REMOVE-ELEMENT (PIPE T))
  • SLOT-BOUNDP*
  • STD/PPCRE::PRINT-SYMBOL-INFO
  • (PRINT-OBJECT (STR T))
  • (PRINT-OBJECT (REGISTER T))
  • (PRINT-OBJECT (REPETITION T))
  • STD/PPCRE::PARSE-REGISTER-NAME-AUX
  • DISJOIN
  • ASCII-ISTRING=
  • STD/STRING::ALL-EQUAL
  • ENSURE-NUMBER
  • ENSURE-INTEGER
  • (PRINT-OBJECT AROUND (READTABLE T))
  • STD/NAMED-READTABLES::%MAKE-READTABLE-ITERATOR
  • STD/NAMED-READTABLES::DISPATCH-MACRO-CHAR-P
  • STD/NAMED-READTABLES::%LIST-ALL-READTABLE-NAMES
  • (PRINT-OBJECT (FUNCALLABLE-STANDARD-OBJECT T))
  • CALL-WITH-SAFE-IO-SYNTAX
  • ZIP-TREE
  • FORMAT-SYMBOL
  • GET-BACKTRACE
  • STD/CONDITION::CALL-WITH-IF-FAILED-HANDLER
  • (DEFERROR)
  • ENSURE-PACKAGE
  • PACKAGE-DEFINITION-FORM

SINGLETON-P names a compiled function:
  Lambda-list: (LIST)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Called by
  • SB-COVER::GET-RECORDS
  • SB-COVER::UNPACK-PAIR
  • (CALL (THREAD-POOL T))

INITIAL-ELEMENT-MISMATCH-STYLE-WARNING names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:INITIAL-ELEMENT-MISMATCH-STYLE-WARNING>:
  Class precedence-list: SB-INT:INITIAL-ELEMENT-MISMATCH-STYLE-WARNING,
                         SB-INT:ARRAY-INITIAL-ELEMENT-MISMATCH,
                         SB-INT:REFERENCE-CONDITION, SIMPLE-WARNING,
                         SIMPLE-STYLE-WARNING, SIMPLE-CONDITION, STYLE-WARNING,
                         WARNING, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:ARRAY-INITIAL-ELEMENT-MISMATCH,
                       SIMPLE-STYLE-WARNING
  No subclasses.
  No direct slots.

DO-PACKED-VARINTS names a macro:
  Lambda-list: ((LOC LOCS &OPTIONAL (BYTEPOS NIL)) &BODY BODY)
  Source file: SYS:SRC;CODE;DEBUG-VAR-IO.LISP

HASHSET-REMOVE names a compiled function:
  Lambda-list: (HASHSET KEY)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;HASHSET.LISP

• Called by
  • UNINTERN-URI

CALL-HOOKS names a compiled function:
  Lambda-list: (KIND HOOKS &KEY (ON-ERROR ERROR))
  Derived type: (FUNCTION (T T &KEY (:ON-ERROR T)) (VALUES NULL &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-EXTENSIONS.LISP

ESCAPE-CHAR-CODE names a constant variable:
  Value: 27

DOUBLE-FLOAT-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
  • COERCE
  • SB-MPFR:COMPARE
  • DIV
  • SB-MPFR:MUL
  • SB-MPFR:SUB
  • SB-MPFR:ADD
  • SB-SIMD-NEON:F64.2!
  • SB-SIMD-AVX:F64.4!
  • SB-SIMD-AVX:F64.2!
  • SB-SIMD-SSE2:F64.2!
  • SB-SIMD-AVX:F64
  • SB-SIMD-AVX:F32
  • SB-SIMD-SSE2:F64
  • SB-SIMD-SSE:F32
  • SB-SIMD:F64
  • SB-SIMD:F32
  • OBJ/BTREE::COMPARE<
  • OBJ/BTREE::COMPARE<=
  • SWANK/RPC::SWITCH-TO-DOUBLE-FLOATS
  • STD/TYPE::GET-TYPE-ID
  • POSITIVE-LONG-FLOAT-P
  • NON-NEGATIVE-LONG-FLOAT-P
  • NON-POSITIVE-LONG-FLOAT-P
  • NEGATIVE-LONG-FLOAT-P
  • POSITIVE-DOUBLE-FLOAT-P
  • NON-NEGATIVE-DOUBLE-FLOAT-P
  • NON-POSITIVE-DOUBLE-FLOAT-P
  • NEGATIVE-DOUBLE-FLOAT-P

SBCL-HOMEDIR-PATHNAME names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;FILESYS.LISP

%FIND-PACKAGE-OR-LOSE names a compiled function:
  Lambda-list: (PACKAGE-DESIGNATOR)
  Derived type: (FUNCTION (T) (VALUES PACKAGE &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

%SIMPLE-ERROR names a compiled function:
  Lambda-list: UNKNOWN
  Declared type: (FUNCTION
                  ((OR STRING FUNCTION SYMBOL CONDITION
                       SB-PCL::CONDITION-CLASS)
                   T &REST T)
                  NIL)
  Derived type: FUNCTION
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;COLD-ERROR.LISP

EXTRACT-VAR-DECLS names a compiled function:
  Lambda-list: (DECLS SYMBOLS)
  Derived type: (FUNCTION (T T) (VALUES LIST T &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

SSET-DELETE names a compiled function:
  Lambda-list: (ELEMENT SET)
  Declared type: (FUNCTION (SB-INT:SSET-ELEMENT SB-INT:SSET)
                  (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;COMPILER;SSET.LISP

SYSTEM-PACKAGE-P names a macro:
  Lambda-list: (PACKAGE)
  Source file: SYS:SRC;CODE;PACKAGE.LISP

MAKE-STDIO-FILE names a compiled function:
  A constructor for SB-INT:STDIO-FILE
  Lambda-list: (SAP &AUX
                (FD
                 (LET ((FILENO
                        (ALIEN-FUNCALL
                         (EXTERN-ALIEN sb_fileno
                                       (FUNCTION INT SYSTEM-AREA-POINTER))
                         SAP)))
                   FILENO)))
  Derived type: (FUNCTION (SB-SYS:SYSTEM-AREA-POINTER)
                 (VALUES SB-INT:STDIO-FILE &OPTIONAL))
  Source file: SYS:SRC;CODE;FD-STREAM.LISP

SYS-TLAB-ADJOIN-EQ names a compiled function:
  Lambda-list: (ITEM LIST)
  Derived type: (FUNCTION (T T) (VALUES CONS &OPTIONAL))
  Source file: SYS:SRC;CODE;LIST.LISP

FAST-READ-BYTE-REFILL names a compiled function:
  Lambda-list: (STREAM EOF-ERROR-P EOF-VALUE)
  Derived type: (FUNCTION (T T T) *)
  Source file: SYS:SRC;CODE;STREAM.LISP

+INFOS-PER-WORD+ names a constant variable:
  Value: 10

LL-KWDS-ALLOWP names a compiled function:
  Lambda-list: (BITS)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;COMPILER;PARSE-LAMBDA-LIST.LISP

ABOUT-TO-MODIFY-SYMBOL-VALUE names a compiled function:
  Lambda-list: (SYMBOL ACTION &OPTIONAL (NEW-VALUE NIL VALUEP) BIND)
  Declared type: (FUNCTION (SYMBOL T &OPTIONAL T T) (VALUES NULL &OPTIONAL))
  Source file: SYS:SRC;CODE;SYMBOL.LISP

• Called by
  • SB-CLTL2::WALK-COMPILER-LET
  • SB-CLTL2::IR1-CONVERT-COMPILER-LET
  • SWANK::CALL-WITH-BINDINGS

C-STRING-ENCODING-ERROR names a compiled function:
  Lambda-list: (EXTERNAL-FORMAT CODE)
  Derived type: (FUNCTION (T T) NIL)
  Source file: SYS:SRC;CODE;FD-STREAM.LISP

C-STRING-ENCODING-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:C-STRING-ENCODING-ERROR>:
  Class precedence-list: SB-INT:C-STRING-ENCODING-ERROR,
                         CHARACTER-ENCODING-ERROR, CHARACTER-CODING-ERROR,
                         ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CHARACTER-ENCODING-ERROR
  No subclasses.
  No direct slots.

SET-FLOATING-POINT-MODES names a compiled function:
  Lambda-list: (&KEY (TRAPS NIL TRAPS-P) (ROUNDING-MODE NIL ROUND-P)
                (CURRENT-EXCEPTIONS NIL CURRENT-X-P)
                (ACCRUED-EXCEPTIONS NIL ACCRUED-X-P)
                (FAST-MODE NIL FAST-MODE-P))
  Derived type: (FUNCTION
                 (&KEY (:TRAPS T) (:ROUNDING-MODE T) (:CURRENT-EXCEPTIONS T)
                  (:ACCRUED-EXCEPTIONS T) (:FAST-MODE T))
                 (VALUES &OPTIONAL))
  Documentation:
    This function sets options controlling the floating-point
    hardware. If a keyword is not supplied, then the current value is
    preserved. Possible keywords:
    
     :TRAPS
       A list of the exception conditions that should cause traps.
       Possible exceptions are :UNDERFLOW, :OVERFLOW, :INEXACT, :INVALID,
      :DIVIDE-BY-ZERO, and on the X86 :DENORMALIZED-OPERAND.
    
    :ROUNDING-MODE
       The rounding mode to use when the result is not exact. Possible
       values are :NEAREST, :POSITIVE-INFINITY, :NEGATIVE-INFINITY and
       :ZERO.  Setting this away from :NEAREST is liable to upset SBCL's
       maths routines which depend on it.
    
    :CURRENT-EXCEPTIONS
    :ACCRUED-EXCEPTIONS
       These arguments allow setting of the exception flags. The main
       use is setting the accrued exceptions to NIL to clear them.
    
    :FAST-MODE
       Set the hardware's "fast mode" flag, if any. When set, IEEE
       conformance or debuggability may be impaired. Some machines don't
       have this feature, and some SBCL ports don't implement it anyway
       -- in such cases the value is always NIL.
    
    :PRECISION (x86 only)
      :24-bit, :53-bit and :64-bit, for the internal precision of the mantissa.
    
    GET-FLOATING-POINT-MODES may be used to find the floating point modes
    currently in effect. SAVE-LISP-AND-DIE preserves the floating point modes
    in effect.
  Source file: SYS:SRC;CODE;FLOAT-TRAP.LISP

CHARACTER-OUTPUT-STREAM-P names a generic function:
  Lambda-list: (STREAM)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Does STREAM perform character output operations?
  Method-combination: STANDARD
  Methods:
    (CHARACTER-OUTPUT-STREAM-P (FUNDAMENTAL-CHARACTER-OUTPUT-STREAM))
    (CHARACTER-OUTPUT-STREAM-P (FUNDAMENTAL-STREAM))
    (CHARACTER-OUTPUT-STREAM-P (ANSI-STREAM))
  Source file: SYS:SRC;PCL;GRAY-STREAMS.LISP

FORM-FEED-CHAR-CODE names a constant variable:
  Value: 12

CONSTANTLY-T names a compiled function:
  Lambda-list: UNKNOWN
  Derived type: FUNCTION
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Called by
  • UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS
  • DAT/TTF:CACHE-FONT-FILE
  • SWANK:LOOKUP-PRESENTED-OBJECT
  • SWANK:EVAL-FOR-EMACS
  • STD/COMP::CALL-CAPTURING-VALUES-AND-CONDITIONS
  • STD/PPCRE::PRINT-SYMBOL-INFO

HASHSET-FIND names a compiled function:
  Lambda-list: (HASHSET KEY)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;HASHSET.LISP

• Called by
  • (INTERN-URI (URI))

CONSTANTLY-0 names a compiled function:
  Lambda-list: UNKNOWN
  Derived type: FUNCTION
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

%HASH-TABLE-ALIST names a compiled function:
  Lambda-list: (HASH-TABLE)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-HASH-TABLE.LISP

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

ALLOC-XSET names a compiled function:
  A constructor for SB-INT:XSET
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES SB-INT:XSET &OPTIONAL))
  Source file: SYS:SRC;CODE;XSET.LISP

• Called by
  • SB-INTROSPECT:MAP-ROOT

PCL-METHODFN-NAME-P names a macro:
  Lambda-list: (NAME)
  Source file: SYS:SRC;COMPILER;INFO-VECTOR.LISP

COMPILER-MACRO-KEYWORD-PROBLEM names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:COMPILER-MACRO-KEYWORD-PROBLEM>:
  Class precedence-list: SB-INT:COMPILER-MACRO-KEYWORD-PROBLEM, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CONDITION
  No subclasses.
  Direct slots:
    SB-KERNEL::ARGUMENT
      Initargs: :ARGUMENT
      Readers: SB-KERNEL::COMPILER-MACRO-KEYWORD-ARGUMENT

FIND-UNDELETED-PACKAGE-OR-LOSE names a compiled function:
  Lambda-list: (PACKAGE-DESIGNATOR)
  Declared type: (FUNCTION ((OR STRING SYMBOL CHARACTER PACKAGE))
                  (VALUES PACKAGE &OPTIONAL))
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • ENSURE-PACKAGE
  • DELETE-PACKAGE*
  • SB-SPROF:PROFILE-CALL-COUNTS
  • SKEL/CLI::START-SKEL
  • SKEL/MPK/CLI::START-MPK
  • SKEL/HOMER/CLI::START-HOMER
  • SKEL/PACKY/CLI::START-PACKY
  • PACKAGE-DOCUMENTATION
  • CLI/LINEDIT::LISP-COMPLETE
  • (EMACS-INSPECT (PACKAGE))
  • SWANK::FUZZY-FIND-MATCHING-SYMBOLS
  • SWANK::FIND-MATCHING-SYMBOLS
  • SWANK::UPDATE-INDENTATION/DELTA-FOR-EMACS
  • SWANK:PROFILE-BY-SUBSTRING
  • SWANK::MATCHING-SYMBOLS
  • SWANK/BACKEND:IMPORT-SWANK-MOP-SYMBOLS
  • PACKAGE-SYMBOLS
  • PACKAGE-SYMBOLS-EXCEPT
  • ENSURE-PACKAGE
  • DELETE-PACKAGE*
  • REEXPORT-PACKAGES
  • EXPORT-PACKAGES

PACKED-INFO-INSERT names a compiled function:
  Lambda-list: (INPUT AUX-KEY INFO-NUMBER VALUE)
  Derived type: (FUNCTION (SB-INT:PACKED-INFO T (UNSIGNED-BYTE 6) T)
                 (VALUES SB-INT:PACKED-INFO &OPTIONAL))
  Source file: SYS:SRC;COMPILER;INFO-VECTOR.LISP

UNENCAPSULATE names a compiled function:
  Lambda-list: (NAME TYPE)
  Derived type: (FUNCTION (T T) *)
  Documentation:
    Removes NAME's encapsulation of the specified TYPE if such exists.
  Source file: SYS:SRC;CODE;FDEFINITION.LISP

• Called by
  • (UNWRAP IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (WRAP IN /home/ellis/src/core/lib/swank/sbcl.lisp)

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

• Called by
  • (DEFINE-SOCKET-OPTION)
  • SB-COVER::PRESERVE-SHARP-DOT-IN-SHARP-PLUS-MINUS
  • CLI/shell::PLAIN-SHELL-READER
  • SWANK/SBCL::MAKE-SOCKET-IO-STREAM

COMPILED-PROGRAM-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:COMPILED-PROGRAM-ERROR>:
  Class precedence-list: SB-INT:COMPILED-PROGRAM-ERROR, PROGRAM-ERROR, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: PROGRAM-ERROR
  No subclasses.
  Direct slots:
    SB-KERNEL::MESSAGE
      Initargs: :MESSAGE
      Readers: SB-KERNEL::PROGRAM-ERROR-MESSAGE
    SB-KERNEL::SOURCE
      Initargs: :SOURCE
      Readers: SB-KERNEL::PROGRAM-ERROR-SOURCE

EXTENDED-FUNCTION-DESIGNATOR names a type-specifier:
  Lambda-list: ()
  Expansion: (SATISFIES SB-INT:EXTENDED-FUNCTION-DESIGNATOR-P)

COPY-SSET names a compiled function:
  Lambda-list: (SET)
  Declared type: (FUNCTION (SB-INT:SSET) (VALUES SB-INT:SSET &OPTIONAL))
  Source file: SYS:SRC;COMPILER;SSET.LISP

CHARACTER-ENCODING-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:CHARACTER-ENCODING-ERROR>:
  Class precedence-list: CHARACTER-ENCODING-ERROR, CHARACTER-CODING-ERROR,
                         ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CHARACTER-CODING-ERROR
  Direct subclasses: SB-IMPL::OCTETS-ENCODING-ERROR,
                     SB-INT:C-STRING-ENCODING-ERROR,
                     SB-INT:STREAM-ENCODING-ERROR
  Direct slots:
    SB-KERNEL::CODE
      Initargs: :CODE
      Readers: SB-INT:CHARACTER-ENCODING-ERROR-CODE

DELQ1 names a compiled function:
  Lambda-list: (ITEM LIST)
  Declared type: (FUNCTION (T LIST) (VALUES LIST &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

PRINT-NOT-READABLE-ERROR names a compiled function:
  Lambda-list: (OBJECT STREAM)
  Derived type: (FUNCTION (T T) *)
  Source file: SYS:SRC;CODE;PRINT.LISP

HASHSET-COUNT names a compiled function:
  Lambda-list: (HASHSET)
  Derived type: (FUNCTION (T) (VALUES UNSIGNED-BYTE &OPTIONAL))
  Source file: SYS:SRC;CODE;HASHSET.LISP

LOOKS-LIKE-NAME-OF-SPECIAL-VAR-P names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

%BOUNDP names a compiled function:
  Lambda-list: (SYMBOL)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;SYMBOL.LISP

*INFO-ENVIRONMENT* names a global variable:
  Declared type: SB-IMPL::INFO-HASHTABLE
  Declared always-bound.
  Value: #<SB-IMPL::INFO-HASHTABLE 0/43 entries {1200010603}>

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

ARRAY-INITIAL-ELEMENT-MISMATCH names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:ARRAY-INITIAL-ELEMENT-MISMATCH>:
  Class precedence-list: SB-INT:ARRAY-INITIAL-ELEMENT-MISMATCH,
                         SB-INT:REFERENCE-CONDITION, SIMPLE-WARNING,
                         SIMPLE-CONDITION, WARNING, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION, SIMPLE-WARNING
  Direct subclasses: SB-INT:INITIAL-ELEMENT-MISMATCH-STYLE-WARNING
  No direct slots.

*REPL-READ-FORM-FUN* names a special variable:
  Value: #<FUNCTION SB-ACLREPL::REPL-READ-FORM-FUN>
  Documentation:
    A function of two stream arguments IN and OUT for the toplevel REPL to
    call: Return the next Lisp form to evaluate (possibly handling other magic--
    like ACL-style keyword commands -- which precede the next Lisp form). TheOUT
    stream is there to support magic which requires issuing new prompts.

• Set by
  • INSTALL-REPL
  • UNINSTALL-REPL
• Referenced by
  • SB-ACLREPL::REP-ONE
  • INSTALL-REPL

XSET-INTERSECTION names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (T T) (VALUES SB-INT:XSET &OPTIONAL))
  Source file: SYS:SRC;CODE;XSET.LISP

ENSURE-LINKAGE-INDEX names a compiled function:
  Lambda-list: (DESIGNATOR &OPTIONAL QUIET)
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES (UNSIGNED-BYTE 19)&OPTIONAL))
  Source file: SYS:SRC;CODE;LINKAGE-SPACE.LISP

LIST-ELTS-EQ names a compiled function:
  Lambda-list: (X Y)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

GET-SIMILAR names a macro:
  Lambda-list: (KEY TABLE)
  Source file: SYS:SRC;COMPILER;DUMP.LISP

BACKSPACE-CHAR-CODE names a constant variable:
  Value: 8

MAKE-INFO-HASHTABLE names a compiled function:
  A constructor for SB-IMPL::INFO-HASHTABLE
  Lambda-list: (&KEY ((STORAGE STORAGE) (MAKE-INFO-STORAGE 30))
                ((COMPARATOR COMPARATOR) (FUNCTION EQUAL))
                ((HASH-FUNCTION HASH-FUNCTION) (FUNCTION GLOBALDB-SXHASHOID))
                ((MUTEX MUTEX) (MAKE-MUTEX NAME info hashtable))
                ((TOMBSTONES TOMBSTONES) 0) ((COUNT COUNT) 0))
  Derived type: (FUNCTION
                 (&KEY (:STORAGE SIMPLE-VECTOR) (:COMPARATOR FUNCTION)
                  (:HASH-FUNCTION FUNCTION) (:MUTEX T)
                  (:TOMBSTONES (UNSIGNED-BYTE 64)) (:COUNT (UNSIGNED-BYTE 64)))
                 (VALUES SB-IMPL::INFO-HASHTABLE &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-LFHASH.LISP

HASH-TABLE-LOCK names a macro:
  Lambda-list: (TABLE)
  Source file: SYS:SRC;CODE;HASH-TABLE.LISP

• Macroexpanded by
  • SB-INTROSPECT:MAP-ROOT

SIMPLE-FILE-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:SIMPLE-FILE-ERROR>:
  Class precedence-list: SB-INT:SIMPLE-FILE-ERROR, SIMPLE-CONDITION, FILE-ERROR,
                         ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SIMPLE-CONDITION, FILE-ERROR
  Direct subclasses: DELETE-FILE-ERROR, FILE-DOES-NOT-EXIST, FILE-EXISTS
  Direct slots:
    SB-KERNEL::MESSAGE
      Initargs: :MESSAGE
      Initform: 'NIL
      Readers: SB-KERNEL::SIMPLE-FILE-ERROR-MESSAGE

RETURN-CHAR-CODE names a constant variable:
  Value: 13

MAKE-DEPRECATION-INFO names a compiled function:
  A constructor for SB-INT:DEPRECATION-INFO
  Lambda-list: (STATE SOFTWARE VERSION &OPTIONAL REPLACEMENT-SPEC &AUX
                (REPLACEMENTS
                 (NORMALIZE-DEPRECATION-REPLACEMENTS REPLACEMENT-SPEC)))
  Derived type: (FUNCTION
                 ((MEMBER :FINAL :LATE :EARLY) (OR STRING NULL) STRING
                  &OPTIONAL T)
                 (VALUES SB-INT:DEPRECATION-INFO &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

FAST-READ-CHAR-REFILL names a compiled function:
  Lambda-list: (STREAM EOF-ERROR-P)
  Derived type: (FUNCTION (T T) (VALUES (OR (MOD 513) NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;STREAM.LISP

DEPRECATION-STATE names a type-specifier:
  Lambda-list: ()
  Expansion: (MEMBER :EARLY :LATE :FINAL)

TWO-ARG-CHAR-NOT-EQUAL names a compiled function:
  Lambda-list: (C1 C2)
  Declared type: (FUNCTION (CHARACTER CHARACTER) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;TARGET-CHAR.LISP

FORMAT-UNIVERSAL-TIME names a compiled function:
  Lambda-list: (DESTINATION UNIVERSAL-TIME &KEY (TIMEZONE NIL) (STYLE LONG)
                (DATE-FIRST T) (PRINT-SECONDS T) (PRINT-MERIDIAN T)
                (PRINT-TIMEZONE T) (PRINT-WEEKDAY T))
  Derived type: (FUNCTION
                 (T T &KEY (:TIMEZONE T) (:STYLE T) (:DATE-FIRST T)
                  (:PRINT-SECONDS T) (:PRINT-MERIDIAN T) (:PRINT-TIMEZONE T)
                  (:PRINT-WEEKDAY T))
                 (VALUES (OR STRING NULL) &OPTIONAL))
  Documentation:
    Format-Universal-Time formats a string containing the time and date
    given by universal-time in a common manner. The destination is any
    destination which can be accepted by the Format function. The
    timezone keyword is an integer specifying hours west of Greenwich.
    The style keyword can be :SHORT (numeric date), :LONG (months and
    weekdays expressed as words), :ABBREVIATED (like :LONG but words are
    abbreviated), or :GOVERNMENT (of the form "XX Month XXXX XX:XX:XX")
    The &KEY argument :DATE-FIRST, if NIL, will print the time first instead
    of the date (the default). The PRINT- keywords, if NIL, inhibit
    the printing of the obvious part of the time/date.
  Source file: SYS:SRC;CODE;FORMAT-TIME.LISP

DO-SSET-ELEMENTS names a macro:
  Lambda-list: ((VAR SSET &OPTIONAL RESULT) &BODY BODY)
  Source file: SYS:SRC;COMPILER;SSET.LISP

RECONS names a compiled function:
  Lambda-list: (OLD-CONS CAR CDR)
  Derived type: (FUNCTION (T T T) (VALUES LIST &OPTIONAL))
  Documentation:
    If CAR is eq to the car of OLD-CONS and CDR is eq to the CDR, return
    OLD-CONS, otherwise return (cons CAR CDR).
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

INVALID-ARRAY-INDEX-ERROR names a compiled function:
  Lambda-list: (ARRAY INDEX BOUND &OPTIONAL AXIS)
  Declared type: (FUNCTION (ARRAY T INTEGER &OPTIONAL T) NIL)
  Source file: SYS:SRC;CODE;ARRAY.LISP

INVALID-ARRAY-INDEX-ERROR names the condition-class #<SB-PCL::CONDITION-CLASSSB-INT:INVALID-ARRAY-INDEX-ERROR>:
  Class precedence-list: SB-INT:INVALID-ARRAY-INDEX-ERROR, TYPE-ERROR, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: TYPE-ERROR
  No subclasses.
  Direct slots:
    ARRAY
      Initargs: :ARRAY
      Readers: SB-KERNEL::INVALID-ARRAY-INDEX-ERROR-ARRAY
    SB-KERNEL::AXIS
      Initargs: :AXIS
      Readers: SB-KERNEL::INVALID-ARRAY-INDEX-ERROR-AXIS

PSXHASH names a compiled function:
  Lambda-list: (KEY)
  Declared type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 62) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;TARGET-SXHASH.LISP

FORM-TRACKING-STREAM-P names a compiled function:
  A predicate for SB-INT:FORM-TRACKING-STREAM
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;FD-STREAM.LISP

GET-FLOATING-POINT-MODES names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES CONS &OPTIONAL))
  Documentation:
    This function returns a list representing the state of the floating
    point modes. The list is in the same format as the &KEY arguments to
    SET-FLOATING-POINT-MODES, i.e.
    
      (apply #'set-floating-point-modes (get-floating-point-modes))
    
    sets the floating point modes to their current values (and thus is a no-op).
  Source file: SYS:SRC;CODE;FLOAT-TRAP.LISP

FLUSH-STANDARD-OUTPUT-STREAMS names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES &OPTIONAL))
  Source file: SYS:SRC;CODE;TOPLEVEL.LISP

• Called by
  • SKEL/CLI::START-SKEL
  • SKEL/MPK/CLI::START-MPK
  • SKEL/HOMER/CLI::START-HOMER
  • SKEL/PACKY/CLI::START-PACKY

HASHSET-INSERT names a compiled function:
  Lambda-list: (HASHSET KEY)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;HASHSET.LISP

• Called by
  • (INTERN-URI (URI))

CONSTANT-DISPLACEMENT names a type-specifier:
  Lambda-list: (LOWTAG ELEMENT-SIZE DATA-OFFSET)

+CLOSURE-NAME-INDEX+ names a constant variable:
  Value: 0

AWHEN names a macro:
  Lambda-list: (TEST &BODY BODY)
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Macroexpanded by
  • DECLARATION-INFORMATION
  • SB-COVER:LCOV-REPORT
  • SB-SPROF:START-PROFILING

ENSURE-GETHASH names a macro:
  Lambda-list: (KEY HASH-TABLE DEFAULT)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Macroexpanded by
  • (JSON-WRITE (ORG-GRAPH-EDGE))
  • (JSON-WRITE (ORG-GRAPH-NODE))
  • NET/PROTO/DBUS::PARSE-SERVER-ADDRESSES-FROM-STREAM
  • (MAKE-CONFIG ((EQL TMUX)))
  • CRY/JWT::ISSUE
  • PLIST-STRING-HASH-TABLE
  • PLIST-HASH-TABLE
  • ALIST-HASH-TABLE

XSET names the structure-class #<STRUCTURE-CLASS SB-INT:XSET>:
  Class precedence-list: SB-INT:XSET, STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STRUCTURE-OBJECT
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::DATA
      Type: (OR LIST HASH-TABLE)
      Initform: NIL
    SB-KERNEL::EXTRA
      Type: (OR SIMPLE-VECTOR SB-INT:INDEX)
      Initform: 0

XSET-ELTS-HASH names a compiled function:
  Lambda-list: (XSET)
  Derived type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 62) &OPTIONAL))
  Source file: SYS:SRC;CODE;XSET.LISP

FUNARG-BIND/CALL-FORMS names a compiled function:
  Lambda-list: (FUNARG ARG-FORMS)
  Derived type: (FUNCTION (T T) (VALUES LIST CONS &OPTIONAL))
  Source file: SYS:SRC;CODE;MACROS.LISP

TWO-ARG-CHAR-EQUAL names a compiled function:
  Lambda-list: (C1 C2)
  Declared type: (FUNCTION (CHARACTER CHARACTER) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;TARGET-CHAR.LISP

• Called by
  • STARTS-WITH-P
  • DAT/CSV:PARSE-CSV-STRING
  • OBJ/TIME::%SPLIT-TIMESTRING
  • SWANK::FIND-DEFINITIONS-FIND-SYMBOL-OR-PACKAGE
  • SWANK::PREFIX-MATCH-P
  • SWANK/SBCL::LISP-SOURCE-LOCATION
  • STARTS-WITH-P

GENSYMIFY names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES SYMBOL &OPTIONAL))
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Called by
  • OBJ/META/FAST::MERGE-KEYWORD-INFOS
  • OBJ/META/FAST::ANONYMIZE-AUXILIARY-INFO
  • OBJ/META/FAST::ANONYMIZE-KEYWORD-INFO
  • OBJ/META/FAST::ANONYMIZE-OPTIONAL-INFO
  • OBJ/META/FAST::ANONYMIZE-REQUIRED-INFO
  • OBJ/META/FAST::ANONYMIZE-ORDINARY-LAMBDA-LIST
  • (INITIALIZE-INSTANCE BEFORE (SUPERVISOR))

FORM-SOURCE-BOUNDS names a compiled function:
  Lambda-list: (FORM)
  Derived type: (FUNCTION (T) (VALUES LIST LIST &OPTIONAL))
  Source file: SYS:SRC;COMPILER;TARGET-MAIN.LISP

SIMPLIFY-NAMESTRING names a compiled function:
  Lambda-list: (NAMESTRING &OPTIONAL HOST)
  Derived type: (FUNCTION (T &OPTIONAL T) *)
  Source file: SYS:SRC;CODE;TARGET-PATHNAME.LISP

STDIO-FILE names the structure-class #<STRUCTURE-CLASS SB-INT:STDIO-FILE>:
  Class precedence-list: SB-INT:STDIO-FILE, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STRUCTURE-OBJECT
  No subclasses.
  Slots:
    SB-IMPL::SAP
      Type: SB-SYS:SYSTEM-AREA-POINTER
      Initform: 0
    SB-IMPL::FD
      Type: FIXNUM
      Initform: -1

SSET names the structure-class #<STRUCTURE-CLASS SB-INT:SSET>:
  Class precedence-list: SB-INT:SSET, STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STRUCTURE-OBJECT
  No subclasses.
  Sealed.
  Slots:
    VECTOR
      Type: SIMPLE-VECTOR
      Initform: #()
    SB-C::LIMIT
      Type: SB-INT:INDEX
      Initform: 0
    COUNT
      Type: SB-INT:INDEX
      Initform: 0

*N-BYTES-FREED-OR-PURIFIED* names a global variable:
  Declared type: UNSIGNED-BYTE
  Declared always-bound.
  Value: 54407872752

FIND-RESTART-OR-CONTROL-ERROR names a compiled function:
  Lambda-list: (IDENTIFIER &OPTIONAL CONDITION (CALL-TEST-P T))
  Derived type: (FUNCTION (T &OPTIONAL T T) (VALUES (NOT NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

INFO-FIND-AUX-KEY/PACKED names a compiled function:
  Lambda-list: (PACKED-INFO SYMBOL)
  Derived type: (FUNCTION (T T)
                 (VALUES (OR NULL (INTEGER 1 16382)) (UNSIGNED-BYTE 44)
                         (MOD 10) &OPTIONAL))
  Source file: SYS:SRC;COMPILER;INFO-VECTOR.LISP

COLLECT names a macro:
  Lambda-list: (COLLECTIONS &BODY BODY)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Macroexpanded by
  • SB-ACLREPL::UNTRACE-CMD
  • SB-CONCURRENCY:LIST-QUEUE-CONTENTS
  • AUGMENT-ENVIRONMENT
  • SB-COVER::COVERAGE-AUGMENTATION
  • SB-COVER::GET-RECORDS
  • SB-COVER:GET-COVERAGE
  • SB-SPROF::REDUCE-GRAPH
  • GET-SIMPLE-FUN-INSTRUCTION-MODEL

MAKE-HASHSET names a compiled function:
  Lambda-list: (ESTIMATED-COUNT TEST-FUNCTION HASH-FUNCTION &KEY WEAKNESS
                SYNCHRONIZED)
  Derived type: (FUNCTION
                 (T T T &KEY (:WEAKNESS BOOLEAN) (:SYNCHRONIZED BOOLEAN))
                 (VALUES SB-IMPL::ROBINHOOD-HASHSET &OPTIONAL))
  Source file: SYS:SRC;CODE;HASHSET.LISP

• Called by
  • MAKE-URI-SPACE

SSET-EMPTY names a compiled function:
  Lambda-list: (SET)
  Declared type: (FUNCTION (SB-INT:SSET) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;COMPILER;SSET.LISP

EVERY/TYPE names a compiled function:
  Lambda-list: (OP THING LIST)
  Derived type: (FUNCTION (FUNCTION T T) (VALUES BOOLEAN BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

DEFINE-FUNCTION-NAME-SYNTAX names a macro:
  Lambda-list: (SYMBOL (VAR) &BODY BODY)
  Documentation:
    Define function names of the form of a list headed by SYMBOL to be
    a legal function name, subject to restrictions imposed by BODY.  BODY
    is evaluated with VAR bound to the form required to check, and should
    return two values: the first value is a generalized boolean indicating
    legality, and the second a symbol for use as a BLOCK name or similar
    situations.
  Source file: SYS:SRC;CODE;FUNCTION-NAMES.LISP

PACKAGE-ITER-STEP names a compiled function:
  Lambda-list: (ITER)
  Declared type: (FUNCTION (SB-IMPL::PKG-ITER)
                  (VALUES (MEMBER NIL :INHERITED :EXTERNAL :INTERNAL) PACKAGE
                          SYMBOL &OPTIONAL))
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

• Called by
  • ENSURE-PACKAGE
  • PACKAGE-DEFINITION-FORM
  • DELETE-PACKAGE*
  • SB-SPROF:PROFILE-CALL-COUNTS
  • PACKAGE-DOCUMENTATION
  • CLI/LINEDIT::LISP-COMPLETE
  • (EMACS-INSPECT (PACKAGE))
  • SWANK::FUZZY-FIND-MATCHING-SYMBOLS
  • SWANK::FIND-MATCHING-SYMBOLS
  • SWANK:PRINT-INDENTATION-LOSSAGE
  • SWANK::UPDATE-INDENTATION/DELTA-FOR-EMACS
  • SWANK:PROFILE-BY-SUBSTRING
  • SWANK::APROPOS-SYMBOLS
  • SWANK::MATCHING-SYMBOLS
  • SWANK/BACKEND:IMPORT-SWANK-MOP-SYMBOLS
  • IRONCLAD:LIST-ALL-AUTHENTICATED-ENCRYPTION-MODES
  • IRONCLAD:LIST-ALL-MACS
  • IRONCLAD:LIST-ALL-DIGESTS
  • IRONCLAD:LIST-ALL-CIPHERS
  • PACKAGE-SYMBOLS
  • LIST-PACKAGE-SYMBOLS
  • REGEX-APROPOS
  • REGEX-APROPOS-LIST
  • PACKAGE-SYMBOLS-EXCEPT
  • (DEFINE-LISP-PACKAGE)
  • ENSURE-PACKAGE
  • PACKAGE-DEFINITION-FORM
  • DELETE-PACKAGE*
  • REEXPORT-PACKAGES
  • EXPORT-PACKAGES

CHECK-DEPRECATED-TYPE names a compiled function:
  Lambda-list: (TYPE-SPECIFIER)
  Derived type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

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

• Called by
  • SB-INTROSPECT:MAP-ROOT

DOHASH names a macro:
  Lambda-list: (((KEY-VAR VALUE-VAR) TABLE &KEY RESULT LOCKED) &BODY BODY)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Macroexpanded by
  • SB-COVER:LCOV-REPORT
  • SB-COVER::COVERAGE-AUGMENTATION
  • SB-COVER::NOTE-SUPPRESSIONS

*CORE-STRING* names a global variable:
  Declared always-bound.
  Value: "/usr/bin/core"

SEQUENCE-BOUNDING-INDICES-BAD-ERROR names a compiled function:
  Lambda-list: (SEQUENCE START END)
  Declared type: (FUNCTION (T T T) NIL)
  Known attributes: no-verify-arg-count
  Source file: SYS:SRC;CODE;SEQ.LISP

• Called by
  • SB-POSIX:STRTOD
  • SB-MD5:MD5SUM-SEQUENCE

PARSE-KEY-ARG-SPEC names a compiled function:
  Lambda-list: (SPEC &OPTIONAL DEFAULT)
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES T T T T BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;COMPILER;PARSE-LAMBDA-LIST.LISP

DEPRECATION-INFO names the structure-class #<STRUCTURE-CLASS SB-INT:DEPRECATION-INFO>:
  Class precedence-list: SB-INT:DEPRECATION-INFO, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STRUCTURE-OBJECT
  No subclasses.
  Slots:
    SB-IMPL::STATE
      Type: SB-INT:DEPRECATION-STATE
      Initform: (SB-INT:MISSING-ARG)
    SB-IMPL::SOFTWARE
      Type: (OR NULL STRING)
      Initform: (SB-INT:MISSING-ARG)
    SB-IMPL::VERSION
      Type: STRING
      Initform: (SB-INT:MISSING-ARG)
    SB-IMPL::REPLACEMENTS
      Type: LIST
      Initform: 'NIL

UNQUOTE names a compiled function:
  A constructor for SB-IMPL::COMMA
  Lambda-list: (EXPR &OPTIONAL (KIND 0))
  Derived type: (FUNCTION (T &OPTIONAL (MOD 3))
                 (VALUES SB-IMPL::COMMA &OPTIONAL))
  Source file: SYS:SRC;CODE;BACKQ.LISP

• Called by
  • (DEFINE-C-STRUCT)
  • (LIFT-FUNCTION)
  • (GELSY ((X . #<STANDARD-CLASS OBJ/TENSOR:BLAS-MIXIN>) (X . #<STANDARD-CLASS OBJ/TENSOR:BLAS-MIXIN>)))
  • (GETT! (T (X . #<TENSOR-CLASS OBJ/TENSOR:DENSE-TENSOR>) (X . #<TENSOR-CLASS OBJ/TENSOR:DENSE-TENSOR>) T (X . #<TENSOR-CLASS OBJ/TENSOR:DENSE-TENSOR>)))
  • (CLASS)
  • (USE-FUNCTIONS)
  • SYN/GEN:BUILD-SWAP-PACKAGE
  • SYN/GEN:BUILD-CONTEXT-SWITCHES
  • (WITH-CODE-PRINTER)
  • (WITH-VECTOR-PARSING)
  • (WITH-OCTETS-PARSING)
  • (WITH-STRING-PARSING)
  • (PARSING-MACROLET)
  • (WITH-HTML)
  • (%DEFCOMPARATOR)
  • (DEFINE-TENSOR-METHOD)
  • (%WITH-ARRAY-PARSING)
  • (WITH-STRUCT*)
  • IRONCLAD::MAYBE-EXPAND-ONE-SHOT-CALL
  • (MAKE-DIGEST)
  • (DEFINE-DIGEST-FINALIZER)
  • (MAKE-CIPHER)
  • (WITH-WORDS)
  • (WITH-DIRECTORY-ITERATOR)
  • (DEFPTYPED)
  • (DEFPUN)
  • (DEFINE-DEFPUN)
  • STD/ASYNC::REGISTERED-MACROLETS
  • (DEFUN/WRAPPER)
  • (SUBMIT-WITH-CANCEL)
  • (DEFINE-SAP-ACCESSORS)
  • (WITH-BINARY-READERS)
  • (WITH-BINARY-WRITERS)
  • (DEFINE-IO)
  • (DEFINE-LOGICAL-HOST-LOADER)
  • (DEFUNITS)
  • (DEFWITH)
  • (PANDORIC-EVAL)
  • (NLET-TAIL)
  • (ONCE-ONLY)
  • (SUBST-MODE-PPCRE-LAMBDA-FORM)
  • (MATCH-MODE-PPCRE-LAMBDA-FORM)
  • (SCAN-MODE-PPCRE-LAMBDA-FORM)
  • (WITH-REBINDING)
  • (WITH-READTABLE-ITERATOR)
  • (DEFHOOK)
  • (BINDING-GENSYMS)
  • (DEFMACRO!)
  • (ALIAS-FUNCTION)
  • (DEFINE-CONDITION-HANDLER)
  • (DEFPACKAGE*)
  • (%DEFPKG*)

ENSURE-LIST names a compiled function:
  Lambda-list: (THING)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Called by
  • SB-INTROSPECT:FIND-DEFINITION-SOURCES-BY-NAME
  • (DEFSTRUCT*)
  • (SOCKET-ERROR-CASE)
  • (SYSCALL-ERROR-CASE)
  • NET/REQ::REQ
  • (AUTHENTICATE (T STANDARD-DBUS-CONNECTION))
  • (SIGNALS)
  • (MIME-CASE)
  • OBJ/TENSOR::LOOP-SLICE-ITERATION-PATH
  • OBJ/TENSOR::MAKE-FOREIGN-DENSE-TENSOR
  • TENSOR-TYPEP
  • (DEFINE-TENSOR-METHOD)
  • SWANK-TRACE-DIALOG::DESCRIBE-TRACE-FOR-EMACS
  • SWANK-TRACE-DIALOG:FIND-TRACE-PART
  • SWANK::KEYWORDS-OF-OPERATOR
  • SWANK:SWANK-REQUIRE
  • STD/DEFSYS::REGISTER-COMPONENT-CLASS
  • STD/ASYNC::PARSE-BINDINGS
  • REMOVE-TEMPLATE-METHOD
  • (DEFINE-TEMPLATE-METHOD)
  • (WITH-MEMOIZATION)
  • (MULTIPLE-VALUE-CASE)

ENCAPSULATED-P names a compiled function:
  Lambda-list: (NAME TYPE)
  Derived type: (FUNCTION (T SYMBOL) *)
  Source file: SYS:SRC;CODE;FDEFINITION.LISP

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

ASSQ names a compiled function:
  Lambda-list: (ITEM ALIST)
  Declared type: (FUNCTION (T LIST) (VALUES LIST &OPTIONAL))
  Documentation:
    Return the first pair of alist where item is EQ to the key of pair.
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Called by
  • (COMPUTE-SLOTS AROUND (STANDARD-CLASS))

ALIGN-UP names a compiled function:
  Lambda-list: (VALUE GRANULARITY)
  Derived type: (FUNCTION (T T) (VALUES INTEGER &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

BIT-VECTOR-= names a compiled function:
  Lambda-list: (X Y)
  Declared type: (FUNCTION (BIT-VECTOR BIT-VECTOR) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • NIL

WITH-UNIQUE-NAMES names a macro:
  Lambda-list: (SYMBOLS &BODY BODY)
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Macroexpanded by
  • (INSTRUCTION-SET-CASE)
  • (FRLOCK-WRITE)
  • (FRLOCK-READ)
  • (WITH-GROWING-C-STRING)
  • SB-GROVEL::C-STRING-WRITER
  • (INVARIANT)
  • (WITH-READTABLE)
  • (PROTECT-ABORT)

ARRAY-READABLY-PRINTABLE-P names a compiled function:
  Lambda-list: (ARRAY)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;PRINT.LISP

LOAD-AS-SOURCE names a compiled function:
  Lambda-list: (STREAM &KEY VERBOSE PRINT (CONTEXT loading))
  Derived type: (FUNCTION (T &KEY (:VERBOSE T) (:PRINT T) (:CONTEXT T))
                 (VALUES (MEMBER T) &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-LOAD.LISP

OUT-STREAM-FROM-DESIGNATOR names a macro:
  Lambda-list: (STREAM)
  Source file: SYS:SRC;CODE;SYSMACS.LISP

DEFCONSTANT-EQX names a macro:
  Lambda-list: (SYMBOL EXPR EQX &OPTIONAL DOC)
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

LEGAL-CLASS-NAME-P names a compiled function:
  Lambda-list: (THING)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

HASH-TABLE-REPLACE names a compiled function:
  Lambda-list: (TO FROM &OPTIONAL (TRANSFORM (FUNCTION IDENTITY)))
  Derived type: (FUNCTION (T T &OPTIONAL T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;READER.LISP

*PRINT-CONDITION-REFERENCES* names a special variable:
  Value: T

• Bound by
  • (PRINT-CONDITION IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::BRIEF-COMPILER-MESSAGE-FOR-EMACS

COMMA-EXPR names a compiled function:
  An accessor for SB-IMPL::COMMA
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::COMMA) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;BACKQ.LISP

• Called by
  • (SEXP-REF (COMMA T))
  • (SEXP-IN-BOUNDS-P (COMMA T))
  • FLATTEN*

STRINGIFY-OBJECT names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES SIMPLE-STRING &OPTIONAL))
  Known attributes: no-verify-arg-count
  Source file: SYS:SRC;CODE;PRINT.LISP

• Called by
  • SB-ACLREPL::SELECT-DESCRIPTION
  • SB-ACLREPL::PACKAGE-CMD
  • SB-ACLREPL::MAKE-CTE
  • SB-ACLREPL::FIND-HISTORY-MATCHING-PATTERN
  • SB-SPROF::ADD-DISASSEMBLY-PROFILE-NOTE
  • NET/REQ::REQ
  • DAT/SVG::GET-MATRIX-FROM-TRANSFORMATION
  • DAT/CSS::%-OR-WORD
  • OBJ/AST::WRITE-AST-STRING
  • URL-ENCODE-PARAMS
  • SWANK-REPL:LISTENER-GET-VALUE
  • HEX-STRING

STRERROR names a compiled function:
  Lambda-list: (&OPTIONAL (ERRNO (GET-ERRNO)))
  Derived type: (FUNCTION (&OPTIONAL T)
                 (VALUES (OR SIMPLE-STRING NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;MISC-ALIENS.LISP

• Called by
  • (SOCKET-ERROR)
  • (SYSCALL-ERROR)
  • IO/KBD:NEW-DEVICE-FROM-PATH
  • (IOCTL)
  • IOCTL

FORMAT-DECODED-TIME names a compiled function:
  Lambda-list: (DESTINATION SECONDS MINUTES HOURS DAY MONTH YEAR &KEY
                (TIMEZONE NIL) (STYLE SHORT) (DATE-FIRST T) (PRINT-SECONDS T)
                (PRINT-MERIDIAN T) (PRINT-TIMEZONE T) (PRINT-WEEKDAY T))
  Derived type: (FUNCTION
                 (T T T T T T T &KEY (:TIMEZONE T) (:STYLE T) (:DATE-FIRST T)
                  (:PRINT-SECONDS T) (:PRINT-MERIDIAN T) (:PRINT-TIMEZONE T)
                  (:PRINT-WEEKDAY T))
                 (VALUES (OR STRING NULL) &OPTIONAL))
  Documentation:
    FORMAT-DECODED-TIME formats a string containing decoded time
    expressed in a humanly-readable manner. The destination is any
    destination which can be accepted by the FORMAT function. The
    timezone keyword is an integer specifying hours west of Greenwich.
    The style keyword can be :SHORT (numeric date), :LONG (months and
    weekdays expressed as words), or :ABBREVIATED (like :LONG but words are
    abbreviated). The keyword DATE-FIRST, if NIL, will cause the time
    to be printed first instead of the date (the default). The PRINT-
    keywords, if nil, inhibit the printing of certain semi-obvious
    parts of the string.
  Source file: SYS:SRC;CODE;FORMAT-TIME.LISP

DEPRECATION-INFO-STATE names a compiled function:
  An accessor for SB-INT:DEPRECATION-INFO
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-INT:DEPRECATION-INFO)
                 (VALUES (MEMBER :FINAL :LATE :EARLY) &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Called by
  • SB-CLTL2::MAYBE-DEPRECATION-ENTRY

FUN-NAME-BLOCK-NAME names a compiled function:
  Lambda-list: (FUN-NAME)
  Declared type: (FUNCTION ((OR CONS SYMBOL)) (VALUES &OPTIONAL SYMBOL &RESTT))
  Derived type: (FUNCTION ((OR CONS SYMBOL)) (VALUES SYMBOL &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

*SETF-FDEFINITION-HOOK* names a global variable:
  Declared always-bound.
  Value: (#<FUNCTION SB-DEBUG::MAYBE-RETRACE-FUNCTION>)
  Documentation:
    A list of functions that (SETF FDEFINITION) invokes before storing the
    new value. The functions take the function name and the new value.

DEPRECATION-WARN names a compiled function:
  Lambda-list: (STATE SOFTWARE VERSION NAMESPACE NAME REPLACEMENTS &KEY
                (RUNTIME-ERROR (NEQ EARLY STATE)))
  Derived type: (FUNCTION (T T T T T T &KEY (:RUNTIME-ERROR T))
                 (VALUES NULL &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

*LOAD-SOURCE-DEFAULT-TYPE* names a special variable:
  Value: "lisp"
  Documentation:
    The source file types which LOAD looks for by default.

DUPLICATE-DEFINITION names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:DUPLICATE-DEFINITION>:
  Class precedence-list: SB-INT:DUPLICATE-DEFINITION,
                         SB-INT:REFERENCE-CONDITION, WARNING, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION, WARNING
  No subclasses.
  Direct slots:
    SB-KERNEL::NAME
      Initargs: :NAME
      Readers: SB-INT:DUPLICATE-DEFINITION-NAME

STREAM-ENCODING-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:STREAM-ENCODING-ERROR>:
  Class precedence-list: SB-INT:STREAM-ENCODING-ERROR, STREAM-ERROR,
                         CHARACTER-ENCODING-ERROR, CHARACTER-CODING-ERROR,
                         ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STREAM-ERROR, CHARACTER-ENCODING-ERROR
  No subclasses.
  No direct slots.

SYMBOL-NAME-HASH names a compiled function:
  Lambda-list: (SYMBOL)
  Declared type: (FUNCTION (SYMBOL) (VALUES (UNSIGNED-BYTE 32) &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;SYMBOL.LISP

SYMBOL-NAME-HASH names a type-specifier:
  Lambda-list: ()
  Expansion: (UNSIGNED-BYTE 32)

MAKE-UNPRINTABLE-OBJECT names a compiled function:
  A constructor for SB-DEBUG::UNPRINTABLE-OBJECT
  Lambda-list: (STRING)
  Derived type: (FUNCTION (T) (VALUES SB-DEBUG::UNPRINTABLE-OBJECT &OPTIONAL))
  Source file: SYS:SRC;CODE;DEBUG.LISP

%WRITE names a compiled function:
  Lambda-list: (OBJECT STREAM)
  Declared type: (FUNCTION (T (OR STREAM BOOLEAN)) (VALUES T &OPTIONAL))
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Known attributes: unwind, any, no-verify-arg-count
  Source file: SYS:SRC;CODE;PRINT.LISP

• Called by
  • (PRINT-OBJECT (PRINTABLE T))
  • (PPRINT-BLOCK IN PRINT-OBJECT)
  • SAVE-DEFERRED-WARNINGS
  • SB-COVER:SAVE-COVERAGE-IN-FILE
  • (WRITE-AST (HOMER-SERVICE T))
  • (WRITE-AST (HOMER-JOB T))
  • (WRITE-AST (HOMER-TASK T))
  • (PROJECT-COMPILE (MAKEFILE))
  • (WRITE-AST (LISP-COMPONENT PATHNAME))
  • (WRITE-AST (LISP-COMPONENT T))
  • (WRITE-AST (SKEL-CONFIG T))
  • POD::FORMAT-CONTAINERFILE-ARG
  • POD::WRITE-CONTAINERFILE-LINE
  • (WRITE-AST (VC-REPO T))
  • (SERIALIZE (TLV (EQL BYTES)))
  • SYN/TS::TS-FILE-QUERY
  • (PRINT-OBJECT (TEXT-NODE T))
  • DAT/PARQUET/GEN::PARSE-PARQUET-THRIFT-DEFINITIONS
  • (WRITE-OBJECT (SIMPLE-RULE T))
  • (WRITE-AST (SIMPLE-RULE T))
  • (WRITE-OBJECT (RULE T))
  • (WRITE-AST (RULE T))
  • (WRITE-AST (SCHEMA T))
  • (WRITE-AST (FIELD T))
  • (WRITE-AST (AST STREAM))
  • SWANK::TO-LINE
  • SAVE-DEFERRED-WARNINGS
  • (WRITE-OBJECT (T T))

FUN-NAME-INLINE-EXPANSION names a compiled function:
  Lambda-list: (FUN-NAME)
  Declared type: (FUNCTION (T) (VALUES LIST BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;COMPILER;IR1TRAN.LISP

ANY/TYPE names a compiled function:
  Lambda-list: (OP THING LIST)
  Derived type: (FUNCTION (FUNCTION T T) (VALUES BOOLEAN BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

DEFINE-UNSUPPORTED-FUN names a macro:
  Lambda-list: (NAME &OPTIONAL (DOC Unsupported on this platform.)
                (CONTROL ~S is unsupported on this platform ~
                                    (OS, CPU, whatever).)
                ARGUMENTS)
  Source file: SYS:SRC;CODE;FOREIGN.LISP

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

META-INFO names a compiled function:
  Lambda-list: (CATEGORY KIND &OPTIONAL (ERRORP T))
  Derived type: (FUNCTION (T T &OPTIONAL T)
                 (VALUES (OR NULL SB-INT:META-INFO) &OPTIONAL))
  Source file: SYS:SRC;COMPILER;EARLY-GLOBALDB.LISP

META-INFO names the structure-class #<STRUCTURE-CLASS SB-INT:META-INFO>:
  Class precedence-list: SB-INT:META-INFO, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STRUCTURE-OBJECT
  No subclasses.
  Sealed.
  Slots:
    NUMBER
      Type: SB-INT:INFO-NUMBER
      Initform: NIL
    SB-IMPL::CATEGORY
      Type: KEYWORD
      Initform: NIL
    SB-IMPL::KIND
      Type: KEYWORD
      Initform: NIL
    SB-IMPL::TYPE-SPEC
      Type: T
      Initform: NIL
    SB-IMPL::TYPE-CHECKER
      Type: (SB-INT:SFUNCTION (T) T)
      Initform: NIL
    SB-IMPL::VALIDATE-FUNCTION
      Type: (OR FUNCTION NULL)
      Initform: NIL
    SB-IMPL::DEFAULT
      Type: T
      Initform: NIL

HASH-TABLE-EQUALP names a compiled function:
  Lambda-list: (X Y)
  Declared type: (FUNCTION (HASH-TABLE SB-KERNEL:INSTANCE)
                  (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;PRED.LISP

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

GLOBAL-FTYPE names a compiled function:
  Lambda-list: (NAME)
  Declared type: (FUNCTION (T) (VALUES SB-KERNEL:CTYPE &OPTIONAL))
  Source file: SYS:SRC;CODE;DEFSTRUCT.LISP

• Called by
  • SB-INTROSPECT:FUNCTION-TYPE
  • FUNCTION-INFORMATION

CHARACTER-DECODING-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:CHARACTER-DECODING-ERROR>:
  Class precedence-list: CHARACTER-DECODING-ERROR, CHARACTER-CODING-ERROR,
                         ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CHARACTER-CODING-ERROR
  Direct subclasses: SB-IMPL::OCTET-DECODING-ERROR,
                     SB-INT:C-STRING-DECODING-ERROR,
                     SB-INT:STREAM-DECODING-ERROR
  Direct slots:
    SB-KERNEL::OCTETS
      Initargs: :OCTETS
      Readers: SB-INT:CHARACTER-DECODING-ERROR-OCTETS

ADDRESS-BASED-COUNTER-VAL names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES (UNSIGNED-BYTE 60) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

STREAM-DECODING-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:STREAM-DECODING-ERROR>:
  Class precedence-list: SB-INT:STREAM-DECODING-ERROR, STREAM-ERROR,
                         CHARACTER-DECODING-ERROR, CHARACTER-CODING-ERROR,
                         ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STREAM-ERROR, CHARACTER-DECODING-ERROR
  No subclasses.
  No direct slots.

SET-INFO-VALUE names a compiled function:
  Lambda-list: (NAME INFO-NUMBER NEW-VALUE)
  Declared type: (FUNCTION (T (UNSIGNED-BYTE 6) T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;COMPILER;INFO-VECTOR.LISP

LOCAL-ARGUMENT-MISMATCH names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:LOCAL-ARGUMENT-MISMATCH>:
  Class precedence-list: SB-INT:LOCAL-ARGUMENT-MISMATCH,
                         SB-INT:REFERENCE-CONDITION, SIMPLE-WARNING,
                         SIMPLE-CONDITION, WARNING, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:REFERENCE-CONDITION, SIMPLE-WARNING
  No subclasses.
  No direct slots.

PERMANENT-FNAME-P names a compiled function:
  Lambda-list: (NAME)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;FUNCTION-NAMES.LISP

MAKE-SSET names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES SB-INT:SSET &OPTIONAL))
  Source file: SYS:SRC;COMPILER;SSET.LISP

CHECK-DEPRECATED-THING names a compiled function:
  Lambda-list: (NAMESPACE NAME)
  Derived type: (FUNCTION (T T)
                 (VALUES (MEMBER :EARLY :LATE :FINAL NIL) &OPTIONAL LIST LIST))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

DEPRECATION-INFO-SOFTWARE names a compiled function:
  An accessor for SB-INT:DEPRECATION-INFO
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-INT:DEPRECATION-INFO)
                 (VALUES (OR STRING NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Called by
  • SB-CLTL2::MAYBE-DEPRECATION-ENTRY

MAP-XSET names a compiled function:
  Lambda-list: (FUNCTION XSET)
  Dynamic-extent arguments: positional=(0)
  Derived type: (FUNCTION (FUNCTION T) (VALUES NULL &OPTIONAL))
  Source file: SYS:SRC;CODE;XSET.LISP

MAKE-LAMBDA-LIST names a compiled function:
  Lambda-list: (LLKS WHOLE REQUIRED &OPTIONAL OPTIONAL REST KEYS AUX)
  Derived type: (FUNCTION (T T T &OPTIONAL T T T T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;COMPILER;PARSE-LAMBDA-LIST.LISP

• Called by
  • OBJ/CMD::UNPARSE-INTERACTIVE-LAMBDA-LIST

DEFINE-DEPRECATED-FUNCTION names a macro:
  Lambda-list: (STATE VERSION NAME REPLACEMENTS LAMBDA-LIST &BODY BODY)
  Source file: SYS:SRC;CODE;TARGET-EXTENSIONS.LISP

POSSIBLY-BASE-STRINGIZE names a compiled function:
  Lambda-list: (S)
  Declared type: (FUNCTION (STRING) (VALUES SIMPLE-STRING &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;TARGET-MISC.LISP

DO-ANONYMOUS names a macro:
  Lambda-list: (VARLIST ENDLIST &REST BODY)
  Source file: SYS:SRC;CODE;MACROS.LISP

• Macroexpanded by
  • (WITH-NEW-REPL-STATE)
  • 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-AVX2:S64.4/=
  • SB-SIMD-AVX2:S32.8/=
  • SB-SIMD-AVX2:S16.16/=
  • SB-SIMD-AVX2:S8.32/=
  • SB-SIMD-AVX2:U64.4/=
  • SB-SIMD-AVX2:U32.8/=
  • SB-SIMD-AVX2:U16.16/=
  • SB-SIMD-AVX2:U8.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.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:F32.4/=
  • SB-SIMD-AVX:F64/=
  • SB-SIMD-AVX:F32/=
  • SB-SIMD-SSE4.1:S64.2/=
  • SB-SIMD-SSE4.1:U64.2/=
  • SB-SIMD-SSE2:S32.4/=
  • SB-SIMD-SSE2:S16.8/=
  • SB-SIMD-SSE2:S8.16/=
  • SB-SIMD-SSE2:U32.4/=
  • SB-SIMD-SSE2:U16.8/=
  • SB-SIMD-SSE2:U8.16/=
  • SB-SIMD-SSE2:F64.2/=
  • SB-SIMD-SSE2:F32.4/=
  • SB-SIMD-SSE2:F64/=
  • SB-SIMD-SSE:F32/=
  • SB-SIMD:S64/=
  • SB-SIMD:S32/=
  • SB-SIMD:S16/=
  • SB-SIMD:S8/=
  • SB-SIMD:U64/=
  • SB-SIMD:U32/=
  • SB-SIMD:U16/=
  • SB-SIMD:U8/=
  • SB-SIMD:F64/=
  • SB-SIMD:F32/=
  • ((SETF S64.2-AREF))
  • ((SETF S32.4-AREF))
  • ((SETF S16.8-AREF))
  • ((SETF S8.16-AREF))
  • ((SETF U64.2-AREF))
  • ((SETF U32.4-AREF))
  • ((SETF U16.8-AREF))
  • ((SETF U8.16-AREF))
  • ((SETF F64.2-AREF))
  • ((SETF F32.4-AREF))
  • ((SETF U32.4-STRING-REF))
  • ((SETF S64.4-NON-TEMPORAL-AREF))
  • ((SETF S32.8-NON-TEMPORAL-AREF))
  • ((SETF S16.16-NON-TEMPORAL-AREF))
  • ((SETF S8.32-NON-TEMPORAL-AREF))
  • ((SETF U64.4-NON-TEMPORAL-AREF))
  • ((SETF U32.8-NON-TEMPORAL-AREF))
  • ((SETF U16.16-NON-TEMPORAL-AREF))
  • ((SETF U8.32-NON-TEMPORAL-AREF))
  • ((SETF S64.2-NON-TEMPORAL-AREF))
  • ((SETF S32.4-NON-TEMPORAL-AREF))
  • ((SETF S16.8-NON-TEMPORAL-AREF))
  • ((SETF S8.16-NON-TEMPORAL-AREF))
  • ((SETF U64.2-NON-TEMPORAL-AREF))
  • ((SETF U32.4-NON-TEMPORAL-AREF))
  • ((SETF U16.8-NON-TEMPORAL-AREF))
  • ((SETF U8.16-NON-TEMPORAL-AREF))
  • ((SETF F64.4-NON-TEMPORAL-AREF))
  • ((SETF F32.8-NON-TEMPORAL-AREF))
  • ((SETF F64.2-NON-TEMPORAL-AREF))
  • ((SETF F32.4-NON-TEMPORAL-AREF))
  • ((SETF S64.4-NON-TEMPORAL-AREF))
  • ((SETF S32.8-NON-TEMPORAL-AREF))
  • ((SETF S16.16-NON-TEMPORAL-AREF))
  • ((SETF S8.32-NON-TEMPORAL-AREF))
  • ((SETF U64.4-NON-TEMPORAL-AREF))
  • ((SETF U32.8-NON-TEMPORAL-AREF))
  • ((SETF U16.16-NON-TEMPORAL-AREF))
  • ((SETF U8.32-NON-TEMPORAL-AREF))
  • ((SETF S64.2-NON-TEMPORAL-AREF))
  • ((SETF S32.4-NON-TEMPORAL-AREF))
  • ((SETF S16.8-NON-TEMPORAL-AREF))
  • ((SETF S8.16-NON-TEMPORAL-AREF))
  • ((SETF U64.2-NON-TEMPORAL-AREF))
  • ((SETF U32.4-NON-TEMPORAL-AREF))
  • ((SETF U16.8-NON-TEMPORAL-AREF))
  • ((SETF U8.16-NON-TEMPORAL-AREF))
  • ((SETF F64.4-NON-TEMPORAL-AREF))
  • ((SETF F32.8-NON-TEMPORAL-AREF))
  • ((SETF F64.2-NON-TEMPORAL-AREF))
  • ((SETF F32.4-NON-TEMPORAL-AREF))
  • ((SETF S64.4-AREF))
  • ((SETF S32.8-AREF))
  • ((SETF S16.16-AREF))
  • ((SETF S8.32-AREF))
  • ((SETF U64.4-AREF))
  • ((SETF U32.8-AREF))
  • ((SETF U16.16-AREF))
  • ((SETF U8.32-AREF))
  • ((SETF S64.2-AREF))
  • ((SETF S32.4-AREF))
  • ((SETF S16.8-AREF))
  • ((SETF S8.16-AREF))
  • ((SETF U64.2-AREF))
  • ((SETF U32.4-AREF))
  • ((SETF U16.8-AREF))
  • ((SETF U8.16-AREF))
  • ((SETF F64.4-AREF))
  • ((SETF F32.8-AREF))
  • ((SETF F64.2-AREF))
  • ((SETF F32.4-AREF))
  • ((SETF F64-AREF))
  • ((SETF F32-AREF))
  • ((SETF U32.8-STRING-REF))
  • ((SETF U32.4-STRING-REF))
  • ((SETF S64.2-NON-TEMPORAL-AREF))
  • ((SETF S32.4-NON-TEMPORAL-AREF))
  • ((SETF S16.8-NON-TEMPORAL-AREF))
  • ((SETF S8.16-NON-TEMPORAL-AREF))
  • ((SETF U64.2-NON-TEMPORAL-AREF))
  • ((SETF U32.4-NON-TEMPORAL-AREF))
  • ((SETF U16.8-NON-TEMPORAL-AREF))
  • ((SETF U8.16-NON-TEMPORAL-AREF))
  • ((SETF F64.2-NON-TEMPORAL-AREF))
  • ((SETF F32.4-NON-TEMPORAL-AREF))
  • ((SETF S64.2-NON-TEMPORAL-AREF))
  • ((SETF S32.4-NON-TEMPORAL-AREF))
  • ((SETF S16.8-NON-TEMPORAL-AREF))
  • ((SETF S8.16-NON-TEMPORAL-AREF))
  • ((SETF U64.2-NON-TEMPORAL-AREF))
  • ((SETF U32.4-NON-TEMPORAL-AREF))
  • ((SETF U16.8-NON-TEMPORAL-AREF))
  • ((SETF U8.16-NON-TEMPORAL-AREF))
  • ((SETF F64.2-NON-TEMPORAL-AREF))
  • ((SETF S64.2-AREF))
  • ((SETF S32.4-AREF))
  • ((SETF S16.8-AREF))
  • ((SETF S8.16-AREF))
  • ((SETF U64.2-AREF))
  • ((SETF U32.4-AREF))
  • ((SETF U16.8-AREF))
  • ((SETF U8.16-AREF))
  • ((SETF F64.2-AREF))
  • ((SETF F64-AREF))
  • ((SETF U32.4-STRING-REF))
  • ((SETF F32.4-NON-TEMPORAL-AREF))
  • ((SETF F32.4-AREF))
  • ((SETF F32-AREF))
  • (S64.2-AREF)
  • (S32.4-AREF)
  • (S16.8-AREF)
  • (S8.16-AREF)
  • (U64.2-AREF)
  • (U32.4-AREF)
  • (U16.8-AREF)
  • (U8.16-AREF)
  • (F64.2-AREF)
  • (F32.4-AREF)
  • (U32.4-STRING-REF)
  • (S64.4-NON-TEMPORAL-AREF)
  • (S32.8-NON-TEMPORAL-AREF)
  • (S16.16-NON-TEMPORAL-AREF)
  • (S8.32-NON-TEMPORAL-AREF)
  • (U64.4-NON-TEMPORAL-AREF)
  • (U32.8-NON-TEMPORAL-AREF)
  • (U16.16-NON-TEMPORAL-AREF)
  • (U8.32-NON-TEMPORAL-AREF)
  • (S64.2-NON-TEMPORAL-AREF)
  • (S32.4-NON-TEMPORAL-AREF)
  • (S16.8-NON-TEMPORAL-AREF)
  • (S8.16-NON-TEMPORAL-AREF)
  • (U64.2-NON-TEMPORAL-AREF)
  • (U32.4-NON-TEMPORAL-AREF)
  • (U16.8-NON-TEMPORAL-AREF)
  • (U8.16-NON-TEMPORAL-AREF)
  • (F64.4-NON-TEMPORAL-AREF)
  • (F32.8-NON-TEMPORAL-AREF)
  • (F64.2-NON-TEMPORAL-AREF)
  • (F32.4-NON-TEMPORAL-AREF)
  • (S64.4-AREF)
  • (S32.8-AREF)
  • (S16.16-AREF)
  • (S8.32-AREF)
  • (S64.2-AREF)
  • (S32.4-AREF)
  • (S16.8-AREF)
  • (S8.16-AREF)
  • (U64.4-AREF)
  • (U32.8-AREF)
  • (U16.16-AREF)
  • (U8.32-AREF)
  • (U64.2-AREF)
  • (U32.4-AREF)
  • (U16.8-AREF)
  • (U8.16-AREF)
  • (F64.4-AREF)
  • (F32.8-AREF)
  • (F64.2-AREF)
  • (F32.4-AREF)
  • (F64-AREF)
  • (F32-AREF)
  • (U32.8-STRING-REF)
  • (U32.4-STRING-REF)
  • (S64.2-NON-TEMPORAL-AREF)
  • (S32.4-NON-TEMPORAL-AREF)
  • (S16.8-NON-TEMPORAL-AREF)
  • (S8.16-NON-TEMPORAL-AREF)
  • (U64.2-NON-TEMPORAL-AREF)
  • (U32.4-NON-TEMPORAL-AREF)
  • (U16.8-NON-TEMPORAL-AREF)
  • (U8.16-NON-TEMPORAL-AREF)
  • (F64.2-NON-TEMPORAL-AREF)
  • (F32.4-NON-TEMPORAL-AREF)
  • (S64.2-AREF)
  • (S32.4-AREF)
  • (S16.8-AREF)
  • (S8.16-AREF)
  • (U64.2-AREF)
  • (U32.4-AREF)
  • (U16.8-AREF)
  • (U8.16-AREF)
  • (F64.2-AREF)
  • (F64-AREF)
  • (U32.4-STRING-REF)
  • (F32.4-AREF)
  • (F32-AREF)
  • (WITH-ROW-MAJOR-SIMD-INDEX)
  • (DEFINE-FAKE-VOP)
  • (PRINTABLE-SLOT-PLIST APPEND (FUNCTION-RECORD))
  • (DECODE-RECORD-DEFINITION ((EQL SIMD-RECORD) T))
  • (DECODE-RECORD-DEFINITION ((EQL VALUE-RECORD) T))
  • SB-SIMD-INTERNALS::FIND-PRIMITIVE-TYPE
  • SB-SIMD-INTERNALS::PARSE-INSTRUCTION-SET-CASE-CLAUSES
  • (DEFINE-INSTRUCTION-SET)
  • SB-SIMD-INTERNALS:INCLUDED-INSTRUCTION-SETS
  • SB-SIMD-INTERNALS:MKSYM
  • SB-INTROSPECT::LARGEST-OBJECTS
  • SB-INTROSPECT:MAP-ROOT
  • (FRLOCK-READ)
  • (WITH-ADDRINFO)
  • (WITH-HOSTENT)
  • (WITH-SOCKADDR-UN-ABSTRACT)
  • (WITH-SOCKADDR-UN)
  • (WITH-SOCKADDR-IN6)
  • (WITH-IN6-ADDR)
  • (WITH-SOCKADDR-IN)
  • (WITH-IN-ADDR)
  • (WITH-PROTOENT)
  • (WITH-ALIEN-TIMEVAL)
  • (WITH-ALIEN-UTIMBUF)
  • (WITH-ALIEN-TERMIOS)
  • (WITH-ALIEN-FLOCK)
  • (WITH-ALIEN-STAT)
  • (WITH-ALIEN-GROUP)
  • (WITH-ALIEN-PASSWD)
  • (WITH-DIRENT)
  • (DEFINE-SIMPLE-CALL)
  • (DEFINE-CALL-INTERNALLY)
  • (DEFINE-DESIGNATOR)
  • (ACCESSORS-FOR (T VALUE-SLOT T))
  • (SIZE (STRUCTURED-TYPE))
  • ASDF/PACKAGE-INFERRED-SYSTEM::PACKAGE-INFERRED-SYSTEM-FILE-DEPENDENCIES
  • (INPUT-FILES (BASIC-CONCATENATE-SOURCE-OP SYSTEM))
  • (PERFORM (DELIVER-ASD-OP SYSTEM))
  • ASDF/PARSE-DEFSYSTEM:PARSE-COMPONENT-FORM
  • ASDF/PARSE-DEFSYSTEM::PARSE-DEPENDENCY-DEFS
  • ASDF/OPERATE:ALREADY-LOADED-SYSTEMS
  • ASDF/PLAN:REQUIRED-COMPONENTS
  • (COMPUTE-ACTION-STAMP (T OPERATION COMPONENT))
  • ASDF/FORCING:NORMALIZE-FORCED-NOT-SYSTEMS
  • ASDF/FORCING:NORMALIZE-FORCED-SYSTEMS
  • (OUTPUT-FILES AROUND (T T))
  • ASDF/SYSTEM-REGISTRY:REGISTERED-SYSTEMS
  • UIOP/CONFIGURATION:IN-FIRST-DIRECTORY
  • UIOP/CONFIGURATION:XDG-CONFIG-DIRS
  • UIOP/CONFIGURATION:XDG-DATA-DIRS
  • UIOP/LISP-BUILD:UNREIFY-DEFERRED-WARNINGS
  • UIOP/LISP-BUILD:REIFY-DEFERRED-WARNINGS
  • UIOP/LISP-BUILD::REIFY-UNDEFINED-WARNING
  • UIOP/LISP-BUILD:UNREIFY-SIMPLE-SEXP
  • UIOP/LISP-BUILD:REIFY-SIMPLE-SEXP
  • (WITH-DEPRECATION)
  • UIOP/VERSION:PARSE-VERSION
  • UIOP/UTILITY:REDUCE/STRCAT
  • (WHILE-COLLECTING)
  • (IF-LET)
  • ENSURE-PACKAGE
  • PACKAGE-DEFINITION-FORM
  • PACKAGES-FROM-NAMES
  • SB-COVER::COMPUTE-FILE-STATES
  • SB-SPROF:START-PROFILING
  • SKEL/MPK::MUSIC-METADATA-TAGS
  • (CHECK-ARGS)
  • SKEL/MPK/MPD::PARSE-LIST
  • SKEL/MPK/MPD::FILTER-KEYS
  • SKEL/MPK/MPD::SPLIT-VALUES
  • SKEL/HOMER/CLI::START-HOMER
  • (LOAD-AST (HOME-CONFIG))
  • (EXEC (HOMER-JOB))
  • (INIT ((EQL HOMER)))
  • SKEL/KRYPT:INIT-KRYPT
  • SKEL/PACKY::ENSURE-DIST-TARGET-DIRECTORIES
  • (SERDE (PKGBUILD PATHNAME))
  • SKEL/COMP/shell::PARSE-PKGBUILD
  • (WRITE-AST (ASDF-SYSTEM PATHNAME))
  • WRITE-ASD-COMPONENTS
  • (LOAD-AST (SKEL-PROJECT))
  • PRINT-SKEL-OBJECT
  • (WITH-SK-RULE-ENV)
  • MATH/SYN::PROCESS-SLICE
  • (B⊗)
  • (=)
  • (B=)
  • (B\)
  • (B/)
  • (B@)
  • (B./)
  • (B.*)
  • (B-)
  • (B+)
  • MATH/LAPACK:EIG
  • BUILDAH-RUN
  • PODMAN-RUN
  • (BUILD (ARCHISO-CONFIG))
  • BOX::FORMAT-ARCHISO-FILE-PERMISSIONS
  • (LOAD-AST AFTER (ARCHISO-CONFIG))
  • (DEPENDENCIES (PROJECT-DOCUMENTATION))
  • (DEPENDENTS (PROJECT-DOCUMENTATION))
  • PROJECT-DOCUMENTATION
  • MODULE-DOCUMENTATION
  • (DOC-FILES (MOD-COMPONENT))
  • (DOC-FILES (SYSTEM-DOCUMENTATION))
  • (DEPENDENCIES (SYSTEM-DOCUMENTATION))
  • (DEPENDENTS (SYSTEM-DOCUMENTATION))
  • SYSTEM-DOCUMENTATION
  • (PUBLISH (PACKAGE-DOCUMENTATION))
  • (DEPENDENCIES (PACKAGE-DOCUMENTATION))
  • (DEPENDENTS (PACKAGE-DOCUMENTATION))
  • PACKAGE-DOCUMENTATION
  • (CHANGE-CLASS (MOD-COMPONENT (EQL MOD-DOCUMENTATION)))
  • (PUBLISH (SYMBOL-DOCUMENTATION))
  • DOC::NORMALIZE-SOURCE-LOCATION-ALIST
  • (DOC-FILES (SYMBOL-DOCUMENTATION))
  • SYMBOL-TAG-STRING
  • FUZZY-MATCH
  • DOC/FUZZY::KEEP-EXACT-MATCHES-IN-SUGGESTIONS
  • DOC/FUZZY::SORT-SUGGESTIONS
  • DOC/FUZZY::SUBSTRING-NORM
  • SUMMARIZE-TEXT
  • (TEXTRANK (DOCUMENT-COLLECTION))
  • SENTENCE-TOKENIZE
  • WORD-TOKENIZE
  • (VC-EXPORT (HG-REPO))
  • MAKE-HG-REPO
  • FIND-HG-REQUIRES
  • VC/HG::FIND-HG-SUBMODULES
  • FIND-HG-BOOKMARKS
  • HG-BUNDLESPEC-STRING-P
  • RUN-HG-COMMAND
  • RUN-GIT-COMMAND
  • ORGAN/DB::INSERT-ORG-NODES
  • ORGAN/DB::INSERT-ORG-FILES
  • ORGAN/GRAPH:ORG-GRAPH-TINYSEARCH-JSON
  • ORGAN/GRAPH:ORG-GRAPH-MINISEARCH-JSON
  • ORGAN/GRAPH::ORG-GRAPH-NODE-FIX-PATHS
  • ORGAN/GRAPH::EXPAND-FILES
  • (BUILD (ORG-GRAPH))
  • (READ-AST ((EQL ORG-GRAPH) T))
  • (ORG-PARSE ((EQL HEADLINE) STREAM))
  • (MAKE-DB ((EQL RDB)))
  • (MULTI-GET (RDB-DATABASE T))
  • RDB::%RDB-INGESTOPT-NO-GETTER-P
  • RDB::%RDB-COMPACTOPT-NO-GETTER-P
  • RDB::%RDB-BACKUPOPT-NO-GETTER-P
  • RDB::%RDB-WRITEOPT-NO-GETTER-P
  • RDB::%RDB-READOPT-NO-GETTER-P
  • RDB::%RDB-OPT-NO-GETTER-P
  • RDB::MULTI-GET-CF-KV-STR-RAW
  • RDB::MULTI-GET-KV-STR-RAW
  • Q/SQL::PLAN-AGGREGATE-QUERY
  • Q/SQL::PLAN-NON-AGGREGATE-QUERY
  • Q/PROTO:EXTRACT-COLUMNS*
  • (SCHEMA (JOIN))
  • (PROJ (SCHEMA LIST))
  • (DESERIALIZE (JSON-OBJECT (EQL OPENAPI)))
  • NET/SRV/OPENAPI::OPENAPI-HEADERS-FROM-JSON
  • NET/SRV/OPENAPI::OPENAPI-RESPONSES-FROM-JSON
  • NET/SRV/OPENAPI::OPENAPI-PARAMETERS-FROM-JSON
  • NET/SRV/OPENAPI::OPENAPI-TAGS-FROM-JSON
  • NET/SRV/OPENAPI::OPENAPI-SERVERS-FROM-JSON
  • NET/SRV/OPENAPI::OPENAPI-PATHS-FROM-JSON
  • NET/SRV/OPENAPI::OPENAPI-RESPONSE-OBJECT-FROM-JSON
  • NET/SRV/OPENAPI::OPENAPI-OPERATION-FROM-JSON
  • NET/SRV/OPENAPI::OPENAPI-PATH-ITEM-FROM-JSON
  • NET/SRV/OPENAPI::OPENAPI-COMPONENTS-FROM-JSON
  • NET/REQ::REQ
  • (WITH-PEERS)
  • NET/PROTO/DBUS::REQUEST-NAME
  • (SUPPORTED-AUTHENTICATORS (STANDARD-DBUS-CONNECTION))
  • (CASE-BYTE)
  • (CASEV=)
  • (CASEV)
  • PARALLEL-REDUCE
  • (DEFINE-DBUS-SIGNAL-HANDLER)
  • (DEFINE-DBUS-METHOD)
  • (ENCODE-OSC-DATA (OSC-BUNDLE))
  • (TRAVERSE (CODE-PRINTER FUNCTION-DEFINITION T))
  • SYN/GEN/C/SYM::SYMBOL-APPEND
  • (ENUM)
  • SYN/GEN/C:FIX-CASE
  • SYN/GEN:CINTERN
  • (WITH-SUDO)
  • (WITH-GNUPLOT-TERM)
  • EXEC-PICARD
  • (LOAD-AST (MPV-CONFIG))
  • YTDL-LIST
  • YTDL-EXTRACTORS
  • SYSTEMD-UNITS
  • (TMUX-FORMAT)
  • CLI/TOOLS/TERM::FORMAT-TMUX-STRING
  • CLI/LINEDIT::APROPOS-WORD
  • CLI/LINEDIT::HELP
  • CLI/LINEDIT::MAKE-LIST-COMPLETER
  • VSPARK
  • SPARK
  • LD-LIBRARY-PATH-LIST
  • EXEC-PATH-LIST
  • CLI-ARGS
  • CRY/SSH::LOAD-SSH-CONFIG-FILE
  • PARSE/YACC:PARSE-WITH-LEXER
  • PARSE/YACC::ITEMS-CLOSURE
  • PARSE/YACC::MAP-LR1-COLLECTION
  • (MAKE-MATCHER)
  • JACK:JACK-ALL-NOTES-OFF
  • RT/FLAMEGRAPH::PRINT-GRAPH
  • RT/TRACING::JSON-FROM-TRACE-EVENT
  • (TRACED-FLET)
  • RT:RUN-ALL-TESTS
  • (DEFTEST)
  • (MAP-TESTS (TEST-SUITE T))
  • DAT/QRCODE::TAKE-DATA-IN-TURN
  • DAT/QRCODE::KANJI->BSTREAM
  • DAT/QRCODE::ALNUM->BSTREAM
  • DAT/QRCODE::NUMERIC->BSTREAM
  • (MODULE-PLACEMENT (QR-INPUT))
  • (DATA-ENCODING (QR-INPUT))
  • (VALIDATE-AND-ANALYSIS (QR-INPUT))
  • (GEN-POLY-GFLOG (RS-ECC))
  • DAT/QRCODE::BCH-XOR
  • DAT/QRCODE::POLY-SUBSTRACT
  • DAT/QRCODE::POLY-MULTIPLY
  • (WITH-GF-SHORTCUTS)
  • (WITH-GF-ARITHMETICS)
  • (WITH-GF-ACCESSORS)
  • (EXPECTED-VALUES (REGRETTABLE-HEX-VALUE))
  • (BIND-BITS)
  • DAT/GIF::DISPOSAL-METHOD-VALUE
  • (DEFINE-MIDI-MESSAGE)
  • DAT/MIDI::WRITE-BYTES
  • DAT/TAR::ATTRIBUTE-ALIST-TO-OCTETS
  • (CLOSE-TAR-FILE (T))
  • DAT/BIB::WRITE-BIBLIOGRAPHY
  • DAT/BIB::WRITE-BIBTEX-FIELDS
  • (UNWRAP (TOML-DOCUMENT))
  • (SERIALIZE (LIST (EQL INI)))
  • DAT/INI::INI-READ-PAIR
  • DAT/MIME:LOAD-MIME-INFO
  • (TRANSFORM-HTML5-DOM ((EQL XML) T))
  • (%PROCESS-START-TAG ((EQL IN-FOREIGN-CONTENT) T))
  • DAT/HTML::NODE-COUNT
  • (RUN-STATE* (T (EQL CDATA-SECTION-STATE)))
  • DAT/SVG:PARSE-SVG-STRING
  • DAT/SVG::GET-POINTS-FROM-PATH
  • DAT/SVG::POINTS-CLOSE-EQUAL-P
  • DAT/XML::START-TAG
  • DAT/XML::GENERATE-XML
  • DAT/PARQUET/GEN::PARSE-PARQUET-THRIFT-DEFINITIONS
  • DAT/PARQUET/GEN::%DEFINE-PARQUET-STRUCTS
  • DAT/PARQUET/GEN::PARQUET-JSON-STRUCTS
  • (DEFINE-PARQUET-ENUM)
  • DAT/CSS::FORMAT-DECLARATION
  • DAT/CSS::TRANSFORM-ORIGIN
  • DAT/JSON:JSON-POINTER-FROM-STRING
  • DAT/DOT::GRAPH-FROM-DOT
  • DAT/DOT:GRAPH-TO-DOT
  • DAT/DOT::NODE-TO-DOT
  • DAT/DOT::EDGE-TO-DOT
  • DAT/DOT::SUBGRAPH-PRINT
  • DAT/DOT::RANK-PRINT
  • BACKUP-FILE-SINK
  • FATAL!
  • ERROR!
  • WARN!
  • INFO!
  • DEBUG!
  • TRACE!
  • IO/KBD:SEARCH-KEYMAP
  • (DEFINE-KEYSYM-SETS)
  • IO/KBD::LIST-ALL-KEYCODES
  • (DEFINE-KEYSYM-NAMES)
  • IO/DISK::ALL-MOUNTPOINTS
  • DELETE-TEMPORARY-FILES
  • (MAKE-WRITERS)
  • (MAKE-READERS)
  • (WITH-INPUT-FROM-SEQUENCE)
  • SECURITY:PAM-FLAGS
  • (DEF-IO-OP)
  • (WITH-IO-URING-ZCRX-CQE)
  • (WITH-IO-URING-ZCRX-RQE)
  • (WITH-IO-TIMESPEC)
  • (WITH-IO-URING-RECVMSG-OUT)
  • (WITH-IO-URING-FILE-INDEX-RANGE)
  • (WITH-IO-URING-SYNC-CANCEL-REG)
  • (WITH-IO-URING-GETEVENTS-ARG)
  • (WITH-IO-URING-BUF-REG)
  • (WITH-IO-URING-BUF)
  • (WITH-IO-URING-PROBE)
  • (WITH-IO-URING-PROBE-OP)
  • (WITH-IO-URING-RSRC-UPDATE2)
  • (WITH-IO-URING-RSRC-UPDATE)
  • (WITH-IO-URING-RSRC-REGISTER)
  • (WITH-IO-URING-PARAMS)
  • (WITH-IO-CQRING-OFFSETS)
  • (WITH-IO-SQRING-OFFSETS)
  • (WITH-IO-URING-CQE)
  • OBJ/STORE::WARN-ON-REINITIALIZATION-DATA-LOSS
  • OBJ/STORE::INITIALIZE-NEW-SLOTS
  • MAP-CLASS
  • OBJ/STORE::REBUILD-SLOT-INDICES
  • MAKE-SSET
  • (UPDATE-INSTANCE-FOR-DIFFERENT-CLASS AFTER (STORED-OBJECT STORED-OBJECT))
  • CLASS-GRAPH
  • (MIN-CUT (GRAPH))
  • OBJ/GRAPH::WEIGH-CUT
  • (SHORTEST-PATH (GRAPH T T))
  • (MERGE-NODES (GRAPH T T))
  • (ADD-EDGE (SIMPLE-GRAPH LIST))
  • ((SETF NODE-EDGES) (T GRAPH T))
  • (DELETE-EDGE (GRAPH EDGE))
  • (DELETE-EDGE (GRAPH T))
  • (DELETE-NODE (GRAPH NODE))
  • (DELETE-NODE (SIMPLE-GRAPH T))
  • [BROKEN LINK: OBJ/DB:SET-DATABASE-BACKEND-OPTIONS]
  • OBJ/DB::PARSE-DATABASE-BACKEND-OPTIONS
  • (DEFCOMMAND)
  • LIST-ALL-COMMANDS
  • PARSE-INTERACTIVE-LAMBDA-LIST
  • (LOAD-AST (PROJECT-COMPONENT))
  • (CALL (PROJECT RULE))
  • (MAKE (PROJECT))
  • PROJECT-PATHS
  • PROJECT-DIRECTORIES
  • (SCHEMA-DIFF (T T))
  • SORTED-SLOTS
  • (COMPUTE-SLOT-FIELDS-BY-TYPE ((EQL INDEXED) T T))
  • (COMPUTE-SLOT-FIELDS-BY-TYPE (T T T))
  • COMPUTE-SLOT-FIELDS
  • (DEFCONFIG)
  • (TRAVERSE (T AST T))
  • (TRAVERSE (T LIST T))
  • (TRAVERSE AFTER (COPY-TRAVERSER NODE T))
  • OBJ/UUID::GET-NODE-ID
  • (DEFINE-COLOR-TYPE)
  • (WITH-COLUMNIFICATION)
  • (WITH-COORDINATES)
  • OBJ/TENSOR::LOOP-SLICE-ITERATION-PATH
  • (WITH-PEEKY!)
  • (TENSOR-FOLDL)
  • MAPSLICE
  • (MAP-TENSOR!)
  • (LAMBDA-EINSTEIN)
  • OBJ/TENSOR::LOOP-GENERATOR
  • OBJ/TENSOR::LOOP-GENERATOR-BASE
  • OBJ/TENSOR::PARSE-LOOPX
  • OBJ/TENSOR::GENERATE-PERMUTATIONS
  • (COPY! (PERMUTATION-CYCLE (EQL PERMUTATION-CYCLE)))
  • (DOREFS)
  • (OFFSET-REF)
  • (FOR-INDEX-ITERATOR ((EQL STRIDE) T T T))
  • (MOD-UPDATE)
  • (REALIFIED-TENSOR (TENSOR-CLASS))
  • (COMPLEXIFIED-TENSOR (TENSOR-CLASS))
  • (DEFINE-TENSOR-METHOD)
  • OBJ/URI::PARSE-PATH
  • DELETE-FROM-MIX
  • MIX
  • OBJ/META/MIX::%MIX
  • (PRINT-OBJECT (MIXIN-CLASS T))
  • ASSOCIATION-END-SLOT-NAMES
  • TRANSIENT-SLOT-NAMES
  • OBJ/META/STORED::COMPUTE-DERIVED-INDEX-TRIGGERS
  • OBJ/META/STORED::ENSURE-CLASS-INHERITS-FROM
  • (FIND-SLOT-DEF-NAMES-BY-TYPE (STORED-CLASS T))
  • OBJ/META/FAST::COMPUTE-EFFECTIVE-METHOD-LAMBDA-LIST
  • OBJ/META/FAST::MAKE-FAST-METHOD-LAMBDA
  • OBJ/META/FAST::CALL-FAST-METHOD-LAMBDA
  • OBJ/META/FAST::WRAP-IN-REINITIALIZE-ARGUMENTS
  • OBJ/META/FAST::LAMBDA-LIST-APPLY-ARGUMENTS
  • OBJ/META/FAST::ANONYMIZE-ORDINARY-LAMBDA-LIST
  • OBJ/META/FAST::UNPARSE-AUXILIARY
  • OBJ/META/FAST::UNPARSE-KEYWORD
  • OBJ/META/FAST::UNPARSE-OPTIONAL
  • OBJ/META/FAST::UNPARSE-REQUIRED
  • OBJ/META/FILTERED::CHECK-FILTERS
  • (COMPUTE-STATIC-CALL-SIGNATURES (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • OBJ/META/SEALED::TYPE-PROTOTYPE-PAIRS
  • OBJ/META/SEALED::SNODE-PROTOTYPE
  • OBJ/META/SEALED::MAP-CLASS-PROTOTYPES
  • (SPECIALIZER-PROTOTYPE (CLASS))
  • (REMOVE-METHOD BEFORE (SEALABLE-GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD))
  • (ADD-METHOD BEFORE (SEALABLE-GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD))
  • (SEAL-DOMAIN (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • (SEAL-DOMAIN BEFORE (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • (SEAL-METAOBJECT BEFORE (POTENTIALLY-SEALABLE-METHOD))
  • (MAKE-METHOD-LAMBDA AROUND (GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD T T))
  • (PRINT-OBJECT (DOMAIN T))
  • (WITH-KEYCTL-PKEY-QUERY)
  • (WITH-KEYCTL-KDF-PARAMS)
  • (WITH-KERNEL-TIMESPEC)
  • (WITH-MSGHDR)
  • (WITH-IOVEC)
  • (WITH-BTRFS-QGROUP-LIMIT)
  • (WITH-BTRFS-UTIL-SUBVOLUME-INFO)
  • SWANK-TRACE-DIALOG:REPORT-PARTIAL-TREE
  • SWANK-TRACE-DIALOG:DIALOG-UNTRACE-ALL
  • SWANK::LIST-CLASS-SYMBOLS
  • SWANK::LIST-STRUCTURE-SYMBOLS
  • SWANK::PRESENT-REPL-RESULTS-VIA-PRESENTATION-STREAMS
  • SWANK::MENU-CHOICES-FOR-PRESENTATION-ID
  • SWANK::PRESENT-REPL-RESULTS
  • (MAKE-SYMBOLS-LISTING ((EQL CLASSIFICATION) T))
  • SWANK::METHOD-SPECIALIZERS-FOR-INSPECT
  • SWANK::SCORE-COMPLETION
  • SWANK::COMPUTE-HIGHEST-SCORING-COMPLETION
  • SWANK::%MAKE-DUPLICATE-SYMBOLS-FILTER
  • SWANK::FUZZY-CONVERT-MATCHING-FOR-EMACS
  • SWANK::ARGLIST-REF
  • SWANK:COMPLETIONS-FOR-KEYWORD
  • (COMPUTE-ENRICHED-DECODED-ARGLIST ((EQL APPLY) T))
  • SWANK::EXTRA-KEYWORDS/SLOTS
  • SWANK::APPLICABLE-METHODS-KEYWORDS
  • SWANK::ENCODE-ARGLIST
  • SWANK::TRANSPOSE-LISTS
  • SWANK::FIND-MATCHING-PACKAGES
  • SWANK::PACKAGE-COMPLETION-SET
  • SWANK::SYMBOL-COMPLETION-SET
  • SWANK-REPL::INIT-GLOBAL-STREAM-REDIRECTION
  • SWANK::UPDATE-INDENTATION/DELTA-FOR-EMACS
  • SWANK::MOP-HELPER
  • SWANK:INSPECTOR-EVAL
  • SWANK::PREPARE-PART
  • SWANK::FIND-DEFINITION
  • SWANK:XREF
  • SWANK:FIND-DEFINITIONS-FOR-EMACS
  • SWANK:LIST-ALL-PACKAGE-NAMES
  • SWANK:APROPOS-LIST-FOR-EMACS
  • SWANK::FORMAT-COMPLETION-SET
  • SWANK:FRAME-LOCALS-AND-CATCH-TAGS
  • SWANK::SIMPLE-REPL
  • SWANK::CALL-WITH-BINDINGS
  • (FRAME-CATCH-TAGS IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (LIST-CALLEES IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (LIST-CALLERS IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (WHO-SPECIALIZES IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (WHO-MACROEXPANDS IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (WHO-REFERENCES IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (WHO-SETS IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (WHO-BINDS IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (WHO-CALLS IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::SIGIO-HANDLER
  • SWANK::DELETE-STALE-CONTRIB-FASL-FILES
  • SWANK::SRC-FILES
  • (WITH-TEMP-KECCAK-ROWS)
  • (WITH-TEMP-KECCAK-STATE)
  • (WITH-KECCAK-STATE-ACCESSORS)
  • STD/DEFSYS::CALL-SYSTEM-PROVIDERS
  • STD/DEFSYS::LOAD-SYSTEM-REQUIRES
  • (INIT ((EQL SYS)))
  • LOAD-COMPONENT
  • COMPILE-COMPONENT
  • READ-COMPONENT
  • STD/DEFSYS::%PARSE-COMPONENTS-FORM
  • STD/DEFSYS::%PARSE-COMPONENT-FORM
  • STD/DEFSYS::%MOD-COMPONENT-WALK
  • STD/DEFSYS::%PARSE-REQUIRE-FORM
  • STD/DEFSYS::%PARSE-PROVIDE-FORM
  • (CHANGE-CLASS (SYSTEM (EQL BENCH-SYSTEM)))
  • (CHANGE-CLASS (SYSTEM (EQL TEST-SYSTEM)))
  • (CHANGE-CLASS (SYSTEM (EQL SYSTEM)))
  • (CHANGE-CLASS (SYSTEM (EQL SYSTEM)))
  • (CHANGE-CLASS (MOD-COMPONENT (EQL MODULE)))
  • (CHANGE-CLASS (MODULE (EQL MOD-COMPONENT)))
  • DIRECTORY-SYSDEF-FILES
  • FIND-SYSTEM-DEPENDENTS
  • (REFUSING)
  • (USING)
  • LOAD-MODULES
  • STD/DEFSYS::LOAD-MODULE*
  • STD/DEFSYS::%LOAD-MODULE
  • STD/DEFSYS::%LOAD-PROTO
  • STD/DEFSYS::FIND-SUBMODULES
  • STD/DEFSYS::EXPAND-COMPONENT-REQUIRES
  • (PRINT-OBJECT (MOD-COMPONENT T))
  • (MAKE-LOAD-FORM (COMPONENT))
  • SYSDEFS
  • MAKE-SYMLINKS
  • INIT-XDG-DIRS
  • STD/OS::XDG-PATH-SPLIT
  • (DEFINE-PRINTER)
  • PRINT-IN-BOX
  • PRINT-TABLE
  • STD/PRINT::ROTATE-ROWS-TO-COLUMNS
  • FMT-TREE
  • STD/PRINT::FORMAT-TREE-SEGMENTS
  • FORMAT-SXHASH
  • STD/ASYNC::MAKE-INPUT-PARTS
  • (%SLET)
  • STD/ASYNC::MAKE-BINDING-DATA
  • STD/ASYNC::MAKE-BINDING-DATUM
  • (WITH-CLIENT-BINDINGS)
  • (WITH-SUBMIT-INDEXED)
  • (DO-FAST-RECEIVES)
  • FINISH-THREADS
  • (FLAGS-CASE)
  • (DEFINE-BITFIELD)
  • STD/COMP::UNREIFY-DEFERRED-WARNINGS
  • STD/COMP::REIFY-DEFERRED-WARNINGS
  • STD/COMP::REIFY-UNDEFINED-WARNING
  • (CHECKED-COMPILE-AND-ASSERT)
  • PRINT-SIGNALED-CONDITIONS
  • STD/COMP::%ASM
  • (DEFINE-ALIEN-ENUM)
  • ALIEN-ENUM-KEYS
  • ALIEN-ENUM-VALUES
  • CLONE-OCTET-VECTOR-LIST*
  • LOAD-ALIENS
  • (DEFINE-TYPE-MAPPING)
  • CHECK-LOGICAL-HOST
  • (DEFINE-LOGICAL-PATHNAME)
  • (WITH-COUNTDOWN)
  • CPU-VENDOR
  • SAVE-SHARED-OBJECTS
  • FORGET-SHARED-OBJECTS
  • PACKAGE-SYMBOL-NAMES
  • (DEFINE-TEMPLATE-METHOD)
  • (DEFCLASS!)
  • LIST-SLOT-VALUES-USING-CLASS
  • (WITH-FSLOTS)
  • SLOT-VALUES
  • STRUCT-SLOTS-AND-VALUES
  • LIST-CLASS-SLOTS
  • LIST-CLASS-METHODS
  • STD/META::LIST-INDIRECT-CLASS-METHODS
  • SHALLOW-COPY-OBJECT
  • INIT*
  • (COPY (T CONS))
  • STD/META::MAP-VERBS
  • (WITH-MEMOIZATION)
  • (DEFUNITS)
  • (LETY*)
  • (LETV*)
  • (DEFINE-CLASS)
  • (DEFCLASS*)
  • (DEFWITH)
  • (DEFONCE)
  • (DEFITYPED)
  • (DEFITYPED*)
  • (DEFTYPED)
  • (DEFTYPED*)
  • (MULTIPLE-VALUE-CASE)
  • STD/MACS::EXPAND-DESTRUCTURING-CASE
  • (XOR)
  • STD/MACS::GENERATE-SWITCH-BODY
  • STD/MACS::%WITH-COLLECTORS-GENSYMS-ALIST
  • (PLAMBDA)
  • (WITH-PANDORIC)
  • PANDORICLET-SET
  • PANDORICLET-GET
  • (NLET-TAIL)
  • (DLAMBDA)
  • (ONCE-ONLY)
  • (SORTF)
  • {-reader
  • (SUBST-MODE-PPCRE-LAMBDA-FORM)
  • (MATCH-MODE-PPCRE-LAMBDA-FORM)
  • (SCAN-MODE-PPCRE-LAMBDA-FORM)
  • (INCF-AFTER)
  • (CREATE-MATCHER-AUX (ALTERNATION T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL FLAGS) T))
  • (REMOVE-REGISTERS (SEQ))
  • (COPY-REGEX (ALTERNATION))
  • (COPY-REGEX (SEQ))
  • (WITH-UNIQUE-NAMES)
  • (REC)
  • MAP-PRODUCT
  • (RCURRY)
  • (CURRY)
  • (MULTIPLE-VALUE-COMPOSE)
  • DISJOIN
  • (STRING-CASE)
  • STD/STRING::%EMIT-STRING-CASE
  • STD/STRING::EMIT-COMMON-CHECKS
  • STD/STRING::FIND-BEST-SPLIT
  • STD/NAMED-READTABLES::LIST-ALL-NAMED-READTABLES
  • MERGE-READTABLES-INTO
  • (DEFREADTABLE)
  • (INITIALIZE-INSTANCE (DYNAMIC-HOOK))
  • (INITIALIZE-INSTANCE (VALUE-HOOK))
  • PARTIAL-MACROEXPAND-ALL
  • (USING-GENSYMS)
  • (ENSURE-FUNCTIONF)
  • (WITH-MARKING)
  • UNQUOTE-ARGS
  • (DEFUN!)
  • (DEFMACRO!)
  • (DEFMACRO/G!)
  • TOPOSORT
  • SET-EQUAL
  • MAPTREE
  • (CART-ETYPECASE)
  • (CART-ECASE)
  • MAPCART
  • CART
  • UNZIP
  • INTERSPERSE
  • (DEFERROR)
  • STD/CONDITION::%ANCESTORS
  • (DEFPKG)
  • ENSURE-PACKAGE
  • PACKAGE-DEFINITION-FORM
  • PACKAGES-FROM-NAMES
  • REEXPORT-PACKAGES
  • EXPORT-PACKAGES
  • (%MATCH)
  • STD/MACS::OPTIONAL-PATTERNS
  • (INITIALIZE-INSTANCE (KEY-HOOK))
  • (COMPUTE-APPLICABLE-METHODS (TENSOR-METHOD-GENERATOR T))

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

SPECIAL-FORM-FUNCTION names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:SPECIAL-FORM-FUNCTION>:
  Class precedence-list: SB-INT:SPECIAL-FORM-FUNCTION, UNDEFINED-FUNCTION,
                         CELL-ERROR, ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: UNDEFINED-FUNCTION
  No subclasses.
  No direct slots.

UNSIGNED-BYTE-WITH-A-BITE-OUT names a type-specifier:
  Lambda-list: (SIZE BITE)

MURMUR-HASH-WORD/FIXNUM names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;STRING-HASH.LISP

XSET-EMPTY-P names a compiled function:
  Lambda-list: (XSET)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;XSET.LISP

LOGICAL-PATHNAME-P names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;PATHNAME.LISP

• Called by
  • (PUBLISH (DEFINITION-SOURCE))

META-INFO-NUMBER names a compiled function:
  An accessor for SB-INT:META-INFO
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-INT:META-INFO)
                 (VALUES (UNSIGNED-BYTE 6) &OPTIONAL))
  Source file: SYS:SRC;COMPILER;EARLY-GLOBALDB.LISP

KEYWORDICATE names a compiled function:
  Lambda-list: (&REST THINGS)
  Derived type: (FUNCTION * (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Called by
  • CORE:DISPATCH-CORE
  • SKEL/COMP/shell::PARSE-PKGBUILD-VALUE
  • WRITE-ASD-COMPONENTS
  • (LOAD-AST (SKEL-PROJECT))
  • SKEL/CORE::SK-SLOT-NAME
  • (PUBLISH (PROJECT-DOCUMENTATION))
  • (PUBLISH (SYSTEM-DOCUMENTATION))
  • (PUBLISH (PACKAGE-DOCUMENTATION))
  • (PUBLISH (MOD-DOCUMENTATION))
  • (PUBLISH (FILE-DOCUMENTATION))
  • (PUBLISH (SYMBOL-DOCUMENTATION))
  • DOC::NORMALIZE-ALLOC-INFO
  • VC/HG::PARSE-HG-URI
  • HG-BUNDLESPEC-STRING-P
  • ORGAN/GRAPH::%FILE-KEYWORDS
  • (BUILD (ORG-GRAPH-EDGE))
  • ORGAN/GRAPH::WRAP-EDGE
  • (ORG-PARSE ((EQL PLANNING-LINE) STREAM))
  • (DEFINE-ORG-PARSER)
  • (DEFINE-ORG-OBJECT)
  • (DEFINE-ORG-ELEMENT)
  • [BROKEN LINK: RDB:SCHEMA-FROM-RDB-COLUMN-FAMILIES]
  • (AST (RDB-BACKUPOPTS))
  • (AST (RDB-COMPACTOPTS))
  • (AST (RDB-WRITEOPTS))
  • (AST (RDB-READOPTS))
  • (AST (RDB-OPTS))
  • ((SETF HEADER-OUT) (T STRING))
  • NET/PROTO/DM::GET-PEER
  • (GETF-TEMPO)
  • DAT/BIB::READ-BIBTEX-ENTRY
  • DAT/PARQUET/GEN::%DEFINE-PARQUET-STRUCTS
  • (DEFINE-PARQUET-ENUM)
  • (SPLIT-DIRECTIVE)
  • (DEFINE-LOG-LEVEL)
  • (INITIALIZE-INSTANCE AFTER (DECODING-STREAM))
  • [BROKEN LINK: OBJ/DB:SET-DATABASE-BACKEND-OPTIONS]
  • OBJ/DB::%DATABASE-BACKEND-OPTION-KEY
  • (DEFCOMMAND)
  • (DEFINE-COMMAND-TYPE)
  • OBJ/CMD::CMD-INTERN
  • SCHEMA-FROM-COLUMNS
  • (BUILD (FIELD))
  • (DEFCONFIG)
  • OBJ/TENSOR::LOOP-INDEX-ITERATION-PATH
  • TREE-SITTER:LANGUAGE-MODULE
  • (COMPILE-SYSTEM (SYSTEM))
  • (FIND-SYSTEM (T))
  • STD/DEFSYS::LOAD-SYSTEM-REQUIRES
  • (DEFSYS)
  • STD/DEFSYS::%PARSE-COMPONENT-FORM
  • STD/DEFSYS::%PARSE-REQUIRE-FORM
  • (CHANGE-CLASS (SYSTEM (EQL BENCH-SYSTEM)))
  • (CHANGE-CLASS (SYSTEM (EQL TEST-SYSTEM)))
  • (CHANGE-CLASS (SYSTEM (EQL SYSTEM)))
  • FIND-MODULE
  • (WITH-ALIEN-SLOTS)
  • (DEFINE-ALIEN-LOADER)
  • MACHINE-TARGET
  • (DEFCLASS!)
  • (DEFUNITS)
  • (DEFCLASS*)

%SIMPLE-TYPE-ERROR names a compiled function:
  Lambda-list: UNKNOWN
  Declared type: (FUNCTION
                  ((OR STRING FUNCTION SYMBOL CONDITION
                       SB-PCL::CONDITION-CLASS)
                   T T T &REST T)
                  NIL)
  Derived type: FUNCTION
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;COLD-ERROR.LISP

XSET-MEMBERS names a compiled function:
  Lambda-list: (XSET)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Source file: SYS:SRC;CODE;XSET.LISP

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

MAKE-STATIC-VECTOR names a compiled function:
  Lambda-list: (LENGTH &KEY (ELEMENT-TYPE (QUOTE (UNSIGNED-BYTE 8)))
                       (INITIAL-CONTENTS NIL CONTENTS-P)
                       (INITIAL-ELEMENT NIL ELEMENT-P))
  Derived type: (FUNCTION
                 (T &KEY (:ELEMENT-TYPE T) (:INITIAL-CONTENTS T)
                  (:INITIAL-ELEMENT T))
                 (VALUES T &OPTIONAL))
  Documentation:
    Allocate vector of LENGTH elements in static space. Only allocation
    of specialized arrays is supported.
  Source file: SYS:SRC;CODE;ARRAY.LISP

BOOTSTRAP-PACKAGE-NOT-FOUND names the condition-class #<SB-PCL::CONDITION-CLASSSB-INT:BOOTSTRAP-PACKAGE-NOT-FOUND>:
  Class precedence-list: SB-INT:BOOTSTRAP-PACKAGE-NOT-FOUND, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CONDITION
  No subclasses.
  Direct slots:
    SB-IMPL::NAME
      Initargs: :NAME
      Readers: SB-INT:BOOTSTRAP-PACKAGE-NAME

LOGICALLY-READONLYIZE names a compiled function:
  Lambda-list: (VECTOR &OPTIONAL (ALWAYS-SHAREABLE T))
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;STRING.LISP

READ-EVALUATED-FORM-OF-TYPE names a compiled function:
  Lambda-list: (TYPE &OPTIONAL (PROMPT-CONTROL NIL PROMPTP) &REST PROMPT-ARGS)
  Derived type: (FUNCTION (T &REST T) (VALUES CONS &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

SYS-TLAB-APPEND names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;LIST.LISP

MURMUR-HASH-WORD/+FIXNUM names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 62) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;STRING-HASH.LISP

XSET-COUNT names a compiled function:
  Lambda-list: (XSET)
  Derived type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Source file: SYS:SRC;CODE;XSET.LISP

MISC-INDEX names a compiled function:
  Lambda-list: (CHAR)
  Declared type: (FUNCTION (CHARACTER) (VALUES (MOD 23716) &OPTIONAL))
  Derived type: (FUNCTION (CHARACTER)
                 (VALUES (OR (INTEGER 0 0) (INTEGER 9 23715)) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;TARGET-CHAR.LISP

SFUNCTION names a type-specifier:
  Lambda-list: (ARGS &OPTIONAL RESULT)

SYS-COPY-STRUCT names a compiled function:
  Lambda-list: (STRUCTURE)
  Derived type: (FUNCTION (T) (VALUES SB-KERNEL:INSTANCE &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-DEFSTRUCT.LISP

ENCAPSULATE-FUNOBJ names a compiled function:
  Lambda-list: (TRACED-FUN &OPTIONAL (NAME NIL NAMEP))
  Derived type: (FUNCTION
                 ((OR (SATISFIES SB-KERNEL:SIMPLE-FUN-P)
                      (SATISFIES SB-KERNEL:CLOSUREP))
                  &OPTIONAL T)
                 (VALUES (OR NULL FUNCTION) &OPTIONAL))
  Source file: SYS:SRC;CODE;NTRACE.LISP

FSET names a compiled function:
  Lambda-list: (DESIGNATOR FUNCTION)
  Derived type: (FUNCTION
                 ((OR SB-KERNEL:FDEFN CONS SYMBOL) (OR FUNCTION (INTEGER 0 0)))
                 (VALUES (OR FUNCTION (INTEGER 0 0)) &OPTIONAL))
  Source file: SYS:SRC;CODE;LINKAGE-SPACE.LISP

STANDARD-READTABLE-MODIFIED-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:STANDARD-READTABLE-MODIFIED-ERROR>:
  Class precedence-list: SB-INT:STANDARD-READTABLE-MODIFIED-ERROR,
                         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::OPERATION
      Initargs: :OPERATION
      Readers: SB-KERNEL::STANDARD-READTABLE-MODIFIED-OPERATION

WITH-REBOUND-IO-SYNTAX names a macro:
  Lambda-list: (&BODY BODY)
  Source file: SYS:SRC;CODE;TOPLEVEL.LISP

MAKE-CASE-FROB-STREAM names a compiled function:
  Lambda-list: (TARGET KIND)
  Derived type: (FUNCTION
                 (STREAM
                  (MEMBER :UPCASE :DOWNCASE :CAPITALIZE :CAPITALIZE-FIRST))
                 (VALUES SB-IMPL::CASE-FROB-STREAM &OPTIONAL))
  Documentation:
    Return a stream that sends all output to the stream TARGET, but modifies
    the case of letters, depending on KIND, which should be one of:
      :UPCASE - convert to upper case.
      :DOWNCASE - convert to lower case.
      :CAPITALIZE - convert the first letter of words to upper case and the
         rest of the word to lower case.
      :CAPITALIZE-FIRST - convert the first letter of the first word to upper
         case and everything else to lower case.
  Source file: SYS:SRC;CODE;STREAM.LISP

• Called by
  • NIL
  • NIL
  • NIL
  • NIL
  • NIL
  • NIL

PROPER-LIST-OF-LENGTH-P names a compiled function:
  Lambda-list: (X MIN &OPTIONAL (MAX MIN))
  Derived type: (FUNCTION (T T &OPTIONAL T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

• Called by
  • SB-CLTL2::WALK-COMPILER-LET
  • SB-CLTL2::IR1-CONVERT-COMPILER-LET

NOT/TYPE names a macro:
  Lambda-list: (X)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

CLEAR-INFO-VALUES names a compiled function:
  Lambda-list: (NAME INFO-NUMBERS)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;COMPILER;GLOBALDB.LISP

PACKAGE-INTERNAL-SYMBOL-COUNT names a compiled function:
  Lambda-list: (PACKAGE)
  Derived type: (FUNCTION (T)
                 (VALUES (INTEGER -35184372088830 17592186044415) &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

FILE-NAME names a compiled function:
  Lambda-list: (STREAM &OPTIONAL NEW-NAME)
  Derived type: (FUNCTION (T &OPTIONAL T) *)
  Source file: SYS:SRC;CODE;FD-STREAM.LISP

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

POWER-OF-TWO-CEILING names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION ((UNSIGNED-BYTE 44))
                 (VALUES (INTEGER 1 17592186044416) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

SANE-PACKAGE names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES PACKAGE &OPTIONAL))
  Source file: SYS:SRC;CODE;PRIMORDIAL-EXTENSIONS.LISP

+FDEFN-INFO-NUM+ names a constant variable:
  Value: 63

PRINT-PRETTY-ON-STREAM-P names a compiled function:
  Lambda-list: (STREAM)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;PPRINT.LISP

XSET-SUBSET-P names a compiled function:
  Lambda-list: (XSET1 XSET2)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;XSET.LISP

SSET-COUNT names a compiled function:
  An accessor for SB-INT:SSET
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-INT:SSET) (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Source file: SYS:SRC;COMPILER;SSET.LISP

(SETF SSET-COUNT) names a compiled function:
  An accessor for SB-INT:SSET
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION ((UNSIGNED-BYTE 44) SB-INT:SSET)
                 (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Source file: SYS:SRC;COMPILER;SSET.LISP

C-STRING-DECODING-ERROR names a compiled function:
  Lambda-list: (EXTERNAL-FORMAT SAP OFFSET COUNT)
  Derived type: (FUNCTION (T T T T) NIL)
  Source file: SYS:SRC;CODE;FD-STREAM.LISP

C-STRING-DECODING-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:C-STRING-DECODING-ERROR>:
  Class precedence-list: SB-INT:C-STRING-DECODING-ERROR,
                         CHARACTER-DECODING-ERROR, CHARACTER-CODING-ERROR,
                         ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CHARACTER-DECODING-ERROR
  No subclasses.
  No direct slots.

STANDARD-PPRINT-DISPATCH-TABLE-MODIFIED-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:STANDARD-PPRINT-DISPATCH-TABLE-MODIFIED-ERROR>:
  Class precedence-list: SB-INT:STANDARD-PPRINT-DISPATCH-TABLE-MODIFIED-ERROR,
                         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::OPERATION
      Initargs: :OPERATION
      Readers: SB-KERNEL::STANDARD-PPRINT-DISPATCH-TABLE-MODIFIED-OPERATION

SET-CLOSURE-NAME names a compiled function:
  Lambda-list: (CLOSURE PERMIT-COPY NAME)
  Derived type: (FUNCTION (T T T)
                 (VALUES (OR (SATISFIES SB-KERNEL:CLOSUREP) FUNCTION)
                         &OPTIONAL))
  Source file: SYS:SRC;CODE;SIMPLE-FUN.LISP

MAKE-TRIVIAL-DEFAULT-LOGICAL-PATHNAME names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-PATHNAME.LISP

SIMPLE-COMPILER-NOTE names the condition-class #<SB-PCL::CONDITION-CLASS SB-INT:SIMPLE-COMPILER-NOTE>:
  Class precedence-list: SB-INT:SIMPLE-COMPILER-NOTE, SIMPLE-CONDITION,
                         COMPILER-NOTE, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SIMPLE-CONDITION, COMPILER-NOTE
  Direct subclasses: SB-C::PERFECT-HASH-GENERATOR-FAILED,
                     SB-C::UNKNOWN-TYPEP-NOTE, CODE-DELETION-NOTE
  No direct slots.

TWO-ARG-CHAR-GREATERP names a compiled function:
  Lambda-list: (C1 C2)
  Declared type: (FUNCTION (CHARACTER CHARACTER) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;TARGET-CHAR.LISP

GET-EXTERNAL-FORMAT names a compiled function:
  Lambda-list: (EXTERNAL-FORMAT)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;OCTETS.LISP

• Called by
  • DAT/HTML::FIND-ENCODING
  • (INITIALIZE-INSTANCE AFTER (DECODING-STREAM))
  • MAKE-FLEX-STREAM

*CL-PACKAGE* names a symbol macro:
  Expansion: #<PACKAGE "COMMON-LISP">

CHECK-DESIGNATOR names a compiled function:
  Lambda-list: (NAME MACRO &OPTIONAL (PREDICATE (FUNCTION SYMBOLP))
                (WHAT symbol) (ARG-REFERENCE NAME))
  Derived type: (FUNCTION (T T &OPTIONAL T T T) (VALUES NULL &OPTIONAL))
  Source file: SYS:SRC;COMPILER;PROCLAIM.LISP

MAYBE-DEFAULTED-EXTERNAL-FORMAT names a compiled function:
  Lambda-list: (EXTERNAL-FORMAT)
  Derived type: (FUNCTION (T) (VALUES (NOT NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;OCTETS.LISP

WITH-SANE-IO-SYNTAX names a macro:
  Lambda-list: (&BODY FORMS)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Macroexpanded by
  • STD/CORE::HANDLE-SERIOUS-CONDITION

TWO-ARG-CHAR-NOT-GREATERP names a compiled function:
  Lambda-list: (C1 C2)
  Declared type: (FUNCTION (CHARACTER CHARACTER) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;TARGET-CHAR.LISP

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

SIMPLE-READER-ERROR names a compiled function:
  Lambda-list: (STREAM CONTROL &REST ARGS)
  Declared type: (FUNCTION (STREAM STRING &REST T) NIL)
  Derived type: (FUNCTION (T T &REST T) NIL)
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;READER.LISP

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

• Called by
  • SB-COVER::SUPPRESS-SHARP-A
  • SB-COVER::SUPPRESS-SHARP-C
  • SB-COVER::MAKE-RECORDING-READ-LIST

PRINT-DEPRECATION-MESSAGE names a compiled function:
  Lambda-list: (NAMESPACE NAME SOFTWARE VERSION &OPTIONAL REPLACEMENTS STREAM)
  Derived type: (FUNCTION (T T T T &OPTIONAL T T)
                 (VALUES (OR STRING NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-EXTENSIONS.LISP

AVER names a macro:
  Lambda-list: (EXPR)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

• Macroexpanded by
  • (%64BIT-ROTATE-BYTE/C)
  • (%32BIT-ROTATE-BYTE/C)
  • SB-COVER::GET-RECORDS
  • SB-COVER::SOURCE-POSITION-LINE-NUMBER
  • SB-COVER::PACK-PAIR
  • SB-SPROF:STOP-PROFILING
  • SB-SPROF::CONVERT-RAW-DATA
  • SB-SPROF::EXTRACT-TRACES
  • SB-SPROF:MAP-TRACES

%INTERN names a compiled function:
  Lambda-list: (NAME LENGTH PACKAGE ELT-TYPE IGNORE-LOCK &OPTIONAL
                (ALLOW-INHERITED T))
  Derived type: (FUNCTION (T T T T T &OPTIONAL T)
                 (VALUES SYMBOL (MEMBER NIL :INHERITED :EXTERNAL :INTERNAL)
                         &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

COMMA-P names a compiled function:
  A predicate for SB-IMPL::COMMA
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;BACKQ.LISP

POSQ names a compiled function:
  Lambda-list: (ITEM LIST)
  Derived type: (FUNCTION (T T)
                 (VALUES (OR (MOD 17592186044415) NULL) &OPTIONAL))
  Documentation:
    Return the position of the first element EQ to ITEM.
  Source file: SYS:SRC;CODE;TARGET-EXTENSIONS.LISP

LL-KWDS-KEYP names a compiled function:
  Lambda-list: (BITS)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;COMPILER;PARSE-LAMBDA-LIST.LISP

DEPRECATED-THING-P names a compiled function:
  Lambda-list: (NAMESPACE NAME)
  Derived type: (FUNCTION (T T)
                 (VALUES (MEMBER :EARLY :LATE :FINAL NIL) &OPTIONAL CONS LIST))
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

DEBOOTSTRAP-PACKAGE names a compiled function:
  Lambda-list: (&OPTIONAL CONDITION)
  Derived type: (FUNCTION (&OPTIONAL T) NIL)
  Source file: SYS:SRC;CODE;TARGET-PACKAGE.LISP

FIXNUMP 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-ACLREPL::DISPLAY-INSPECT
  • (SOCKET-CLOSE (SOCKET))
  • (SOCKET-MAKE-STREAM (SOCKET))
  • (SOCKET-OPEN-P (SOCKET))
  • (PRINT-OBJECT (SOCKET T))
  • SB-POSIX:FILE-DESCRIPTOR
  • ((SETF COMPONENT-PROPERTY) (T COMPONENT T))
  • (COMPONENT-PROPERTY (COMPONENT T))
  • (INITIALIZE-INSTANCE AFTER (FILTERED-SEQUENTIAL-PLAN))
  • (COMPONENT-RELATIVE-PATHNAME (SYSTEM))
  • (COMPONENT-PATHNAME (SYSTEM))
  • (VERSION-SATISFIES (COMPONENT T))
  • (AROUND-COMPILE-HOOK (COMPONENT))
  • (COMPONENT-RELATIVE-PATHNAME (COMPONENT))
  • (COMPONENT-PATHNAME (COMPONENT))
  • SB-COVER::COVERAGE-AUGMENTATION
  • MATH/GRAPH:MAX-DAG
  • MATH/GRAPH:DIRECTED-SUBGRAPH
  • MATH/GRAPH:TREE-DECOMPOSITION
  • MATH/GRAPH:DIJKSTRA-PRIMS
  • MATH/GRAPH:DIJKSTRA
  • MATH/GRAPH:LINE-GRAPH
  • MATH/GRAPH:CHOLESKY-COVER
  • MATH/GRAPH:ELIMINATION-TREE
  • MATH/GRAPH:MAX-CARDINALITY-SEARCH
  • MATH/GRAPH::GRAPH-QUEUE
  • MATH/GRAPH:GNP
  • MATH/GRAPH::CLIQUEP
  • MATH/GRAPH::HYPER->BIPARTITE
  • MATH/GRAPH::ADLIST-TO-GRAPH
  • EXPT
  • ATAN
  • LOG
  • CONJUGATE
  • MATH/SYM::CONJUGATE!
  • IMAGPART
  • MATH/SYM::IMAGPART~
  • REALPART
  • MATH/SYM::REALPART~
  • MATH/SYM:⊗
  • /
  • MATH/SYM:@
  • MATH/LAPACK::ROOTS
  • MATH/LAPACK::POLYVAL
  • MATH/LAPACK::POLYFIT
  • (TRSYL! BEFORE (TENSOR TENSOR TENSOR))
  • (GELSY BEFORE (TENSOR TENSOR))
  • MATH/LAPACK::PSD-PROJ
  • MATH/LAPACK:EIG
  • MATH/LAPACK:GEEV-COMPLEXIFY-EIGVEC
  • (GEEV! BEFORE (TENSOR))
  • MATH/LAPACK:LDL-PERMUTE!
  • MATH/LAPACK:LDL
  • (POTRS! BEFORE (TENSOR TENSOR))
  • MATH/LAPACK:LU
  • (GETRI! BEFORE (TENSOR))
  • (GETRS! BEFORE (TENSOR TENSOR))
  • MATH/BLAS::TR
  • (TRS! BEFORE (T DENSE-TENSOR DENSE-TENSOR))
  • MATH/BLAS:MESHGRID
  • (GER (T DENSE-TENSOR DENSE-TENSOR (EQL NIL)))
  • (GER! BEFORE (T DENSE-TENSOR DENSE-TENSOR DENSE-TENSOR))
  • (GETT! BEFORE (T TENSOR TENSOR T TENSOR))
  • (GEM (T DENSE-TENSOR DENSE-TENSOR (EQL NIL) (EQL NIL)))
  • (GEM! BEFORE (T TENSOR TENSOR T TENSOR))
  • (PROD (DENSE-TENSOR))
  • (MEAN (DENSE-TENSOR))
  • (TENSOR-SUM (DENSE-TENSOR))
  • MATH/BLAS::REDUCE-CHECK
  • (AXPY! BEFORE (NUMBER BASE-TENSOR BASE-TENSOR))
  • PARSE-RESPONSE
  • PARSE-REQUEST
  • NET/PROTO/http::PARSE-CHUNKED-BODY
  • NET/PROTO/http::PARSE-HEADERS
  • NET/PROTO/http::PARSE-HEADER-FIELD-AND-VALUE
  • (SHARED-INITIALIZE AFTER (SOCKET T))
  • (TRAVERSE AFTER (CODE-PRINTER ATTRIBUTE-EXPRESSION T))
  • (TRAVERSE BEFORE (CODE-PRINTER ATTRIBUTE-EXPRESSION T))
  • (TRAVERSE (CODE-PRINTER COMMENT T))
  • (TRAVERSE AFTER (CODE-PRINTER TYPEDEF T))
  • (TRAVERSE (CODE-PRINTER TYPEDEF T))
  • (TRAVERSE BEFORE (CODE-PRINTER TYPEDEF T))
  • (TRAVERSE AFTER (CODE-PRINTER CAST-EXPRESSION T))
  • (TRAVERSE BEFORE (CODE-PRINTER CAST-EXPRESSION T))
  • (TRAVERSE (CODE-PRINTER INCLUDE T))
  • (TRAVERSE AFTER (CODE-PRINTER FUNCTION-CALL T))
  • (TRAVERSE (CODE-PRINTER FUNCTION-CALL T))
  • (TRAVERSE BEFORE (CODE-PRINTER FUNCTION-CALL T))
  • (TRAVERSE AFTER (CODE-PRINTER NOT-EXPRESSION T))
  • (TRAVERSE BEFORE (CODE-PRINTER NOT-EXPRESSION T))
  • (TRAVERSE (CODE-PRINTER POSTFIX-EXPRESSION T))
  • (TRAVERSE (CODE-PRINTER PREFIX-EXPRESSION T))
  • (TRAVERSE BEFORE (CODE-PRINTER PREFIX-EXPRESSION T))
  • (TRAVERSE AFTER (CODE-PRINTER CLIST T))
  • (TRAVERSE BEFORE (CODE-PRINTER CLIST T))
  • (TRAVERSE AFTER (CODE-PRINTER FLOAT-TYPE T))
  • (TRAVERSE AFTER (CODE-PRINTER LABEL-STATEMENT T))
  • (TRAVERSE BEFORE (CODE-PRINTER LABEL-STATEMENT T))
  • (TRAVERSE (CODE-PRINTER JUMP-STATEMENT T))
  • (TRAVERSE BEFORE (CODE-PRINTER JUMP-STATEMENT T))
  • (TRAVERSE AFTER (CODE-PRINTER CONDITIONAL-EXPRESSION T))
  • (TRAVERSE BEFORE (CODE-PRINTER CONDITIONAL-EXPRESSION T))
  • (TRAVERSE AFTER (CODE-PRINTER ASSIGNMENT-EXPRESSION T))
  • (TRAVERSE BEFORE (CODE-PRINTER ASSIGNMENT-EXPRESSION T))
  • (TRAVERSE AFTER (CODE-PRINTER INFIX-EXPRESSION T))
  • (TRAVERSE BEFORE (CODE-PRINTER INFIX-EXPRESSION T))
  • (TRAVERSE (CODE-PRINTER DECLARATION-ITEM T))
  • (TRAVERSE AFTER (CODE-PRINTER DECLARATION-LIST T))
  • (TRAVERSE BEFORE (CODE-PRINTER DECLARATION-LIST T))
  • (TRAVERSE AFTER (CODE-PRINTER ENUM-DEFINITION T))
  • (TRAVERSE (CODE-PRINTER ENUM-DEFINITION T))
  • (TRAVERSE BEFORE (CODE-PRINTER ENUM-DEFINITION T))
  • (TRAVERSE AFTER (CODE-PRINTER STRUCT-DEFINITION T))
  • (TRAVERSE BEFORE (CODE-PRINTER STRUCT-DEFINITION T))
  • (TRAVERSE AFTER (CODE-PRINTER PARAMETER-LIST T))
  • (TRAVERSE (CODE-PRINTER PARAMETER-LIST T))
  • (TRAVERSE BEFORE (CODE-PRINTER PARAMETER-LIST T))
  • (TRAVERSE AFTER (CODE-PRINTER FUNCTION-DEFINITION T))
  • (TRAVERSE (CODE-PRINTER FUNCTION-DEFINITION T))
  • (TRAVERSE BEFORE (CODE-PRINTER FUNCTION-DEFINITION T))
  • (TRAVERSE AFTER (CODE-PRINTER C-TYPE T))
  • (TRAVERSE AFTER (CODE-PRINTER COMPOUND-STATEMENT T))
  • (TRAVERSE (CODE-PRINTER COMPOUND-STATEMENT T))
  • (TRAVERSE BEFORE (CODE-PRINTER COMPOUND-STATEMENT T))
  • (TRAVERSE AFTER (CODE-PRINTER EXPRESSION-STATEMENT T))
  • (TRAVERSE BEFORE (CODE-PRINTER EXPRESSION-STATEMENT T))
  • PARSE/LEX:MATCHER-RANGE
  • IO/KBD::LIST-ALL-KEYCODES
  • (GET-STORE-SCHEMA (STORE T))
  • OBJ/BTREE::COMPARE<
  • OBJ/BTREE::COMPARE<=
  • DIAG~
  • DIAG
  • EYE
  • ONES
  • RANGE
  • OBJ/TENSOR::BLAS-MATRIX-COMPATIBLEP
  • OBJ/TENSOR::CONSECUTIVE-STOREP
  • OBJ/TENSOR::R3-VECTORP
  • OBJ/TENSOR::QUATERNION-VECTORP
  • OBJ/TENSOR::CHECK-DIMS
  • MAPSOR
  • (MAPSOR! BEFORE (FUNCTION TENSOR TENSOR))
  • RANDI
  • RANDE
  • OBJ/TENSOR::RANDE!
  • RAND
  • OBJ/TENSOR::RAND!
  • RANDN
  • OBJ/TENSOR::RANDN!
  • CTRANSPOSE
  • CTRANSPOSE!
  • TENSOR-CONJUGATE
  • TENSOR-CONJUGATE!
  • (TRANSPOSE)
  • (TRANSPOSE (DENSE-TENSOR))
  • (TRANSPOSE~)
  • TRANSPOSE~
  • (TRANSPOSE!)
  • TRANSPOSE!
  • (SCALD! BEFORE (DENSE-TENSOR DENSE-TENSOR))
  • (DIV (DENSE-TENSOR T))
  • (DIV! BEFORE (DENSE-TENSOR DENSE-TENSOR))
  • (SCAL! BEFORE (DENSE-TENSOR DENSE-TENSOR))
  • (DOT BEFORE (TENSOR TENSOR))
  • TENSOR-IMAGPART
  • TENSOR-REALPART
  • TENSOR-IMAGPART~
  • TENSOR-REALPART~
  • (GO= (NULL <SIMPLE-DENSE-TENSOR: BOOLEAN>))
  • (GA= (NULL <SIMPLE-DENSE-TENSOR: BOOLEAN>))
  • (GO= (TENSOR TENSOR))
  • (GA= (TENSOR TENSOR))
  • (GE= (TENSOR TENSOR))
  • JOIN
  • (RESHAPE! (DENSE-TENSOR CONS))
  • (SUPTENSOR~ (DENSE-TENSOR T))
  • ((SETF SUBTENSOR~) (T DENSE-TENSOR LIST))
  • (SUBTENSOR~ (DENSE-TENSOR LIST))
  • (PERMUTE! (TENSOR PERMUTATION-PIVOT-FLIP))
  • (PERMUTE! BEFORE (TENSOR PERMUTATION))
  • (SWAP! BEFORE (DENSE-TENSOR DENSE-TENSOR))
  • (COPY! (TENSOR SYMBOL))
  • (COPY! (DENSE-TENSOR SYMBOL))
  • (COPY! BEFORE (TENSOR TENSOR))
  • (COPY! (ARRAY SYMBOL))
  • (COPY! (CONS SYMBOL))
  • (COPY! BEFORE (ARRAY TENSOR))
  • (COPY! BEFORE (TENSOR ARRAY))
  • OBJ/TENSOR::COORDINATE-INDEXING
  • INDICES
  • (STORE-SIZE (GRAPH-ACCESSOR))
  • OBJ/TENSOR::%TENSOR-REF-SUBSCRIPTS
  • OBJ/TENSOR::GRAPH-INDEXING!
  • Δ-I
  • FENCE
  • (INITIALIZE-INSTANCE AFTER (STRIDE-ACCESSOR))
  • (HEAD (STRIDE-ACCESSOR))
  • STRIDES
  • (PRINT-OBJECT (GRAPH-ACCESSOR T))
  • PRINT-TENSOR
  • ZEROS
  • (TOTAL-SIZE (DENSE-TENSOR))
  • OBJ/TENSOR::TENSOR-SQUAREP
  • TENSOR-TYPEP
  • (INITIALIZE-INSTANCE AFTER (BASE-ACCESSOR))
  • DIMENSIONS
  • (SOCKET-FD IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • IRONCLAD::POWER-MOD
  • (SHARED-INITIALIZE AFTER (CIPHER T))
  • (PRINT-OBJECT (MOD-COMPONENT T))
  • (INITIALIZE-INSTANCE AFTER (PKG-COMPONENT))
  • STD/ASYNC::%PDOTIMES
  • STD/BIT::FLP2
  • (MSG (PIPE STRING))
  • ((SETF FILE) (T FILE-SOURCE))
  • ((SETF FILE) (T FILE-SINK))
  • STREAM-FD
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL BACK-REFERENCE) T))
  • (INITIALIZE-INSTANCE AFTER (STR))
  • STD/TYPE::GET-TYPE-ID
  • POSITIVE-FIXNUM-P
  • NON-NEGATIVE-FIXNUM-P
  • NON-POSITIVE-FIXNUM-P
  • NEGATIVE-FIXNUM-P
  • STD/NUM::%MULTIPLY-RANGE