anchor.diff:  
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
  +;;; Macro expansion.
  +
  +(defun macro-function (symbol &optional environment)
  +  (when (null environment)
  +    (setf environment *global-environment*))
  +  (let ((entry (find-if (lambda (entry)
  +			  (and (typep entry 'macro-entry)
  +			       (eq (name entry) symbol)))
  +			environment)))
  +    (if (null entry)
  +	nil
  +	(definition entry))))
  +
  +(defparameter *macroexpand-hook*
  +  (lambda (macro-function macro-form environment)
  +    (funcall macro-function macro-form environment)))
  +
  +(defun macroexpand-1 (form &optional environment)
  +  (when (null environment)
  +    (setf environment *global-environment*))
  +  (let ((expander nil))
  +    (cond ((and (consp form) (symbolp (car form)))
  +	   (setf expander (macro-function (car form) environment)))
  +	  ((symbolp form)
  +	   (let ((entry (find-if (lambda (entry)
  +				   (and (typep entry 'symbol-macro-entry)
  +					(eq (name entry) form)))
  +				 environment)))
  +	     (if (null entry)
  +		 nil
  +		 (setf expander (definition entry)))))
  +	  (t nil))
  +    (if expander
  +	(values (funcall (coerce *macroexpand-hook* 'function)
  +			 expander
  +			 form
  +			 environment)
  +		t)
  +	(values form nil))))
  +
  +(defun macroexpand (form &optional environment)
  +  (multiple-value-bind (expansion expanded-p)
  +      (macroexpand-1 form environment)
  +    (if expanded-p
  +	(loop while (multiple-value-bind (new-expansion expanded-p)
  +			(macroexpand-1 expansion environment)
  +		      (setf expansion new-expansion)
  +		      expanded-p)
  +	      finally (return (values expansion t)))
  +	(values form nil))))
  +
  +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  +;;;
  +;;; Global environment.
  +;;;
  +;;; The FUNCTION namespace contains three types of entries:
  +;;; GLOBAL-FUNCTION-ENTRY, GLOBAL-MACRO-ENTRY, and
  +;;; SPECIAL-OPERATOR-ENTRY.  All special operator entries are global,
  +;;; because there is no mechanism for defining local special
  +;;; operators.
  + 
  +(defclass package ()
  +  ((%name :initarg :name :accessor name)
  +   (%nicknames :initarg :nicknames :initform '() :accessor nicknames)))
  +
  +(defclass global-environment ()
  +  (;; The package namespace.  A list of packages.
  +   (%packages :initform '() :accessor packages)
  +   ;; The class namespace.  A list of classes.
  +   (%classes :initform '() :accessor classes)
  +   ;; The type namespace.
  +   (%types :initform '() :accessor types)
  +   ;; The variable namespace.  It contains entries for
  +   ;; symbol macros, constant variables, and special variables. 
  +   (%variables :initform '() :accessor variables)
  +   ;; The function namespace.  It contains entries for
  +   ;; macros and functions.
  +   ;; FIXME: what about compiler macros?
  +   (%functions :initform '() :accessor functions)
  +   (%proclamations :initform '() :accessor proclamations)))
  +
  +(defparameter *global-environment*
  +  (make-instance 'global-environment))
  +
  +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  +;;;
   ;;; Querying the environment.
   
   (defun find-in-namespace (name environment namespace)
  
positive.code: 			 :notinline)))))
  
  (defun find-ignore-info (entry env)
    (cond ((loop for e in env
  	       when (and (typep e 'ignore-declaration-entry)
  			 (eq (location e) entry))
  		 return t)
  	 :ignore)
  	((loop for e in env
  	       when (and (typep e 'ignorable-declaration-entry)
  			 (eq (location e) entry))
  		 return t)
  
negative.code:   (unless (find-if (lambda (entry)
  		     (and (typep entry 'declaration-declaration-entry)
  			  (eq (name entry) name)))
  		   (proclamations *global-environment*))
      (push (make-instance 'declaration-declaration-entry
  	    :name name)
  	  (proclamations *global-environment*))))
  
  (defun proclaim-ftype (name type)
    (let ((entry (find-if (lambda (entry)
  