anchor.diff:  	(push (list :special v) env))))
     (eval-progn-body body env))
   
  +(defun frob-flet-function (definition env)
  +  (destructuring-bind (name lambda-list &body body) definition
  +    (values name
  +            ;; FIXME: create a named block.
  +            (eval-lambda `(lambda ,lambda-list
  +                            ,@body)
  +                         env))))
  +
  +(defspecial block (&environment env name &body body)
  +  (let ((env (cons (list :block name #+nil(lambda (values)
  +                                       (return-from block (values-list values))))
  +                   env)))
  +    (eval-progn-body body env)))
  +
  +(defspecial flet (&environment env definitions &body forms)
  +  (let ((functions (mapcar (lambda (def)
  +                             (multiple-value-bind (name fn)
  +                                 (frob-flet-function def env)
  +                               (cons name fn)))
  +                           definitions)))
  +    (multiple-value-bind (body declares)
  +        (sys.int::parse-declares forms)
  +      (eval-locally-body declares body (cons (list* :functions functions) env)))))
  +
   (defspecial function (&environment env name)
     (if (sys.int::lambda-expression-p name)
         (eval-lambda name env)
         (fdefinition name)))
   
  +(defspecial labels (&environment env definitions &body forms)
  +  (let* ((env (cons (list :functions) env))
  +         (functions (mapcar (lambda (def)
  +                              (multiple-value-bind (name fn)
  +                                  (frob-flet-function def env)
  +                                (cons name fn)))
  +                            definitions)))
  +    (setf (rest (first env)) functions)
  +    (multiple-value-bind (body declares)
  +        (sys.int::parse-declares forms)
  +      (eval-locally-body declares body env))))
  +
   (defspecial quote (object)
     object)
  +
  +(defspecial return-from (&environment env name &optional value)
  +  (dolist (e env (error "No block named ~S." name))
  +    (when (and (eql (first e) :block)
  +               (eql (second e) name))
  +      (funcall (third e) (multiple-value-list (eval-in-lexenv value env))))))
   
   (defspecial setq (&environment env symbol value)
     (setf (symbol-value symbol) (eval-in-lexenv value env)))
  
positive.code:   `(setf (gethash ',name *special-forms*)
           (lambda (,form-sym ,env-sym)
             (declare (ignorable ,form-sym ,env-sym)
                      (system:lambda-name ,name))
             (destructuring-bind ,lambda-list (cdr ,form-sym)
               ,@body)))))
  
  (defun eval-lambda (lambda outer-env)
    (let ((lambda-list (second lambda))
  
negative.code:     (cond (fn (funcall fn form env))
            #+nil((macro-function (first form) env)
             (eval-in-lexenv (macroexpand-1 form env) env))
            (t (apply (find-function (first form) env)
                      (mapcar (lambda (f) (eval-in-lexenv f env))
                              (rest form)))))))
  
  