anchor.diff:  
   (defclass standard-effective-slot-definition
       (standard-slot-definition effective-slot-definition)
  -  #.*direct-slots-standard-effective-slot-definition*)
  +  #.(find-direct-slots 'standard-effective-slot-definition))
   
   (defclass specializer (metaobject)
  -  #.*direct-slots-specializer*)
  +  #.(find-direct-slots 'specializer))
   
   (defclass eql-specializer (specializer)
  -  #.*direct-slots-eql-specializer*)
  +  #.(find-direct-slots 'eql-specializer))
   
   (defclass class (specializer)
  -  #.*direct-slots-class*)
  +  #.(find-direct-slots 'class))
   
   (defclass built-in-class (class)
  -  #.*direct-slots-built-in-class*)
  +  #.(find-direct-slots 'built-in-class))
   
   (defclass forward-reference-class (class)
  -  #.*direct-slots-forward-reference-class*)
  +  #.(find-direct-slots 'forward-reference-class))
   
   ;;; We can not use DEFCLASS to create the class named STANDARD-CLASS,
   ;;; because we already created it in order to make it posible to
  
positive.code: 
  ;;; REMEMBER: Change make-direct-slot-definition to use make-instance. +
  ;;; REMEMBER: Patch version information of slot-definition-instances. +
  
  (defun slot-definition-name (slot-definition)
    (slot-value-using-slots
     slot-definition
     '%name
     *effective-slots-standard-direct-slot-definition*))
  
  ;;; REMEMBER: Change slot-defintion-name to be a reader function. +
  
  (defun slot-definition-allocation (slot-definition)
    (slot-value-using-slots
     slot-definition
     '%allocation
     *effective-slots-standard-direct-slot-definition*))
  
  ;;; REMEMBER: Change slot-defintion-allocation to be a reader function. +
  
  (defun slot-definition-type (slot-definition)
    (slot-value-using-slots
     slot-definition
     '%type
     *effective-slots-standard-direct-slot-definition*))
  
  ;;; REMEMBER: Change slot-defintion-type to be a reader function. +
  
  (defun slot-definition-initargs (slot-definition)
    (slot-value-using-slots
     slot-definition
     '%initargs
     *effective-slots-standard-direct-slot-definition*))
  
  ;;; REMEMBER: Change slot-defintion-initargs to be a reader function. +
  
  (defun slot-definition-initform (slot-definition)
    (slot-value-using-slots
     slot-definition
     '%initform
     *effective-slots-standard-direct-slot-definition*))
  
  ;;; REMEMBER: Change slot-defintion-initform to be a reader function. +
  
  (defun slot-definition-initfunction (slot-definition)
    (slot-value-using-slots
     slot-definition
     '%initfunction
     *effective-slots-standard-direct-slot-definition*))
  
  ;;; REMEMBER: Change slot-defintion-initfunction to be a reader function. +
  
  (defun slot-definition-readers (slot-definition)
    (slot-value-using-slots
     slot-definition
     '%readers
     *effective-slots-standard-direct-slot-definition*))
  
  ;;; REMEMBER: Change slot-defintion-readers to be a reader function. +
  
  (defun slot-definition-writers (slot-definition)
    (slot-value-using-slots
     slot-definition
     '%writers
     *effective-slots-standard-direct-slot-definition*))
  
  ;;; REMEMBER: Change slot-defintion-writers to be a reader function. +
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  
negative.code: ;; 		 :datum new-class)
  ;; 	  (setf (gethash name *classes*) new-class))))
  
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Generating temporary accessors for our metaobjects. 
  ;;;
  ;;; We take our slot descriptors and generate really stupid and slow
  ;;; (but very safe) versions of all the readers and accessors that
  ;;; were mentioned in those slot descriptions.  Each reader has the
  ;;; following form:
  ;;;
  ;;;    (defun mumble (x)
  ;;;      (let ((class (standard-instance-class x))
  ;;;            (slots (standard-instance-slots x)))
  ;;;        (cond ((eq class (find-class 'class-1 nil))
  ;;;               (slotcontents slots s-1))
  ;;;              ((eq class (find-class 'class-2 nil))
  ;;;               (slotcontents slots s-2))
  ;;;              ...
  ;;;              (t (error ...)))))
  ;;;
  ;;; where s-i is the index in class-i of the slot that is read.
  ;;;
  ;;; Writers have the analogous structure. 
  ;;;
  ;;; This means that all our accessors are operational even though
  ;;; they are not generic functions of course. 
  (eval-when (:compile-toplevel :load-toplevel)
  
    (defun collect-reader (reader)
      (let ((result '()))
        (maphash (lambda (class-name slot-descriptors)
  		 (loop for s in slot-descriptors
  		       for i from 0
  		       do (when (or (eq (cadr (member :reader s)) reader)
  				    (eq (cadr (member :accessor s)) reader))
  			    (push `(,class-name ,i) result))))
  	       *effective-slots*)
        result))
    
    (defun collect-writer (writer)
      (let ((result '()))
        (maphash (lambda (class-name slot-descriptors)
  		 (loop for s in slot-descriptors
  		       for i from 0
  		       do (when (eq (cadr (member :accessor s)) writer)
  			    (push `(,class-name ,i) result))))
  	       *effective-slots*)
        result))
    
    (let ((readers '())
  	(writers '()))
      ;; Find all :reader and :accessor slot options
      (maphash (lambda (class-name slot-descriptors)
  	       (declare (ignore class-name))
  	       (loop for s in slot-descriptors
  		     do (let (temp)
  			  (setf temp (member :reader s))
  			  (when temp
  			    (pushnew (cadr temp) readers))
  			  (setf temp (member :accessor s))
  			  (when temp
  			    (pushnew (cadr temp) readers)
  			    (pushnew (cadr temp) writers)))))
  	     *effective-slots*)
      ;; For each one, create a function
      (flet ((make-reader-function-form (name readers)
  	     `(defun ,name (x)
  		(let ((class (standard-instance-class x))
  		      (slots (standard-instance-slots x)))
  		  (cond 
  		    ,@(loop for reader in readers
  			    collect
  			    `((eq class (find-class ',(car reader) nil))
  			      (slot-contents slots ,(cadr reader))))
  		    (t (error "no reader on ~s" ',name))))))
  	   (make-writer-function-form (name writers)
  	     `(defun (setf ,name) (new-value x)
  		(let ((class (standard-instance-class x))
  		      (slots (standard-instance-slots x)))
  		  (cond 
  		    ,@(loop for writer in writers
  			    collect
  			    `((eq class (find-class ',(car writer) nil))
  			      (setf (slot-contents slots ,(cadr writer))
  				    new-value)))
  		    (t (error "no writer on ~s" ',name)))))))
        (loop for reader in readers
  	    do (eval (make-reader-function-form
  		      reader (collect-reader reader))))
        (loop for writer in writers
  	    do (eval (make-writer-function-form
  		      writer (collect-writer writer))))))
  
    ) ; eval-when
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; The contents of this file should be read sequentially, because the
  ;;; bootstrapping issues make it necessary to create functionality
  ;;; step by step.  FIXME: elaborate...
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  