anchor.diff:  ;;; the name is a special operator.
   ;;;
   ;;; For a special operator we do nothing.
  +;;;
  +;;; Recall that we may simultaneously have a global function entry and
  +;;; a global macro for the name.  Furthermore, one of those entries
  +;;; may have a compiler macro auxiliar entry referring to it. 
   ;;;
   ;;; We could remove the entry altogether, but we have chosen not to do
   ;;; that.  The reason is that we may have other entries that refer to
  
positive.code: ;;;
  ;;; Class DECLARATION-DECLARATION-ENTRY.
  
  (defclass declaration-declaration-entry (autonomous-declaration-entry)
    ((%name :initarg :name :reader name)))
  
  (defun make-declaration-declaration-entry (name)
  
negative.code: ;;; must decide what to return in the case of a macro or a special
  ;;; operator.  We decide that for a macro, it returns its expander
  ;;; function, and for a special operator, it returns the name. 
  ;;;
  ;;; Recall that we may simultaneously have a global function entry and
  ;;; a global macro for the name.  If that is the case, then the global
  ;;; macro entry is the one that is valid.  
  
  (defun fdefinition (function-name)
    (unless (function-name-p function-name)
      (error "not a function name ~s" function-name))
    ;; First see if there is a global macro entry with the right name.
    (let ((macro-entry
  	  (find-if (lambda (entry)
  		     (and (typep entry 'global-macro-entry)
  			  (equal (name entry) function-name)))
  		   (functions *global-environment*))))
      (if (not (null macro-entry))
  	;; We found a global macro entry with the right name.
  	;; Return the expansion function associated with it.
  	(definition macro-entry)
  	;; If we did not find a global macro entry, see if there might
  	;; be a global function entry with the right name.
  	(let ((function-entry
  		(find-if (lambda (entry)
  			   (and (typep entry 'global-function-entry)
  				(equal (name entry) function-name)))
  			 (functions *global-environment*))))
  	  (if (not (null function-entry))
  	      ;; We found a global function entry with the right name.
  	      ;; In this case, there can not also be a special
  	      ;; operator entry for the same name.
  	      (if (or (null (location function-entry))
  		      (eq (car (storage (location function-entry))) +unbound+))
  		  (error 'undefined-function :name function-name)
  		  (car (storage (location function-entry))))
  	      ;; If we did not find a global function entry, see if
  	      ;; there might be a special operator entry.
  	      (let ((specop-entry
  		      (find-if (lambda (entry)
  				 (and (typep entry 'special-operator-entry)
  				      (equal (name entry) function-name)))
  			       (functions *global-environment*))))
  		(if (null specop-entry)
  		    (error 'undefined-function :name function-name)
  		    t)))))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  