lispdoc - results for pathname

(pathname pathspec)
Function: Convert PATHSPEC (a pathname designator) into a pathname.
Example:
(defun figure-out-fname (fname)
  "should be made into one line later.."
  (let* ((fname (pathname fname))
         (result (merge-pathnames fname)))
    (namestring result)))
Mentioned in:
CLtL2 - 19.5. Defstruct Options
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 22.1.6. What the Print Function Produces
CLtL2 - 23.1.1. Pathnames
CLtL2 - 23.1.5. Logical Pathnames
CLtL2 - 23.1.5.3. Using Logical Pathnames
CLtL2 - 23.1.5.5. Discussion of Logical Pathnames
CLtL2 - 23.1.6. Pathname Functions
CLtL2 - 23.2. Opening and Closing Files
CLtL2 - 23.3. Renaming, Deleting, and Other File Operations
CLtL2 - 23.5. Accessing Directories
CLtL2 - 25.1.4. Similarity of Constants
HyperSpec - 19.2.1 Pathname Components
HyperSpec - 19.2.1.1 The Pathname Host Component
HyperSpec - 19.2.1.2 The Pathname Device Component
HyperSpec - 19.2.1.3 The Pathname Directory Component
HyperSpec - 19.2.1.4 The Pathname Name Component
HyperSpec - 19.2.1.5 The Pathname Type Component
HyperSpec - 19.2.1.6 The Pathname Version Component
HyperSpec - 19.2.2 Interpreting Pathname Component Values
HyperSpec - 19.2.2.1.1 Special Characters in Pathname Components
HyperSpec - 19.2.2.1.2 Case in Pathname Components
HyperSpec - 19.2.2.1.2.1 Local Case in Pathname Components
HyperSpec - 19.2.2.1.2.2 Common Case in Pathname Components
HyperSpec - 19.2.2.2 Special Pathname Component Values
HyperSpec - 19.2.2.4 Restrictions on Examining Pathname Components
HyperSpec - 19.2.2.4.1 Restrictions on Examining a Pathname Host Component
HyperSpec - 19.2.2.4.2 Restrictions on Examining a Pathname Device Component
HyperSpec - 19.2.2.4.3 Restrictions on Examining a Pathname Directory Component
HyperSpec - 19.2.2.4.4 Restrictions on Examining a Pathname Name Component
HyperSpec - 19.2.2.4.5 Restrictions on Examining a Pathname Type Component
HyperSpec - 19.2.2.4.6 Restrictions on Examining a Pathname Version Component
HyperSpec - 19.2.2.4.7 Notes about the Pathname Version Component
HyperSpec - 19.3.1 Syntax of Logical Pathname Namestrings
HyperSpec - 19.3.1.1 Additional Information about Parsing Logical Pathname Namestrings
HyperSpec - 19.3.1.1.1 The Host part of a Logical Pathname Namestring
HyperSpec - 19.3.1.1.2 The Device part of a Logical Pathname Namestring
HyperSpec - 19.3.1.1.3 The Directory part of a Logical Pathname Namestring
HyperSpec - 19.3.1.1.4 The Type part of a Logical Pathname Namestring
HyperSpec - 19.3.1.1.5 The Version part of a Logical Pathname Namestring
HyperSpec - 19.3.1.1.6 Wildcard Words in a Logical Pathname Namestring
HyperSpec - 19.3.1.1.7 Lowercase Letters in a Logical Pathname Namestring
HyperSpec - 19.3.1.1.8 Other Syntax in a Logical Pathname Namestring
HyperSpec - 19.3.2 Logical Pathname Components
HyperSpec - 19.3.2.1 Unspecific Components of a Logical Pathname
HyperSpec - 19.3.2.2 Null Strings as Components of a Logical Pathname
HyperSpec - Function PATHNAME
HyperSpec - System Class PATHNAME
PCL - how pathnames represent filenames
(pathnamep object)
Undocumented
 Mentioned in:
CLtL2 - 23.1.6. Pathname Functions
CLtL2 - 6.2.2. Specific Data Type Predicates
HyperSpec - Function PATHNAMEP
pathnames
 
 Mentioned in:
HyperSpec - 19.1.2 Pathnames as Filenames
HyperSpec - 19.1.3 Parsing Namestrings Into Pathnames
HyperSpec - 19.2 Pathnames
HyperSpec - 19.2.2.3 Restrictions on Wildcard Pathnames
HyperSpec - 19.2.2.5 Restrictions on Constructing Pathnames
HyperSpec - 19.2.3 Merging Pathnames
HyperSpec - 19.2.3.1 Examples of Merging Pathnames
HyperSpec - 19.3 Logical Pathnames
HyperSpec - 20.1.1 Coercion of Streams to Pathnames
HyperSpec - 22.1.3.11 Printing Pathnames
(make-pathname &key host (device nil devp) (directory nil dirp)
 (name nil namep) (type nil typep) (version nil versionp) defaults (case local))
Function: Makes a new pathname from the component arguments. Note that host is a host-structure or string.
Example:
(defun directory-wildcard (dirname)
  (make-pathname :name :wild :type :wild
                 :defaults
                 (pathname-as-directory dirname)))
Mentioned in:
CLtL2 - 23.1.2. Case Conventions
CLtL2 - 23.1.3. Structured Directories
CLtL2 - 23.1.5.2. Parsing of Logical Pathname Namestrings
CLtL2 - 23.1.5.3. Using Logical Pathnames
CLtL2 - 23.1.6. Pathname Functions
HyperSpec - Function MAKE-PATHNAME
PCL - constructing new pathnames
PCL - listing a directory
PCL - two representations of directory names
(pathname-host pathname &key (case local))
Function: Return PATHNAME's host.
 Mentioned in:
CLtL2 - 23.1.2. Case Conventions
CLtL2 - 23.1.5.2. Parsing of Logical Pathname Namestrings
CLtL2 - 23.1.5.3. Using Logical Pathnames
CLtL2 - 23.1.6. Pathname Functions
HyperSpec - Function PATHNAME-HOST, PATHNAME-DEVICE, PATHNAME-DIRECTORY, PATHNAME-NAME, PATHNAME-TYPE, PATHNAME-VERSION
PCL - how pathnames represent filenames
(pathname-name pathname &key (case local))
Function: Return PATHNAME's name.
Example:
(defun tl-merge-two-paths (new-path base)
  "Tries to merge two paths.."
  (let ((new-dir
         (append (pathname-directory base)
                 (cdr
                  (pathname-directory
                   new-path)))))
    (make-pathname :name (pathname-name new-path)
                   :type (pathname-type new-path)
                   :directory new-dir)))
Mentioned in:
CLtL2 - 23.1.2. Case Conventions
CLtL2 - 23.1.6. Pathname Functions
HyperSpec - Function PATHNAME-HOST, PATHNAME-DEVICE, PATHNAME-DIRECTORY, PATHNAME-NAME, PATHNAME-TYPE, PATHNAME-VERSION
PCL - how pathnames represent filenames
(pathname-type pathname &key (case local))
Function: Return PATHNAME's type.
Example:
(defun mp3-p (file)
  (and (not (directory-pathname-p file))
       (string-equal "mp3" (pathname-type file))))
Mentioned in:
CLtL2 - 23.1.2. Case Conventions
CLtL2 - 23.1.6. Pathname Functions
HyperSpec - Function PATHNAME-HOST, PATHNAME-DEVICE, PATHNAME-DIRECTORY, PATHNAME-NAME, PATHNAME-TYPE, PATHNAME-VERSION
PCL - how pathnames represent filenames
(merge-pathnames pathname &optional (defaults *default-pathname-defaults*)
 (default-version newest))
Function: Construct a filled in pathname by completing the unspecified components from the defaults.
Example:
(defun figure-out-fname (fname)
  "should be made into one line later.."
  (let* ((fname (pathname fname))
         (result (merge-pathnames fname)))
    (namestring result)))
Mentioned in:
CLtL2 - 23.1.2. Case Conventions
CLtL2 - 23.1.3. Structured Directories
CLtL2 - 23.1.5.2. Parsing of Logical Pathname Namestrings
CLtL2 - 23.1.6. Pathname Functions
CLtL2 - 23.3. Renaming, Deleting, and Other File Operations
HyperSpec - Function MERGE-PATHNAMES
PCL - constructing new pathnames
*load-pathname*
Variable: the defaulted pathname that LOAD is currently loading
 Mentioned in:
CLtL2 - 23.4. Loading Files
HyperSpec - Variable *LOAD-PATHNAME*, *LOAD-TRUENAME
(pathname-device pathname &key (case local))
Function: Return PATHNAME's device.
 Mentioned in:
CLtL2 - 23.1.2. Case Conventions
CLtL2 - 23.1.6. Pathname Functions
HyperSpec - Function PATHNAME-HOST, PATHNAME-DEVICE, PATHNAME-DIRECTORY, PATHNAME-NAME, PATHNAME-TYPE, PATHNAME-VERSION
PCL - how pathnames represent filenames
(pathname-version pathname)
Function: Return PATHNAME's version.
 Mentioned in:
CLtL2 - 23.1.6. Pathname Functions
HyperSpec - Function PATHNAME-HOST, PATHNAME-DEVICE, PATHNAME-DIRECTORY, PATHNAME-NAME, PATHNAME-TYPE, PATHNAME-VERSION
PCL - how pathnames represent filenames
(logical-pathname pathspec)
Function: Converts the pathspec argument to a logical-pathname and returns it.
 Mentioned in:
CLtL2 - 23.1.5. Logical Pathnames
CLtL2 - 23.1.5.2. Parsing of Logical Pathname Namestrings
CLtL2 - 23.1.5.3. Using Logical Pathnames
CLtL2 - 23.1.5.5. Discussion of Logical Pathnames
HyperSpec - Function LOGICAL-PATHNAME
HyperSpec - System Class LOGICAL-PATHNAME
(pathname-directory pathname &key (case local))
Function: Return PATHNAME's directory.
Example:
(defun tl-merge-two-paths (new-path base)
  "Tries to merge two paths.."
  (let ((new-dir
         (append (pathname-directory base)
                 (cdr
                  (pathname-directory
                   new-path)))))
    (make-pathname :name (pathname-name new-path)
                   :type (pathname-type new-path)
                   :directory new-dir)))
Mentioned in:
CLtL2 - 23.1.2. Case Conventions
CLtL2 - 23.1.3. Structured Directories
CLtL2 - 23.1.6. Pathname Functions
HyperSpec - Function PATHNAME-HOST, PATHNAME-DEVICE, PATHNAME-DIRECTORY, PATHNAME-NAME, PATHNAME-TYPE, PATHNAME-VERSION
PCL - how pathnames represent filenames
(translate-pathname source from-wildname to-wildname &key)
Function: Use the source pathname to translate the from-wildname's wild and unspecified elements into a completed to-pathname based on the to-wildname.
 Mentioned in:
CLtL2 - 23.1.2. Case Conventions
CLtL2 - 23.1.4. Extended Wildcards
CLtL2 - 23.1.5.3. Using Logical Pathnames
HyperSpec - Function TRANSLATE-PATHNAME
(wild-pathname-p pathname &optional field-key)
Function: Predicate for determining whether pathname contains any wildcards.
Example:
(defun list-directory (dirname)
  "Return a list of the contents of the directory named by dirname.
Names of subdirectories will be returned in `directory normal
form'. Unlike CL:DIRECTORY, LIST-DIRECTORY does not accept
wildcard pathnames; `dirname' should simply be a pathname that
names a directory. It can be in either file or directory form."
  (when (wild-pathname-p dirname)
    (error
     "Can only list concrete directory names."))
  (let ((wildcard (directory-wildcard dirname)))
    (directory wildcard)))
Mentioned in:
CLtL2 - 23.1.4. Extended Wildcards
CLtL2 - 23.1.6. Pathname Functions
CLtL2 - 23.2. Opening and Closing Files
CLtL2 - 23.3. Renaming, Deleting, and Other File Operations
HyperSpec - Function WILD-PATHNAME-P
(asdf:error-pathname condition)
Undocumented
  
(pathname-match-p in-pathname in-wildname)
Function: Pathname matches the wildname template?
 Mentioned in:
CLtL2 - 23.1.4. Extended Wildcards
CLtL2 - 23.1.5.3. Using Logical Pathnames
HyperSpec - Function PATHNAME-MATCH-P
(asdf:merge-pathnames* specified &optional
 (defaults *default-pathname-defaults*))
Function: MERGE-PATHNAMES* is like MERGE-PATHNAMES except that if the SPECIFIED pathname does not have an absolute directory, then the HOST and DEVICE come from the DEFAULTS. Also, if either argument is NIL, then the other argument is returned unmodified.
  
(asdf:component-pathname component)
Function: Extracts the pathname applicable for a particular component.
  
(file-error-pathname condition)
Function: Return the offending thread that the THREAD-ERROR pertains to.
 Mentioned in:
CLtL2 - 29.5. Predefined Condition Types
HyperSpec - Function FILE-ERROR-PATHNAME
(user-homedir-pathname &optional host)
Function: Return the home directory of the user as a pathname. If the HOME environment variable has been specified, the directory it designates is returned; otherwise obtains the home directory from the operating system. HOST argument is ignored by SBCL.
 Mentioned in:
CLtL2 - 23.1.6. Pathname Functions
CLtL2 - 25.4.2. Other Environment Inquiries
HyperSpec - Function USER-HOMEDIR-PATHNAME
(compile-file-pathname input-file &key (output-file nil output-file-p)
 &allow-other-keys)
Function: Return a pathname describing what file COMPILE-FILE would write to given these arguments.
 Mentioned in:
CLtL2 - 23.1.5.3. Using Logical Pathnames
CLtL2 - 23.1.5.5. Discussion of Logical Pathnames
HyperSpec - Function COMPILE-FILE-PATHNAME
*compile-file-pathname*
Variable: The defaulted pathname of the file currently being compiled, or NIL if not compiling.
 Mentioned in:
CLtL2 - 25.1. The Compiler
HyperSpec - Variable *COMPILE-FILE-PATHNAME*, *COMPILE-FILE-TRUENAME
(asdf:absolute-pathname-p pathspec)
Undocumented
  
(asdf:directory-pathname-p pathname)
Function: 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.
  
(translate-logical-pathname pathname &key)
Function: Translate PATHNAME to a physical pathname, which is returned.
 Mentioned in:
CLtL2 - 23.1.4. Extended Wildcards
CLtL2 - 23.1.5.2. Parsing of Logical Pathname Namestrings
CLtL2 - 23.1.5.3. Using Logical Pathnames
HyperSpec - Function TRANSLATE-LOGICAL-PATHNAME
*default-pathname-defaults
 
 Mentioned in:
HyperSpec - Variable *DEFAULT-PATHNAME-DEFAULTS
(asdf:compile-file-pathname* input-file &rest keys &key output-file
 &allow-other-keys)
Undocumented
  
*default-pathname-defaults*
Undocumented
 Mentioned in:
CLtL2 - 23.1.3. Structured Directories
CLtL2 - 23.1.6. Pathname Functions
CLtL2 - 23.4. Loading Files
CLtL2 - 25.1. The Compiler
PCL - constructing new pathnames
(cl-fad:pathname-as-file pathspec)
Function: Converts the non-wild pathname designator PATHSPEC to file form.
  
(cffi:foreign-library-pathname lib)
Undocumented
  
(asdf:system-relative-pathname system name &key type)
Undocumented
  
(logical-pathname-translations host)
Function: Return the (logical) host object argument's list of translations.
 Mentioned in:
CLtL2 - 23.1.5.1. Syntax of Logical Pathname Namestrings
CLtL2 - 23.1.5.3. Using Logical Pathnames
CLtL2 - 23.1.5.5. Discussion of Logical Pathnames
HyperSpec - Accessor LOGICAL-PATHNAME-TRANSLATIONS
(asdf:ensure-directory-pathname pathspec)
Function: Converts the non-wild pathname designator PATHSPEC to directory form.
  
(asdf:system-definition-pathname system)
Undocumented
  
(asdf:pathname-directory-pathname pathname)
Function: Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME, and NIL NAME, TYPE and VERSION components
  
(asdf:component-relative-pathname component)
Function: Returns a pathname for the component argument intended to be interpreted relative to the pathname of that component's parent. Despite the function's name, the return value may be an absolute pathname, because an absolute pathname may be interpreted relative to another pathname in a degenerate way.
  
hunchentoot:*access-log-pathname*
Variable: A designator for the pathname of the access log file used by the LOG-ACCESS-TO-FILE function. The initial value is NIL which means that nothing will be logged.
  
(cl-fad:directory-pathname-p pathspec)
Function: Returns NIL if PATHSPEC (a pathname designator) does not designate a directory, PATHSPEC otherwise. It is irrelevant whether file or directory designated by PATHSPEC does actually exist.
  
hunchentoot:*message-log-pathname*
Variable: A designator for the pathname of the message log file used by the LOG-MESSAGE-TO-FILE function. The initial value is NIL which means that nothing will be logged.
  
(cl-fad:pathname-as-directory pathspec)
Function: Converts the non-wild pathname designator PATHSPEC to directory form.
  
(load-logical-pathname-translations host)
Function: Reads logical pathname translations from SYS:SITE;HOST.TRANSLATIONS.NEWEST, with HOST replaced by the supplied parameter. Returns T on success. If HOST is already defined as logical pathname host, no file is loaded and NIL is returned. The file should contain a single form, suitable for use with (SETF LOGICAL-PATHNAME-TRANSLATIONS). Note: behaviour of this function is higly implementation dependent, and historically it used to be a no-op in SBcL -- the current approach is somewhat experimental and subject to change.
 Mentioned in:
CLtL2 - 23.1.5.3. Using Logical Pathnames
CLtL2 - 23.1.5.5. Discussion of Logical Pathnames
HyperSpec - Function LOAD-LOGICAL-PATHNAME-TRANSLATIONS
(asdf:component-name-to-pathname-components s &key force-directory
 force-relative)
Function: Splits the path string S, returning three 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, suitable for use with MAKE-PATHNAME when prepended with the flag value. A filename with type extension, possibly NIL in the case of a directory pathname. FORCE-DIRECTORY forces S to be interpreted as a directory pathname (third return value will be NIL, final component of S will be treated as part of the directory path. The intention of this function is to support structured component names, e.g., (:file "foo/bar"), which will be unpacked to relative pathnames.