anchor.diff:          (character-offset p (length word))
           (skip-whitespace-forward p t))
         (with-point ((start p))
  +        (line-start start)
  +        (setf state (parse-partial-sexp (copy-point start :temporary)
  +                                        (line-end p)))
           (cond
  -          ((unbalanced-p (setf state
  -                               (parse-partial-sexp (copy-point start :temporary)
  -                                                   (line-end p))))
  +          ((unbalanced-p state)
              (setf unbalanced-flag t)
              (unless (setf state (unbalanced-indent p indent start))
                (return-from c-indent-line nil)))
  -          ((and word (ppcre:scan "^(?:case|default)$" word))
  -           (%indent p (- indent tab-width)))
             (t
  -           (%indent p indent)
  -           (unless (indent-cond-op p indent)
  -             (return-from c-indent-line nil)))))
  +           (cond
  +             ((and word (ppcre:scan "^(?:case|default)$" word))
  +              (%indent p (- indent tab-width)))
  +             (t
  +              (%indent p indent)
  +              (unless (indent-cond-op p indent)
  +                (return-from c-indent-line nil)))))))
         (when (eql #\{ (car (pps-state-paren-stack state)))
           (let ((indent (+ indent tab-width))
                 (status))
  
positive.code:     (loop :for start := 0 :then (1+ i)
            :for i := (position #\} (line-string p) :start start)
            :while i
            :do
            (unless (let ((p (character-offset (line-start p) i)))
                          (check-type p point)
                          (in-string-or-comment-p p))
                  (return t)))))
  
  (defun unbalanced-p (state)
    (if (member #\( (pps-state-paren-stack state)) t nil))
  
negative.code:                   (return-from c-indent-line nil)))
      (when (eql #\# (character-at p))
        (%indent p 0))
      (when (eql #\} (character-at p))
        (character-offset p 1)
        (skip-whitespace-forward p t))
      (alexandria:when-let ((i (end-block-line-p p)))
        (with-point ((p p)
                     (start p))
          (line-start start)
          (character-offset (line-start p) (1+ i))
          (when (> 0 (pps-state-paren-depth (parse-partial-sexp start p)))
            (decf indent tab-width))))
      (let ((word (looking-at p "\\w+"))
            (state)
            (unbalanced-flag nil))
  