Testing a File’s Existence

To replace **PROBE-FILE**, you can define a function called file-exists-p. It should accept a pathname and return an equivalent pathname if the file exists and **NIL** if it doesn’t. It should be able to accept the name of a directory in either directory or file form but should always return a directory form pathname if the file exists and is a directory. This will allow you to use file-exists-p, along with directory-pathname-p, to test whether an arbitrary name is the name of a file or directory.

In theory, file-exists-p is quite similar to the standard function **PROBE-FILE**; indeed, in several implementations—SBCL, LispWorks, and OpenMCL—**PROBE-FILE** already gives you the behavior you want for file-exists-p. But not all implementations of **PROBE-FILE** behave quite the same.

Allegro and CMUCL’s **PROBE-FILE** functions are close to what you need—they will accept the name of a directory in either form but, instead of returning a directory form name, simply return the name in the same form as the argument it was passed. Luckily, if passed the name of a nondirectory in directory form, they return **NIL**. So with those implementations you can get the behavior you want by first passing the name to **PROBE-FILE** in directory form—if the file exists and is a directory, it will return the directory form name. If that call returns **NIL**, then you try again with a file form name.

CLISP, on the other hand, once again has its own way of doing things. Its **PROBE-FILE** immediately signals an error if passed a name in directory form, regardless of whether a file or directory exists with that name. It also signals an error if passed a name in file form that’s actually the name of a directory. For testing whether a directory exists, CLISP provides its own function: probe-directory (in the ext package). This is almost the mirror image of **PROBE-FILE**: it signals an error if passed a name in file form or if passed a name in directory form that happens to name a file. The only difference is it returns **T** rather than a pathname when the named directory exists.

But even in CLISP you can implement the desired semantics by wrapping the calls to **PROBE-FILE** and probe-directory in **IGNORE-ERRORS**.4

  1. (defun file-exists-p (pathname)
  2.   #+(or sbcl lispworks openmcl)
  3.   (probe-file pathname)
  5.   #+(or allegro cmu)
  6.   (or (probe-file (pathname-as-directory pathname))
  7.       (probe-file pathname))
  9.   #+clisp
  10.   (or (ignore-errors
  11.         (probe-file (pathname-as-file pathname)))
  12.       (ignore-errors
  13.         (let ((directory-form (pathname-as-directory pathname)))
  14.           (when (ext:probe-directory directory-form)
  15.             directory-form))))
  17.   #-(or sbcl cmu lispworks openmcl allegro clisp)
  18.   (error "file-exists-p not implemented"))

The function pathname-as-file that you need for the CLISP implementation of file-exists-p is the inverse of the previously defined pathname-as-directory, returning a pathname that’s the file form equivalent of its argument. This function, despite being needed here only by CLISP, is generally useful, so define it for all implementations and make it part of the library.

  1. (defun pathname-as-file (name)
  2.   (let ((pathname (pathname name)))
  3.     (when (wild-pathname-p pathname)
  4.       (error "Can't reliably convert wild pathnames."))
  5.     (if (directory-pathname-p name)
  6.       (let* ((directory (pathname-directory pathname))
  7.              (name-and-type (pathname (first (last directory)))))
  8.         (make-pathname
  9.          :directory (butlast directory)
  10.          :name (pathname-name name-and-type)
  11.          :type (pathname-type name-and-type)
  12.          :defaults pathname))
  13.       pathname)))