UIOP/PATHNAME

*UNSPECIFIC-PATHNAME-TYPE* names a special variable:
  Value: :UNSPECIFIC
  Documentation:
    Unspecific type component to use with the underlying implementation's MAKE-PATHNAME

• Referenced by
  • UIOP/PATHNAME:SPLIT-NAME-TYPE

DIRECTORIZE-PATHNAME-HOST-DEVICE names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Documentation:
    Given a PATHNAME, return a pathname that has representations of its HOSTand DEVICE components
    added to its DIRECTORY component. This is useful for output translations.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/PATHNAME:TRANSLATE-PATHNAME*

PARSE-UNIX-NAMESTRING names a compiled function:
  Lambda-list: (NAME &REST KEYS &KEY TYPE DEFAULTS DOT-DOT ENSURE-DIRECTORY
                &ALLOW-OTHER-KEYS)
  Derived type: (FUNCTION
                 (T &REST T &KEY (:TYPE T) (:DEFAULTS T) (:DOT-DOT T)
                  (:ENSURE-DIRECTORY T) &ALLOW-OTHER-KEYS)
                 *)
  Documentation:
    Coerce NAME into a PATHNAME using standard Unix syntax.
    
    Unix syntax is used whether or not the underlying system is Unix;
    on such non-Unix systems it is reliably usable only for relative pathnames.
    This function is especially useful to manipulate relative pathnamesportably,
    where it is of crucial to possess a portable pathname syntax independent ofthe underlying OS.
    This is what PARSE-UNIX-NAMESTRING provides, and why we use it in ASDF.
    
    When given a PATHNAME object, just return it untouched.
    When given NIL, just return NIL.
    When given a non-null SYMBOL, first downcase its name and treat it as astring.
    When given a STRING, portably decompose it into a pathname as below.
    
    #\/ separates directory components.
    
    The last #\/-separated substring is interpreted as follows:
    1- If TYPE is :DIRECTORY or ENSURE-DIRECTORY is true,
     the string is made the last directory component, and NAME and TYPE areNIL.
     if the string is empty, it's the empty pathname with all slots NIL.
    2- If TYPE is NIL, the substring is a file-namestring, and its NAME andTYPE
     are separated by SPLIT-NAME-TYPE.
    3- If TYPE is a string, it is the given TYPE, and the whole string is theNAME.
    
    Directory components with an empty name or the name "." are removed.
    Any directory named ".." is read as DOT-DOT,
    which must be one of :BACK or :UP and defaults to :BACK.
    
    HOST, DEVICE and VERSION components are taken from DEFAULTS,
    which itself defaults to *NIL-PATHNAME*, also used if DEFAULTS is NIL.
    No host or device can be specified in the string itself,
    which makes it unsuitable for absolute pathnames outside Unix.
    
    For relative pathnames, these components (and hence the defaults) won'tmatter
    if you use MERGE-PATHNAMES* but will matter if you use MERGE-PATHNAMES,
    which is an important reason to always use MERGE-PATHNAMES*.
    
    Arbitrary keys are accepted, and the parse result is passed to ENSURE-PATHNAME
    with those keys, removing TYPE DEFAULTS and DOT-DOT.
    When you're manipulating pathnames that are supposed to make sense portably
    even though the OS may not be Unixish, we recommend you use :WANT-RELATIVET
    to throw an error if the pathname is absolute
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PARSE-DEFSYSTEM:DETERMINE-SYSTEM-DIRECTORY
  • ASDF/SYSTEM-REGISTRY:PROBE-ASD
  • (COMPONENT-RELATIVE-PATHNAME (SYSTEM))
  • (COMPONENT-RELATIVE-PATHNAME (COMPONENT))
  • UIOP/BACKWARD-DRIVER:COERCE-PATHNAME
  • UIOP/CONFIGURATION:SYSTEM-CONFIG-PATHNAMES
  • UIOP/CONFIGURATION:XDG-CONFIG-DIRS
  • UIOP/CONFIGURATION:XDG-DATA-DIRS
  • UIOP/CONFIGURATION:RESOLVE-RELATIVE-LOCATION
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/PATHNAME:SUBPATHNAME

WITH-ENOUGH-PATHNAME names a macro:
  Lambda-list: ((PATHNAME-VAR &KEY (PATHNAME PATHNAME-VAR)
                 (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*))
                &BODY BODY)
  Documentation:
    Shorthand syntax for CALL-WITH-ENOUGH-PATHNAME
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

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

SUBPATHNAME names a compiled function:
  Lambda-list: (PATHNAME SUBPATH &KEY TYPE)
  Derived type: (FUNCTION (T T &KEY (:TYPE T)) *)
  Documentation:
    This function takes a PATHNAME and a SUBPATH and a TYPE.
    If SUBPATH is already a PATHNAME object (not namestring),
    and is an absolute pathname at that, it is returned unchanged;
    otherwise, SUBPATH is turned into a relative pathname with given TYPE
    as per PARSE-UNIX-NAMESTRING with :WANT-RELATIVE T :TYPE TYPE,
    then it is merged with the PATHNAME-DIRECTORY-PATHNAME of PATHNAME.
  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
  • ASDF/SOURCE-REGISTRY::PROCESS-SOURCE-REGISTRY-CACHE
  • ASDF/PACKAGE-INFERRED-SYSTEM:SYSDEF-PACKAGE-INFERRED-SYSTEM-SEARCH
  • ASDF/BUNDLE::BUNDLE-OUTPUT-FILES
  • ASDF/PARSE-DEFSYSTEM::NORMALIZE-VERSION
  • ASDF/FIND-SYSTEM::CHECK-NOT-OLD-ASDF-SYSTEM
  • (OUTPUT-FILES (COMPILE-OP SYSTEM))
  • SYSTEM-RELATIVE-PATHNAME
  • UIOP/CONFIGURATION:IN-FIRST-DIRECTORY
  • UIOP/CONFIGURATION:XDG-CONFIG-HOME
  • UIOP/CONFIGURATION:XDG-DATA-HOME
  • UIOP/PATHNAME:SUBPATHNAME*

*WILD-DIRECTORY* names a special variable:
  Value: #P"*/"
  Documentation:
    A pathname object with wildcards for matching any subdirectory

• Referenced by
  • UIOP/CONFIGURATION:RESOLVE-RELATIVE-LOCATION

PATHNAME-HOST-PATHNAME names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES PATHNAME &OPTIONAL))
  Documentation:
    return a pathname with the same host as given PATHNAME, and all otherfields NIL
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

ABSOLUTE-PATHNAME-P names a compiled function:
  Lambda-list: (PATHSPEC)
  Derived type: (FUNCTION (T) (VALUES (OR PATHNAME NULL) &OPTIONAL))
  Documentation:
    If PATHSPEC is a pathname or namestring object that parses as a pathname
    possessing an :ABSOLUTE directory component, return the (parsed) pathname.
    Otherwise return NIL
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/SOURCE-REGISTRY:PARSE-SOURCE-REGISTRY-STRING
  • ASDF/OUTPUT-TRANSLATIONS:APPLY-OUTPUT-TRANSLATIONS
  • ASDF/OUTPUT-TRANSLATIONS::PROCESS-OUTPUT-TRANSLATIONS-DIRECTIVE
  • (COMPONENT-PATHNAME (COMPONENT))
  • UIOP/CONFIGURATION:FILTER-PATHNAME-SET
  • UIOP/CONFIGURATION:RESOLVE-LOCATION
  • UIOP/LISP-BUILD:COMPILE-FILE-PATHNAME*
  • UIOP/FILESYSTEM:GET-PATHNAME-DEFAULTS
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/FILESYSTEM:TRUENAMIZE
  • UIOP/PATHNAME:TRANSLATE-PATHNAME*
  • UIOP/PATHNAME:SUBPATHP
  • ENSURE-ABSOLUTE-PATHNAME
  • UIOP/PATHNAME:SUBPATHNAME
  • PATHNAME-TO-URI
  • ENSURE-ABSOLUTE-PATHNAME

*OUTPUT-TRANSLATION-FUNCTION* names a special variable:
  Value: ASDF/OUTPUT-TRANSLATIONS:APPLY-OUTPUT-TRANSLATIONS
  Documentation:
    Hook for output translations.
    
    This function needs to be idempotent, so that actions can work
    whether their inputs were translated or not,
    which they will be if we are composing operations. e.g. if some
    create-lisp-op creates a lisp file from some higher-level input,
    you need to still be able to use compile-op on that lisp file.

• Referenced by
  • (OUTPUT-FILES AROUND (T T))
  • UIOP/LISP-BUILD:COMPILE-FILE-PATHNAME*

SUBPATHNAME* names a compiled function:
  Lambda-list: (PATHNAME SUBPATH &KEY TYPE)
  Derived type: (FUNCTION (T T &KEY (:TYPE T)) *)
  Documentation:
    returns NIL if the base pathname is NIL, otherwise like SUBPATHNAME.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/CONFIGURATION:XDG-CACHE-HOME
  • UIOP/CONFIGURATION:GET-FOLDER-PATH

PHYSICAL-PATHNAME-P names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    is X a pathname that is not a logical-pathname?
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/FILESYSTEM:DELETE-DIRECTORY-TREE
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/PATHNAME:DIRECTORIZE-PATHNAME-HOST-DEVICE

NORMALIZE-PATHNAME-DIRECTORY-COMPONENT names a compiled function:
  Lambda-list: (DIRECTORY)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Convert the DIRECTORY component from a format usable by the underlying
    implementation's MAKE-PATHNAME and other primitives to a CLHS-standardformat
    that is a list and not a string.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/SOURCE-REGISTRY::PATHNAME-DIRECTORY-DEPTH
  • ASDF/OUTPUT-TRANSLATIONS::SET-OUTPUT-TRANSLATIONS
  • UIOP/FILESYSTEM:TRUENAMIZE
  • SUBDIRECTORIES
  • UIOP/PATHNAME:RELATIVIZE-DIRECTORY-COMPONENT
  • UIOP/PATHNAME:UNIX-NAMESTRING
  • UIOP/PATHNAME:ENSURE-DIRECTORY-PATHNAME
  • RELATIVE-PATHNAME-P
  • ABSOLUTE-PATHNAME-P
  • PATHNAME-EQUAL
  • UIOP/PATHNAME:MERGE-PATHNAMES*
  • UIOP/PATHNAME:MERGE-PATHNAME-DIRECTORY-COMPONENTS

DIRECTORY-SEPARATOR-FOR-HOST names a compiled function:
  Lambda-list: (&OPTIONAL (PATHNAME *DEFAULT-PATHNAME-DEFAULTS*))
  Derived type: (FUNCTION (&OPTIONAL T) *)
  Documentation:
    Given a PATHNAME, return the character used to delimit directory names onthis host and device.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/PATHNAME:DIRECTORIZE-PATHNAME-HOST-DEVICE

UNIX-NAMESTRING names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES (OR STRING NULL) &OPTIONAL))
  Documentation:
    Given a non-wild PATHNAME, return a Unix-style namestring for it.
    If the PATHNAME is NIL or a STRING, return it unchanged.
    
    This only considers the DIRECTORY, NAME and TYPE components of thepathname.
    This is a portable solution for representing relative pathnames,
    But unless you are running on a Unix system, it is not a general solution
    to representing native pathnames.
    
    An error is signaled if the argument is not NULL, a STRING or a PATHNAME,
    or if it is a PATHNAME but some of its components are not recognized.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

PATHNAME-EQUAL names a compiled function:
  Lambda-list: (P1 P2)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Are the two pathnames P1 and P2 reasonably equal in the paths they denote?
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PACKAGE-INFERRED-SYSTEM::SAME-PACKAGE-INFERRED-SYSTEM-P
  • (PERFORM (DELIVER-ASD-OP SYSTEM))
  • (FIND-SYSTEM (STRING))
  • UIOP/FILESYSTEM:FILTER-LOGICAL-DIRECTORY-RESULTS
  • UIOP/PATHNAME:SUBPATHP
  • FIND-SKELFILE
  • SKEL/CORE::FIND-SKEL-PROJECT-ROOT
  • (PUBLISH (SYMBOL-DOCUMENTATION))
  • DIRECTORY-SYSDEF-FILES

*NIL-PATHNAME* names a special variable:
  Value: #P""
  Documentation:
    A pathname that is as neutral as possible for use as defaults
    when merging, making or parsing pathnames

• Referenced by
  • ASDF/SOURCE-REGISTRY:FLATTEN-SOURCE-REGISTRY
  • ASDF/SESSION:COMPUTE-FILE-STAMP
  • ASDF/SESSION:NORMALIZE-NAMESTRING
  • UIOP/FILESYSTEM:TRUENAME*
  • PARSE-NATIVE-NAMESTRING
  • UIOP/PATHNAME:SUBPATHP
  • UIOP/PATHNAME:PARSE-UNIX-NAMESTRING

NIL-PATHNAME names a compiled function:
  Lambda-list: (&OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*))
  Derived type: (FUNCTION (&OPTIONAL T) (VALUES PATHNAME &OPTIONAL))
  Documentation:
    A pathname that is as neutral as possible for use as defaults
    when merging, making or parsing pathnames
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

MERGE-PATHNAME-DIRECTORY-COMPONENTS names a compiled function:
  Lambda-list: (SPECIFIED DEFAULTS)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Documentation:
    Helper for MERGE-PATHNAMES* that handles directory components
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • PATHNAME-PARENT-DIRECTORY-PATHNAME
  • UIOP/PATHNAME:MERGE-PATHNAMES*

WILDEN names a compiled function:
  Lambda-list: (PATH)
  Derived type: (FUNCTION (T) *)
  Documentation:
    From a pathname, return a wildcard pathname matching any file in anysubdirectory of given pathname's directory
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/OUTPUT-TRANSLATIONS:APPLY-OUTPUT-TRANSLATIONS
  • UIOP/CONFIGURATION:RESOLVE-ABSOLUTE-LOCATION
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/PATHNAME:DIRECTORIZE-PATHNAME-HOST-DEVICE

SUBPATHP names a compiled function:
  Lambda-list: (MAYBE-SUBPATH BASE-PATHNAME)
  Derived type: (FUNCTION (T T) (VALUES (OR PATHNAME NULL) &OPTIONAL))
  Documentation:
    if MAYBE-SUBPATH is a pathname that is under BASE-PATHNAME, return apathname object that
    when used with MERGE-PATHNAMES* with defaults BASE-PATHNAME, returns MAYBE-SUBPATH.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/FILESYSTEM:LISP-IMPLEMENTATION-PATHNAME-P
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/PATHNAME:ENOUGH-PATHNAME

PATHNAME-DIRECTORY-PATHNAME names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES (OR PATHNAME NULL) &OPTIONAL))
  Documentation:
    Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME,
    and NIL NAME, TYPE and VERSION components
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (PROCESS-SOURCE-REGISTRY (PATHNAME))
  • ASDF/PARSE-DEFSYSTEM:DETERMINE-SYSTEM-DIRECTORY
  • (PERFORM (DEFINE-OP SYSTEM))
  • (OUTPUT-FILES AROUND (T T))
  • ASDF/SYSTEM:SYSTEM-SOURCE-DIRECTORY
  • (COMPONENT-PATHNAME (COMPONENT))
  • UIOP/CONFIGURATION:RESOLVE-ABSOLUTE-LOCATION
  • TMPIZE-PATHNAME
  • UIOP/FILESYSTEM:CALL-WITH-CURRENT-DIRECTORY
  • UIOP/PATHNAME:SUBPATHNAME

HIDDEN-PATHNAME-P names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Return a boolean that is true if the pathname is hidden as per Unix style,
    i.e. its name starts with a dot.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-DIRECTORY

RELATIVIZE-PATHNAME-DIRECTORY names a compiled function:
  Lambda-list: (PATHSPEC)
  Derived type: (FUNCTION (T) (VALUES PATHNAME &OPTIONAL))
  Documentation:
    Given a PATHNAME, return a relative pathname with otherwise the samecomponents
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

*WILD* names a special variable:
  Value: :WILD
  Documentation:
    Wild component for use with MAKE-PATHNAME

• Referenced by
  • UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-DIRECTORY

MAKE-PATHNAME-COMPONENT-LOGICAL names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Documentation:
    Make a pathname component suitable for use in a logical-pathname
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • SUBDIRECTORIES
  • DIRECTORY-FILES
  • UIOP/PATHNAME:MERGE-PATHNAMES*
  • UIOP/PATHNAME:MAKE-PATHNAME-LOGICAL

FILE-PATHNAME-P names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES (OR PATHNAME NULL) &OPTIONAL))
  Documentation:
    Does PATHNAME represent a file, i.e. has a non-null NAME component?
    
    Accepts NIL, a string (converted through PARSE-NAMESTRING) or a PATHNAME.
    
    Note that this does _not_ check to see that PATHNAME points to an
    actually-existing file.
    
    Returns the (parsed) PATHNAME when true
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PACKAGE-INFERRED-SYSTEM:SYSDEF-PACKAGE-INFERRED-SYSTEM-SEARCH
  • (INPUT-FILES (SELFWARD-OPERATION COMPONENT))
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/FILESYSTEM:FILE-EXISTS-P

*WILD-FILE* names a special variable:
  Value: #P"*.*"
  Documentation:
    A pathname object with wildcards for matching any file with TRANSLATE-PATHNAME

• Referenced by
  • ASDF/BACKWARD-INTERFACE:ENABLE-ASDF-BINARY-LOCATIONS-COMPATIBILITY
  • UIOP/CONFIGURATION:RESOLVE-RELATIVE-LOCATION

MAKE-PATHNAME-LOGICAL names a compiled function:
  Lambda-list: (PATHNAME HOST)
  Derived type: (FUNCTION (T T) (VALUES PATHNAME &OPTIONAL))
  Documentation:
    Take a PATHNAME's directory, name, type and version components,
    and make a new pathname with corresponding components and specified logicalHOST
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • DIRECTORY-FILES

RELATIVE-PATHNAME-P names a compiled function:
  Lambda-list: (PATHSPEC)
  Derived type: (FUNCTION (T) (VALUES (OR PATHNAME NULL) &OPTIONAL))
  Documentation:
    If PATHSPEC is a pathname or namestring object that parses as a pathname
    possessing a :RELATIVE or NIL directory component, return the (parsed)pathname.
    Otherwise return NIL
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/PATHNAME:SUBPATHP

CALL-WITH-ENOUGH-PATHNAME names a compiled function:
  Lambda-list: (MAYBE-SUBPATH DEFAULTS-PATHNAME THUNK)
  Derived type: (FUNCTION (T T T) *)
  Documentation:
    In a context where *DEFAULT-PATHNAME-DEFAULTS* is bound to DEFAULTS-PATHNAME (if not null,
    or else to its current value), call THUNK with ENOUGH-PATHNAME for MAYBE-SUBPATH
    given DEFAULTS-PATHNAME as a base pathname.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

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

SPLIT-UNIX-NAMESTRING-DIRECTORY-COMPONENTS names a compiled function:
  Lambda-list: (UNIX-NAMESTRING &KEY ENSURE-DIRECTORY DOT-DOT)
  Derived type: (FUNCTION (T &KEY (:ENSURE-DIRECTORY T) (:DOT-DOT T))
                 (VALUES (MEMBER :RELATIVE :ABSOLUTE)
                         (OR LIST (SIMPLE-ARRAY * (*))
                             SB-KERNEL:EXTENDED-SEQUENCE)
                         T BOOLEAN &OPTIONAL))
  Documentation:
    Splits the path string UNIX-NAMESTRING, returning four values:
    A flag that is either :absolute or :relative, indicating
       how the rest of the values are to be interpreted.
    A directory path --- a list of strings and keywords, suitable for
       use with MAKE-PATHNAME when prepended with the flag value.
       Directory components with an empty name or the name . are removed.
       Any directory named .. is read as DOT-DOT, or :BACK if it's NIL(not :UP).
    A last-component, either a file-namestring including type extension,
       or NIL in the case of a directory pathname.
    A flag that is true iff the unix-style-pathname was just
       a file-namestring without / path specification.
    ENSURE-DIRECTORY forces the namestring to be interpreted as a directorypathname:
    the third return value will be NIL, and final component of the namestring
    will be treated as part of the directory path.
    
    An empty string is thus read as meaning a pathname object with all fieldsnil.
    
    Note that colon characters #: will NOT be interpreted as hostspecification.
    Absolute pathnames are only appropriate on Unix-style systems.
    
    The intention of this function is to support structured component names,
    e.g., (:file "foo/bar"), which will be unpacked to relative pathnames.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/PATHNAME:DIRECTORIZE-PATHNAME-HOST-DEVICE
  • UIOP/PATHNAME:PARSE-UNIX-NAMESTRING

ENOUGH-PATHNAME names a compiled function:
  Lambda-list: (MAYBE-SUBPATH BASE-PATHNAME)
  Derived type: (FUNCTION (T T) (VALUES T &OPTIONAL))
  Documentation:
    if MAYBE-SUBPATH is a pathname that is under BASE-PATHNAME, return apathname object that
    when used with MERGE-PATHNAMES* with defaults BASE-PATHNAME, returns MAYBE-SUBPATH.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME

LOGICAL-PATHNAME-P names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    is X a logical-pathname?
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PARSE-DEFSYSTEM:REGISTER-SYSTEM-DEFINITION
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/FILESYSTEM:TRUENAMIZE
  • DIRECTORY-FILES
  • UIOP/FILESYSTEM:FILTER-LOGICAL-DIRECTORY-RESULTS
  • UIOP/PATHNAME:PHYSICALIZE-PATHNAME
  • UIOP/PATHNAME:PHYSICAL-PATHNAME-P

*WILD-INFERIORS* names a special variable:
  Value: #P"**/"
  Documentation:
    A pathname object with wildcards for matching any recursive subdirectory

• Referenced by
  • ASDF/BACKWARD-INTERFACE:ENABLE-ASDF-BINARY-LOCATIONS-COMPATIBILITY
  • UIOP/CONFIGURATION:RESOLVE-RELATIVE-LOCATION

PATHNAME-ROOT names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES PATHNAME &OPTIONAL))
  Documentation:
    return the root directory for the host and device of given PATHNAME
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/OUTPUT-TRANSLATIONS:APPLY-OUTPUT-TRANSLATIONS
  • UIOP/PATHNAME:DIRECTORIZE-PATHNAME-HOST-DEVICE
  • UIOP/PATHNAME:SUBPATHP

ENSURE-DIRECTORY-PATHNAME names a compiled function:
  Lambda-list: (PATHSPEC &OPTIONAL (ON-ERROR (QUOTE ERROR)))
  Derived type: (FUNCTION (T &OPTIONAL T) *)
  Documentation:
    Converts the non-wild pathname designator PATHSPEC to directory form.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/SYSTEM-REGISTRY:SYSDEF-CENTRAL-REGISTRY-SEARCH
  • UIOP/CONFIGURATION:IN-FIRST-DIRECTORY
  • UIOP/CONFIGURATION:RESOLVE-ABSOLUTE-LOCATION
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/FILESYSTEM:TRUENAMIZE
  • SUBDIRECTORIES
  • PARSE-NATIVE-NAMESTRING
  • UIOP/PATHNAME:SUBPATHNAME*
  • UIOP/PATHNAME:ENSURE-DIRECTORY-PATHNAME

MAKE-PATHNAME* names a compiled function:
  Lambda-list: (&REST KEYS &KEY DIRECTORY HOST DEVICE NAME TYPE VERSION
                DEFAULTS)
  Derived type: (FUNCTION
                 (&REST T &KEY (:DIRECTORY T) (:HOST T) (:DEVICE T) (:NAME T)
                  (:TYPE T) (:VERSION T) (:DEFAULTS T))
                 (VALUES PATHNAME &OPTIONAL))
  Documentation:
    Takes arguments like CL:MAKE-PATHNAME in the CLHS, and
       tries hard to make a pathname that will actually behave as documented,
       despite the peculiarities of each implementation. DEPRECATED: just useMAKE-PATHNAME.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

*WILD-FILE-FOR-DIRECTORY* names a special variable:
  Value: #P"*.*"
  Documentation:
    A pathname object with wildcards for matching any file with DIRECTORY

• Referenced by
  • DIRECTORY-FILES

MERGE-PATHNAMES* names a compiled function:
  Lambda-list: (SPECIFIED &OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*))
  Derived type: (FUNCTION (T &OPTIONAL T) (VALUES T &OPTIONAL))
  Documentation:
    MERGE-PATHNAMES* is like MERGE-PATHNAMES except that
    if the SPECIFIED pathname does not have an absolute directory,
    then the HOST and DEVICE both come from the DEFAULTS, whereas
    if the SPECIFIED pathname does have an absolute directory,
    then the HOST and DEVICE both come from the SPECIFIED pathname.
    This is what users want on a modern Unix or Windows operating system,
    unlike the MERGE-PATHNAMES behavior.
    Also, if either argument is NIL, then the other argument is returnedunmodified;
    this is unlike MERGE-PATHNAMES which always merges with a pathname,
    by default *DEFAULT-PATHNAME-DEFAULTS*, which cannot be NIL.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/OUTPUT-TRANSLATIONS:APPLY-OUTPUT-TRANSLATIONS
  • (COMPONENT-PATHNAME (COMPONENT))
  • UIOP/CONFIGURATION:RESOLVE-LOCATION
  • UIOP/CONFIGURATION:RESOLVE-ABSOLUTE-LOCATION
  • UIOP/CONFIGURATION:RESOLVE-RELATIVE-LOCATION
  • UIOP/LISP-BUILD:COMPILE-FILE-PATHNAME*
  • UIOP/FILESYSTEM:GET-PATHNAME-DEFAULTS
  • UIOP/FILESYSTEM:TRUENAMIZE
  • SUBDIRECTORIES
  • DIRECTORY-FILES
  • UIOP/PATHNAME:TRANSLATE-PATHNAME*
  • UIOP/PATHNAME:DIRECTORIZE-PATHNAME-HOST-DEVICE
  • UIOP/PATHNAME:WILDEN
  • ENSURE-ABSOLUTE-PATHNAME
  • UIOP/PATHNAME:SUBPATHNAME

ENSURE-PATHNAME names a compiled function:
  Lambda-list: (PATHNAME &KEY ON-ERROR DEFAULTS TYPE DOT-DOT NAMESTRING
                         EMPTY-IS-NIL WANT-PATHNAME WANT-LOGICAL WANT-PHYSICAL
                         ENSURE-PHYSICAL WANT-RELATIVE WANT-ABSOLUTE
                         ENSURE-ABSOLUTE ENSURE-SUBPATH WANT-NON-WILD WANT-WILD
                         WILDEN WANT-FILE WANT-DIRECTORY ENSURE-DIRECTORY
                         WANT-EXISTING ENSURE-DIRECTORIES-EXIST TRUENAME
                         RESOLVE-SYMLINKS TRUENAMIZE &AUX (P PATHNAME))
  Declared type: FUNCTION
  Derived type: (FUNCTION
                 (T &KEY (:ON-ERROR T) (:DEFAULTS T) (:TYPE T) (:DOT-DOT T)
                  (:NAMESTRING T) (:EMPTY-IS-NIL T) (:WANT-PATHNAME T)
                  (:WANT-LOGICAL T) (:WANT-PHYSICAL T) (:ENSURE-PHYSICAL T)
                  (:WANT-RELATIVE T) (:WANT-ABSOLUTE T) (:ENSURE-ABSOLUTE T)
                  (:ENSURE-SUBPATH T) (:WANT-NON-WILD T) (:WANT-WILD T)
                  (:WILDEN T) (:WANT-FILE T) (:WANT-DIRECTORY T)
                  (:ENSURE-DIRECTORY T) (:WANT-EXISTING T)
                  (:ENSURE-DIRECTORIES-EXIST T) (:TRUENAME T)
                  (:RESOLVE-SYMLINKS T) (:TRUENAMIZE T))
                 (VALUES T &OPTIONAL))
  Documentation:
    Coerces its argument into a PATHNAME,
    optionally doing some transformations and checking specified constraints.
    
    If the argument is NIL, then NIL is returned unless the WANT-PATHNAMEconstraint is specified.
    
    If the argument is a STRING, it is first converted to a pathname via
    PARSE-UNIX-NAMESTRING, PARSE-NAMESTRING or PARSE-NATIVE-NAMESTRINGrespectively
    depending on the NAMESTRING argument being :UNIX, :LISP or :NATIVErespectively,
    or else by using CALL-FUNCTION on the NAMESTRING argument;
    if :UNIX is specified (or NIL, the default, which specifies the samething),
    then PARSE-UNIX-NAMESTRING it is called with the keywords
    DEFAULTS TYPE DOT-DOT ENSURE-DIRECTORY WANT-RELATIVE, and
    the result is optionally merged into the DEFAULTS if ENSURE-ABSOLUTE istrue.
    
    The pathname passed or resulting from parsing the string
    is then subjected to all the checks and transformations below are run.
    
    Each non-nil constraint argument can be one of the symbols T, ERROR, CERRORor IGNORE.
    The boolean T is an alias for ERROR.
    ERROR means that an error will be raised if the constraint is notsatisfied.
    CERROR means that an continuable error will be raised if the constraint isnot satisfied.
    IGNORE means just return NIL instead of the pathname.
    
    The ON-ERROR argument, if not NIL, is a function designator (as per CALL-FUNCTION)
    that will be called with the the following arguments:
    a generic format string for ensure pathname, the pathname,
    the keyword argument corresponding to the failed check or transformation,
    a format string for the reason ENSURE-PATHNAME failed,
    and a list with arguments to that format string.
    If ON-ERROR is NIL, ERROR is used instead, which does the right thing.
    You could also pass (CERROR "CONTINUE DESPITE FAILED CHECK").
    
    The transformations and constraint checks are done in this order,
    which is also the order in the lambda-list:
    
    EMPTY-IS-NIL returns NIL if the argument is an empty string.
    WANT-PATHNAME checks that pathname (after parsing if needed) is not null.
    Otherwise, if the pathname is NIL, ensure-pathname returns NIL.
    WANT-LOGICAL checks that pathname is a LOGICAL-PATHNAME
    WANT-PHYSICAL checks that pathname is not a LOGICAL-PATHNAME
    ENSURE-PHYSICAL ensures that pathname is physical via TRANSLATE-LOGICAL-PATHNAME
    WANT-RELATIVE checks that pathname has a relative directory component
    WANT-ABSOLUTE checks that pathname does have an absolute directorycomponent
    ENSURE-ABSOLUTE merges with the DEFAULTS, then checks again
    that the result absolute is an absolute pathname indeed.
    ENSURE-SUBPATH checks that the pathname is a subpath of the DEFAULTS.
    WANT-FILE checks that pathname has a non-nil FILE component
    WANT-DIRECTORY checks that pathname has nil FILE and TYPE components
    ENSURE-DIRECTORY uses ENSURE-DIRECTORY-PATHNAME to interpret
    any file and type components as being actually a last directory component.
    WANT-NON-WILD checks that pathname is not a wild pathname
    WANT-WILD checks that pathname is a wild pathname
    WILDEN merges the pathname with **/*.*.* if it is not wild
    WANT-EXISTING checks that a file (or directory) exists with that pathname.
    ENSURE-DIRECTORIES-EXIST creates any parent directory with ENSURE-DIRECTORIES-EXIST.
    TRUENAME replaces the pathname by its truename, or errors if not possible.
    RESOLVE-SYMLINKS replaces the pathname by a variant with symlinks resolvedby RESOLVE-SYMLINKS.
    TRUENAMIZE uses TRUENAMIZE to resolve as many symlinks as possible.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/FIND-SYSTEM:LOCATE-SYSTEM
  • UIOP/CONFIGURATION:RESOLVE-ABSOLUTE-LOCATION
  • UIOP/CONFIGURATION:RESOLVE-RELATIVE-LOCATION
  • TMPIZE-PATHNAME
  • UIOP/STREAM:CALL-WITH-TEMPORARY-FILE
  • UIOP/FILESYSTEM:RENAME-FILE-OVERWRITING-TARGET
  • UIOP/FILESYSTEM:PROBE-FILE*
  • PARSE-NATIVE-NAMESTRING
  • UIOP/PATHNAME:PARSE-UNIX-NAMESTRING

DENORMALIZE-PATHNAME-DIRECTORY-COMPONENT names a compiled function:
  Lambda-list: (DIRECTORY-COMPONENT)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Documentation:
    Convert the DIRECTORY-COMPONENT from a CLHS-standard format to a formatusable
    by the underlying implementation's MAKE-PATHNAME and other primitives
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

*WILD-PATH* names a special variable:
  Value: #P"**/*.*"
  Documentation:
    A pathname object with wildcards for matching any file in any recursivesubdirectory

• Referenced by
  • ASDF/OUTPUT-TRANSLATIONS:WRAPPING-OUTPUT-TRANSLATIONS
  • UIOP/PATHNAME:WILDEN

SPLIT-NAME-TYPE names a compiled function:
  Lambda-list: (FILENAME)
  Derived type: (FUNCTION (T) (VALUES T T &OPTIONAL))
  Documentation:
    Split a filename into two values NAME and TYPE that are returned.
    We assume filename has no directory component.
    The last . if any separates name and type from from type,
    except that if there is only one . and it is in first position,
    the whole filename is the NAME with an empty type.
    NAME is always a string.
    For an empty type, *UNSPECIFIC-PATHNAME-TYPE* is returned.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/PATHNAME:PARSE-UNIX-NAMESTRING

PHYSICALIZE-PATHNAME names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES (OR PATHNAME NULL) &OPTIONAL))
  Documentation:
    if X is a logical pathname, use translate-logical-pathname on it.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (FIND-SYSTEM (STRING))
  • (PERFORM (DEFINE-OP SYSTEM))
  • ASDF/SESSION:NORMALIZE-NAMESTRING
  • UIOP/LISP-BUILD:COMPILE-FILE*
  • UIOP/FILESYSTEM:ENSURE-ALL-DIRECTORIES-EXIST
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/FILESYSTEM:SAFE-FILE-WRITE-DATE

DIRECTORY-PATHNAME-P names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Does PATHNAME represent a directory?
    
    A directory-pathname is a pathname _without_ a filename. The three
    ways that the filename components can be missing are for it to be NIL,
    :UNSPECIFIC or the empty string.
    
    Note that this does _not_ check to see that PATHNAME points to an
    actually-existing directory.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • (PROCESS-SOURCE-REGISTRY (PATHNAME))
  • (PROCESS-OUTPUT-TRANSLATIONS (PATHNAME))
  • ASDF/SYSTEM-REGISTRY:SYSDEF-CENTRAL-REGISTRY-SEARCH
  • ASDF/SYSTEM-REGISTRY:PROBE-ASD
  • UIOP/STREAM:DETECT-ENCODING
  • UIOP/FILESYSTEM:DELETE-DIRECTORY-TREE
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • SUBDIRECTORIES
  • DIRECTORY-FILES
  • UIOP/FILESYSTEM:DIRECTORY-EXISTS-P
  • UIOP/PATHNAME:SUBPATHP
  • UIOP/PATHNAME:ENSURE-DIRECTORY-PATHNAME

RELATIVIZE-DIRECTORY-COMPONENT names a compiled function:
  Lambda-list: (DIRECTORY-COMPONENT)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Documentation:
    Given the DIRECTORY-COMPONENT of a pathname, return an otherwise similarrelative directory component
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • UIOP/PATHNAME:RELATIVIZE-PATHNAME-DIRECTORY

PATHNAME-PARENT-DIRECTORY-PATHNAME names a compiled function:
  Lambda-list: (PATHNAME)
  Derived type: (FUNCTION (T) (VALUES (OR PATHNAME NULL) &OPTIONAL))
  Documentation:
    Returns a new pathname that corresponds to the parent of the currentpathname's directory,
    i.e. removing one level of depth in the DIRECTORY component. e.g. ifpathname is
    Unix pathname /foo/bar/baz/file.type then return /foo/bar/
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • FIND-SKELFILE
  • SKEL/CORE::FIND-SKEL-FILE
  • SKEL/CORE::FIND-SKEL-PROJECT-ROOT

ENSURE-ABSOLUTE-PATHNAME names a compiled function:
  Lambda-list: (PATH &OPTIONAL DEFAULTS (ON-ERROR (QUOTE ERROR)))
  Derived type: (FUNCTION (T &OPTIONAL T T) *)
  Documentation:
    Given a pathname designator PATH, return an absolute pathname as specifiedby PATH
    considering the DEFAULTS, or, if not possible, use CALL-FUNCTION on thespecified ON-ERROR behavior,
    with a format control-string and other arguments as arguments
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/PARSE-DEFSYSTEM:DETERMINE-SYSTEM-DIRECTORY
  • (OUTPUT-FILES AROUND (T T))
  • ASDF/SYSTEM-REGISTRY:PROBE-ASD
  • ASDF/SESSION:NORMALIZE-NAMESTRING
  • UIOP/STREAM:CALL-WITH-TEMPORARY-FILE
  • UIOP/PATHNAME:ENSURE-PATHNAME
  • UIOP/FILESYSTEM:TRUENAMIZE
  • UIOP/PATHNAME:ENOUGH-PATHNAME
  • ENSURE-ABSOLUTE-PATHNAME

WITH-PATHNAME-DEFAULTS names a macro:
  Lambda-list: ((&OPTIONAL DEFAULTS) &BODY BODY)
  Documentation:
    Execute BODY in a context where the *DEFAULT-PATHNAME-DEFAULTS* is asspecified,
    where leaving the defaults NIL or unspecified means a (NIL-PATHNAME),except
    on ABCL, Genera and XCL, where it remains unchanged for it doubles ascurrent-directory.
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Macroexpanded by
  • ASDF/SOURCE-REGISTRY:FLATTEN-SOURCE-REGISTRY
  • ASDF/SESSION:COMPUTE-FILE-STAMP
  • ASDF/SESSION:NORMALIZE-NAMESTRING
  • UIOP/FILESYSTEM:TRUENAME*
  • PARSE-NATIVE-NAMESTRING
  • UIOP/PATHNAME:SUBPATHP

TRANSLATE-PATHNAME* names a compiled function:
  Lambda-list: (PATH ABSOLUTE-SOURCE DESTINATION &OPTIONAL ROOT SOURCE)
  Derived type: (FUNCTION (T T T &OPTIONAL T T) *)
  Documentation:
    A wrapper around TRANSLATE-PATHNAME to be used by the ASDF output-translations facility.
    PATH is the pathname to be translated.
    ABSOLUTE-SOURCE is an absolute pathname to use as source for translate-pathname,
    DESTINATION is either a function, to be called with PATH and ABSOLUTE-SOURCE,
    or a relative pathname, to be merged with ROOT and used as destination fortranslate-pathname
    or an absolute pathname, to be used as destination for translate-pathname.
    In that last case, if ROOT is non-NIL, PATH is first transformated byDIRECTORIZE-PATHNAME-HOST-DEVICE.
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:CONTRIB;ASDF;UIOP.LISP.NEWEST

• Called by
  • ASDF/OUTPUT-TRANSLATIONS:APPLY-OUTPUT-TRANSLATIONS