anchor.diff:    "Define a function with BODY written in Lisp-1 style.
   
   This is just like DEFUN."
  -  (with-vars-bound (extract-argument-names args :allow-specializers nil)
  +  (with-bound-vars (extract-argument-names args :allow-specializers nil)
       `(defun ,name ,args
          ,(lisp1 `(block ,name ,@body)))))
   
  
positive.code: 
  ;;;; * Special Variables
  
  (defvar *vars-bound* nil
    "When walking code, this variable contains a list of
  variables (represented by symbols) which have been bound in
  the variable namespace.
  
  In essence these variables do not have to be sharp-quoted.")
  
  (defvar *funs-bound* nil
    "When walking code, this variable contains a list of
  variables (represented by symbols) which have been bound in
  the function namespace.
  
  In essence these variables must be sharp-quoted.")
  
  (defmacro with-vars-bound (vars &body body)
    "Execute BODY with VARS added to the variable namespace and
  VARS removed from the function namespace.
  
  This should only be used when code-walking."
    `(let ((*vars-bound* (append         *vars-bound* ,vars))
  	 (*funs-bound* (set-difference *funs-bound* ,vars)))
       ,@body))
  
  (defmacro with-funs-bound (funs &body body)
    "Execute BODY with FUNS added to the function namespace and
  FUNS removed from the variable namespace.
  
  This should only be used when code-walking."  
    `(let ((*funs-bound* (append         *funs-bound* ,funs))
  	 (*vars-bound* (set-difference *vars-bound* ,funs)))
       ,@body))
  
  ;;;; * Definers
  
negative.code:   "Define a method with BODY written in Lisp-1 style.
  
  This is just like DEFMETHOD."
    (with-bound-vars (extract-argument-names args :allow-specializers t)
      `(defmethod ,name ,args
         ,(lisp1 `(block ,name ,@body)))))
  
  