anchor.diff:    (with-c-output nil
       (if (atom c)
           (c-format "~A" c)
  -        (destructuring-bind (head &rest body) c
  -          (ecase head
  -            ((:== :!= :+ :* :/ :& :&& :. :->)
  -             (destructuring-bind (a b) body
  -               (c-format "((~A) ~A (~A))"
  -                         (c-exp a) head (c-exp b))))
  -            (:call (destructuring-bind (name &rest args) body
  -                     (c-format "~A(~{~A~^, ~})"
  -                               (c-exp name)
  -                               (map 'list #'c-exp args)))))))))
  +        (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)
  -  (destructuring-bind (head &rest body) c
  -    (ecase head
  -      ((:== :!= :call)
  -       (c-exp c))
  -      (:seq (destructuring-bind (&rest rest) body
  -              (map nil #'c-gen rest)))
  -      (:stmt (destructuring-bind (name) body
  -               (c-gen name)
  -               (c-format ";~&")))
  -      (:goto (destructuring-bind (label) body
  -               (c-format-goto label)))
  -      (:return (destructuring-bind (value) body
  -                 (c-format-return (c-exp value))))
  -      (:label (destructuring-bind (label) body
  -                (c-format-label label)))
  -      (:case (destructuring-bind (label) body
  -               (c-format-case label)))
  -      (:block
  -          (with-c-block
  -            (map nil #'c-gen body)))
  -      (:if (destructuring-bind (test then-clause &optional else-clause) body
  -             (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 (destructuring-bind (str) body
  -                  (c-indent-format "// ~A" str)))
  -      )))
  +  (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)
  
positive.code:             ;; default
              (c-gen '(:seq (:label "default")
                       (:return -1)))))))))
  
negative.code: 
  (defun c-indent-format (fmt &rest args)
    (format *c-stream* "~&~A"
            (make-string (max 0 *c-indent*) :initial-element #\Tab))
    (apply #'c-format fmt args))
  
  (defmacro with-c-indent (&body body)
  