anchor.diff:      (while-or-until :until (ps-gensym) state)))
   
   (defun body-clause (term state)
  -  (case term
  -    ((:when :unless)
  -     (list (intern (symbol-name term))
  -           (eat state)
  -           (body-clause (eat state :atom) state)))
  -    ((:sum :collect :append :count :minimize :maximize)
  -     (accumulate term (eat state) (eat state :if :into) state))
  -    (:do (eat state :progn))
  -    (otherwise (err "a PS-LOOP keyword" term))))
  +  (loop-case term
  +        ((:when :unless)
  +         (list (intern (symbol-name term))
  +               (eat state)
  +               (body-clause (eat state :atom) state)))
  +        ((:sum :collect :append :count :minimize :maximize)
  +         (accumulate term (eat state) (eat state :if :into) state))
  +        (:do (eat state :progn))
  +        (otherwise (err "a PS-LOOP keyword" term))))
   
   (defun clause (state)
     (let ((term (eat state :atom)))
  -    (case term
  -      (:with (a-with-clause state))
  -      (:for (for-clause state))
  -      (:repeat (repeat-clause state))
  -      (:while (while-clause state))
  -      (:until (until-clause state))
  -      (:initially (push (eat state :progn) (initially state)))
  -      (:finally (push (eat state :progn) (finally state)))
  -      (otherwise (push (body-clause term state) (body state))))))
  +    (loop-case term
  +          (:with (a-with-clause state))
  +          (:for (for-clause state))
  +          (:repeat (repeat-clause state))
  +          (:while (while-clause state))
  +          (:until (until-clause state))
  +          (:initially (push (eat state :progn) (initially state)))
  +          (:finally (push (eat state :progn) (finally state)))
  +          (otherwise (push (body-clause term state) (body state))))))
   
   (defun parse-ps-loop (terms)
     (if (null terms)
  
positive.code:         (test-op nil)
          (by nil)
          (end nil))
      (loop while (member (peek state) '(:to :below :downto :above :by)) do
            (let ((term (eat state)))
              (if (eq term :by)
                  (setf by (eat state))
                  (setf op (case term ((:downto :above) '-) (otherwise '+))
                        test-op (case term (:to '>) (:below '>=) (:downto '<) (:above '<=))
                        end (eat state)))))
      (let ((test (when test-op
                    (with-local-var (v end state)
  
negative.code:       (var-or-bindings state)
      (let ((term (eat state :atom)))
        (when bindings
          (when (loop-keyword? term :from)
            (err "an atom after FROM" bindings))
          (setf var (ps-gensym)))
        (loop-case term
              (:from (for-from var state))
              (:= (for-= var bindings state))
              ((:in :across) (for-in var bindings state))
              (:on (for-on var bindings state))
              (otherwise (error "FOR ~s ~s is not valid in PS-LOOP." var term))))))
  
  (defun a-with-clause (state) ;; so named to avoid with-xxx macro convention
    (multiple-value-bind (var bindings)
  