anchor.diff:    (mapcar #'(lambda (x) `(,(gensym (symbol-name x)) ,x)) names))
   
   (defun restore-state (bindings)
  -  "Given bindings produced by SAVE-STATE-BINDINGS, generate a list of
  -SETF forms that will restore the saved values."
  +  "Given bindings produced by SAVE-STATE-BINDINGS, generate a list of SETF forms
  +that will restore the saved values."
     (mapcar #'(lambda (x) `(setf ,@(reverse x))) bindings))
   
   (defun grammar-p (name names)
  -  "If a symbol either names a production within the grammar or an
  -external parser function."
  +  "If a symbol either names a production within the grammar or an external
  +parser function."
     (or (member name names) (get name 'parser-function)))
   
   (defun compile-and (body txt pos names result state)
  -  "Compile the forms in an AND so that the AND matches if each of
  -the elements matches in sequence."
  +  "Compile the forms in an AND so that the AND matches if each of the elements
  +matches in sequence."
     (unless (null body)
       (let ((body (rewrite-returns body)))
         (with-gensyms (p)
  
positive.code:          (compile-and (rest body) txt p names (gensym "R") state))))))
  
  (defun rewrite-returns (and-body)
    "Rewrite the list of forms to be compiled into a AND so that a (=>
  ...) form will have its result returned as the result of the AND. If
  the => form specifies a value expression it can refer to the value
  matched by the parser via the variable _. Otherwise the value of the
  parser is returned by the AND."
    (let (result)
      (labels ((return-form (x) (and (consp x) (eql (car x) '=>)))
               (rewrite (x)
  
negative.code:         (values args nil))))
  
  (defun compile-production (p names state)
    "Compile a production into a function definition appropriate for a LABELS
  binding."
    (with-gensyms (txt pos)
      (destructuring-bind ((name &rest args) &rest body) p
        `(,name (,@args ,txt ,pos)
  