anchor.diff:  
   (defmethod slot-unbound (class (release release) (slot (eql 'provided-systems)))
     (declare (ignore class))
  -  (initialize-system-index (dist release))
  -  (if (slot-boundp release 'provided-systems)
  -      (provided-systems release)
  -      (setf (provided-systems release) nil)))
  +  (setf (slot-value release 'provided-systems)
  +        (mapcar (lambda (system-file)
  +                  (find-system-in-dist (pathname-name system-file)
  +                                       (dist release)))
  +                (system-files release))))
   
   (defmethod slot-unbound (class (dist dist) (slot (eql 'system-index)))
     (declare (ignore class))
  -  (initialize-system-index dist))
  +  (setf (slot-value dist 'system-index)
  +        (make-hash-table :test 'equal)))
  +
  +(defun make-system-from-line (line dist)
  +  (let ((system (make-line-instance line 'system
  +                                    :release
  +                                    :system-file-name
  +                                    :name
  +                                    :required-systems)))
  +    (setf (dist system) dist)
  +    (setf (release system)
  +          (find-release-in-dist (release system) dist))
  +    system))
   
   (defmethod find-system-in-dist (system-name dist)
  -  (values (gethash system-name (system-index dist))))
  +  (let* ((index (system-index dist))
  +         (system (gethash system-name index)))
  +    (or system
  +        (let ((line (cdb-lookup dist system-name "systems.cdb")))
  +          (when line
  +            (setf (gethash system-name index)
  +                  (make-system-from-line line dist)))))))
   
   (defmethod preference ((system system))
     (if (probe-file (preference-file system))
  
positive.code:     (ql-impl-util:delete-directory-tree (base-directory dist))))
  
  
  (defmethod find-release-in-dist (release dist)
    (values (gethash release (release-index dist))))
  
  
  (defparameter *dist-enumeration-functions*
  
negative.code: 
  (defmethod slot-unbound (class (dist dist) (slot (eql 'release-index)))
    (declare (ignore class))
    (setf (slot-value dist 'release-index)
          (make-hash-table :test 'equal)))
  
  
  ;;;
  