UIOP/LISP-BUILD

*COMPILE-FILE-FAILURE-BEHAVIOUR* names a special variable:
  Value: :ERROR
  Documentation:
    How should ASDF react if it encounters a failure (per the ANSI spec ofCOMPILE-FILE)
    when compiling a file, which includes any non-style-warning warning.
    Valid values are :error, :warn, and :ignore.
    Note that ASDF ALWAYS raises an error if it fails to create an output filewhen compiling.

• Set by
  • ((SETF OPERATION-ON-FAILURE) (T OPERATION))
• Bound by
  • (OPERATE AROUND (T T))
• Referenced by
  • (OPERATION-ON-FAILURE (OPERATION))
  • (OPERATE AROUND (T T))
  • UIOP/LISP-BUILD:COMPILE-FILE*
  • CHECK-LISP-COMPILE-WARNINGS

*COMPILE-CHECK* names a special variable:
  Value: NIL
  Documentation:
    A hook for user-defined compile-time invariants

• Referenced by
  • UIOP/LISP-BUILD:COMPILE-FILE*

CHECK-LISP-COMPILE-WARNINGS names a compiled function:
  Lambda-list: (WARNINGS-P FAILURE-P &OPTIONAL CONTEXT-FORMAT CONTEXT-ARGUMENTS)
  Derived type: (FUNCTION (T T &OPTIONAL T T) (VALUES NULL &OPTIONAL))
  Documentation:
    Given the warnings or failures as resulted from COMPILE-FILE or checkingdeferred warnings,
    raise an error or warning as appropriate
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • CHECK-DEFERRED-WARNINGS
  • CHECK-LISP-COMPILE-RESULTS

CHECK-DEFERRED-WARNINGS names a compiled function:
  Lambda-list: (FILES &OPTIONAL CONTEXT-FORMAT CONTEXT-ARGUMENTS)
  Derived type: (FUNCTION (T &OPTIONAL T T) *)
  Documentation:
    Given a list of FILES containing deferred warnings saved by CALL-WITH-SAVED-DEFERRED-WARNINGS,
    re-intern and raise any warnings that are still meaningful.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/LISP-ACTION::PERFORM-LISP-WARNINGS-CHECK

PROCLAIM-OPTIMIZATION-SETTINGS names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES T &OPTIONAL))
  Documentation:
    Proclaim the optimization settings in *OPTIMIZATION-SETTINGS*
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

RESET-DEFERRED-WARNINGS names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES (OR NULL (INTEGER 0 0)) &OPTIONAL))
  Documentation:
    Reset the set of deferred warnings to be handled at the end of the currentWITH-COMPILATION-UNIT.
    One of three functions required for deferred-warnings support in ASDF.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • CALL-WITH-SAVED-DEFERRED-WARNINGS
  • CHECK-DEFERRED-WARNINGS

COMPILE-FILE-TYPE names a compiled function:
  Lambda-list: (&REST KEYS)
  Derived type: (FUNCTION *
                 (VALUES
                  (OR SIMPLE-STRING SB-IMPL::PATTERN
                      (MEMBER :WILD :UNSPECIFIC NIL))
                  &OPTIONAL))
  Documentation:
    pathname TYPE for lisp FASt Loading files
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/BACKWARD-INTERFACE:ENABLE-ASDF-BINARY-LOCATIONS-COMPATIBILITY
  • (PERFORM (BASIC-COMPILE-BUNDLE-OP SYSTEM))
  • ASDF/BUNDLE:BUNDLE-PATHNAME-TYPE
  • UIOP/LISP-BUILD:COMPILE-FILE-PATHNAME*

COMPILE-CONDITION names the condition-class #<SB-PCL::CONDITION-CLASS UIOP/LISP-BUILD:COMPILE-CONDITION>:
  Class precedence-list: UIOP/LISP-BUILD:COMPILE-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CONDITION
  Direct subclasses: UIOP/LISP-BUILD:COMPILE-FAILED-ERROR,
                     UIOP/LISP-BUILD:COMPILE-FAILED-WARNING,
                     UIOP/LISP-BUILD:COMPILE-WARNED-ERROR,
                     UIOP/LISP-BUILD:COMPILE-WARNED-WARNING,
                     UIOP/LISP-BUILD:COMPILE-FILE-ERROR
  Direct slots:
    UIOP/LISP-BUILD::CONTEXT-FORMAT
      Initargs: :CONTEXT-FORMAT
      Initform: 'NIL
      Readers: UIOP/LISP-BUILD::COMPILE-CONDITION-CONTEXT-FORMAT
    UIOP/LISP-BUILD::CONTEXT-ARGUMENTS
      Initargs: :CONTEXT-ARGUMENTS
      Initform: 'NIL
      Readers: UIOP/LISP-BUILD::COMPILE-CONDITION-CONTEXT-ARGUMENTS
    UIOP/LISP-BUILD::DESCRIPTION
      Initargs: :DESCRIPTION
      Initform: 'NIL
      Readers: UIOP/LISP-BUILD::COMPILE-CONDITION-DESCRIPTION

*WARNINGS-FILE-TYPE* names a special variable:
  Value: NIL
  Documentation:
    Pathname type for warnings files, or NIL if disabled

• Set by
  • UIOP/LISP-BUILD:DISABLE-DEFERRED-WARNINGS-CHECK
  • UIOP/LISP-BUILD:ENABLE-DEFERRED-WARNINGS-CHECK
• Referenced by
  • (OUTPUT-FILES (COMPILE-OP SYSTEM))
  • (INPUT-FILES (COMPILE-OP SYSTEM))
  • (PERFORM (COMPILE-OP SYSTEM))
  • ASDF/LISP-ACTION:LISP-COMPILATION-OUTPUT-FILES
  • UIOP/LISP-BUILD:WARNINGS-FILE-P

UNREIFY-DEFERRED-WARNINGS names a compiled function:
  Lambda-list: (REIFIED-DEFERRED-WARNINGS)
  Derived type: (FUNCTION (T) (VALUES NULL &OPTIONAL))
  Documentation:
    given a S-expression created by REIFY-DEFERRED-WARNINGS, reinstantiate thecorresponding
    deferred warnings as to be handled at the end of the current WITH-COMPILATION-UNIT.
    Handle any warning that has been resolved already,
    such as an undefined function that has been defined since.
    One of three functions required for deferred-warnings support in ASDF.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • CHECK-DEFERRED-WARNINGS

GET-OPTIMIZATION-SETTINGS names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES LIST &OPTIONAL))
  Documentation:
    Get current compiler optimization settings, ready to PROCLAIM again
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/LISP-BUILD:PROCLAIM-OPTIMIZATION-SETTINGS

REIFY-DEFERRED-WARNINGS names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES LIST &OPTIONAL))
  Documentation:
    return a portable S-expression, portably readable and writeable in anyCommon Lisp implementation
    using READ within a WITH-SAFE-IO-SYNTAX, that represents the warningscurrently deferred by
    WITH-COMPILATION-UNIT. One of three functions required for deferred-warnings support in ASDF.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • SAVE-DEFERRED-WARNINGS

WITH-OPTIMIZATION-SETTINGS names a macro:
  Lambda-list: ((&OPTIONAL (SETTINGS *OPTIMIZATION-SETTINGS*)) &BODY BODY)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

WARNINGS-FILE-TYPE names a compiled function:
  Lambda-list: (&OPTIONAL IMPLEMENTATION-TYPE)
  Derived type: (FUNCTION (&OPTIONAL T)
                 (VALUES
                  (OR NULL (SIMPLE-BASE-STRING 12) (SIMPLE-BASE-STRING 13)
                      (SIMPLE-BASE-STRING 14) (SIMPLE-BASE-STRING 16))
                  &OPTIONAL))
  Documentation:
    The pathname type for warnings files on given IMPLEMENTATION-TYPE,
    where NIL designates the current one
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION
  • UIOP/LISP-BUILD:WARNINGS-FILE-P
  • UIOP/LISP-BUILD:ENABLE-DEFERRED-WARNINGS-CHECK

LOAD* names a compiled function:
  Lambda-list: (X &REST KEYS &KEY &ALLOW-OTHER-KEYS)
  Derived type: (FUNCTION (T &REST T &KEY &ALLOW-OTHER-KEYS) *)
  Documentation:
    Portable wrapper around LOAD that properly handles loading from a stream.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (PERFORM (DEFINE-OP SYSTEM))
  • ASDF/LISP-ACTION:PERFORM-LISP-LOAD-SOURCE
  • ASDF/LISP-ACTION:PERFORM-LISP-LOAD-FASL
  • UIOP/LISP-BUILD:LOAD-FROM-STRING

COMPILE-WARNED-WARNING names the condition-class #<SB-PCL::CONDITION-CLASS UIOP/LISP-BUILD:COMPILE-WARNED-WARNING>:
  Class precedence-list: UIOP/LISP-BUILD:COMPILE-WARNED-WARNING,
                         UIOP/LISP-BUILD:COMPILE-CONDITION, WARNING, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: UIOP/LISP-BUILD:COMPILE-CONDITION, WARNING
  No subclasses.
  No direct slots.

WARNINGS-FILE-P names a compiled function:
  Lambda-list: (FILE &OPTIONAL IMPLEMENTATION-TYPE)
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Is FILE a saved warnings file for the given IMPLEMENTATION-TYPE?
    If that given type is NIL, use the currently configured *WARNINGS-FILE-TYPE* instead.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (INPUT-FILES (COMPILE-OP SYSTEM))
  • ASDF/LISP-ACTION::PERFORM-LISP-WARNINGS-CHECK

WITH-SAVED-DEFERRED-WARNINGS names a macro:
  Lambda-list: ((WARNINGS-FILE &KEY SOURCE-NAMESTRING) &BODY BODY)
  Documentation:
    Trivial syntax for CALL-WITH-SAVED-DEFERRED-WARNINGS
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Macroexpanded by
  • UIOP/LISP-BUILD:COMPILE-FILE*

COMPILE-FILE* names a compiled function:
  Lambda-list: (INPUT-FILE &REST KEYS &KEY (COMPILE-CHECK *COMPILE-CHECK*)
                OUTPUT-FILE WARNINGS-FILE EMIT-CFASL &ALLOW-OTHER-KEYS)
  Derived type: (FUNCTION
                 (T &REST T &KEY (:COMPILE-CHECK T) (:OUTPUT-FILE T)
                  (:WARNINGS-FILE T) (:EMIT-CFASL T) &ALLOW-OTHER-KEYS)
                 (VALUES (OR PATHNAME NULL) T T &OPTIONAL))
  Documentation:
    This function provides a portable wrapper around COMPILE-FILE.
    It ensures that the OUTPUT-FILE value is only returned and
    the file only actually created if the compilation was successful,
    even though your implementation may not do that. It also checks an optional
    user-provided consistency function COMPILE-CHECK to determine success;
    it will call this function if not NIL at the end of the compilation
    with the arguments sent to COMPILE-FILE*, except with :OUTPUT-FILE TMP-FILE
    where TMP-FILE is the name of a temporary output-file.
    It also checks two flags (with legacy british spelling from ASDF1),
    *COMPILE-FILE-FAILURE-BEHAVIOUR* and *COMPILE-FILE-WARNINGS-BEHAVIOUR*
    with appropriate implementation-dependent defaults,
    and if a failure (respectively warnings) are reported by COMPILE-FILE,
    it will consider that an error unless the respective behaviour flag
    is one of :SUCCESS :WARN :IGNORE.
    If WARNINGS-FILE is defined, deferred warnings are saved to that file.
    On ECL or MKCL, it creates both the linkable object and loadable faslfiles.
    On implementations that erroneously do not recognize standard keywordarguments,
    it will filter them appropriately.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (PERFORM (COMPILE-OP GROVEL-CONSTANTS-FILE))
  • ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION

CALL-WITH-MUFFLED-COMPILER-CONDITIONS names a compiled function:
  Lambda-list: (THUNK)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Call given THUNK in a context where uninteresting conditions and compilerconditions are muffled
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/LISP-BUILD:COMPILE-FILE*

*OPTIMIZATION-SETTINGS* names a special variable:
  Value: NIL
  Documentation:
    Optimization settings to be used by PROCLAIM-OPTIMIZATION-SETTINGS

• Referenced by
  • (WITH-OPTIMIZATION-SETTINGS)
  • UIOP/LISP-BUILD:PROCLAIM-OPTIMIZATION-SETTINGS

CALL-WITH-MUFFLED-LOADER-CONDITIONS names a compiled function:
  Lambda-list: (THUNK)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Call given THUNK in a context where uninteresting conditions and loaderconditions are muffled
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/LISP-BUILD:LOAD*

DISABLE-DEFERRED-WARNINGS-CHECK names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES NULL &OPTIONAL))
  Documentation:
    Disable the saving of deferred warnings
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

*UNINTERESTING-CONDITIONS* names a special variable:
  Value: NIL
  Documentation:
    Conditions that may be skipped while compiling or loading Lisp code.

• Referenced by
  • UIOP/LISP-BUILD:CALL-WITH-MUFFLED-LOADER-CONDITIONS
  • UIOP/LISP-BUILD:CALL-WITH-MUFFLED-COMPILER-CONDITIONS

COMPILE-FILE-PATHNAME* names a compiled function:
  Lambda-list: (INPUT-FILE &REST KEYS &KEY OUTPUT-FILE &ALLOW-OTHER-KEYS)
  Derived type: (FUNCTION (T &REST T &KEY (:OUTPUT-FILE T) &ALLOW-OTHER-KEYS)*)
  Documentation:
    Variant of COMPILE-FILE-PATHNAME that works well with COMPILE-FILE*
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/LISP-BUILD:COMPILE-FILE*

*PREVIOUS-OPTIMIZATION-SETTINGS* names a special variable:
  Value: NIL
  Documentation:
    Optimization settings saved by PROCLAIM-OPTIMIZATION-SETTINGS

• Set by
  • UIOP/LISP-BUILD:PROCLAIM-OPTIMIZATION-SETTINGS
• Referenced by
  • UIOP/LISP-BUILD:PROCLAIM-OPTIMIZATION-SETTINGS

LISPIZE-PATHNAME names a compiled function:
  Lambda-list: (INPUT-FILE)
  Derived type: (FUNCTION (T) (VALUES PATHNAME &OPTIONAL))
  Documentation:
    From a INPUT-FILE pathname, return a corresponding .lisp source pathname
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

*UNINTERESTING-LOADER-CONDITIONS* names a special variable:
  Value: ("Overwriting already existing readtable ~S."
          #(#:FINALIZERS-OFF-WARNING :ASDF-FINALIZERS))
  Documentation:
    Additional conditions that may be skipped while loading Lisp code.

• Referenced by
  • UIOP/LISP-BUILD:CALL-WITH-MUFFLED-LOADER-CONDITIONS

SAVE-DEFERRED-WARNINGS names a compiled function:
  Lambda-list: (WARNINGS-FILE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Save forward reference conditions so they may be issued at a latter time,
    possibly in a different process.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • CALL-WITH-SAVED-DEFERRED-WARNINGS

*COMPILE-FILE-WARNINGS-BEHAVIOUR* names a special variable:
  Value: :WARN
  Documentation:
    How should ASDF react if it encounters a warning when compiling a file?
    Valid values are :error, :warn, and :ignore.

• Set by
  • ((SETF OPERATION-ON-WARNINGS) (T OPERATION))
• Bound by
  • (OPERATE AROUND (T T))
• Referenced by
  • (OPERATION-ON-WARNINGS (OPERATION))
  • (OPERATE AROUND (T T))
  • UIOP/LISP-BUILD:COMPILE-FILE*
  • CHECK-LISP-COMPILE-WARNINGS

COMPILE-FILE-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS UIOP/LISP-BUILD:COMPILE-FILE-ERROR>:
  Class precedence-list: UIOP/LISP-BUILD:COMPILE-FILE-ERROR,
                         UIOP/LISP-BUILD:COMPILE-CONDITION, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: UIOP/LISP-BUILD:COMPILE-CONDITION, ERROR
  Direct subclasses: SB-GROVEL::A-DOT-OUT-FAILED, SB-GROVEL::C-COMPILE-FAILED
  No direct slots.

COMPILE-FAILED-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS UIOP/LISP-BUILD:COMPILE-FAILED-ERROR>:
  Class precedence-list: UIOP/LISP-BUILD:COMPILE-FAILED-ERROR,
                         UIOP/LISP-BUILD:COMPILE-CONDITION, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: UIOP/LISP-BUILD:COMPILE-CONDITION, ERROR
  No subclasses.
  No direct slots.

COMBINE-FASLS names a compiled function:
  Lambda-list: (INPUTS OUTPUT)
  Derived type: (FUNCTION (T T) *)
  Documentation:
    Combine a list of FASLs INPUTS into a single FASL OUTPUT
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (PERFORM (BASIC-COMPILE-BUNDLE-OP SYSTEM))

LOAD-PATHNAME names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES (OR PATHNAME NULL) &OPTIONAL))
  Documentation:
    Portably return the LOAD-PATHNAME of the current source file or fasl
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PARSE-DEFSYSTEM:REGISTER-SYSTEM-DEFINITION
  • ASDF/PARSE-DEFSYSTEM:DETERMINE-SYSTEM-DIRECTORY
  • UIOP/CONFIGURATION:RESOLVE-ABSOLUTE-LOCATION

LOAD-FROM-STRING names a compiled function:
  Lambda-list: (STRING)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Portably read and evaluate forms from a STRING.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

*BASE-BUILD-DIRECTORY* names a special variable:
  Value: NIL
  Documentation:
    When set to a non-null value, it should be an absolute directory pathname,
    which will serve as the *DEFAULT-PATHNAME-DEFAULTS* around a COMPILE-FILE,
    what more while the input-file is shortened if possible to ENOUGH-PATHNAMErelative to it.
    This can help you produce more deterministic output for FASLs.

• Referenced by
  • UIOP/LISP-BUILD:COMPILE-FILE*

CURRENT-LISP-FILE-PATHNAME names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES (OR PATHNAME NULL) &OPTIONAL))
  Documentation:
    Portably return the PATHNAME of the current Lisp source file being compiledor loaded
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

CALL-AROUND-HOOK names a compiled function:
  Lambda-list: (HOOK FUNCTION)
  Derived type: (FUNCTION (T T) *)
  Documentation:
    Call a HOOK around the execution of FUNCTION
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (CALL-WITH-AROUND-COMPILE-HOOK (COMPONENT T))

*USUAL-UNINTERESTING-CONDITIONS* names a special variable:
  Value: (SB-INT:SIMPLE-COMPILER-NOTE
          "&OPTIONAL and &KEY found in the same lambda list: ~S"
          SB-KERNEL:LEXICAL-ENVIRONMENT-TOO-COMPLEX
          SB-KERNEL:UNDEFINED-ALIEN-STYLE-WARNING
          UIOP/LISP-BUILD:SB-GROVEL-UNKNOWN-CONSTANT-CONDITION
          IMPLICIT-GENERIC-FUNCTION-WARNING SB-INT:PACKAGE-AT-VARIANCE
          SB-KERNEL:UNINTERESTING-REDEFINITION
          SB-KERNEL:REDEFINITION-WITH-DEFUN
          SB-KERNEL:REDEFINITION-WITH-DEFGENERIC
          SB-KERNEL:REDEFINITION-WITH-DEFMETHOD
          SB-KERNEL:REDEFINITION-WITH-DEFMACRO
          "No generic function ~S present when encountering macroexpansion ofdefmethod. Assuming it will be an instance of standard-generic-function.")
  Documentation:
    A suggested value to which to set or bind *uninteresting-conditions*.

SB-GROVEL-UNKNOWN-CONSTANT-CONDITION names a type-specifier:
  Lambda-list: ()
  Expansion: (AND STYLE-WARNING
                  (SATISFIES
                   UIOP/LISP-BUILD::SB-GROVEL-UNKNOWN-CONSTANT-CONDITION-P))

WITH-MUFFLED-COMPILER-CONDITIONS names a macro:
  Lambda-list: ((&OPTIONAL) &BODY BODY)
  Documentation:
    Trivial syntax for CALL-WITH-MUFFLED-COMPILER-CONDITIONS
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Macroexpanded by
  • UIOP/LISP-BUILD:COMPILE-FILE*

ENABLE-DEFERRED-WARNINGS-CHECK names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES T &OPTIONAL))
  Documentation:
    Enable the saving of deferred warnings
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

UNREIFY-SIMPLE-SEXP names a compiled function:
  Lambda-list: (SEXP)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Given the portable output of REIFY-SIMPLE-SEXP, return the simple SEXP itrepresents
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/LISP-BUILD:UNREIFY-SIMPLE-SEXP

REIFY-SIMPLE-SEXP names a compiled function:
  Lambda-list: (SEXP)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Given a simple SEXP, return a representation of it as a portable SEXP.
    Simple means made of symbols, numbers, characters, simple-strings,pathnames, cons cells.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/LISP-BUILD:REIFY-SIMPLE-SEXP

WITH-MUFFLED-LOADER-CONDITIONS names a macro:
  Lambda-list: ((&OPTIONAL) &BODY BODY)
  Documentation:
    Trivial syntax for CALL-WITH-MUFFLED-LOADER-CONDITIONS
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Macroexpanded by
  • UIOP/LISP-BUILD:LOAD*

CHECK-LISP-COMPILE-RESULTS names a compiled function:
  Lambda-list: (OUTPUT WARNINGS-P FAILURE-P &OPTIONAL CONTEXT-FORMAT
                CONTEXT-ARGUMENTS)
  Derived type: (FUNCTION (T T T &OPTIONAL T T) *)
  Documentation:
    Given the results of COMPILE-FILE, raise an error or warning as appropriate
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (PERFORM (COMPILE-OP GROVEL-CONSTANTS-FILE))
  • ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION

COMPILE-FAILED-WARNING names the condition-class #<SB-PCL::CONDITION-CLASS UIOP/LISP-BUILD:COMPILE-FAILED-WARNING>:
  Class precedence-list: UIOP/LISP-BUILD:COMPILE-FAILED-WARNING,
                         UIOP/LISP-BUILD:COMPILE-CONDITION, WARNING, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: UIOP/LISP-BUILD:COMPILE-CONDITION, WARNING
  No subclasses.
  No direct slots.

COMPILE-WARNED-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS UIOP/LISP-BUILD:COMPILE-WARNED-ERROR>:
  Class precedence-list: UIOP/LISP-BUILD:COMPILE-WARNED-ERROR,
                         UIOP/LISP-BUILD:COMPILE-CONDITION, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: UIOP/LISP-BUILD:COMPILE-CONDITION, ERROR
  No subclasses.
  No direct slots.

*UNINTERESTING-COMPILER-CONDITIONS* names a special variable:
  Value: NIL
  Documentation:
    Additional conditions that may be skipped while compiling Lisp code.

• Referenced by
  • UIOP/LISP-BUILD:CALL-WITH-MUFFLED-COMPILER-CONDITIONS