source: trunk/source/lib/pathnames.lisp @ 14358

Last change on this file since 14358 was 14358, checked in by rme, 9 years ago

New functions DELETE-EMPTY-DIRECTORY and DELETE-DIRECTORY.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 22.8 KB
Line 
1;;;-*-Mode: LISP; Package: CCL -*-
2;;;
3;;;   Copyright (C) 1994-2001 Digitool, Inc
4;;;   Portions copyright (C) 2001-2009 Clozure Associates
5;;;   This file is part of Clozure CL. 
6;;;
7;;;   Clozure CL is licensed under the terms of the Lisp Lesser GNU Public
8;;;   License , known as the LLGPL and distributed with Clozure CL as the
9;;;   file "LICENSE".  The LLGPL consists of a preamble and the LGPL,
10;;;   which is distributed with Clozure CL as the file "LGPL".  Where these
11;;;   conflict, the preamble takes precedence. 
12;;;
13;;;   Clozure CL is referenced in the preamble as the "LIBRARY."
14;;;
15;;;   The LLGPL is also available online at
16;;;   http://opensource.franz.com/preamble.html
17
18;;pathnames.lisp Pathnames for Coral Common LISP
19(in-package "CCL")
20
21(eval-when (eval compile)
22  (require 'level-2)
23  (require 'backquote)
24)
25;(defconstant $accessDenied -5000) ; put this with other errnos
26(defconstant $afpAccessDenied -5000) ; which name to use?
27
28
29
30;-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
31;ANSI CL logical pathnames
32
33
34(defvar *pathname-translations-pathname*
35  (make-pathname :host "ccl" :type "pathname-translations"))
36
37(defun load-logical-pathname-translations (host)
38  ;(setq host (verify-logical-host-name host))
39  (when (not (%str-assoc host %logical-host-translations%))
40    (setf (logical-pathname-translations host)
41          (with-open-file (file (merge-pathnames (make-pathname :name host :defaults nil)
42                                                 *pathname-translations-pathname*)
43                                :element-type 'base-char)
44            (read file)))
45    T))
46
47(defun back-translate-pathname (path &optional hosts)
48  (let ((newpath (back-translate-pathname-1 path hosts)))
49    (cond ((equalp path newpath)
50           ;; (fcomp-standard-source path)
51           (namestring (pathname path)))
52          (t newpath))))
53
54
55(defun back-translate-pathname-1 (path &optional hosts)
56  (dolist (host %logical-host-translations%)
57    (when (or (null hosts) (member (car host) hosts :test 'string-equal))
58      (dolist (trans (cdr host))
59        (when (pathname-match-p path (cadr trans))
60          (let* (newpath)         
61            (setq newpath (translate-pathname path (cadr trans) (car trans) :reversible t))
62            (return-from back-translate-pathname-1 
63              (if  (equalp path newpath) path (back-translate-pathname-1 newpath hosts))))))))
64  path)
65
66
67
68; must be after back-translate-pathname
69(defun physical-pathname-p (path)
70  (let* ((path (pathname path))
71         (dir (pathname-directory path)))
72    (and dir
73         (or (not (logical-pathname-p path))
74             (not (null (memq (pathname-host path) '(nil :unspecific))))))))
75
76
77
78;-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
79;File or directory Manipulations
80
81(defun unix-rename (old-name new-name)
82  (with-filename-cstrs ((old old-name)
83                        (new new-name))
84    #+windows-target
85    (#__wunlink new)
86    (let* ((res #-windows-target (#_rename old new)
87                #+windows-target (#__wrename old new)))
88      (declare (fixnum res))
89      (if (zerop res)
90        (values t nil)
91        (values nil (%get-errno))))))
92
93(defun rename-file (file new-name &key (if-exists :error))
94  "Rename FILE to have the specified NEW-NAME. If FILE is a stream open to a
95  file, then the associated file is renamed."
96  (let* ((original (truename file))
97         (original-namestring (native-translated-namestring original))
98         (new-name (merge-pathnames new-name original))
99         (new-namestring (native-translated-namestring new-name)))
100    (unless new-namestring
101      (error "~S can't be created." new-name))
102    (unless (and (probe-file new-name)
103                 (not (if-exists if-exists new-name)))
104      (multiple-value-bind (res error)
105                           (unix-rename original-namestring
106                                        new-namestring)
107        (unless res
108          (error "Failed to rename ~A to ~A: ~A"
109                 original new-name error))
110        (when (streamp file)
111          (setf (stream-filename file)
112                (namestring (native-to-pathname new-namestring))))
113        (values new-name original (truename new-name))))))
114
115(defun copy-file (source-path dest-path &key (if-exists :error) (if-does-not-exist :create)
116                              (preserve-attributes nil))
117  (let* ((original (truename source-path))
118         (new-name (merge-pathnames dest-path original))
119         (buffer (make-array 4096 :element-type '(unsigned-byte 8))))
120    (with-open-file (in original :direction :input
121                        :element-type '(unsigned-byte 8))
122      (with-open-file (out new-name :direction :output
123                           :if-exists if-exists
124                           :if-does-not-exist if-does-not-exist
125                           :element-type '(unsigned-byte 8))
126        (loop
127          as n = (stream-read-vector in buffer 0 4096) until (eql n 0)
128          do (stream-write-vector out buffer 0 n))))
129    (when preserve-attributes
130      (copy-file-attributes original new-name))
131    (values new-name original (truename new-name))))
132
133(defun recursive-copy-directory (source-path dest-path &key test (if-exists :error))
134  ;; TODO: Support :if-exists :supersede to blow away any files not in source dir
135  (assert (directoryp source-path)(source-path)
136          "source-path is not a directory in RECURSIVE-COPY-DIRECTORY")
137  (setq if-exists (require-type if-exists '(member :overwrite :error)))
138  (setq dest-path (ensure-directory-pathname dest-path))
139  (when (eq if-exists :error)
140    (when (probe-file dest-path)
141      (if-exists if-exists dest-path))
142    ;; Skip the probe-file in recursive calls, we already know it's ok.
143    (setq if-exists :overwrite))
144  (let* ((source-dir (ensure-directory-pathname source-path))
145         (pattern (make-pathname :name :wild :type :wild :defaults source-dir))
146         (source-files (directory pattern :test test :directories t :files t)))
147    (ensure-directories-exist dest-path)
148    (dolist (f source-files)
149      (when (or (null test) (funcall test f))
150        (if (directory-pathname-p f)
151            (let ((dest-file (make-pathname :name (first (last (pathname-directory f)))
152                                            :defaults dest-path)))
153              (recursive-copy-directory f dest-file :test test :if-exists if-exists))
154            (let* ((dest-file (make-pathname :name (pathname-name f)
155                                             :type (pathname-type f)
156                                             :defaults dest-path)))
157              (copy-file f dest-file :if-exists :supersede :preserve-attributes t)))))))
158
159(defun delete-empty-directory (path)
160  (let* ((namestring (native-translated-namestring path))
161         (err (%rmdir namestring)))
162    (or (eql 0 err) (signal-file-error err path))))
163
164(defun delete-directory (path)
165  "Delete specified directory and all its contents."
166  (let ((namestring (native-translated-namestring path)))
167    (if (eq :directory (%unix-file-kind namestring t))
168      (let* ((dir (ensure-directory-pathname path))
169             (wild (make-pathname :name :wild :type :wild :defaults dir))
170             (files (directory wild :directories nil :files t
171                               :follow-links nil :include-emacs-lockfiles t))
172             (subdirs (directory wild :directories t :files nil
173                                 :follow-links nil
174                                 :include-emacs-lockfiles t)))
175        (dolist (f files)
176          (delete-file f))
177        (dolist (d subdirs)
178          (delete-directory d))
179        (delete-empty-directory path))
180      (error "~s is not a directory" path))))
181
182;;; use with caution!
183;;; blows away a directory and all its contents
184(defun recursive-delete-directory (path &key (if-does-not-exist :error))
185  (setq path (ensure-directory-pathname path))
186  (setq if-does-not-exist (require-type if-does-not-exist '(member :error nil)))
187  (when (eq if-does-not-exist :error)
188    (unless (probe-file path)
189      (if-does-not-exist if-does-not-exist path)))
190  (when (probe-file path)
191      (if (directoryp path)
192          ;; it's a directory: blow it away
193          (let* ((pattern (make-pathname :name :wild :type :wild :defaults path))
194                 (files (directory pattern :directories nil :files t))
195                 (subdirs (directory pattern :directories t :files nil))
196                 (target-pathname (native-translated-namestring path)))
197            (dolist (f files)
198              (delete-file f))
199            (dolist (d subdirs)
200              (recursive-delete-directory d :if-does-not-exist if-does-not-exist))
201            (%rmdir target-pathname))
202          ;; it's not a directory: for safety's sake, signal an error
203          (error "Pathname '~A' is not a directory" path))))
204
205;;; It's not clear that we can support anything stronger than
206;;; "advisory" ("you pretend the file's locked & I will too") file
207;;; locking under Darwin.
208
209
210
211
212(defun create-directory (path &key (mode #o777))
213  (let* ((pathname (translate-logical-pathname (merge-pathnames path)))
214         (created-p nil)
215         (parent-dirs (let* ((pd (pathname-directory pathname)))
216                        (if (eq (car pd) :relative)
217                          (pathname-directory (merge-pathnames
218                                               pathname
219                                               (mac-default-directory)))
220                          pd)))
221         (nparents (length parent-dirs)))
222    (when (wild-pathname-p pathname)
223      (error 'file-error :error-type "Inappropriate use of wild pathname ~s"
224             :pathname pathname))
225    (do* ((i 1 (1+ i)))
226         ((> i nparents) (values pathname created-p))
227      (declare (fixnum i))
228      (let* ((parent (make-pathname
229                      :name :unspecific
230                      :type :unspecific
231                      :host (pathname-host pathname)
232                      :device (pathname-device pathname)
233                      :directory (subseq parent-dirs 0 i)))
234             (parent-name (native-translated-namestring parent))
235             (parent-kind (%unix-file-kind parent-name)))
236
237        (if parent-kind
238          (unless (eq parent-kind :directory)
239            (error 'simple-file-error
240                   :error-type "Can't create directory ~s, since file ~a exists and is not a directory"
241                   :pathname pathname
242                   :format-arguments (list parent-name)))
243          (let* ((result (%mkdir parent-name mode)))
244            (declare (fixnum result))
245            (if (< result 0)
246              (signal-file-error result parent-name)
247              (setq created-p t))))))))
248
249
250(defun ensure-directories-exist (pathspec &key verbose (mode #o777))
251  "Test whether the directories containing the specified file
252  actually exist, and attempt to create them if they do not.
253  The MODE argument is an extension to control the Unix permission
254  bits.  Portable programs should avoid using the :MODE keyword
255  argument."
256  (let ((pathname (let ((pathspec (translate-logical-pathname (merge-pathnames pathspec))))
257                    (make-directory-pathname :device (pathname-device pathspec)
258                                             :directory (pathname-directory pathspec))))
259        (created-p nil))
260    (when (wild-pathname-p pathname)
261      (error 'file-error
262             :error-type "Inappropriate use of wild pathname ~s"
263             :pathname pathname))
264    (let ((dir (pathname-directory pathname)))
265      (if (eq (car dir) :relative)
266        (setq dir (pathname-directory (merge-pathnames
267                                       pathname
268                                       (mac-default-directory)))))
269      (loop for i from 1 upto (length dir)
270            do (let ((newpath (make-pathname
271                               :name :unspecific
272                               :type :unspecific
273                               :host (pathname-host pathname)
274                               :device (pathname-device pathname)
275                               :directory (subseq dir 0 i))))
276                 (unless (probe-file newpath)
277                   (let ((namestring (native-translated-namestring newpath)))
278                     (when verbose
279                       (format *standard-output* "~&Creating directory: ~A~%"
280                               namestring))
281                     (%mkdir namestring mode)
282                     (unless (probe-file newpath)
283                       (error 'file-error
284                              :pathname namestring
285                              :error-type "Can't create directory ~S."))
286                     (setf created-p t)))))
287      (values pathspec created-p))))
288
289(defun dirpath-to-filepath (path)
290  (setq path (translate-logical-pathname (merge-pathnames path)))
291  (let* ((dir (pathname-directory path))
292         (super (butlast dir))
293         (name (car (last dir))))
294    (when (eq name :up)
295      (setq dir (remove-up (copy-list dir)))
296      (setq super (butlast dir))
297      (setq name (car (last dir))))
298    (when (null super)
299      (signal-file-error $xnocreate path))
300    (setq path (make-pathname :directory super :name name :defaults nil))))
301
302(defun filepath-to-dirpath (path)
303  (let* ((dir (pathname-directory path))
304         (rest (file-namestring path)))
305    (make-pathname :directory (append dir (list rest)) :defaults nil)))
306 
307
308
309;Takes a pathname, returns the truename of the directory if the pathname
310;names a directory, NIL if it names an ordinary file, error otherwise.
311;E.g. (directoryp "ccl;:foo:baz") might return #P"hd:mumble:foo:baz:" if baz
312;is a dir. - should we doc this - its exported?
313(defun directoryp (path)
314  (let* ((native (native-translated-namestring path))
315         (realpath (%realpath native)))
316    (if realpath (eq (%unix-file-kind realpath) :directory))))
317         
318
319;-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
320;Wildcards
321
322
323
324 
325;-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
326;Directory Traversing
327
328(defun %path-cat (device dir subdir)
329  (if device
330      (%str-cat device ":" dir subdir)
331    (%str-cat dir subdir)))
332
333(defmacro with-open-dir ((dirent device dir) &body body)
334  `(let ((,dirent (%open-dir (native-translated-namestring (make-pathname :device ,device :directory ,dir :defaults nil)))))
335     (when ,dirent
336       (unwind-protect
337           (progn ,@body)
338         (close-dir ,dirent)))))
339
340(defun path-is-link (path)
341  "Returns T if PATH is a (hard or symbolic) link, NIL otherwise."
342  (eq (%unix-file-kind (native-translated-namestring path) t) :link))
343
344
345(defun %add-directory-result (path result follow-links)
346  (let* ((resolved (and follow-links (path-is-link path) (probe-file path))))
347    (if resolved
348      (push (namestring resolved) (cdr result)) ; may introduce duplicates.
349      (push (namestring path) (car result)))
350    path))
351
352(defun %make-directory-result ()
353  (cons nil nil))
354
355(defun %process-directory-result (result)
356  (dolist (resolved (cdr result) (mapcar #'parse-namestring (sort (car result)  #'string<)))
357    (pushnew resolved (car result) :test #'string=)))
358
359 
360(defun directory (path &key (directories nil) ;; include subdirectories
361                            (files t)         ;; include files
362                            (all t)           ;; include Unix dot files (other than dot and dot dot)
363                            (directory-pathnames t) ;; return directories as directory-pathname-p's.
364                            (include-emacs-lockfiles nil) ;; inculde .#foo
365                            test              ;; Only return pathnames matching test
366                            (follow-links t)) ;; return truename's of matching files.
367  "Return a list of PATHNAMEs, each the TRUENAME of a file that matched the
368   given pathname. Note that the interaction between this ANSI-specified
369   TRUENAMEing and the semantics of the Unix filesystem (symbolic links..)
370   means this function can sometimes return files which don't have the same
371   directory as PATHNAME."
372  (let* ((keys (list :directories directories ;list defaulted key values
373                     :files files
374                     :all all
375                     :directory-pathnames directory-pathnames
376                     :test test
377                     :include-emacs-lockfiles include-emacs-lockfiles
378                     :follow-links follow-links))
379         (path (full-pathname (merge-pathnames path) :no-error nil))
380         (dir (directory-namestring path)))
381    (declare (dynamic-extent keys))
382    (if (null (pathname-directory path))
383      (setq dir (directory-namestring (setq path
384                                            (merge-pathnames path
385                                                             (mac-default-directory))))))
386    (assert (eq (car (pathname-directory path)) :absolute) ()
387            "full-pathname returned relative path ~s??" path)
388    (%process-directory-result (%directory "/" dir path '(:absolute) keys (%make-directory-result)))))
389
390(defun %directory (dir rest path so-far keys result)
391  (multiple-value-bind (sub-dir wild rest) (%split-dir rest)
392    (%some-specific dir sub-dir wild rest path so-far keys result)))
393
394(defun %some-specific (dir sub-dir wild rest path so-far keys result)
395  (let* ((start 1)
396         (end (length sub-dir))
397         (full-dir (if (eq start end) dir (%str-cat dir (%substr sub-dir start end)))))
398    (while (neq start end)
399      (let ((pos (position #\/ sub-dir :start start :end end)))
400        (push (%path-std-quotes (%substr sub-dir start pos) nil "/:;*") so-far)
401        (setq start (%i+ 1 pos))))
402    (cond ((null wild)
403           (%files-in-directory full-dir path so-far keys result))
404          ((string= wild "**")
405           (%all-directories full-dir rest path so-far keys result))
406          (t (%one-wild full-dir wild rest path so-far keys result)))))
407
408; for a * or *x*y
409(defun %one-wild (dir wild rest path so-far keys result)
410  (let ((device (pathname-device path))
411        (all (getf keys :all))
412        name)
413    (with-open-dir (dirent device dir)
414      (while (setq name (%read-dir dirent))
415        (when (and (or all (neq (%schar name 0) #\.))
416                   (not (string= name "."))
417                   (not (string= name ".."))
418                   (%path-pstr*= wild name)
419                   (eq (%unix-file-kind (%path-cat device dir name) t) :directory))
420          (let ((subdir (%path-cat nil dir name))
421                (so-far (cons (%path-std-quotes name nil "/;:*") so-far)))
422            (declare (dynamic-extent so-far))
423            (%directory (%str-cat subdir "/") rest path so-far keys result)
424))))
425    result))
426
427(defun %files-in-directory (dir path so-far keys result)
428  (let ((device (pathname-device path))
429        (name (pathname-name path))
430        (type (pathname-type path))
431        (directories (getf keys :directories))
432        (files (getf keys :files))
433        (directory-pathnames (getf keys :directory-pathnames))
434        (test (getf keys :test))
435        (follow-links (getf keys :follow-links))
436        (all (getf keys :all))
437        (include-emacs-lockfiles (getf keys :include-emacs-lockfiles))
438        sub dir-list ans)
439    (if (not (or name type))
440      (let (full-path)
441        (when (and directories
442                   (eq (%unix-file-kind (namestring (setq full-path (%cons-pathname (reverse so-far) nil nil nil device)))
443                                        t)
444                       :directory))
445          (setq ans (if directory-pathnames full-path
446                      (%cons-pathname (reverse (cdr so-far)) (car so-far) nil nil device)))
447          (when (and ans (or (null test) (funcall test ans)))
448            (%add-directory-result ans result follow-links))))
449      (with-open-dir (dirent (pathname-device path) dir)
450        (while (setq sub (%read-dir dirent))
451          (when (and (or all (neq (%schar sub 0) #\.))
452                     (or include-emacs-lockfiles
453                         (< (length sub) 2)
454                         (not (string= sub ".#" :end1 2)))
455                     (not (string= sub "."))
456                     (not (string= sub ".."))
457                     (%file*= name type sub))
458            (setq ans
459                  (if (eq (%unix-file-kind (%path-cat device dir sub) t) :directory)
460                    (when directories
461                      (let* ((std-sub (%path-std-quotes sub nil "/;:*")))
462                        (if directory-pathnames
463                          (%cons-pathname (reverse (cons std-sub so-far)) nil nil nil device)
464                          (%cons-pathname (or dir-list (setq dir-list (reverse so-far))) std-sub nil nil device))))
465                    (when files
466                      (multiple-value-bind (name type) (%std-name-and-type sub)
467                        (%cons-pathname (or dir-list (setq dir-list (reverse so-far))) name type nil device)))))
468            (when (and ans (or (null test) (funcall test ans)))
469              (%add-directory-result ans result follow-links))))))
470    result))
471
472(defun %all-directories (dir rest path so-far keys result)
473  (let ((do-files nil)
474        (do-dirs nil)
475        (device (pathname-device path))
476        (name (pathname-name path))
477        (type (pathname-type path))
478        (all (getf keys :all))
479        (test (getf keys :test))
480        (directory-pathnames (getf keys :directory-pathnames))
481        (follow-links (getf keys :follow-links))
482        sub dir-list ans)
483    ;; First process the case that the ** stands for 0 components
484    (multiple-value-bind (next-dir next-wild next-rest) (%split-dir rest)
485      (while (and next-wild ; Check for **/**/ which is the same as **/
486                  (string= next-dir "/")
487                  (string= next-wild "**"))
488        (setq rest next-rest)
489        (multiple-value-setq (next-dir next-wild next-rest) (%split-dir rest)))
490      (cond ((not (string= next-dir "/"))
491             (%some-specific dir next-dir next-wild next-rest path so-far keys result))
492            (next-wild
493             (%one-wild dir next-wild next-rest path so-far keys result))
494            ((or name type)
495             (when (getf keys :files) (setq do-files t))
496             (when (getf keys :directories) (setq do-dirs t)))
497            (t (when (getf keys :directories)
498                 (setq sub (if directory-pathnames
499                             (%cons-pathname (setq dir-list (reverse so-far)) nil nil nil device)
500                             (%cons-pathname (reverse (cdr so-far)) (car so-far) nil nil device)))
501                 (when (or (null test) (funcall test sub))
502                   (%add-directory-result sub result follow-links))))))
503    ;; now descend doing %all-dirs on dirs and collecting files & dirs
504    ;; if do-x is t
505    (with-open-dir (dirent device (%path-std-quotes dir nil "*;:"))
506      (while (setq sub (%read-dir dirent))
507        (when (and (or all (neq (%schar sub 0) #\.))
508                   (not (string= sub "."))
509                   (not (string= sub "..")))
510          (if (eq (%unix-file-kind (%path-cat device dir sub) t) :directory)
511            (let* ((subfile (%path-cat nil dir sub))
512                   (std-sub (%path-std-quotes sub nil "/;:*"))
513                   (so-far (cons std-sub so-far))
514                   (subdir (%str-cat subfile  "/")))
515              (declare (dynamic-extent so-far))
516              (when (and do-dirs (%file*= name type sub))
517                (setq ans (if directory-pathnames
518                            (%cons-pathname (reverse so-far) nil nil nil device)
519                            (%cons-pathname (or dir-list (setq dir-list (reverse (cdr so-far))))
520                                            std-sub nil nil device)))
521                (when (or (null test) (funcall test ans))
522                  (%add-directory-result ans result follow-links)))
523              (%all-directories subdir rest path so-far keys result))
524            (when (and do-files (%file*= name type sub))
525              (multiple-value-bind (name type) (%std-name-and-type sub)
526                (setq ans (%cons-pathname (or dir-list (setq dir-list (reverse so-far))) name type nil device))
527                (when (or (null test) (funcall test ans))
528                  (%add-directory-result ans result follow-links))))))))
529    result))
530
531(defun %split-dir (dir &aux pos)                 ; dir ends in a "/".
532  ;"/foo/bar/../x*y/baz/../z*t/"  ->  "/foo/bar/../" "x*y" "/baz/../z*t/"
533  (if (null (setq pos (%path-mem "*" dir)))
534    (values dir nil nil)
535    (let (epos (len (length dir)))
536      (setq pos (if (setq pos (%path-mem-last "/" dir 0 pos)) (%i+ pos 1) 0)
537            epos (%path-mem "/" dir pos len))
538      (when (%path-mem-last-quoted "/" dir 0 pos)
539        (signal-file-error $xbadfilenamechar dir #\/))
540      (values (unless (%izerop pos) (namestring-unquote (%substr dir 0 pos)))
541              (%substr dir pos epos)
542              (%substr dir epos len)))))
543
544(defun %path-pstr*= (pattern pstr &optional (p-start 0))
545  (assert (eq p-start 0))
546  (%path-str*= pstr pattern))
547
548(defun %file*= (name-pat type-pat pstr)
549  (if (eq name-pat :wild) (setq name-pat "*"))
550  (if (eq type-pat :wild) (setq type-pat "*"))
551  (when (and (null name-pat) (null type-pat))
552    (return-from %file*= T))
553  (let* ((end (length pstr))
554         (pos (position #\. pstr :from-end t))
555         (type (and pos (%substr pstr (%i+ pos 1) end)))
556         (name (unless (eq (or pos end) 0) (if pos (%substr pstr 0 pos) pstr))))
557    (and (cond ((or (eq name-pat :unspecific) (null name-pat)) (null name))
558               (t (%path-pstr*= name-pat (or name ""))))
559         (cond ((or (null type-pat) (eq type-pat :unspecific)) (null type))
560               (t (%path-pstr*= type-pat (or type "")))))))
561
562(provide "PATHNAMES")
Note: See TracBrowser for help on using the repository browser.