anchor.diff:                                     :default-directory)
                             :directory t :wilden nil))
               ((eql :user-cache) (resolve-location *user-cache* :directory t :wilden nil))
  -            ((eql :system-cache) (resolve-location *system-cache* :directory t :wilden nil))
  +            ((eql :system-cache)
  +             (error "Using the :system-cache is deprecated. ~%~
  +Please remove it from your ASDF configuration"))
               ((eql :default-directory) (default-directory))))
            (s (if (and wilden (not (pathnamep x)))
                   (wilden r)
                   r)))
       (unless (absolute-pathname-p s)
  -      (error (compatfmt "~@<Not an absolute pathname: ~3i~_~S~@:>") s))
  +      (error (compatfmt "~@<Invalid designator for an absolute pathname: ~3i~_~S~@:>") x))
       s))
   
   (defun* resolve-location (x &key directory wilden)
  
positive.code:                              (find-symbol* type *package*)
                               (find-symbol* type :asdf))
          :for class = (and symbol (find-class symbol nil))
          :when (and class (subtypep class 'component))
          :return class)
        (and (eq type :file)
             (or (module-default-component-class parent)
                 (find-class *default-component-class*)))
        (sysdef-error "don't recognize component type ~A" type)))
  
  (defun* maybe-add-tree (tree op1 op2 c)
  
negative.code:                           (values (or null pathname) &optional))
                  resolve-location))
  
  (defun* resolve-relative-location-component (x &key directory wilden)
    (let ((r (etypecase x
               (pathname x)
               (string (coerce-pathname x :type (when directory :directory)))
               (cons
                (if (null (cdr x))
                    (resolve-relative-location-component
                     (car x) :directory directory :wilden wilden)
                    (let* ((car (resolve-relative-location-component
                                 (car x) :directory t :wilden nil)))
                      (merge-pathnames*
                       (resolve-relative-location-component
                        (cdr x) :directory directory :wilden wilden)
                       car))))
               ((eql :default-directory)
                (relativize-pathname-directory (default-directory)))
               ((eql :*/) *wild-directory*)
               ((eql :**/) *wild-inferiors*)
               ((eql :*.*.*) *wild-file*)
               ((eql :implementation)
                (coerce-pathname (implementation-identifier) :type :directory))
               ((eql :implementation-type)
                (coerce-pathname (string-downcase (implementation-type)) :type :directory))
               ((eql :hostname)
                (coerce-pathname (hostname) :type :directory)))))
      (when (absolute-pathname-p r)
        (error (compatfmt "~@<pathname ~S is not relative~@:>") x))
      (if (or (pathnamep x) (not wilden)) r (wilden r))))
  
  (defvar *here-directory* nil
    "This special variable is bound to the currect directory during calls to
  