anchor.diff:  	    (t (le-form*-cdr form))))
       (lexical-variable (le-variable form))
       (lambda-information
  -     (if *environment-chain*
  -         `(,(if (getf (lambda-information-plist form) 'declared-dynamic-extent)
  -                'sys.c::make-dx-closure
  -                'sys.int::make-closure)
  -           ,(le-lambda form)
  -           ,(second (first *environment-chain*)))
  -         (le-lambda form)))))
  +     (cond ((not *environment-chain*)
  +            (le-lambda form))
  +           ((getf (lambda-information-plist form) 'declared-dynamic-extent)
  +            `(sys.c::make-dx-closure
  +              ,(le-lambda form)
  +              ,(second (first *environment-chain*))))
  +           (*environment-allocation-mode*
  +            `(sys.int::make-closure
  +              ,(le-lambda form)
  +              ,(second (first *environment-chain*))
  +              ',*environment-allocation-mode*))
  +           (t `(sys.int::make-closure
  +                ,(le-lambda form)
  +                ,(second (first *environment-chain*))))))))
   
   (defvar *environment-chain* nil
     "The directly accessible environment vectors in this function.")
  
positive.code:                                 (let ((info (assoc current-env new-envs)))
                                    (append (list stmt)
                                            (when info
                                              (list `(setq ,(second info) (,(if (gethash current-env *environment-layout-dx*)
                                                                                'sys.c::make-dx-simple-vector
                                                                                'sys.int::make-simple-vector)
                                                                            ',(1+ (length (third info)))))))
                                            (when (and info *environment*)
                                              (list (list '(setf sys.int::%svref)
                                                          (second (first *environment-chain*))
  
negative.code:                             (gethash env *environment-layout*)))
                    *environment*))))
  
  (defun generate-make-environment (lambda size)
    (cond ((gethash lambda *environment-layout-dx*)
           ;; DX allocation.
           `(sys.c::make-dx-simple-vector ',size))
          (*environment-allocation-mode*
           ;; Allocation in an explicit area.
           `(sys.int::make-simple-vector ',size ',*environment-allocation-mode*))
          ;; General allocation.
          (t `(sys.int::make-simple-vector ',size))))
  
  (defun le-lambda (lambda)
    (let ((*environment-chain* '())
          (*environment* *environment*)
          (local-env (gethash lambda *environment-layout*))
          (*current-lambda* lambda)
          (*environment-allocation-mode* (let* ((declares (getf (lambda-information-plist lambda) :declares))
                                                (mode (assoc 'sys.c::closure-allocation declares)))
                                           (if (and mode (cdr mode))
                                               (second mode)
                                               *environment-allocation-mode*))))
      (when *environment*
        ;; The entry environment vector.
        (let ((env (make-lexical-variable :name (gensym "Environment")
  