anchor.diff:             do (case c
                   (#\- (putchars #\_))
                   (#\= (putchars "_equal_"))
  +                (#\Space (putchars "_sp_"))
                   (#\( (putchars "_lp_"))
                   (#\) (putchars "_rp_"))
                   (otherwise (putchars c))))))))
   
   
   
  +(defun print-c-parser-predicate (stream symbol context)
  +  (cond
  +    ((atom symbol)
  +     (format stream "(~A) -> ~A" context (csymbol symbol)))
  +    ((and (listp symbol)
  +          (eq :not (car symbol)))
  +     (destructuring-bind (not clause) symbol
  +       (assert (eq not :not))
  +       (format stream "(!(~A) -> ~A)" context (csymbol clause))))
  +    (t (error "Unknown predicate ~A" symbol))))
  +
  +
  +(defun print-c-parser-funcall (stream symbol context)
  +  (if (and (listp symbol)
  +           (eq :predicate (car symbol)))
  +      (print-c-parser-predicate stream (cadr symbol) context)
  +      (format stream "~A( ~A )" (csymbol symbol) context)))
  +
  +(defun print-c-parser-stub (stream symbol context-type context)
  +  (if (and (listp symbol)
  +           (eq :predicate (car symbol)))
  +      (format stream "~&/* No code for predicate symbol */~%")
  +      (format stream "~&static int ~A( ~A ~A ) {~%~%~%}~%~%"
  +              (csymbol symbol) context-type context)))
  +
  +
  +
   (defun fa->c-stub (fa &key
                      output
                      (halt-function "halt")
  -                   (static-functions t)
  -                   (context-type "void*"))
  +                   ;(static-functions t)
  +                   (context-type "void*")
  +                   (print-stub #'print-c-parser-stub))
     (output-function (lambda (s)
                        (format s "~&/************************************/~&")
                        (format s "~&/* STUB FUNCTIONS FOR MOTION PARSER */~&")
  
positive.code:                          (do-finite-set (z (fa-terminals fa))
                             (let ((q1 (funcall mover q0 z)))
                               (when q1
                                 (format s "~&		if( 0 == ~A( context ) ) goto state~A;~&" (csymbol z) q1))))
                           (when (finite-set-inp q0 (fa-accept fa))
                             (format s "~&		if( 0 == ~A( context ) ) return 0;~&" halt-function))
                           (format s "~&		return -1;~&"))
  
negative.code:                      (format s "~%/* Each function must return 0 for an occuring terminal and nonzero otherwise */~%~%")
                       (do-finite-set (z (finite-set-add (fa-terminals fa) halt-function))
                         (format s "~&/* Terminal Symbol function for \"~A\" */~&" z)
                         (funcall print-stub s z context-type "context")))
                         ;(format s "~&~:[~;static ~]int ~A( ~A context ) {~%~%~%}~%~%" static-functions (csymbol z) context-type)))
                     output))
  
  (defun fa->c-parser (fa &key
  