Update CC Mode to release 5.31.

1 files changed, 581 insertions, 1148 deletions

diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 95e4e5226f..e5dcecf459 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -1,6 +1,6 @@
 ;;; cc-fonts.el --- font lock support for CC Mode
 
-;; Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+;; Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
 ;; Authors:    2003- Alan Mackenzie
 ;;             2002- Martin Stjernholm
@@ -30,8 +30,8 @@
 
 ;; Some comments on the use of faces:
 ;;
-;; o  `c-label-face-name' is either `font-lock-constant-face' (in Emacs
-;;    20 and later), or `font-lock-reference-face'.
+;; o  `c-label-face-name' is either `font-lock-constant-face' (in
+;;    Emacs), or `font-lock-reference-face'.
 ;;
 ;; o  `c-constant-face-name', `c-reference-face-name' and
 ;;    `c-doc-markup-face-name' are essentially set up like
@@ -47,10 +47,6 @@
 ;;    documentation are actually comments in these languages, as opposed
 ;;    to elisp).
 ;;
-;; o  `c-invalid-face-name' is `font-lock-warning-face' in Emacs.  In
-;;    older XEmacs there's no corresponding standard face, so there
-;;    it's mapped to a special `c-invalid-face'.
-;;
 ;; TBD: We should probably provide real faces for the above uses and
 ;; instead initialize them from the standard faces.
 
@@ -103,17 +99,9 @@
 (cc-bytecomp-defvar c-reference-face-name)
 (cc-bytecomp-defun c-fontify-recorded-types-and-refs)
 (cc-bytecomp-defun c-font-lock-declarators)
-(cc-bytecomp-defun c-font-lock-objc-iip-decl)
 (cc-bytecomp-defun c-font-lock-objc-method)
 (cc-bytecomp-defun c-font-lock-invalid-string)
 
-;; Emacs 19 doesn't have `defface'.  This "replacement" leaves a lot
-;; to be wished for but at least it avoids any errors.
-(cc-eval-when-compile
-  (or (fboundp 'defface)
-      (cc-bytecomp-defmacro defface (face spec doc &rest args)
-	`(make-face ',face))))
-
 
 ;; Note that font-lock in XEmacs doesn't expand face names as
 ;; variables, so we have to use the (eval . FORM) in the font lock
@@ -124,8 +112,8 @@
 	 ;; XEmacs has a font-lock-preprocessor-face.
 	 'font-lock-preprocessor-face)
 	((c-face-name-p 'font-lock-builtin-face)
-	 ;; In Emacs 20 and later font-lock-builtin-face has
-	 ;; traditionally been used for preprocessor directives.
+	 ;; In Emacs font-lock-builtin-face has traditionally been
+	 ;; used for preprocessor directives.
 	 'font-lock-builtin-face)
 	(t
 	 'font-lock-reference-face)))
@@ -150,19 +138,19 @@
 (defconst c-constant-face-name
   (if (and (c-face-name-p 'font-lock-constant-face)
 	   (eq font-lock-constant-face 'font-lock-constant-face))
-      ;; This doesn't exist in XEmacs <= 20 and some earlier versions
-      ;; of XEmacs 21.
+      ;; This doesn't exist in some earlier versions of XEmacs 21.
       'font-lock-constant-face
     c-label-face-name))
 
 (defconst c-reference-face-name
-  (if (and (c-face-name-p 'font-lock-reference-face)
-	   (eq font-lock-reference-face 'font-lock-reference-face))
-      ;; This is considered obsolete in Emacs 20 and later, but it
-      ;; still maps well to this use.  (Another reason to do this is
-      ;; to get unique faces for the test suite.)
-      'font-lock-reference-face
-    c-label-face-name))
+  (with-no-warnings
+   (if (and (c-face-name-p 'font-lock-reference-face)
+	    (eq font-lock-reference-face 'font-lock-reference-face))
+       ;; This is considered obsolete in Emacs, but it still maps well
+       ;; to this use.  (Another reason to do this is to get unique
+       ;; faces for the test suite.)
+       'font-lock-reference-face
+     c-label-face-name)))
 
 ;; This should not mapped to a face that also is used to fontify things
 ;; that aren't comments or string literals.
@@ -184,31 +172,10 @@
 	 'font-lock-doc-markup-face
     c-label-face-name))
 
-(defconst c-invalid-face-name
-  (if (c-face-name-p 'font-lock-warning-face)
-      ;; Emacs >= 20 and XEmacs >= 21 has a font-lock-warning-face.
-      'font-lock-warning-face
-    ;; Otherwise we provide a face.
-    'c-invalid-face))
-
-(unless (c-face-name-p c-invalid-face-name)
-  (defconst c-invalid-face 'c-invalid-face) ; Necessary in Emacs 19.
-  ;; This face should be called `c-invalid' for consistency with the
-  ;; rest of emacs, but as it's only used in very old versions of Emacs,
-  ;; we leave it unchanged (the face-alias mechanism doesn't exist in
-  ;; those old versions).
-  (defface c-invalid-face
-    '((((class color) (background light)) (:foreground "red1"))
-      (((class color)) (:foreground "hotpink"))
-      (t (:inverse-video t)))
-    "Face used to highlight invalid syntax."
-    :group 'c-fonts))
-
-;; To make hard spaces visible an inverted version of
-;; `c-invalid-face-name' is used.  Since font-lock in Emacs expands
-;; all face names in `font-lock-keywords' as variables we need to have
-;; a variable for it.
-(defconst c-nonbreakable-space-face 'c-nonbreakable-space)
+(defconst c-negation-char-face-name
+  (if (c-face-name-p 'font-lock-negation-char-face)
+      ;; Emacs 22 has a special face for negation chars.
+      'font-lock-negation-char-face))
 
 (cc-bytecomp-defun face-inverse-video-p) ; Only in Emacs.
 (cc-bytecomp-defun face-property-instance) ; Only in XEmacs.
@@ -216,25 +183,18 @@
 (defun c-make-inverse-face (oldface newface)
   ;; Emacs and XEmacs have completely different face manipulation
   ;; routines. :P
-  ;;
-  ;; This function does not do any hidden buffer changes
   (copy-face oldface newface)
   (cond ((fboundp 'face-inverse-video-p)
-	 ;; Emacs 20 and later.  This only looks at the inverse flag
-	 ;; in the current frame.  Other display configurations might
-	 ;; be different, but it can only show if the same Emacs has
-	 ;; frames on e.g. a color and a monochrome display
-	 ;; simultaneously.
+	 ;; Emacs.  This only looks at the inverse flag in the current
+	 ;; frame.  Other display configurations might be different,
+	 ;; but it can only show if the same Emacs has frames on
+	 ;; e.g. a color and a monochrome display simultaneously.
 	 (unless (face-inverse-video-p oldface)
 	   (invert-face newface)))
 	((fboundp 'face-property-instance)
 	 ;; XEmacs.  Same pitfall here.
 	 (unless (face-property-instance oldface 'reverse)
-	   (invert-face newface)))
-	(t
-	 ;; Emacs 19 has no inverse flag at all.  Just inverse the
-	 ;; face and hope it wasn't inversed already.
-	 (invert-face newface))))
+	   (invert-face newface)))))
 
 (eval-and-compile
   ;; We need the following functions during compilation since they're
@@ -247,6 +207,8 @@
     ;; additional font-lock property, or else the font-lock package
     ;; won't recognize it as fontified and might override it
     ;; incorrectly.
+    ;;
+    ;; This function does a hidden buffer change.
     (if (fboundp 'font-lock-set-face)
 	;; Note: This function has no docstring in XEmacs so it might be
 	;; considered internal.
@@ -255,6 +217,8 @@
 
   (defmacro c-remove-font-lock-face (from to)
     ;; This is the inverse of `c-put-font-lock-face'.
+    ;;
+    ;; This function does a hidden buffer change.
     (if (fboundp 'font-lock-remove-face)
 	`(font-lock-remove-face ,from ,to)
       `(remove-text-properties ,from ,to '(face nil))))
@@ -263,6 +227,8 @@
     ;; Put `font-lock-string-face' on a string.  The surrounding
     ;; quotes are included in Emacs but not in XEmacs.  The passed
     ;; region should include them.
+    ;;
+    ;; This function does a hidden buffer change.
     (if (featurep 'xemacs)
 	`(c-put-font-lock-face (1+ ,from) (1- ,to) 'font-lock-string-face)
       `(c-put-font-lock-face ,from ,to 'font-lock-string-face)))
@@ -271,19 +237,22 @@
     ;; Like `let', but additionally activates `c-record-type-identifiers'
     ;; and `c-record-ref-identifiers', and fontifies the recorded ranges
     ;; accordingly on exit.
+    ;;
+    ;; This function does hidden buffer changes.
     `(let ((c-record-type-identifiers t)
 	   c-record-ref-identifiers
 	   ,@varlist)
        (prog1 (progn ,@body)
 	 (c-fontify-recorded-types-and-refs))))
   (put 'c-fontify-types-and-refs 'lisp-indent-function 1)
-  (eval-after-load "edebug" '(def-edebug-spec c-fontify-types-and-refs let*))
 
   (defun c-skip-comments-and-strings (limit)
     ;; If the point is within a region fontified as a comment or
     ;; string literal skip to the end of it or to LIMIT, whichever
     ;; comes first, and return t.  Otherwise return nil.  The match
     ;; data is not clobbered.
+    ;;
+    ;; This function might do hidden buffer changes.
     (when (c-got-face-at (point) c-literal-faces)
       (while (progn
 	       (goto-char (next-single-property-change
@@ -292,6 +261,26 @@
 		    (c-got-face-at (point) c-literal-faces))))
       t))
 
+  (defun c-make-syntactic-matcher (regexp)
+    ;; Returns a byte compiled function suitable for use in place of a
+    ;; regexp string in a `font-lock-keywords' matcher, except that
+    ;; only matches outside comments and string literals count.
+    ;;
+    ;; This function does not do any hidden buffer changes, but the
+    ;; generated functions will.  (They are however used in places
+    ;; covered by the font-lock context.)
+    (byte-compile
+     `(lambda (limit)
+	(let (res)
+	  (while (and (setq res (re-search-forward ,regexp limit t))
+		      (progn
+			(goto-char (match-beginning 0))
+			(or (c-skip-comments-and-strings limit)
+			    (progn
+			      (goto-char (match-end 0))
+			      nil)))))
+	  res))))
+
   (defun c-make-font-lock-search-function (regexp &rest highlights)
     ;; This function makes a byte compiled function that works much like
     ;; a matcher element in `font-lock-keywords'.  It cuts out a little
@@ -315,32 +304,30 @@
     ;; the anchored matcher forms.
     ;;
     ;; This function does not do any hidden buffer changes, but the
-    ;; generated functions will.  They are however used in places
-    ;; covered by the font-lock context.
+    ;; generated functions will.  (They are however used in places
+    ;; covered by the font-lock context.)
 
     ;; Note: Replace `byte-compile' with `eval' to debug the generated
     ;; lambda easier.
     (byte-compile
      `(lambda (limit)
-	(let (-match-end-pos-
-	      ;; The font-lock package in Emacs is known to clobber
+	(let (;; The font-lock package in Emacs is known to clobber
 	      ;; `parse-sexp-lookup-properties' (when it exists).
 	      (parse-sexp-lookup-properties
 	       (cc-eval-when-compile
 		 (boundp 'parse-sexp-lookup-properties))))
 	  (while (re-search-forward ,regexp limit t)
-	    (setq -match-end-pos- (point))
 	    (unless (progn
 		      (goto-char (match-beginning 0))
 		      (c-skip-comments-and-strings limit))
-	      (goto-char -match-end-pos-)
+	      (goto-char (match-end 0))
 	      ,@(mapcar
 		 (lambda (highlight)
 		   (if (integerp (car highlight))
 		       (progn
-			 (unless (nth 2 highlight)
+			 (unless (eq (nth 2 highlight) t)
 			   (error
-			    "The override flag must currently be set in %s"
+			    "The override flag must currently be t in %s"
 			    highlight))
 			 (when (nth 3 highlight)
 			   (error
@@ -359,11 +346,23 @@
 			(save-match-data ,(car highlight))
 			,(nth 2 highlight))))
 		 highlights))))
-	nil))))
+	nil)))
+
+  (eval-after-load "edebug"
+    '(progn
+       (def-edebug-spec c-fontify-types-and-refs let*)
+       (def-edebug-spec c-make-syntactic-matcher t)
+       ;; If there are literal quoted or backquoted highlight specs in
+       ;; the call to `c-make-font-lock-search-function' then let's
+       ;; instrument the forms in them.
+       (def-edebug-spec c-make-font-lock-search-function
+	 (form &rest &or ("quote" (&rest form)) ("`" (&rest form)) form)))))
 
 (defun c-fontify-recorded-types-and-refs ()
-  ;; Converts the ranges recorded on `c-record-type-identifiers' and
+  ;; Convert the ranges recorded on `c-record-type-identifiers' and
   ;; `c-record-ref-identifiers' to fontification.
+  ;;
+  ;; This function does hidden buffer changes.
   (let (elem)
     (while (consp c-record-type-identifiers)
       (setq elem (car c-record-type-identifiers)
@@ -388,108 +387,123 @@ stuff.  Used on level 1 and higher."
 
   t `(,@(when (c-lang-const c-opt-cpp-prefix)
 	  (let* ((noncontinued-line-end "\\(\\=\\|\\(\\=\\|[^\\]\\)[\n\r]\\)")
-		 (ncle-depth (c-regexp-opt-depth noncontinued-line-end))
-		 (sws-depth (c-lang-const c-syntactic-ws-depth)))
+		 (ncle-depth (regexp-opt-depth noncontinued-line-end))
+		 (sws-depth (c-lang-const c-syntactic-ws-depth))
+		 (nsws-depth (c-lang-const c-nonempty-syntactic-ws-depth)))
+
 	    `(;; The stuff after #error and #warning is a message, so
 	      ;; fontify it as a string.
-	      (,(concat noncontinued-line-end
-			(c-lang-const c-opt-cpp-prefix)
-			"\\(error\\|warning\\)\\>\\s *\\(.*\\)$")
-	       ,(+ ncle-depth 2) font-lock-string-face)
+	      ,@(when (c-lang-const c-cpp-message-directives)
+		  (let* ((re (c-make-keywords-re nil
+			       (c-lang-const c-cpp-message-directives)))
+			 (re-depth (regexp-opt-depth re)))
+		    `((,(concat noncontinued-line-end
+				(c-lang-const c-opt-cpp-prefix)
+				re
+				"\\s +\\(.*\\)$")
+		       ,(+ ncle-depth re-depth 1) font-lock-string-face))))
 
 	      ;; Fontify filenames in #include <...> as strings.
-	      (,(concat noncontinued-line-end
-			(c-lang-const c-opt-cpp-prefix)
-			"\\(import\\|include\\)\\>"
-			(c-lang-const c-syntactic-ws)
-			"\\(<[^>\n\r]*>?\\)")
-	       (,(+ ncle-depth sws-depth 2)
-		font-lock-string-face)
-
-	       ;; Use an anchored matcher to put paren syntax on the brackets.
-	       (,(byte-compile
-		  `(lambda (limit)
-		     (let ((beg-pos
-			    (match-beginning ,(+ ncle-depth sws-depth 2)))
-			   (end-pos
-			    (1- (match-end ,(+ ncle-depth sws-depth 2)))))
-		       (if (eq (char-after end-pos) ?>)
-			   (progn
-			     (c-mark-<-as-paren beg-pos)
-			     (c-mark->-as-paren end-pos))
-			 (c-clear-char-property beg-pos 'syntax-table)))
-		     nil))))
+	      ,@(when (c-lang-const c-cpp-include-directives)
+		  (let* ((re (c-make-keywords-re nil
+			       (c-lang-const c-cpp-include-directives)))
+			 (re-depth (regexp-opt-depth re)))
+		    `((,(concat noncontinued-line-end
+				(c-lang-const c-opt-cpp-prefix)
+				re
+				(c-lang-const c-syntactic-ws)
+				"\\(<[^>\n\r]*>?\\)")
+		       (,(+ ncle-depth re-depth sws-depth 1)
+			font-lock-string-face)
+
+		       ;; Use an anchored matcher to put paren syntax
+		       ;; on the brackets.
+		       (,(byte-compile
+			  `(lambda (limit)
+			     (let ((beg (match-beginning
+					 ,(+ ncle-depth re-depth sws-depth 1)))
+				   (end (1- (match-end ,(+ ncle-depth re-depth
+							   sws-depth 1)))))
+			       (if (eq (char-after end) ?>)
+				   (progn
+				     (c-mark-<-as-paren beg)
+				     (c-mark->-as-paren end))
+				 (c-clear-char-property beg 'syntax-table)))
+			     nil)))))))
 
 	      ;; #define.
-	      (,(c-make-font-lock-search-function
-		 (concat
-		  noncontinued-line-end
-		  (c-lang-const c-opt-cpp-prefix)
-		  "define\\>"
-		  (c-lang-const c-syntactic-ws)
-		  "\\(" (c-lang-const c-symbol-key) "\\)" ; 1 + ncle + sws
-		  (concat "\\("		; 2 + ncle + sws + c-sym-key
-			  ;; Macro with arguments - a "function".
-			  "\\(\(\\)"	; 3 + ncle + sws + c-sym-key
-			  "\\|"
-			  ;; Macro without arguments - a "variable".
-			  "\\([^\(]\\|$\\)"
-			  "\\)"))
-		 `((if (match-beginning ,(+ 3 ncle-depth sws-depth
-					    (c-lang-const c-symbol-key-depth)))
-		       ;; "Function".  Fontify the name and the arguments.
-		       (save-restriction
-			 (c-put-font-lock-face
-			  (match-beginning ,(+ 1 ncle-depth sws-depth))
-			  (match-end ,(+ 1 ncle-depth sws-depth))
-			  'font-lock-function-name-face)
-			 (goto-char (match-end
-				     ,(+ 3 ncle-depth sws-depth
-					 (c-lang-const c-symbol-key-depth))))
-
-			 (narrow-to-region (point-min) limit)
-			 (while (and
-				 (progn
-				   (c-forward-syntactic-ws)
-				   (looking-at c-symbol-key))
-				 (progn
-				   (c-put-font-lock-face
-				    (match-beginning 0) (match-end 0)
-				    'font-lock-variable-name-face)
-				   (goto-char (match-end 0))
-				   (c-forward-syntactic-ws)
-				   (eq (char-after) ?,)))
-			   (forward-char)))
-
-		     ;; "Variable".
-		     (c-put-font-lock-face
-		      (match-beginning ,(+ 1 ncle-depth sws-depth))
-		      (match-end ,(+ 1 ncle-depth sws-depth))
-		      'font-lock-variable-name-face)))))
+	      ,@(when (c-lang-const c-opt-cpp-macro-define)
+		  `((,(c-make-font-lock-search-function
+		       (concat
+			noncontinued-line-end
+			(c-lang-const c-opt-cpp-prefix)
+			(c-lang-const c-opt-cpp-macro-define)
+			(c-lang-const c-nonempty-syntactic-ws)
+			"\\(" (c-lang-const ; 1 + ncle + nsws
+			       c-symbol-key) "\\)"
+			(concat "\\("	; 2 + ncle + nsws + c-sym-key
+				;; Macro with arguments - a "function".
+				"\\(\(\\)" ; 3 + ncle + nsws + c-sym-key
+				"\\|"
+				;; Macro without arguments - a "variable".
+				"\\([^\(]\\|$\\)"
+				"\\)"))
+		       `((if (match-beginning
+			      ,(+ 3 ncle-depth nsws-depth
+				  (c-lang-const c-symbol-key-depth)))
+
+			     ;; "Function".  Fontify the name and the arguments.
+			     (save-restriction
+			       (c-put-font-lock-face
+				(match-beginning ,(+ 1 ncle-depth nsws-depth))
+				(match-end ,(+ 1 ncle-depth nsws-depth))
+				'font-lock-function-name-face)
+			       (goto-char
+				(match-end
+				 ,(+ 3 ncle-depth nsws-depth
+				     (c-lang-const c-symbol-key-depth))))
+
+			       (narrow-to-region (point-min) limit)
+			       (while (and
+				       (progn
+					 (c-forward-syntactic-ws)
+					 (looking-at c-symbol-key))
+				       (progn
+					 (c-put-font-lock-face
+					  (match-beginning 0) (match-end 0)
+					  'font-lock-variable-name-face)
+					 (goto-char (match-end 0))
+					 (c-forward-syntactic-ws)
+					 (eq (char-after) ?,)))
+				 (forward-char)))
+
+			   ;; "Variable".
+			   (c-put-font-lock-face
+			    (match-beginning ,(+ 1 ncle-depth nsws-depth))
+			    (match-end ,(+ 1 ncle-depth nsws-depth))
+			    'font-lock-variable-name-face)))))))
 
 	      ;; Fontify cpp function names in preprocessor
 	      ;; expressions in #if and #elif.
-	      ,(when (c-lang-const c-cpp-defined-fns)
-		 `(,(c-make-font-lock-search-function
-		     (concat noncontinued-line-end
-			     (c-lang-const c-opt-cpp-prefix)
-			     "\\(if\\|elif\\)\\>" ; 1 + ncle-depth
-			     ;; Match the whole logical line to look
-			     ;; for the functions in.
-			     "\\(\\\\\\(.\\|[\n\r]\\)\\|[^\n\r]\\)*")
-		     `((let ((limit (match-end 0)))
-			 (while (re-search-forward
-				 ,(concat "\\<\\("
-					  (c-regexp-opt
-					   (c-lang-const c-cpp-defined-fns)
-					   nil)
-					  "\\)\\>"
-					  "\\s *\(?")
-				 limit 'move)
-			   (c-put-font-lock-face (match-beginning 1)
-						 (match-end 1)
-						 c-preprocessor-face-name)))
-		       (goto-char (match-end ,(1+ ncle-depth)))))))
+	      ,@(when (and (c-lang-const c-cpp-expr-directives)
+			   (c-lang-const c-cpp-expr-functions))
+		  (let ((ced-re (c-make-keywords-re t
+				  (c-lang-const c-cpp-expr-directives)))
+			(cef-re (c-make-keywords-re t
+				  (c-lang-const c-cpp-expr-functions))))
+		    `((,(c-make-font-lock-search-function
+			 (concat noncontinued-line-end
+				 (c-lang-const c-opt-cpp-prefix)
+				 ced-re ; 1 + ncle-depth
+				 ;; Match the whole logical line to look
+				 ;; for the functions in.
+				 "\\(\\\\\\(.\\|[\n\r]\\)\\|[^\n\r]\\)*")
+			 `((let ((limit (match-end 0)))
+			     (while (re-search-forward ,cef-re limit 'move)
+			       (c-put-font-lock-face (match-beginning 1)
+						     (match-end 1)
+						     c-preprocessor-face-name)))
+			   (goto-char (match-end ,(1+ ncle-depth)))))))))
 
 	      ;; Fontify the directive names.
 	      (,(c-make-font-lock-search-function
@@ -500,45 +514,52 @@ stuff.  Used on level 1 and higher."
 			 "\\)")
 		 `(,(1+ ncle-depth) c-preprocessor-face-name t)))
 
-	      ;; fontify the n in ifndef
-	      (,(concat noncontinued-line-end
-			(c-lang-const c-opt-cpp-prefix)
-			"if\\(n\\)def\\>")
-	       ,(+ ncle-depth 1) font-lock-negation-char-face prepend)
+	      (eval . (list ,(c-make-syntactic-matcher
+			      (concat noncontinued-line-end
+				      (c-lang-const c-opt-cpp-prefix)
+				      "if\\(n\\)def\\>"))
+			    ,(+ ncle-depth 1)
+			    c-negation-char-face-name
+			    'append))
 	      )))
 
       ,@(when (c-major-mode-is 'pike-mode)
+	  ;; Recognize hashbangs in Pike.
 	  `((eval . (list "\\`#![^\n\r]*"
 			  0 c-preprocessor-face-name))))
 
-      ;; Make hard spaces visible through an inverted `c-invalid-face-name'.
+      ;; Make hard spaces visible through an inverted `font-lock-warning-face'.
       (eval . (list
 	       "\240"
 	       0 (progn
-		   (unless (c-face-name-p c-nonbreakable-space-face)
-		     (c-make-inverse-face c-invalid-face-name
-					  c-nonbreakable-space-face))
-		   'c-nonbreakable-space-face)))
+		   (unless (c-face-name-p 'c-nonbreakable-space-face)
+		     (c-make-inverse-face 'font-lock-warning-face
+					  'c-nonbreakable-space-face))
+		   ''c-nonbreakable-space-face)))
       ))
 
 (defun c-font-lock-invalid-string ()
   ;; Assuming the point is after the opening character of a string,
-  ;; fontify that char with `c-invalid-face-name' if the string
+  ;; fontify that char with `font-lock-warning-face' if the string
   ;; decidedly isn't terminated properly.
+  ;;
+  ;; This function does hidden buffer changes.
   (let ((start (1- (point))))
     (save-excursion
-      (and (nth 3 (parse-partial-sexp start (c-point 'eol)))
-	   (if (c-major-mode-is '(c-mode c++-mode objc-mode pike-mode))
+      (and (eq (elt (parse-partial-sexp start (c-point 'eol)) 8) start)
+	   (if (integerp c-multiline-string-start-char)
+	       ;; There's no multiline string start char before the
+	       ;; string, so newlines aren't allowed.
+	       (not (eq (char-before start) c-multiline-string-start-char))
+	     ;; Multiline strings are allowed anywhere if
+	     ;; c-multiline-string-start-char is t.
+	     (not c-multiline-string-start-char))
+	   (if c-string-escaped-newlines
 	       ;; There's no \ before the newline.
 	       (not (eq (char-before (point)) ?\\))
-	     ;; Quoted newlines aren't supported.
+	     ;; Escaped newlines aren't supported.
 	     t)
-	   (if (c-major-mode-is 'pike-mode)
-	       ;; There's no # before the string, so newlines
-	       ;; aren't allowed.
-	       (not (eq (char-before start) ?#))
-	     t)
-	   (c-put-font-lock-face start (1+ start) c-invalid-face-name)))))
+	   (c-put-font-lock-face start (1+ start) 'font-lock-warning-face)))))
 
 (c-lang-defconst c-basic-matchers-before
   "Font lock matchers for basic keywords, labels, references and various
@@ -566,18 +587,18 @@ casts and declarations are fontified.  Used on level 2 and higher."
 	  (let ((re (c-make-keywords-re nil (c-lang-const c-constant-kwds))))
 	    (if (c-major-mode-is 'pike-mode)
 		;; No symbol is a keyword after "->" in Pike.
-		`((eval . (list ,(concat "\\(\\=\\|\\(\\=\\|[^-]\\)[^>]\\)"
+		`((eval . (list ,(concat "\\(\\=.?\\|[^>]\\|[^-]>\\)"
 					 "\\<\\(" re "\\)\\>")
-				3 c-constant-face-name)))
+				2 c-constant-face-name)))
 	      `((eval . (list ,(concat "\\<\\(" re "\\)\\>")
 			      1 c-constant-face-name))))))
 
       ;; Fontify all keywords except the primitive types.
       ,(if (c-major-mode-is 'pike-mode)
 	   ;; No symbol is a keyword after "->" in Pike.
-	   `(,(concat "\\(\\=\\|\\(\\=\\|[^-]\\)[^>]\\)"
+	   `(,(concat "\\(\\=.?\\|[^>]\\|[^-]>\\)"
 		      "\\<" (c-lang-const c-regular-keywords-regexp))
-	     3 font-lock-keyword-face)
+	     2 font-lock-keyword-face)
 	 `(,(concat "\\<" (c-lang-const c-regular-keywords-regexp))
 	   1 font-lock-keyword-face))
 
@@ -596,9 +617,10 @@ casts and declarations are fontified.  Used on level 2 and higher."
 		  ;; Search for class identifiers preceded by ".".  The
 		  ;; anchored matcher takes it from there.
 		  (concat (c-lang-const c-opt-identifier-concat-key)
-			  "[ \t\n\r\f\v]*"
+			  (c-lang-const c-simple-ws) "*"
 			  (concat "\\("
-				  "[" c-upper "][" (c-lang-const c-symbol-chars) "]*"
+				  "[" c-upper "]"
+				  "[" (c-lang-const c-symbol-chars) "]*"
 				  "\\|"
 				  "\\*"
 				  "\\)"))
@@ -612,24 +634,26 @@ casts and declarations are fontified.  Used on level 2 and higher."
 				    (< (skip-chars-backward
 					,(c-lang-const c-symbol-chars)) 0))
 				  (not (get-text-property (point) 'face)))
-			(c-put-font-lock-face (point) id-end c-reference-face-name)
+			(c-put-font-lock-face (point) id-end
+					      c-reference-face-name)
 			(c-backward-syntactic-ws)))
 		    nil
 		    (goto-char (match-end 0)))))
 
 	    `((,(byte-compile
-		 ;; Must use a function here since we match longer than we
-		 ;; want to move before doing a new search.  This is not
-		 ;; necessary for XEmacs >= 20 since it restarts the search
-		 ;; from the end of the first highlighted submatch (something
-		 ;; that causes problems in other places).
+		 ;; Must use a function here since we match longer than
+		 ;; we want to move before doing a new search.  This is
+		 ;; not necessary for XEmacs since it restarts the
+		 ;; search from the end of the first highlighted
+		 ;; submatch (something that causes problems in other
+		 ;; places).
 		 `(lambda (limit)
 		    (while (re-search-forward
 			    ,(concat "\\(\\<" ; 1
 				     "\\(" (c-lang-const c-symbol-key) "\\)" ; 2
-				     "[ \t\n\r\f\v]*"
+				     (c-lang-const c-simple-ws) "*"
 				     (c-lang-const c-opt-identifier-concat-key)
-				     "[ \t\n\r\f\v]*"
+				     (c-lang-const c-simple-ws) "*"
 				     "\\)"
 				     "\\("
 				     (c-lang-const c-opt-after-id-concat-key)
@@ -660,29 +684,30 @@ casts and declarations are fontified.  Used on level 2 and higher."
 		  (if (> (point) limit) (goto-char limit)))))
 
 	    ;; The @interface/@implementation/@protocol directives.
-	    (,(concat "\\<"
-		      (c-regexp-opt
+	    ,(c-make-font-lock-search-function
+	      (concat "\\<"
+		      (regexp-opt
 		       '("@interface" "@implementation" "@protocol")
 		       t)
 		      "\\>")
-	     (,(byte-compile
-		(lambda (limit)
-		  (let (;; The font-lock package in Emacs is known to clobber
-			;; `parse-sexp-lookup-properties' (when it exists).
-			(parse-sexp-lookup-properties
-			 (cc-eval-when-compile
-			   (boundp 'parse-sexp-lookup-properties))))
-		    (save-restriction
-		      (narrow-to-region (point-min) limit)
-		      (c-font-lock-objc-iip-decl)))
-		  nil))))))
-
-      ("\\(!\\)[^=]" 1 font-lock-negation-char-face)
+	      '((c-fontify-types-and-refs
+		    (;; The font-lock package in Emacs is known to clobber
+		     ;; `parse-sexp-lookup-properties' (when it exists).
+		     (parse-sexp-lookup-properties
+		      (cc-eval-when-compile
+			(boundp 'parse-sexp-lookup-properties))))
+		  (c-forward-objc-directive)
+		  nil)
+		(goto-char (match-beginning 0))))))
+
+      (eval . (list "\\(!\\)[^=]" 1 c-negation-char-face-name))
       ))
 
 (defun c-font-lock-complex-decl-prepare (limit)
   ;; Called before any of the matchers in `c-complex-decl-matchers'.
   ;; Nil is always returned.
+  ;;
+  ;; This function does hidden buffer changes.
 
   ;;(message "c-font-lock-complex-decl-prepare %s %s" (point) limit)
 
@@ -718,17 +743,20 @@ casts and declarations are fontified.  Used on level 2 and higher."
 
 (defun c-font-lock-<>-arglists (limit)
   ;; Fontify types and references in names containing angle bracket
-  ;; arglists from the point to LIMIT.  This will also fontify cases
-  ;; like normal function calls on the form "foo (a < b, c > d)", but
-  ;; `c-font-lock-declarations' will undo that later.  Nil is always
-  ;; returned.
+  ;; arglists from the point to LIMIT.  Note that
+  ;; `c-font-lock-declarations' already has handled many of them.  Nil
+  ;; is always returned.
+  ;;
+  ;; This function might do hidden buffer changes.
 
   (let (;; The font-lock package in Emacs is known to clobber
 	;; `parse-sexp-lookup-properties' (when it exists).
 	(parse-sexp-lookup-properties
 	 (cc-eval-when-compile
 	   (boundp 'parse-sexp-lookup-properties)))
-	id-start id-end pos kwd-sym)
+	(c-parse-and-markup-<>-arglists t)
+	c-restricted-<>-arglists
+	id-start id-end id-face pos kwd-sym)
 
     (while (and (< (point) limit)
 		(re-search-forward c-opt-<>-arglist-start limit t))
@@ -739,28 +767,51 @@ casts and declarations are fontified.  Used on level 2 and higher."
 
       (goto-char id-start)
       (unless (c-skip-comments-and-strings limit)
-	(setq kwd-sym nil)
-	(if (or (not (eq (get-text-property id-start 'face)
-			 'font-lock-keyword-face))
-		(when (looking-at c-opt-<>-sexp-key)
-		  (setq kwd-sym (c-keyword-sym (match-string 1)))))
+	(setq kwd-sym nil
+	      c-restricted-<>-arglists nil
+	      id-face (get-text-property id-start 'face))
+
+	(if (cond
+	     ((eq id-face 'font-lock-type-face)
+	      ;; The identifier got the type face so it has already been
+	      ;; handled in `c-font-lock-declarations'.
+	      nil)
+
+	     ((eq id-face 'font-lock-keyword-face)
+	      (when (looking-at c-opt-<>-sexp-key)
+		;; There's a special keyword before the "<" that tells
+		;; that it's an angle bracket arglist.
+		(setq kwd-sym (c-keyword-sym (match-string 1)))))
+
+	     (t
+	      ;; There's a normal identifier before the "<".  If we're not in
+	      ;; a declaration context then we set `c-restricted-<>-arglists'
+	      ;; to avoid recognizing templates in function calls like "foo (a
+	      ;; < b, c > d)".
+	      (c-backward-syntactic-ws)
+	      (when (and (memq (char-before) '(?\( ?,))
+			 (not (eq (get-text-property (1- (point)) 'c-type)
+				  'c-decl-arg-start)))
+		(setq c-restricted-<>-arglists t))
+	      t))
+
 	    (progn
 	      (goto-char (1- pos))
 	      ;; Check for comment/string both at the identifier and
 	      ;; at the "<".
 	      (unless (c-skip-comments-and-strings limit)
 
-		(when (c-forward-<>-arglist (c-keyword-member kwd-sym
-							      'c-<>-type-kwds)
-					    t)
-		  (when (and c-opt-identifier-concat-key
-			     (not (get-text-property id-start 'face)))
-		    (c-forward-syntactic-ws)
-		    (if (looking-at c-opt-identifier-concat-key)
+		(c-fontify-types-and-refs ()
+		  (when (c-forward-<>-arglist (c-keyword-member
+					       kwd-sym 'c-<>-type-kwds))
+		    (when (and c-opt-identifier-concat-key
+			       (not (get-text-property id-start 'face)))
+		      (c-forward-syntactic-ws)
+		      (if (looking-at c-opt-identifier-concat-key)
+			  (c-put-font-lock-face id-start id-end
+						c-reference-face-name)
 			(c-put-font-lock-face id-start id-end
-					      c-reference-face-name)
-		      (c-put-font-lock-face id-start id-end
-					    'font-lock-type-face))))
+					      'font-lock-type-face)))))
 
 		(goto-char pos)))
 	  (goto-char pos)))))
@@ -773,6 +824,8 @@ casts and declarations are fontified.  Used on level 2 and higher."
   ;; "bar" in "int foo = 17, bar;").  Stop at LIMIT.  If TYPES is
   ;; non-nil, fontify all identifiers as types.  Nil is always
   ;; returned.
+  ;;
+  ;; This function might do hidden buffer changes.
 
   ;;(message "c-font-lock-declarators from %s to %s" (point) limit)
   (c-fontify-types-and-refs
@@ -789,7 +842,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
 	    (let (got-identifier)
 	      (setq paren-depth 0)
 	      ;; Skip over type decl prefix operators.  (Note similar
-	      ;; code in `c-font-lock-declarations'.)
+	      ;; code in `c-forward-decl-or-cast-1'.)
 	      (while (and (looking-at c-type-decl-prefix-key)
 			  (if (and (c-major-mode-is 'c++-mode)
 				   (match-beginning 2))
@@ -830,6 +883,11 @@ casts and declarations are fontified.  Used on level 2 and higher."
 
 	    (<= (point) limit)
 
+	    (progn
+	      (when (looking-at c-decl-hangon-key)
+		(c-forward-keyword-clause 1))
+	      (<= (point) limit))
+
 	    ;; Search syntactically to the end of the declarator (";",
 	    ;; ",", a closen paren, eob etc) or to the beginning of an
 	    ;; initializer or function prototype ("=" or "\\s\(").
@@ -883,6 +941,9 @@ casts and declarations are fontified.  Used on level 2 and higher."
 			     (looking-at "{"))
 			(c-safe (c-forward-sexp) t)
 		      t)
+		    ;; FIXME: Should look for c-decl-end markers here;
+		    ;; we might go far into the following declarations
+		    ;; in e.g. ObjC mode (see e.g. methods-4.m).
 		    (c-syntactic-re-search-forward "[;,{]" limit 'move t)
 		    (backward-char)))
 
@@ -905,106 +966,50 @@ casts and declarations are fontified.  Used on level 2 and higher."
 	c-reference-face-name
 	font-lock-keyword-face))
 
-;; Macro used inside `c-font-lock-declarations'.  It ought to be a
-;; defsubst or perhaps even a defun, but it contains lots of free
-;; variables that refer to things inside `c-font-lock-declarations'.
-(defmacro c-fl-shift-type-backward (&optional short)
-  ;; `c-font-lock-declarations' can consume an arbitrary length list
-  ;; of types when parsing a declaration, which means that it
-  ;; sometimes consumes the identifier in the declaration as a type.
-  ;; This is used to "backtrack" and make the last type be treated
-  ;; as an identifier instead.
-  `(progn
-     ,(unless short
-	;; These identifiers are bound only in the inner let.
-	'(setq identifier-type at-type
-	       identifier-start type-start
-	       identifier-end type-end))
-     (if (setq at-type (if (eq prev-at-type 'prefix)
-			   t
-			 prev-at-type))
-	 (setq type-start prev-type-start
-	       type-end prev-type-end)
-       (setq type-start start-pos
-	     type-end start-pos))
-     ,(unless short
-	;; These identifiers are bound only in the inner let.
-	'(setq start type-end
-	       got-parens nil
-	       got-identifier t
-	       got-suffix t
-	       got-suffix-after-parens t
-	       paren-depth 0))))
-
 (defun c-font-lock-declarations (limit)
-  ;; Fontify all the declarations and casts from the point to LIMIT.
-  ;; Assumes that strings and comments have been fontified already.
-  ;; Nil is always returned.
+  ;; Fontify all the declarations, casts and labels from the point to LIMIT.
+  ;; Assumes that strings and comments have been fontified already.  Nil is
+  ;; always returned.
   ;;
-  ;; This function can make hidden buffer changes, but the font-lock
-  ;; context covers that.
+  ;; This function might do hidden buffer changes.
 
   ;;(message "c-font-lock-declarations search from %s to %s" (point) limit)
 
   (save-restriction
-    (let (start-pos
-	  c-restricted-<>-arglists
-	  ;; Nonzero if the `c-decl-prefix-re' match is in an arglist context,
-	  ;; as opposed to a statement-level context.  The major difference is
-	  ;; that "," works as declaration delimiter in an arglist context,
-	  ;; whereas it only separates declarators in the same declaration in
-	  ;; a statement context.  If it's nonzero then the value is the
-	  ;; matched char, e.g. ?\( or ?,.
-	  arglist-match
-	  ;; 'decl if we're in an arglist containing declarations (but if
-	  ;; `c-recognize-paren-inits' is set it might also be an initializer
-	  ;; arglist), '<> if the arglist is of angle bracket type, 'other if
-	  ;; it's some other arglist, or nil if not in an arglist at all.
-	  arglist-type
-	  ;; Set to the result of `c-forward-type'.
-	  at-type
-	  ;; These record the start and end of the type or possible type found
-	  ;; by `c-forward-type'.  `type-start' is at the start of the first
-	  ;; type token, and `type-end' is at the start of the first token
-	  ;; after the type (and after any specifiers).
-	  type-start type-end
-	  ;; These store `at-type', `type-start' and `type-end' of the
-	  ;; identifier before the one in those variables.  The previous
-	  ;; identifier might turn out to be the real type in a declaration if
-	  ;; the last one has to be the declarator in it.  If `prev-at-type'
-	  ;; is nil then the other variables have undefined values.
-	  prev-at-type prev-type-start prev-type-end
-	  ;; Whether we've found a declaration or a cast.  We might know this
-	  ;; before we've found the type in it.
-	  at-decl-or-cast
-	  ;; Set when we need to back up to parse this as a declaration but
-	  ;; not as a cast.
-	  backup-if-not-cast
-	  ;; Set if we've found a "typedef" specifier.  The identifiers in the
-	  ;; declaration are then fontified as types.
-	  at-typedef
-	  ;; Set if we've found a specifier that can start a declaration where
-	  ;; there's no type.
-	  maybe-typeless
-	  ;; The position of the next token after the closing paren of the
-	  ;; last fontified cast.
+    (let (;; The position where `c-find-decl-spots' stopped.
+	  start-pos
+	  ;; 'decl if we're in an arglist containing declarations (but
+	  ;; if `c-recognize-paren-inits' is set it might also be an
+	  ;; initializer arglist), '<> if the arglist is of angle
+	  ;; bracket type, 'arglist if it's some other arglist, or nil
+	  ;; if not in an arglist at all.
+	  context
+	  ;; The position of the next token after the closing paren of
+	  ;; the last detected cast.
 	  last-cast-end
-	  ;; The same for the currently investigated cast.
-	  cast-end
-	  ;; The maximum of the end positions of all the checked type decl
-	  ;; expressions in the successfully identified declarations.  The
-	  ;; position might be either before or after the syntactic whitespace
-	  ;; following the last token in the type decl expression.
+	  ;; The result from `c-forward-decl-or-cast-1'.
+	  decl-or-cast
+	  ;; The maximum of the end positions of all the checked type
+	  ;; decl expressions in the successfully identified
+	  ;; declarations.  The position might be either before or
+	  ;; after the syntactic whitespace following the last token
+	  ;; in the type decl expression.
 	  (max-type-decl-end 0)
 	  ;; Same as `max-type-decl-*', but used when we're before
 	  ;; `token-pos'.
 	  (max-type-decl-end-before-token 0)
-	  ;; Allow recording of identifier ranges in `c-forward-type' etc for
-	  ;; later fontification.  Not using `c-fontify-types-and-refs' here
-	  ;; since the ranges should be fontified selectively only when a
-	  ;; declaration or cast has been successfully recognized.
-	  c-record-type-identifiers
+	  ;; Set according to the context to direct the heuristics for
+	  ;; recognizing C++ templates.
+	  c-restricted-<>-arglists
+	  ;; Turn on recording of identifier ranges in
+	  ;; `c-forward-decl-or-cast-1' and `c-forward-label' for
+	  ;; later fontification.
+	  (c-record-type-identifiers t)
 	  c-record-ref-identifiers
+	  ;; Make `c-forward-type' calls mark up template arglists if
+	  ;; it finds any.  That's necessary so that we later will
+	  ;; stop inside them to fontify types there.
+	  (c-parse-and-markup-<>-arglists t)
 	  ;; The font-lock package in Emacs is known to clobber
 	  ;; `parse-sexp-lookup-properties' (when it exists).
 	  (parse-sexp-lookup-properties
@@ -1024,737 +1029,162 @@ casts and declarations are fontified.  Used on level 2 and higher."
       ;; "some_other_variable" as an identifier, and the latter will not
       ;; correct itself until the second line is changed.  To avoid that we
       ;; narrow to the limit if the region to fontify is a single line.
-      (when (<= limit (c-point 'bonl))
-	(narrow-to-region
-	 (point-min)
-	 (save-excursion
-	   ;; Narrow after any operator chars following the limit though, since
-	   ;; those characters can be useful in recognizing a declaration (in
-	   ;; particular the '{' that opens a function body after the header).
-	   (goto-char limit)
-	   (skip-chars-forward c-nonsymbol-chars)
-	   (point))))
+      (narrow-to-region
+       (point-min)
+       (if (<= limit (c-point 'bonl))
+	   (save-excursion
+	     ;; Narrow after any operator chars following the limit though,
+	     ;; since those characters can be useful in recognizing a
+	     ;; declaration (in particular the '{' that opens a function body
+	     ;; after the header).
+	     (goto-char limit)
+	     (skip-chars-forward c-nonsymbol-chars)
+	     (point))
+	 limit))
 
       (c-find-decl-spots
        limit
-       c-identifier-start
+       c-decl-start-re
        c-font-lock-maybe-decl-faces
 
        (lambda (match-pos inside-macro)
-	 (catch 'false-alarm
-	   ;; Don't do anything more if we're looking at a keyword
-	   ;; that can't start a declaration.
-	   (when (and (eq (get-text-property (point) 'face)
-			  'font-lock-keyword-face)
-		      (looking-at c-not-decl-init-keywords))
-	     (throw 'false-alarm t))
-
-	   ;; Set `arglist-match' and `arglist-type'.  Look for "<" for the
-	   ;; sake of C++-style template arglists.
-	   (setq arglist-match (char-before match-pos))
-	   (if (memq arglist-match '(?\( ?, ?\[ ?<))
-
-	       ;; Find out the type of the arglist.
-	       (if (<= match-pos (point-min))
-		   (setq arglist-type 'other)
-		 (let ((type (c-get-char-property (1- match-pos) 'c-type)))
-		   (cond ((eq type 'c-decl-arg-start)
-			  ;; Got a cached hit in a declaration arglist.
-			  (setq arglist-type 'decl))
-			 ((or (eq type 'c-<>-arg-sep)
-			      (eq arglist-match ?<))
-			  ;; Inside an angle bracket arglist.
-			  (setq arglist-type '<>))
-			 (type
-			  ;; Got a cached hit in some other type of arglist.
-			  (setq arglist-type 'other))
-			 ((if inside-macro
-			      (< match-pos max-type-decl-end-before-token)
-			    (< match-pos max-type-decl-end))
-			  ;; The point is within the range of a previously
-			  ;; encountered type decl expression, so the arglist
-			  ;; is probably one that contains declarations.
-			  ;; However, if `c-recognize-paren-inits' is set it
-			  ;; might also be an initializer arglist.
-			  (setq arglist-type 'decl)
-			  ;; The result of this check is cached with a char
-			  ;; property on the match token, so that we can look
-			  ;; it up again when refontifying single lines in a
-			  ;; multiline declaration.
-			  (c-put-char-property (1- match-pos)
-					       'c-type 'c-decl-arg-start))
-			 (t
-			  (setq arglist-type 'other)))))
-
-	     (setq arglist-match nil
-		   arglist-type nil))
-
-	   (setq at-type nil
-		 at-decl-or-cast nil
-		 backup-if-not-cast nil
-		 at-typedef nil
-		 maybe-typeless nil
-		 c-record-type-identifiers t
-		 c-record-ref-identifiers nil
-		 ;; `start-pos' is used below to point to the start of the
-		 ;; first type, i.e. after any leading specifiers.  It might
-		 ;; also point at the beginning of the preceding syntactic
-		 ;; whitespace.
-		 start-pos (point)
-		 ;; If we're in a normal arglist context we don't want to
-		 ;; recognize commas in nested angle bracket arglists since
-		 ;; those commas could be part of our own arglist.
-		 c-restricted-<>-arglists
-		 (and c-recognize-<>-arglists
-		      (eq arglist-type 'other)))
-
-	   (when (and c-restricted-<>-arglists
-		      (/= arglist-match ?,))
-	     ;; We're standing at the start of a normal arglist so remove any
-	     ;; angle bracket arglists containing commas that's been
-	     ;; recognized inside it by the preceding slightly opportunistic
-	     ;; scan in `c-font-lock-<>-arglists'.
-	     (while (and (c-syntactic-re-search-forward
-			  c-opt-<>-arglist-start-in-paren nil t t)
-			 (match-beginning 1))
-	       (backward-char)
-	       (when (save-match-data
-		       (and (c-get-char-property (point) 'syntax-table)
-			    (not (c-forward-<>-arglist nil t))))
-		 (c-remove-font-lock-face (match-beginning 2) (match-end 2))))
-	     (goto-char start-pos))
-
-	   ;; Check for a type, but be prepared to skip over leading
-	   ;; specifiers like "static".  Unknown symbols are treated as
-	   ;; possible types, but they could also be specifiers disguised
-	   ;; through macros like __INLINE__, so we recognize both types and
-	   ;; known specifiers after them too.
-	   (while (let ((start (point))
-			(res (unless (eq at-type t)
-			       ;; Don't look for a type if we already found a
-			       ;; positive one; we only loop for the
-			       ;; `c-specifier-key' check then.
-			       (c-forward-type))))
-
-		    (when res
-		      ;; Found a known or possible type or a prefix of a known
-		      ;; type.
-
-		      (when at-type
-			;; Got two identifiers with nothing but whitespace
-			;; between them.  That can only happen in
-			;; declarations.
-			(setq at-decl-or-cast t)
-
-			(when (eq at-type 'found)
-			  ;; If the previous identifier is a found type we
-			  ;; record it as a real one; it might be some sort of
-			  ;; alias for a prefix like "unsigned".
-			  (save-excursion
-			    (goto-char type-start)
-			    (let ((c-promote-possible-types t))
-			      (c-forward-type)))))
-
-		      (setq prev-at-type at-type
-			    prev-type-start type-start
-			    prev-type-end type-end
-			    at-type res
-			    type-start start
-			    type-end (point))
-
-		      ;; If the type isn't known we continue so that we'll
-		      ;; jump over all specifiers and type identifiers.  The
-		      ;; reason to do this for a known type prefix is to make
-		      ;; things like "unsigned INT16" work.
-		      (setq res (not (eq res t))))
-
-		    (if (looking-at c-specifier-key)
-			;; Found a known specifier keyword.  The specifier
-			;; keywords are restrictive, so we check for them
-			;; anywhere inside or around the type(s).  We thereby
-			;; avoid having special cases for specifiers like MSVC
-			;; '__declspec' which can come after the type.
-			(progn
-			  (setq at-decl-or-cast t)
-			  (let ((kwd-sym (c-keyword-sym (match-string 1))))
-			    (when (c-keyword-member
-				   kwd-sym 'c-typedef-decl-kwds)
-			      (setq at-typedef t))
-			    (when (c-keyword-member
-				   kwd-sym 'c-typeless-decl-kwds)
-			      (setq maybe-typeless t)))
-			  (c-forward-keyword-clause)
-			  ;; Move type-end forward if we've passed a type,
-			  ;; otherwise move start-pos forward.
-			  (if at-type
-			      (setq type-end (point))
-			    (setq start-pos (point))))
-
-		      res)))
-
-	   (cond
-	    ((eq at-type 'prefix)
-	     ;; A prefix type is itself a primitive type when it's not
-	     ;; followed by another type.
-	     (setq at-type t))
-
-	    ((not at-type)
-	     ;; Got no type but set things up to continue anyway to handle the
-	     ;; various cases when a declaration doesn't start with a type.
-	     (setq type-end start-pos))
-
-	    ((and (eq at-type 'maybe)
-		  (c-major-mode-is 'c++-mode))
-	     ;; If it's C++ then check if the last "type" ends on the form
-	     ;; "foo::foo" or "foo::~foo", i.e. if it's the name of a
-	     ;; (con|de)structor.
-	     (save-excursion
-	       (let (name end-2 end-1)
-		 (goto-char type-end)
-		 (c-backward-syntactic-ws)
-		 (setq end-2 (point))
-		 (when (and
-			(c-simple-skip-symbol-backward)
-			(progn
-			  (setq name
-				(buffer-substring-no-properties (point) end-2))
-			  ;; Cheating in the handling of syntactic ws below.
-			  (< (skip-chars-backward ":~ \t\n\r\v\f") 0))
-			(progn
-			  (setq end-1 (point))
-			  (c-simple-skip-symbol-backward))
-			(>= (point) type-start)
-			(equal (buffer-substring-no-properties (point) end-1)
-			       name))
-		   ;; It is a (con|de)structor name.  In that case the
-		   ;; declaration is typeless so zap out any preceding
-		   ;; identifier(s) that we might have taken as types.
-		   (goto-char type-start)
-		   (setq at-type nil
-			 prev-at-type nil
-			 type-end type-start))))))
-
-	   ;; Check for and step over a type decl expression after the thing
-	   ;; that is or might be a type.  This can't be skipped since we need
-	   ;; the correct end position of the declarator for
-	   ;; `max-type-decl-end-*'.
-	   (let ((start (point)) (paren-depth 0) pos
-		 ;; True if there's a non-open-paren match of
-		 ;; `c-type-decl-prefix-key'.
-		 got-prefix
-		 ;; True if the declarator is surrounded by a parenthesis pair.
-		 got-parens
-		 ;; True if there is an identifier in the declarator.
-		 got-identifier
-		 ;; True if there's a non-close-paren match of
-		 ;; `c-type-decl-suffix-key'.
-		 got-suffix
-		 ;; True if there's a prefix or suffix match outside the
-		 ;; outermost paren pair that surrounds the declarator.
-		 got-prefix-before-parens
-		 got-suffix-after-parens
-		 ;; True if we've parsed the type decl to a token that
-		 ;; is known to end declarations in this context.
-		 at-decl-end
-		 ;; The earlier values of `at-type', `type-start' and
-		 ;; `type-end' if we've shifted the type backwards.
-		 identifier-type identifier-start identifier-end)
-	     (goto-char type-end)
-
-	     ;; Skip over type decl prefix operators.  (Note similar code in
-	     ;; `c-font-lock-declarators'.)
-	     (while (and (looking-at c-type-decl-prefix-key)
-			 (if (and (c-major-mode-is 'c++-mode)
-				  (match-beginning 2))
-			     ;; If the second submatch matches in C++ then
-			     ;; we're looking at an identifier that's a prefix
-			     ;; only if it specifies a member pointer.
-			     (when (setq got-identifier (c-forward-name))
-			       (if (looking-at "\\(::\\)")
-				   ;; We only check for a trailing "::" and
-				   ;; let the "*" that should follow be
-				   ;; matched in the next round.
-				   (progn (setq got-identifier nil) t)
-				 ;; It turned out to be the real identifier,
-				 ;; so stop.
-				 nil))
-			   t))
-	       (if (eq (char-after) ?\()
-		   (progn
-		     (setq paren-depth (1+ paren-depth))
-		     (forward-char))
-		 (unless got-prefix-before-parens
-		   (setq got-prefix-before-parens (= paren-depth 0)))
-		 (setq got-prefix t)
-		 (goto-char (match-end 1)))
-	       (c-forward-syntactic-ws))
-	     (setq got-parens (> paren-depth 0))
-
-	     ;; Skip over an identifier.
-	     (or got-identifier
-		 (and (looking-at c-identifier-start)
-		      (setq got-identifier (c-forward-name))))
-
-	     ;; Skip over type decl suffix operators.
-	     (while (if (looking-at c-type-decl-suffix-key)
-			(if (eq (char-after) ?\))
-			    (when (> paren-depth 0)
-			      (setq paren-depth (1- paren-depth))
-			      (forward-char)
-			      t)
-			  (when (if (save-match-data (looking-at "\\s\("))
-				    (c-safe (c-forward-sexp 1) t)
-				  (goto-char (match-end 1))
-				  t)
-			    (unless got-suffix-after-parens
-			      (setq got-suffix-after-parens (= paren-depth 0)))
-			    (setq got-suffix t)))
-		      ;; No suffix matched.  We might have matched the
-		      ;; identifier as a type and the open paren of a function
-		      ;; arglist as a type decl prefix.  In that case we
-		      ;; should "backtrack": Reinterpret the last type as the
-		      ;; identifier, move out of the arglist and continue
-		      ;; searching for suffix operators.
-		      ;;
-		      ;; Do this even if there's no preceding type, to cope
-		      ;; with old style function declarations in K&R C,
-		      ;; (con|de)structors in C++ and `c-typeless-decl-kwds'
-		      ;; style declarations.  That isn't applicable in an
-		      ;; arglist context, though.
-		      (when (and (= paren-depth 1)
-				 (not got-prefix-before-parens)
-				 (not (eq at-type t))
-				 (or prev-at-type
-				     maybe-typeless
-				     (when c-recognize-typeless-decls
-				       (not arglist-type)))
-				 (setq pos (c-up-list-forward (point)))
-				 (eq (char-before pos) ?\)))
-			(c-fl-shift-type-backward)
-			(goto-char pos)
-			t))
-	       (c-forward-syntactic-ws))
-
-	     (when (and maybe-typeless
-			(not got-identifier)
-			(not got-prefix)
-			at-type
-			(not (eq at-type t)))
-	       ;; Have found no identifier but `c-typeless-decl-kwds' has
-	       ;; matched so we know we're inside a declaration.  The
-	       ;; preceding type must be the identifier instead.
-	       (c-fl-shift-type-backward))
-
-	     (setq
-	      at-decl-or-cast
-	      (catch 'at-decl-or-cast
-
-		(when (> paren-depth 0)
-		  ;; Encountered something inside parens that isn't matched by
-		  ;; the `c-type-decl-*' regexps, so it's not a type decl
-		  ;; expression.  Try to skip out to the same paren depth to
-		  ;; not confuse the cast check below.
-		  (c-safe (goto-char (scan-lists (point) 1 paren-depth)))
-		  (throw 'at-decl-or-cast nil))
-
-		(setq at-decl-end
-		      (looking-at (cond ((eq arglist-type '<>) "[,>]")
-					(arglist-type "[,\)]")
-					(t "[,;]"))))
-
-		;; Now we've collected info about various characteristics of
-		;; the construct we're looking at.  Below follows a decision
-		;; tree based on that.  It's ordered to check more certain
-		;; signs before less certain ones.
-
-		(if got-identifier
-		    (progn
-
-		      (when (and (or at-type maybe-typeless)
-				 (not (or got-prefix got-parens)))
-			;; Got another identifier directly after the type, so
-			;; it's a declaration.
-			(throw 'at-decl-or-cast t))
-
-		      (when (and got-parens
-				 (not got-prefix)
-				 (not got-suffix-after-parens)
-				 (or prev-at-type maybe-typeless))
-			;; Got a declaration of the form "foo bar (gnu);"
-			;; where we've recognized "bar" as the type and "gnu"
-			;; as the declarator.  In this case it's however more
-			;; likely that "bar" is the declarator and "gnu" a
-			;; function argument or initializer (if
-			;; `c-recognize-paren-inits' is set), since the parens
-			;; around "gnu" would be superfluous if it's a
-			;; declarator.  Shift the type one step backward.
-			(c-fl-shift-type-backward)))
-
-		  ;; Found no identifier.
-
-		  (if prev-at-type
-		      (when (or (= (point) start)
-				(and got-suffix
-				     (not got-prefix)
-				     (not got-parens)))
-			;; Got two types after each other, so if this isn't a
-			;; cast then the latter probably is the identifier and
-			;; we should back up to the previous type.
-			(setq backup-if-not-cast t)
-			(throw 'at-decl-or-cast t))
-
-		    (when (eq at-type t)
-		      ;; If the type is known we know that there can't be any
-		      ;; identifier somewhere else, and it's only in
-		      ;; declarations in e.g. function prototypes and in casts
-		      ;; that the identifier may be left out.
-		      (throw 'at-decl-or-cast t))
-
-		    (when (= (point) start)
-		      ;; Only got a single identifier (parsed as a type so
-		      ;; far).
-		      (if (and
-			   ;; Check that the identifier isn't at the start of
-			   ;; an expression.
-			   at-decl-end
-			   (cond
-			    ((eq arglist-type 'decl)
-			     ;; Inside an arglist that contains declarations.
-			     ;; If K&R style declarations and parenthesis
-			     ;; style initializers aren't allowed then the
-			     ;; single identifier must be a type, else we
-			     ;; require that it's known or found (primitive
-			     ;; types are handled above).
-			     (or (and (not c-recognize-knr-p)
-				      (not c-recognize-paren-inits))
-				 (memq at-type '(known found))))
-			    ((eq arglist-type '<>)
-			     ;; Inside a template arglist.  Accept known and
-			     ;; found types; other identifiers could just as
-			     ;; well be constants in C++.
-			     (memq at-type '(known found)))))
-			  (throw 'at-decl-or-cast t)
-			(throw 'at-decl-or-cast nil))))
-
-		  (if (and
-		       got-parens
-		       (not got-prefix)
-		       (not arglist-type)
-		       (not (eq at-type t))
-		       (or
-			prev-at-type
-			maybe-typeless
-			(when c-recognize-typeless-decls
-			  (or (not got-suffix)
-			      (not (looking-at
-				    c-after-suffixed-type-maybe-decl-key))))))
-		      ;; Got an empty paren pair and a preceding type that
-		      ;; probably really is the identifier.  Shift the type
-		      ;; backwards to make the last one the identifier.  This
-		      ;; is analogous to the "backtracking" done inside the
-		      ;; `c-type-decl-suffix-key' loop above.
-		      ;;
-		      ;; Exception: In addition to the conditions in that
-		      ;; "backtracking" code, do not shift backward if we're
-		      ;; not looking at either `c-after-suffixed-type-decl-key'
-		      ;; or "[;,]".  Since there's no preceding type, the
-		      ;; shift would mean that the declaration is typeless.
-		      ;; But if the regexp doesn't match then we will simply
-		      ;; fall through in the tests below and not recognize it
-		      ;; at all, so it's better to try it as an abstract
-		      ;; declarator instead.
-		      (c-fl-shift-type-backward)
-
-		    ;; Still no identifier.
-
-		    (when (and got-prefix (or got-parens got-suffix))
-		      ;; Require `got-prefix' together with either
-		      ;; `got-parens' or `got-suffix' to recognize it as an
-		      ;; abstract declarator: `got-parens' only is probably an
-		      ;; empty function call.  `got-suffix' only can build an
-		      ;; ordinary expression together with the preceding
-		      ;; identifier which we've taken as a type.  We could
-		      ;; actually accept on `got-prefix' only, but that can
-		      ;; easily occur temporarily while writing an expression
-		      ;; so we avoid that case anyway.  We could do a better
-		      ;; job if we knew the point when the fontification was
-		      ;; invoked.
-		      (throw 'at-decl-or-cast t))))
-
-		(when at-decl-or-cast
-		  ;; By now we've located the type in the declaration that we
-		  ;; know we're in.
-		  (throw 'at-decl-or-cast t))
-
-		(when (and got-identifier
-			   (not arglist-type)
-			   (looking-at c-after-suffixed-type-decl-key)
-			   (if (and got-parens
-				    (not got-prefix)
-				    (not got-suffix)
-				    (not (eq at-type t)))
-			       ;; Shift the type backward in the case that
-			       ;; there's a single identifier inside parens.
-			       ;; That can only occur in K&R style function
-			       ;; declarations so it's more likely that it
-			       ;; really is a function call.  Therefore we
-			       ;; only do this after
-			       ;; `c-after-suffixed-type-decl-key' has
-			       ;; matched.
-			       (progn (c-fl-shift-type-backward) t)
-			     got-suffix-after-parens))
-		  ;; A declaration according to
-		  ;; `c-after-suffixed-type-decl-key'.
-		  (throw 'at-decl-or-cast t))
-
-		(when (and (or got-prefix (not got-parens))
-			   (memq at-type '(t known)))
-		  ;; It's a declaration if a known type precedes it and it
-		  ;; can't be a function call.
-		  (throw 'at-decl-or-cast t))
-
-		;; If we get here we can't tell if this is a type decl or a
-		;; normal expression by looking at it alone.  (That's under
-		;; the assumption that normal expressions always can look like
-		;; type decl expressions, which isn't really true but the
-		;; cases where it doesn't hold are so uncommon (e.g. some
-		;; placements of "const" in C++) it's not worth the effort to
-		;; look for them.)
-
-		(unless (or at-decl-end (looking-at "=[^=]"))
-		  ;; If this is a declaration it should end here or its
-		  ;; initializer(*) should start here, so check for allowed
-		  ;; separation tokens.  Note that this rule doesn't work
-		  ;; e.g. with a K&R arglist after a function header.
-		  ;;
-		  ;; *) Don't check for C++ style initializers using parens
-		  ;; since those already have been matched as suffixes.
-		  (throw 'at-decl-or-cast nil))
-
-		;; Below are tests that only should be applied when we're
-		;; certain to not have parsed halfway through an expression.
-
-		(when (memq at-type '(t known))
-		  ;; The expression starts with a known type so treat it as a
-		  ;; declaration.
-		  (throw 'at-decl-or-cast t))
-
-		(when (and (c-major-mode-is 'c++-mode)
-			   ;; In C++ we check if the identifier is a known
-			   ;; type, since (con|de)structors use the class name
-			   ;; as identifier.  We've always shifted over the
-			   ;; identifier as a type and then backed up again in
-			   ;; this case.
-			   identifier-type
-			   (or (memq identifier-type '(found known))
-			       (and (eq (char-after identifier-start) ?~)
-				    ;; `at-type' probably won't be 'found for
-				    ;; destructors since the "~" is then part
-				    ;; of the type name being checked against
-				    ;; the list of known types, so do a check
-				    ;; without that operator.
-				    (or (save-excursion
-					  (goto-char (1+ identifier-start))
-					  (c-forward-syntactic-ws)
-					  (c-with-syntax-table
-					      c-identifier-syntax-table
-					    (looking-at c-known-type-key)))
-					(c-check-type (1+ identifier-start)
-						      identifier-end)))))
-		  (throw 'at-decl-or-cast t))
-
-		(if got-identifier
-		    (progn
-		      (when (and got-prefix-before-parens
-				 at-type
-				 (or at-decl-end (looking-at "=[^=]"))
-				 (not arglist-type)
-				 (not got-suffix))
-			;; Got something like "foo * bar;".  Since we're not
-			;; inside an arglist it would be a meaningless
-			;; expression because the result isn't used.  We
-			;; therefore choose to recognize it as a declaration.
-			;; Do not allow a suffix since it could then be a
-			;; function call.
-			(throw 'at-decl-or-cast t))
-
-		      (when (and (or got-suffix-after-parens
-				     (looking-at "=[^=]"))
-				 (eq at-type 'found)
-				 (not (eq arglist-type 'other)))
-			;; Got something like "a (*b) (c);" or "a (b) = c;".
-			;; It could be an odd expression or it could be a
-			;; declaration.  Treat it as a declaration if "a" has
-			;; been used as a type somewhere else (if it's a known
-			;; type we won't get here).
-			(throw 'at-decl-or-cast t)))
-
-		  (when (and arglist-type
-			     (or got-prefix
-				 (and (eq arglist-type 'decl)
-				      (not c-recognize-paren-inits)
-				      (or got-parens got-suffix))))
-		    ;; Got a type followed by an abstract declarator.  If
-		    ;; `got-prefix' is set it's something like "a *" without
-		    ;; anything after it.  If `got-parens' or `got-suffix' is
-		    ;; set it's "a()", "a[]", "a()[]", or similar, which we
-		    ;; accept only if the context rules out expressions.
-		    (throw 'at-decl-or-cast t)))
-
-		;; If we had a complete symbol table here (which rules out
-		;; `c-found-types') we should return t due to the
-		;; disambiguation rule (in at least C++) that anything that
-		;; can be parsed as a declaration is a declaration.  Now we're
-		;; being more defensive and prefer to highlight things like
-		;; "foo (bar);" as a declaration only if we're inside an
-		;; arglist that contains declarations.
-		(eq arglist-type 'decl))))
-
-	   ;; Point is now after the type decl expression.
-
-	   (cond
-	    ;; Check for a cast.
-	    ((save-excursion
-	       (and
-		c-cast-parens
-
-		;; Should be the first type/identifier in a cast paren.
-		(memq arglist-match c-cast-parens)
-
-		;; The closing paren should follow.
-		(progn
-		  (c-forward-syntactic-ws)
-		  (looking-at "\\s\)"))
-
-		;; There should be a primary expression after it.
-		(let (pos)
-		  (forward-char)
-		  (c-forward-syntactic-ws)
-		  (setq cast-end (point))
-		  (and (looking-at c-primary-expr-regexp)
-		       (progn
-			 (setq pos (match-end 0))
-			 (or
-			  ;; Check if the expression begins with a prefix
-			  ;; keyword.
-			  (match-beginning 2)
-			  (if (match-beginning 1)
-			      ;; Expression begins with an ambiguous operator.
-			      ;; Treat it as a cast if it's a type decl or if
-			      ;; we've recognized the type somewhere else.
-			      (or at-decl-or-cast
-				  (memq at-type '(t known found)))
-			    ;; Unless it's a keyword, it's the beginning of a
-			    ;; primary expression.
-			    (not (looking-at c-keywords-regexp)))))
-		       ;; If `c-primary-expr-regexp' matched a nonsymbol
-		       ;; token, check that it matched a whole one so that we
-		       ;; don't e.g. confuse the operator '-' with '->'.  It's
-		       ;; ok if it matches further, though, since it e.g. can
-		       ;; match the float '.5' while the operator regexp only
-		       ;; matches '.'.
-		       (or (not (looking-at c-nonsymbol-token-regexp))
-			   (<= (match-end 0) pos))))
-
-		;; There should either be a cast before it or something that
-		;; isn't an identifier or close paren.
-		(/= match-pos 0)
-		(progn
-		  (goto-char (1- match-pos))
-		  (or (eq (point) last-cast-end)
-		      (progn
-			(c-backward-syntactic-ws)
-			(if (< (skip-syntax-backward "w_") 0)
-			    ;; It's a symbol.  Accept it only if it's one of
-			    ;; the keywords that can precede an expression
-			    ;; (without surrounding parens).
-			    (looking-at c-simple-stmt-key)
-			  (and
-			   ;; Check that it isn't a close paren (block close
-			   ;; is ok, though).
-			   (not (memq (char-before) '(?\) ?\])))
-			   ;; Check that it isn't a nonsymbol identifier.
-			   (not (c-on-identifier)))))))))
-
-	     ;; Handle the cast.
-	     (setq last-cast-end cast-end)
-	     (when (and at-type (not (eq at-type t)))
-	       (let ((c-promote-possible-types t))
-		 (goto-char type-start)
-		 (c-forward-type))))
-
-	    (at-decl-or-cast
-	     ;; We're at a declaration.  Highlight the type and the following
-	     ;; declarators.
-
-	     (when backup-if-not-cast
-	       (c-fl-shift-type-backward t))
-
-	     (when (and (eq arglist-type 'decl) (looking-at ","))
-	       ;; Make sure to propagate the `c-decl-arg-start' property to
-	       ;; the next argument if it's set in this one, to cope with
-	       ;; interactive refontification.
-	       (c-put-char-property (point) 'c-type 'c-decl-arg-start))
-
-	     ;; Set `max-type-decl-end' or `max-type-decl-end-before-token'
-	     ;; under the assumption that we're after the first type decl
-	     ;; expression in the declaration now.  That's not really true; we
-	     ;; could also be after a parenthesized initializer expression in
-	     ;; C++, but this is only used as a last resort to slant ambiguous
-	     ;; expression/declarations, and overall it's worth the risk to
-	     ;; occasionally fontify an expression as a declaration in an
-	     ;; initializer expression compared to getting ambiguous things in
-	     ;; normal function prototypes fontified as expressions.
-	     (if inside-macro
-		 (when (> (point) max-type-decl-end-before-token)
-		   (setq max-type-decl-end-before-token (point)))
-	       (when (> (point) max-type-decl-end)
-		 (setq max-type-decl-end (point))))
-
-	     (when (and at-type (not (eq at-type t)))
-	       (let ((c-promote-possible-types t))
-		 (goto-char type-start)
-		 (c-forward-type)))
-
-	     (goto-char type-end)
-
-	     (let ((decl-list
-		    (if arglist-type
-			;; Should normally not fontify a list of declarators
-			;; inside an arglist, but the first argument in the
-			;; ';' separated list of a "for" statement is an
-			;; exception.
-			(when (and (eq arglist-match ?\() (/= match-pos 0))
-			  (save-excursion
-			    (goto-char (1- match-pos))
-			    (c-backward-syntactic-ws)
-			    (and (c-simple-skip-symbol-backward)
-				 (looking-at c-paren-stmt-key))))
-		      t)))
-
-	       ;; Fix the `c-decl-id-start' or `c-decl-type-start' property
-	       ;; before the first declarator if it's a list.
-	       ;; `c-font-lock-declarators' handles the rest.
-	       (when decl-list
-		 (save-excursion
-		   (c-backward-syntactic-ws)
-		   (unless (bobp)
-		     (c-put-char-property (1- (point)) 'c-type
-					  (if at-typedef
-					      'c-decl-type-start
-					    'c-decl-id-start)))))
-
-	       (c-font-lock-declarators (point-max) decl-list at-typedef)))
-
-	    (t
-	     ;; False alarm.  Skip the fontification done below.
-	     (throw 'false-alarm t)))
-
-	   ;; A cast or declaration has been successfully identified, so do
-	   ;; all the fontification of types and refs that's been recorded by
-	   ;; the calls to `c-forward-type' and `c-forward-name' above.
-	   (c-fontify-recorded-types-and-refs)
-	   nil)))
+	 (setq start-pos (point))
+	 (when
+	  ;; The result of the form below is true when we don't recognize a
+	  ;; declaration or cast.
+	  (if (and (eq (get-text-property (point) 'face)
+		       'font-lock-keyword-face)
+		   (looking-at c-not-decl-init-keywords))
+	      ;; Don't do anything more if we're looking at a keyword that
+	      ;; can't start a declaration.
+	      t
+
+	    ;; Set `context'.  Look for "<" for the sake of C++-style template
+	    ;; arglists.
+	    (if (memq (char-before match-pos) '(?\( ?, ?\[ ?<))
+
+		;; Find out the type of the arglist.
+		(if (<= match-pos (point-min))
+		    (setq context 'arglist)
+		  (let ((type (c-get-char-property (1- match-pos) 'c-type)))
+		    (cond ((eq type 'c-decl-arg-start)
+			   ;; Got a cached hit in a declaration arglist.
+			   (setq context 'decl))
+			  ((or (eq type 'c-<>-arg-sep)
+			       (eq (char-before match-pos) ?<))
+			   ;; Inside an angle bracket arglist.
+			   (setq context '<>))
+			  (type
+			   ;; Got a cached hit in some other type of arglist.
+			   (setq context 'arglist))
+			  ((if inside-macro
+			       (< match-pos max-type-decl-end-before-token)
+			     (< match-pos max-type-decl-end))
+			   ;; The point is within the range of a previously
+			   ;; encountered type decl expression, so the arglist
+			   ;; is probably one that contains declarations.
+			   ;; However, if `c-recognize-paren-inits' is set it
+			   ;; might also be an initializer arglist.
+			   (setq context 'decl)
+			   ;; The result of this check is cached with a char
+			   ;; property on the match token, so that we can look
+			   ;; it up again when refontifying single lines in a
+			   ;; multiline declaration.
+			   (c-put-char-property (1- match-pos)
+						'c-type 'c-decl-arg-start))
+			  (t
+			   (setq context 'arglist)))))
+
+	      (setq context nil))
+
+	    ;; If we're in a normal arglist context we don't want to
+	    ;; recognize commas in nested angle bracket arglists since
+	    ;; those commas could be part of our own arglist.
+	    (setq c-restricted-<>-arglists (and c-recognize-<>-arglists
+						(eq context 'arglist))
+
+		  ;; Now analyze the construct.
+		  decl-or-cast (c-forward-decl-or-cast-1
+				match-pos context last-cast-end))
+
+	    (if (not decl-or-cast)
+		;; False alarm.  Return t to go on to the next check.
+		t
+
+	      (if (eq decl-or-cast 'cast)
+		  ;; Save the position after the previous cast so we can feed
+		  ;; it to `c-forward-decl-or-cast-1' in the next round.  That
+		  ;; helps it discover cast chains like "(a) (b) c".
+		  (setq last-cast-end (point))
+
+		;; Set `max-type-decl-end' or `max-type-decl-end-before-token'
+		;; under the assumption that we're after the first type decl
+		;; expression in the declaration now.  That's not really true;
+		;; we could also be after a parenthesized initializer
+		;; expression in C++, but this is only used as a last resort
+		;; to slant ambiguous expression/declarations, and overall
+		;; it's worth the risk to occasionally fontify an expression
+		;; as a declaration in an initializer expression compared to
+		;; getting ambiguous things in normal function prototypes
+		;; fontified as expressions.
+		(if inside-macro
+		    (when (> (point) max-type-decl-end-before-token)
+		      (setq max-type-decl-end-before-token (point)))
+		  (when (> (point) max-type-decl-end)
+		    (setq max-type-decl-end (point))))
+
+		;; Back up to the type to fontify the declarator(s).
+		(goto-char (car decl-or-cast))
+
+		(let ((decl-list
+		       (if context
+			   ;; Should normally not fontify a list of
+			   ;; declarators inside an arglist, but the first
+			   ;; argument in the ';' separated list of a "for"
+			   ;; statement is an exception.
+			   (when (eq (char-before match-pos) ?\()
+			     (save-excursion
+			       (goto-char (1- match-pos))
+			       (c-backward-syntactic-ws)
+			       (and (c-simple-skip-symbol-backward)
+				    (looking-at c-paren-stmt-key))))
+			 t)))
+
+		  ;; Fix the `c-decl-id-start' or `c-decl-type-start' property
+		  ;; before the first declarator if it's a list.
+		  ;; `c-font-lock-declarators' handles the rest.
+		  (when decl-list
+		    (save-excursion
+		      (c-backward-syntactic-ws)
+		      (unless (bobp)
+			(c-put-char-property (1- (point)) 'c-type
+					     (if (cdr decl-or-cast)
+						 'c-decl-type-start
+					       'c-decl-id-start)))))
+
+		  (c-font-lock-declarators
+		   (point-max) decl-list (cdr decl-or-cast))))
+
+	      ;; A cast or declaration has been successfully identified, so do
+	      ;; all the fontification of types and refs that's been recorded.
+	      (c-fontify-recorded-types-and-refs)
+	      nil))
+
+	  ;; It was a false alarm.  Check if we're in a label instead.
+	  (goto-char start-pos)
+	  (when (c-forward-label t match-pos nil)
+	    ;; Can't use `c-fontify-types-and-refs' here since we
+	    ;; should use the label face.
+	    (let (elem)
+	      (while c-record-ref-identifiers
+		(setq elem (car c-record-ref-identifiers)
+		      c-record-ref-identifiers (cdr c-record-ref-identifiers))
+		(c-put-font-lock-face (car elem) (cdr elem)
+				      c-label-face-name)))
+	    ;; `c-forward-label' probably has added a `c-decl-end'
+	    ;; marker, so return t to `c-find-decl-spots' to signal
+	    ;; that.
+	    t))))
 
       nil)))
 
@@ -1794,32 +1224,40 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
       ;; Fontify types preceded by `c-type-prefix-kwds' and the
       ;; identifiers in the declarations they might start.
       ,@(when (c-lang-const c-type-prefix-kwds)
-	  (let ((prefix-re (c-make-keywords-re nil
-			     (c-lang-const c-type-prefix-kwds))))
+	  (let* ((prefix-re (c-make-keywords-re nil
+			      (c-lang-const c-type-prefix-kwds)))
+		 (type-match (+ 2
+				(regexp-opt-depth prefix-re)
+				(c-lang-const c-simple-ws-depth))))
 	    `((,(c-make-font-lock-search-function
-		 (concat "\\<\\(" prefix-re "\\)"
-			 "[ \t\n\r\f\v]+"
-			 "\\(" (c-lang-const c-symbol-key) "\\)")
-		 `(,(+ (c-regexp-opt-depth prefix-re) 2)
+		 (concat "\\<\\(" prefix-re "\\)" ; 1
+			 (c-lang-const c-simple-ws) "+"
+			 (concat "\\("	; 2 + prefix-re + c-simple-ws
+				 (c-lang-const c-symbol-key)
+				 "\\)"))
+		 `(,type-match
 		   'font-lock-type-face t)
-		 '((c-font-lock-declarators limit t nil)
+		 `((c-font-lock-declarators limit t nil)
 		   (save-match-data
-		     (goto-char (match-end 2))
+		     (goto-char (match-end ,type-match))
 		     (c-forward-syntactic-ws))
-		   (goto-char (match-end 2))))))))
+		   (goto-char (match-end ,type-match))))))))
 
       ;; Fontify special declarations that lacks a type.
       ,@(when (c-lang-const c-typeless-decl-kwds)
 	  `((,(c-make-font-lock-search-function
 	       (concat "\\<\\("
-		       (c-regexp-opt (c-lang-const c-typeless-decl-kwds))
+		       (regexp-opt (c-lang-const c-typeless-decl-kwds))
 		       "\\)\\>")
 	       '((c-font-lock-declarators limit t nil)
 		 (save-match-data
 		   (goto-char (match-end 1))
 		   (c-forward-syntactic-ws))
 		 (goto-char (match-end 1)))))))
-      ))
+
+      ;; Fontify generic colon labels in languages that support them.
+      ,@(when (c-lang-const c-recognize-colon-labels)
+	  `(c-font-lock-labels))))
 
 (c-lang-defconst c-complex-decl-matchers
   "Complex font lock matchers for types and declarations.  Used on level
@@ -1828,10 +1266,6 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
   t `(;; Initialize some things before the search functions below.
       c-font-lock-complex-decl-prepare
 
-      ;; Fontify angle bracket arglists like templates in C++.
-      ,@(when (c-lang-const c-recognize-<>-arglists)
-	  `(c-font-lock-<>-arglists))
-
       ,@(if (c-major-mode-is 'objc-mode)
 	    ;; Fontify method declarations in Objective-C, but first
 	    ;; we have to put the `c-decl-end' `c-type' property on
@@ -1847,18 +1281,15 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
 				  nil)))
 		'((c-put-char-property (1- (match-end 1))
 				       'c-type 'c-decl-end)))
+	      c-font-lock-objc-methods))
 
-	      c-font-lock-objc-methods)
-
-	  (when (c-lang-const c-opt-access-key)
-	    `(,(c-make-font-lock-search-function
-		(c-lang-const c-opt-access-key)
-		'((c-put-char-property (1- (match-end 0))
-				       'c-type 'c-decl-end))))))
-
-      ;; Fontify all declarations and casts.
+      ;; Fontify all declarations, casts and normal labels.
       c-font-lock-declarations
 
+      ;; Fontify angle bracket arglists like templates in C++.
+      ,@(when (c-lang-const c-recognize-<>-arglists)
+	  `(c-font-lock-<>-arglists))
+
       ;; The first two rules here mostly find occurences that
       ;; `c-font-lock-declarations' has found already, but not
       ;; declarations containing blocks in the type (see note below).
@@ -1870,9 +1301,9 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
 		   (c-lang-const c-primitive-type-kwds))))
 	 (if (c-major-mode-is 'pike-mode)
 	     ;; No symbol is a keyword after "->" in Pike.
-	     `(,(concat "\\(\\=\\|\\(\\=\\|[^-]\\)[^>]\\)"
+	     `(,(concat "\\(\\=.?\\|[^>]\\|[^-]>\\)"
 			"\\<\\(" re "\\)\\>")
-	       3 font-lock-type-face)
+	       2 font-lock-type-face)
 	   `(,(concat "\\<\\(" re "\\)\\>")
 	     1 'font-lock-type-face)))
 
@@ -1900,8 +1331,8 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
 			(unless (c-skip-comments-and-strings limit)
 			  (c-forward-syntactic-ws)
 			  ;; Handle prefix declaration specifiers.
-			  (when (looking-at c-specifier-key)
-			    (c-forward-keyword-clause))
+			  (when (looking-at c-prefix-spec-kwds-re)
+			    (c-forward-keyword-clause 1))
 			  ,(if (c-major-mode-is 'c++-mode)
 			       `(when (and (c-forward-type)
 					   (eq (char-after) ?=))
@@ -1949,12 +1380,15 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
       ))
 
 (defun c-font-lock-labels (limit)
-  ;; Fontify all the declarations from the point to LIMIT.  Assumes
+  ;; Fontify all statement labels from the point to LIMIT.  Assumes
   ;; that strings and comments have been fontified already.  Nil is
   ;; always returned.
   ;;
-  ;; This function can make hidden buffer changes, but the font-lock
-  ;; context covers that.
+  ;; Note: This function is only used on decoration level 2; this is
+  ;; taken care of directly by the gargantuan
+  ;; `c-font-lock-declarations' on higher levels.
+  ;;
+  ;; This function might do hidden buffer changes.
 
   (let (continue-pos id-start
 	;; The font-lock package in Emacs is known to clobber
@@ -2027,11 +1461,9 @@ higher."
 		   (c-forward-syntactic-ws))
 		 (goto-char (match-end 0)))))))
 
-      ;; Fontify labels in languages that supports them.
-      ,@(when (c-lang-const c-label-key)
-
-	  `(;; Fontify labels after goto etc.
-	    ;; (Got three different interpretation levels here,
+	;; Fontify labels after goto etc.
+	,@(when (c-lang-const c-before-label-kwds)
+	  `(;; (Got three different interpretation levels here,
 	    ;; which makes it a bit complicated: 1) The backquote
 	    ;; stuff is expanded when compiled or loaded, 2) the
 	    ;; eval form is evaluated at font-lock setup (to
@@ -2048,11 +1480,8 @@ higher."
 			     "\\("	; identifier-offset
 			     (c-lang-const c-symbol-key)
 			     "\\)")
-		    (list ,(+ (c-regexp-opt-depth c-before-label-re) 2)
-			  c-label-face-name nil t))))
-
-	    ;; Fontify normal labels.
-	    c-font-lock-labels))
+		    (list ,(+ (regexp-opt-depth c-before-label-re) 2)
+			  c-label-face-name nil t))))))
 
       ;; Fontify the clauses after various keywords.
       ,@(when (or (c-lang-const c-type-list-kwds)
@@ -2068,7 +1497,7 @@ higher."
 				 (c-lang-const c-paren-type-kwds)))
 		       "\\)\\>")
 	       '((c-fontify-types-and-refs ((c-promote-possible-types t))
-		   (c-forward-keyword-clause)
+		   (c-forward-keyword-clause 1)
 		   (if (> (point) limit) (goto-char limit))))))))
       ))
 
@@ -2135,8 +1564,6 @@ higher."
   ;; to override, but we should otoh avoid clobbering a user setting.
   ;; This heuristic for that isn't perfect, but I can't think of any
   ;; better. /mast
-  ;;
-  ;; This function does not do any hidden buffer changes.
   (when (and (boundp def-var)
 	     (memq (symbol-value def-var)
 		   (cons nil
@@ -2193,6 +1620,8 @@ need for `c-font-lock-extra-types'.")
   ;;
   ;; As usual, C++ takes the prize in coming up with a hard to parse
   ;; syntax. :P
+  ;;
+  ;; This function might do hidden buffer changes.
 
   (unless (c-skip-comments-and-strings limit)
     (save-excursion
@@ -2338,50 +1767,13 @@ need for `c++-font-lock-extra-types'.")
 
 ;;; Objective-C.
 
-(defun c-font-lock-objc-iip-decl ()
-  ;; Assuming the point is after an "@interface", "@implementation",
-  ;; "@protocol" declaration, fontify all the types in the directive.
-  ;; Return t if the directive was fully recognized.  Point will then
-  ;; be at the end of it.
-
-  (c-fontify-types-and-refs
-      (start-char
-       (c-promote-possible-types t)
-       ;; Turn off recognition of angle bracket arglists while parsing
-       ;; types here since the protocol reference list might then be
-       ;; considered part of the preceding name or superclass-name.
-       c-recognize-<>-arglists)
-    (catch 'break
-
-      ;; Handle the name of the class itself.
-      (c-forward-syntactic-ws)
-      (unless (c-forward-type) (throw 'break nil))
-
-      ;; Look for ": superclass-name" or "( category-name )".
-      (when (looking-at "[:\(]")
-	(setq start-char (char-after))
-	(forward-char)
-	(c-forward-syntactic-ws)
-	(unless (c-forward-type) (throw 'break nil))
-	(when (eq start-char ?\()
-	  (unless (eq (char-after) ?\)) (throw 'break nil))
-	  (forward-char)
-	  (c-forward-syntactic-ws)))
-
-      ;; Look for a protocol reference list.
-      (when (if (eq (char-after) ?<)
-		(progn
-		  (setq c-recognize-<>-arglists t)
-		  (c-forward-<>-arglist t t))
-	      t)
-	(c-put-char-property (1- (point)) 'c-type 'c-decl-end)
-	t))))
-
 (defun c-font-lock-objc-method ()
   ;; Assuming the point is after the + or - that starts an Objective-C
   ;; method declaration, fontify it.  This must be done before normal
   ;; casts, declarations and labels are fontified since they will get
   ;; false matches in these things.
+  ;;
+  ;; This function might do hidden buffer changes.
 
   (c-fontify-types-and-refs
       ((first t)
@@ -2430,6 +1822,8 @@ need for `c++-font-lock-extra-types'.")
 (defun c-font-lock-objc-methods (limit)
   ;; Fontify method declarations in Objective-C.  Nil is always
   ;; returned.
+  ;;
+  ;; This function might do hidden buffer changes.
 
   (let (;; The font-lock package in Emacs is known to clobber
 	;; `parse-sexp-lookup-properties' (when it exists).
@@ -2605,6 +1999,8 @@ need for `pike-font-lock-extra-types'.")
   ;; Note that faces added through KEYWORDS should never replace the
   ;; existing `c-doc-face-name' face since the existence of that face
   ;; is used as a flag in other code to skip comments.
+  ;;
+  ;; This function might do hidden buffer changes.
 
   (let (comment-beg region-beg)
     (if (eq (get-text-property (point) 'face)
@@ -2686,6 +2082,8 @@ need for `pike-font-lock-extra-types'.")
   ;; between the point and LIMIT that only is fontified with
   ;; `c-doc-face-name'.  If a match is found then submatch 0 surrounds
   ;; the first char and t is returned, otherwise nil is returned.
+  ;;
+  ;; This function might do hidden buffer changes.
   (let (start)
     (while (if (re-search-forward regexp limit t)
 	       (not (eq (get-text-property
@@ -2697,11 +2095,40 @@ need for `pike-font-lock-extra-types'.")
 			      (copy-marker (1+ start))))
       t)))
 
+;; GtkDoc patterns contributed by Masatake YAMATO <[email protected]>.
+
+(defconst gtkdoc-font-lock-doc-comments
+  (let ((symbol "[a-zA-Z0-9_]+")
+	(header "^ \\* "))
+    `((,(concat header "\\("     symbol "\\):[ \t]*$") 
+       1 ,c-doc-markup-face-name prepend nil)
+      (,(concat                  symbol     "()")
+       0 ,c-doc-markup-face-name prepend nil)
+      (,(concat header "\\(" "@" symbol "\\):")
+       1 ,c-doc-markup-face-name prepend nil)
+      (,(concat "[#%]" symbol)
+       0 ,c-doc-markup-face-name prepend nil))
+    ))
+
+(defconst gtkdoc-font-lock-doc-protection
+  `(("< \\(public\\|private\\|protected\\) >"
+     1 ,c-doc-markup-face-name prepend nil)))
+
+(defconst gtkdoc-font-lock-keywords
+  `((,(lambda (limit)
+	(c-font-lock-doc-comments "/\\*\\*$" limit
+	  gtkdoc-font-lock-doc-comments)
+	(c-font-lock-doc-comments "/\\*< " limit
+	  gtkdoc-font-lock-doc-protection)
+	))))
+
+;; Javadoc.
+
 (defconst javadoc-font-lock-doc-comments
   `(("{@[a-z]+[^}\n\r]*}"		; "{@foo ...}" markup.
      0 ,c-doc-markup-face-name prepend nil)
-    ("^\\(/\\*\\)?[ \t*]*\\(@[a-z]+\\)" ; "@foo ..." markup.
-     2 ,c-doc-markup-face-name prepend nil)
+    ("^\\(/\\*\\)?\\(\\s \\|\\*\\)*\\(@[a-z]+\\)" ; "@foo ..." markup.
+     3 ,c-doc-markup-face-name prepend nil)
     (,(concat "</?\\sw"			; HTML tags.
 	      "\\("
 	      (concat "\\sw\\|\\s \\|[=\n\r*.:]\\|"
@@ -2715,13 +2142,15 @@ need for `pike-font-lock-extra-types'.")
     ;; allowed in non-markup use.
     (,(lambda (limit)
 	(c-find-invalid-doc-markup "[<>&]\\|{@" limit))
-     0 ,c-invalid-face-name prepend nil)))
+     0 'font-lock-warning-face prepend nil)))
 
 (defconst javadoc-font-lock-keywords
   `((,(lambda (limit)
 	(c-font-lock-doc-comments "/\\*\\*" limit
 	  javadoc-font-lock-doc-comments)))))
 
+;; Pike autodoc.
+
 (defconst autodoc-decl-keywords
   ;; Adorned regexp matching the keywords that introduce declarations
   ;; in Pike Autodoc.
@@ -2736,6 +2165,8 @@ need for `pike-font-lock-extra-types'.")
 (defun autodoc-font-lock-line-markup (limit)
   ;; Fontify all line oriented keywords between the point and LIMIT.
   ;; Nil is always returned.
+  ;;
+  ;; This function might do hidden buffer changes.
 
   (let ((line-re (concat "^\\(\\(/\\*!\\|\\s *\\("
 			 c-current-comment-prefix
@@ -2765,7 +2196,7 @@ need for `pike-font-lock-extra-types'.")
 		     (and (eq (char-before) ?@)
 			  (not (eobp))
 			  (progn (forward-char)
-				 (skip-chars-forward " \t")
+				 (skip-syntax-forward " ")
 				 (looking-at c-current-comment-prefix))))
 	      (goto-char (match-end 0))
 	      (c-remove-font-lock-face pos (1- end))
@@ -2804,7 +2235,7 @@ need for `pike-font-lock-extra-types'.")
 		 (and (eq (char-before) ?@)
 		      (not (eobp))
 		      (progn (forward-char)
-			     (skip-chars-forward " \t")
+			     (skip-syntax-forward " ")
 			     (looking-at c-current-comment-prefix))))
 	  (goto-char (match-end 0))))))
 
@@ -2818,12 +2249,14 @@ need for `pike-font-lock-extra-types'.")
     ;; Fontify remaining markup characters as invalid.
     (,(lambda (limit)
 	(c-find-invalid-doc-markup "@" limit))
-     0 ,c-invalid-face-name prepend nil)
+     0 'font-lock-warning-face prepend nil)
     ))
 
 (defun autodoc-font-lock-keywords ()
   ;; Note that we depend on that `c-current-comment-prefix' has got
   ;; its proper value here.
+  ;;
+  ;; This function might do hidden buffer changes.
 
   ;; The `c-type' text property with `c-decl-end' is used to mark the
   ;; end of the `autodoc-decl-keywords' occurrences to fontify the
@@ -2846,13 +2279,13 @@ need for `pike-font-lock-extra-types'.")
      ',(eval-when-compile               ; Evaluate while compiling cc-fonts
 	 (list
 	  ;; Function names.
-	  '("^[ \t]*\\(func\\(tion\\)?\\)\\>[ \t]*\\(\\sw+\\)?"
+	  '("^\\s *\\(func\\(tion\\)?\\)\\>\\s *\\(\\sw+\\)?"
 	    (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t))
 	  ;;
 	  ;; Variable names.
 	  (cons
 	   (concat "\\<"
-		   (c-regexp-opt
+		   (regexp-opt
 		    '("ARGC" "ARGIND" "ARGV" "BINMODE" "CONVFMT" "ENVIRON"
 		      "ERRNO" "FIELDWIDTHS" "FILENAME" "FNR" "FS" "IGNORECASE"
 		      "LINT" "NF" "NR" "OFMT" "OFS" "ORS" "PROCINFO" "RLENGTH"
@@ -2861,7 +2294,7 @@ need for `pike-font-lock-extra-types'.")
 
 	  ;; Special file names.  (acm, 2002/7/22)
 	  ;; The following regexp was created by first evaluating this in GNU Emacs 21.1:
-	  ;; (c-regexp-opt '("/dev/stdin" "/dev/stdout" "/dev/stderr" "/dev/fd/n" "/dev/pid"
+	  ;; (regexp-opt '("/dev/stdin" "/dev/stdout" "/dev/stderr" "/dev/fd/n" "/dev/pid"
 	  ;;                 "/dev/ppid" "/dev/pgrpid" "/dev/user") 'words)
 	  ;; , removing the "?:" from each "\\(?:" (for backward compatibility with older Emacsen)
 	  ;; , replacing the "n" in "dev/fd/n" with "[0-9]+"
@@ -2875,7 +2308,7 @@ std\\(err\\|in\\|out\\)\\|user\\)\\)\\>\
 	    (1 font-lock-variable-name-face t)
 	    (8 font-lock-variable-name-face t t))
 	  ;; Do the same (almost) with
-	  ;; (c-regexp-opt '("/inet/tcp/lport/rhost/rport" "/inet/udp/lport/rhost/rport"
+	  ;; (regexp-opt '("/inet/tcp/lport/rhost/rport" "/inet/udp/lport/rhost/rport"
 	  ;;                 "/inet/raw/lport/rhost/rport") 'words)
 	  ;; This cannot be combined with the above pattern, because the match number
 	  ;; for the (optional) closing \" would then exceed 9.
@@ -2886,7 +2319,7 @@ std\\(err\\|in\\|out\\)\\|user\\)\\)\\>\
 
 	  ;; Keywords.
 	  (concat "\\<"
-		  (c-regexp-opt
+		  (regexp-opt
 		   '("BEGIN" "END" "break" "continue" "delete" "do" "else"
 		     "exit" "for" "getline" "if" "in" "next" "nextfile"
 		     "return" "while")
@@ -2896,7 +2329,7 @@ std\\(err\\|in\\|out\\)\\|user\\)\\)\\>\
 	  `(eval . (list
 		    ,(concat
 		      "\\<"
-		      (c-regexp-opt
+		      (regexp-opt
 		       '("adump" "and" "asort" "atan2" "bindtextdomain" "close"
 			 "compl" "cos" "dcgettext" "exp" "extension" "fflush"
 			 "gensub" "gsub" "index" "int" "length" "log" "lshift"
@@ -2909,17 +2342,17 @@ std\\(err\\|in\\|out\\)\\|user\\)\\)\\>\
 
 	  ;; gawk debugging keywords.  (acm, 2002/7/21)
 	  ;; (Removed, 2003/6/6.  These functions are now fontified as built-ins)
-;;	(list (concat "\\<" (c-regexp-opt '("adump" "stopme") t) "\\>")
+;;	(list (concat "\\<" (regexp-opt '("adump" "stopme") t) "\\>")
 ;;	   0 'font-lock-warning-face)
 
 	  ;; User defined functions with an apparent spurious space before the
 	  ;; opening parenthesis.  acm, 2002/5/30.
-	  `(,(concat "\\(\\w\\|_\\)" c-awk-escaped-nls* "[ \t]"
+	  `(,(concat "\\(\\w\\|_\\)" c-awk-escaped-nls* "\\s "
 		     c-awk-escaped-nls*-with-space* "(")
 	    (0 'font-lock-warning-face))
 
 	  ;; Space after \ in what looks like an escaped newline.  2002/5/31
-	  '("\\\\[ \t]+$" 0 font-lock-warning-face t)
+	  '("\\\\\\s +$" 0 font-lock-warning-face t)
 
 	  ;; Unbalanced string (") or regexp (/) delimiters.  2002/02/16.
 	  '("\\s|" 0 font-lock-warning-face t nil)