anchor.diff:    (sicl-code-utilities:check-form-proper-list form)
     (sicl-code-utilities:check-argcount form 0 0)
     (sicl-ast:make-halt-ast))
  +
  +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  +;;;
  +;;; CONVERT is the function that must be called by every conversion
  +;;; attempt.  
  +;;;
  +;;; This function has an unusual control structure.  The reason is the
  +;;; complication that arises because of the way top-level forms are
  +;;; handled.  Whether a form is a top-level form or not is indicated
  +;;; by the variable *TOP-LEVEL-FORM-P*.  This variable is initially
  +;;; TRUE, and we want it to become FALSE by default whenever CONVERT
  +;;; is called recursively.  In some cases, however, subforms of some
  +;;; form F should be processed the same way as F is processed (see
  +;;; section 3.2.3.1 in the HyperSpec).  The simplest control structure
  +;;; would be for all indivudual converters to set *TOP-LEVEL-FORM-P*
  +;;; to FALSE, EXCEPT those that process subforms the same way.
  +;;; However, that would require us to take special action whenever we
  +;;; add a converter for a new special form, and we would like to avoid
  +;;; that.  We would like the special action to be visible only in the
  +;;; converters that treat subforms as top-level forms.
  +;;;
  +;;; The way we solve this problem is as follows: We use a second
  +;;; variable *TOP-LEVEL-SUBFORM-P*, which is normally FALSE.  An
  +;;; :AROUND method on CONVERT binds *TOP-LEVEL-FORM-P* to the value of
  +;;; *TOP-LEVEL-SUBFORM-P*, and binds *TOP-LEVEL-SUBFORM-P* to FALSE.
  +;;; Individual converters that need to process subforms the same way
  +;;; bind *TOP-LEVEL-SUBFORM-P* to the value of *TOP-LEVEL-FORM-P*
  +;;; before calling CONVERT.
  +
  +
  +(defmethod convert (form environment)
  +  (setf form (sicl-env:fully-expand-form form environment))
  +  (cond ((and (not (consp form))
  +	      (not (symbolp form)))
  +	 (convert-constant form))
  +	((and (symbolp form)
  +	      (sicl-env:constantp form environment))
  +	 (convert-constant (sicl-env:symbol-value form)))
  +	((and (consp form)
  +	      (eq (car form) 'quote))
  +	 (convert-constant (cadr form)))
  +	((symbolp form)
  +	 (convert-variable form environment))
  +	(t
  +	 (convert-compound (car form) form environment))))
  +	 
  +(defmethod convert :around (form environment)
  +  (let ((*top-level-form-p* *top-level-subform-p*)
  +	(*top-level-subform-p* nil))
  +    (when (and *compile-time-too* *top-level-form-p*)
  +      (eval form))
  +    (call-next-method)))
  
positive.code: ;;; When this variable is false, we are invoked by EVAL or COMPILE.
  ;;; When it is true, we are invoked by COMPILE-FILE.
  (defparameter *compile-file* nil)
  
  ;;; When this variable is false, non-immediate constants will be
  ;;; converted into a LOAD-TIME-VALUE ast, which means that the machine
  
negative.code: (defmethod convert-compound
      ((head (eql 'progn)) form environment)
    (sicl-code-utilities:check-form-proper-list form)
    ;; According to section 3.2.3.1 of the HyperSpec, PROGN
    ;; processes its subforms the same way as the form itself.
    (let ((*top-level-subform-p* *top-level-form-p*))
      (sicl-ast:make-progn-ast
       (convert-sequence (cdr form) environment))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  