anchor.diff:    `(funcall ,parser ,input))
   
   (defun compile-if (body input names state)
  -  (flet ((comp (x) (new-compile-form x input names state)))
  +  (flet ((comp (x) (compile-form x input names state)))
       (destructuring-bind (test then else) body
         `(if ,test ,(comp then) ,(comp else)))))
   
   (defun compile-tracer (form input names state)
  -  (new-compile-form `(tracer ,(cadr form) ',(cadr form)) input names state))
  +  (compile-form `(tracer ,(cadr form) ',(cadr form)) input names state))
   
   (defun compile-parser-call (exp names input state)
     (destructuring-bind (name &rest args) (rewrite-form exp names)
  
positive.code:                 ,good
                  (return-from ,or (values ,ok ,result ,next-input)))))))))
  
  (defun new-compile-form (form input names state)
    "Compile a single parser form."
    (cond
      ((parser-function-invocation-p form names) (compile-parser-call form names input state))
  
      ((form-p 'and form) (new-compile-and (rest form) input names state))
  
      ((form-p 'or form) (new-compile-or (rest form) input names state))
  
      ((form-p 'if form) (compile-if (cdr form) input names state))
  
  
negative.code:       (let ((new-body (mapcar #'rewrite body)))
          (values (if result `(,@new-body ,result) body) variables)))))
  
  (defun compile-or (body input names state)
    (let ((state-bindings (save-state-bindings state)))
      (with-gensyms (ok result next-input or good)
        (flet ((comp (x)
                 `(cond
                    ((setf (values ,ok ,result ,next-input) ,(compile-form x input names state))
                     (go ,good))
                    (t ,@(restore-state state-bindings)))))
          `(block ,or
  