Peter Siebel - Practical Common Lisp

(:use :common-lisp)

(:export

:list-directory

:file-exists-p

:directory-pathname-p

:file-pathname-p

:pathname-as-directory

:pathname-as-file

:walk-directory

:directory-p

:file-p))

and LOAD it. Then at the REPL or at the top of the file where you type the definitions from this chapter, type the following expression:

(in-package :com.gigamonkeys.pathnames)

In addition to avoiding name conflicts with symbols already available in CL-USER, packaging the library this way also makes it easier to use in other code, as you'll see in several future chapters.

You can implement the function for listing a single directory, list-directory, as a thin wrapper around the standard function DIRECTORY . DIRECTORY takes a special kind of pathname, called a wild pathname , that has one or more components containing the special value :wildand returns a list of pathnames representing files in the file system that match the wild pathname. [167] Another special value, :wild-inferiors , can appear as part of the directory component of a wild pathname, but you won't need it in this chapter. The matching algorithm—like most things having to do with the interaction between Lisp and a particular file system—isn't defined by the language standard, but most implementations on Unix and Windows follow the same basic scheme.

The DIRECTORY function has two problems that you need to address with list-directory. The main one is that certain aspects of its behavior differ fairly significantly between different Common Lisp implementations, even on the same operating system. The other is that while DIRECTORY provides a powerful interface for listing files, to use it properly requires understanding some rather subtle points about the pathname abstraction. Between these subtleties and the idiosyncrasies of different implementations, actually writing portable code that uses DIRECTORY to do something as simple as listing all the files and subdirectories in a single directory can be a frustrating experience. You can deal with those subtleties and idiosyncrasies once and for all, by writing list-directory, and forget them thereafter.

One subtlety I discussed in Chapter 14 is the two ways to represent the name of a directory as a pathname: directory form and file form.

To get DIRECTORY to return a list of files in /home/peter/, you need to pass it a wild pathname whose directory component is the directory you want to list and whose name and type components are :wild. Thus, to get a listing of the files in /home/peter/, it might seem you could write this:

(directory (make-pathname :name :wild :type :wild :defaults home-dir))

where home-diris a pathname representing /home/peter/. This would work if home-dirwere in directory form. But if it were in file form—for example, if it had been created by parsing the namestring "/home/peter"—then that same expression would list all the files in /homesince the name component "peter"would be replaced with :wild.

To avoid having to worry about explicitly converting between representations, you can define list-directoryto accept a nonwild pathname in either form, which it will then convert to the appropriate wild pathname.

To help with this, you should define a few helper functions. One, component-present-p, will test whether a given component of a pathname is "present," meaning neither NIL nor the special value :unspecific. [168] Implementations are allowed to return :unspecific instead of NIL as the value of pathname components in certain situations such as when the component isn't used by that implementation. Another, directory-pathname-p, tests whether a pathname is already in directory form, and the third, pathname-as-directory, converts any pathname to a directory form pathname.

(defun component-present-p (value)

(and value (not (eql value :unspecific))))

(defun directory-pathname-p (p)

(and

(not (component-present-p (pathname-name p)))

(not (component-present-p (pathname-type p)))

p))

(defun pathname-as-directory (name)

(let ((pathname (pathname name)))

(when (wild-pathname-p pathname)

(error "Can't reliably convert wild pathnames."))

(if (not (directory-pathname-p name))

(make-pathname

:directory (append (or (pathname-directory pathname) (list :relative))

(list (file-namestring pathname)))

:name nil

:type nil

:defaults pathname)

pathname)))

Now it seems you could generate a wild pathname to pass to DIRECTORY by calling MAKE-PATHNAME with a directory form name returned by pathname-as-directory. Unfortunately, it's not quite that simple, thanks to a quirk in CLISP's implementation of DIRECTORY . In CLISP, DIRECTORY won't return files with no extension unless the type component of the wildcard is NIL rather than :wild. So you can define a function, directory-wildcard, that takes a pathname in either directory or file form and returns a proper wildcard for the given implementation using read-time conditionalization to make a pathname with a :wildtype component in all implementations except for CLISP and NIL in CLISP.

(defun directory-wildcard (dirname)

(make-pathname

:name :wild

:type #-clisp :wild #+clisp nil

:defaults (pathname-as-directory dirname)))

Note how each read-time conditional operates at the level of a single expression After #-clisp, the expression :wildis either read or skipped; likewise, after #+clisp, the NIL is read or skipped.

Now you can take a first crack at the list-directoryfunction.

(defun list-directory (dirname)

(when (wild-pathname-p dirname)

(error "Can only list concrete directory names."))

(directory (directory-wildcard dirname)))

As it stands, this function would work in SBCL, CMUCL, and LispWorks. Unfortunately, a couple more implementation differences remain to be smoothed over. One is that not all implementations will return subdirectories of the given directory. Allegro, SBCL, CMUCL, and LispWorks do. OpenMCL doesn't by default but will if you pass DIRECTORY a true value via the implementation-specific keyword argument :directories. CLISP's DIRECTORY returns subdirectories only when it's passed a wildcard pathname with :wildas the last element of the directory component and NIL name and type components. In this case, it returns only subdirectories, so you'll need to call DIRECTORY twice with different wildcards and combine the results.