anchor.diff:  ;;;; Superclass for all metaclasses implementing some sort of virtual slots
   
   (eval-when (:compile-toplevel :load-toplevel :execute)
  -  (defclass virtual-class (pcl::standard-class))
  +  (defclass virtual-slot-class (pcl::standard-class))
   
     (defclass direct-virtual-slot-definition (standard-direct-slot-definition)
  -    ((location
  -      :reader slot-definition-location
  -      :initarg :location)))
  +    ((setter :reader slot-definition-setter :initarg :setter)
  +     (getter :reader slot-definition-getter :initarg :getter)))
     
     (defclass effective-virtual-slot-definition
       (standard-effective-slot-definition)))
     
   
  -(defmethod direct-slot-definition-class ((class virtual-class) initargs)
  +(defmethod direct-slot-definition-class ((class virtual-slot-class) initargs)
     (if (eq (getf initargs :allocation) :virtual)
         (find-class 'direct-virtual-slot-definition)
       (call-next-method)))
   
  -
  -(defmethod effective-slot-definition-class ((class virtual-class) initargs)
  +(defmethod effective-slot-definition-class ((class virtual-slot-class) initargs)
     (if (eq (getf initargs :allocation) :virtual)
         (find-class 'effective-virtual-slot-definition)
       (call-next-method)))
   
  -
  -(defun %direct-slot-definitions-slot-value (slotds slot &optional default)
  +(defun %most-specific-slot-value (slotds slot &optional default)
     (let ((slotd
   	 (find-if
   	  #'(lambda (slotd)
  
positive.code:   (cache-instance instance)
    (ext:finalize instance (instance-finalizer instance)))
  
  
  (defmethod initialize-proxy ((instance proxy)
  			     &rest initargs)
    (declare (ignore initargs))
    (cache-instance instance))
  
  
  (defmethod instance-finalizer ((instance proxy))
    (let ((location (proxy-location instance)))
      #'(lambda ()
  	(remove-cached-instance location))))
  
  
  
negative.code: ;      (:instance (error "Allocation :instance not allowed in class ~A" class))
        (t (call-next-method))))
  
    (defmethod effective-slot-definition-class ((class proxy-class) initargs)
      (case (getf initargs :allocation)
        (:alien (find-class 'effective-alien-slot-definition))
        (:virtual (find-class 'effective-virtual-alien-slot-definition))
        (t (call-next-method))))
    
    (defmethod compute-virtual-slot-accessors
        ((class proxy-class) (slotd effective-alien-slot-definition)
         direct-slotds)
      (with-slots (offset type) slotd
        (let ((reader (intern-reader-function type))
  	    (writer (intern-writer-function type))
  	    (destroy (intern-destroy-function type)))
  	(setf offset (slot-definition-offset (first direct-slotds)))
  	(list
  	 #'(lambda (object)
  	     (funcall reader (proxy-location object) offset))
  