anchor.diff:                          defaults)
     (if defaults
         (setf defaults (pathname defaults))
  -      (setf defaults (make-instance 'pathname :host (pathname-host *default-pathname-defaults*))))
  -  (make-instance 'pathname
  +      (setf defaults (make-instance (host-pathname-class (pathname-host *default-pathname-defaults*))
  +                                    :host (pathname-host *default-pathname-defaults*))))
  +  (make-instance (host-pathname-class (if host (find-host host) (pathname-host defaults)))
                    :host (if host (find-host host) (pathname-host defaults))
                    :device (if devicep device (pathname-device defaults))
                    :directory (if directoryp directory (pathname-directory defaults))
  
positive.code:   (check-type direction (member :input :output :io :probe))
    (check-type if-exists (member :error :new-version :rename :rename-and-delete :overwrite :append :supersede nil))
    (check-type if-does-not-exist (member :error :create nil))
    (let* ((path (merge-pathnames filespec))
           (host (pathname-host path)))
      (when (wild-pathname-p path)
        (error 'simple-file-error
  
negative.code: (defgeneric directory-using-host (host path &key))
  
  (defun directory (pathspec &rest args &key &allow-other-keys)
    (let ((path (translate-logical-pathname (merge-pathnames pathspec))))
      (apply #'directory-using-host (pathname-host path) path args)))
  
  (defun case-correct-path-component (component from-host to-host)
    (cond ((and (typep from-host 'logical-host)
                (not (typep to-host 'logical-host))
                (stringp component))
           (string-downcase component))
          ((and (not (typep from-host 'logical-host))
                (typep to-host 'logical-host)
                (stringp component))
           (string-upcase component))
          (t component)))
  
  (defun translate-one (source from to what)
    (cond ((member (funcall what to) '(nil :wild))
           (case-correct-path-component (funcall what source)
                                        (pathname-host from)
                                        (pathname-host to)))
          ((or (eql (funcall what source) (funcall what from))
               (eql (funcall what from) :wild))
           (case-correct-path-component (funcall what source)
                                        (pathname-host from)
                                        (pathname-host to)))
          (t (error "Source and from ~S don't match." what))))
  
  (defun translate-directory (source from-wildcard to-wildcard)
  