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