SB-MOP

SLOT-DEFINITION-READERS names a generic function:
  Lambda-list: (SLOT-DEFINITION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-DEFINITION-READERS (DIRECT-SLOT-DEFINITION))
      Documentation:
        automatically generated reader method

(SETF SLOT-DEFINITION-READERS) names a generic function:
  Lambda-list: (NEW-VALUE SLOT-DEFINITION)
  Argument precedence order: (NEW-VALUE SLOT-DEFINITION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-DEFINITION-READERS) (T DIRECT-SLOT-DEFINITION))
      Documentation:
        automatically generated writer method

• Called by
  • SWANK::LIST-CLASS-SYMBOLS

CLASS-DIRECT-SUPERCLASSES names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (CLASS-DIRECT-SUPERCLASSES (CLASS))
      Documentation:
        automatically generated reader method

• Called by
  • (REALIFIED-TENSOR (TENSOR-CLASS))
  • (COMPLEXIFIED-TENSOR (TENSOR-CLASS))
  • OBJ/META/STORED::SUPERCLASS-MEMBER-P
  • (SHARED-INITIALIZE AROUND (STORED-CLASS T))
  • ADD-MIXIN
  • (SPECIALIZER-DIRECT-SUPERSPECIALIZERS (CLASS))
  • (EMACS-INSPECT (STANDARD-CLASS))
  • SWANK:MOP
  • SUBCLASSP

SLOT-BOUNDP-USING-CLASS names a generic function:
  Lambda-list: (CLASS OBJECT SLOTD)
  Argument precedence order: (CLASS OBJECT SLOTD)
  Derived type: (FUNCTION (T T T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-BOUNDP-USING-CLASS (STORED-CLASS STORED-OBJECT SYMBOL))
      Documentation:
        Checks if the slot exists in the database.
    (SLOT-BOUNDP-USING-CLASS (STORED-CLASS STORED-OBJECT
                              STORED-SLOT-DEFINITION))
      Documentation:
        Checks if the slot exists in the database.
    (SLOT-BOUNDP-USING-CLASS (STORED-CLASS STORED-OBJECT
                              ASSOCIATION-SLOT-DEFINITION))
    (SLOT-BOUNDP-USING-CLASS (DYNAMIC-CLASS T DYNAMIC-EFFECTIVE-SLOT))
    (SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT
                              STANDARD-EFFECTIVE-SLOT-DEFINITION))
    (SLOT-BOUNDP-USING-CLASS (CONDITION-CLASS CONDITION
                              CONDITION-EFFECTIVE-SLOT-DEFINITION))
    (SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT
                              STRUCTURE-EFFECTIVE-SLOT-DEFINITION))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • OBJ/STORE::UPDATE-SLOT-INDEX
  • OBJ/STORE::REMOVE-ASSOCIATION
  • OBJ/STORE::REMOVE-ASSOCIATION-END
  • OBJ/STORE::UPDATE-ASSOCIATION-END
  • (SLOT-VALUE-FOR-INSPECTOR (T T T))
  • LIST-SLOT-VALUES-USING-CLASS
  • (SLOT-MAKUNBOUND-USING-CLASS (STORED-CLASS STORED-OBJECT SET-VALUED-SLOT-DEFINITION))

FIND-METHOD-COMBINATION names a generic function:
  Lambda-list: (GENERIC-FUNCTION TYPE OPTIONS)
  Argument precedence order: (GENERIC-FUNCTION TYPE OPTIONS)
  Derived type: (FUNCTION (T T T) *)
  Method-combination: STANDARD
  Methods:
    (FIND-METHOD-COMBINATION (GENERIC-FUNCTION T T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

ADD-DEPENDENT names a generic function:
  Lambda-list: (METAOBJECT DEPENDENT)
  Argument precedence order: (METAOBJECT DEPENDENT)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    (ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

SLOT-DEFINITION-TYPE names a generic function:
  Lambda-list: (SLOT-DEFINITION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-DEFINITION-TYPE (SLOT-DEFINITION))
      Documentation:
        automatically generated reader method

(SETF SLOT-DEFINITION-TYPE) names a generic function:
  Lambda-list: (NEW-VALUE SLOT-DEFINITION)
  Argument precedence order: (NEW-VALUE SLOT-DEFINITION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-DEFINITION-TYPE) (T SLOT-DEFINITION))
      Documentation:
        automatically generated writer method
    ((SETF SLOT-DEFINITION-TYPE) :AFTER (T EFFECTIVE-SLOT-DEFINITION))

CLASS-SLOTS names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (CLASS-SLOTS (SLOT-CLASS))
      Documentation:
        automatically generated reader method
    (CLASS-SLOTS :BEFORE (SLOT-CLASS))
    (CLASS-SLOTS (SYSTEM-CLASS))
    (CLASS-SLOTS (FORWARD-REFERENCED-CLASS))

(SETF CLASS-SLOTS) names a generic function:
  Lambda-list: (NEW-VALUE SLOT-CLASS)
  Argument precedence order: (NEW-VALUE SLOT-CLASS)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  No methods.
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • SB-ACLREPL::INSPECTED-STANDARD-OBJECT-PARTS
  • PRINT-SKEL-OBJECT
  • OBJ/STORE::REBUILD-SLOT-INDICES
  • DROP-INSTANCE-SLOTS
  • (TRAVERSE AFTER (COPY-TRAVERSER NODE T))
  • (ALLOCATE-INSTANCE (DYNAMIC-CLASS))
  • SLOT-DVAR*
  • OBJ/META/STORED::TRANSIENT-SLOT-DEFS
  • (FIND-SLOT-DEFS-BY-TYPE (STORED-CLASS T))
  • (EMACS-INSPECT (STANDARD-CLASS))
  • (ALL-SLOTS-FOR-INSPECTOR (STANDARD-OBJECT))
  • SWANK::EXTRA-KEYWORDS/SLOTS
  • (MAKE-LOAD-FORM (COMPONENT))
  • STD/PRINT::%DESCRIBE-OBJECT
  • SLOT-VALUES
  • STRUCT-SLOTS-AND-VALUES
  • FIND-SLOT-DEF-BY-NAME
  • LIST-CLASS-SLOTS
  • SHALLOW-COPY-OBJECT
  • (SLOT-BOUNDP-USING-CLASS (STORED-CLASS STORED-OBJECT SYMBOL))

ENSURE-CLASS names a compiled function:
  Lambda-list: (NAME &REST ARGS)
  Derived type: (FUNCTION (T &REST T) *)
  Source file: SYS:SRC;PCL;STD-CLASS.LISP

• Called by
  • ADD-MIXIN

EXTRACT-SPECIALIZER-NAMES names a compiled function:
  Lambda-list: (LAMBDA-LIST)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Source file: SYS:SRC;PCL;BOOT.LISP

FUNCALLABLE-STANDARD-OBJECT names the funcallable-standard-class #<FUNCALLABLE-STANDARD-CLASS SB-MOP:FUNCALLABLE-STANDARD-OBJECT>:
  Class precedence-list: FUNCALLABLE-STANDARD-OBJECT, FUNCTION, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: FUNCTION, STANDARD-OBJECT
  Direct subclasses: RT/FUZZ:FUZZER, STYLE, TASK, HOOK, KERNEL-OBJECT,
                     GENERIC-FUNCTION
  No direct slots.

SLOT-MAKUNBOUND-USING-CLASS names a generic function:
  Lambda-list: (CLASS OBJECT SLOTD)
  Argument precedence order: (CLASS OBJECT SLOTD)
  Derived type: (FUNCTION (T T T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-MAKUNBOUND-USING-CLASS (STORED-CLASS STORED-OBJECT
                                  STORED-SLOT-DEFINITION))
      Documentation:
        Removes the slot value from the database.
    (SLOT-MAKUNBOUND-USING-CLASS (STORED-CLASS STORED-OBJECT
                                  ASSOCIATION-SLOT-DEFINITION))
    (SLOT-MAKUNBOUND-USING-CLASS (STORED-CLASS STORED-OBJECT
                                  SET-VALUED-SLOT-DEFINITION))
      Documentation:
        Make sure we reclaim the sset storage
    (SLOT-MAKUNBOUND-USING-CLASS (DYNAMIC-CLASS T DYNAMIC-EFFECTIVE-SLOT))
    (SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT
                                  STANDARD-EFFECTIVE-SLOT-DEFINITION))
    (SLOT-MAKUNBOUND-USING-CLASS (CONDITION-CLASS CONDITION
                                  CONDITION-EFFECTIVE-SLOT-DEFINITION))
    (SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT
                                  STRUCTURE-EFFECTIVE-SLOT-DEFINITION))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • DROP-INSTANCE-SLOTS
  • OBJ/STORE::REMOVE-ASSOCIATION
  • (ALL-SLOTS-FOR-INSPECTOR (STANDARD-OBJECT))
  • ((SETF SLOT-VALUE-USING-CLASS) (T STORED-CLASS STORED-OBJECT SET-VALUED-SLOT-DEFINITION))

CLASS-DIRECT-DEFAULT-INITARGS names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))
    (CLASS-DIRECT-DEFAULT-INITARGS (SYSTEM-CLASS))
    (CLASS-DIRECT-DEFAULT-INITARGS (FORWARD-REFERENCED-CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

EFFECTIVE-SLOT-DEFINITION-CLASS names a generic function:
  Lambda-list: (CLASS &REST INITARGS)
  Derived type: (FUNCTION (T &REST T) *)
  Method-combination: STANDARD
  Methods:
    (EFFECTIVE-SLOT-DEFINITION-CLASS (DYNAMIC-CLASS))
    (EFFECTIVE-SLOT-DEFINITION-CLASS (STORED-CLASS))
      Documentation:
        Chooses the stored or transient effective slot
        definition class depending on the keyword.
    (EFFECTIVE-SLOT-DEFINITION-CLASS (CONDITION-CLASS))
    (EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS))
    (EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

DIRECT-SLOT-DEFINITION-CLASS names a generic function:
  Lambda-list: (CLASS &REST INITARGS)
  Derived type: (FUNCTION (T &REST T) *)
  Method-combination: STANDARD
  Methods:
    (DIRECT-SLOT-DEFINITION-CLASS (DYNAMIC-CLASS))
    (DIRECT-SLOT-DEFINITION-CLASS (STORED-CLASS))
      Documentation:
        Checks for the transient tag (and the allocation type)
           and chooses stored or transient slot definitions.
    (DIRECT-SLOT-DEFINITION-CLASS (CONDITION-CLASS))
    (DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS))
    (DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

SLOT-DEFINITION-NAME names a generic function:
  Lambda-list: (SLOT-DEFINITION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-DEFINITION-NAME (SLOT-DEFINITION))
      Documentation:
        automatically generated reader method

(SETF SLOT-DEFINITION-NAME) names a generic function:
  Lambda-list: (NEW-VALUE SLOT-DEFINITION)
  Argument precedence order: (NEW-VALUE SLOT-DEFINITION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-DEFINITION-NAME) (T SLOT-DEFINITION))
      Documentation:
        automatically generated writer method

• Called by
  • SKEL/CORE::SK-PRINT-SLOT
  • (COMPUTE-SLOTS AROUND (STANDARD-CLASS))
  • OBJ/STORE::REBUILD-SLOT-INDICES
  • OBJ/STORE::ENSURE-SLOT-DEF-INDEX
  • OBJ/STORE::GET-STORE-INDEX
  • OBJ/STORE::UPDATE-DERIVED-SLOT
  • OBJ/STORE::GET-ASSOCIATIONS
  • OBJ/STORE::ADD-ASSOCIATION
  • OBJ/STORE::GET-STORE-ASSOCIATION-INDEX
  • OBJ/STORE::GET-ASSOCIATION-INDEX
  • OBJ/STORE::UPDATE-OTHER-ASSOCIATION-END
  • (COMPUTE-SLOT-FIELDS-BY-TYPE ((EQL INDEXED) T T))
  • (TRAVERSE AFTER (COPY-TRAVERSER NODE T))
  • (DEFINE-COLOR-TYPE)
  • (ALLOCATE-INSTANCE (DYNAMIC-CLASS))
  • SLOT-DVAR*
  • OBJ/META/STORED::FIND-CLASS-FOR-DIRECT-SLOT
  • ASSOCIATION-END-SLOT-NAMES
  • TRANSIENT-SLOT-NAMES
  • OBJ/META/STORED::COMPUTE-DERIVED-INDEX-TRIGGERS
  • (FIND-SLOT-DEF-NAMES-BY-TYPE (STORED-CLASS T))
  • (EMACS-INSPECT (STANDARD-SLOT-DEFINITION))
  • (EMACS-INSPECT (STANDARD-CLASS))
  • SWANK::QUERY-AND-SET-SLOT
  • SWANK::SLOT-HOME-CLASS-USING-CLASS
  • SWANK::MAKE-SLOT-LISTING
  • (ALL-SLOTS-FOR-INSPECTOR (STANDARD-OBJECT))
  • SWANK::EXTRA-KEYWORDS/SLOTS
  • (MAKE-LOAD-FORM (COMPONENT))
  • STD/PRINT::%DESCRIBE-OBJECT
  • PRINT-SLOT-EXCLUSION
  • LIST-SLOT-VALUES-USING-CLASS
  • SLOT-VALUES
  • STRUCT-SLOTS-AND-VALUES
  • SLOTS-AND-VALUES
  • FIND-SLOT-DEF-BY-NAME
  • FIND-DIRECT-SLOT-DEF-BY-NAME
  • STD/META::FIND-CLASS-FOR-DIRECT-SLOT
  • LIST-CLASS-SLOTS
  • SHALLOW-COPY-OBJECT
  • (NAME (SLOT-DEFINITION))
  • (SLOT-MAKUNBOUND-USING-CLASS (STORED-CLASS STORED-OBJECT STORED-SLOT-DEFINITION))
  • (SLOT-BOUNDP-USING-CLASS (STORED-CLASS STORED-OBJECT SYMBOL))
  • (SLOT-BOUNDP-USING-CLASS (STORED-CLASS STORED-OBJECT STORED-SLOT-DEFINITION))
  • (SLOT-VALUE-USING-CLASS (STORED-CLASS STORED-OBJECT STORED-SLOT-DEFINITION))
  • ((SETF SLOT-VALUE-USING-CLASS) (T STORED-CLASS STORED-OBJECT STORED-SLOT-DEFINITION))
  • ((SETF SLOT-VALUE-USING-CLASS) (T STORED-CLASS STORED-OBJECT ASSOCIATION-SLOT-DEFINITION))

STANDARD-DIRECT-SLOT-DEFINITION names the standard-class #<STANDARD-CLASS SB-MOP:STANDARD-DIRECT-SLOT-DEFINITION>:
  Class precedence-list: STANDARD-DIRECT-SLOT-DEFINITION,
                         STANDARD-SLOT-DEFINITION, DIRECT-SLOT-DEFINITION,
                         SLOT-DEFINITION, METAOBJECT,
                         SB-PCL::DEFINITION-SOURCE-MIXIN, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STANDARD-SLOT-DEFINITION, DIRECT-SLOT-DEFINITION
  Direct subclasses: OBJ/META/DYNAMIC::DYNAMIC-DIRECT-SLOT,
                     OBJ/META/STORED::TRANSIENT-DIRECT-SLOT-DEFINITION,
                     CACHED-DIRECT-SLOT-DEFINITION,
                     OBJ/META/STORED::STORED-DIRECT-SLOT-DEFINITION
  No direct slots.

ENSURE-CLASS-USING-CLASS names a generic function:
  Lambda-list: (CLASS NAME &REST ARGS &KEY &ALLOW-OTHER-KEYS)
  Argument precedence order: (CLASS NAME)
  Derived type: (FUNCTION (T T &REST T &KEY &ALLOW-OTHER-KEYS) *)
  Method-combination: STANDARD
  Methods:
    (ENSURE-CLASS-USING-CLASS (NULL T))
    (ENSURE-CLASS-USING-CLASS (PCL-CLASS T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • (DEFAULT-CLASS-CONSTRUCTOR (OBJECT-SCHEMA))

METHOD-GENERIC-FUNCTION names a generic function:
  Lambda-list: (STANDARD-METHOD)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (METHOD-GENERIC-FUNCTION (STANDARD-METHOD))
      Documentation:
        automatically generated reader method

(SETF METHOD-GENERIC-FUNCTION) names a generic function:
  Lambda-list: (NEW-VALUE STANDARD-METHOD)
  Argument precedence order: (NEW-VALUE STANDARD-METHOD)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF METHOD-GENERIC-FUNCTION) (T STANDARD-METHOD))
      Documentation:
        automatically generated writer method

• Called by
  • SB-INTROSPECT::METHOD-GENERIC-FUNCTION-NAME
  • SB-INTROSPECT:FIND-DEFINITION-SOURCE
  • (INITIALIZE-INSTANCE BEFORE (CACHED-METHOD))
  • SPECIALIZER-DIRECT-METHODS
  • (EMACS-INSPECT (STANDARD-METHOD))
  • SWANK::METHOD-FOR-INSPECT-VALUE
  • SWANK::METHOD-SPECIALIZERS-FOR-INSPECT
  • SWANK:DISASSEMBLE-FORM

STANDARD-EFFECTIVE-SLOT-DEFINITION names the standard-class #<STANDARD-CLASS SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION>:
  Class precedence-list: STANDARD-EFFECTIVE-SLOT-DEFINITION,
                         STANDARD-SLOT-DEFINITION, EFFECTIVE-SLOT-DEFINITION,
                         SLOT-DEFINITION, METAOBJECT,
                         SB-PCL::DEFINITION-SOURCE-MIXIN, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STANDARD-SLOT-DEFINITION, EFFECTIVE-SLOT-DEFINITION
  Direct subclasses: OBJ/META/DYNAMIC::DYNAMIC-EFFECTIVE-SLOT,
                     OBJ/META/STORED::TRANSIENT-EFFECTIVE-SLOT-DEFINITION,
                     OBJ/META/STORED::CACHED-EFFECTIVE-SLOT-DEFINITION,
                     OBJ/META/STORED::STORED-EFFECTIVE-SLOT-DEFINITION
  Direct slots:
    SB-PCL::LOCATION
      Readers: SLOT-DEFINITION-LOCATION
      Writers: (SETF SLOT-DEFINITION-LOCATION)
      Documentation:
       

FUNCALLABLE-STANDARD-CLASS names the standard-class #<STANDARD-CLASS SB-MOP:FUNCALLABLE-STANDARD-CLASS>:
  Class precedence-list: FUNCALLABLE-STANDARD-CLASS, SB-PCL::STD-CLASS,
                         SB-PCL::SLOT-CLASS, SB-PCL::PCL-CLASS, CLASS,
                         SB-PCL::DEPENDENT-UPDATE-MIXIN, SB-PCL::PLIST-MIXIN,
                         SB-PCL::DEFINITION-SOURCE-MIXIN,
                         SB-PCL::STANDARD-SPECIALIZER, SPECIALIZER, METAOBJECT,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-PCL::STD-CLASS
  Direct subclasses: KERNEL-CLASS
  No direct slots.

EQL-SPECIALIZER-OBJECT names a generic function:
  Lambda-list: (EQL-SPECIALIZER)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (EQL-SPECIALIZER-OBJECT (EQL-SPECIALIZER))
      Documentation:
        automatically generated reader method

• Called by
  • SB-INTROSPECT:WHO-SPECIALIZES-GENERALLY
  • SB-INTROSPECT:WHO-SPECIALIZES-DIRECTLY
  • (COMPUTE-APPLICABLE-METHODS-USING-CLASSES (TENSOR-METHOD-GENERATOR T))
  • (SPECIALIZER-PROTOTYPE (CLASS))
  • (SPECIALIZER-PROTOTYPE (EQL-SPECIALIZER))
  • (SEAL-SPECIALIZER (EQL-SPECIALIZER))
  • (SPECIALIZER-SEALED-P (EQL-SPECIALIZER))
  • (SPECIALIZER-SEALABLE-P (EQL-SPECIALIZER))
  • (SPECIALIZER-SUBSETP (EQL-SPECIALIZER CLASS))
  • (SPECIALIZER-SUBSETP (EQL-SPECIALIZER EQL-SPECIALIZER))
  • (SPECIALIZER-INTERSECTIONP (CLASS EQL-SPECIALIZER))
  • (SPECIALIZER-INTERSECTIONP (EQL-SPECIALIZER CLASS))
  • (SPECIALIZER-INTERSECTIONP (EQL-SPECIALIZER EQL-SPECIALIZER))
  • (SPECIALIZER-DIRECT-SUPERSPECIALIZERS (EQL-SPECIALIZER))
  • (SPECIALIZER-TYPE (EQL-SPECIALIZER))
  • SWANK::METHOD-SPECIALIZERS-FOR-INSPECT
  • (COMPUTE-APPLICABLE-METHODS (TENSOR-METHOD-GENERATOR T))

SPECIALIZER-DIRECT-GENERIC-FUNCTIONS names a generic function:
  Lambda-list: (SPECIALIZER)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • LIST-CLASS-METHODS
  • STD/META::LIST-INDIRECT-CLASS-METHODS

FUNCALLABLE-STANDARD-INSTANCE-ACCESS names a compiled function:
  Lambda-list: (INSTANCE LOCATION)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;PCL;SLOTS.LISP

(SETF FUNCALLABLE-STANDARD-INSTANCE-ACCESS) names a compiled function:
  Lambda-list: (NEW-VALUE INSTANCE LOCATION)
  Derived type: (FUNCTION (T T T) (VALUES T &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;PCL;SLOTS.LISP

SLOT-DEFINITION-INITFORM names a generic function:
  Lambda-list: (SLOT-DEFINITION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-DEFINITION-INITFORM (SLOT-DEFINITION))
      Documentation:
        automatically generated reader method

(SETF SLOT-DEFINITION-INITFORM) names a generic function:
  Lambda-list: (NEW-VALUE SLOT-DEFINITION)
  Argument precedence order: (NEW-VALUE SLOT-DEFINITION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-DEFINITION-INITFORM) (T SLOT-DEFINITION))
      Documentation:
        automatically generated writer method

• Called by
  • OBJ/META/STORED::MAKE-SLOTS-CACHE
  • (EMACS-INSPECT (STANDARD-SLOT-DEFINITION))
  • SWANK::EXTRA-KEYWORDS/SLOTS

READER-METHOD-CLASS names a generic function:
  Lambda-list: (CLASS DIRECT-SLOT &REST INITARGS)
  Argument precedence order: (CLASS DIRECT-SLOT)
  Derived type: (FUNCTION (T T &REST T) *)
  Method-combination: STANDARD
  Methods:
    (READER-METHOD-CLASS (SLOT-CLASS T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

CLASS-DIRECT-SLOTS names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (CLASS-DIRECT-SLOTS (SLOT-CLASS))
      Documentation:
        automatically generated reader method
    (CLASS-DIRECT-SLOTS (SYSTEM-CLASS))
    (CLASS-DIRECT-SLOTS (FORWARD-REFERENCED-CLASS))

(SETF CLASS-DIRECT-SLOTS) names a generic function:
  Lambda-list: (NEW-VALUE SLOT-CLASS)
  Argument precedence order: (NEW-VALUE SLOT-CLASS)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  No methods.
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • SWANK::LIST-CLASS-SYMBOLS
  • (EMACS-INSPECT (STANDARD-CLASS))
  • SWANK::SLOT-HOME-CLASS-USING-CLASS
  • (ALL-SLOTS-FOR-INSPECTOR (STANDARD-OBJECT))
  • SWANK::EXTRA-KEYWORDS/SLOTS
  • FIND-DIRECT-SLOT-DEF-BY-NAME

COMPUTE-SLOTS names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (COMPUTE-SLOTS :AROUND (STANDARD-CLASS))
    (COMPUTE-SLOTS :AROUND (CONDITION-CLASS))
    (COMPUTE-SLOTS (STANDARD-CLASS))
    (COMPUTE-SLOTS (FUNCALLABLE-STANDARD-CLASS))
    (COMPUTE-SLOTS (STRUCTURE-CLASS))
    (COMPUTE-SLOTS (CONDITION-CLASS))
    (COMPUTE-SLOTS :AROUND (FUNCALLABLE-STANDARD-CLASS))
    (COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • SLOTS-AND-VALUES

CLASS-DEFAULT-INITARGS names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (CLASS-DEFAULT-INITARGS (SLOT-CLASS))
    (CLASS-DEFAULT-INITARGS (SYSTEM-CLASS))
    (CLASS-DEFAULT-INITARGS (FORWARD-REFERENCED-CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • OBJ/SCHEMA::CLASS-DEFAULT-FIELDS

GENERIC-FUNCTION-METHODS names a generic function:
  Lambda-list: (GENERIC-FUNCTION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (GENERIC-FUNCTION-METHODS (STANDARD-GENERIC-FUNCTION))
      Documentation:
        automatically generated reader method

(SETF GENERIC-FUNCTION-METHODS) names a generic function:
  Lambda-list: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Argument precedence order: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF GENERIC-FUNCTION-METHODS) (T STANDARD-GENERIC-FUNCTION))
      Documentation:
        automatically generated writer method

• Called by
  • SB-INTROSPECT:FIND-FUNCTION-CALLEES
  • SB-INTROSPECT:FIND-DEFINITION-SOURCES-BY-NAME
  • (COMPUTE-APPLICABLE-METHODS-USING-CLASSES (TENSOR-METHOD-GENERATOR T))
  • (COMPUTE-EFFECTIVE-METHOD-FUNCTION (FAST-GENERIC-FUNCTION T T))
  • (COMPUTE-DISCRIMINATING-FUNCTION (FILTERED-FUNCTION))
  • (COMPUTE-STATIC-CALL-SIGNATURES (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • (ADD-METHOD AROUND (SEALABLE-GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD))
  • (SEAL-DOMAIN (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • SWANK::METHODS-BY-APPLICABILITY
  • SWANK::GENERIC-FUNCTION-KEYWORDS
  • (COMPUTE-APPLICABLE-METHODS (TENSOR-METHOD-GENERATOR T))

ADD-DIRECT-METHOD names a generic function:
  Lambda-list: (SPECIALIZER METHOD)
  Argument precedence order: (SPECIALIZER METHOD)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    (ADD-DIRECT-METHOD (SUBTYPE-SPECIALIZER T))
    (ADD-DIRECT-METHOD (GROUP-SPECIALIZER T))
    (ADD-DIRECT-METHOD (CLASSP-SPECIALIZER T))
    (ADD-DIRECT-METHOD :AROUND (SPECIALIZER METHOD))
    (ADD-DIRECT-METHOD (SPECIALIZER METHOD))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

DIRECT-SLOT-DEFINITION names the standard-class #<STANDARD-CLASS SB-MOP:DIRECT-SLOT-DEFINITION>:
  Class precedence-list: DIRECT-SLOT-DEFINITION, SLOT-DEFINITION, METAOBJECT,
                         SB-PCL::DEFINITION-SOURCE-MIXIN, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SLOT-DEFINITION
  Direct subclasses: SB-PCL::STRUCTURE-DIRECT-SLOT-DEFINITION,
                     SB-PCL::CONDITION-DIRECT-SLOT-DEFINITION,
                     STANDARD-DIRECT-SLOT-DEFINITION
  Direct slots:
    SB-PCL::READERS
      Initargs: :READERS
      Readers: SLOT-DEFINITION-READERS
      Writers: (SETF SLOT-DEFINITION-READERS)
      Documentation:

    SB-PCL::WRITERS
      Initargs: :WRITERS
      Readers: SLOT-DEFINITION-WRITERS
      Writers: (SETF SLOT-DEFINITION-WRITERS)
      Documentation:
       

REMOVE-DIRECT-SUBCLASS names a generic function:
  Lambda-list: (CLASS SUBCLASS)
  Argument precedence order: (CLASS SUBCLASS)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    (REMOVE-DIRECT-SUBCLASS (CLASS CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

GENERIC-FUNCTION-METHOD-COMBINATION names a generic function:
  Lambda-list: (GENERIC-FUNCTION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (GENERIC-FUNCTION-METHOD-COMBINATION (STANDARD-GENERIC-FUNCTION))
      Documentation:
        automatically generated reader method

(SETF GENERIC-FUNCTION-METHOD-COMBINATION) names a generic function:
  Lambda-list: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Argument precedence order: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF GENERIC-FUNCTION-METHOD-COMBINATION) (T STANDARD-GENERIC-FUNCTION))
      Documentation:
        automatically generated writer method

• Called by
  • OBJ/META/FAST::EFFECTIVE-METHOD-LAMBDA
  • (REINITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (INITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (EMACS-INSPECT (STANDARD-GENERIC-FUNCTION))

METHOD-LAMBDA-LIST names a generic function:
  Lambda-list: (M)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (METHOD-LAMBDA-LIST (STANDARD-METHOD))
      Documentation:
        automatically generated reader method

• Called by
  • OBJ/META/FAST::COMPUTE-EFFECTIVE-METHOD-LAMBDA-LIST
  • OBJ/META/FAST::CALL-FAST-METHOD-LAMBDA
  • (EMACS-INSPECT (STANDARD-METHOD))
  • SWANK::METHODS-KEYWORDS

SLOT-DEFINITION-INITARGS names a generic function:
  Lambda-list: (SLOT-DEFINITION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-DEFINITION-INITARGS (SLOT-DEFINITION))
      Documentation:
        automatically generated reader method

(SETF SLOT-DEFINITION-INITARGS) names a generic function:
  Lambda-list: (NEW-VALUE SLOT-DEFINITION)
  Argument precedence order: (NEW-VALUE SLOT-DEFINITION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-DEFINITION-INITARGS) (T SLOT-DEFINITION))
      Documentation:
        automatically generated writer method

• Called by
  • (EMACS-INSPECT (STANDARD-SLOT-DEFINITION))
  • SWANK::EXTRA-KEYWORDS/SLOTS

SLOT-DEFINITION-ALLOCATION names a generic function:
  Lambda-list: (SLOTD)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-DEFINITION-ALLOCATION (STORED-SLOT-DEFINITION))
    (SLOT-DEFINITION-ALLOCATION (CONDITION-SLOT-DEFINITION))
      Documentation:
        automatically generated reader method
    (SLOT-DEFINITION-ALLOCATION (STANDARD-SLOT-DEFINITION))
      Documentation:
        automatically generated reader method
    (SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))

(SETF SLOT-DEFINITION-ALLOCATION) names a generic function:
  Lambda-list: (NEW-VALUE STANDARD-SLOT-DEFINITION)
  Argument precedence order: (NEW-VALUE STANDARD-SLOT-DEFINITION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-DEFINITION-ALLOCATION) (T CONDITION-SLOT-DEFINITION))
      Documentation:
        automatically generated writer method
    ((SETF SLOT-DEFINITION-ALLOCATION) (T STANDARD-SLOT-DEFINITION))
      Documentation:
        automatically generated writer method

• Called by
  • (COMPUTE-SLOTS AROUND (STANDARD-CLASS))
  • STD/PRINT::%DESCRIBE-OBJECT
  • SLOTS-AND-VALUES

GENERIC-FUNCTION-NAME names a generic function:
  Lambda-list: (GENERIC-FUNCTION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (GENERIC-FUNCTION-NAME (STANDARD-GENERIC-FUNCTION))
      Documentation:
        automatically generated reader method

(SETF GENERIC-FUNCTION-NAME) names a generic function:
  Lambda-list: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Argument precedence order: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF GENERIC-FUNCTION-NAME) (T T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • SB-INTROSPECT::METHOD-GENERIC-FUNCTION-NAME
  • (SEAL-DOMAIN AFTER (FAST-GENERIC-FUNCTION DOMAIN))
  • (OPTIMIZE-FUNCTION-CALL (FAST-GENERIC-FUNCTION STATIC-CALL-SIGNATURE))
  • OBJ/META/FAST::MAKE-FAST-METHOD-LAMBDA
  • OBJ/META/FAST::EXPAND-EFFECTIVE-METHOD-BODY
  • (SEAL-DOMAIN BEFORE (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • SPECIALIZER-DIRECT-METHODS
  • (EMACS-INSPECT (STANDARD-METHOD))
  • (EMACS-INSPECT (STANDARD-GENERIC-FUNCTION))
  • SWANK::METHOD-FOR-INSPECT-VALUE
  • LIST-CLASS-METHODS
  • STD/META::REGISTER-VERB

GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER names a generic function:
  Lambda-list: (GENERIC-FUNCTION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER (STANDARD-GENERIC-FUNCTION))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • (REINITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (INITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (SEAL-DOMAIN BEFORE (SEALABLE-GENERIC-FUNCTION DOMAIN))

SLOT-DEFINITION-LOCATION names a generic function:
  Lambda-list: (STANDARD-EFFECTIVE-SLOT-DEFINITION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-DEFINITION-LOCATION (STANDARD-EFFECTIVE-SLOT-DEFINITION))
      Documentation:
        automatically generated reader method

(SETF SLOT-DEFINITION-LOCATION) names a generic function:
  Lambda-list: (NEW-VALUE STANDARD-EFFECTIVE-SLOT-DEFINITION)
  Argument precedence order: (NEW-VALUE STANDARD-EFFECTIVE-SLOT-DEFINITION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-DEFINITION-LOCATION) (T STANDARD-EFFECTIVE-SLOT-DEFINITION))
      Documentation:
        automatically generated writer method

• Called by
  • (ALLOCATE-INSTANCE (DYNAMIC-CLASS))
  • SLOT-DVAR
  • OBJ/META/STORED::MAKE-SLOTS-CACHE

STANDARD-WRITER-METHOD names the standard-class #<STANDARD-CLASS SB-MOP:STANDARD-WRITER-METHOD>:
  Class precedence-list: STANDARD-WRITER-METHOD, STANDARD-ACCESSOR-METHOD,
                         SB-PCL::ACCESSOR-METHOD, STANDARD-METHOD,
                         SB-PCL::PLIST-MIXIN, SB-PCL::DEFINITION-SOURCE-MIXIN,
                         METHOD, METAOBJECT, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STANDARD-ACCESSOR-METHOD
  No subclasses.
  No direct slots.

CLASS-PRECEDENCE-LIST names a generic function:
  Lambda-list: (PCL-CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (CLASS-PRECEDENCE-LIST (PCL-CLASS))
      Documentation:
        automatically generated reader method
    (CLASS-PRECEDENCE-LIST (FORWARD-REFERENCED-CLASS))

• Called by
  • OBJ/TENSOR::SUB-SPECIALIZER-P
  • (SEAL-METAOBJECT BEFORE (CLASS))
  • (EMACS-INSPECT (STANDARD-CLASS))
  • SWANK::SLOT-HOME-CLASS-USING-CLASS
  • SWANK::SPECIALIZER<
  • (DEFERROR)
  • STD/CONDITION::%ANCESTORS

METHOD-FUNCTION names a generic function:
  Lambda-list: (METHOD)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (METHOD-FUNCTION (STANDARD-METHOD))
      Documentation:
        automatically generated reader method

• Called by
  • SB-INTROSPECT:FIND-FUNCTION-CALLEES
  • (EMACS-INSPECT (STANDARD-METHOD))
  • SWANK:DISASSEMBLE-FORM

EXTRACT-LAMBDA-LIST names a compiled function:
  Lambda-list: (LAMBDA-LIST)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;PCL;BOOT.LISP

CLASS-PROTOTYPE names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (CLASS-PROTOTYPE (PCL-CLASS))
      Documentation:
        automatically generated reader method
    (CLASS-PROTOTYPE :BEFORE (PCL-CLASS))
    (CLASS-PROTOTYPE (STD-CLASS))
    (CLASS-PROTOTYPE (CONDITION-CLASS))
    (CLASS-PROTOTYPE (STRUCTURE-CLASS))

• Called by
  • OBJ/META/SEALED::MAP-CLASS-PROTOTYPES
  • (EMACS-INSPECT (STANDARD-CLASS))
  • SWANK::EXTRA-KEYWORDS/CHANGE-CLASS
  • SWANK::EXTRA-KEYWORDS/MAKE-INSTANCE

SPECIALIZER-DIRECT-METHODS names a generic function:
  Lambda-list: (SPECIALIZER)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SPECIALIZER-DIRECT-METHODS (SUBTYPE-SPECIALIZER))
      Documentation:
        automatically generated reader method
    (SPECIALIZER-DIRECT-METHODS (GROUP-SPECIALIZER))
      Documentation:
        automatically generated reader method
    (SPECIALIZER-DIRECT-METHODS (CLASSP-SPECIALIZER))
      Documentation:
        automatically generated reader method
    (SPECIALIZER-DIRECT-METHODS (SPECIALIZER))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • SB-INTROSPECT::COLLECT-SPECIALIZING-METHODS
  • (EMACS-INSPECT (STANDARD-CLASS))
  • SPECIALIZER-DIRECT-METHODS

INTERN-EQL-SPECIALIZER names a compiled function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) (VALUES T BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;PCL;DEFS.LISP

• Called by
  • ADD-MIXIN
  • (ENSURE-SPECIALIZER (CONS))

SET-FUNCALLABLE-INSTANCE-FUNCTION names a compiled function:
  Lambda-list: (FIN NEW-VALUE)
  Derived type: (FUNCTION (T FUNCTION) (VALUES FUNCTION &OPTIONAL))
  Source file: SYS:SRC;PCL;LOW.LISP

• Called by
  • RT/FUZZ:FUZZER
  • (INITIALIZE-INSTANCE (TEST))
  • (COMPUTE-DISCRIMINATING-FUNCTION (FILTERED-FUNCTION))
  • MAKE-TASK
  • (INITIALIZE-INSTANCE (DYNAMIC-HOOK))
  • (INITIALIZE-INSTANCE (VALUE-HOOK))
  • MAKE-KERNEL
  • (INITIALIZE-INSTANCE (KEY-HOOK))

COMPUTE-DISCRIMINATING-FUNCTION names a generic function:
  Lambda-list: (GF)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (COMPUTE-DISCRIMINATING-FUNCTION (FILTERED-FUNCTION))
    (COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))
    (COMPUTE-DISCRIMINATING-FUNCTION :AROUND (STANDARD-GENERIC-FUNCTION))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • (COMPUTE-DISCRIMINATING-FUNCTION (FILTERED-FUNCTION))

SPECIALIZER names the standard-class #<STANDARD-CLASS SB-MOP:SPECIALIZER>:
  Class precedence-list: SPECIALIZER, METAOBJECT, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: METAOBJECT
  Direct subclasses: OBJ/TENSOR::SUBTYPE-SPECIALIZER,
                     OBJ/TENSOR::GROUP-SPECIALIZER,
                     OBJ/TENSOR::CLASSP-SPECIALIZER,
                     SB-PCL::EXACT-CLASS-SPECIALIZER,
                     SB-PCL::SPECIALIZER-WITH-OBJECT,
                     SB-PCL::STANDARD-SPECIALIZER
  Direct slots:
    SB-PCL::%TYPE
      Readers: SB-PCL::SPECIALIZER-TYPE
      Documentation:
       

COMPUTE-DEFAULT-INITARGS names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

CLASS-DIRECT-SUBCLASSES names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (CLASS-DIRECT-SUBCLASSES (CLASS))
      Documentation:
        automatically generated reader method

• Called by
  • CUDA:CUDA-VECTOR
  • CLASS-GRAPH
  • (REALIFIED-TENSOR (TENSOR-CLASS))
  • (COMPLEXIFIED-TENSOR (TENSOR-CLASS))
  • TENSOR
  • OBJ/META/SEALED::MAP-CLASS-PROTOTYPES
  • SYS:IO-VECTOR
  • SYS:IO-VEC
  • (EMACS-INSPECT (STANDARD-CLASS))
  • SWANK:MOP
  • FOREIGN-VECTOR

EFFECTIVE-SLOT-DEFINITION names the standard-class #<STANDARD-CLASS SB-MOP:EFFECTIVE-SLOT-DEFINITION>:
  Class precedence-list: EFFECTIVE-SLOT-DEFINITION, SLOT-DEFINITION,METAOBJECT,
                         SB-PCL::DEFINITION-SOURCE-MIXIN, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SLOT-DEFINITION
  Direct subclasses: SB-PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION,
                     SB-PCL::CONDITION-EFFECTIVE-SLOT-DEFINITION,
                     STANDARD-EFFECTIVE-SLOT-DEFINITION
  Direct slots:
    SB-PCL::ACCESSOR-FLAGS
      Initform: 0
      Documentation:

    INFO
      Readers: SB-PCL::SLOT-DEFINITION-INFO
      Writers: (SETF SB-PCL::SLOT-DEFINITION-INFO)
      Documentation:
       

ACCESSOR-METHOD-SLOT-DEFINITION names a generic function:
  Lambda-list: (STANDARD-ACCESSOR-METHOD)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (ACCESSOR-METHOD-SLOT-DEFINITION (STANDARD-ACCESSOR-METHOD))
      Documentation:
        automatically generated reader method

METAOBJECT names the standard-class #<STANDARD-CLASS SB-MOP:METAOBJECT>:
  Class precedence-list: METAOBJECT, STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STANDARD-OBJECT
  Direct subclasses: SPECIALIZER, SLOT-DEFINITION, METHOD-COMBINATION, METHOD,
                     GENERIC-FUNCTION
  No direct slots.

SLOT-VALUE-USING-CLASS names a generic function:
  Lambda-list: (CLASS OBJECT SLOTD)
  Argument precedence order: (CLASS OBJECT SLOTD)
  Derived type: (FUNCTION (T T T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-VALUE-USING-CLASS (STORED-CLASS STORED-OBJECT STORED-SLOT-DEFINITION))
      Documentation:
        Get the slot value from the database.
    (SLOT-VALUE-USING-CLASS (STORED-CLASS STORED-OBJECT
                             ASSOCIATION-SLOT-DEFINITION))
    (SLOT-VALUE-USING-CLASS (STORED-CLASS STORED-OBJECT
                             SET-VALUED-SLOT-DEFINITION))
      Documentation:
        Ensure that there is a slot-set in the slot (lazy instantiation)
    (SLOT-VALUE-USING-CLASS (DYNAMIC-CLASS T DYNAMIC-EFFECTIVE-SLOT))
    (SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT
                             STANDARD-EFFECTIVE-SLOT-DEFINITION))
    (SLOT-VALUE-USING-CLASS (CONDITION-CLASS CONDITION
                             CONDITION-EFFECTIVE-SLOT-DEFINITION))
    (SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT
                             STRUCTURE-EFFECTIVE-SLOT-DEFINITION))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

(SETF SLOT-VALUE-USING-CLASS) names a generic function:
  Lambda-list: (NEW-VALUE CLASS OBJECT SLOTD)
  Argument precedence order: (NEW-VALUE CLASS OBJECT SLOTD)
  Derived type: (FUNCTION (T T T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-VALUE-USING-CLASS) (T STORED-CLASS STORED-OBJECT
                                    STORED-SLOT-DEFINITION))
      Documentation:
        Set the slot value in the database.
    ((SETF SLOT-VALUE-USING-CLASS) (T STORED-CLASS STORED-OBJECT
                                    ASSOCIATION-SLOT-DEFINITION))
    ((SETF SLOT-VALUE-USING-CLASS) (T STORED-CLASS STORED-OBJECT
                                    SET-VALUED-SLOT-DEFINITION))
      Documentation:
        Setting a value adds it to the slot set
    ((SETF SLOT-VALUE-USING-CLASS) (T DYNAMIC-CLASS T DYNAMIC-EFFECTIVE-SLOT))
    ((SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT
                                    STANDARD-EFFECTIVE-SLOT-DEFINITION))
    ((SETF SLOT-VALUE-USING-CLASS) (T CONDITION-CLASS CONDITION
                                    CONDITION-EFFECTIVE-SLOT-DEFINITION))
    ((SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT
                                    STRUCTURE-EFFECTIVE-SLOT-DEFINITION))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • OBJ/STORE::UPDATE-SLOT-INDEX
  • OBJ/STORE::REMOVE-ASSOCIATION-END
  • OBJ/STORE::UPDATE-ASSOCIATION-END
  • (SLOT-VALUE-FOR-INSPECTOR (T T T))
  • LIST-SLOT-VALUES-USING-CLASS
  • (SLOT-MAKUNBOUND-USING-CLASS (STORED-CLASS STORED-OBJECT SET-VALUED-SLOT-DEFINITION))
  • ((SETF SLOT-VALUE-USING-CLASS) (T STORED-CLASS STORED-OBJECT SET-VALUED-SLOT-DEFINITION))

STANDARD-SLOT-DEFINITION names the standard-class #<STANDARD-CLASS SB-MOP:STANDARD-SLOT-DEFINITION>:
  Class precedence-list: STANDARD-SLOT-DEFINITION, SLOT-DEFINITION, METAOBJECT,
                         SB-PCL::DEFINITION-SOURCE-MIXIN, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SLOT-DEFINITION
  Direct subclasses: TRANSIENT-SLOT-DEFINITION, CACHED-SLOT-DEFINITION,
                     STORED-SLOT-DEFINITION, STANDARD-EFFECTIVE-SLOT-DEFINITION,
                     STANDARD-DIRECT-SLOT-DEFINITION
  Direct slots:
    SB-PCL::ALLOCATION
      Initargs: :ALLOCATION
      Initform: :INSTANCE
      Readers: SLOT-DEFINITION-ALLOCATION
      Writers: (SETF SLOT-DEFINITION-ALLOCATION)
      Documentation:

    SB-PCL::ALLOCATION-CLASS
      Initargs: :ALLOCATION-CLASS
      Readers: SB-PCL::SLOT-DEFINITION-ALLOCATION-CLASS
      Writers: (SETF SB-PCL::SLOT-DEFINITION-ALLOCATION-CLASS)
      Documentation:
       

MAKE-METHOD-LAMBDA names a generic function:
  Lambda-list: (PROTO-GENERIC-FUNCTION PROTO-METHOD LAMBDA-EXPRESSION
                ENVIRONMENT)
  Argument precedence order: (PROTO-GENERIC-FUNCTION PROTO-METHOD
                              LAMBDA-EXPRESSION ENVIRONMENT)
  Derived type: (FUNCTION (T T T T) *)
  Method-combination: STANDARD
  Methods:
    (MAKE-METHOD-LAMBDA :AROUND (SEALABLE-STANDARD-GENERIC-FUNCTION FAST-METHOD
                                 T T))
    (MAKE-METHOD-LAMBDA :AROUND (GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD T
                                 T))
    (MAKE-METHOD-LAMBDA (STANDARD-GENERIC-FUNCTION STANDARD-METHOD T T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

STANDARD-READER-METHOD names the standard-class #<STANDARD-CLASS SB-MOP:STANDARD-READER-METHOD>:
  Class precedence-list: STANDARD-READER-METHOD, STANDARD-ACCESSOR-METHOD,
                         SB-PCL::ACCESSOR-METHOD, STANDARD-METHOD,
                         SB-PCL::PLIST-MIXIN, SB-PCL::DEFINITION-SOURCE-MIXIN,
                         METHOD, METAOBJECT, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STANDARD-ACCESSOR-METHOD
  No subclasses.
  No direct slots.

COMPUTE-EFFECTIVE-METHOD names a generic function:
  Lambda-list: (GENERIC-FUNCTION COMBIN APPLICABLE-METHODS)
  Argument precedence order: (GENERIC-FUNCTION COMBIN APPLICABLE-METHODS)
  Derived type: (FUNCTION (T T T) *)
  Method-combination: STANDARD
  Methods:
    (COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))
    (COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))
    (COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION STANDARD-METHOD-COMBINATION T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • OBJ/META/FAST::EFFECTIVE-METHOD-LAMBDA

CLASS-FINALIZED-P names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (CLASS-FINALIZED-P (CLASS))
      Documentation:
        automatically generated reader method

• Called by
  • OBJ/META/SEALED::MAP-CLASS-PROTOTYPES
  • (SEAL-METAOBJECT BEFORE (CLASS))
  • (EMACS-INSPECT (STANDARD-CLASS))
  • SWANK::SPECIALIZER<
  • SWANK::EXTRA-KEYWORDS/SLOTS
  • SWANK::CLASS-FROM-CLASS-NAME-FORM
  • ENSURE-FINALIZED

FINALIZE-INHERITANCE names a generic function:
  Lambda-list: (CLASS)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (FINALIZE-INHERITANCE :AFTER (STORED-CLASS))
    (FINALIZE-INHERITANCE (CONDITION-CLASS))
    (FINALIZE-INHERITANCE (STRUCTURE-CLASS))
    (FINALIZE-INHERITANCE (STD-CLASS))
    (FINALIZE-INHERITANCE (FORWARD-REFERENCED-CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • (SEAL-METAOBJECT BEFORE (CLASS))
  • (EMACS-INSPECT (STANDARD-CLASS))
  • SWANK::CLASS-FROM-CLASS-NAME-FORM
  • ENSURE-FINALIZED

GENERIC-FUNCTION-LAMBDA-LIST names a generic function:
  Lambda-list: (GENERIC-FUNCTION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • SB-INTROSPECT:FIND-DEFINITION-SOURCE
  • OBJ/META/FAST::COMPUTE-EFFECTIVE-METHOD-LAMBDA-LIST
  • (OPTIMIZE-FUNCTION-CALL (FAST-GENERIC-FUNCTION STATIC-CALL-SIGNATURE))
  • (REINITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (INITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (EMACS-INSPECT (STANDARD-GENERIC-FUNCTION))
  • (ARGLIST-DISPATCH ((EQL DEFMETHOD) T))

COMPUTE-APPLICABLE-METHODS-USING-CLASSES names a generic function:
  Lambda-list: (GENERIC-FUNCTION CLASSES)
  Argument precedence order: (GENERIC-FUNCTION CLASSES)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    (COMPUTE-APPLICABLE-METHODS-USING-CLASSES (TENSOR-METHOD-GENERATOR T))
    (COMPUTE-APPLICABLE-METHODS-USING-CLASSES (FILTERED-FUNCTION T))
    (COMPUTE-APPLICABLE-METHODS-USING-CLASSES (SIMPLE-FILTERED-FUNCTION T))
    (COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • SWANK::APPLICABLE-METHODS-KEYWORDS

FORWARD-REFERENCED-CLASS names the standard-class #<STANDARD-CLASS SB-MOP:FORWARD-REFERENCED-CLASS>:
  Class precedence-list: FORWARD-REFERENCED-CLASS, SB-PCL::PCL-CLASS, CLASS,
                         SB-PCL::DEPENDENT-UPDATE-MIXIN, SB-PCL::PLIST-MIXIN,
                         SB-PCL::DEFINITION-SOURCE-MIXIN,
                         SB-PCL::STANDARD-SPECIALIZER, SPECIALIZER, METAOBJECT,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-PCL::PCL-CLASS
  No subclasses.
  No direct slots.

REMOVE-DEPENDENT names a generic function:
  Lambda-list: (METAOBJECT DEPENDENT)
  Argument precedence order: (METAOBJECT DEPENDENT)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    (REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

UPDATE-DEPENDENT names a generic function:
  Lambda-list: (METAOBJECT DEPENDENT &REST INITARGS)
  Argument precedence order: (METAOBJECT DEPENDENT)
  Derived type: (FUNCTION (T T &REST T) *)
  Method-combination: STANDARD
  No methods.
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

STANDARD-ACCESSOR-METHOD names the standard-class #<STANDARD-CLASS SB-MOP:STANDARD-ACCESSOR-METHOD>:
  Class precedence-list: STANDARD-ACCESSOR-METHOD, SB-PCL::ACCESSOR-METHOD,
                         STANDARD-METHOD, SB-PCL::PLIST-MIXIN,
                         SB-PCL::DEFINITION-SOURCE-MIXIN, METHOD, METAOBJECT,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-PCL::ACCESSOR-METHOD
  Direct subclasses: STANDARD-WRITER-METHOD, STANDARD-READER-METHOD
  Direct slots:
    SB-PCL::%SLOT-DEFINITION
      Initargs: :SLOT-DEFINITION
      Readers: ACCESSOR-METHOD-SLOT-DEFINITION
      Documentation:
       

MAP-DEPENDENTS names a generic function:
  Lambda-list: (METAOBJECT FUNCTION)
  Argument precedence order: (METAOBJECT FUNCTION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    (MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

COMPUTE-CLASS-PRECEDENCE-LIST names a generic function:
  Lambda-list: (ROOT)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (COMPUTE-CLASS-PRECEDENCE-LIST (CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

• Called by
  • OBJ/META/STORED::FIND-CLASS-FOR-DIRECT-SLOT
  • STD/META::FIND-CLASS-FOR-DIRECT-SLOT
  • STD/META::LIST-INDIRECT-CLASS-METHODS

WRITER-METHOD-CLASS names a generic function:
  Lambda-list: (CLASS DIRECT-SLOT &REST INITARGS)
  Argument precedence order: (CLASS DIRECT-SLOT)
  Derived type: (FUNCTION (T T &REST T) *)
  Method-combination: STANDARD
  Methods:
    (WRITER-METHOD-CLASS (SLOT-CLASS T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

STANDARD-INSTANCE-ACCESS names a compiled function:
  Lambda-list: (INSTANCE LOCATION)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;PCL;SLOTS.LISP

(SETF STANDARD-INSTANCE-ACCESS) names a compiled function:
  Lambda-list: (NEW-VALUE INSTANCE LOCATION)
  Derived type: (FUNCTION (T T T) (VALUES T &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;PCL;SLOTS.LISP

• Called by
  • SLOT-DVAR

EQL-SPECIALIZER names the standard-class #<STANDARD-CLASS SB-MOP:EQL-SPECIALIZER>:
  Class precedence-list: EQL-SPECIALIZER, SB-PCL::STANDARD-SPECIALIZER,
                         SB-PCL::EXACT-CLASS-SPECIALIZER,
                         SB-PCL::SPECIALIZER-WITH-OBJECT, SPECIALIZER,
                         METAOBJECT, STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-PCL::STANDARD-SPECIALIZER,
                       SB-PCL::EXACT-CLASS-SPECIALIZER,
                       SB-PCL::SPECIALIZER-WITH-OBJECT
  No subclasses.
  Direct slots:
    SB-PCL::OBJECT
      Initargs: :OBJECT
      Readers: EQL-SPECIALIZER-OBJECT, SB-PCL::SPECIALIZER-OBJECT
      Documentation:

    SB-PCL::DIRECT-METHODS
      Initform: (CONS NIL NIL)
      Documentation:
       

REMOVE-DIRECT-METHOD names a generic function:
  Lambda-list: (SPECIALIZER METHOD)
  Argument precedence order: (SPECIALIZER METHOD)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    (REMOVE-DIRECT-METHOD (SUBTYPE-SPECIALIZER T))
    (REMOVE-DIRECT-METHOD (GROUP-SPECIALIZER T))
    (REMOVE-DIRECT-METHOD (CLASSP-SPECIALIZER T))
    (REMOVE-DIRECT-METHOD :AROUND (SPECIALIZER METHOD))
    (REMOVE-DIRECT-METHOD (SPECIALIZER METHOD))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

VALIDATE-SUPERCLASS names a generic function:
  Lambda-list: (CLASS SUPERCLASS)
  Argument precedence order: (CLASS SUPERCLASS)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    (VALIDATE-SUPERCLASS (STANDARD-GENERIC-FUNCTION TENSOR-METHOD-GENERATOR))
    (VALIDATE-SUPERCLASS (TENSOR-CLASS KERNEL-CLASS))
    (VALIDATE-SUPERCLASS (TENSOR-CLASS STANDARD-CLASS))
    (VALIDATE-SUPERCLASS (MIXIN-CLASS STANDARD-CLASS))
    (VALIDATE-SUPERCLASS (DYNAMIC-CLASS STANDARD-CLASS))
    (VALIDATE-SUPERCLASS (STANDARD-CLASS DYNAMIC-CLASS))
    (VALIDATE-SUPERCLASS (STORED-CLASS STANDARD-CLASS))
    (VALIDATE-SUPERCLASS (STANDARD-CLASS STORED-CLASS))
    (VALIDATE-SUPERCLASS (FOREIGN-VECTOR-CLASS STANDARD-CLASS))
    (VALIDATE-SUPERCLASS (KERNEL-CLASS STANDARD-CLASS))
    (VALIDATE-SUPERCLASS (KERNEL-CLASS FUNCALLABLE-STANDARD-CLASS))
    (VALIDATE-SUPERCLASS (CLASS CLASS))
    (VALIDATE-SUPERCLASS (CLASS SYSTEM-CLASS))
    (VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))
    (VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

SLOT-DEFINITION names the standard-class #<STANDARD-CLASS SB-MOP:SLOT-DEFINITION>:
  Class precedence-list: SLOT-DEFINITION, METAOBJECT,
                         SB-PCL::DEFINITION-SOURCE-MIXIN, STANDARD-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: METAOBJECT, SB-PCL::DEFINITION-SOURCE-MIXIN
  Direct subclasses: EFFECTIVE-SLOT-DEFINITION, DIRECT-SLOT-DEFINITION,
                     SB-PCL::STRUCTURE-SLOT-DEFINITION,
                     SB-PCL::CONDITION-SLOT-DEFINITION, STANDARD-SLOT-DEFINITION
  Direct slots:
    SB-PCL::NAME
      Initargs: :NAME
      Readers: SLOT-DEFINITION-NAME
      Writers: (SETF SLOT-DEFINITION-NAME)
      Documentation:

    SB-PCL::INITFORM
      Initargs: :INITFORM
      Readers: SLOT-DEFINITION-INITFORM
      Writers: (SETF SLOT-DEFINITION-INITFORM)
      Documentation:

    SB-PCL::INITFUNCTION
      Initargs: :INITFUNCTION
      Readers: SLOT-DEFINITION-INITFUNCTION
      Writers: (SETF SLOT-DEFINITION-INITFUNCTION)
      Documentation:

    SB-PCL::INITARGS
      Initargs: :INITARGS
      Readers: SLOT-DEFINITION-INITARGS
      Writers: (SETF SLOT-DEFINITION-INITARGS)
      Documentation:

    SB-PCL::%TYPE
      Initargs: :TYPE
      Initform: T
      Readers: SLOT-DEFINITION-TYPE
      Writers: (SETF SLOT-DEFINITION-TYPE)
      Documentation:

    SB-PCL::%DOCUMENTATION
      Initargs: :DOCUMENTATION
      Readers: SB-PCL::%SLOT-DEFINITION-DOCUMENTATION
      Documentation:

    SB-PCL::%CLASS
      Initargs: :CLASS
      Readers: SB-PCL::SLOT-DEFINITION-CLASS
      Writers: (SETF SB-PCL::SLOT-DEFINITION-CLASS)
      Documentation:
       

SLOT-DEFINITION-INITFUNCTION names a generic function:
  Lambda-list: (SLOT-DEFINITION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-DEFINITION-INITFUNCTION (SLOT-DEFINITION))
      Documentation:
        automatically generated reader method

(SETF SLOT-DEFINITION-INITFUNCTION) names a generic function:
  Lambda-list: (NEW-VALUE SLOT-DEFINITION)
  Argument precedence order: (NEW-VALUE SLOT-DEFINITION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-DEFINITION-INITFUNCTION) (T SLOT-DEFINITION))
      Documentation:
        automatically generated writer method

• Called by
  • (EMACS-INSPECT (STANDARD-SLOT-DEFINITION))
  • SWANK::EXTRA-KEYWORDS/SLOTS

ADD-DIRECT-SUBCLASS names a generic function:
  Lambda-list: (CLASS SUBCLASS)
  Argument precedence order: (CLASS SUBCLASS)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    (ADD-DIRECT-SUBCLASS (CLASS CLASS))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

GENERIC-FUNCTION-DECLARATIONS names a generic function:
  Lambda-list: (GENERIC-FUNCTION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (GENERIC-FUNCTION-DECLARATIONS (STANDARD-GENERIC-FUNCTION))
      Documentation:
        automatically generated reader method

(SETF GENERIC-FUNCTION-DECLARATIONS) names a generic function:
  Lambda-list: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Argument precedence order: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF GENERIC-FUNCTION-DECLARATIONS) (T STANDARD-GENERIC-FUNCTION))
      Documentation:
        automatically generated writer method

SLOT-DEFINITION-WRITERS names a generic function:
  Lambda-list: (SLOT-DEFINITION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (SLOT-DEFINITION-WRITERS (DIRECT-SLOT-DEFINITION))
      Documentation:
        automatically generated reader method

(SETF SLOT-DEFINITION-WRITERS) names a generic function:
  Lambda-list: (NEW-VALUE SLOT-DEFINITION)
  Argument precedence order: (NEW-VALUE SLOT-DEFINITION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF SLOT-DEFINITION-WRITERS) (T DIRECT-SLOT-DEFINITION))
      Documentation:
        automatically generated writer method

METHOD-SPECIALIZERS names a generic function:
  Lambda-list: (M)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (METHOD-SPECIALIZERS (STANDARD-METHOD))
      Documentation:
        automatically generated reader method

• Called by
  • SB-INTROSPECT:FIND-DEFINITION-SOURCE
  • OBJ/TENSOR::METHOD-MORE-SPECIFIC-P
  • (COMPUTE-APPLICABLE-METHODS-USING-CLASSES (TENSOR-METHOD-GENERATOR T))
  • (COMPUTE-STATIC-CALL-SIGNATURES (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • (REMOVE-METHOD BEFORE (SEALABLE-GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD))
  • (ADD-METHOD BEFORE (SEALABLE-GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD))
  • (ADD-METHOD AROUND (SEALABLE-GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD))
  • (SEAL-DOMAIN (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • (SEAL-METAOBJECT BEFORE (POTENTIALLY-SEALABLE-METHOD))
  • (METAOBJECT-SEALABLE-P (POTENTIALLY-SEALABLE-METHOD))
  • (METHOD-DOMAIN (METHOD))
  • (EMACS-INSPECT (STANDARD-METHOD))
  • SWANK::METHODS-BY-APPLICABILITY
  • SWANK::METHOD-SPECIALIZERS-FOR-INSPECT
  • (COMPUTE-APPLICABLE-METHODS (TENSOR-METHOD-GENERATOR T))

COMPUTE-EFFECTIVE-SLOT-DEFINITION names a generic function:
  Lambda-list: (CLASS NAME DSLOTDS)
  Argument precedence order: (CLASS NAME DSLOTDS)
  Derived type: (FUNCTION (T T T) *)
  Method-combination: STANDARD
  Methods:
    (COMPUTE-EFFECTIVE-SLOT-DEFINITION (DYNAMIC-CLASS T T))
    (COMPUTE-EFFECTIVE-SLOT-DEFINITION (STORED-CLASS T T))
    (COMPUTE-EFFECTIVE-SLOT-DEFINITION (CONDITION-CLASS T T))
    (COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP

GENERIC-FUNCTION-METHOD-CLASS names a generic function:
  Lambda-list: (GENERIC-FUNCTION)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (GENERIC-FUNCTION-METHOD-CLASS (STANDARD-GENERIC-FUNCTION))
      Documentation:
        automatically generated reader method

(SETF GENERIC-FUNCTION-METHOD-CLASS) names a generic function:
  Lambda-list: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Argument precedence order: (NEW-VALUE STANDARD-GENERIC-FUNCTION)
  Derived type: (FUNCTION (T T) *)
  Method-combination: STANDARD
  Methods:
    ((SETF GENERIC-FUNCTION-METHOD-CLASS) (T STANDARD-GENERIC-FUNCTION))
      Documentation:
        automatically generated writer method

• Called by
  • OBJ/META/FAST::WRAP-IN-CALL-METHOD-MACROLET
  • (REINITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (INITIALIZE-INSTANCE AFTER (FILTERED-FUNCTION))
  • (EMACS-INSPECT (STANDARD-GENERIC-FUNCTION))

ENSURE-GENERIC-FUNCTION-USING-CLASS names a generic function:
  Lambda-list: (GENERIC-FUNCTION FUN-NAME &KEY &ALLOW-OTHER-KEYS)
  Argument precedence order: (GENERIC-FUNCTION FUN-NAME)
  Derived type: (FUNCTION
                 (T T &KEY (:GENERIC-FUNCTION-CLASS T) (:ENVIRONMENT T)
                  &ALLOW-OTHER-KEYS)
                 *)
  Method-combination: STANDARD
  Methods:
    (ENSURE-GENERIC-FUNCTION-USING-CLASS (NULL T))
    (ENSURE-GENERIC-FUNCTION-USING-CLASS (GENERIC-FUNCTION T))
  Source file: SYS:SRC;PCL;GENERIC-FUNCTIONS.LISP