anchor.diff:  			       ,(canonicalize-direct-superclasses direct-superclasses)
   			     :direct-slots
   			       ,(canonicalize-direct-slots slot-definitions)
  -				 :shared-slots
  -			       ,(canonicalize-shared-slots slot-definitions)
  -				 :shared-slot-initforms
  -				   ,(canonicalize-shared-slot-initforms slot-definitions)		
   			     ,@(canonicalize-defclass-options options)))
   	
   (defun canonicalize-direct-slots (slot-definitions)
  -   `(list ,@(apply 'append (mapcar #'canonicalize-direct-slot slot-definitions))))
  -
  -(defun canonicalize-shared-slots (slot-definitions)
  -   `(list ,@(apply 'append (mapcar #'canonicalize-shared-slot slot-definitions))))
  -
  +   `(list ,@(mapcar #'canonicalize-direct-slot slot-definitions)))
  +	
   (defun canonicalize-direct-slot (spec)
  -	(canonicalize-slot-definition spec ':instance))
  -
  -(defun canonicalize-shared-slot (spec)
  -	(canonicalize-slot-definition spec ':class))
  -	
  -(defun canonicalize-slot-definition (spec allocation-type)
  -	(if (symbolp spec)
  -		(if (not (eq allocation-type ':class))
  -			`((list :name ',spec)))
  -		(let ((name (car spec))
  +	(if (symbolp spec) `(list :name ',spec)
  +                        (let ((name (car spec))
   			  (initfunction nil)
   			  (initform nil)
   			  (initargs ())
  
positive.code: 
  (defgeneric allocate-instance (class))
  (defmethod allocate-instance ((class standard-class))
    (std-allocate-instance class))
  
  (defgeneric make-instance (class &key))
  (defmethod make-instance ((class standard-class) &rest initargs)
    (setq initargs (append initargs (mapappend #'(lambda (def-init)
                                                                                  (let ((key (car def-init)))
                                                                                      (unless (caddr (multiple-value-list (get-properties initargs (list key))))
                                                                                                   (list key (funcall (caddr def-init)))))) (class-default-initargs class))))
    (let ((instance (allocate-instance class)))
      (unless ; all subclasses of metaobject except strict subclasses of standard-class,
                   ; standard-generic-function and standard-method. Standard-class only for now.
              (and (subclassp class #.(find-class 'metaobject))
                      (or (eq class the-class-standard-class) (not (subclassp class the-class-standard-class))))
              (setf (std-instance-signature instance)
                      (list (class-effective-slots class) (class-shared-slot-definitions class) (class-shared-slots class))))
      (apply #'initialize-instance instance initargs)
      instance))
  (defmethod make-instance ((class symbol) &rest initargs)
  
negative.code: 				(add-writer-method
  					class writer (slot-definition-name direct-slot)))))
  
  	(values))
  
  ;;; Slot definition metaobjects
  
  