anchor.diff:    (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))
  +              (stringp component)
  +              (not (mixed-case-p component)))
            (string-downcase component))
           ((and (not (typep from-host 'logical-host))
                 (typep to-host 'logical-host)
  -              (stringp component))
  +              (stringp component)
  +              (not (mixed-case-p component)))
            (string-upcase component))
           (t component)))
   
  
positive.code:              (let ((chars (make-array 50
                                        :element-type 'character
                                        :fill-pointer 0
                                        :adjustable t)))
                 (loop
                    (when (>= offset (length namestring))
                      (return))
                    (let ((ch (char namestring offset)))
                      (cond ((or (alphanumericp ch)
                                 (eql ch #\-)
                                 (eql ch #\*))
                             (vector-push-extend (char-upcase ch) chars)
                             (incf offset))
                            (t (return)))))
                 (cond ((string= chars "*")
                        :wild)
                       ((string= chars "**")
  
negative.code:          (case-correct-path-component (funcall what source)
                                        (pathname-host from)
                                        (pathname-host to)))
          ((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))))
  
  (defun translate-directory (source from-wildcard to-wildcard)
    (let* ((s-d (pathname-directory source))
  