anchor.diff:    (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)
  +    (flet ((write-word (word)
  +             (cond ((mixed-case-p word)
  +                    (write-char #\| namestring)
  +                    (loop
  +                       for ch across word
  +                       do
  +                         (when (member ch '(#\\ #\|))
  +                           (write-char #\\ namestring))
  +                         (write-char ch namestring))
  +                    (write-char #\| namestring))
  +                   (t
  +                    (write-string word namestring)))))
  +      (dolist (dir (rest (pathname-directory path)))
  +        (cond ((eql dir :wild)
                  (write-string "*" namestring))
  +              ((eql dir :wild-inferiors)
  +               (write-string "**" namestring))
                 (t
  -               (write-string type namestring)))
  -        (when version
  +               (write-word dir)))
  +        (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-word name)))
  +        (when type
             (write-char #\. namestring)
  -          (cond ((eql version :wild)
  +          (cond ((eql type :wild)
                    (write-string "*" namestring))
  -                ((eql version :newest)
  -                 (write-string "NEWEST" namestring))
                   (t
  -                 (write type namestring))))))))
  +                 (write-word type)))
  +          (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)
  
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))
  