anchor.diff:  	 (e (not (null (intersection '(:execute eval) situations)))))
       (let ((new-form (cons 'progn (cddr form))))
         (if (and *compile-file* *top-level-form-p*)
  -	  ;; This test tree corresponds to figure 3-7 of the HyperSpec.
  -	  (if c
  -	      (if l
  -		  (let ((*compile-time-too* t))
  -		    (convert new-form environment))
  -		  (progn (eval new-form) nil))
  -	      (if l
  -		  (if e
  -		      (convert new-form environment)
  -		      (let ((*compile-time-too* nil))
  -			(convert new-form environment)))
  -		  (when (and e *compile-time-too*)
  -		    (progn (eval new-form) nil))))
  +	  (let ((*top-level-subform-p* *top-level-form-p*))
  +	    ;; This test tree corresponds to figure 3-7 of the
  +	    ;; HyperSpec.
  +	    (if c
  +		(if l
  +		    (let ((*compile-time-too* t))
  +		      (convert new-form environment))
  +		    (progn (eval new-form) nil))
  +		(if l
  +		    (if e
  +			(convert new-form environment)
  +			(let ((*compile-time-too* nil))
  +			  (convert new-form environment)))
  +		    (when (and e *compile-time-too*)
  +		      (progn (eval new-form) nil)))))
   	  (when e
   	    (convert new-form environment))))))
   
  
positive.code: 
  (defgeneric convert (form environment))
  
  (defun convert-top-level-form (form)
    (let ((*location-asts* (make-hash-table :test #'eq)))
      (convert `(function (lambda () ,form)) nil)))
  
negative.code: 		      ,@forms)))
  	       env)))))))
  
  ;;; We convert a LET* form recursively.  If it has a single binding,
  ;;; we convert it into a SETQ.  If it has more than one binding, we
  ;;; convert it as follows:
  ;;;
  ;;; (let* ((<var> <init-form>)
  ;;;        <more-bindings>)
  ;;;   <body>)
  ;;; =>
  ;;; (let ((<var> <init-form>))
  ;;;   (let (<more-bindings>)
  ;;;      <body>)))
  
  (defmethod convert-compound
      ((symbol (eql 'let*)) form env)
    (sicl-code-utilities:check-form-proper-list form)
    (sicl-code-utilities:check-argcount form 1 nil)
    (destructuring-bind (bindings &rest body) (cdr form)
      (check-binding-forms bindings)
      (if (= (length bindings) 1)
  	(convert-simple-let (car bindings) body env)
  	(let* ((first (car bindings))
  	       (var (if (symbolp first) first (car first)))
  	       (init-form (if (symbolp first) nil (cadr first))))
  	  (multiple-value-bind (declarations forms)
  	      (sicl-code-utilities:separate-ordinary-body body)
  	    (multiple-value-bind (first remaining)
  		(separate-declarations 
  		 (sicl-code-utilities:canonicalize-declaration-specifiers 
  		  (mapcar #'cdr declarations))
  		 var)
  	      (convert
  	       `(let ((,var ,init-form))
  		  (declare ,@first)
  		  (let* ,(cdr bindings)
  		    (declare ,@remaining)
  		    ,@forms))
  	       env)))))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Converting LOAD-TIME-VALUE.
  