anchor.diff:                  :halt-function halt-function
                   :context-type context-type
                   ))
  +
   
   
   ;; Generate a predictive parser for LL(1) grammars
  
positive.code: 
  (defun c-indent-format (fmt &rest args)
    (format *c-stream* "~&~A"
            (make-string *c-indent* :initial-element #\Tab))
    (apply #'c-format fmt args))
  
  (defmacro with-c-indent (&body body)
  
negative.code:   (with-c-output nil
      (if (atom c)
          (c-format "~A" c)
          (spec-case c
            (((binop is (or :== :!= :+ :* :/ :& :&&)) a b)
             (c-format "(~A ~A ~A)"
                       (c-exp a) binop (c-exp b)))
            (((binop is (or  :. :->)) a b)
             (c-format "(~A~A~A)"
                       (c-exp a) binop b))
            ((:call name &rest args)
             (c-format "(~A(~{~A~^, ~}))"
                       (c-exp name)
                       (map 'list #'c-exp args)))
            (((unop is (or :~ :!)) a)
             (c-format "(~A ~A)" unop
                       (c-exp a)))
            (a
             (error "Unknown c-expression: ~A" a))))))
  
  (defun c-gen (c)
    (spec-case c
      ((&ignore (op is (or :== :!= :call :! :->)) &rest rest)
       (c-exp c))
      ((:seq &rest rest)
       (map nil #'c-gen rest))
      ((:stmt name)
       (c-gen name)
       (c-format ";~&"))
      ((:goto label)
       (c-format-goto label))
      ((:return value)
       (c-format-return (c-exp value)))
      ((:label label)
       (c-format-label label))
      ((:case label)
       (c-format-case label))
      ((:block &rest body)
       (with-c-block
         (map nil #'c-gen body)))
      ((:if test then-clause &optional else-clause)
       (with-c-nest ((c-indent-format "if ( ~A )" (c-exp test)))
         (map nil #'c-gen then-clause))
       (when else-clause
         (with-c-nest ((c-indent-format "else"))
           (map nil #'c-gen else-clause))))
      ((:comment str)
       (c-indent-format "// ~A" str))
      (a
       (error "Unknown c-code: ~A" a))))
  
  
  (defun csymbol (gsymbol &optional prefix)
  