progmodes/cc-engine.el (c-guess-basic-syntax): Reindent.

2 files changed, 1364 insertions, 1360 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index e34fde79543..75c1818b24d 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,7 @@
+2011-03-06  Alan Mackenzie  <acm@muc.de>
+
+        * progmodes/cc-engine.el (c-guess-basic-syntax): Reindent.
+
 2011-03-06  Jay Belanger  <jay.p.belanger@gmail.com>
 
         * calc/calc-ext.el (calc-init-extensions):
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 654323e03e4..e84ea3c1dcd 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -8725,841 +8725,841 @@ comment at the start of cc-engine.el for more info."
 (defun c-guess-basic-syntax ()
   "Return the syntactic context of the current line."
   (save-excursion
-      (beginning-of-line)
-      (c-save-buffer-state
-          ((indent-point (point))
-           (case-fold-search nil)
-           ;; A whole ugly bunch of various temporary variables.  Have
-           ;; to declare them here since it's not possible to declare
-           ;; a variable with only the scope of a cond test and the
-           ;; following result clauses, and most of this function is a
-           ;; single gigantic cond. :P
-           literal char-before-ip before-ws-ip char-after-ip macro-start
-           in-macro-expr c-syntactic-context placeholder c-in-literal-cache
-           step-type tmpsymbol keyword injava-inher special-brace-list tmp-pos
-           containing-<
-           ;; The following record some positions for the containing
-           ;; declaration block if we're directly within one:
-           ;; `containing-decl-open' is the position of the open
-           ;; brace.  `containing-decl-start' is the start of the
-           ;; declaration.  `containing-decl-kwd' is the keyword
-           ;; symbol of the keyword that tells what kind of block it
-           ;; is.
-           containing-decl-open
-           containing-decl-start
-           containing-decl-kwd
-           ;; The open paren of the closest surrounding sexp or nil if
-           ;; there is none.
-           containing-sexp
-           ;; The position after the closest preceding brace sexp
-           ;; (nested sexps are ignored), or the position after
-           ;; `containing-sexp' if there is none, or (point-min) if
-           ;; `containing-sexp' is nil.
-           lim
-           ;; The paren state outside `containing-sexp', or at
-           ;; `indent-point' if `containing-sexp' is nil.
-           (paren-state (c-parse-state))
-           ;; There's always at most one syntactic element which got
-           ;; an anchor pos.  It's stored in syntactic-relpos.
-           syntactic-relpos
-           (c-stmt-delim-chars c-stmt-delim-chars))
-
-        ;; Check if we're directly inside an enclosing declaration
-        ;; level block.
-        (when (and (setq containing-sexp
-                         (c-most-enclosing-brace paren-state))
-                   (progn
-                     (goto-char containing-sexp)
-                     (eq (char-after) ?{))
-                   (setq placeholder
-                         (c-looking-at-decl-block
-                          (c-most-enclosing-brace paren-state
-                                                  containing-sexp)
-                          t)))
-          (setq containing-decl-open containing-sexp
-                containing-decl-start (point)
-                containing-sexp nil)
-          (goto-char placeholder)
-          (setq containing-decl-kwd (and (looking-at c-keywords-regexp)
-                                         (c-keyword-sym (match-string 1)))))
-
-        ;; Init some position variables.
-        (if c-state-cache
-            (progn
-              (setq containing-sexp (car paren-state)
-                    paren-state (cdr paren-state))
-              (if (consp containing-sexp)
-                  (progn
-                    (setq lim (cdr containing-sexp))
-                    (if (cdr c-state-cache)
-                        ;; Ignore balanced paren.  The next entry
-                        ;; can't be another one.
-                        (setq containing-sexp (car (cdr c-state-cache))
-                              paren-state (cdr paren-state))
-                      ;; If there is no surrounding open paren then
-                      ;; put the last balanced pair back on paren-state.
-                      (setq paren-state (cons containing-sexp paren-state)
-                            containing-sexp nil)))
-                (setq lim (1+ containing-sexp))))
-          (setq lim (point-min)))
-
-        ;; If we're in a parenthesis list then ',' delimits the
-        ;; "statements" rather than being an operator (with the
-        ;; exception of the "for" clause).  This difference is
-        ;; typically only noticeable when statements are used in macro
-        ;; arglists.
-        (when (and containing-sexp
-                   (eq (char-after containing-sexp) ?\())
-          (setq c-stmt-delim-chars c-stmt-delim-chars-with-comma))
-        ;; cache char before and after indent point, and move point to
-        ;; the most likely position to perform the majority of tests
-        (goto-char indent-point)
-        (c-backward-syntactic-ws lim)
-        (setq before-ws-ip (point)
-              char-before-ip (char-before))
-        (goto-char indent-point)
-        (skip-chars-forward " \t")
-        (setq char-after-ip (char-after))
-
-        ;; are we in a literal?
-        (setq literal (c-in-literal lim))
-
-        ;; now figure out syntactic qualities of the current line
-        (cond
+    (beginning-of-line)
+    (c-save-buffer-state
+        ((indent-point (point))
+         (case-fold-search nil)
+         ;; A whole ugly bunch of various temporary variables.  Have
+         ;; to declare them here since it's not possible to declare
+         ;; a variable with only the scope of a cond test and the
+         ;; following result clauses, and most of this function is a
+         ;; single gigantic cond. :P
+         literal char-before-ip before-ws-ip char-after-ip macro-start
+         in-macro-expr c-syntactic-context placeholder c-in-literal-cache
+         step-type tmpsymbol keyword injava-inher special-brace-list tmp-pos
+         containing-<
+         ;; The following record some positions for the containing
+         ;; declaration block if we're directly within one:
+         ;; `containing-decl-open' is the position of the open
+         ;; brace.  `containing-decl-start' is the start of the
+         ;; declaration.  `containing-decl-kwd' is the keyword
+         ;; symbol of the keyword that tells what kind of block it
+         ;; is.
+         containing-decl-open
+         containing-decl-start
+         containing-decl-kwd
+         ;; The open paren of the closest surrounding sexp or nil if
+         ;; there is none.
+         containing-sexp
+         ;; The position after the closest preceding brace sexp
+         ;; (nested sexps are ignored), or the position after
+         ;; `containing-sexp' if there is none, or (point-min) if
+         ;; `containing-sexp' is nil.
+         lim
+         ;; The paren state outside `containing-sexp', or at
+         ;; `indent-point' if `containing-sexp' is nil.
+         (paren-state (c-parse-state))
+         ;; There's always at most one syntactic element which got
+         ;; an anchor pos.  It's stored in syntactic-relpos.
+         syntactic-relpos
+         (c-stmt-delim-chars c-stmt-delim-chars))
+
+      ;; Check if we're directly inside an enclosing declaration
+      ;; level block.
+      (when (and (setq containing-sexp
+                       (c-most-enclosing-brace paren-state))
+                 (progn
+                   (goto-char containing-sexp)
+                   (eq (char-after) ?{))
+                 (setq placeholder
+                       (c-looking-at-decl-block
+                        (c-most-enclosing-brace paren-state
+                                                containing-sexp)
+                        t)))
+        (setq containing-decl-open containing-sexp
+              containing-decl-start (point)
+              containing-sexp nil)
+        (goto-char placeholder)
+        (setq containing-decl-kwd (and (looking-at c-keywords-regexp)
+                                       (c-keyword-sym (match-string 1)))))
+
+      ;; Init some position variables.
+      (if c-state-cache
+          (progn
+            (setq containing-sexp (car paren-state)
+                  paren-state (cdr paren-state))
+            (if (consp containing-sexp)
+                (progn
+                  (setq lim (cdr containing-sexp))
+                  (if (cdr c-state-cache)
+                      ;; Ignore balanced paren.  The next entry
+                      ;; can't be another one.
+                      (setq containing-sexp (car (cdr c-state-cache))
+                            paren-state (cdr paren-state))
+                    ;; If there is no surrounding open paren then
+                    ;; put the last balanced pair back on paren-state.
+                    (setq paren-state (cons containing-sexp paren-state)
+                          containing-sexp nil)))
+              (setq lim (1+ containing-sexp))))
+        (setq lim (point-min)))
+
+      ;; If we're in a parenthesis list then ',' delimits the
+      ;; "statements" rather than being an operator (with the
+      ;; exception of the "for" clause).  This difference is
+      ;; typically only noticeable when statements are used in macro
+      ;; arglists.
+      (when (and containing-sexp
+                 (eq (char-after containing-sexp) ?\())
+        (setq c-stmt-delim-chars c-stmt-delim-chars-with-comma))
+      ;; cache char before and after indent point, and move point to
+      ;; the most likely position to perform the majority of tests
+      (goto-char indent-point)
+      (c-backward-syntactic-ws lim)
+      (setq before-ws-ip (point)
+            char-before-ip (char-before))
+      (goto-char indent-point)
+      (skip-chars-forward " \t")
+      (setq char-after-ip (char-after))
+
+      ;; are we in a literal?
+      (setq literal (c-in-literal lim))
+
+      ;; now figure out syntactic qualities of the current line
+      (cond
 
-         ;; CASE 1: in a string.
-         ((eq literal 'string)
-          (c-add-syntax 'string (c-point 'bopl)))
-
-         ;; CASE 2: in a C or C++ style comment.
-         ((and (memq literal '(c c++))
-               ;; This is a kludge for XEmacs where we use
-               ;; `buffer-syntactic-context', which doesn't correctly
-               ;; recognize "\*/" to end a block comment.
-               ;; `parse-partial-sexp' which is used by
-               ;; `c-literal-limits' will however do that in most
-               ;; versions, which results in that we get nil from
-               ;; `c-literal-limits' even when `c-in-literal' claims
-               ;; we're inside a comment.
-               (setq placeholder (c-literal-limits lim)))
-          (c-add-syntax literal (car placeholder)))
-
-         ;; CASE 3: in a cpp preprocessor macro continuation.
-         ((and (save-excursion
-                 (when (c-beginning-of-macro)
-                   (setq macro-start (point))))
-               (/= macro-start (c-point 'boi))
-               (progn
-                 (setq tmpsymbol 'cpp-macro-cont)
-                 (or (not c-syntactic-indentation-in-macros)
-                     (save-excursion
-                       (goto-char macro-start)
-                       ;; If at the beginning of the body of a #define
-                       ;; directive then analyze as cpp-define-intro
-                       ;; only.  Go on with the syntactic analysis
-                       ;; otherwise.  in-macro-expr is set if we're in a
-                       ;; cpp expression, i.e. before the #define body
-                       ;; or anywhere in a non-#define directive.
-                       (if (c-forward-to-cpp-define-body)
-                           (let ((indent-boi (c-point 'boi indent-point)))
-                             (setq in-macro-expr (> (point) indent-boi)
-                                   tmpsymbol 'cpp-define-intro)
-                             (= (point) indent-boi))
-                         (setq in-macro-expr t)
-                         nil)))))
-          (c-add-syntax tmpsymbol macro-start)
-          (setq macro-start nil))
-
-         ;; CASE 11: an else clause?
-         ((looking-at "else\\>[^_]")
-          (c-beginning-of-statement-1 containing-sexp)
-          (c-add-stmt-syntax 'else-clause nil t
-                             containing-sexp paren-state))
+       ;; CASE 1: in a string.
+       ((eq literal 'string)
+        (c-add-syntax 'string (c-point 'bopl)))
+
+       ;; CASE 2: in a C or C++ style comment.
+       ((and (memq literal '(c c++))
+             ;; This is a kludge for XEmacs where we use
+             ;; `buffer-syntactic-context', which doesn't correctly
+             ;; recognize "\*/" to end a block comment.
+             ;; `parse-partial-sexp' which is used by
+             ;; `c-literal-limits' will however do that in most
+             ;; versions, which results in that we get nil from
+             ;; `c-literal-limits' even when `c-in-literal' claims
+             ;; we're inside a comment.
+             (setq placeholder (c-literal-limits lim)))
+        (c-add-syntax literal (car placeholder)))
+
+       ;; CASE 3: in a cpp preprocessor macro continuation.
+       ((and (save-excursion
+               (when (c-beginning-of-macro)
+                 (setq macro-start (point))))
+             (/= macro-start (c-point 'boi))
+             (progn
+               (setq tmpsymbol 'cpp-macro-cont)
+               (or (not c-syntactic-indentation-in-macros)
+                   (save-excursion
+                     (goto-char macro-start)
+                     ;; If at the beginning of the body of a #define
+                     ;; directive then analyze as cpp-define-intro
+                     ;; only.  Go on with the syntactic analysis
+                     ;; otherwise.  in-macro-expr is set if we're in a
+                     ;; cpp expression, i.e. before the #define body
+                     ;; or anywhere in a non-#define directive.
+                     (if (c-forward-to-cpp-define-body)
+                         (let ((indent-boi (c-point 'boi indent-point)))
+                           (setq in-macro-expr (> (point) indent-boi)
+                                 tmpsymbol 'cpp-define-intro)
+                           (= (point) indent-boi))
+                       (setq in-macro-expr t)
+                       nil)))))
+        (c-add-syntax tmpsymbol macro-start)
+        (setq macro-start nil))
+
+       ;; CASE 11: an else clause?
+       ((looking-at "else\\>[^_]")
+        (c-beginning-of-statement-1 containing-sexp)
+        (c-add-stmt-syntax 'else-clause nil t
+                           containing-sexp paren-state))
 
-         ;; CASE 12: while closure of a do/while construct?
-         ((and (looking-at "while\\>[^_]")
-               (save-excursion
-                 (prog1 (eq (c-beginning-of-statement-1 containing-sexp)
-                            'beginning)
-                   (setq placeholder (point)))))
-          (goto-char placeholder)
-          (c-add-stmt-syntax 'do-while-closure nil t
-                             containing-sexp paren-state))
+       ;; CASE 12: while closure of a do/while construct?
+       ((and (looking-at "while\\>[^_]")
+             (save-excursion
+               (prog1 (eq (c-beginning-of-statement-1 containing-sexp)
+                          'beginning)
+                 (setq placeholder (point)))))
+        (goto-char placeholder)
+        (c-add-stmt-syntax 'do-while-closure nil t
+                           containing-sexp paren-state))
 
-         ;; CASE 13: A catch or finally clause?  This case is simpler
-         ;; than if-else and do-while, because a block is required
-         ;; after every try, catch and finally.
-         ((save-excursion
-            (and (cond ((c-major-mode-is 'c++-mode)
-                        (looking-at "catch\\>[^_]"))
-                       ((c-major-mode-is 'java-mode)
-                        (looking-at "\\(catch\\|finally\\)\\>[^_]")))
-                 (and (c-safe (c-backward-syntactic-ws)
-                              (c-backward-sexp)
-                              t)
-                      (eq (char-after) ?{)
-                      (c-safe (c-backward-syntactic-ws)
-                              (c-backward-sexp)
-                              t)
-                      (if (eq (char-after) ?\()
-                          (c-safe (c-backward-sexp) t)
-                        t))
-                 (looking-at "\\(try\\|catch\\)\\>[^_]")
-                 (setq placeholder (point))))
-          (goto-char placeholder)
-          (c-add-stmt-syntax 'catch-clause nil t
-                             containing-sexp paren-state))
+       ;; CASE 13: A catch or finally clause?  This case is simpler
+       ;; than if-else and do-while, because a block is required
+       ;; after every try, catch and finally.
+       ((save-excursion
+          (and (cond ((c-major-mode-is 'c++-mode)
+                      (looking-at "catch\\>[^_]"))
+                     ((c-major-mode-is 'java-mode)
+                      (looking-at "\\(catch\\|finally\\)\\>[^_]")))
+               (and (c-safe (c-backward-syntactic-ws)
+                            (c-backward-sexp)
+                            t)
+                    (eq (char-after) ?{)
+                    (c-safe (c-backward-syntactic-ws)
+                            (c-backward-sexp)
+                            t)
+                    (if (eq (char-after) ?\()
+                        (c-safe (c-backward-sexp) t)
+                      t))
+               (looking-at "\\(try\\|catch\\)\\>[^_]")
+               (setq placeholder (point))))
+        (goto-char placeholder)
+        (c-add-stmt-syntax 'catch-clause nil t
+                           containing-sexp paren-state))
 
-         ;; CASE 18: A substatement we can recognize by keyword.
-         ((save-excursion
-            (and c-opt-block-stmt-key
-                 (not (eq char-before-ip ?\;))
-                 (not (c-at-vsemi-p before-ws-ip))
-                 (not (memq char-after-ip '(?\) ?\] ?,)))
-                 (or (not (eq char-before-ip ?}))
-                     (c-looking-at-inexpr-block-backward c-state-cache))
-                 (> (point)
-                    (progn
-                      ;; Ought to cache the result from the
-                      ;; c-beginning-of-statement-1 calls here.
+       ;; CASE 18: A substatement we can recognize by keyword.
+       ((save-excursion
+          (and c-opt-block-stmt-key
+               (not (eq char-before-ip ?\;))
+               (not (c-at-vsemi-p before-ws-ip))
+               (not (memq char-after-ip '(?\) ?\] ?,)))
+               (or (not (eq char-before-ip ?}))
+                   (c-looking-at-inexpr-block-backward c-state-cache))
+               (> (point)
+                  (progn
+                    ;; Ought to cache the result from the
+                    ;; c-beginning-of-statement-1 calls here.
+                    (setq placeholder (point))
+                    (while (eq (setq step-type
+                                     (c-beginning-of-statement-1 lim))
+                               'label))
+                    (if (eq step-type 'previous)
+                        (goto-char placeholder)
                       (setq placeholder (point))
-                      (while (eq (setq step-type
-                                       (c-beginning-of-statement-1 lim))
-                                 'label))
-                      (if (eq step-type 'previous)
-                          (goto-char placeholder)
-                        (setq placeholder (point))
-                        (if (and (eq step-type 'same)
-                                 (not (looking-at c-opt-block-stmt-key)))
-                            ;; Step up to the containing statement if we
-                            ;; stayed in the same one.
-                            (let (step)
-                              (while (eq
-                                      (setq step
-                                            (c-beginning-of-statement-1 lim))
-                                      'label))
-                              (if (eq step 'up)
-                                  (setq placeholder (point))
-                                ;; There was no containing statement afterall.
-                                (goto-char placeholder)))))
-                      placeholder))
-                 (if (looking-at c-block-stmt-2-key)
-                     ;; Require a parenthesis after these keywords.
-                     ;; Necessary to catch e.g. synchronized in Java,
-                     ;; which can be used both as statement and
-                     ;; modifier.
-                     (and (zerop (c-forward-token-2 1 nil))
-                          (eq (char-after) ?\())
-                   (looking-at c-opt-block-stmt-key))))
-
-          (if (eq step-type 'up)
-              ;; CASE 18A: Simple substatement.
-              (progn
-                (goto-char placeholder)
-                (cond
-                 ((eq char-after-ip ?{)
-                  (c-add-stmt-syntax 'substatement-open nil nil
-                                     containing-sexp paren-state))
-                 ((save-excursion
-                    (goto-char indent-point)
-                    (back-to-indentation)
-                    (c-forward-label))
-                  (c-add-stmt-syntax 'substatement-label nil nil
-                                     containing-sexp paren-state))
-                 (t
-                  (c-add-stmt-syntax 'substatement nil nil
-                                     containing-sexp paren-state))))
-
-            ;; CASE 18B: Some other substatement.  This is shared
-            ;; with case 10.
-            (c-guess-continued-construct indent-point
-                                         char-after-ip
-                                         placeholder
-                                         lim
-                                         paren-state)))
-
-         ;; CASE 14: A case or default label
-         ((looking-at c-label-kwds-regexp)
-          (if containing-sexp
-              (progn
-                (goto-char containing-sexp)
-                (setq lim (c-most-enclosing-brace c-state-cache
-                                                  containing-sexp))
-                (c-backward-to-block-anchor lim)
-                (c-add-stmt-syntax 'case-label nil t lim paren-state))
-            ;; Got a bogus label at the top level.  In lack of better
-            ;; alternatives, anchor it on (point-min).
-            (c-add-syntax 'case-label (point-min))))
-
-         ;; CASE 15: any other label
-         ((save-excursion
-            (back-to-indentation)
-            (and (not (looking-at c-syntactic-ws-start))
-                 (c-forward-label)))
-          (cond (containing-decl-open
-                 (setq placeholder (c-add-class-syntax 'inclass
-                                                       containing-decl-open
-                                                       containing-decl-start
-                                                       containing-decl-kwd
-                                                       paren-state))
-                 ;; Append access-label with the same anchor point as
-                 ;; inclass gets.
-                 (c-append-syntax 'access-label placeholder))
-
-                (containing-sexp
-                 (goto-char containing-sexp)
-                 (setq lim (c-most-enclosing-brace c-state-cache
-                                                   containing-sexp))
-                 (save-excursion
-                   (setq tmpsymbol
-                         (if (and (eq (c-beginning-of-statement-1 lim) 'up)
-                                  (looking-at "switch\\>[^_]"))
-                             ;; If the surrounding statement is a switch then
-                             ;; let's analyze all labels as switch labels, so
-                             ;; that they get lined up consistently.
-                             'case-label
-                           'label)))
-                 (c-backward-to-block-anchor lim)
-                 (c-add-stmt-syntax tmpsymbol nil t lim paren-state))
+                      (if (and (eq step-type 'same)
+                               (not (looking-at c-opt-block-stmt-key)))
+                          ;; Step up to the containing statement if we
+                          ;; stayed in the same one.
+                          (let (step)
+                            (while (eq
+                                    (setq step
+                                          (c-beginning-of-statement-1 lim))
+                                    'label))
+                            (if (eq step 'up)
+                                (setq placeholder (point))
+                              ;; There was no containing statement afterall.
+                              (goto-char placeholder)))))
+                    placeholder))
+               (if (looking-at c-block-stmt-2-key)
+                   ;; Require a parenthesis after these keywords.
+                   ;; Necessary to catch e.g. synchronized in Java,
+                   ;; which can be used both as statement and
+                   ;; modifier.
+                   (and (zerop (c-forward-token-2 1 nil))
+                        (eq (char-after) ?\())
+                 (looking-at c-opt-block-stmt-key))))
+
+        (if (eq step-type 'up)
+            ;; CASE 18A: Simple substatement.
+            (progn
+              (goto-char placeholder)
+              (cond
+               ((eq char-after-ip ?{)
+                (c-add-stmt-syntax 'substatement-open nil nil
+                                   containing-sexp paren-state))
+               ((save-excursion
+                  (goto-char indent-point)
+                  (back-to-indentation)
+                  (c-forward-label))
+                (c-add-stmt-syntax 'substatement-label nil nil
+                                   containing-sexp paren-state))
+               (t
+                (c-add-stmt-syntax 'substatement nil nil
+                                   containing-sexp paren-state))))
+
+          ;; CASE 18B: Some other substatement.  This is shared
+          ;; with case 10.
+          (c-guess-continued-construct indent-point
+                                       char-after-ip
+                                       placeholder
+                                       lim
+                                       paren-state)))
 
-                (t
-                 ;; A label on the top level.  Treat it as a class
-                 ;; context.  (point-min) is the closest we get to the
-                 ;; class open brace.
-                 (c-add-syntax 'access-label (point-min)))))
+       ;; CASE 14: A case or default label
+       ((looking-at c-label-kwds-regexp)
+        (if containing-sexp
+            (progn
+              (goto-char containing-sexp)
+              (setq lim (c-most-enclosing-brace c-state-cache
+                                                containing-sexp))
+              (c-backward-to-block-anchor lim)
+              (c-add-stmt-syntax 'case-label nil t lim paren-state))
+          ;; Got a bogus label at the top level.  In lack of better
+          ;; alternatives, anchor it on (point-min).
+          (c-add-syntax 'case-label (point-min))))
 
-         ;; CASE 4: In-expression statement.  C.f. cases 7B, 16A and
-         ;; 17E.
-         ((setq placeholder (c-looking-at-inexpr-block
-                             (c-safe-position containing-sexp paren-state)
-                             containing-sexp
-                             ;; Have to turn on the heuristics after
-                             ;; the point even though it doesn't work
-                             ;; very well.  C.f. test case class-16.pike.
-                             t))
-          (setq tmpsymbol (assq (car placeholder)
-                                '((inexpr-class . class-open)
-                                  (inexpr-statement . block-open))))
-          (if tmpsymbol
-              ;; It's a statement block or an anonymous class.
-              (setq tmpsymbol (cdr tmpsymbol))
-            ;; It's a Pike lambda.  Check whether we are between the
-            ;; lambda keyword and the argument list or at the defun
-            ;; opener.
-            (setq tmpsymbol (if (eq char-after-ip ?{)
-                                'inline-open
-                              'lambda-intro-cont)))
-          (goto-char (cdr placeholder))
+       ;; CASE 15: any other label
+       ((save-excursion
           (back-to-indentation)
-          (c-add-stmt-syntax tmpsymbol nil t
-                             (c-most-enclosing-brace c-state-cache (point))
-                             paren-state)
-          (unless (eq (point) (cdr placeholder))
-            (c-add-syntax (car placeholder))))
-
-         ;; CASE 5: Line is inside a declaration level block or at top level.
-         ((or containing-decl-open (null containing-sexp))
-          (cond
-
-           ;; CASE 5A: we are looking at a defun, brace list, class,
-           ;; or inline-inclass method opening brace
-           ((setq special-brace-list
-                  (or (and c-special-brace-lists
-                           (c-looking-at-special-brace-list))
-                      (eq char-after-ip ?{)))
-            (cond
+          (and (not (looking-at c-syntactic-ws-start))
+               (c-forward-label)))
+        (cond (containing-decl-open
+               (setq placeholder (c-add-class-syntax 'inclass
+                                                     containing-decl-open
+                                                     containing-decl-start
+                                                     containing-decl-kwd
+                                                     paren-state))
+               ;; Append access-label with the same anchor point as
+               ;; inclass gets.
+               (c-append-syntax 'access-label placeholder))
+
+              (containing-sexp
+               (goto-char containing-sexp)
+               (setq lim (c-most-enclosing-brace c-state-cache
+                                                 containing-sexp))
+               (save-excursion
+                 (setq tmpsymbol
+                       (if (and (eq (c-beginning-of-statement-1 lim) 'up)
+                                (looking-at "switch\\>[^_]"))
+                           ;; If the surrounding statement is a switch then
+                           ;; let's analyze all labels as switch labels, so
+                           ;; that they get lined up consistently.
+                           'case-label
+                         'label)))
+               (c-backward-to-block-anchor lim)
+               (c-add-stmt-syntax tmpsymbol nil t lim paren-state))
 
-             ;; CASE 5A.1: Non-class declaration block open.
-             ((save-excursion
-                (let (tmp)
-                  (and (eq char-after-ip ?{)
-                       (setq tmp (c-looking-at-decl-block containing-sexp t))
-                       (progn
-                         (setq placeholder (point))
-                         (goto-char tmp)
-                         (looking-at c-symbol-key))
-                       (c-keyword-member
-                        (c-keyword-sym (setq keyword (match-string 0)))
-                        'c-other-block-decl-kwds))))
-              (goto-char placeholder)
-              (c-add-stmt-syntax
-               (if (string-equal keyword "extern")
-                   ;; Special case for extern-lang-open.
-                   'extern-lang-open
-                 (intern (concat keyword "-open")))
-               nil t containing-sexp paren-state))
-
-             ;; CASE 5A.2: we are looking at a class opening brace
-             ((save-excursion
-                (goto-char indent-point)
-                (skip-chars-forward " \t")
-                (and (eq (char-after) ?{)
-                     (c-looking-at-decl-block containing-sexp t)
-                     (setq placeholder (point))))
-              (c-add-syntax 'class-open placeholder))
-
-             ;; CASE 5A.3: brace list open
-             ((save-excursion
-                (c-beginning-of-decl-1 lim)
-                (while (looking-at c-specifier-key)
-                  (goto-char (match-end 1))
-                  (c-forward-syntactic-ws indent-point))
-                (setq placeholder (c-point 'boi))
-                (or (consp special-brace-list)
-                    (and (or (save-excursion
-                               (goto-char indent-point)
-                               (setq tmpsymbol nil)
-                               (while (and (> (point) placeholder)
-                                           (zerop (c-backward-token-2 1 t))
-                                           (/= (char-after) ?=))
-                                 (and c-opt-inexpr-brace-list-key
-                                      (not tmpsymbol)
-                                      (looking-at c-opt-inexpr-brace-list-key)
-                                      (setq tmpsymbol 'topmost-intro-cont)))
-                               (eq (char-after) ?=))
-                             (looking-at c-brace-list-key))
-                         (save-excursion
-                           (while (and (< (point) indent-point)
-                                       (zerop (c-forward-token-2 1 t))
-                                       (not (memq (char-after) '(?\; ?\()))))
-                           (not (memq (char-after) '(?\; ?\()))
-                           ))))
-              (if (and (not c-auto-newline-analysis)
-                       (c-major-mode-is 'java-mode)
-                       (eq tmpsymbol 'topmost-intro-cont))
-                  ;; We're in Java and have found that the open brace
-                  ;; belongs to a "new Foo[]" initialization list,
-                  ;; which means the brace list is part of an
-                  ;; expression and not a top level definition.  We
-                  ;; therefore treat it as any topmost continuation
-                  ;; even though the semantically correct symbol still
-                  ;; is brace-list-open, on the same grounds as in
-                  ;; case B.2.
-                  (progn
-                    (c-beginning-of-statement-1 lim)
-                    (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
-                (c-add-syntax 'brace-list-open placeholder)))
-
-             ;; CASE 5A.4: inline defun open
-             ((and containing-decl-open
-                   (not (c-keyword-member containing-decl-kwd
-                                          'c-other-block-decl-kwds)))
-              (c-add-syntax 'inline-open)
-              (c-add-class-syntax 'inclass
-                                  containing-decl-open
-                                  containing-decl-start
-                                  containing-decl-kwd
-                                  paren-state))
-
-             ;; CASE 5A.5: ordinary defun open
-             (t
-              (save-excursion
-                (c-beginning-of-decl-1 lim)
-                (while (looking-at c-specifier-key)
-                  (goto-char (match-end 1))
-                  (c-forward-syntactic-ws indent-point))
-                (c-add-syntax 'defun-open (c-point 'boi))
-                ;; Bogus to use bol here, but it's the legacy.  (Resolved,
-                ;; 2007-11-09)
-                ))))
-
-           ;; CASE 5B: After a function header but before the body (or
-           ;; the ending semicolon if there's no body).
-           ((save-excursion
-              (when (setq placeholder (c-just-after-func-arglist-p lim))
-                (setq tmp-pos (point))))
-            (cond
+              (t
+               ;; A label on the top level.  Treat it as a class
+               ;; context.  (point-min) is the closest we get to the
+               ;; class open brace.
+               (c-add-syntax 'access-label (point-min)))))
+
+       ;; CASE 4: In-expression statement.  C.f. cases 7B, 16A and
+       ;; 17E.
+       ((setq placeholder (c-looking-at-inexpr-block
+                           (c-safe-position containing-sexp paren-state)
+                           containing-sexp
+                           ;; Have to turn on the heuristics after
+                           ;; the point even though it doesn't work
+                           ;; very well.  C.f. test case class-16.pike.
+                           t))
+        (setq tmpsymbol (assq (car placeholder)
+                              '((inexpr-class . class-open)
+                                (inexpr-statement . block-open))))
+        (if tmpsymbol
+            ;; It's a statement block or an anonymous class.
+            (setq tmpsymbol (cdr tmpsymbol))
+          ;; It's a Pike lambda.  Check whether we are between the
+          ;; lambda keyword and the argument list or at the defun
+          ;; opener.
+          (setq tmpsymbol (if (eq char-after-ip ?{)
+                              'inline-open
+                            'lambda-intro-cont)))
+        (goto-char (cdr placeholder))
+        (back-to-indentation)
+        (c-add-stmt-syntax tmpsymbol nil t
+                           (c-most-enclosing-brace c-state-cache (point))
+                           paren-state)
+        (unless (eq (point) (cdr placeholder))
+          (c-add-syntax (car placeholder))))
 
-             ;; CASE 5B.1: Member init list.
-             ((eq (char-after tmp-pos) ?:)
-              (if (or (> tmp-pos indent-point)
-                      (= (c-point 'bosws) (1+ tmp-pos)))
-                  (progn
-                    ;; There is no preceding member init clause.
-                    ;; Indent relative to the beginning of indentation
-                    ;; for the topmost-intro line that contains the
-                    ;; prototype's open paren.
-                    (goto-char placeholder)
-                    (c-add-syntax 'member-init-intro (c-point 'boi)))
-                ;; Indent relative to the first member init clause.
-                (goto-char (1+ tmp-pos))
-                (c-forward-syntactic-ws)
-                (c-add-syntax 'member-init-cont (point))))
+       ;; CASE 5: Line is inside a declaration level block or at top level.
+       ((or containing-decl-open (null containing-sexp))
+        (cond
 
-             ;; CASE 5B.2: K&R arg decl intro
-             ((and c-recognize-knr-p
-                   (c-in-knr-argdecl lim))
-              (c-beginning-of-statement-1 lim)
-              (c-add-syntax 'knr-argdecl-intro (c-point 'boi))
-              (if containing-decl-open
-                  (c-add-class-syntax 'inclass
-                                      containing-decl-open
-                                      containing-decl-start
-                                      containing-decl-kwd
-                                      paren-state)))
-
-             ;; CASE 5B.4: Nether region after a C++ or Java func
-             ;; decl, which could include a `throws' declaration.
-             (t
-              (c-beginning-of-statement-1 lim)
-              (c-add-syntax 'func-decl-cont (c-point 'boi))
-              )))
+         ;; CASE 5A: we are looking at a defun, brace list, class,
+         ;; or inline-inclass method opening brace
+         ((setq special-brace-list
+                (or (and c-special-brace-lists
+                         (c-looking-at-special-brace-list))
+                    (eq char-after-ip ?{)))
+          (cond
 
-           ;; CASE 5C: inheritance line. could be first inheritance
-           ;; line, or continuation of a multiple inheritance
-           ((or (and (c-major-mode-is 'c++-mode)
+           ;; CASE 5A.1: Non-class declaration block open.
+           ((save-excursion
+              (let (tmp)
+                (and (eq char-after-ip ?{)
+                     (setq tmp (c-looking-at-decl-block containing-sexp t))
                      (progn
-                       (when (eq char-after-ip ?,)
-                         (skip-chars-forward " \t")
-                         (forward-char))
-                       (looking-at c-opt-postfix-decl-spec-key)))
-                (and (or (eq char-before-ip ?:)
-                         ;; watch out for scope operator
-                         (save-excursion
-                           (and (eq char-after-ip ?:)
-                                (c-safe (forward-char 1) t)
-                                (not (eq (char-after) ?:))
-                                )))
-                     (save-excursion
-                       (c-backward-syntactic-ws lim)
-                       (if (eq char-before-ip ?:)
-                           (progn
-                             (forward-char -1)
-                             (c-backward-syntactic-ws lim)))
-                       (back-to-indentation)
-                       (looking-at c-class-key)))
-                ;; for Java
-                (and (c-major-mode-is 'java-mode)
-                     (let ((fence (save-excursion
-                                    (c-beginning-of-statement-1 lim)
-                                    (point)))
-                           cont done)
-                       (save-excursion
-                         (while (not done)
-                           (cond ((looking-at c-opt-postfix-decl-spec-key)
-                                  (setq injava-inher (cons cont (point))
-                                        done t))
-                                 ((or (not (c-safe (c-forward-sexp -1) t))
-                                      (<= (point) fence))
-                                  (setq done t))
-                                 )
-                           (setq cont t)))
-                       injava-inher)
-                     (not (c-crosses-statement-barrier-p (cdr injava-inher)
-                                                         (point)))
-                     ))
-            (cond
-
-             ;; CASE 5C.1: non-hanging colon on an inher intro
-             ((eq char-after-ip ?:)
-              (c-beginning-of-statement-1 lim)
-              (c-add-syntax 'inher-intro (c-point 'boi))
-              ;; don't add inclass symbol since relative point already
-              ;; contains any class offset
-              )
+                       (setq placeholder (point))
+                       (goto-char tmp)
+                       (looking-at c-symbol-key))
+                     (c-keyword-member
+                      (c-keyword-sym (setq keyword (match-string 0)))
+                      'c-other-block-decl-kwds))))
+            (goto-char placeholder)
+            (c-add-stmt-syntax
+             (if (string-equal keyword "extern")
+                 ;; Special case for extern-lang-open.
+                 'extern-lang-open
+               (intern (concat keyword "-open")))
+             nil t containing-sexp paren-state))
 
-             ;; CASE 5C.2: hanging colon on an inher intro
-             ((eq char-before-ip ?:)
-              (c-beginning-of-statement-1 lim)
-              (c-add-syntax 'inher-intro (c-point 'boi))
-              (if containing-decl-open
-                  (c-add-class-syntax 'inclass
-                                      containing-decl-open
-                                      containing-decl-start
-                                      containing-decl-kwd
-                                      paren-state)))
-
-             ;; CASE 5C.3: in a Java implements/extends
-             (injava-inher
-              (let ((where (cdr injava-inher))
-                    (cont (car injava-inher)))
-                (goto-char where)
-                (cond ((looking-at "throws\\>[^_]")
-                       (c-add-syntax 'func-decl-cont
-                                     (progn (c-beginning-of-statement-1 lim)
-                                            (c-point 'boi))))
-                      (cont (c-add-syntax 'inher-cont where))
-                      (t (c-add-syntax 'inher-intro
-                                       (progn (goto-char (cdr injava-inher))
-                                              (c-beginning-of-statement-1 lim)
-                                              (point))))
-                      )))
-
-             ;; CASE 5C.4: a continued inheritance line
-             (t
-              (c-beginning-of-inheritance-list lim)
-              (c-add-syntax 'inher-cont (point))
-              ;; don't add inclass symbol since relative point already
-              ;; contains any class offset
-              )))
-
-           ;; CASE 5D: this could be a top-level initialization, a
-           ;; member init list continuation, or a template argument
-           ;; list continuation.
+           ;; CASE 5A.2: we are looking at a class opening brace
            ((save-excursion
-              ;; Note: We use the fact that lim is always after any
-              ;; preceding brace sexp.
-              (if c-recognize-<>-arglists
-                  (while (and
-                          (progn
-                            (c-syntactic-skip-backward "^;,=<>" lim t)
-                            (> (point) lim))
-                          (or
-                           (when c-overloadable-operators-regexp
-                             (when (setq placeholder (c-after-special-operator-id lim))
-                               (goto-char placeholder)
-                               t))
-                           (cond
-                            ((eq (char-before) ?>)
-                             (or (c-backward-<>-arglist nil lim)
-                                 (backward-char))
-                             t)
-                            ((eq (char-before) ?<)
-                             (backward-char)
-                             (if (save-excursion
-                                   (c-forward-<>-arglist nil))
-                                 (progn (forward-char)
-                                        nil)
-                               t))
-                            (t nil)))))
-                ;; NB: No c-after-special-operator-id stuff in this
-                ;; clause - we assume only C++ needs it.
-                (c-syntactic-skip-backward "^;,=" lim t))
-              (memq (char-before) '(?, ?= ?<)))
-            (cond
-
-             ;; CASE 5D.3: perhaps a template list continuation?
-             ((and (c-major-mode-is 'c++-mode)
-                   (save-excursion
-                     (save-restriction
-                       (c-with-syntax-table c++-template-syntax-table
-                         (goto-char indent-point)
-                         (setq placeholder (c-up-list-backward))
-                         (and placeholder
-                              (eq (char-after placeholder) ?<))))))
-              (c-with-syntax-table c++-template-syntax-table
-                (goto-char placeholder)
-                (c-beginning-of-statement-1 lim t)
-                (if (save-excursion
-                      (c-backward-syntactic-ws lim)
-                      (eq (char-before) ?<))
-                    ;; In a nested template arglist.
-                    (progn
-                      (goto-char placeholder)
-                      (c-syntactic-skip-backward "^,;" lim t)
-                      (c-forward-syntactic-ws))
-                  (back-to-indentation)))
-              ;; FIXME: Should use c-add-stmt-syntax, but it's not yet
-              ;; template aware.
-              (c-add-syntax 'template-args-cont (point) placeholder))
-
-             ;; CASE 5D.4: perhaps a multiple inheritance line?
-             ((and (c-major-mode-is 'c++-mode)
-                   (save-excursion
-                     (c-beginning-of-statement-1 lim)
-                     (setq placeholder (point))
-                     (if (looking-at "static\\>[^_]")
-                         (c-forward-token-2 1 nil indent-point))
-                     (and (looking-at c-class-key)
-                          (zerop (c-forward-token-2 2 nil indent-point))
-                          (if (eq (char-after) ?<)
-                              (c-with-syntax-table c++-template-syntax-table
-                                (zerop (c-forward-token-2 1 t indent-point)))
-                            t)
-                          (eq (char-after) ?:))))
-              (goto-char placeholder)
-              (c-add-syntax 'inher-cont (c-point 'boi)))
-
-             ;; CASE 5D.5: Continuation of the "expression part" of a
-             ;; top level construct.  Or, perhaps, an unrecognised construct.
-             (t
-              (while (and (setq placeholder (point))
-                          (eq (car (c-beginning-of-decl-1 containing-sexp))
-                              'same)
-                          (save-excursion
-                            (c-backward-syntactic-ws)
-                            (eq (char-before) ?}))
-                          (< (point) placeholder)))
-              (c-add-stmt-syntax
-               (cond
-                ((eq (point) placeholder) 'statement) ; unrecognised construct
-                   ;; A preceding comma at the top level means that a
-                   ;; new variable declaration starts here.  Use
-                   ;; topmost-intro-cont for it, for consistency with
-                   ;; the first variable declaration.  C.f. case 5N.
-                ((eq char-before-ip ?,) 'topmost-intro-cont)
-                (t 'statement-cont))
-               nil nil containing-sexp paren-state))
-             ))
-
-           ;; CASE 5F: Close of a non-class declaration level block.
-           ((and (eq char-after-ip ?})
-                 (c-keyword-member containing-decl-kwd
-                                   'c-other-block-decl-kwds))
-            ;; This is inconsistent: Should use `containing-decl-open'
-            ;; here if it's at boi, like in case 5J.
-            (goto-char containing-decl-start)
-            (c-add-stmt-syntax
-              (if (string-equal (symbol-name containing-decl-kwd) "extern")
-                  ;; Special case for compatibility with the
-                  ;; extern-lang syntactic symbols.
-                  'extern-lang-close
-                (intern (concat (symbol-name containing-decl-kwd)
-                                "-close")))
-              nil t
-              (c-most-enclosing-brace paren-state (point))
-              paren-state))
-
-           ;; CASE 5G: we are looking at the brace which closes the
-           ;; enclosing nested class decl
-           ((and containing-sexp
-                 (eq char-after-ip ?})
-                 (eq containing-decl-open containing-sexp))
-            (c-add-class-syntax 'class-close
+              (goto-char indent-point)
+              (skip-chars-forward " \t")
+              (and (eq (char-after) ?{)
+                   (c-looking-at-decl-block containing-sexp t)
+                   (setq placeholder (point))))
+            (c-add-syntax 'class-open placeholder))
+
+           ;; CASE 5A.3: brace list open
+           ((save-excursion
+              (c-beginning-of-decl-1 lim)
+              (while (looking-at c-specifier-key)
+                (goto-char (match-end 1))
+                (c-forward-syntactic-ws indent-point))
+              (setq placeholder (c-point 'boi))
+              (or (consp special-brace-list)
+                  (and (or (save-excursion
+                             (goto-char indent-point)
+                             (setq tmpsymbol nil)
+                             (while (and (> (point) placeholder)
+                                         (zerop (c-backward-token-2 1 t))
+                                         (/= (char-after) ?=))
+                               (and c-opt-inexpr-brace-list-key
+                                    (not tmpsymbol)
+                                    (looking-at c-opt-inexpr-brace-list-key)
+                                    (setq tmpsymbol 'topmost-intro-cont)))
+                             (eq (char-after) ?=))
+                           (looking-at c-brace-list-key))
+                       (save-excursion
+                         (while (and (< (point) indent-point)
+                                     (zerop (c-forward-token-2 1 t))
+                                     (not (memq (char-after) '(?\; ?\()))))
+                         (not (memq (char-after) '(?\; ?\()))
+                         ))))
+            (if (and (not c-auto-newline-analysis)
+                     (c-major-mode-is 'java-mode)
+                     (eq tmpsymbol 'topmost-intro-cont))
+                ;; We're in Java and have found that the open brace
+                ;; belongs to a "new Foo[]" initialization list,
+                ;; which means the brace list is part of an
+                ;; expression and not a top level definition.  We
+                ;; therefore treat it as any topmost continuation
+                ;; even though the semantically correct symbol still
+                ;; is brace-list-open, on the same grounds as in
+                ;; case B.2.
+                (progn
+                  (c-beginning-of-statement-1 lim)
+                  (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
+              (c-add-syntax 'brace-list-open placeholder)))
+
+           ;; CASE 5A.4: inline defun open
+           ((and containing-decl-open
+                 (not (c-keyword-member containing-decl-kwd
+                                        'c-other-block-decl-kwds)))
+            (c-add-syntax 'inline-open)
+            (c-add-class-syntax 'inclass
                                 containing-decl-open
                                 containing-decl-start
                                 containing-decl-kwd
                                 paren-state))
 
-           ;; CASE 5H: we could be looking at subsequent knr-argdecls
+           ;; CASE 5A.5: ordinary defun open
+           (t
+            (save-excursion
+              (c-beginning-of-decl-1 lim)
+              (while (looking-at c-specifier-key)
+                (goto-char (match-end 1))
+                (c-forward-syntactic-ws indent-point))
+              (c-add-syntax 'defun-open (c-point 'boi))
+              ;; Bogus to use bol here, but it's the legacy.  (Resolved,
+              ;; 2007-11-09)
+              ))))
+
+         ;; CASE 5B: After a function header but before the body (or
+         ;; the ending semicolon if there's no body).
+         ((save-excursion
+            (when (setq placeholder (c-just-after-func-arglist-p lim))
+              (setq tmp-pos (point))))
+          (cond
+
+           ;; CASE 5B.1: Member init list.
+           ((eq (char-after tmp-pos) ?:)
+            (if (or (> tmp-pos indent-point)
+                    (= (c-point 'bosws) (1+ tmp-pos)))
+                (progn
+                  ;; There is no preceding member init clause.
+                  ;; Indent relative to the beginning of indentation
+                  ;; for the topmost-intro line that contains the
+                  ;; prototype's open paren.
+                  (goto-char placeholder)
+                  (c-add-syntax 'member-init-intro (c-point 'boi)))
+              ;; Indent relative to the first member init clause.
+              (goto-char (1+ tmp-pos))
+              (c-forward-syntactic-ws)
+              (c-add-syntax 'member-init-cont (point))))
+
+           ;; CASE 5B.2: K&R arg decl intro
            ((and c-recognize-knr-p
-                 (not containing-sexp)  ; can't be knr inside braces.
-                 (not (eq char-before-ip ?}))
-                 (save-excursion
-                   (setq placeholder (cdr (c-beginning-of-decl-1 lim)))
-                   (and placeholder
-                        ;; Do an extra check to avoid tripping up on
-                        ;; statements that occur in invalid contexts
-                        ;; (e.g. in macro bodies where we don't really
-                        ;; know the context of what we're looking at).
-                        (not (and c-opt-block-stmt-key
-                                  (looking-at c-opt-block-stmt-key)))))
-                 (< placeholder indent-point))
-            (goto-char placeholder)
-            (c-add-syntax 'knr-argdecl (point)))
-
-           ;; CASE 5I: ObjC method definition.
-           ((and c-opt-method-key
-                 (looking-at c-opt-method-key))
-            (c-beginning-of-statement-1 nil t)
-            (if (= (point) indent-point)
-                ;; Handle the case when it's the first (non-comment)
-                ;; thing in the buffer.  Can't look for a 'same return
-                ;; value from cbos1 since ObjC directives currently
-                ;; aren't recognized fully, so that we get 'same
-                ;; instead of 'previous if it moved over a preceding
-                ;; directive.
-                (goto-char (point-min)))
-            (c-add-syntax 'objc-method-intro (c-point 'boi)))
-
-           ;; CASE 5P: AWK pattern or function or continuation
-           ;; thereof.
-           ((c-major-mode-is 'awk-mode)
-            (setq placeholder (point))
-            (c-add-stmt-syntax
-             (if (and (eq (c-beginning-of-statement-1) 'same)
-                      (/= (point) placeholder))
-                 'topmost-intro-cont
-               'topmost-intro)
-             nil nil
-             containing-sexp paren-state))
-
-           ;; CASE 5N: At a variable declaration that follows a class
-           ;; definition or some other block declaration that doesn't
-           ;; end at the closing '}'.  C.f. case 5D.5.
-           ((progn
-              (c-backward-syntactic-ws lim)
-              (and (eq (char-before) ?})
+                 (c-in-knr-argdecl lim))
+            (c-beginning-of-statement-1 lim)
+            (c-add-syntax 'knr-argdecl-intro (c-point 'boi))
+            (if containing-decl-open
+                (c-add-class-syntax 'inclass
+                                    containing-decl-open
+                                    containing-decl-start
+                                    containing-decl-kwd
+                                    paren-state)))
+
+           ;; CASE 5B.4: Nether region after a C++ or Java func
+           ;; decl, which could include a `throws' declaration.
+           (t
+            (c-beginning-of-statement-1 lim)
+            (c-add-syntax 'func-decl-cont (c-point 'boi))
+            )))
+
+         ;; CASE 5C: inheritance line. could be first inheritance
+         ;; line, or continuation of a multiple inheritance
+         ((or (and (c-major-mode-is 'c++-mode)
+                   (progn
+                     (when (eq char-after-ip ?,)
+                       (skip-chars-forward " \t")
+                       (forward-char))
+                     (looking-at c-opt-postfix-decl-spec-key)))
+              (and (or (eq char-before-ip ?:)
+                       ;; watch out for scope operator
+                       (save-excursion
+                         (and (eq char-after-ip ?:)
+                              (c-safe (forward-char 1) t)
+                              (not (eq (char-after) ?:))
+                              )))
                    (save-excursion
-                     (let ((start (point)))
-                       (if (and c-state-cache
-                                (consp (car c-state-cache))
-                                (eq (cdar c-state-cache) (point)))
-                           ;; Speed up the backward search a bit.
-                           (goto-char (caar c-state-cache)))
-                       (c-beginning-of-decl-1 containing-sexp)
-                       (setq placeholder (point))
-                       (if (= start (point))
-                           ;; The '}' is unbalanced.
-                           nil
-                         (c-end-of-decl-1)
-                         (>= (point) indent-point))))))
-            (goto-char placeholder)
-            (c-add-stmt-syntax 'topmost-intro-cont nil nil
-                               containing-sexp paren-state))
+                     (c-backward-syntactic-ws lim)
+                     (if (eq char-before-ip ?:)
+                         (progn
+                           (forward-char -1)
+                           (c-backward-syntactic-ws lim)))
+                     (back-to-indentation)
+                     (looking-at c-class-key)))
+              ;; for Java
+              (and (c-major-mode-is 'java-mode)
+                   (let ((fence (save-excursion
+                                  (c-beginning-of-statement-1 lim)
+                                  (point)))
+                         cont done)
+                     (save-excursion
+                       (while (not done)
+                         (cond ((looking-at c-opt-postfix-decl-spec-key)
+                                (setq injava-inher (cons cont (point))
+                                      done t))
+                               ((or (not (c-safe (c-forward-sexp -1) t))
+                                    (<= (point) fence))
+                                (setq done t))
+                               )
+                         (setq cont t)))
+                     injava-inher)
+                   (not (c-crosses-statement-barrier-p (cdr injava-inher)
+                                                       (point)))
+                   ))
+          (cond
 
-           ;; NOTE: The point is at the end of the previous token here.
+           ;; CASE 5C.1: non-hanging colon on an inher intro
+           ((eq char-after-ip ?:)
+            (c-beginning-of-statement-1 lim)
+            (c-add-syntax 'inher-intro (c-point 'boi))
+            ;; don't add inclass symbol since relative point already
+            ;; contains any class offset
+            )
 
-           ;; CASE 5J: we are at the topmost level, make
-           ;; sure we skip back past any access specifiers
-           ((and
-             ;; A macro continuation line is never at top level.
-             (not (and macro-start
-                       (> indent-point macro-start)))
-             (save-excursion
-               (setq placeholder (point))
-               (or (memq char-before-ip '(?\; ?{ ?} nil))
-                   (c-at-vsemi-p before-ws-ip)
-                   (when (and (eq char-before-ip ?:)
-                              (eq (c-beginning-of-statement-1 lim)
-                                  'label))
-                     (c-backward-syntactic-ws lim)
-                     (setq placeholder (point)))
-                   (and (c-major-mode-is 'objc-mode)
-                        (catch 'not-in-directive
-                          (c-beginning-of-statement-1 lim)
-                          (setq placeholder (point))
-                          (while (and (c-forward-objc-directive)
-                                      (< (point) indent-point))
-                            (c-forward-syntactic-ws)
-                            (if (>= (point) indent-point)
-                                (throw 'not-in-directive t))
-                            (setq placeholder (point)))
-                          nil)))))
-            ;; For historic reasons we anchor at bol of the last
-            ;; line of the previous declaration.  That's clearly
-            ;; highly bogus and useless, and it makes our lives hard
-            ;; to remain compatible.  :P
-            (goto-char placeholder)
-            (c-add-syntax 'topmost-intro (c-point 'bol))
+           ;; CASE 5C.2: hanging colon on an inher intro
+           ((eq char-before-ip ?:)
+            (c-beginning-of-statement-1 lim)
+            (c-add-syntax 'inher-intro (c-point 'boi))
             (if containing-decl-open
-                (if (c-keyword-member containing-decl-kwd
-                                      'c-other-block-decl-kwds)
-                    (progn
-                      (goto-char (c-brace-anchor-point containing-decl-open))
-                      (c-add-stmt-syntax
-                       (if (string-equal (symbol-name containing-decl-kwd)
-                                         "extern")
-                           ;; Special case for compatibility with the
-                           ;; extern-lang syntactic symbols.
-                           'inextern-lang
-                         (intern (concat "in"
-                                         (symbol-name containing-decl-kwd))))
-                       nil t
-                       (c-most-enclosing-brace paren-state (point))
-                       paren-state))
-                  (c-add-class-syntax 'inclass
-                                      containing-decl-open
-                                      containing-decl-start
-                                      containing-decl-kwd
-                                      paren-state)))
-            (when (and c-syntactic-indentation-in-macros
-                       macro-start
-                       (/= macro-start (c-point 'boi indent-point)))
-              (c-add-syntax 'cpp-define-intro)
-              (setq macro-start nil)))
-
-           ;; CASE 5K: we are at an ObjC method definition
-           ;; continuation line.
-           ((and c-opt-method-key
+                (c-add-class-syntax 'inclass
+                                    containing-decl-open
+                                    containing-decl-start
+                                    containing-decl-kwd
+                                    paren-state)))
+
+           ;; CASE 5C.3: in a Java implements/extends
+           (injava-inher
+            (let ((where (cdr injava-inher))
+                  (cont (car injava-inher)))
+              (goto-char where)
+              (cond ((looking-at "throws\\>[^_]")
+                     (c-add-syntax 'func-decl-cont
+                                   (progn (c-beginning-of-statement-1 lim)
+                                          (c-point 'boi))))
+                    (cont (c-add-syntax 'inher-cont where))
+                    (t (c-add-syntax 'inher-intro
+                                     (progn (goto-char (cdr injava-inher))
+                                            (c-beginning-of-statement-1 lim)
+                                            (point))))
+                    )))
+
+           ;; CASE 5C.4: a continued inheritance line
+           (t
+            (c-beginning-of-inheritance-list lim)
+            (c-add-syntax 'inher-cont (point))
+            ;; don't add inclass symbol since relative point already
+            ;; contains any class offset
+            )))
+
+         ;; CASE 5D: this could be a top-level initialization, a
+         ;; member init list continuation, or a template argument
+         ;; list continuation.
+         ((save-excursion
+            ;; Note: We use the fact that lim is always after any
+            ;; preceding brace sexp.
+            (if c-recognize-<>-arglists
+                (while (and
+                        (progn
+                          (c-syntactic-skip-backward "^;,=<>" lim t)
+                          (> (point) lim))
+                        (or
+                         (when c-overloadable-operators-regexp
+                           (when (setq placeholder (c-after-special-operator-id lim))
+                             (goto-char placeholder)
+                             t))
+                         (cond
+                          ((eq (char-before) ?>)
+                           (or (c-backward-<>-arglist nil lim)
+                               (backward-char))
+                           t)
+                          ((eq (char-before) ?<)
+                           (backward-char)
+                           (if (save-excursion
+                                 (c-forward-<>-arglist nil))
+                               (progn (forward-char)
+                                      nil)
+                             t))
+                          (t nil)))))
+              ;; NB: No c-after-special-operator-id stuff in this
+              ;; clause - we assume only C++ needs it.
+              (c-syntactic-skip-backward "^;,=" lim t))
+            (memq (char-before) '(?, ?= ?<)))
+          (cond
+
+           ;; CASE 5D.3: perhaps a template list continuation?
+           ((and (c-major-mode-is 'c++-mode)
+                 (save-excursion
+                   (save-restriction
+                     (c-with-syntax-table c++-template-syntax-table
+                       (goto-char indent-point)
+                       (setq placeholder (c-up-list-backward))
+                       (and placeholder
+                            (eq (char-after placeholder) ?<))))))
+            (c-with-syntax-table c++-template-syntax-table
+              (goto-char placeholder)
+              (c-beginning-of-statement-1 lim t)
+              (if (save-excursion
+                    (c-backward-syntactic-ws lim)
+                    (eq (char-before) ?<))
+                  ;; In a nested template arglist.
+                  (progn
+                    (goto-char placeholder)
+                    (c-syntactic-skip-backward "^,;" lim t)
+                    (c-forward-syntactic-ws))
+                (back-to-indentation)))
+            ;; FIXME: Should use c-add-stmt-syntax, but it's not yet
+            ;; template aware.
+            (c-add-syntax 'template-args-cont (point) placeholder))
+
+           ;; CASE 5D.4: perhaps a multiple inheritance line?
+           ((and (c-major-mode-is 'c++-mode)
                  (save-excursion
                    (c-beginning-of-statement-1 lim)
-                   (beginning-of-line)
-                   (when (looking-at c-opt-method-key)
-                     (setq placeholder (point)))))
-            (c-add-syntax 'objc-method-args-cont placeholder))
+                   (setq placeholder (point))
+                   (if (looking-at "static\\>[^_]")
+                       (c-forward-token-2 1 nil indent-point))
+                   (and (looking-at c-class-key)
+                        (zerop (c-forward-token-2 2 nil indent-point))
+                        (if (eq (char-after) ?<)
+                            (c-with-syntax-table c++-template-syntax-table
+                              (zerop (c-forward-token-2 1 t indent-point)))
+                          t)
+                        (eq (char-after) ?:))))
+            (goto-char placeholder)
+            (c-add-syntax 'inher-cont (c-point 'boi)))
+
+           ;; CASE 5D.5: Continuation of the "expression part" of a
+           ;; top level construct.  Or, perhaps, an unrecognised construct.
+           (t
+            (while (and (setq placeholder (point))
+                        (eq (car (c-beginning-of-decl-1 containing-sexp))
+                            'same)
+                        (save-excursion
+                          (c-backward-syntactic-ws)
+                          (eq (char-before) ?}))
+                        (< (point) placeholder)))
+            (c-add-stmt-syntax
+             (cond
+              ((eq (point) placeholder) 'statement) ; unrecognised construct
+              ;; A preceding comma at the top level means that a
+              ;; new variable declaration starts here.  Use
+              ;; topmost-intro-cont for it, for consistency with
+              ;; the first variable declaration.  C.f. case 5N.
+              ((eq char-before-ip ?,) 'topmost-intro-cont)
+              (t 'statement-cont))
+             nil nil containing-sexp paren-state))
+           ))
 
-           ;; CASE 5L: we are at the first argument of a template
+         ;; CASE 5F: Close of a non-class declaration level block.
+         ((and (eq char-after-ip ?})
+               (c-keyword-member containing-decl-kwd
+                                 'c-other-block-decl-kwds))
+          ;; This is inconsistent: Should use `containing-decl-open'
+          ;; here if it's at boi, like in case 5J.
+          (goto-char containing-decl-start)
+          (c-add-stmt-syntax
+           (if (string-equal (symbol-name containing-decl-kwd) "extern")
+               ;; Special case for compatibility with the
+               ;; extern-lang syntactic symbols.
+               'extern-lang-close
+             (intern (concat (symbol-name containing-decl-kwd)
+                             "-close")))
+           nil t
+           (c-most-enclosing-brace paren-state (point))
+           paren-state))
+
+         ;; CASE 5G: we are looking at the brace which closes the
+         ;; enclosing nested class decl
+         ((and containing-sexp
+               (eq char-after-ip ?})
+               (eq containing-decl-open containing-sexp))
+          (c-add-class-syntax 'class-close
+                              containing-decl-open
+                              containing-decl-start
+                              containing-decl-kwd
+                              paren-state))
+
+         ;; CASE 5H: we could be looking at subsequent knr-argdecls
+         ((and c-recognize-knr-p
+               (not containing-sexp)    ; can't be knr inside braces.
+               (not (eq char-before-ip ?}))
+               (save-excursion
+                 (setq placeholder (cdr (c-beginning-of-decl-1 lim)))
+                 (and placeholder
+                      ;; Do an extra check to avoid tripping up on
+                      ;; statements that occur in invalid contexts
+                      ;; (e.g. in macro bodies where we don't really
+                      ;; know the context of what we're looking at).
+                      (not (and c-opt-block-stmt-key
+                                (looking-at c-opt-block-stmt-key)))))
+               (< placeholder indent-point))
+          (goto-char placeholder)
+          (c-add-syntax 'knr-argdecl (point)))
+
+         ;; CASE 5I: ObjC method definition.
+         ((and c-opt-method-key
+               (looking-at c-opt-method-key))
+          (c-beginning-of-statement-1 nil t)
+          (if (= (point) indent-point)
+              ;; Handle the case when it's the first (non-comment)
+              ;; thing in the buffer.  Can't look for a 'same return
+              ;; value from cbos1 since ObjC directives currently
+              ;; aren't recognized fully, so that we get 'same
+              ;; instead of 'previous if it moved over a preceding
+              ;; directive.
+              (goto-char (point-min)))
+          (c-add-syntax 'objc-method-intro (c-point 'boi)))
+
+         ;; CASE 5P: AWK pattern or function or continuation
+         ;; thereof.
+         ((c-major-mode-is 'awk-mode)
+          (setq placeholder (point))
+          (c-add-stmt-syntax
+           (if (and (eq (c-beginning-of-statement-1) 'same)
+                    (/= (point) placeholder))
+               'topmost-intro-cont
+             'topmost-intro)
+           nil nil
+           containing-sexp paren-state))
+
+         ;; CASE 5N: At a variable declaration that follows a class
+         ;; definition or some other block declaration that doesn't
+         ;; end at the closing '}'.  C.f. case 5D.5.
+         ((progn
+            (c-backward-syntactic-ws lim)
+            (and (eq (char-before) ?})
+                 (save-excursion
+                   (let ((start (point)))
+                     (if (and c-state-cache
+                              (consp (car c-state-cache))
+                              (eq (cdar c-state-cache) (point)))
+                         ;; Speed up the backward search a bit.
+                         (goto-char (caar c-state-cache)))
+                     (c-beginning-of-decl-1 containing-sexp)
+                     (setq placeholder (point))
+                     (if (= start (point))
+                         ;; The '}' is unbalanced.
+                         nil
+                       (c-end-of-decl-1)
+                       (>= (point) indent-point))))))
+          (goto-char placeholder)
+          (c-add-stmt-syntax 'topmost-intro-cont nil nil
+                             containing-sexp paren-state))
+
+         ;; NOTE: The point is at the end of the previous token here.
+
+         ;; CASE 5J: we are at the topmost level, make
+         ;; sure we skip back past any access specifiers
+         ((and
+           ;; A macro continuation line is never at top level.
+           (not (and macro-start
+                     (> indent-point macro-start)))
+           (save-excursion
+             (setq placeholder (point))
+             (or (memq char-before-ip '(?\; ?{ ?} nil))
+                 (c-at-vsemi-p before-ws-ip)
+                 (when (and (eq char-before-ip ?:)
+                            (eq (c-beginning-of-statement-1 lim)
+                                'label))
+                   (c-backward-syntactic-ws lim)
+                   (setq placeholder (point)))
+                 (and (c-major-mode-is 'objc-mode)
+                      (catch 'not-in-directive
+                        (c-beginning-of-statement-1 lim)
+                        (setq placeholder (point))
+                        (while (and (c-forward-objc-directive)
+                                    (< (point) indent-point))
+                          (c-forward-syntactic-ws)
+                          (if (>= (point) indent-point)
+                              (throw 'not-in-directive t))
+                          (setq placeholder (point)))
+                        nil)))))
+          ;; For historic reasons we anchor at bol of the last
+          ;; line of the previous declaration.  That's clearly
+          ;; highly bogus and useless, and it makes our lives hard
+          ;; to remain compatible.  :P
+          (goto-char placeholder)
+          (c-add-syntax 'topmost-intro (c-point 'bol))
+          (if containing-decl-open
+              (if (c-keyword-member containing-decl-kwd
+                                    'c-other-block-decl-kwds)
+                  (progn
+                    (goto-char (c-brace-anchor-point containing-decl-open))
+                    (c-add-stmt-syntax
+                     (if (string-equal (symbol-name containing-decl-kwd)
+                                       "extern")
+                         ;; Special case for compatibility with the
+                         ;; extern-lang syntactic symbols.
+                         'inextern-lang
+                       (intern (concat "in"
+                                       (symbol-name containing-decl-kwd))))
+                     nil t
+                     (c-most-enclosing-brace paren-state (point))
+                     paren-state))
+                (c-add-class-syntax 'inclass
+                                    containing-decl-open
+                                    containing-decl-start
+                                    containing-decl-kwd
+                                    paren-state)))
+          (when (and c-syntactic-indentation-in-macros
+                     macro-start
+                     (/= macro-start (c-point 'boi indent-point)))
+            (c-add-syntax 'cpp-define-intro)
+            (setq macro-start nil)))
+
+         ;; CASE 5K: we are at an ObjC method definition
+         ;; continuation line.
+         ((and c-opt-method-key
+               (save-excursion
+                 (c-beginning-of-statement-1 lim)
+                 (beginning-of-line)
+                 (when (looking-at c-opt-method-key)
+                   (setq placeholder (point)))))
+          (c-add-syntax 'objc-method-args-cont placeholder))
+
+         ;; CASE 5L: we are at the first argument of a template
          ;; arglist that begins on the previous line.
          ((and c-recognize-<>-arglists
                (eq (char-before) ?<)
@@ -9573,32 +9573,32 @@ comment at the start of cc-engine.el for more info."
           (c-beginning-of-statement-1 containing-sexp)
           (c-add-stmt-syntax 'statement nil t containing-sexp paren-state))
 
-     ;;CASE 5N: We are at a tompmost continuation line and the only
-     ;;preceding items are annotations.
+         ;;CASE 5N: We are at a tompmost continuation line and the only
+         ;;preceding items are annotations.
          ((and (c-major-mode-is 'java-mode)
                (setq placeholder (point))
-           (c-beginning-of-statement-1)
-           (progn
+               (c-beginning-of-statement-1)
+               (progn
                  (while (and (c-forward-annotation))
-               (c-forward-syntactic-ws))
-             t)
-           (prog1
-             (>= (point) placeholder)
-             (goto-char placeholder)))
-      (c-add-syntax 'annotation-top-cont (c-point 'boi)))
+                   (c-forward-syntactic-ws))
+                 t)
+               (prog1
+                   (>= (point) placeholder)
+                 (goto-char placeholder)))
+          (c-add-syntax 'annotation-top-cont (c-point 'boi)))
 
          ;; CASE 5M: we are at a topmost continuation line
          (t
           (c-beginning-of-statement-1 (c-safe-position (point) paren-state))
-            (when (c-major-mode-is 'objc-mode)
-              (setq placeholder (point))
-              (while (and (c-forward-objc-directive)
-                          (< (point) indent-point))
-                (c-forward-syntactic-ws)
-                (setq placeholder (point)))
-              (goto-char placeholder))
-            (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
-           ))
+          (when (c-major-mode-is 'objc-mode)
+            (setq placeholder (point))
+            (while (and (c-forward-objc-directive)
+                        (< (point) indent-point))
+              (c-forward-syntactic-ws)
+              (setq placeholder (point)))
+            (goto-char placeholder))
+          (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
+         ))
 
 
        ;; (CASE 6 has been removed.)
@@ -9614,576 +9614,576 @@ comment at the start of cc-engine.el for more info."
         (cond
 
          ;; CASE 7A: we are looking at the arglist closing paren.
-           ;; C.f. case 7F.
-           ((memq char-after-ip '(?\) ?\]))
-            (goto-char containing-sexp)
-            (setq placeholder (c-point 'boi))
-            (if (and (c-safe (backward-up-list 1) t)
-                     (>= (point) placeholder))
-                (progn
-                  (forward-char)
-                  (skip-chars-forward " \t"))
-              (goto-char placeholder))
-            (c-add-stmt-syntax 'arglist-close (list containing-sexp) t
+         ;; C.f. case 7F.
+         ((memq char-after-ip '(?\) ?\]))
+          (goto-char containing-sexp)
+          (setq placeholder (c-point 'boi))
+          (if (and (c-safe (backward-up-list 1) t)
+                   (>= (point) placeholder))
+              (progn
+                (forward-char)
+                (skip-chars-forward " \t"))
+            (goto-char placeholder))
+          (c-add-stmt-syntax 'arglist-close (list containing-sexp) t
                              (c-most-enclosing-brace paren-state (point))
                              paren-state))
 
-        ;; CASE 19: line is an expression, not a statement, and is directly
-        ;; contained by a template delimiter.   Most likely, we are in a
-        ;; template arglist within a statement.  This case is based on CASE
-        ;; 7.   At some point in the future, we may wish to create more
-        ;; syntactic symbols such as `template-intro',
-        ;; `template-cont-nonempty', etc., and distinguish between them as we
-        ;; do for `arglist-intro' etc. (2009-12-07).
-        ((and c-recognize-<>-arglists
-             (setq containing-< (c-up-list-backward indent-point containing-sexp))
-             (eq (char-after containing-<) ?\<))
-        (setq placeholder (c-point 'boi containing-<))
-        (goto-char containing-sexp)     ; Most nested Lbrace/Lparen (but not
+         ;; CASE 19: line is an expression, not a statement, and is directly
+         ;; contained by a template delimiter.  Most likely, we are in a
+         ;; template arglist within a statement.  This case is based on CASE
+         ;; 7.  At some point in the future, we may wish to create more
+         ;; syntactic symbols such as `template-intro',
+         ;; `template-cont-nonempty', etc., and distinguish between them as we
+         ;; do for `arglist-intro' etc. (2009-12-07).
+         ((and c-recognize-<>-arglists
+               (setq containing-< (c-up-list-backward indent-point containing-sexp))
+               (eq (char-after containing-<) ?\<))
+          (setq placeholder (c-point 'boi containing-<))
+          (goto-char containing-sexp) ; Most nested Lbrace/Lparen (but not
                                         ; '<') before indent-point.
-        (if (>= (point) placeholder)
-            (progn
-              (forward-char)
-              (skip-chars-forward " \t"))
-          (goto-char placeholder))
-        (c-add-stmt-syntax 'template-args-cont (list containing-<) t
-                           (c-most-enclosing-brace c-state-cache (point))
-                           paren-state))
+          (if (>= (point) placeholder)
+              (progn
+                (forward-char)
+                (skip-chars-forward " \t"))
+            (goto-char placeholder))
+          (c-add-stmt-syntax 'template-args-cont (list containing-<) t
+                             (c-most-enclosing-brace c-state-cache (point))
+                             paren-state))
 
          ;; CASE 7B: Looking at the opening brace of an
          ;; in-expression block or brace list.  C.f. cases 4, 16A
          ;; and 17E.
-           ((and (eq char-after-ip ?{)
-                 (progn
-                   (setq placeholder (c-inside-bracelist-p (point)
-                                                           paren-state))
-                   (if placeholder
-                       (setq tmpsymbol '(brace-list-open . inexpr-class))
-                     (setq tmpsymbol '(block-open . inexpr-statement)
-                           placeholder
-                           (cdr-safe (c-looking-at-inexpr-block
-                                      (c-safe-position containing-sexp
-                                                       paren-state)
-                                      containing-sexp)))
-                     ;; placeholder is nil if it's a block directly in
-                     ;; a function arglist.  That makes us skip out of
-                     ;; this case.
-                     )))
-            (goto-char placeholder)
-            (back-to-indentation)
-            (c-add-stmt-syntax (car tmpsymbol) nil t
-                               (c-most-enclosing-brace paren-state (point))
-                               paren-state)
-            (if (/= (point) placeholder)
-                (c-add-syntax (cdr tmpsymbol))))
+         ((and (eq char-after-ip ?{)
+               (progn
+                 (setq placeholder (c-inside-bracelist-p (point)
+                                                         paren-state))
+                 (if placeholder
+                     (setq tmpsymbol '(brace-list-open . inexpr-class))
+                   (setq tmpsymbol '(block-open . inexpr-statement)
+                         placeholder
+                         (cdr-safe (c-looking-at-inexpr-block
+                                    (c-safe-position containing-sexp
+                                                     paren-state)
+                                    containing-sexp)))
+                   ;; placeholder is nil if it's a block directly in
+                   ;; a function arglist.  That makes us skip out of
+                   ;; this case.
+                   )))
+          (goto-char placeholder)
+          (back-to-indentation)
+          (c-add-stmt-syntax (car tmpsymbol) nil t
+                             (c-most-enclosing-brace paren-state (point))
+                             paren-state)
+          (if (/= (point) placeholder)
+              (c-add-syntax (cdr tmpsymbol))))
+
+         ;; CASE 7C: we are looking at the first argument in an empty
+         ;; argument list. Use arglist-close if we're actually
+         ;; looking at a close paren or bracket.
+         ((memq char-before-ip '(?\( ?\[))
+          (goto-char containing-sexp)
+          (setq placeholder (c-point 'boi))
+          (if (and (c-safe (backward-up-list 1) t)
+                   (>= (point) placeholder))
+              (progn
+                (forward-char)
+                (skip-chars-forward " \t"))
+            (goto-char placeholder))
+          (c-add-stmt-syntax 'arglist-intro (list containing-sexp) t
+                             (c-most-enclosing-brace paren-state (point))
+                             paren-state))
 
-           ;; CASE 7C: we are looking at the first argument in an empty
-           ;; argument list. Use arglist-close if we're actually
-           ;; looking at a close paren or bracket.
-           ((memq char-before-ip '(?\( ?\[))
+         ;; CASE 7D: we are inside a conditional test clause. treat
+         ;; these things as statements
+         ((progn
             (goto-char containing-sexp)
-            (setq placeholder (c-point 'boi))
-            (if (and (c-safe (backward-up-list 1) t)
-                     (>= (point) placeholder))
-                (progn
-                  (forward-char)
-                  (skip-chars-forward " \t"))
-              (goto-char placeholder))
-            (c-add-stmt-syntax 'arglist-intro (list containing-sexp) t
-                               (c-most-enclosing-brace paren-state (point))
-                               paren-state))
+            (and (c-safe (c-forward-sexp -1) t)
+                 (looking-at "\\<for\\>[^_]")))
+          (goto-char (1+ containing-sexp))
+          (c-forward-syntactic-ws indent-point)
+          (if (eq char-before-ip ?\;)
+              (c-add-syntax 'statement (point))
+            (c-add-syntax 'statement-cont (point))
+            ))
+
+         ;; CASE 7E: maybe a continued ObjC method call. This is the
+         ;; case when we are inside a [] bracketed exp, and what
+         ;; precede the opening bracket is not an identifier.
+         ((and c-opt-method-key
+               (eq (char-after containing-sexp) ?\[)
+               (progn
+                 (goto-char (1- containing-sexp))
+                 (c-backward-syntactic-ws (c-point 'bod))
+                 (if (not (looking-at c-symbol-key))
+                     (c-add-syntax 'objc-method-call-cont containing-sexp))
+                 )))
 
-           ;; CASE 7D: we are inside a conditional test clause. treat
-           ;; these things as statements
-           ((progn
-              (goto-char containing-sexp)
-              (and (c-safe (c-forward-sexp -1) t)
-                   (looking-at "\\<for\\>[^_]")))
+         ;; CASE 7F: we are looking at an arglist continuation line,
+         ;; but the preceding argument is on the same line as the
+         ;; opening paren.  This case includes multi-line
+         ;; mathematical paren groupings, but we could be on a
+         ;; for-list continuation line.  C.f. case 7A.
+         ((progn
             (goto-char (1+ containing-sexp))
-            (c-forward-syntactic-ws indent-point)
-            (if (eq char-before-ip ?\;)
-                (c-add-syntax 'statement (point))
-              (c-add-syntax 'statement-cont (point))
-              ))
-
-           ;; CASE 7E: maybe a continued ObjC method call. This is the
-           ;; case when we are inside a [] bracketed exp, and what
-           ;; precede the opening bracket is not an identifier.
-           ((and c-opt-method-key
-                 (eq (char-after containing-sexp) ?\[)
-                 (progn
-                   (goto-char (1- containing-sexp))
-                   (c-backward-syntactic-ws (c-point 'bod))
-                   (if (not (looking-at c-symbol-key))
-                       (c-add-syntax 'objc-method-call-cont containing-sexp))
-                   )))
+            (< (save-excursion
+                 (c-forward-syntactic-ws)
+                 (point))
+               (c-point 'bonl)))
+          (goto-char containing-sexp)   ; paren opening the arglist
+          (setq placeholder (c-point 'boi))
+          (if (and (c-safe (backward-up-list 1) t)
+                   (>= (point) placeholder))
+              (progn
+                (forward-char)
+                (skip-chars-forward " \t"))
+            (goto-char placeholder))
+          (c-add-stmt-syntax 'arglist-cont-nonempty (list containing-sexp) t
+                             (c-most-enclosing-brace c-state-cache (point))
+                             paren-state))
 
-           ;; CASE 7F: we are looking at an arglist continuation line,
-           ;; but the preceding argument is on the same line as the
-           ;; opening paren.  This case includes multi-line
-           ;; mathematical paren groupings, but we could be on a
-           ;; for-list continuation line.  C.f. case 7A.
-           ((progn
-              (goto-char (1+ containing-sexp))
-              (< (save-excursion
-                   (c-forward-syntactic-ws)
-                   (point))
-                 (c-point 'bonl)))
-            (goto-char containing-sexp) ; paren opening the arglist
-            (setq placeholder (c-point 'boi))
-            (if (and (c-safe (backward-up-list 1) t)
-                     (>= (point) placeholder))
-                (progn
-                  (forward-char)
-                  (skip-chars-forward " \t"))
-              (goto-char placeholder))
-            (c-add-stmt-syntax 'arglist-cont-nonempty (list containing-sexp) t
-                               (c-most-enclosing-brace c-state-cache (point))
-                               paren-state))
+         ;; CASE 7G: we are looking at just a normal arglist
+         ;; continuation line
+         (t (c-forward-syntactic-ws indent-point)
+            (c-add-syntax 'arglist-cont (c-point 'boi)))
+         ))
 
-           ;; CASE 7G: we are looking at just a normal arglist
-           ;; continuation line
-           (t (c-forward-syntactic-ws indent-point)
-              (c-add-syntax 'arglist-cont (c-point 'boi)))
-           ))
+       ;; CASE 8: func-local multi-inheritance line
+       ((and (c-major-mode-is 'c++-mode)
+             (save-excursion
+               (goto-char indent-point)
+               (skip-chars-forward " \t")
+               (looking-at c-opt-postfix-decl-spec-key)))
+        (goto-char indent-point)
+        (skip-chars-forward " \t")
+        (cond
 
-         ;; CASE 8: func-local multi-inheritance line
-         ((and (c-major-mode-is 'c++-mode)
-               (save-excursion
-                 (goto-char indent-point)
-                 (skip-chars-forward " \t")
-                 (looking-at c-opt-postfix-decl-spec-key)))
-          (goto-char indent-point)
-          (skip-chars-forward " \t")
-          (cond
+         ;; CASE 8A: non-hanging colon on an inher intro
+         ((eq char-after-ip ?:)
+          (c-backward-syntactic-ws lim)
+          (c-add-syntax 'inher-intro (c-point 'boi)))
 
-           ;; CASE 8A: non-hanging colon on an inher intro
-           ((eq char-after-ip ?:)
-            (c-backward-syntactic-ws lim)
-            (c-add-syntax 'inher-intro (c-point 'boi)))
+         ;; CASE 8B: hanging colon on an inher intro
+         ((eq char-before-ip ?:)
+          (c-add-syntax 'inher-intro (c-point 'boi)))
 
-           ;; CASE 8B: hanging colon on an inher intro
-           ((eq char-before-ip ?:)
-            (c-add-syntax 'inher-intro (c-point 'boi)))
+         ;; CASE 8C: a continued inheritance line
+         (t
+          (c-beginning-of-inheritance-list lim)
+          (c-add-syntax 'inher-cont (point))
+          )))
+
+       ;; CASE 9: we are inside a brace-list
+       ((and (not (c-major-mode-is 'awk-mode)) ; Maybe this isn't needed (ACM, 2002/3/29)
+             (setq special-brace-list
+                   (or (and c-special-brace-lists ;;;; ALWAYS NIL FOR AWK!!
+                            (save-excursion
+                              (goto-char containing-sexp)
+                              (c-looking-at-special-brace-list)))
+                       (c-inside-bracelist-p containing-sexp paren-state))))
+        (cond
 
-           ;; CASE 8C: a continued inheritance line
-           (t
-            (c-beginning-of-inheritance-list lim)
-            (c-add-syntax 'inher-cont (point))
-            )))
+         ;; CASE 9A: In the middle of a special brace list opener.
+         ((and (consp special-brace-list)
+               (save-excursion
+                 (goto-char containing-sexp)
+                 (eq (char-after) ?\())
+               (eq char-after-ip (car (cdr special-brace-list))))
+          (goto-char (car (car special-brace-list)))
+          (skip-chars-backward " \t")
+          (if (and (bolp)
+                   (assoc 'statement-cont
+                          (setq placeholder (c-guess-basic-syntax))))
+              (setq c-syntactic-context placeholder)
+            (c-beginning-of-statement-1
+             (c-safe-position (1- containing-sexp) paren-state))
+            (c-forward-token-2 0)
+            (while (looking-at c-specifier-key)
+              (goto-char (match-end 1))
+              (c-forward-syntactic-ws))
+            (c-add-syntax 'brace-list-open (c-point 'boi))))
+
+         ;; CASE 9B: brace-list-close brace
+         ((if (consp special-brace-list)
+              ;; Check special brace list closer.
+              (progn
+                (goto-char (car (car special-brace-list)))
+                (save-excursion
+                  (goto-char indent-point)
+                  (back-to-indentation)
+                  (or
+                   ;; We were between the special close char and the `)'.
+                   (and (eq (char-after) ?\))
+                        (eq (1+ (point)) (cdr (car special-brace-list))))
+                   ;; We were before the special close char.
+                   (and (eq (char-after) (cdr (cdr special-brace-list)))
+                        (zerop (c-forward-token-2))
+                        (eq (1+ (point)) (cdr (car special-brace-list)))))))
+            ;; Normal brace list check.
+            (and (eq char-after-ip ?})
+                 (c-safe (goto-char (c-up-list-backward (point))) t)
+                 (= (point) containing-sexp)))
+          (if (eq (point) (c-point 'boi))
+              (c-add-syntax 'brace-list-close (point))
+            (setq lim (c-most-enclosing-brace c-state-cache (point)))
+            (c-beginning-of-statement-1 lim)
+            (c-add-stmt-syntax 'brace-list-close nil t lim paren-state)))
 
-         ;; CASE 9: we are inside a brace-list
-         ((and (not (c-major-mode-is 'awk-mode))  ; Maybe this isn't needed (ACM, 2002/3/29)
-               (setq special-brace-list
-                     (or (and c-special-brace-lists ;;;; ALWAYS NIL FOR AWK!!
-                              (save-excursion
-                                (goto-char containing-sexp)
-                                (c-looking-at-special-brace-list)))
-                         (c-inside-bracelist-p containing-sexp paren-state))))
+         (t
+          ;; Prepare for the rest of the cases below by going to the
+          ;; token following the opening brace
+          (if (consp special-brace-list)
+              (progn
+                (goto-char (car (car special-brace-list)))
+                (c-forward-token-2 1 nil indent-point))
+            (goto-char containing-sexp))
+          (forward-char)
+          (let ((start (point)))
+            (c-forward-syntactic-ws indent-point)
+            (goto-char (max start (c-point 'bol))))
+          (c-skip-ws-forward indent-point)
           (cond
 
-           ;; CASE 9A: In the middle of a special brace list opener.
-           ((and (consp special-brace-list)
-                 (save-excursion
-                   (goto-char containing-sexp)
-                   (eq (char-after) ?\())
-                 (eq char-after-ip (car (cdr special-brace-list))))
-            (goto-char (car (car special-brace-list)))
-            (skip-chars-backward " \t")
-            (if (and (bolp)
-                     (assoc 'statement-cont
-                            (setq placeholder (c-guess-basic-syntax))))
-                (setq c-syntactic-context placeholder)
-              (c-beginning-of-statement-1
-               (c-safe-position (1- containing-sexp) paren-state))
-              (c-forward-token-2 0)
-              (while (looking-at c-specifier-key)
-                (goto-char (match-end 1))
-                (c-forward-syntactic-ws))
-              (c-add-syntax 'brace-list-open (c-point 'boi))))
-
-           ;; CASE 9B: brace-list-close brace
-           ((if (consp special-brace-list)
-                ;; Check special brace list closer.
-                (progn
-                  (goto-char (car (car special-brace-list)))
-                  (save-excursion
-                    (goto-char indent-point)
-                    (back-to-indentation)
-                    (or
-                     ;; We were between the special close char and the `)'.
-                     (and (eq (char-after) ?\))
-                          (eq (1+ (point)) (cdr (car special-brace-list))))
-                     ;; We were before the special close char.
-                     (and (eq (char-after) (cdr (cdr special-brace-list)))
-                          (zerop (c-forward-token-2))
-                          (eq (1+ (point)) (cdr (car special-brace-list)))))))
-              ;; Normal brace list check.
-              (and (eq char-after-ip ?})
-                   (c-safe (goto-char (c-up-list-backward (point))) t)
-                   (= (point) containing-sexp)))
+           ;; CASE 9C: we're looking at the first line in a brace-list
+           ((= (point) indent-point)
+            (if (consp special-brace-list)
+                (goto-char (car (car special-brace-list)))
+              (goto-char containing-sexp))
             (if (eq (point) (c-point 'boi))
-                (c-add-syntax 'brace-list-close (point))
+                (c-add-syntax 'brace-list-intro (point))
               (setq lim (c-most-enclosing-brace c-state-cache (point)))
               (c-beginning-of-statement-1 lim)
-              (c-add-stmt-syntax 'brace-list-close nil t lim paren-state)))
+              (c-add-stmt-syntax 'brace-list-intro nil t lim paren-state)))
 
-           (t
-            ;; Prepare for the rest of the cases below by going to the
-            ;; token following the opening brace
-            (if (consp special-brace-list)
-                (progn
-                  (goto-char (car (car special-brace-list)))
-                  (c-forward-token-2 1 nil indent-point))
-              (goto-char containing-sexp))
-            (forward-char)
-            (let ((start (point)))
-              (c-forward-syntactic-ws indent-point)
-              (goto-char (max start (c-point 'bol))))
-            (c-skip-ws-forward indent-point)
-            (cond
+           ;; CASE 9D: this is just a later brace-list-entry or
+           ;; brace-entry-open
+           (t (if (or (eq char-after-ip ?{)
+                      (and c-special-brace-lists
+                           (save-excursion
+                             (goto-char indent-point)
+                             (c-forward-syntactic-ws (c-point 'eol))
+                             (c-looking-at-special-brace-list (point)))))
+                  (c-add-syntax 'brace-entry-open (point))
+                (c-add-syntax 'brace-list-entry (point))
+                ))
+           ))))
+
+       ;; CASE 10: A continued statement or top level construct.
+       ((and (not (memq char-before-ip '(?\; ?:)))
+             (not (c-at-vsemi-p before-ws-ip))
+             (or (not (eq char-before-ip ?}))
+                 (c-looking-at-inexpr-block-backward c-state-cache))
+             (> (point)
+                (save-excursion
+                  (c-beginning-of-statement-1 containing-sexp)
+                  (setq placeholder (point))))
+             (/= placeholder containing-sexp))
+        ;; This is shared with case 18.
+        (c-guess-continued-construct indent-point
+                                     char-after-ip
+                                     placeholder
+                                     containing-sexp
+                                     paren-state))
+
+       ;; CASE 16: block close brace, possibly closing the defun or
+       ;; the class
+       ((eq char-after-ip ?})
+        ;; From here on we have the next containing sexp in lim.
+        (setq lim (c-most-enclosing-brace paren-state))
+        (goto-char containing-sexp)
+        (cond
 
-             ;; CASE 9C: we're looking at the first line in a brace-list
-             ((= (point) indent-point)
-              (if (consp special-brace-list)
-                  (goto-char (car (car special-brace-list)))
-                (goto-char containing-sexp))
-              (if (eq (point) (c-point 'boi))
-                  (c-add-syntax 'brace-list-intro (point))
-                (setq lim (c-most-enclosing-brace c-state-cache (point)))
-                (c-beginning-of-statement-1 lim)
-                (c-add-stmt-syntax 'brace-list-intro nil t lim paren-state)))
-
-             ;; CASE 9D: this is just a later brace-list-entry or
-             ;; brace-entry-open
-             (t (if (or (eq char-after-ip ?{)
-                        (and c-special-brace-lists
-                             (save-excursion
-                               (goto-char indent-point)
-                               (c-forward-syntactic-ws (c-point 'eol))
-                               (c-looking-at-special-brace-list (point)))))
-                    (c-add-syntax 'brace-entry-open (point))
-                  (c-add-syntax 'brace-list-entry (point))
-                  ))
-             ))))
-
-         ;; CASE 10: A continued statement or top level construct.
-         ((and (not (memq char-before-ip '(?\; ?:)))
-               (not (c-at-vsemi-p before-ws-ip))
-               (or (not (eq char-before-ip ?}))
-                   (c-looking-at-inexpr-block-backward c-state-cache))
-               (> (point)
-                  (save-excursion
-                    (c-beginning-of-statement-1 containing-sexp)
-                    (setq placeholder (point))))
-               (/= placeholder containing-sexp))
-          ;; This is shared with case 18.
-          (c-guess-continued-construct indent-point
-                                       char-after-ip
-                                       placeholder
-                                       containing-sexp
-                                       paren-state))
-
-         ;; CASE 16: block close brace, possibly closing the defun or
-         ;; the class
-         ((eq char-after-ip ?})
-          ;; From here on we have the next containing sexp in lim.
-          (setq lim (c-most-enclosing-brace paren-state))
+         ;; CASE 16E: Closing a statement block?  This catches
+         ;; cases where it's preceded by a statement keyword,
+         ;; which works even when used in an "invalid" context,
+         ;; e.g. a macro argument.
+         ((c-after-conditional)
+          (c-backward-to-block-anchor lim)
+          (c-add-stmt-syntax 'block-close nil t lim paren-state))
+
+         ;; CASE 16A: closing a lambda defun or an in-expression
+         ;; block?  C.f. cases 4, 7B and 17E.
+         ((setq placeholder (c-looking-at-inexpr-block
+                             (c-safe-position containing-sexp paren-state)
+                             nil))
+          (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+                              'inline-close
+                            'block-close))
           (goto-char containing-sexp)
-            (cond
+          (back-to-indentation)
+          (if (= containing-sexp (point))
+              (c-add-syntax tmpsymbol (point))
+            (goto-char (cdr placeholder))
+            (back-to-indentation)
+            (c-add-stmt-syntax tmpsymbol nil t
+                               (c-most-enclosing-brace paren-state (point))
+                               paren-state)
+            (if (/= (point) (cdr placeholder))
+                (c-add-syntax (car placeholder)))))
 
-             ;; CASE 16E: Closing a statement block?  This catches
-             ;; cases where it's preceded by a statement keyword,
-             ;; which works even when used in an "invalid" context,
-             ;; e.g. a macro argument.
-             ((c-after-conditional)
-              (c-backward-to-block-anchor lim)
-              (c-add-stmt-syntax 'block-close nil t lim paren-state))
-
-             ;; CASE 16A: closing a lambda defun or an in-expression
-             ;; block?  C.f. cases 4, 7B and 17E.
-             ((setq placeholder (c-looking-at-inexpr-block
-                                 (c-safe-position containing-sexp paren-state)
-                                 nil))
-              (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
-                                  'inline-close
-                                'block-close))
-              (goto-char containing-sexp)
-              (back-to-indentation)
-              (if (= containing-sexp (point))
-                  (c-add-syntax tmpsymbol (point))
-                (goto-char (cdr placeholder))
-                (back-to-indentation)
-                (c-add-stmt-syntax tmpsymbol nil t
-                                   (c-most-enclosing-brace paren-state (point))
-                                   paren-state)
-                (if (/= (point) (cdr placeholder))
-                    (c-add-syntax (car placeholder)))))
-
-             ;; CASE 16B: does this close an inline or a function in
-             ;; a non-class declaration level block?
-             ((save-excursion
-                (and lim
-                     (progn
-                       (goto-char lim)
-                       (c-looking-at-decl-block
-                        (c-most-enclosing-brace paren-state lim)
-                        nil))
-                     (setq placeholder (point))))
-              (c-backward-to-decl-anchor lim)
-              (back-to-indentation)
-              (if (save-excursion
-                    (goto-char placeholder)
-                    (looking-at c-other-decl-block-key))
-                  (c-add-syntax 'defun-close (point))
-                (c-add-syntax 'inline-close (point))))
-
-             ;; CASE 16F: Can be a defun-close of a function declared
-             ;; in a statement block, e.g. in Pike or when using gcc
-             ;; extensions, but watch out for macros followed by
-             ;; blocks.  Let it through to be handled below.
-             ;; C.f. cases B.3 and 17G.
-             ((save-excursion
-                (and (not (c-at-statement-start-p))
-                     (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
-                     (setq placeholder (point))
-                     (let ((c-recognize-typeless-decls nil))
-                       ;; Turn off recognition of constructs that
-                       ;; lacks a type in this case, since that's more
-                       ;; likely to be a macro followed by a block.
-                       (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
-              (back-to-indentation)
-              (if (/= (point) containing-sexp)
-                  (goto-char placeholder))
-              (c-add-stmt-syntax 'defun-close nil t lim paren-state))
-
-             ;; CASE 16C: If there is an enclosing brace then this is
-             ;; a block close since defun closes inside declaration
-             ;; level blocks have been handled above.
-             (lim
-              ;; If the block is preceded by a case/switch label on
-              ;; the same line, we anchor at the first preceding label
-              ;; at boi.  The default handling in c-add-stmt-syntax
-              ;; really fixes it better, but we do like this to keep
-              ;; the indentation compatible with version 5.28 and
-              ;; earlier.  C.f. case 17H.
-              (while (and (/= (setq placeholder (point)) (c-point 'boi))
-                          (eq (c-beginning-of-statement-1 lim) 'label)))
-              (goto-char placeholder)
-              (if (looking-at c-label-kwds-regexp)
-                  (c-add-syntax 'block-close (point))
-                (goto-char containing-sexp)
-                ;; c-backward-to-block-anchor not necessary here; those
-                ;; situations are handled in case 16E above.
-                (c-add-stmt-syntax 'block-close nil t lim paren-state)))
-
-             ;; CASE 16D: Only top level defun close left.
-             (t
-              (goto-char containing-sexp)
-              (c-backward-to-decl-anchor lim)
-              (c-add-stmt-syntax 'defun-close nil nil
-                                 (c-most-enclosing-brace paren-state)
-                                 paren-state))
-             ))
+         ;; CASE 16B: does this close an inline or a function in
+         ;; a non-class declaration level block?
+         ((save-excursion
+            (and lim
+                 (progn
+                   (goto-char lim)
+                   (c-looking-at-decl-block
+                    (c-most-enclosing-brace paren-state lim)
+                    nil))
+                 (setq placeholder (point))))
+          (c-backward-to-decl-anchor lim)
+          (back-to-indentation)
+          (if (save-excursion
+                (goto-char placeholder)
+                (looking-at c-other-decl-block-key))
+              (c-add-syntax 'defun-close (point))
+            (c-add-syntax 'inline-close (point))))
+
+         ;; CASE 16F: Can be a defun-close of a function declared
+         ;; in a statement block, e.g. in Pike or when using gcc
+         ;; extensions, but watch out for macros followed by
+         ;; blocks.  Let it through to be handled below.
+         ;; C.f. cases B.3 and 17G.
+         ((save-excursion
+            (and (not (c-at-statement-start-p))
+                 (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
+                 (setq placeholder (point))
+                 (let ((c-recognize-typeless-decls nil))
+                   ;; Turn off recognition of constructs that
+                   ;; lacks a type in this case, since that's more
+                   ;; likely to be a macro followed by a block.
+                   (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
+          (back-to-indentation)
+          (if (/= (point) containing-sexp)
+              (goto-char placeholder))
+          (c-add-stmt-syntax 'defun-close nil t lim paren-state))
+
+         ;; CASE 16C: If there is an enclosing brace then this is
+         ;; a block close since defun closes inside declaration
+         ;; level blocks have been handled above.
+         (lim
+          ;; If the block is preceded by a case/switch label on
+          ;; the same line, we anchor at the first preceding label
+          ;; at boi.  The default handling in c-add-stmt-syntax
+          ;; really fixes it better, but we do like this to keep
+          ;; the indentation compatible with version 5.28 and
+          ;; earlier.  C.f. case 17H.
+          (while (and (/= (setq placeholder (point)) (c-point 'boi))
+                      (eq (c-beginning-of-statement-1 lim) 'label)))
+          (goto-char placeholder)
+          (if (looking-at c-label-kwds-regexp)
+              (c-add-syntax 'block-close (point))
+            (goto-char containing-sexp)
+            ;; c-backward-to-block-anchor not necessary here; those
+            ;; situations are handled in case 16E above.
+            (c-add-stmt-syntax 'block-close nil t lim paren-state)))
 
-         ;; CASE 17: Statement or defun catchall.
+         ;; CASE 16D: Only top level defun close left.
          (t
-          (goto-char indent-point)
-          ;; Back up statements until we find one that starts at boi.
-          (while (let* ((prev-point (point))
-                        (last-step-type (c-beginning-of-statement-1
-                                         containing-sexp)))
-                   (if (= (point) prev-point)
-                       (progn
-                         (setq step-type (or step-type last-step-type))
-                         nil)
-                     (setq step-type last-step-type)
-                     (/= (point) (c-point 'boi)))))
-          (cond
+          (goto-char containing-sexp)
+          (c-backward-to-decl-anchor lim)
+          (c-add-stmt-syntax 'defun-close nil nil
+                             (c-most-enclosing-brace paren-state)
+                             paren-state))
+         ))
 
-           ;; CASE 17B: continued statement
-           ((and (eq step-type 'same)
-                 (/= (point) indent-point))
-            (c-add-stmt-syntax 'statement-cont nil nil
-                               containing-sexp paren-state))
-
-           ;; CASE 17A: After a case/default label?
-           ((progn
-              (while (and (eq step-type 'label)
-                          (not (looking-at c-label-kwds-regexp)))
-                (setq step-type
-                      (c-beginning-of-statement-1 containing-sexp)))
-              (eq step-type 'label))
-            (c-add-stmt-syntax (if (eq char-after-ip ?{)
-                                   'statement-case-open
-                                 'statement-case-intro)
-                               nil t containing-sexp paren-state))
-
-           ;; CASE 17D: any old statement
-           ((progn
-              (while (eq step-type 'label)
-                (setq step-type
-                      (c-beginning-of-statement-1 containing-sexp)))
-              (eq step-type 'previous))
-            (c-add-stmt-syntax 'statement nil t
-                               containing-sexp paren-state)
-            (if (eq char-after-ip ?{)
-                (c-add-syntax 'block-open)))
-
-           ;; CASE 17I: Inside a substatement block.
-           ((progn
-              ;; The following tests are all based on containing-sexp.
-              (goto-char containing-sexp)
-              ;; From here on we have the next containing sexp in lim.
-              (setq lim (c-most-enclosing-brace paren-state containing-sexp))
-              (c-after-conditional))
-            (c-backward-to-block-anchor lim)
-            (c-add-stmt-syntax 'statement-block-intro nil t
-                               lim paren-state)
-            (if (eq char-after-ip ?{)
-                (c-add-syntax 'block-open)))
-
-           ;; CASE 17E: first statement in an in-expression block.
-           ;; C.f. cases 4, 7B and 16A.
-           ((setq placeholder (c-looking-at-inexpr-block
-                               (c-safe-position containing-sexp paren-state)
-                               nil))
-            (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
-                                'defun-block-intro
-                              'statement-block-intro))
-            (back-to-indentation)
-            (if (= containing-sexp (point))
-                (c-add-syntax tmpsymbol (point))
-              (goto-char (cdr placeholder))
-              (back-to-indentation)
-              (c-add-stmt-syntax tmpsymbol nil t
-                                 (c-most-enclosing-brace c-state-cache (point))
-                                 paren-state)
-              (if (/= (point) (cdr placeholder))
-                  (c-add-syntax (car placeholder))))
-            (if (eq char-after-ip ?{)
-                (c-add-syntax 'block-open)))
-
-           ;; CASE 17F: first statement in an inline, or first
-           ;; statement in a top-level defun. we can tell this is it
-           ;; if there are no enclosing braces that haven't been
-           ;; narrowed out by a class (i.e. don't use bod here).
-           ((save-excursion
-              (or (not (setq placeholder (c-most-enclosing-brace
-                                          paren-state)))
-                  (and (progn
-                         (goto-char placeholder)
-                         (eq (char-after) ?{))
-                       (c-looking-at-decl-block (c-most-enclosing-brace
-                                                 paren-state (point))
-                                                nil))))
-            (c-backward-to-decl-anchor lim)
-            (back-to-indentation)
-            (c-add-syntax 'defun-block-intro (point)))
+       ;; CASE 17: Statement or defun catchall.
+       (t
+        (goto-char indent-point)
+        ;; Back up statements until we find one that starts at boi.
+        (while (let* ((prev-point (point))
+                      (last-step-type (c-beginning-of-statement-1
+                                       containing-sexp)))
+                 (if (= (point) prev-point)
+                     (progn
+                       (setq step-type (or step-type last-step-type))
+                       nil)
+                   (setq step-type last-step-type)
+                   (/= (point) (c-point 'boi)))))
+        (cond
 
-           ;; CASE 17G: First statement in a function declared inside
-           ;; a normal block.  This can occur in Pike and with
-           ;; e.g. the gcc extensions, but watch out for macros
-           ;; followed by blocks.  C.f. cases B.3 and 16F.
-           ((save-excursion
-              (and (not (c-at-statement-start-p))
-                   (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
-                   (setq placeholder (point))
-                   (let ((c-recognize-typeless-decls nil))
-                     ;; Turn off recognition of constructs that lacks
-                     ;; a type in this case, since that's more likely
-                     ;; to be a macro followed by a block.
-                     (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
+         ;; CASE 17B: continued statement
+         ((and (eq step-type 'same)
+               (/= (point) indent-point))
+          (c-add-stmt-syntax 'statement-cont nil nil
+                             containing-sexp paren-state))
+
+         ;; CASE 17A: After a case/default label?
+         ((progn
+            (while (and (eq step-type 'label)
+                        (not (looking-at c-label-kwds-regexp)))
+              (setq step-type
+                    (c-beginning-of-statement-1 containing-sexp)))
+            (eq step-type 'label))
+          (c-add-stmt-syntax (if (eq char-after-ip ?{)
+                                 'statement-case-open
+                               'statement-case-intro)
+                             nil t containing-sexp paren-state))
+
+         ;; CASE 17D: any old statement
+         ((progn
+            (while (eq step-type 'label)
+              (setq step-type
+                    (c-beginning-of-statement-1 containing-sexp)))
+            (eq step-type 'previous))
+          (c-add-stmt-syntax 'statement nil t
+                             containing-sexp paren-state)
+          (if (eq char-after-ip ?{)
+              (c-add-syntax 'block-open)))
+
+         ;; CASE 17I: Inside a substatement block.
+         ((progn
+            ;; The following tests are all based on containing-sexp.
+            (goto-char containing-sexp)
+            ;; From here on we have the next containing sexp in lim.
+            (setq lim (c-most-enclosing-brace paren-state containing-sexp))
+            (c-after-conditional))
+          (c-backward-to-block-anchor lim)
+          (c-add-stmt-syntax 'statement-block-intro nil t
+                             lim paren-state)
+          (if (eq char-after-ip ?{)
+              (c-add-syntax 'block-open)))
+
+         ;; CASE 17E: first statement in an in-expression block.
+         ;; C.f. cases 4, 7B and 16A.
+         ((setq placeholder (c-looking-at-inexpr-block
+                             (c-safe-position containing-sexp paren-state)
+                             nil))
+          (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+                              'defun-block-intro
+                            'statement-block-intro))
+          (back-to-indentation)
+          (if (= containing-sexp (point))
+              (c-add-syntax tmpsymbol (point))
+            (goto-char (cdr placeholder))
             (back-to-indentation)
-            (if (/= (point) containing-sexp)
-                (goto-char placeholder))
-            (c-add-stmt-syntax 'defun-block-intro nil t
-                               lim paren-state))
+            (c-add-stmt-syntax tmpsymbol nil t
+                               (c-most-enclosing-brace c-state-cache (point))
+                               paren-state)
+            (if (/= (point) (cdr placeholder))
+                (c-add-syntax (car placeholder))))
+          (if (eq char-after-ip ?{)
+              (c-add-syntax 'block-open)))
+
+         ;; CASE 17F: first statement in an inline, or first
+         ;; statement in a top-level defun. we can tell this is it
+         ;; if there are no enclosing braces that haven't been
+         ;; narrowed out by a class (i.e. don't use bod here).
+         ((save-excursion
+            (or (not (setq placeholder (c-most-enclosing-brace
+                                        paren-state)))
+                (and (progn
+                       (goto-char placeholder)
+                       (eq (char-after) ?{))
+                     (c-looking-at-decl-block (c-most-enclosing-brace
+                                               paren-state (point))
+                                              nil))))
+          (c-backward-to-decl-anchor lim)
+          (back-to-indentation)
+          (c-add-syntax 'defun-block-intro (point)))
 
-           ;; CASE 17H: First statement in a block.
-           (t
-            ;; If the block is preceded by a case/switch label on the
-            ;; same line, we anchor at the first preceding label at
-            ;; boi.  The default handling in c-add-stmt-syntax is
-            ;; really fixes it better, but we do like this to keep the
-            ;; indentation compatible with version 5.28 and earlier.
-            ;; C.f. case 16C.
-            (while (and (/= (setq placeholder (point)) (c-point 'boi))
-                        (eq (c-beginning-of-statement-1 lim) 'label)))
-            (goto-char placeholder)
-            (if (looking-at c-label-kwds-regexp)
-                (c-add-syntax 'statement-block-intro (point))
-              (goto-char containing-sexp)
-              ;; c-backward-to-block-anchor not necessary here; those
-              ;; situations are handled in case 17I above.
-              (c-add-stmt-syntax 'statement-block-intro nil t
-                                 lim paren-state))
-            (if (eq char-after-ip ?{)
-                (c-add-syntax 'block-open)))
-           ))
-         )
+         ;; CASE 17G: First statement in a function declared inside
+         ;; a normal block.  This can occur in Pike and with
+         ;; e.g. the gcc extensions, but watch out for macros
+         ;; followed by blocks.  C.f. cases B.3 and 16F.
+         ((save-excursion
+            (and (not (c-at-statement-start-p))
+                 (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
+                 (setq placeholder (point))
+                 (let ((c-recognize-typeless-decls nil))
+                   ;; Turn off recognition of constructs that lacks
+                   ;; a type in this case, since that's more likely
+                   ;; to be a macro followed by a block.
+                   (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
+          (back-to-indentation)
+          (if (/= (point) containing-sexp)
+              (goto-char placeholder))
+          (c-add-stmt-syntax 'defun-block-intro nil t
+                             lim paren-state))
 
-        ;; now we need to look at any modifiers
-        (goto-char indent-point)
-        (skip-chars-forward " \t")
+         ;; CASE 17H: First statement in a block.
+         (t
+          ;; If the block is preceded by a case/switch label on the
+          ;; same line, we anchor at the first preceding label at
+          ;; boi.  The default handling in c-add-stmt-syntax is
+          ;; really fixes it better, but we do like this to keep the
+          ;; indentation compatible with version 5.28 and earlier.
+          ;; C.f. case 16C.
+          (while (and (/= (setq placeholder (point)) (c-point 'boi))
+                      (eq (c-beginning-of-statement-1 lim) 'label)))
+          (goto-char placeholder)
+          (if (looking-at c-label-kwds-regexp)
+              (c-add-syntax 'statement-block-intro (point))
+            (goto-char containing-sexp)
+            ;; c-backward-to-block-anchor not necessary here; those
+            ;; situations are handled in case 17I above.
+            (c-add-stmt-syntax 'statement-block-intro nil t
+                               lim paren-state))
+          (if (eq char-after-ip ?{)
+              (c-add-syntax 'block-open)))
+         ))
+       )
+
+      ;; now we need to look at any modifiers
+      (goto-char indent-point)
+      (skip-chars-forward " \t")
+
+      ;; are we looking at a comment only line?
+      (when (and (looking-at c-comment-start-regexp)
+                 (/= (c-forward-token-2 0 nil (c-point 'eol)) 0))
+        (c-append-syntax 'comment-intro))
+
+      ;; we might want to give additional offset to friends (in C++).
+      (when (and c-opt-friend-key
+                 (looking-at c-opt-friend-key))
+        (c-append-syntax 'friend))
+
+      ;; Set syntactic-relpos.
+      (let ((p c-syntactic-context))
+        (while (and p
+                    (if (integerp (c-langelem-pos (car p)))
+                        (progn
+                          (setq syntactic-relpos (c-langelem-pos (car p)))
+                          nil)
+                      t))
+          (setq p (cdr p))))
 
-        ;; are we looking at a comment only line?
-        (when (and (looking-at c-comment-start-regexp)
-                   (/= (c-forward-token-2 0 nil (c-point 'eol)) 0))
-          (c-append-syntax 'comment-intro))
-
-        ;; we might want to give additional offset to friends (in C++).
-        (when (and c-opt-friend-key
-                   (looking-at c-opt-friend-key))
-          (c-append-syntax 'friend))
-
-        ;; Set syntactic-relpos.
-        (let ((p c-syntactic-context))
-          (while (and p
-                      (if (integerp (c-langelem-pos (car p)))
-                          (progn
-                            (setq syntactic-relpos (c-langelem-pos (car p)))
-                            nil)
-                        t))
-            (setq p (cdr p))))
-
-        ;; Start of or a continuation of a preprocessor directive?
-        (if (and macro-start
-                 (eq macro-start (c-point 'boi))
-                 (not (and (c-major-mode-is 'pike-mode)
-                           (eq (char-after (1+ macro-start)) ?\"))))
-            (c-append-syntax 'cpp-macro)
-          (when (and c-syntactic-indentation-in-macros macro-start)
-            (if in-macro-expr
-                (when (or
-                       (< syntactic-relpos macro-start)
-                       (not (or
-                             (assq 'arglist-intro c-syntactic-context)
-                             (assq 'arglist-cont c-syntactic-context)
-                             (assq 'arglist-cont-nonempty c-syntactic-context)
-                             (assq 'arglist-close c-syntactic-context))))
-                  ;; If inside a cpp expression, i.e. anywhere in a
-                  ;; cpp directive except a #define body, we only let
-                  ;; through the syntactic analysis that is internal
-                  ;; in the expression.  That means the arglist
-                  ;; elements, if they are anchored inside the cpp
-                  ;; expression.
-                  (setq c-syntactic-context nil)
-                  (c-add-syntax 'cpp-macro-cont macro-start))
-              (when (and (eq macro-start syntactic-relpos)
-                         (not (assq 'cpp-define-intro c-syntactic-context))
-                         (save-excursion
-                           (goto-char macro-start)
-                           (or (not (c-forward-to-cpp-define-body))
-                               (<= (point) (c-point 'boi indent-point)))))
-                ;; Inside a #define body and the syntactic analysis is
-                ;; anchored on the start of the #define.  In this case
-                ;; we add cpp-define-intro to get the extra
-                ;; indentation of the #define body.
-                (c-add-syntax 'cpp-define-intro)))))
-
-        ;; return the syntax
-        c-syntactic-context)))
+      ;; Start of or a continuation of a preprocessor directive?
+      (if (and macro-start
+               (eq macro-start (c-point 'boi))
+               (not (and (c-major-mode-is 'pike-mode)
+                         (eq (char-after (1+ macro-start)) ?\"))))
+          (c-append-syntax 'cpp-macro)
+        (when (and c-syntactic-indentation-in-macros macro-start)
+          (if in-macro-expr
+              (when (or
+                     (< syntactic-relpos macro-start)
+                     (not (or
+                           (assq 'arglist-intro c-syntactic-context)
+                           (assq 'arglist-cont c-syntactic-context)
+                           (assq 'arglist-cont-nonempty c-syntactic-context)
+                           (assq 'arglist-close c-syntactic-context))))
+                ;; If inside a cpp expression, i.e. anywhere in a
+                ;; cpp directive except a #define body, we only let
+                ;; through the syntactic analysis that is internal
+                ;; in the expression.  That means the arglist
+                ;; elements, if they are anchored inside the cpp
+                ;; expression.
+                (setq c-syntactic-context nil)
+                (c-add-syntax 'cpp-macro-cont macro-start))
+            (when (and (eq macro-start syntactic-relpos)
+                       (not (assq 'cpp-define-intro c-syntactic-context))
+                       (save-excursion
+                         (goto-char macro-start)
+                         (or (not (c-forward-to-cpp-define-body))
+                             (<= (point) (c-point 'boi indent-point)))))
+              ;; Inside a #define body and the syntactic analysis is
+              ;; anchored on the start of the #define.  In this case
+              ;; we add cpp-define-intro to get the extra
+              ;; indentation of the #define body.
+              (c-add-syntax 'cpp-define-intro)))))
+
+      ;; return the syntax
+      c-syntactic-context)))
 
 
 ;; Indentation calculation.