Allow arbitrary regexps in *-font-lock-extra-types.

1 files changed, 246 insertions, 189 deletions

diff --git a/lisp/font-lock.el b/lisp/font-lock.el
index 380d41261ae..5186399ba34 100644
--- a/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@ -190,7 +190,7 @@
 If a number, only buffers greater than this size have fontification messages.")
 
 ;;;###autoload
-(defvar font-lock-maximum-decoration nil
+(defvar font-lock-maximum-decoration t
   "*Maximum decoration level for fontification.
 If nil, use the default decoration (typically the minimum available).
 If t, use the maximum decoration available.
@@ -274,11 +274,12 @@ MATCH-HIGHLIGHT should be of the form:
 
 Where MATCHER can be either the regexp to search for, or the function name to
 call to make the search (called with one argument, the limit of the search).
-MATCH is the subexpression of MATCHER to be highlighted.  FACENAME is an
+MATCH is the subexpression of MATCHER to be highlighted.  MATCH can be
+calculated via the function `font-lock-keyword-depth'.  FACENAME is an
 expression whose value is the face name to use.  FACENAME's default attributes
-may be defined in `font-lock-face-attributes'.
+can be defined via the variable `font-lock-face-attributes'.
 
-OVERRIDE and LAXMATCH are flags.  If OVERRIDE is t, existing fontification may
+OVERRIDE and LAXMATCH are flags.  If OVERRIDE is t, existing fontification can
 be overwritten.  If `keep', only parts not already fontified are highlighted.
 If `prepend' or `append', existing fontification is merged with the new, in
 which the new or existing fontification, respectively, takes precedence.
@@ -332,16 +333,55 @@ These regular expressions should not match text which spans lines.  While
 \\[font-lock-fontify-buffer] handles multi-line patterns correctly, updating
 when you edit the buffer does not, since it considers text one line at a time.
 
-Be very careful composing regexps for this list;
-the wrong pattern can dramatically slow things down!")
-(make-variable-buffer-local 'font-lock-keywords)
+This variable is set by major modes via the variable `font-lock-defaults'.
+Be careful when composing regexps for this list; a poorly written pattern can
+dramatically slow things down!")
 
 ;; This variable is used by mode packages that support Font Lock mode by
 ;; defining their own keywords to use for `font-lock-keywords'.  (The mode
 ;; command should make it buffer-local and set it to provide the set up.)
 (defvar font-lock-defaults nil
-  "If set by a major mode, should be the defaults for Font Lock mode.
-The value should be like the `cdr' of an item in `font-lock-defaults-alist'.")
+  "Defaults for Font Lock mode specified by the major mode.
+Defaults should be of the form:
+
+ (KEYWORDS KEYWORDS-ONLY CASE-FOLD SYNTAX-ALIST SYNTAX-BEGIN ...)
+
+KEYWORDS may be a symbol (a variable or function whose value is the keywords to
+use for fontification) or a list of symbols.  If KEYWORDS-ONLY is non-nil,
+syntactic fontification (strings and comments) is not performed.
+If CASE-FOLD is non-nil, the case of the keywords is ignored when fontifying.
+If SYNTAX-ALIST is non-nil, it should be a list of cons pairs of the form
+\(CHAR-OR-STRING . STRING) used to set the local Font Lock syntax table, for
+keyword and syntactic fontification (see `modify-syntax-entry').
+
+If SYNTAX-BEGIN is non-nil, it should be a function with no args used to move
+backwards outside any enclosing syntactic block, for syntactic fontification.
+Typical values are `beginning-of-line' (i.e., the start of the line is known to
+be outside a syntactic block), or `beginning-of-defun' for programming modes or
+`backward-paragraph' for textual modes (i.e., the mode-dependent function is
+known to move outside a syntactic block).  If nil, the beginning of the buffer
+is used as a position outside of a syntactic block, in the worst case.
+
+These item elements are used by Font Lock mode to set the variables
+`font-lock-keywords', `font-lock-keywords-only',
+`font-lock-keywords-case-fold-search', `font-lock-syntax-table' and
+`font-lock-beginning-of-syntax-function', respectively.
+
+Further item elements are alists of the form (VARIABLE . VALUE) and are in no
+particular order.  Each VARIABLE is made buffer-local before set to VALUE.
+
+Currently, appropriate variables include `font-lock-mark-block-function'.
+If this is non-nil, it should be a function with no args used to mark any
+enclosing block of text, for fontification via \\[font-lock-fontify-block].
+Typical values are `mark-defun' for programming modes or `mark-paragraph' for
+textual modes (i.e., the mode-dependent function is known to put point and mark
+around a text block relevant to that mode).
+
+Other variables include those for buffer-specialised fontification functions,
+`font-lock-fontify-buffer-function', `font-lock-unfontify-buffer-function',
+`font-lock-fontify-region-function', `font-lock-unfontify-region-function',
+`font-lock-comment-start-regexp', `font-lock-inhibit-thing-lock' and
+`font-lock-maximum-size'.")
 
 ;; This variable is used where font-lock.el itself supplies the keywords.
 (defvar font-lock-defaults-alist
@@ -408,48 +448,13 @@ The value should be like the `cdr' of an item in `font-lock-defaults-alist'.")
      (cons 'scheme-interaction-mode	scheme-mode-defaults)
      (cons 'slitex-mode			tex-mode-defaults)
      (cons 'tex-mode			tex-mode-defaults)))
-  "Alist of default major mode and Font Lock defaults.
+  "Alist of fall-back Font Lock defaults for major modes.
 Each item should be a list of the form:
 
- (MAJOR-MODE . (KEYWORDS KEYWORDS-ONLY CASE-FOLD SYNTAX-ALIST SYNTAX-BEGIN
-                ...))
-
-where MAJOR-MODE is a symbol.  KEYWORDS may be a symbol (a variable or function
-whose value is the keywords to use for fontification) or a list of symbols.
-If KEYWORDS-ONLY is non-nil, syntactic fontification (strings and comments) is
-not performed.  If CASE-FOLD is non-nil, the case of the keywords is ignored
-when fontifying.  If SYNTAX-ALIST is non-nil, it should be a list of cons pairs
-of the form (CHAR-OR-STRING . STRING) used to set the local Font Lock syntax
-table, for keyword and syntactic fontification (see `modify-syntax-entry').
-
-If SYNTAX-BEGIN is non-nil, it should be a function with no args used to move
-backwards outside any enclosing syntactic block, for syntactic fontification.
-Typical values are `beginning-of-line' (i.e., the start of the line is known to
-be outside a syntactic block), or `beginning-of-defun' for programming modes or
-`backward-paragraph' for textual modes (i.e., the mode-dependent function is
-known to move outside a syntactic block).  If nil, the beginning of the buffer
-is used as a position outside of a syntactic block, in the worst case.
-
-These item elements are used by Font Lock mode to set the variables
-`font-lock-keywords', `font-lock-keywords-only',
-`font-lock-keywords-case-fold-search', `font-lock-syntax-table' and
-`font-lock-beginning-of-syntax-function', respectively.
-
-Further item elements are alists of the form (VARIABLE . VALUE) and are in no
-particular order.  Each VARIABLE is made buffer-local before set to VALUE.
-
-Currently, appropriate variables include `font-lock-mark-block-function'.
-If this is non-nil, it should be a function with no args used to mark any
-enclosing block of text, for fontification via \\[font-lock-fontify-block].
-Typical values are `mark-defun' for programming modes or `mark-paragraph' for
-textual modes (i.e., the mode-dependent function is known to put point and mark
-around a text block relevant to that mode).
+ (MAJOR-MODE . FONT-LOCK-DEFAULTS)
 
-Other variables include those for buffer-specialised fontification functions,
-`font-lock-fontify-buffer-function', `font-lock-unfontify-buffer-function',
-`font-lock-fontify-region-function', `font-lock-unfontify-region-function',
-`font-lock-comment-start-regexp', `font-lock-inhibit-thing-lock' and
-`font-lock-maximum-size'.")
+where MAJOR-MODE is a symbol and FONT-LOCK-DEFAULTS is a list of default
+settings.  See the variable `font-lock-defaults', which takes precedence.")
 
 (defvar font-lock-keywords-alist nil
   "*Alist of `font-lock-keywords' local to a `major-mode'.
@@ -642,8 +647,8 @@ or nil.  If nil, highlighting keywords are added for the current buffer.
 KEYWORDS should be a list; see the variable `font-lock-keywords'.
 By default they are added at the beginning of the current highlighting list.
 If optional argument APPEND is `set', they are used to replace the current
-highlighting list.  If APPEND has any other value, e.g., t, they are added at
-the end of the current highlighting list.
+highlighting list.  If APPEND is any other non-nil value, they are added at the
+end of the current highlighting list.
 
 For example:
 
@@ -652,7 +657,11 @@ For example:
     (\"\\\\\\=<\\\\(and\\\\|or\\\\|not\\\\)\\\\\\=>\" . font-lock-keyword-face)))
 
 adds two fontification patterns for C mode, to fontify `FIXME:' words, even in
-comments, and to fontify `and', `or' and `not' words as keywords."
+comments, and to fontify `and', `or' and `not' words as keywords.
+
+Note that some modes have specialised support for additional patterns, e.g.,
+see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types',
+`objc-font-lock-extra-types' and `java-font-lock-extra-types'."
   (cond (major-mode
 	 ;; If MAJOR-MODE is non-nil, add the KEYWORDS and APPEND spec to
 	 ;; `font-lock-keywords-alist' so `font-lock-set-defaults' uses them.
@@ -671,8 +680,8 @@ comments, and to fontify `and', `or' and `not' words as keywords."
 					  (append old keywords)
 					(append keywords old))))))))
 
-;; Global Font Lock mode.
-;;
+;;; Global Font Lock mode.
+
 ;; A few people have hassled in the past for a way to make it easier to turn on
 ;; Font Lock mode, without the user needing to know for which modes s/he has to
 ;; turn it on, perhaps the same way hilit19.el/hl319.el does.  I've always
@@ -794,10 +803,10 @@ turned on in a buffer if its major mode is one of `font-lock-global-modes'."
 
 (add-hook 'change-major-mode-hook 'font-lock-change-major-mode)
 
-;; End of Global Font Lock mode.
+;;; End of Global Font Lock mode.
 
-;; Font Lock Support mode.
-;;
+;;; Font Lock Support mode.
+
 ;; This is the code used to interface font-lock.el with any of its add-on
 ;; packages, and provide the user interface.  Packages that have their own
 ;; local buffer fontification functions (see below) may have to call
@@ -848,9 +857,9 @@ The value of this variable is used when Font Lock mode is turned on.")
 	(lazy-lock-mode
 	 (lazy-lock-after-unfontify-buffer))))
 
-;; End of Font Lock Support mode.
+;;; End of Font Lock Support mode.
 
-;; Fontification functions.
+;;; Fontification functions.
 
 ;; Rather than the function, e.g., `font-lock-fontify-region' containing the
 ;; code to fontify a region, the function runs the function whose name is the
@@ -1002,8 +1011,10 @@ delimit the region to fontify."
 	  ((error quit) (message "Fontifying block...%s" error-data)))))))
 
 (define-key facemenu-keymap "\M-g" 'font-lock-fontify-block)
+
+;;; End of Fontification functions.
 
-;; Syntactic fontification functions.
+;;; Syntactic fontification functions.
 
 ;; These record the parse state at a particular position, always the start of a
 ;; line.  Used to make `font-lock-fontify-syntactically-region' faster.
@@ -1114,6 +1125,8 @@ START should be at the beginning of a line."
 	       (error (goto-char end)))
 	     (put-text-property beg (point) 'face font-lock-comment-face)
 	     (setq state (parse-partial-sexp here (point) nil nil state)))))))
+
+;;; End of Syntactic fontification functions.
 
 ;;; Additional text property functions.
 
@@ -1193,6 +1206,8 @@ Optional argument OBJECT is the string or buffer containing the text."
 ;		     (t
 ;		      (put-text-property start next prop new object))))))
 ;      (setq start (text-property-not-all next end prop nil object)))))
+
+;;; End of Additional text property functions.
 
 ;;; Regexp fontification functions.
 
@@ -1277,6 +1292,8 @@ START should be at the beginning of a line."
 	    (font-lock-fontify-anchored-keywords (car highlights) end))
 	  (setq highlights (cdr highlights))))
       (setq keywords (cdr keywords)))))
+
+;;; End of Regexp fontification functions.
 
 ;; Various functions.
 
@@ -1349,9 +1366,8 @@ Sets various variables using `font-lock-defaults' (or, if nil, using
 	     (font-lock-value-in-major-mode font-lock-maximum-decoration)))
 	   (local (cdr (assq major-mode font-lock-keywords-alist))))
       ;; Regexp fontification?
-      (setq font-lock-keywords (if (fboundp keywords)
-				   (funcall keywords)
-				 (eval keywords)))
+      (set (make-local-variable 'font-lock-keywords)
+	   (if (fboundp keywords) (funcall keywords) (eval keywords)))
       ;; Local fontification?
       (while local
 	(font-lock-add-keywords nil (car (car local)) (cdr (car local)))
@@ -1403,7 +1419,7 @@ Sets various variables using `font-lock-defaults' (or, if nil, using
       (set (car (car alist)) (default-value (car (car alist))))
       (setq alist (cdr alist)))))
 
-;; Colour etc. support.
+;;; Colour etc. support.
 
 ;; This section of code is crying out for revision.  Come on down, custom.el?
 
@@ -1612,6 +1628,8 @@ the face is also set; its value is the face name."
     (or (funcall set-p face-name "Underline")
 	(set-face-underline-p face (nth 5 face-attributes)))
     (set face face)))
+
+;;; End of Colour etc. support.
 
 ;;; Menu support.
 
@@ -1713,6 +1731,8 @@ the face is also set; its value is the face name."
 ;(defun font-lock-unset-menu ()
 ;  ;; Deactivate less/more fontification entries.
 ;  (setq font-lock-fontify-level nil))
+
+;;; End of Menu support.
 
 ;;; Various regexp information shared by several modes.
 ;;; Information specific to a single mode should go in its load library.
@@ -1752,10 +1772,19 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
 	    (goto-char (match-end 2)))
 	(error t)))))
 
+(defun font-lock-keyword-depth (keyword)
+  "Return the depth of KEYWORD regexp.
+This means the number of parenthesized expressions."
+  (let ((count 0) start)
+    (while (string-match "\\\\(" keyword start)
+      (setq start (match-end 0) count (1+ count)))
+    count))
+
 
 (defconst lisp-font-lock-keywords-1
   (eval-when-compile
     (list
+     ;;
      ;; Anything not a variable or type declaration is fontified as a function.
      ;; It would be cleaner to allow preceding whitespace, but it would also be
      ;; about five times slower.
@@ -1775,6 +1804,11 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
 		     ((match-beginning 4) font-lock-type-face)
 		     (t font-lock-function-name-face))
 	       nil t))
+     ;;
+     ;; Emacs Lisp autoload cookies.
+     '("^;;;\\(###\\)\\(autoload\\)\\>"
+       (1 font-lock-reference-face prepend)
+       (2 font-lock-warning-face prepend))
      ))
   "Subdued level highlighting for Lisp modes.")
 
@@ -1783,32 +1817,42 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
    (eval-when-compile
      (list
       ;;
-      ;; Control structures.  Common ELisp and CLisp forms combined.
-;      (make-regexp
-;       '("cond" "if" "while" "let\\*?" "prog[nv12*]?" "inline" "catch" "throw"
-;	 "save-restriction" "save-excursion" "save-window-excursion"
-;	 "save-selected-window" "save-match-data" "save-current-buffer"
-;	 "unwind-protect" "condition-case" "track-mouse" "dont-compile"
-;	 "eval-after-load" "eval-and-compile" "eval-when-compile"
-;	 "when" "unless" "do" "flet" "labels" "return" "return-from"
-;	 "with-output-to-temp-buffer" "with-timeout" "with-current-buffer"
-;	 "with-temp-buffer" "with-temp-file"))
+      ;; Control structures.  Emacs Lisp forms.
       (cons (concat "(\\("
-		    "c\\(atch\\|ond\\(\\|ition-case\\)\\)\\|"
-		    "do\\(\\|nt-compile\\)\\|"
+;	'("cond" "if" "while" "let\\*?" "prog[nv12*]?" "inline" "catch" "throw"
+;	  "save-restriction" "save-excursion" "save-window-excursion"
+;	  "save-selected-window" "save-match-data" "save-current-buffer"
+;	  "unwind-protect" "condition-case" "track-mouse" "dont-compile"
+;	  "eval-after-load" "eval-and-compile" "eval-when" "eval-when-compile"
+;	  "with-output-to-temp-buffer" "with-timeout" "with-current-buffer"
+;	  "with-temp-buffer" "with-temp-file")		    
+		    "c\\(atch\\|ond\\(\\|ition-case\\)\\)\\|dont-compile\\|"
 		    "eval-\\(a\\(fter-load\\|nd-compile\\)\\|"
-		    "when-compile\\)\\|flet\\|i\\(f\\|nline\\)\\|"
-		    "l\\(abels\\|et\\*?\\)\\|prog[nv12*]?\\|"
-		    "return\\(\\|-from\\)\\|"
+		    "when\\(\\|-compile\\)\\)\\|"
+		    "i\\(f\\|nline\\)\\|let\\*?\\|prog[nv12*]?\\|"
 		    "save-\\(current-buffer\\|excursion\\|match-data\\|"
 		    "restriction\\|selected-window\\|window-excursion\\)\\|"
-		    "t\\(hrow\\|rack-mouse\\)\\|un\\(less\\|wind-protect\\)\\|"
-		    "w\\(h\\(en\\|ile\\)\\|ith-\\(current-buffer\\|"
+		    "t\\(hrow\\|rack-mouse\\)\\|unwind-protect\\|"
+		    "w\\(hile\\|ith-\\(current-buffer\\|"
 		    "output-to-temp-buffer\\|"
 		    "t\\(emp-\\(buffer\\|file\\)\\|imeout\\)\\)\\)"
 		    "\\)\\>")
 	    1)
       ;;
+      ;; Control structures.  Common Lisp forms.
+      (cons (concat "(\\("
+;	'(make-regexp
+;	  '("when" "unless" "case" "ecase" "typecase" "etypecase"
+;	    "loop" "do\\*?" "dotimes" "dolist"
+;	    "proclaim" "declaim" "declare"
+;	    "lexical-let\\*?" "flet" "labels" "return" "return-from"))
+		    "case\\|d\\(ecla\\(im\\|re\\)\\|o\\(\\*?\\|"
+		    "list\\|times\\)\\)\\|e\\(case\\|typecase\\)\\|flet\\|"
+		    "l\\(abels\\|exical-let\\*?\\|oop\\)\\|proclaim\\|"
+		    "return\\(\\|-from\\)\\|typecase\\|unless\\|when"
+		    "\\)\\>")
+	    1)
+      ;;
       ;; Feature symbols as references.
       '("(\\(featurep\\|provide\\|require\\)\\>[ \t']*\\(\\sw+\\)?"
 	(1 font-lock-keyword-face) (2 font-lock-reference-face nil t))
@@ -1922,25 +1966,25 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
 
 (defvar c-font-lock-extra-types '("FILE" "\\sw+_t")
   "*List of extra types to fontify in C mode.
-Each list item should be a regexp without word-delimiters or parentheses.
+Each list item should be a regexp without word-delimiters.
 For example, a value of (\"FILE\" \"\\\\sw+_t\") means the word FILE and words
 ending in _t are treated as type names.")
 
 (defvar c++-font-lock-extra-types nil
   "*List of extra types to fontify in C++ mode.
-Each list item should be a regexp without word-delimiters or parentheses.
+Each list item should be a regexp without word-delimiters.
 For example, a value of (\"String\") means the word String is treated as a type
 name.")
 
 (defvar objc-font-lock-extra-types '("Class" "BOOL" "IMP" "SEL")
   "*List of extra types to fontify in Objective-C mode.
-Each list item should be a regexp without word-delimiters or parentheses.
+Each list item should be a regexp without word-delimiters.
 For example, a value of (\"Class\" \"BOOL\" \"IMP\" \"SEL\") means the words
 Class, BOOL, IMP and SEL are treated as type names.")
 
 (defvar java-font-lock-extra-types '("[A-Z\300-\326\330-\337]\\sw+")
   "*List of extra types to fontify in Java mode.
-Each list item should be a regexp without word-delimiters or parentheses.
+Each list item should be a regexp without word-delimiters.
 For example, a value of (\"[A-Z\300-\326\330-\337]\\\\sw+\") means capitalised
 words (and words conforming to the Java id spec) are treated as type names.")
 
@@ -1971,22 +2015,23 @@ See also `c-font-lock-extra-types'.")
   "Gaudy level highlighting for C mode.
 See also `c-font-lock-extra-types'.")
 
-(let ((c-keywords
-;      ("break" "continue" "do" "else" "for" "if" "return" "switch" "while")
-       "break\\|continue\\|do\\|else\\|for\\|if\\|return\\|switch\\|while")
-      (c-type-types
-;      ("auto" "extern" "register" "static" "typedef" "struct" "union" "enum"
-;	"signed" "unsigned" "short" "long" "int" "char" "float" "double"
-;	"void" "volatile" "const")
-       `(mapconcat 'identity
-	 (cons 
-	  (,@ (concat "auto\\|c\\(har\\|onst\\)\\|double\\|"	; 6 ()s deep.
-		      "e\\(num\\|xtern\\)\\|float\\|int\\|long\\|register\\|"
-		      "s\\(hort\\|igned\\|t\\(atic\\|ruct\\)\\)\\|typedef\\|"
-		      "un\\(ion\\|signed\\)\\|vo\\(id\\|latile\\)"))
-	  c-font-lock-extra-types)
-	 "\\|"))
-      )
+(let* ((c-keywords
+;	("break" "continue" "do" "else" "for" "if" "return" "switch" "while")
+	"break\\|continue\\|do\\|else\\|for\\|if\\|return\\|switch\\|while")
+       (c-type-types
+;	("auto" "extern" "register" "static" "typedef" "struct" "union" "enum"
+;	 "signed" "unsigned" "short" "long" "int" "char" "float" "double"
+;	 "void" "volatile" "const")
+	`(mapconcat 'identity
+	  (cons 
+	   (,@ (concat "auto\\|c\\(har\\|onst\\)\\|double\\|"
+		       "e\\(num\\|xtern\\)\\|float\\|int\\|long\\|register\\|"
+		       "s\\(hort\\|igned\\|t\\(atic\\|ruct\\)\\)\\|typedef\\|"
+		       "un\\(ion\\|signed\\)\\|vo\\(id\\|latile\\)"))
+	   c-font-lock-extra-types)
+	  "\\|"))
+       (c-type-depth `(font-lock-keyword-depth (,@ c-type-types)))
+       )
  (setq c-font-lock-keywords-1
   (list
    ;;
@@ -2051,15 +2096,17 @@ See also `c-font-lock-extra-types'.")
       (list (concat "\\<\\(" (,@ c-type-types) "\\)\\>"
 		    "\\([ \t*&]+\\sw+\\>\\)*")
 	    ;; Fontify each declaration item.
-	    '(font-lock-match-c-style-declaration-item-and-skip-to-next
-	      ;; Start with point after all type specifiers.
-	      (goto-char (or (match-beginning 8) (match-end 1)))
-	      ;; Finish with point after first type specifier.
-	      (goto-char (match-end 1))
-	      ;; Fontify as a variable or function name.
-	      (1 (if (match-beginning 2)
-		     font-lock-function-name-face
-		   font-lock-variable-name-face)))))
+	    (list 'font-lock-match-c-style-declaration-item-and-skip-to-next
+		  ;; Start with point after all type specifiers.
+		  (list 'goto-char (list 'or (list 'match-beginning
+						   (+ (,@ c-type-depth) 2))
+					 '(match-end 1)))
+		  ;; Finish with point after first type specifier.
+		  '(goto-char (match-end 1))
+		  ;; Fontify as a variable or function name.
+		  '(1 (if (match-beginning 2)
+			  font-lock-function-name-face
+			font-lock-variable-name-face)))))
     ;;
     ;; Fontify structures, or typedef names, plus their items.
     '("\\(}\\)[ \t*]*\\sw"
@@ -2109,7 +2156,7 @@ See also `c++-font-lock-extra-types'.")
   (when (looking-at (eval-when-compile
 		      (concat "[ \t*&]*\\(\\sw+\\)"
 			      "\\(<\\(\\sw+\\)[ \t*&]*>\\)?"
-			      "\\(::\\*?\\(\\sw+\\)\\)?"
+			      "\\([ \t]*::[ \t*]*\\(\\sw+\\)\\)?"
 			      "[ \t]*\\((\\)?")))
     (save-match-data
       (condition-case nil
@@ -2161,9 +2208,12 @@ See also `c++-font-lock-extra-types'.")
 		       "v\\(irtual\\|o\\(id\\|latile\\)\\)"))	; 12 ()s deep.
 	   c++-font-lock-extra-types)
 	  "\\|"))
-       (c++-type-suffix "\\(<\\(\\sw+\\)[ \t*&]*>\\)?\\(::\\*?\\(\\sw+\\)\\)?")
+       (c++-type-suffix (concat "\\(<\\(\\sw+\\)[ \t*&]*>\\)?"
+				"\\([ \t]*::[ \t*]*\\(\\sw+\\)\\)?"))
+       (c++-type-depth `(font-lock-keyword-depth
+			 (concat (,@ c++-type-types) (,@ c++-type-suffix))))
        (c++-type-spec (concat "\\(\\sw+\\)\\>" c++-type-suffix))
-      )
+       )
  (setq c++-font-lock-keywords-1
   (append
    ;;
@@ -2229,20 +2279,22 @@ See also `c++-font-lock-extra-types'.")
       (list (concat "\\<\\(" (,@ c++-type-types) "\\)\\>" (,@ c++-type-suffix)
 		    "\\([ \t*&]+" (,@ c++-type-spec) "\\)*")
 	    ;; Fontify each declaration item.
-	    '(font-lock-match-c++-style-declaration-item-and-skip-to-next
-	      ;; Start with point after all type specifiers.
-	      (goto-char (or (match-beginning 18) (match-end 1)))
-	      ;; Finish with point after first type specifier.
-	      (goto-char (match-end 1))
-	      ;; Fontify as a variable or function name.
-	      (1 (cond ((or (match-beginning 2) (match-beginning 4))
-			font-lock-type-face)
-		       ((match-beginning 6) font-lock-function-name-face)
-		       (t font-lock-variable-name-face)))
-	      (3 font-lock-function-name-face nil t)
-	      (5 (if (match-beginning 6)
-		     font-lock-function-name-face
-		   font-lock-variable-name-face) nil t))))
+	    (list 'font-lock-match-c++-style-declaration-item-and-skip-to-next
+		  ;; Start with point after all type specifiers.
+		  (list 'goto-char (list 'or (list 'match-beginning
+						   (+ (,@ c++-type-depth) 2))
+					 '(match-end 1)))
+		  ;; Finish with point after first type specifier.
+		  '(goto-char (match-end 1))
+		  ;; Fontify as a variable or function name.
+		  '(1 (cond ((or (match-beginning 2) (match-beginning 4))
+			     font-lock-type-face)
+			    ((match-beginning 6) font-lock-function-name-face)
+			    (t font-lock-variable-name-face)))
+		  '(3 font-lock-function-name-face nil t)
+		  '(5 (if (match-beginning 6)
+			  font-lock-function-name-face
+			font-lock-variable-name-face) nil t))))
     ;;
     ;; Fontify structures, or typedef names, plus their items.
     '("\\(}\\)[ \t*]*\\sw"
@@ -2287,28 +2339,28 @@ See also `objc-font-lock-extra-types'.")
 
 ;; Regexps written with help from Stephen Peters <speters@us.oracle.com> and
 ;; Jacques Duthen Prestataire <duthen@cegelec-red.fr>.
-(let ((objc-keywords
-;       (make-regexp
+(let* ((objc-keywords
 ;	'("break" "continue" "do" "else" "for" "if" "return" "switch" "while"
-;	  "sizeof" "self" "super"))
-       (concat "break\\|continue\\|do\\|else\\|for\\|if\\|return\\|"
-	       "s\\(elf\\|izeof\\|uper\\|witch\\)\\|while"))
-      (objc-type-types
-       `(mapconcat 'identity
-	 (cons
-;	 '("auto" "extern" "register" "static" "typedef" "struct" "union"
-;	   "enum" "signed" "unsigned" "short" "long" "int" "char"
-;	   "float" "double" "void" "volatile" "const"
-;	   "id" "oneway" "in" "out" "inout" "bycopy" "byref")
-	  (,@ (concat "auto\\|by\\(copy\\|ref\\)\\|c\\(har\\|onst\\)\\|"
-		      "double\\|e\\(num\\|xtern\\)\\|float\\|"
-		      "i\\([dn]\\|n\\(out\\|t\\)\\)\\|long\\|"
-		      "o\\(neway\\|ut\\)\\|register\\|s\\(hort\\|igned\\|"
-		      "t\\(atic\\|ruct\\)\\)\\|typedef\\|"
-		      "un\\(ion\\|signed\\)\\|vo\\(id\\|latile\\)"))
-	  objc-font-lock-extra-types)
-	 "\\|"))
-      )
+;	  "sizeof" "self" "super")
+	(concat "break\\|continue\\|do\\|else\\|for\\|if\\|return\\|"
+		"s\\(elf\\|izeof\\|uper\\|witch\\)\\|while"))
+       (objc-type-types
+	`(mapconcat 'identity
+	  (cons
+;	   '("auto" "extern" "register" "static" "typedef" "struct" "union"
+;	     "enum" "signed" "unsigned" "short" "long" "int" "char"
+;	     "float" "double" "void" "volatile" "const"
+;	     "id" "oneway" "in" "out" "inout" "bycopy" "byref")
+	   (,@ (concat "auto\\|by\\(copy\\|ref\\)\\|c\\(har\\|onst\\)\\|"
+		       "double\\|e\\(num\\|xtern\\)\\|float\\|"
+		       "i\\([dn]\\|n\\(out\\|t\\)\\)\\|long\\|"
+		       "o\\(neway\\|ut\\)\\|register\\|s\\(hort\\|igned\\|"
+		       "t\\(atic\\|ruct\\)\\)\\|typedef\\|"
+		       "un\\(ion\\|signed\\)\\|vo\\(id\\|latile\\)"))
+	   objc-font-lock-extra-types)
+	  "\\|"))
+       (objc-type-depth `(font-lock-keyword-depth (,@ objc-type-types)))
+       )
  (setq objc-font-lock-keywords-1
   (append
    ;;
@@ -2379,15 +2431,17 @@ See also `objc-font-lock-extra-types'.")
       (list (concat "\\<\\(" (,@ objc-type-types) "\\)\\>"
 		    "\\([ \t*&]+\\sw+\\>\\)*")
 	    ;; Fontify each declaration item.
-	    '(font-lock-match-c-style-declaration-item-and-skip-to-next
-	      ;; Start with point after all type specifiers.
-	      (goto-char (or (match-beginning 2) (match-end 1)))
-	      ;; Finish with point after first type specifier.
-	      (goto-char (match-end 1))
-	      ;; Fontify as a variable or function name.
-	      (1 (if (match-beginning 2)
-		     font-lock-function-name-face
-		   font-lock-variable-name-face)))))
+	    (list 'font-lock-match-c-style-declaration-item-and-skip-to-next
+		  ;; Start with point after all type specifiers.
+		  (list 'goto-char (list 'or (list 'match-beginning
+						   (+ (,@ objc-type-depth) 2))
+					 '(match-end 1)))
+		  ;; Finish with point after first type specifier.
+		  '(goto-char (match-end 1))
+		  ;; Fontify as a variable or function name.
+		  '(1 (if (match-beginning 2)
+			  font-lock-function-name-face
+			font-lock-variable-name-face)))))
     ;;
     ;; Fontify structures, or typedef names, plus their items.
     '("\\(}\\)[ \t*]*\\sw"
@@ -2427,40 +2481,40 @@ See also `java-font-lock-extra-types'.")
 
 ;; Regexps written with help from Fred White <fwhite@bbn.com> and
 ;; Anders Lindgren <andersl@csd.uu.se>.
-(let ((java-keywords
-       (concat "\\<\\("
-;	       (make-regexp
+(let* ((java-keywords
+	(concat "\\<\\("
 ;		'("catch" "do" "else" "super" "this" "finally" "for" "if"
 ;;		  ;; Anders Lindgren <andersl@csd.uu.se> says these have gone.
 ;;		  "cast" "byvalue" "future" "generic" "operator" "var"
 ;;		  "inner" "outer" "rest"
 ;		  "interface" "return" "switch" "throw" "try" "while")
-	       "catch\\|do\\|else\\|f\\(inally\\|or\\)\\|"
-	       "i\\(f\\|nterface\\)\\|return\\|s\\(uper\\|witch\\)\\|"
-	       "t\\(h\\(is\\|row\\)\\|ry\\)\\|while"
-	       "\\)\\>"))
-      ;;
-      ;; These are immediately followed by an object name.
-      (java-minor-types
-       (mapconcat 'identity
-	'("boolean" "char" "byte" "short" "int" "long" "float" "double" "void")
-	"\\|"))
-      ;;
-      ;; These are eventually followed by an object name.
-      (java-major-types
-;       (make-regexp
+		"catch\\|do\\|else\\|f\\(inally\\|or\\)\\|"
+		"i\\(f\\|nterface\\)\\|return\\|s\\(uper\\|witch\\)\\|"
+		"t\\(h\\(is\\|row\\)\\|ry\\)\\|while"
+		"\\)\\>"))
+       ;;
+       ;; These are immediately followed by an object name.
+       (java-minor-types
+	(mapconcat 'identity
+	 '("boolean" "char" "byte" "short" "int" "long"
+	   "float" "double" "void")
+	 "\\|"))
+       ;;
+       ;; These are eventually followed by an object name.
+       (java-major-types
 ;	'("abstract" "const" "final" "synchronized" "transient" "static"
 ;;	  ;; Anders Lindgren <andersl@csd.uu.se> says this has gone.
 ;;	  "threadsafe"
 ;	  "volatile" "public" "private" "protected" "native")
-       (concat "abstract\\|const\\|final\\|native\\|"
-	       "p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|"
-	       "s\\(tatic\\|ynchronized\\)\\|transient\\|volatile"))
-      ;;
-      ;; Random types immediately followed by an object name.
-      (java-other-types
-       '(mapconcat 'identity (cons "\\sw+\\.\\sw+" java-font-lock-extra-types)
-		   "\\|"))
+	(concat "abstract\\|const\\|final\\|native\\|"
+		"p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|"
+		"s\\(tatic\\|ynchronized\\)\\|transient\\|volatile"))
+       ;;
+       ;; Random types immediately followed by an object name.
+       (java-other-types
+	'(mapconcat 'identity (cons "\\sw+\\.\\sw+" java-font-lock-extra-types)
+		    "\\|"))
+       (java-other-depth `(font-lock-keyword-depth (,@ java-other-types)))
       )
  (setq java-font-lock-keywords-1
   (list
@@ -2539,13 +2593,16 @@ See also `java-font-lock-extra-types'.")
 		    "\\([ \t]*\\[[ \t]*\\]\\)*"
 		    "\\([ \t]*\\sw\\)")
 	    ;; Fontify each declaration item.
-	    '(font-lock-match-c-style-declaration-item-and-skip-to-next
-	      ;; Start and finish with point after the type specifier.
-	      (goto-char (match-beginning 3)) (goto-char (match-beginning 3))
-	      ;; Fontify as a variable or function name.
-	      (1 (if (match-beginning 2)
-		     font-lock-function-name-face
-		   font-lock-variable-name-face)))))
+	    (list 'font-lock-match-c-style-declaration-item-and-skip-to-next
+		  ;; Start and finish with point after the type specifier.
+		  (list 'goto-char (list 'match-beginning
+					 (+ (,@ java-other-depth) 3)))
+		  (list 'goto-char (list 'match-beginning
+					 (+ (,@ java-other-depth) 3)))
+		  ;; Fontify as a variable or function name.
+		  '(1 (if (match-beginning 2)
+			  font-lock-function-name-face
+			font-lock-variable-name-face)))))
     ;;
     ;; Fontify those that are immediately followed by an item or items.
     (list (concat "\\<\\(" java-minor-types "\\)\\>"
@@ -2567,7 +2624,7 @@ See also `java-font-lock-extra-types'.")
 	  ;; Fontify each declaration item.
 	  '(font-lock-match-c-style-declaration-item-and-skip-to-next
 	    ;; Start with point after all type specifiers.
-	    (goto-char (or (match-beginning 2) (match-end 1)))
+	    (goto-char (or (match-beginning 5) (match-end 1)))
 	    ;; Finish with point after first type specifier.
 	    (goto-char (match-end 1))
 	    ;; Fontify as a variable or function name.