anchor.diff:    (:export))
   (in-package :lem-c-mode)
   
  -(defparameter *tab-width* 8)
  -
   (defvar *c-syntax-table*
     (let ((table (make-syntax-table
                   :space-chars '(#\space #\tab #\newline)
  -                :symbol-chars '(#\_ #\; #\,)
  +                :symbol-chars '(#\_)
                   :paren-alist '((#\( . #\))
                                  (#\{ . #\})
                                  (#\[ . #\]))
  
positive.code:                          (when (or (null (form-offset point 1))
                                     (point< start point))
                             (1+ column)))))
                     (+ (point-column point) *tab-width*)))
                ((or (looking-at point "^\\s*$")
                     (looking-at point "^\\s*(?:\\|\\||&&)"))
                 (go :start))
                ((looking-at point ".*\\{\\s*$")
                 (back-to-indentation point)
                 (+ (point-column point) *tab-width*))
                ((and (looking-at point ".*\\,\\s*$")
                      (scan-lists (line-end point) -1 1 t)
                      (eql #\( (character-at point)))
                 (1+ (point-column point)))
                (t
                 (back-to-indentation point)
                 (point-column point)))))))
  
  (pushnew (cons "\\.c$" 'c-mode) *auto-mode-alist* :test #'equal)
  
negative.code:     (return-from calc-indent (1+ (point-charpos point))))
    (when (in-string-p point)
      (return-from calc-indent nil))
    (when (looking-at point "\\}")
      (unless (form-offset point -1) (return-from calc-indent nil))
      (back-to-indentation point)
      (return-from calc-indent (- (point-column point) (tab-size))))
    (with-point ((start point))
      (tagbody
       :start
        (unless (line-offset point -1)
          (return-from calc-indent 0))
        (line-end point)
        (maybe-beginning-of-string-or-comment point)
        (form-offset point -1)
        (back-to-indentation point)
        (return-from calc-indent
          (cond ((and (looking-at point "^\\s*(case:|default:|do\\b|else\\b|for\\b|if\\b|switch\\b|while\\b)")
                      (not (looking-at point ".*(?:;|\\{\\})\\s*$")))
                 (message "case-1")
                 (or (when (looking-at point "if\\s*\\(")
                       (with-point ((point point))
                         (skip-chars-forward point (lambda (c) (not (eql c #\())))
  