anchor.diff:  ;;; DOWNFROM - BY - TO/DOWNTO/ABOVE 
   (define-parser arithmetic-down-8-parser
     (consecutive (lambda (var type-spec from by to)
  -		 (let ((to-var (gensym))
  -		       (by-var (gensym)))
  -		   (multiple-value-bind (initial-value type)
  -		       (arithmetic-value-and-type type-spec)
  -		     (make-instance 'for-as-arithmetic
  -		       :bindings `((,var ,initial-value)
  -				   (,by-var ,initial-value)
  -				   (,to-var (cdr to)))
  -		       :declarations `((cl:type ,type ,var))
  -		       :prologue `(progn (setq ,var ,from)
  -					 (setq ,by-var ,by)
  -					 (,to-var (cdr to)))
  -		       :termination
  -		       `(when (,(if (eq (car to) '/=) '<= '<) ,var ,to-var)
  -			  (go end))
  -		       :step `((decf ,var ,by-var))))))
  +		 (make-instance 'for-as-arithmetic-down
  +		   :var-spec var
  +		   :type-spec type-spec
  +		   :start-form from
  +		   :end-form (second to)
  +		   :by-form by
  +		   :termination-test (first to)))
   	       'simple-var-parser
   	       'optional-type-spec-parser
   	       'downfrom-parser
  
positive.code: ;;; TO/DOWNTO/ABOVE - BY - DOWNFROM
  (define-parser arithmetic-down-10-parser
    (consecutive (lambda (var type-spec to by from)
  		 (let ((to-var (gensym))
  		       (by-var (gensym)))
  		   (multiple-value-bind (initial-value type)
  		       (arithmetic-value-and-type type-spec)
  		     (make-instance 'for-as-arithmetic
  		       :bindings `((,to-var (cdr to))
  				   (,by-var ,initial-value)
  				   (,var ,initial-value))
  		       :declarations `((cl:type ,type ,var))
  		       :prologue `(progn (,to-var (cdr to))
  					 (setq ,by-var ,by)
  					 (setq ,var ,from))
  		       :termination
  		       `(when (,(if (eq (car to) '/=) '<= '<) ,var ,to-var)
  			  (go end))
  		       :step `((decf ,var ,by-var))))))
  	       'simple-var-parser
  	       'optional-type-spec-parser
  	       (alternative 'to-parser 'downto-parser 'above-parser)
  
negative.code: ;;;
  ;;; Clause FOR-AS-ARITHMETIC.
  
  (defclass for-as-arithmetic (for-as-subclause var-and-type-spec-mixin)
    (;; The form that was given after one of the LOOP keywords FROM,
     ;; UPFROM, or DOWNFROM, or 0 if none of these LOOP keywords was
     ;; given.
     (%start-form :initform 0 :initarg :start-form :reader start-form)
     ;; The form that was after one of the LOOP keywords TO, UPTO,
     ;; DOWNTO, BELOW, or ABOVE, or NIL if none of these LOOP keywords
     ;; was given.
     (%end-form :initform nil :initarg :end-form :reader end-form)
     ;; The form that was after the LOOP keyword BY, or 0 if this
     ;; keyword was not given.
     (%by-form :initform 1 :initarg :by-form :reader by-form)
     ;; If termination is TO, UPTO, or DOWNTO, then this slot contains
     ;; the symbol <=.  If termination is ABOVE or BELOW, then this slot
     ;; contains the symbol <.
     (%termination-test :initform '<=
  		      :initarg :termination-test
  		      :reader termination-test)))
  
  (defclass for-as-arithmetic-up (for-as-arithmetic) ()
    (:default-initargs :termination-test '<=))
  
  (defclass for-as-arithmetic-down (for-as-arithmetic) ()
    (:default-initargs :termination-test '>=))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  