(let* ((original (truename file))
(original-namestring (native-namestring original :as-file t))
(new-name (merge-pathnames new-name original))
- (new-namestring (native-namestring new-name :as-file t)))
+ (new-namestring (native-namestring (physicalize-pathname new-name)
+ :as-file t)))
(unless new-namestring
(error 'simple-file-error
:pathname new-name
(defun delete-file (file)
#!+sb-doc
- "Delete the specified FILE."
- (let* ((truename (probe-file file))
- (namestring (when truename
- (native-namestring truename :as-file t))))
+ "Delete the specified FILE.
+
+If FILE is a stream, on Windows the stream is closed immediately. On Unix
+plaforms the stream remains open, allowing IO to continue: the OS resources
+associated with the deleted file remain available till the stream is closed as
+per standard Unix unlink() behaviour."
+ (let* ((pathname (translate-logical-pathname file))
+ (namestring (native-namestring pathname :as-file t)))
+ (truename file) ; for error-checking side-effect
+ #!+win32
(when (streamp file)
- (close file :abort t))
- (unless namestring
- (error 'simple-file-error
- :pathname file
- :format-control "~S doesn't exist."
- :format-arguments (list file)))
+ (close file))
(multiple-value-bind (res err) (sb!unix:unix-unlink namestring)
(unless res
(simple-file-perror "couldn't delete ~A" namestring err))))
(pathname (canonicalize-pathname pathname))
(name (pathname-name pathname))
(type (pathname-type pathname))
- ;; KLUDGE: We want #p"/foo" to match #p"/foo/,
- ;; so cobble up a directory name component from
- ;; name and type -- just take care with "*.*"!
- (dirname (if (and (eq :wild name) (eq :wild type))
- "*"
- (with-output-to-string (s)
- (when name
- (write-string (unparse-physical-piece name) s))
- (when type
- (write-string "." s)
- (write-string (unparse-physical-piece type) s)))))
- (dir (maybe-make-pattern dirname 0 (length dirname)))
(match-name (make-matcher name))
- (match-type (make-matcher type))
- (match-dir (make-matcher dir)))
+ (match-type (make-matcher type)))
(map-matching-directories
(if (or name type)
(lambda (directory)
- (map-matching-files #'record
- directory
- match-name
- match-type
- match-dir))
+ (map-matching-entries #'record
+ directory
+ match-name
+ match-type))
#'record)
pathname)))
(do-pathnames (pathname)
;;; DIRECTORY.
(defun map-directory (function directory &key (files t) (directories t) (errorp t))
#!+sb-doc
- "Call FUNCTION with the pathname for each entry in DIRECTORY as follows: if
-FILES is true (the default), FUNCTION is called for each file in the
-directory; if DIRECTORIES is true (the default), FUNCTION is called for each
-subdirectory. If ERRORP is true (the default) signal an error if DIRECTORY
-does not exist, cannot be read, etc.
+ "Map over entries in DIRECTORY. Keyword arguments specify which entries to
+map over, and how:
+
+ :FILES
+ If true, call FUNCTION with the pathname of each file in DIRECTORY.
+ Defaults to T.
+
+ :DIRECTORIES
+ If true, call FUNCTION with a pathname for each subdirectory of DIRECTORY.
+ If :AS-FILES, the pathname used is a pathname designating the subdirectory
+ as a file in DIRECTORY. Otherwise the pathname used is a directory
+ pathname. Defaults to T.
+
+ :ERRORP
+ If true, signal an error if DIRECTORY does not exist, cannot be read, etc.
+ Defaults to T.
On platforms supporting symbolic links the decision to call FUNCTION with its
pathname depends on the resolution of the link: if it points to a directory,
symbolic link as an immediate child of DIRECTORY.
Experimental: interface subject to change."
+ (declare (pathname-designator directory))
(let* ((fun (%coerce-callable-to-fun function))
+ (as-files (eq :as-files directories))
(physical (physicalize-pathname directory))
;; Not QUERY-FILE-SYSTEM :EXISTENCE, since it doesn't work on Windows
;; network shares.
(flet ((map-it (name dirp)
(funcall fun
(merge-pathnames (parse-native-namestring
- name nil physical :as-directory dirp)
+ name nil physical
+ :as-directory (and dirp (not as-files)))
physical))))
(with-native-directory-iterator (next dirname :errorp errorp)
(loop for name = (next)
;; end of the line
(funcall function subdirectory))
((or (eq :wild next) (typep next 'pattern))
- (lambda (pathname)
- (map-wild function more pathname)))
+ (map-wild function more subdirectory))
((eq :wild-inferiors next)
- (lambda (pathname)
- (map-wild-inferiors function more pathname)))
+ (map-wild-inferiors function more subdirectory))
(t
- (lambda (pathname)
- (let ((this (pathname-directory pathname)))
- (when (equal next (car (last this)))
- (map-matching-directories
- function
- (make-pathname :directory (append this more)
- :defaults pathname)))))))))
+ (let ((this (pathname-directory subdirectory)))
+ (map-matching-directories
+ function
+ (make-pathname :directory (append this more)
+ :defaults subdirectory)))))))
(map-directory
(if (eq :wild this)
#'cont
(lambda (sub)
- (awhen (pattern-matches this (last-directory-piece sub))
- (funcall #'cont it))))
+ (when (pattern-matches this (last-directory-piece sub))
+ (funcall #'cont sub))))
directory
:files nil
:directories t
:directories t
:errorp nil)))
-;;; Part of DIRECTORY: implements iterating over files in a directory, and matching
-;;; them.
-(defun map-matching-files (function directory match-name match-type match-dir)
+;;; Part of DIRECTORY: implements iterating over entries in a directory, and
+;;; matching them.
+(defun map-matching-entries (function directory match-name match-type)
(map-directory
(lambda (file)
- (let ((pname (pathname-name file))
- (ptype (pathname-type file)))
- (when (if (or pname ptype)
- (and (funcall match-name pname) (funcall match-type ptype))
- (funcall match-dir (last-directory-piece file)))
- (funcall function file))))
+ (when (and (funcall match-name (pathname-name file))
+ (funcall match-type (pathname-type file)))
+ (funcall function file)))
directory
:files t
- :directories t
+ :directories :as-files
:errorp nil))
;;; NOTE: There is a fair amount of hair below that is probably not