anchor.diff:        (let ((slot (find slot-name
                           (class-slots class)
                           :key #'slot-definition-name)))
  -        (if (null slot)
  -            (error "The slot ~S is missing from the class ~S."
  -                   slot-name class)
  -            (let ((pos (position slot
  -                                 (remove-if-not #'instance-slot-p
  -                                                (class-slots class)))))
  -               (if (null pos)
  -                   (error "The slot ~S is not an instance~@
  +        (when (null slot)
  +          (error "The slot ~S is missing from the class ~S."
  +                 slot-name class))
  +        (case (slot-definition-allocation slot)
  +          (:instance
  +           (position slot (remove-if-not #'instance-slot-p
  +                                         (class-slots class))))
  +          (:class
  +           (slot-definition-location slot))
  +          (t
  +           (error "The slot ~S is not an instance or class~@
                              slot in the class ~S."
  -                          slot-name class)
  -                   pos))))))
  +                          slot-name class))))))
   
   (defun slot-contents (slots location)
  -  (svref slots location))
  +  (if (consp location)
  +      (cdr location)
  +      (svref slots location)))
   
   (defun (setf slot-contents) (new-value slots location)
  -  (setf (svref slots location) new-value))
  +  (if (consp location)
  +      (setf (cdr location) new-value)
  +      (setf (svref slots location) new-value)))
   
   (defun fast-sv-position (value simple-vector)
     (dotimes (i (array-dimension simple-vector 0))
  
positive.code:     (setf (getf* slot ':readers) readers)
      (setf (getf* slot ':writers) writers)
      (setf (getf* slot ':allocation) allocation)
      (make-standard-slot-definition :properties slot)))
  
  (defun make-effective-slot-definition
  
negative.code:       :initargs (remove-duplicates
                    (mapappend #'slot-definition-initargs
                               direct-slots))
        :allocation (slot-definition-allocation (car direct-slots))
        :location (if (eql (slot-definition-allocation (car direct-slots)) :class)
                      (slot-definition-location (car direct-slots))
                      nil))))
  
  ;;;
  ;;; Generic function metaobjects and standard-generic-function
  