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

1 files changed, 1360 insertions, 1360 deletions

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.