anchor.diff:          (symbol-call :asdf :load-system :asdf :verbose nil))))
   
     (register-hook-function '*post-upgrade-cleanup-hook* 'upgrade-configuration))
  -
  -;;;; -------------------------------------------------------------------------
  -;;;; Stamp cache
  -
  -(uiop/package:define-package :asdf/cache
  -  (:use :uiop/common-lisp :uiop :asdf/upgrade)
  -  (:export #:get-file-stamp #:compute-file-stamp #:register-file-stamp
  -           #:set-asdf-cache-entry #:unset-asdf-cache-entry #:consult-asdf-cache
  -           #:do-asdf-cache #:normalize-namestring
  -           #:call-with-asdf-cache #:with-asdf-cache #:*asdf-cache*
  -           #:clear-configuration-and-retry #:retry))
  -(in-package :asdf/cache)
  -
  -;;; This stamp cache is useful for:
  -;; * consistency of stamps used within a single run
  -;; * fewer accesses to the filesystem
  -;; * the ability to test with fake timestamps, without touching files
  -
  -(with-upgradability ()
  -  (defvar *asdf-cache* nil)
  -
  -  (defun set-asdf-cache-entry (key value-list)
  -    (apply 'values
  -           (if *asdf-cache*
  -               (setf (gethash key *asdf-cache*) value-list)
  -               value-list)))
  -
  -  (defun unset-asdf-cache-entry (key)
  -    (when *asdf-cache*
  -      (remhash key *asdf-cache*)))
  -
  -  (defun consult-asdf-cache (key &optional thunk)
  -    (if *asdf-cache*
  -        (multiple-value-bind (results foundp) (gethash key *asdf-cache*)
  -          (if foundp
  -              (apply 'values results)
  -              (set-asdf-cache-entry key (multiple-value-list (call-function thunk)))))
  -        (call-function thunk)))
  -
  -  (defmacro do-asdf-cache (key &body body)
  -    `(consult-asdf-cache ,key #'(lambda () ,@body)))
  -
  -  (defun call-with-asdf-cache (thunk &key override key)
  -    (let ((fun (if key #'(lambda () (consult-asdf-cache key thunk)) thunk)))
  -      (if (and *asdf-cache* (not override))
  -          (funcall fun)
  -          (loop
  -            (restart-case
  -                (let ((*asdf-cache* (make-hash-table :test 'equal)))
  -                  (return (funcall fun)))
  -              (retry ()
  -                :report (lambda (s)
  -                          (format s (compatfmt "~@<Retry ASDF operation.~@:>"))))
  -              (clear-configuration-and-retry ()
  -                :report (lambda (s)
  -                          (format s (compatfmt "~@<Retry ASDF operation after resetting the configuration.~@:>")))
  -                (clear-configuration)))))))
  -
  -  (defmacro with-asdf-cache ((&key key override) &body body)
  -    `(call-with-asdf-cache #'(lambda () ,@body) :override ,override :key ,key))
  -
  -  (defun normalize-namestring (pathname)
  -    (let ((resolved (resolve-symlinks*
  -                     (ensure-absolute-pathname
  -                      (physicalize-pathname pathname)
  -                      'get-pathname-defaults))))
  -      (with-pathname-defaults () (namestring resolved))))
  -
  -  (defun compute-file-stamp (normalized-namestring)
  -    (with-pathname-defaults ()
  -      (safe-file-write-date normalized-namestring)))
  -
  -  (defun register-file-stamp (file &optional (stamp nil stampp))
  -    (let* ((namestring (normalize-namestring file))
  -           (stamp (if stampp stamp (compute-file-stamp namestring))))
  -      (set-asdf-cache-entry `(get-file-stamp ,namestring) (list stamp))))
  -
  -  (defun get-file-stamp (file)
  -    (when file
  -      (let ((namestring (normalize-namestring file)))
  -        (do-asdf-cache `(get-file-stamp ,namestring) (compute-file-stamp namestring))))))
   
   ;;;; -------------------------------------------------------------------------
   ;;;; Components
  
positive.code:    #:find-system-if-being-defined
     #:contrib-sysdef-search #:sysdef-find-asdf ;; backward compatibility symbols, functions removed
     #:sysdef-preloaded-system-search #:register-preloaded-system #:*preloaded-systems*
     #:*defined-systems* #:clear-defined-systems #:*immutable-systems* #:register-immutable-system
     ;; defined in source-registry, but specially mentioned here:
     #:initialize-source-registry #:sysdef-source-registry-search))
  (in-package :asdf/find-system)
  
negative.code:     (:documentation "Abstract operation for linking files together"))
  
    (defclass gather-op (bundle-op)
      ((gather-op :initform nil :allocation :class :reader gather-op)
       (gather-type :initform :no-output-file :allocation :class :reader gather-type))
      (:documentation "Abstract operation for gathering many input files from a system"))
  
    (defun operation-monolithic-p (op)
  