anchor.diff:      (if slotd
   	(slot-value slotd slot)
         default)))
  -  
  -
  -(defgeneric compute-virtual-slot-location (class slotd direct-slotds))
  -
  -(defmethod compute-virtual-slot-location
  -    ((class virtual-class)
  + 
  +(defgeneric compute-virtual-slot-accessors (class slotd direct-slotds))
  +
  +(defmethod compute-virtual-slot-accessors
  +    ((class virtual-slot-class)
        (slotd effective-virtual-slot-definition)
        direct-slotds)
  -    (let ((location
  -	   (%direct-slot-definitions-slot-value direct-slotds 'location)))
  -      (if (and location (symbolp location))
  -	  (list location `(setf ,location))
  -	location)))
  -
  +    (let ((getter (%most-specific-slot-value direct-slotds 'getter))
  +	  (setter (%most-specific-slot-value direct-slotds 'setter)))
  +      (list getter setter)))
   
   (defmethod compute-effective-slot-definition
  -    ((class virtual-class) direct-slotds)
  +    ((class virtual-slot-class) direct-slotds)
     (let ((slotd (call-next-method)))
       (when (typep slotd 'effective-virtual-slot-definition)
         (setf
          (slot-value slotd 'pcl::location)
  -       (compute-virtual-slot-location class slotd direct-slotds)))
  +       (compute-virtual-slot-accessors class slotd direct-slotds)))
       slotd))
   
  -
   (defmethod slot-value-using-class
  -    ((class virtual-class) (object standard-object)
  +    ((class virtual-slot-class) (object standard-object)
        (slotd effective-virtual-slot-definition))
     (let ((reader (first (slot-definition-location slotd))))
       (if reader
   	(funcall reader object)
         (slot-unbound class object (slot-definition-name slotd)))))
   
  -
   (defmethod slot-boundp-using-class
  -    ((class virtual-class) (object standard-object)
  +    ((class virtual-slot-class) (object standard-object)
        (slotd effective-virtual-slot-definition))
      (and (first (slot-definition-location slotd)) t))
       
  -
  -
   (defmethod (setf slot-value-using-class)
  -    (value (class virtual-class) (object standard-object)
  +    (value (class virtual-slot-class) (object standard-object)
        (slotd effective-virtual-slot-definition))
  -  (let ((writer (second (slot-definition-location slotd))))
  +  (let ((setter (second (slot-definition-location slotd))))
       (cond
  -     ((null writer)
  +     ((null setter)
         (error
          "Can't set read-only slot ~A in ~A"
          (slot-definition-name slotd)
          object))
  -     ((or (functionp writer) (symbolp writer))
  -      (funcall writer value object)
  +     ((or (functionp setter) (symbolp setter))
  +      (funcall setter value object)
         value)
        (t
  -      (funcall (fdefinition writer) value object)
  +      (funcall (fdefinition setter) value object)
         value))))
   	
  -
   (defmethod validate-superclass
  -    ((class virtual-class) (super pcl::standard-class))
  +    ((class virtual-slot-class) (super pcl::standard-class))
     t)
   
   
  
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: 	     (let ((location (proxy-location object)))
  	       (funcall destroy location offset)
  	       (funcall writer value location offset)))))))
   
    (defmethod compute-virtual-slot-accessors
        ((class proxy-class)
         (slotd effective-virtual-alien-slot-definition)
         direct-slotds)
      (destructuring-bind (getter setter) (call-next-method)
        (let ((class-name (class-name class)))
  	(with-slots (type) slotd
  	  (list
  	   (if (stringp getter)
  	       (mkbinding getter type class-name)
  	     getter)
  	   (if (stringp setter)
  	       (let ((setter (mkbinding setter 'nil class-name type)))
  		 #'(lambda (value object)
  		     (funcall setter object value)))
  	     setter))))))
  
    (defmethod compute-slots ((class proxy-class))
      (with-slots (direct-slots size) class
        (let ((current-offset
  	     (proxy-class-size (most-specific-proxy-superclass class)))
  	    (max-size 0))
  	(dolist (slotd direct-slots)
  	  (when (eq (slot-definition-allocation slotd) :alien)
  	    (with-slots (offset type) slotd
  	      (unless (slot-boundp slotd 'offset)
  		(setf offset current-offset))
  	      (setq current-offset (+ offset (size-of type)))
  	      (setq max-size (max max-size current-offset)))))
  	(unless (slot-boundp class 'size)
  	  (setf size max-size))))
      (call-next-method))
     
    (defmethod validate-superclass ((class proxy-class)
  				  (super pcl::standard-class))
      (subtypep (class-name super) 'proxy))
    
    (defmethod proxy-class-size (class)
      (declare (ignore class))
      0)
  
    (defgeneric make-proxy-instance (class location weak-ref
  				   &rest initargs &key)))
  
  (defmethod make-proxy-instance ((class symbol) location weak-ref
  				&rest initargs &key)
  