anchor.diff:  ;;; of STANDARD-CLASS.
   
   (defclass standard-object (t)
  -  #.*direct-slots-standard-object*)
  +  #.(find-direct-slots 'standard-object))
   
   (defclass metaobject (standard-object)
  -  #.*direct-slots-metaobject*)
  +  #.(find-direct-slots 'metaobject))
   
   (defclass method (metaobject)
  -  #.*direct-slots-method*)
  +  #.(find-direct-slots 'method))
   
   (defclass standard-method (method)
  -  #.*direct-slots-standard-method*)
  +  #.(find-direct-slots 'standard-method))
   
   (defclass standard-accessor-method (standard-method)
  -  #.*direct-slots-standard-accessor-method*)
  +  #.(find-direct-slots 'standard-accessor-method))
   
   (defclass standard-reader-method (standard-accessor-method)
  -  #.*direct-slots-standard-reader-method*)
  +  #.(find-direct-slots 'standard-reader-method))
   
   (defclass standard-writer-method (standard-accessor-method)
  -  #.*direct-slots-standard-writer-method*)
  +  #.(find-direct-slots 'standard-writer-method))
   
   (defclass method-combination (metaobject)
  -  #.*direct-slots-method-combination*)
  +  #.(find-direct-slots 'method-combination))
   
   (defclass slot-definition (metaobject)
  -  #.*direct-slots-slot-definition*)
  +  #.(find-direct-slots 'slot-definition))
   
   (defclass direct-slot-definition (slot-definition)
  -  #.*direct-slots-direct-slot-definition*)
  +  #.(find-direct-slots 'direct-slot-definition))
   
   (defclass effective-slot-definition (slot-definition)
  -  #.*direct-slots-effective-slot-definition*)
  +  #.(find-direct-slots 'effective-slot-definition))
   
   (defclass standard-slot-definition (slot-definition)
  -  #.*direct-slots-standard-slot-definition*)
  +  #.(find-direct-slots 'standard-slot-definition))
   
   ;;; We can not use DEFCLASS to create the class named
   ;;; STANDARD-DIRECT-SLOT-DEFINITION, because we already created it in
  
positive.code: 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; The contents of this file should be read sequentially, because the
  ;;; bootstrapping issues make it necessary to create functionality
  ;;; step by step.  FIXME: elaborate...
  
  (defun class-name (class)
    (slot-value-using-slots
     class
     '%name
     *effective-slots-standard-class*))
  
  (defun (setf class-name) (new-value class)
    (setf (slot-value-using-slots
  	 class
  	 '%name
  	 *effective-slots-standard-class*)
  	new-value))
  
  (defun class-direct-superclasses (class)
    ;; FIXME: can this be done better?
    (if (eq class (find-class t))
        '()
        (slot-value-using-slots
         class
         '%direct-superclasses
         *effective-slots-standard-class*)))
  
  (defun (setf class-direct-superclasses)  (new-value class)
    (setf (slot-value-using-slots
  	 class
  	 '%direct-superclasses
  	 *effective-slots-standard-class*)
  	new-value))
  
  (defun class-direct-slots (class)
    (slot-value-using-slots
     class
     '%direct-slots
     *effective-slots-standard-class*))
  
  (defun (setf class-direct-slots) (new-value class)
    (setf (slot-value-using-slots
  	 class
  	 '%direct-slots
  	 *effective-slots-standard-class*)
  	new-value))
  
  (defun class-precedence-list (class)
    (slot-value-using-slots
     class
     '%precedence-list
     *effective-slots-standard-class*))
  
  (defun (setf class-precedence-list) (new-value class)
    (setf (slot-value-using-slots
  	 class
  	 '%precedence-list
  	 *effective-slots-standard-class*)
  	new-value))
  
  ;;; For some reason, this accessor is not called class-effective-slots.
  (defun class-slots (class)
    (slot-value-using-slots
     class
     '%effective-slots
     *effective-slots-standard-class*))
  
  (defun (setf class-slots) (new-value class)
    (setf (slot-value-using-slots
  	 class
  	 '%effective-slots
  	 *effective-slots-standard-class*)
  	new-value))
  
  (defun class-direct-subclasses (class)
    (slot-value-using-slots
     class
     '%direct-subclasses
     *effective-slots-standard-class*))
  
  (defun (setf class-direct-subclasses) (new-value class)
    (setf (slot-value-using-slots
  	 class
  	 '%direct-subclasses
  	 *effective-slots-standard-class*)
  	new-value))
  
  (defun class-direct-methods (class)
    (slot-value-using-slots
     class
     '%direct-methods
     *effective-slots-standard-class*))
  
  (defun (setf class-direct-methods) (new-value class)
    (setf (slot-value-using-slots
  	 class
  	 '%direct-methods
  	 *effective-slots-standard-class*)
  	new-value))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Functions find-class and (setf find-class)
  ;;;
  ;;; For now, ignore the environment parameter to FIND-CLASS, and just
  ;;; use a global variable to hold a hash table with class definitions.
  
negative.code:   (when (symbolp class)
      (setf class (find-class class)))
    (if (eq class *class-standard-class*)
        (let* ((defs (find-effective-slots 'standard-class))
  	     (slot-storage (allocate-slot-storage (length defs)
  						  *secret-unbound-value*))
  	     (instance (allocate-standard-instance *class-standard-class*
  