anchor.diff:    `(defun ,name (,body-var)
        (when (or (null ,body-var)
   	       (and ,@(mapcar (lambda (start-symbol)
  -				`(not (symbol-equal (car ,body-var) ',start-symbol)))
  +				`(not (symbol-equal (car ,body-var)
  +						    ',start-symbol)))
   			      start-symbols)))
          (return-from ,name (values nil ,body-var)))
        ,@body))
  
positive.code: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Conditions for parsing
  
  (define-condition loop-parse-error (parse-error) ())
  
  ;;; Root class for loop parse errors that report
  ;;; something that was found, but should not be there. 
  (define-condition loop-parse-error-found (parse-error)
    ((%found :initarg :found :reader found)))
  
  
negative.code:     (if (or (null rest1)
  	    (not (symbol-equal (car rest1) '#:by)))
  	(values (make-instance class-name
  		  :list-form form
  		  :step-fun-form #'cdr)
  		rest1)
  	(multiple-value-bind (step-fun-form rest2)
  	    (parse-form (cdr rest1))
  	  (values (make-instance class-name
  		    :list-form form
  		    :step-fun-form step-fun-form)
  		  rest2)))))
  
  ;;; Parse a FOR/AS IN/ON subclause.  The list we are given starts
  ;;; with the variable and the optional type-spec.
  (defun parse-for/as-in/on (body)
    (multiple-value-bind (var type-spec rest1)
        (parse-var-and-type-spec body)
      ;; FIXME: handle type-spec.
      (declare (ignore type-spec))
      (cond ((symbol-equal (car rest1) '#:in)
  	   (parse-for/as-in/on (cdr body) 'for/as-in-list-subclause var))
  	  ((symbol-equal (car rest1) '#:on)
  	   (parse-for/as-in/on (cdr body) 'for/as-on-list-subclause var))
  	  (t
  	   (values nil body)))))
  	  
  (defun parse-for/as-in (body)
    (multiple-value-bind (var type-spec rest1)
        (parse-var-and-type-spec body)
      ;; FIXME: handle type-spec.
      (declare (ignore type-spec))
      (if (symbol-equal (car rest1) '#:in)
  	(
    
  
  (define-elementary-parser parse-for/as-in body (#:in)
    (parse-for/as-in/on (cdr body) 'for/as-in-list-subclause))
  
  (define-elementary-parser parse-for/as-on body (#:on)
    (parse-for/as-in/on (cdr body) 'for/as-on-list-subclause))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Clauses FOR/AS ACROSS
  ;;;
  ;;;    for-as-across::= var [type-spec] across vector 
  
  (defclass for/as-across-subclause (for/as-subclause) 
    ((%array-form :initarg :array-form :reader array-form)))
  
  (define-elementary-parser parse-for/as-across body (#:across)
    (multiple-value-bind (form rest)
        (parse-form body)
      (values (make-instance 'for/as-across-subclause
  	      :array-form form)
  	    rest)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Clause FOR/AS = THEN
  ;;;
  ;;;    for-as-equals-then::= var [type-spec] = form1 [then form2] 
  
  (defclass for/as-equals-then-subclause (for/as-subclause)
    ((%form1 :initarg :form1 :reader form1)
     (%form2 :initarg :form2 :reader form2)))
  
  (define-elementary-parser parse-for/as-equals-then body (#:=)
    (multiple-value-bind (form1 rest1)
  