UIOP/UTILITY

APPENDF names a macro:
  Lambda-list: (PLACE &REST ARGS)
  Documentation:
    Append onto list
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Macroexpanded by
  • ASDF/SOURCE-REGISTRY::PROCESS-SOURCE-REGISTRY-DIRECTIVE
  • ASDF/PARSE-DEFSYSTEM:PARSE-COMPONENT-FORM

+CRLF+ names a special variable:
  Value: "
"

• Referenced by
  • UIOP/UTILITY:STRIPLN

+CR+ names a special variable:
  Value: "
"

• Referenced by
  • UIOP/UTILITY:STRIPLN

MATCH-ANY-CONDITION-P names a compiled function:
  Lambda-list: (CONDITION CONDITIONS)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Documentation:
    match CONDITION against any of the patterns of CONDITIONS supplied
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS

FIRST-CHAR names a compiled function:
  Lambda-list: (S)
  Derived type: (FUNCTION (T) (VALUES (OR CHARACTER NULL) &OPTIONAL))
  Documentation:
    Return the first character of a non-empty string S, or NIL
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/PATHNAME:SPLIT-UNIX-NAMESTRING-DIRECTORY-COMPONENTS
  • UIOP/PATHNAME:HIDDEN-PATHNAME-P

*UIOP-DEBUG-UTILITY* names a special variable:
  Value: (OR
          (IGNORE-ERRORS
           (PROBE-FILE
            (UIOP/PACKAGE:SYMBOL-CALL :ASDF :SYSTEM-RELATIVE-PATHNAME :UIOP
                                      "contrib/debug.lisp")))
          (PROBE-FILE
           (UIOP/PACKAGE:SYMBOL-CALL :UIOP/PATHNAME :SUBPATHNAME
                                     (USER-HOMEDIR-PATHNAME)
                                     "common-lisp/asdf/uiop/contrib/debug.lisp")))
  Documentation:
    form that evaluates to the pathname to your favorite debugging utilities

• Referenced by
  • UIOP/UTILITY:LOAD-UIOP-DEBUG-UTILITY

TIMESTAMP< names a compiled function:
  Lambda-list: (X Y)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/UTILITY:LATER-TIMESTAMP
  • UIOP/UTILITY:EARLIER-TIMESTAMP
  • TIMESTAMP<=
  • UIOP/UTILITY:TIMESTAMPS<

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

NEST names a macro:
  Lambda-list: (&REST THINGS)
  Documentation:
    Macro to keep code nesting and indentation under control.
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Macroexpanded by
  • ASDF/PARSE-DEFSYSTEM:REGISTER-SYSTEM-DEFINITION
  • (FIND-SYSTEM (STRING))
  • (PERFORM (DEFINE-OP SYSTEM))
  • (COMPUTE-ACTION-STAMP (T OPERATION COMPONENT))
  • UIOP/RUN-PROGRAM::%SYSTEM
  • UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM

LATEST-TIMESTAMP names a compiled function:
  Lambda-list: (&REST LIST)
  Derived type: FUNCTION
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PLAN::MERGE-ACTION-STATUS

ENSURE-GETHASH names a compiled function:
  Lambda-list: (KEY TABLE DEFAULT)
  Derived type: (FUNCTION (T T T) (VALUES T BOOLEAN &OPTIONAL))
  Documentation:
    Lookup the TABLE for a KEY as by GETHASH, but if not present,
    call the (possibly constant) function designated by DEFAULT as per CALL-FUNCTION,
    set the corresponding entry to the result in the table.
    Return two values: the entry after its optional computation, and whether itwas found
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/FIND-SYSTEM::CHECK-NOT-OLD-ASDF-SYSTEM
  • ASDF/OPERATION:MAKE-OPERATION

STRING-SUFFIX-P names a compiled function:
  Lambda-list: (STRING SUFFIX)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Does STRING end with SUFFIX?
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/SOURCE-REGISTRY:PARSE-SOURCE-REGISTRY-STRING
  • UIOP/UTILITY:STRIPLN
  • STRING-ENCLOSED-P

+MAX-CHARACTER-TYPE-INDEX+ names a special variable:
  Value: 1

CHARACTER-TYPE-INDEX names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BIT &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/UTILITY:STRINGS-COMMON-ELEMENT-TYPE

STANDARD-CASE-SYMBOL-NAME names a compiled function:
  Lambda-list: (NAME-DESIGNATOR)
  Derived type: (FUNCTION (T) (VALUES SIMPLE-STRING &OPTIONAL))
  Documentation:
    Given a NAME-DESIGNATOR for a symbol, if it is a symbol, convert it to astring using STRING;
    if it is a string, use STRING-UPCASE on an ANSI CL platform, or STRING on aso-called "modern"
    platform such as Allegro with modern syntax.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/UTILITY:FIND-STANDARD-CASE-SYMBOL

EARLIER-TIMESTAMP names a compiled function:
  Lambda-list: (X Y)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

EARLIEST-TIMESTAMP names a compiled function:
  Lambda-list: (&REST LIST)
  Derived type: FUNCTION
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

STYLE-WARN names a compiled function:
  Lambda-list: (DATUM &REST ARGUMENTS)
  Derived type: (FUNCTION (T &REST T) (VALUES NULL &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/VERSION::NOTIFY-DEPRECATED-FUNCTION

REMOVE-PLIST-KEYS names a compiled function:
  Lambda-list: (KEYS PLIST)
  Derived type: (FUNCTION (T T) (VALUES LIST &OPTIONAL))
  Documentation:
    Remove a list of keys from a plist
  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:PARSE-COMPONENT-FORM
  • ASDF/SYSTEM-REGISTRY::MAKE-PRELOADED-SYSTEM
  • UIOP/LISP-BUILD:COMPILE-FILE*
  • UIOP/LISP-BUILD:COMPILE-FILE-PATHNAME*
  • UIOP/PATHNAME:PARSE-UNIX-NAMESTRING

REGISTER-HOOK-FUNCTION names a compiled function:
  Lambda-list: (VARIABLE HOOK &OPTIONAL CALL-NOW-P)
  Derived type: (FUNCTION (T T &OPTIONAL T) *)
  Documentation:
    Push the HOOK function (a designator as per ENSURE-FUNCTION) onto the hookVARIABLE.
    When CALL-NOW-P is true, also call the function immediately.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/CONFIGURATION:REGISTER-CLEAR-CONFIGURATION-HOOK
  • UIOP/IMAGE:REGISTER-IMAGE-DUMP-HOOK
  • UIOP/IMAGE:REGISTER-IMAGE-RESTORE-HOOK

WITH-UPGRADABILITY names a macro:
  Lambda-list: ((&OPTIONAL) &BODY BODY)
  Documentation:
    Evaluate BODY at compile- load- and run- times, with DEFUN and DEFGENERICmodified
    to also declare the functions NOTINLINE and to accept a wrapping thefunction name
    specification into a list with keyword argument SUPERSEDE (which defaultsto T if the name
    is not wrapped, and NIL if it is wrapped). If SUPERSEDE is true, callUNDEFINE-FUNCTION
    to supersede any previous definition.
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

EMPTYP names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Predicate that is true for an empty sequence
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/FILESYSTEM:SPLIT-NATIVE-PATHNAMES-STRING
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/OS:GETENVP
  • UIOP/UTILITY:STRINGS-COMMON-ELEMENT-TYPE

PARAMETER-ERROR names a compiled function:
  Lambda-list: (FORMAT-CONTROL FUNCTIONALITY &REST FORMAT-ARGUMENTS)
  Derived type: (FUNCTION (T T &REST T) NIL)
  Documentation:
    Signal an error because some FUNCTIONALITY or its specific implementationon a given underlying
    platform does not accept a given parameter or combination of parameters.Report a formatted error
    message, that takes the functionality as its first argument (that can beskipped with ~*).
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

PARAMETER-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS UIOP/UTILITY:PARAMETER-ERROR>:
  Class precedence-list: UIOP/UTILITY:PARAMETER-ERROR, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: ERROR
  No subclasses.
  Direct slots:
    UIOP/UTILITY::FUNCTIONALITY
      Initargs: :FUNCTIONALITY
    UIOP/UTILITY::FORMAT-CONTROL
      Initargs: :FORMAT-CONTROL
    UIOP/UTILITY::FORMAT-ARGUMENTS
      Initargs: :FORMAT-ARGUMENTS

• Called by
  • (RESOLVE-DEPENDENCY-COMBINATION (T (EQL REQUIRE) T))
  • ASDF/FORCING:MAKE-FORCING
  • (RESOLVE-DEPENDENCY-COMBINATION (T T T))
  • (INITIALIZE-INSTANCE AFTER (OPERATION))
  • UIOP/RUN-PROGRAM::%SYSTEM
  • UIOP/RUN-PROGRAM::%REDIRECTED-SYSTEM-COMMAND
  • UIOP/RUN-PROGRAM::%USE-LAUNCH-PROGRAM
  • UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO
  • (VOMIT-OUTPUT-STREAM (T T))
  • (SLURP-INPUT-STREAM (T T))
  • UIOP/LAUNCH-PROGRAM::%NORMALIZE-IO-SPECIFIER
  • UIOP/LAUNCH-PROGRAM::REQUIRES-ESCAPING-P
  • UIOP/FILESYSTEM:DELETE-DIRECTORY-TREE
  • UIOP/FILESYSTEM:GETENV-PATHNAMES
  • DIRECTORY-FILES
  • UIOP/PATHNAME:TRANSLATE-PATHNAME*
  • UIOP/PATHNAME:UNIX-NAMESTRING
  • UIOP/PATHNAME:NORMALIZE-PATHNAME-DIRECTORY-COMPONENT
  • FEATUREP

IF-LET names a macro:
  Lambda-list: (BINDINGS &BODY (THEN-FORM &OPTIONAL ELSE-FORM))
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Macroexpanded by
  • ASDF/BACKWARD-INTERFACE:SYSTEM-REGISTERED-P
  • (EXPLAIN (OPERATION T))
  • (TRAVERSE (OPERATION T))
  • ASDF/SOURCE-REGISTRY:COMPUTE-SOURCE-REGISTRY
  • ASDF/PACKAGE-INFERRED-SYSTEM:SYSDEF-PACKAGE-INFERRED-SYSTEM-SEARCH
  • ASDF/PACKAGE-INFERRED-SYSTEM::PACKAGE-INFERRED-SYSTEM-FILE-DEPENDENCIES
  • ASDF/PARSE-DEFSYSTEM:REGISTER-SYSTEM-DEFINITION
  • ASDF/PARSE-DEFSYSTEM::NORMALIZE-VERSION
  • (FIND-SYSTEM (STRING))
  • ASDF/FIND-SYSTEM:LOAD-ASD
  • (PERFORM (DEFINE-OP SYSTEM))
  • (INPUT-FILES (DEFINE-OP SYSTEM))
  • (RECORD-DEPENDENCY (NULL T T))
  • ASDF/OPERATE:COMPONENT-LOADED-P
  • (OPERATE (OPERATION T))
  • ASDF/PLAN:ACTION-ALREADY-DONE-P
  • (MARK-AS-DONE (T OPERATION T))
  • (MAKE-PLAN (T OPERATION T))
  • (COLLECT-DEPENDENCIES (OPERATION T))
  • (FORCING (NULL))
  • (FIND-COMPONENT (STRING T))
  • (INPUT-FILES (PREPARE-SOURCE-OP SYSTEM))
  • ASDF/LISP-ACTION:PERFORM-LISP-LOAD-FASL
  • (OUTPUT-FILES (COMPILE-OP SYSTEM))
  • (INPUT-FILES (PREPARE-OP SYSTEM))
  • (PERFORM (OPERATION T))
  • (COMPONENT-OPERATION-TIME (OPERATION T))
  • (INPUT-FILES (SELFWARD-OPERATION COMPONENT))
  • (ADDITIONAL-INPUT-FILES (OPERATION T))
  • (OPERATION-DONE-P (OPERATION T))
  • (INPUT-FILES (OPERATION T))
  • (OUTPUT-FILES (OPERATION T))
  • ASDF/ACTION::UPWARD-OPERATION-DEPENDS-ON
  • (COMPONENT-DEPENDS-ON (OPERATION T))
  • ASDF/ACTION:ACTION-VALID-P
  • ASDF/SYSTEM-REGISTRY:PROBE-ASD
  • ASDF/SYSTEM-REGISTRY:SEARCH-FOR-SYSTEM-DEFINITION
  • ASDF/SYSTEM-REGISTRY:REGISTER-PRELOADED-SYSTEM
  • ASDF/SYSTEM-REGISTRY::ENSURE-PRELOADED-SYSTEM-REGISTERED
  • ASDF/SYSTEM:PRIMARY-SYSTEM-NAME
  • (RECURSE IN SUB-COMPONENTS)
  • (COMPONENT-SYSTEM (COMPONENT))
  • UIOP/RUN-PROGRAM::%USE-LAUNCH-PROGRAM
  • UIOP/LAUNCH-PROGRAM:CLOSE-STREAMS
  • UIOP/LAUNCH-PROGRAM:WAIT-PROCESS
  • UIOP/LAUNCH-PROGRAM::%PROCESS-STATUS
  • UIOP/LISP-BUILD:WARNINGS-FILE-P
  • TMPIZE-PATHNAME
  • UIOP/FILESYSTEM:LISP-IMPLEMENTATION-PATHNAME-P
  • UIOP/FILESYSTEM:LISP-IMPLEMENTATION-DIRECTORY
  • UIOP/FILESYSTEM:TRUENAMIZE
  • UIOP/OS:CHDIR

REDUCE/STRCAT names a compiled function:
  Lambda-list: (STRINGS &KEY KEY START END)
  Derived type: (FUNCTION (T &KEY (:KEY T) (:START T) (:END T))
                 (VALUES SIMPLE-STRING &OPTIONAL))
  Documentation:
    Reduce a list as if by STRCAT, accepting KEY START and END keywords likeREDUCE.
    NIL is interpreted as an empty string. A character is interpreted as astring of length one.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/RUN-PROGRAM::%REDIRECTED-SYSTEM-COMMAND
  • UIOP/UTILITY:STRCAT

DEFUN* names a macro:
  Lambda-list: (NAME FORMALS &REST REST)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

COERCE-CLASS names a compiled function:
  Lambda-list: (CLASS &KEY (PACKAGE CL) (SUPER T) (ERROR (QUOTE ERROR)))
  Derived type: (FUNCTION (T &KEY (:PACKAGE T) (:SUPER T) (:ERROR T)) *)
  Documentation:
    Coerce CLASS to a class that is subclass of SUPER if specified,
    or invoke ERROR handler as per CALL-FUNCTION.
    
    A keyword designates the name a symbol, which when found in either PACKAGE,designates a class.
    -- for backward compatibility, *PACKAGE* is also accepted for now, but thismay go in the future.
    A string is read as a symbol while in PACKAGE, the symbol designates aclass.
    
    A class object designates itself.
    NIL designates itself (no class).
    A symbol otherwise designates a class by name.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/BUNDLE::BUNDLE-OUTPUT-FILES
  • ASDF/PARSE-DEFSYSTEM:CLASS-FOR-TYPE
  • ASDF/OPERATION:MAKE-OPERATION

LATER-TIMESTAMP names a compiled function:
  Lambda-list: (X Y)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

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

TIMESTAMP*< names a compiled function:
  Lambda-list: (&REST LIST)
  Derived type: FUNCTION
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

DEFGENERIC* names a macro:
  Lambda-list: (NAME FORMALS &REST REST)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

LOAD-UIOP-DEBUG-UTILITY names a compiled function:
  Lambda-list: (&KEY PACKAGE UTILITY-FILE)
  Derived type: (FUNCTION (&KEY (:PACKAGE T) (:UTILITY-FILE T))
                 (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

CALL-FUNCTIONS names a compiled function:
  Lambda-list: (FUNCTION-SPECS)
  Derived type: (FUNCTION (T) (VALUES NULL &OPTIONAL))
  Documentation:
    For each function in the list FUNCTION-SPECS, in order, call the functionas per CALL-FUNCTION
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/UPGRADE:CLEANUP-UPGRADED-ASDF
  • UIOP/CONFIGURATION:CLEAR-CONFIGURATION
  • UIOP/IMAGE:CALL-IMAGE-DUMP-HOOK
  • UIOP/IMAGE:CALL-IMAGE-RESTORE-HOOK

MATCH-CONDITION-P names a compiled function:
  Lambda-list: (X CONDITION)
  Derived type: (FUNCTION (T T) *)
  Documentation:
    Compare received CONDITION to some pattern X:
    a symbol naming a condition class,
    a simple vector of length 2, arguments to find-symbol* with result asabove,
    or a string describing the format-control of a simple-condition.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/UTILITY:MATCH-ANY-CONDITION-P

STRCAT names a compiled function:
  Lambda-list: (&REST STRINGS)
  Derived type: FUNCTION
  Documentation:
    Concatenate strings.
    NIL is interpreted as an empty string, a character as a string of lengthone.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PARSE-DEFSYSTEM:SYSDEF-ERROR-COMPONENT
  • (BAD-SYSTEM-NAME)
  • TMPIZE-PATHNAME
  • UIOP/STREAM:ADD-PATHNAME-SUFFIX
  • UIOP/OS:PARSE-FILE-LOCATION-INFO

LEXICOGRAPHIC< names a compiled function:
  Lambda-list: (ELEMENT< X Y)
  Derived type: (FUNCTION (T T T) *)
  Documentation:
    Lexicographically compare two lists of using the function element< tocompare elements.
    element< is a strict total order; the resulting order on X and Y will alsobe strict.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/VERSION:VERSION<
  • UIOP/UTILITY:LEXICOGRAPHIC<=
  • UIOP/UTILITY:LEXICOGRAPHIC<

LIST-TO-HASH-SET names a compiled function:
  Lambda-list: (LIST &AUX (H (MAKE-HASH-TABLE TEST (QUOTE EQUAL))))
  Derived type: (FUNCTION (T) (VALUES HASH-TABLE &OPTIONAL))
  Documentation:
    Convert a LIST into hash-table that has the same elements when viewed as aset,
    up to the given equality TEST
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/FIND-SYSTEM:LOAD-ASD
  • ASDF/FORCING:NORMALIZE-FORCED-NOT-SYSTEMS
  • ASDF/FORCING:NORMALIZE-FORCED-SYSTEMS
  • ASDF/SYSTEM-REGISTRY:REGISTER-IMMUTABLE-SYSTEM

LAST-CHAR names a compiled function:
  Lambda-list: (S)
  Derived type: (FUNCTION (T) (VALUES (OR CHARACTER NULL) &OPTIONAL))
  Documentation:
    Return the last character of a non-empty string S, or NIL
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/PATHNAME:DIRECTORY-SEPARATOR-FOR-HOST

TIMESTAMPS-EARLIEST names a compiled function:
  Lambda-list: (LIST)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (COMPUTE-ACTION-STAMP (T OPERATION COMPONENT))
  • UIOP/UTILITY:EARLIEST-TIMESTAMP

LEXICOGRAPHIC<= names a compiled function:
  Lambda-list: (ELEMENT< X Y)
  Derived type: (FUNCTION (T T T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Lexicographically compare two lists of using the function element< tocompare elements.
    element< is a strict total order; the resulting order on X and Y will be anon-strict total order.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/BACKWARD-DRIVER:VERSION-COMPATIBLE-P

UIOP-DEBUG names a macro:
  Lambda-list: (&REST KEYS)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

ENSURE-LIST names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PACKAGE-INFERRED-SYSTEM:REGISTER-SYSTEM-PACKAGES
  • (INPUT-FILES (SELFWARD-OPERATION COMPONENT))
  • ASDF/ACTION::SELFWARD-OPERATION-DEPENDS-ON
  • (DEFPARAMETER*)

SPLIT-STRING names a compiled function:
  Lambda-list: (STRING &KEY MAX (SEPARATOR (QUOTE (  	))))
  Derived type: (FUNCTION (T &KEY (:MAX T) (:SEPARATOR T))
                 (VALUES LIST &OPTIONAL))
  Documentation:
    Split STRING into a list of components separated by
    any of the characters in the sequence SEPARATOR.
    If MAX is specified, then no more than max(1,MAX) components will bereturned,
    starting the separation from the end, e.g. when called with arguments
     "a.b.c.d.e" :max 3 :separator "." it will return ("a.b.c" "d" "e").
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/FILESYSTEM:SPLIT-NATIVE-PATHNAMES-STRING
  • UIOP/PATHNAME:SPLIT-NAME-TYPE
  • UIOP/PATHNAME:SPLIT-UNIX-NAMESTRING-DIRECTORY-COMPONENTS
  • UIOP/VERSION:PARSE-VERSION
  • ORGAN:ORG-TAG-SPLIT
  • DAT/MIME::MIME-EQUAL
  • DAT/SVG::CONVERT-TO-POINTS

PARSE-BODY names a compiled function:
  Lambda-list: (BODY &KEY DOCUMENTATION WHOLE)
  Derived type: (FUNCTION (T &KEY (:DOCUMENTATION T) (:WHOLE T))
                 (VALUES LIST LIST T &OPTIONAL))
  Documentation:
    Parses BODY into (values remaining-forms declarations doc-string).
    Documentation strings are recognized only if DOCUMENTATION is true.
    Syntax errors in body are signalled and WHOLE is used in the signal
    arguments when given.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (WITH-DEPRECATION)

STRING-ENCLOSED-P names a compiled function:
  Lambda-list: (PREFIX STRING SUFFIX)
  Derived type: (FUNCTION (T T T) *)
  Documentation:
    Does STRING begin with PREFIX and end with SUFFIX?
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/LISP-BUILD::SB-GROVEL-UNKNOWN-CONSTANT-CONDITION-P

FIND-STANDARD-CASE-SYMBOL names a compiled function:
  Lambda-list: (NAME-DESIGNATOR PACKAGE-DESIGNATOR &OPTIONAL (ERROR T))
  Derived type: (FUNCTION (T T &OPTIONAL T) *)
  Documentation:
    Find a symbol designated by NAME-DESIGNATOR in a package designated byPACKAGE-DESIGNATOR,
    where STANDARD-CASE-SYMBOL-NAME is used to transform them if thesedesignators are strings.
    If optional ERROR argument is NIL, return NIL instead of an error when thesymbol is not found.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

REMOVE-PLIST-KEY names a compiled function:
  Lambda-list: (KEY PLIST)
  Derived type: (FUNCTION (T T) (VALUES LIST &OPTIONAL))
  Documentation:
    Remove a single key from a plist
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PLAN:REQUIRED-COMPONENTS
  • UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM
  • UIOP/STREAM:SAFE-READ-FILE-FORM
  • UIOP/STREAM:SAFE-READ-FILE-LINE
  • UIOP/STREAM:READ-FILE-FORM
  • UIOP/STREAM:READ-FILE-FORMS
  • UIOP/STREAM:READ-FILE-LINE
  • (WRITE-FILE-ENTRY (T T))

ACCESS-AT-COUNT names a compiled function:
  Lambda-list: (AT)
  Derived type: (FUNCTION (T) (VALUES (OR NUMBER NULL) &OPTIONAL))
  Documentation:
    From an AT specification, extract a COUNT of maximum number
    of sub-objects to read as per ACCESS-AT
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/STREAM:SLURP-STREAM-FORM
  • UIOP/STREAM:SLURP-STREAM-LINE

TIMESTAMPS< names a compiled function:
  Lambda-list: (LIST)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/UTILITY:TIMESTAMP*<

+CHARACTER-TYPES+ names a special variable:
  Value: #(BASE-CHAR CHARACTER)

• Referenced by
  • UIOP/UTILITY:STRINGS-COMMON-ELEMENT-TYPE

NOT-IMPLEMENTED-ERROR names a compiled function:
  Lambda-list: (FUNCTIONALITY &OPTIONAL FORMAT-CONTROL &REST FORMAT-ARGUMENTS)
  Derived type: (FUNCTION (T &REST T) NIL)
  Documentation:
    Signal an error because some FUNCTIONALITY is not implemented in thecurrent version
    of the software on the current platform; it may or may not be implementedin different combinations
    of version of the software and of the underlying platform. Optionally,report a formatted error
    message.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

NOT-IMPLEMENTED-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS UIOP/UTILITY:NOT-IMPLEMENTED-ERROR>:
  Class precedence-list: UIOP/UTILITY:NOT-IMPLEMENTED-ERROR, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: ERROR
  No subclasses.
  Direct slots:
    UIOP/UTILITY::FUNCTIONALITY
      Initargs: :FUNCTIONALITY
    UIOP/UTILITY::FORMAT-CONTROL
      Initargs: :FORMAT-CONTROL
    UIOP/UTILITY::FORMAT-ARGUMENTS
      Initargs: :FORMAT-ARGUMENTS

• Called by
  • UIOP/IMAGE:CREATE-IMAGE
  • UIOP/OS:GETCWD

+LF+ names a special variable:
  Value: "
"

• Referenced by
  • UIOP/UTILITY:STRIPLN

STRIPLN names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL SEQUENCE))
  Documentation:
    Strip a string X from any ending CR, LF or CRLF.
    Return two values, the stripped string and the ending that was stripped,
    or the original value and NIL if no stripping took place.
    Since our STRCAT accepts NIL as empty string designator,
    the two results passed to STRCAT always reconstitute the original string
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/STREAM:SLURP-STREAM-LINES
  • UIOP/STREAM:SLURP-STREAM-STRING

LENGTH=N-P names a compiled function:
  Lambda-list: (X N)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/SOURCE-REGISTRY:VALIDATE-SOURCE-REGISTRY-DIRECTIVE
  • ASDF/OUTPUT-TRANSLATIONS:VALIDATE-OUTPUT-TRANSLATIONS-DIRECTIVE
  • ASDF/PACKAGE-INFERRED-SYSTEM::SAME-PACKAGE-INFERRED-SYSTEM-P
  • (RESOLVE-DEPENDENCY-COMBINATION (T (EQL REQUIRE) T))
  • ASDF/ACTION:OUTPUT-FILE
  • UIOP/CONFIGURATION:LOCATION-FUNCTION-P
  • UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-FILE
  • UIOP/CONFIGURATION:CONFIGURATION-INHERITANCE-DIRECTIVE-P

TIMESTAMPS-LATEST names a compiled function:
  Lambda-list: (LIST)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (COMPUTE-ACTION-STAMP (T OPERATION COMPONENT))
  • UIOP/UTILITY:LATEST-TIMESTAMP

ENSURE-FUNCTION names a compiled function:
  Lambda-list: (FUN &KEY (PACKAGE CL))
  Derived type: (FUNCTION (T &KEY (:PACKAGE T)) *)
  Documentation:
    Coerce the object FUN into a function.
    
    If FUN is a FUNCTION, return it.
    If the FUN is a non-sequence literal constant, return constantly that,
    i.e. for a boolean keyword character number or pathname.
    Otherwise if FUN is a non-literally constant symbol, return itsFDEFINITION.
    If FUN is a CONS, return the function that applies its CAR
    to the appended list of the rest of its CDR and the arguments,
    unless the CAR is LAMBDA, in which case the expression is evaluated.
    If FUN is a string, READ a form from it in the specified PACKAGE (default:CL)
    and EVAL that in a (FUNCTION ...) context.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/OUTPUT-TRANSLATIONS::PROCESS-OUTPUT-TRANSLATIONS-DIRECTIVE
  • (PERFORM BEFORE (PROGRAM-OP SYSTEM))
  • UIOP/UTILITY:CALL-FUNCTION
  • UIOP/UTILITY:ACCESS-AT

WHILE-COLLECTING names a macro:
  Lambda-list: ((&REST COLLECTORS) &BODY BODY)
  Documentation:
    COLLECTORS should be a list of names for collections.  A collector
    defines a function that, when applied to an argument inside BODY, will
    add its argument to the corresponding collection.  Returns multiple values,
    a list for each collection, in order.
       E.g.,
    (while-collecting (foo bar)
               (dolist (x '((a 1) (b 2) (c 3)))
                 (foo (first x))
                 (bar (second x))))
    Returns two values: (A B C) and (1 2 3).
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Macroexpanded by
  • ASDF/SOURCE-REGISTRY:FLATTEN-SOURCE-REGISTRY
  • ASDF/OUTPUT-TRANSLATIONS:COMPUTE-OUTPUT-TRANSLATIONS
  • ASDF/PACKAGE-INFERRED-SYSTEM::PACKAGE-DEPENDENCIES
  • (PERFORM (DELIVER-ASD-OP SYSTEM))
  • ASDF/BUNDLE:DIRECT-DEPENDENCY-FILES
  • ASDF/COMPONENT:SUB-COMPONENTS

TIMESTAMP<= names a compiled function:
  Lambda-list: (X Y)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (FIND-SYSTEM (STRING))
  • ASDF/FIND-SYSTEM::DEFINITION-DEPENDENCIES-UP-TO-DATE-P
  • (COMPUTE-ACTION-STAMP (T OPERATION COMPONENT))

ACCESS-AT names a compiled function:
  Lambda-list: (OBJECT AT)
  Derived type: (FUNCTION (T T) *)
  Documentation:
    Given an OBJECT and an AT specifier, list of successive accessors,
    call each accessor on the result of the previous calls.
    An accessor may be an integer, meaning a call to ELT,
    a keyword, meaning a call to GETF,
    NIL, meaning identity,
    a function or other symbol, meaning itself,
    or a list of a function designator and arguments, interpreted as per ENSURE-FUNCTION.
    As a degenerate case, the AT specifier may be an atom of a single suchaccessor
    instead of a list.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/STREAM:SLURP-STREAM-FORM
  • UIOP/STREAM:SLURP-STREAM-LINE

BASE-STRING-P names a compiled function:
  Lambda-list: (STRING)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Does the STRING only contain BASE-CHARs?
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

+NON-BASE-CHARS-EXIST-P+ names a constant variable:
  Value: T

STRING-PREFIX-P names a compiled function:
  Lambda-list: (PREFIX STRING)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Does STRING begin with PREFIX?
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • STRING-ENCLOSED-P

LATEST-TIMESTAMP-F names a macro:
  Lambda-list: (PLACE &REST TIMESTAMPS)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

STRINGS-COMMON-ELEMENT-TYPE names a compiled function:
  Lambda-list: (STRINGS)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Documentation:
    What least subtype of CHARACTER can contain all the elements of all theSTRINGS?
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/UTILITY:REDUCE/STRCAT

CALL-FUNCTION names a compiled function:
  Lambda-list: (FUNCTION-SPEC &REST ARGUMENTS)
  Derived type: (FUNCTION (T &REST T) *)
  Documentation:
    Call the function designated by FUNCTION-SPEC as per ENSURE-FUNCTION,
    with the given ARGUMENTS
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/FORCING::OR-FUNCTION
  • ASDF/FORCING::ACTION-OVERRIDE-P
  • ASDF/FORCING:NORMALIZE-FORCED-NOT-SYSTEMS
  • ASDF/SESSION:CONSULT-ASDF-CACHE
  • UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO
  • (BEFORE70 IN %CALL-WITH-PROGRAM-IO)
  • UIOP/LISP-BUILD:CALL-AROUND-HOOK
  • UIOP/IMAGE:RESTORE-IMAGE
  • UIOP/STREAM:CALL-WITH-TEMPORARY-FILE
  • UIOP/FILESYSTEM:DELETE-DIRECTORY-TREE
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/FILESYSTEM:COLLECT-SUB*DIRECTORIES
  • UIOP/FILESYSTEM:FILTER-LOGICAL-DIRECTORY-RESULTS
  • ENSURE-ABSOLUTE-PATHNAME
  • UIOP/PATHNAME:ENSURE-DIRECTORY-PATHNAME
  • UIOP/VERSION:PARSE-VERSION
  • ENSURE-GETHASH
  • UIOP/UTILITY:COERCE-CLASS
  • UIOP/UTILITY:REGISTER-HOOK-FUNCTION

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

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