anchor.diff:  
   ;;;; * Special Variables
   
  -(defvar *bound-vars* nil
  +(defvar *vars-bound* nil
     "When walking code, this variable contains a list of
  -variables (represented by symbols) which have been bound.")
  +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
   
  
positive.code: 			(lisp1s arguments))))
  
  (deflisp1-walker function-binding-form (binds body)
    (new (class-name-of form)
         :binds (lisp1b binds)
         :body  (lisp1s body)))
  
  (deflisp1-walker variable-binding-form (binds body)
    (new (class-name-of form)
         :binds (lisp1b binds)
         :body  (lisp1s body)))
  
  (deflisp1-walker setq-form (var value)
    (new 'setq-form
  
negative.code: 
  (deflisp1-walker lambda-function-form (arguments body)
    ;; For any function-form (ie lambda), we just transform the body.
    ;; We also must add the parameters to the variable namespace, and
    ;; remove the parameters from the function namespace.
    (with-vars-bound (mapcar #'name arguments)
      (new 'lambda-function-form
  	 :arguments arguments
  	 :body      (lisp1s body))))
  
  (deflisp1-walker variable-reference (name)
    ;; If a free variable is bound in the toplevel, *and* not bound by
    ;; an enclosing lambda, then we'll return that function.  Also, if
    ;; the variable has been bound by an enclosing function binding form
    ;; then we'll return that function.  We take advantage of the fact
    ;; that the `name' slot is shared.
    (if (or (and (fboundp name) (not (member name *vars-bound*)))
  	  (member name *funs-bound*))
        (change-class form 'free-function-object-form)
        form))
  
  