anchor.diff:             (setf (get ',name 'parser-function) t))
            (defun ,name (,@args ,input)
              ,@(when docstring (list docstring))
  -           ,(compile-and body input () ()))))))
  +           ,(compile-and body input nil nil))))))
   
   ;;; Compiler ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   
  
positive.code:   (funcall comp `(tracer ,(cadr form) ',(cadr form))))
  
  (defun compile-parser-call (exp input names state)
    (destructuring-bind (name &rest args) (rewrite-form exp names)
      (flet ((comp (x) (compile-parser-argument x names state)))
        `(,name ,@(mapcar #'comp args) ,input))))
  
  (defun compile-parser-argument (form names state)
    "Compile a form appearing as an argument to a parser function."
    (with-gensyms (input)
      (labels ((self (x) (compile-parser-argument x names state)))
        (cond
          ((or
            (parser-call-p form names)
            (form-p 'and form)
            (form-p 'or form)
            (stringp form)
            (characterp form))
           (thunkify (compile-form form input names state) input names))
  
          ((form-p 'if form) (compile-if (cdr form) #'self))
          ((form-p 'trace form) (compile-trace form #'self))
          (t form)))))
  
  (defun thunkify (x input names)
    (if (one-arg-parser-call-p x names) `#',(car x) `(lambda (,input) ,x)))
  
  (defun one-arg-parser-call-p (exp names)
    "Expression is a call to a grammar function and the only arguments required
  are the ones that will be passed by anyone invoking a grammar function, i.e. the
  input. N.B. the length test depends, obviously, on the number of standard
  arguments which used to be two (text and position) and is now one (combined
  input object)."
    (and (consp exp) (grammar-p (car exp) names) (= (length exp) 2)))
  
  (defun rewrite-form (form names)
    "Rewrite bare symbols naming parser productions or parser functions into
  cannonical list from."
    (cond
      ((and (symbolp form) (grammar-p form names)) (list form))
      (t form)))
  
  (defun compile-string (str input) `(matching-string ,str ,(length str) ,input))
  
  
negative.code:      ,(compile-parser name args body)))
  
  (defmacro defterm (name (&rest args) &body body)
    "Define a stand-alone parser function using the same language as DEFPARSER."
    (multiple-value-bind (docstring body) (extract-docstring body)
      (with-gensyms (input)
        `(progn
  