anchor.diff:           (case-correct-path-component (funcall what source)
                                         (pathname-host from)
                                         (pathname-host to)))
  -        ((or (eql (funcall what source) (funcall what from))
  +        ((and (equal (funcall what source) (funcall what from))
  +              (not (member (funcall what to) '(nil :wild :unspecified))))
  +         (funcall what to))
  +        ((or (equal (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))))
  +        (t
  +         (error "Source and from ~S don't match." what))))
   
   (defun translate-directory (source from-wildcard to-wildcard)
     (let* ((s-d (pathname-directory source))
  
positive.code:   (with-output-to-string (namestring)
      (when (eql (first (pathname-directory path)) :relative)
        (write-char #\; namestring))
      (dolist (dir (rest (pathname-directory path)))
        (cond ((eql dir :wild)
               (write-string "*" namestring))
              ((eql dir :wild-inferiors)
               (write-string "**" namestring))
              (t
               (write-string dir namestring)))
        (write-char #\; namestring))
      (let ((name (pathname-name path))
            (type (pathname-type path))
            (version (pathname-version path)))
        (cond ((eql name :wild)
               (write-string "*" namestring))
              (name
               (write-string name namestring)))
        (when type
          (write-char #\. namestring)
          (cond ((eql type :wild)
                 (write-string "*" namestring))
                (t
                 (write-string type namestring)))
          (when version
            (write-char #\. namestring)
            (cond ((eql version :wild)
                   (write-string "*" namestring))
                  ((eql version :newest)
                   (write-string "NEWEST" namestring))
                  (t
                   (write type namestring))))))))
  
  (defmethod host-default-device ((host logical-host))
    nil)
  
negative.code:   (let ((path (translate-logical-pathname (merge-pathnames pathspec))))
      (apply #'directory-using-host (pathname-host path) path args)))
  
  (defun mixed-case-p (name)
    (not (every (lambda (ch)
                  (or (eql ch #\*)
                      (eql ch #\-)
                      (digit-char-p ch)
                      (upper-case-p ch)))
                name)))
  
  (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)
                (not (mixed-case-p component)))
           (string-downcase component))
          ((and (not (typep from-host 'logical-host))
                (typep to-host 'logical-host)
                (stringp component)
                (not (mixed-case-p component)))
           (string-upcase component))
          (t component)))
  
  