X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/b5e2c7a755cb352e9ac47095073e2c9eaa63c02b..231a33160ed418f73dea4f0972e469c8cdd64c13:/lisp/font-lock.el

diff --git a/lisp/font-lock.el b/lisp/font-lock.el
index 424db62a06..8f7d57c716 100644
--- a/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@ -1,6 +1,6 @@
 ;;; font-lock.el --- Electric font lock mode
 
-;; Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999, 2000, 2001
+;; Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999, 2000, 2001, 2002
 ;;  Free Software Foundation, Inc.
 
 ;; Author: jwz, then rms, then sm
@@ -152,9 +152,9 @@
 ;;    "Default expressions to highlight in Foo mode.")
 ;;
 ;;  (add-hook 'foo-mode-hook
-;;   (function (lambda ()
-;;               (make-local-variable 'font-lock-defaults)
-;;               (setq font-lock-defaults '(foo-font-lock-keywords t)))))
+;;   (lambda ()
+;;     (make-local-variable 'font-lock-defaults)
+;;     (setq font-lock-defaults '(foo-font-lock-keywords t))))
 
 ;;; Adding Font Lock support for modes:
 
@@ -207,6 +207,8 @@
 
 ;;; Code:
 
+(require 'syntax)
+
 ;; Define core `font-lock' group.
 (defgroup font-lock nil
   "Font Lock mode text highlighting package."
@@ -444,106 +446,6 @@ 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
-  "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 that for syntactic keyword fontification,
-`font-lock-syntactic-keywords'
-and 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-inhibit-thing-lock' and `font-lock-maximum-size'.")
-;;;###autoload
-(make-variable-buffer-local 'font-lock-defaults)
-
-;; This variable is used where font-lock.el itself supplies the keywords.
-(defvar font-lock-defaults-alist
-  (let (;; We use `beginning-of-defun', rather than nil, for SYNTAX-BEGIN.
-	;; Thus the calculation of the cache is usually faster but not
-	;; infallible, so we risk mis-fontification.  sm.
-	(c-mode-defaults
-	 '((c-font-lock-keywords c-font-lock-keywords-1
-	    c-font-lock-keywords-2 c-font-lock-keywords-3)
-	   nil nil ((?_ . "w")) beginning-of-defun
-	   (font-lock-mark-block-function . mark-defun)))
-	(c++-mode-defaults
-	 '((c++-font-lock-keywords c++-font-lock-keywords-1
-	    c++-font-lock-keywords-2 c++-font-lock-keywords-3)
-	   nil nil ((?_ . "w")) beginning-of-defun
-	   (font-lock-mark-block-function . mark-defun)))
-	(objc-mode-defaults
-	 '((objc-font-lock-keywords objc-font-lock-keywords-1
-	    objc-font-lock-keywords-2 objc-font-lock-keywords-3)
-	   nil nil ((?_ . "w") (?$ . "w")) nil
-	   (font-lock-mark-block-function . mark-defun)))
-	(java-mode-defaults
-	 '((java-font-lock-keywords java-font-lock-keywords-1
-	    java-font-lock-keywords-2 java-font-lock-keywords-3)
-	   nil nil ((?_ . "w") (?$ . "w")) nil
-	   (font-lock-mark-block-function . mark-defun)))
-	(lisp-mode-defaults
-	 '((lisp-font-lock-keywords
-	    lisp-font-lock-keywords-1 lisp-font-lock-keywords-2)
-	   nil nil (("+-*/.<>=!?$%_&~^:" . "w")) beginning-of-defun
-	   (font-lock-mark-block-function . mark-defun))))
-    (list
-     (cons 'c-mode			c-mode-defaults)
-     (cons 'c++-mode			c++-mode-defaults)
-     (cons 'objc-mode			objc-mode-defaults)
-     (cons 'java-mode			java-mode-defaults)
-     (cons 'emacs-lisp-mode		lisp-mode-defaults)
-     (cons 'lisp-mode			lisp-mode-defaults)
-     (cons 'lisp-interaction-mode	lisp-mode-defaults)))
-  "Alist of fall-back Font Lock defaults for major modes.
-
-This variable should not be used any more.
-Set the buffer-local `font-lock-keywords' in the major mode instead.
-
-Each item should be a list of the form:
-
- (MAJOR-MODE . FONT-LOCK-DEFAULTS)
-
-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.")
-(make-obsolete-variable 'font-lock-defaults-alist 'font-lock-defaults)
-
 (defvar font-lock-keywords-alist nil
   "*Alist of `font-lock-keywords' local to a `major-mode'.
 This is normally set via `font-lock-add-keywords' and
@@ -616,14 +518,18 @@ This is normally set via `font-lock-defaults'.")
 If this is nil, the major mode's syntax table is used.
 This is normally set via `font-lock-defaults'.")
 
-;; If this is nil, we only use the beginning of the buffer if we can't use
-;; `font-lock-cache-position' and `font-lock-cache-state'.
 (defvar font-lock-beginning-of-syntax-function nil
-  "*Non-nil means use this function to move back outside of a syntactic block.
-When called with no args it should leave point at the beginning of any
-enclosing syntactic block.
-If this is nil, the beginning of the buffer is used (in the worst case).
-This is normally set via `font-lock-defaults'.")
+  "*Non-nil means use this function to move back outside all constructs.
+When called with no args it should move point backward to a place which
+is not in a string or comment and not within any bracket-pairs (or else,
+a place such that any bracket-pairs outside it can be ignored for Emacs
+syntax analysis and fontification).
+
+If this is nil, the beginning of the buffer is used, which is
+always correct but tends to be slow.
+This is normally set via `font-lock-defaults'.
+This variable is semi-obsolete; we recommend setting
+`syntax-begin-function' instead.")
 
 (defvar font-lock-mark-block-function nil
   "*Non-nil means use this function to mark a block of text.
@@ -656,14 +562,6 @@ This is normally set via `font-lock-defaults'.")
 Currently, valid mode names are `fast-lock-mode', `jit-lock-mode' and
 `lazy-lock-mode'.  This is normally set via `font-lock-defaults'.")
 
-(defvar font-lock-multiline nil
-  "Whether font-lock should cater to multiline keywords.
-If nil, don't try to handle multiline patterns.
-If t, always handle multiline patterns.
-If `undecided', don't try to handle multiline patterns until you see one.
-Major/minor modes can set this variable if they know which option applies.")
-
-(defvar font-lock-fontified nil)	; Whether we have fontified the buffer.
 
 ;; Font Lock mode.
 
@@ -676,109 +574,26 @@ Major/minor modes can set this variable if they know which option applies.")
   ;; We use this to preserve or protect things when modifying text properties.
   (defmacro save-buffer-state (varlist &rest body)
     "Bind variables according to VARLIST and eval BODY restoring buffer state."
-    `(let* ,(append varlist
-		    '((modified (buffer-modified-p)) (buffer-undo-list t)
-		      (inhibit-read-only t) (inhibit-point-motion-hooks t)
-		      (inhibit-modification-hooks t)
-		      deactivate-mark buffer-file-name buffer-file-truename))
-       ,@body
-       (when (and (not modified) (buffer-modified-p))
-	 (set-buffer-modified-p nil))))
+    (let ((modified (make-symbol "modified")))
+      `(let* ,(append varlist
+		      `((,modified (buffer-modified-p))
+			(buffer-undo-list t)
+			(inhibit-read-only t)
+			(inhibit-point-motion-hooks t)
+			(inhibit-modification-hooks t)
+			deactivate-mark
+			buffer-file-name
+			buffer-file-truename))
+	 (progn
+	   ,@body)
+	 (unless ,modified
+	   (restore-buffer-modified-p nil)))))
   (put 'save-buffer-state 'lisp-indent-function 1)
   (def-edebug-spec save-buffer-state let)
   ;;
   ;; Shut up the byte compiler.
   (defvar font-lock-face-attributes))	; Obsolete but respected if set.
 
-;;;###autoload
-(define-minor-mode font-lock-mode
-  "Toggle Font Lock mode.
-With arg, turn Font Lock mode off if and only if arg is a non-positive
-number; if arg is nil, toggle Font Lock mode; anything else turns Font
-Lock on.
-\(Font Lock is also known as \"syntax highlighting\".)
-
-When Font Lock mode is enabled, text is fontified as you type it:
-
- - Comments are displayed in `font-lock-comment-face';
- - Strings are displayed in `font-lock-string-face';
- - Certain other expressions are displayed in other faces according to the
-   value of the variable `font-lock-keywords'.
-
-To customize the faces (colors, fonts, etc.) used by Font Lock for
-fontifying different parts of buffer text, use \\[customize-face].
-
-You can enable Font Lock mode in any major mode automatically by turning on in
-the major mode's hook.  For example, put in your ~/.emacs:
-
- (add-hook 'c-mode-hook 'turn-on-font-lock)
-
-Alternatively, you can use Global Font Lock mode to automagically turn on Font
-Lock mode in buffers whose major mode supports it and whose major mode is one
-of `font-lock-global-modes'.  For example, put in your ~/.emacs:
-
- (global-font-lock-mode t)
-
-There are a number of support modes that may be used to speed up Font Lock mode
-in various ways, specified via the variable `font-lock-support-mode'.  Where
-major modes support different levels of fontification, you can use the variable
-`font-lock-maximum-decoration' to specify which level you generally prefer.
-When you turn Font Lock mode on/off the buffer is fontified/defontified, though
-fontification occurs only if the buffer is less than `font-lock-maximum-size'.
-
-For example, to specify that Font Lock mode use use Lazy Lock mode as a support
-mode and use maximum levels of fontification, put in your ~/.emacs:
-
- (setq font-lock-support-mode 'lazy-lock-mode)
- (setq font-lock-maximum-decoration t)
-
-To add your own highlighting for some major mode, and modify the highlighting
-selected automatically via the variable `font-lock-maximum-decoration', you can
-use `font-lock-add-keywords'.
-
-To fontify a buffer, without turning on Font Lock mode and regardless of buffer
-size, you can use \\[font-lock-fontify-buffer].
-
-To fontify a block (the function or paragraph containing point, or a number of
-lines around point), perhaps because modification on the current line caused
-syntactic change on other lines, you can use \\[font-lock-fontify-block].
-
-See the variable `font-lock-defaults-alist' for the Font Lock mode default
-settings.  You can set your own default settings for some mode, by setting a
-buffer local value for `font-lock-defaults', via its mode hook."
-  nil nil nil
-  ;; Don't turn on Font Lock mode if we don't have a display (we're running a
-  ;; batch job) or if the buffer is invisible (the name starts with a space).
-  (when (or noninteractive (eq (aref (buffer-name) 0) ?\ ))
-    (setq font-lock-mode nil))
-
-  ;; Turn on Font Lock mode.
-  (when font-lock-mode
-    (add-hook 'after-change-functions 'font-lock-after-change-function nil t)
-    (font-lock-set-defaults)
-    (font-lock-turn-on-thing-lock)
-    ;; Fontify the buffer if we have to.
-    (let ((max-size (font-lock-value-in-major-mode font-lock-maximum-size)))
-      (cond (font-lock-fontified
-	     nil)
-	    ((or (null max-size) (> max-size (buffer-size)))
-	     (font-lock-fontify-buffer))
-	    (font-lock-verbose
-	     (message "Fontifying %s...buffer size greater than font-lock-maximum-size"
-		      (buffer-name))))))
-  ;; Turn off Font Lock mode.
-  (unless font-lock-mode
-    (remove-hook 'after-change-functions 'font-lock-after-change-function t)
-    (font-lock-unfontify-buffer)
-    (font-lock-turn-off-thing-lock)
-    (font-lock-unset-defaults)))
-
-;;;###autoload
-(defun turn-on-font-lock ()
-  "Turn on Font Lock mode (only if the terminal can display it)."
-  (unless font-lock-mode
-    (font-lock-mode)))
-
 ;;;###autoload
 (defun font-lock-add-keywords (mode keywords &optional append)
   "Add highlighting KEYWORDS for MODE.
@@ -803,7 +618,7 @@ When used from an elisp package (such as a minor mode), it is recommended
 to use nil for MODE (and place the call in a loop or on a hook) to avoid
 subtle problems due to details of the implementation.
 
-Note that some modes have specialised support for additional patterns, e.g.,
+Note that some modes have specialized 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 (mode
@@ -931,94 +746,6 @@ subtle problems due to details of the implementation."
 			 (delete (font-lock-compile-keyword keyword)
 				 font-lock-keywords)))))))
 
-;;; 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
-;; balked at that way, as I see it as just re-moulding the same problem in
-;; another form.  That is; some person would still have to keep track of which
-;; modes (which may not even be distributed with Emacs) support Font Lock mode.
-;; The list would always be out of date.  And that person might have to be me.
-
-;; Implementation.
-;;
-;; In a previous discussion the following hack came to mind.  It is a gross
-;; hack, but it generally works.  We use the convention that major modes start
-;; by calling the function `kill-all-local-variables', which in turn runs
-;; functions on the hook variable `change-major-mode-hook'.  We attach our
-;; function `font-lock-change-major-mode' to that hook.  Of course, when this
-;; hook is run, the major mode is in the process of being changed and we do not
-;; know what the final major mode will be.  So, `font-lock-change-major-mode'
-;; only (a) notes the name of the current buffer, and (b) adds our function
-;; `turn-on-font-lock-if-enabled' to the hook variables `find-file-hooks' and
-;; `post-command-hook' (for buffers that are not visiting files).  By the time
-;; the functions on the first of these hooks to be run are run, the new major
-;; mode is assumed to be in place.  This way we get a Font Lock function run
-;; when a major mode is turned on, without knowing major modes or their hooks.
-;;
-;; Naturally this requires that (a) major modes run `kill-all-local-variables',
-;; as they are supposed to do, and (b) the major mode is in place after the
-;; file is visited or the command that ran `kill-all-local-variables' has
-;; finished, whichever the sooner.  Arguably, any major mode that does not
-;; follow the convension (a) is broken, and I can't think of any reason why (b)
-;; would not be met (except `gnudoit' on non-files).  However, it is not clean.
-;;
-;; Probably the cleanest solution is to have each major mode function run some
-;; hook, e.g., `major-mode-hook', but maybe implementing that change is
-;; impractical.  I am personally against making `setq' a macro or be advised,
-;; or have a special function such as `set-major-mode', but maybe someone can
-;; come up with another solution?
-
-;; User interface.
-;;
-;; Although Global Font Lock mode is a pseudo-mode, I think that the user
-;; interface should conform to the usual Emacs convention for modes, i.e., a
-;; command to toggle the feature (`global-font-lock-mode') with a variable for
-;; finer control of the mode's behaviour (`font-lock-global-modes').
-;;
-;; The feature should not be enabled by loading font-lock.el, since other
-;; mechanisms for turning on Font Lock mode, such as M-x font-lock-mode RET or
-;; (add-hook 'c-mode-hook 'turn-on-font-lock), would cause Font Lock mode to be
-;; turned on everywhere.  That would not be intuitive or informative because
-;; loading a file tells you nothing about the feature or how to control it.  It
-;; would also be contrary to the Principle of Least Surprise.  sm.
-
-(defcustom font-lock-global-modes t
-  "*Modes for which Font Lock mode is automagically turned on.
-Global Font Lock mode is controlled by the command `global-font-lock-mode'.
-If nil, means no modes have Font Lock mode automatically turned on.
-If t, all modes that support Font Lock mode have it automatically turned on.
-If a list, it should be a list of `major-mode' symbol names for which Font Lock
-mode should be automatically turned on.  The sense of the list is negated if it
-begins with `not'.  For example:
- (c-mode c++-mode)
-means that Font Lock mode is turned on for buffers in C and C++ modes only."
-  :type '(choice (const :tag "none" nil)
-		 (const :tag "all" t)
-		 (set :menu-tag "mode specific" :tag "modes"
-		      :value (not)
-		      (const :tag "Except" not)
-		      (repeat :inline t (symbol :tag "mode"))))
-  :group 'font-lock)
-
-(defun turn-on-font-lock-if-enabled ()
-  (when (and (or font-lock-defaults
-		 (assq major-mode font-lock-defaults-alist))
-	     (or (eq font-lock-global-modes t)
-		 (if (eq (car-safe font-lock-global-modes) 'not)
-		     (not (memq major-mode (cdr font-lock-global-modes)))
-		   (memq major-mode font-lock-global-modes))))
-    (let (inhibit-quit)
-      (turn-on-font-lock))))
-
-;;;###autoload
-(easy-mmode-define-global-mode
- global-font-lock-mode font-lock-mode turn-on-font-lock-if-enabled
- :extra-args (dummy))
-
-;;; End of Global Font Lock mode.
-
 ;;; Font Lock Support mode.
 
 ;; This is the code used to interface font-lock.el with any of its add-on
@@ -1061,9 +788,9 @@ The value of this variable is used when Font Lock mode is turned on."
   :version "21.1"
   :group 'font-lock)
 
-(defvar fast-lock-mode nil)
-(defvar lazy-lock-mode nil)
-(defvar jit-lock-mode nil)
+(defvar fast-lock-mode)
+(defvar lazy-lock-mode)
+(defvar jit-lock-mode)
 
 (defun font-lock-turn-on-thing-lock ()
   (let ((thing-mode (font-lock-value-in-major-mode font-lock-support-mode)))
@@ -1084,26 +811,26 @@ The value of this variable is used when Font Lock mode is turned on."
 			      (not font-lock-keywords-only))))))
 
 (defun font-lock-turn-off-thing-lock ()
-  (cond (fast-lock-mode
+  (cond ((and (boundp 'fast-lock-mode) fast-lock-mode)
 	 (fast-lock-mode -1))
-	(jit-lock-mode
+	((and (boundp 'jit-lock-mode) jit-lock-mode)
 	 (jit-lock-unregister 'font-lock-fontify-region)
 	 ;; Reset local vars to the non-jit-lock case.
 	 (kill-local-variable 'font-lock-fontify-buffer-function))
-	(lazy-lock-mode
+	((and (boundp 'lazy-lock-mode) lazy-lock-mode)
 	 (lazy-lock-mode -1))))
 
 (defun font-lock-after-fontify-buffer ()
-  (cond (fast-lock-mode
+  (cond ((and (boundp 'fast-lock-mode) fast-lock-mode)
 	 (fast-lock-after-fontify-buffer))
 	;; Useless now that jit-lock intercepts font-lock-fontify-buffer.  -sm
 	;; (jit-lock-mode
 	;;  (jit-lock-after-fontify-buffer))
-	(lazy-lock-mode
+	((and (boundp 'lazy-lock-mode) lazy-lock-mode)
 	 (lazy-lock-after-fontify-buffer))))
 
 (defun font-lock-after-unfontify-buffer ()
-  (cond (fast-lock-mode
+  (cond ((and (boundp 'fast-lock-mode) fast-lock-mode)
 	 (fast-lock-after-unfontify-buffer))
 	;; Useless as well.  It's only called when:
 	;; - turning off font-lock: it does not matter if we leave spurious
@@ -1113,7 +840,7 @@ The value of this variable is used when Font Lock mode is turned on."
 	;;
 	;; (jit-lock-mode
 	;;  (jit-lock-after-unfontify-buffer))
-	(lazy-lock-mode
+	((and (boundp 'lazy-lock-mode) lazy-lock-mode)
 	 (lazy-lock-after-unfontify-buffer))))
 
 ;;; End of Font Lock Support mode.
@@ -1195,10 +922,7 @@ The value of this variable is used when Font Lock mode is turned on."
 		(font-lock-after-fontify-buffer)
 		(setq font-lock-fontified t)))
 	  ;; We don't restore the old fontification, so it's best to unfontify.
-	  (quit (font-lock-unfontify-buffer))))
-      ;; Make sure we undo `font-lock-keywords' etc.
-      (unless font-lock-mode
-	(font-lock-unset-defaults)))))
+	  (quit (font-lock-unfontify-buffer)))))))
 
 (defun font-lock-default-unfontify-buffer ()
   ;; Make sure we unfontify etc. in the whole buffer.
@@ -1208,13 +932,18 @@ The value of this variable is used when Font Lock mode is turned on."
     (font-lock-after-unfontify-buffer)
     (setq font-lock-fontified nil)))
 
+(defvar font-lock-dont-widen nil
+  "If non-nil, font-lock will work on the non-widened buffer.
+Useful for things like RMAIL and Info where the whole buffer is not
+a very meaningful entity to highlight.")
+
 (defun font-lock-default-fontify-region (beg end loudly)
   (save-buffer-state
       ((parse-sexp-lookup-properties font-lock-syntactic-keywords)
        (old-syntax-table (syntax-table)))
     (unwind-protect
 	(save-restriction
-	  (widen)
+	  (unless font-lock-dont-widen (widen))
 	  ;; Use the fontification syntax table, if any.
 	  (when font-lock-syntax-table
 	    (set-syntax-table font-lock-syntax-table))
@@ -1253,12 +982,19 @@ The value of this variable is used when Font Lock mode is turned on."
 ;		 (or (nth 4 state) (nth 7 state))))
 ;	  (font-lock-fontify-keywords-region beg end))
 
+(defvar font-lock-extra-managed-props nil
+  "Additional text properties managed by font-lock.
+This is used by `font-lock-default-unfontify-region' to decide
+what properties to clear before refontifying a region.")
+
 (defun font-lock-default-unfontify-region (beg end)
   (save-buffer-state nil
-    (remove-text-properties beg end
-			    (if font-lock-syntactic-keywords
-				'(face nil syntax-table nil font-lock-multiline nil)
-			      '(face nil font-lock-multiline nil)))))
+    (remove-list-of-text-properties
+     beg end (append
+	      font-lock-extra-managed-props
+	      (if font-lock-syntactic-keywords
+		  '(syntax-table face font-lock-multiline)
+		'(face font-lock-multiline))))))
 
 ;; Called when any modification is made to buffer text.
 (defun font-lock-after-change-function (beg end old-len)
@@ -1294,7 +1030,8 @@ delimit the region to fontify."
 	      (font-lock-fontify-region (point) (mark)))
 	  ((error quit) (message "Fontifying block...%s" error-data)))))))
 
-(define-key facemenu-keymap "\M-g" 'font-lock-fontify-block)
+(if (boundp 'facemenu-keymap)
+    (define-key facemenu-keymap "\M-g" 'font-lock-fontify-block))
 
 ;;; End of Fontification functions.
 
@@ -1397,23 +1134,28 @@ see `font-lock-syntactic-keywords'."
 	 (start (match-beginning match)) (end (match-end match))
 	 (value (nth 1 highlight))
 	 (override (nth 2 highlight)))
-    (when (and (consp value) (not (numberp (car value))))
-      (setq value (eval value)))
-    (when (stringp value) (setq value (string-to-syntax value)))
-    (cond ((not start)
-	   ;; No match but we might not signal an error.
-	   (or (nth 3 highlight)
-	       (error "No match %d in highlight %S" match highlight)))
-	  ((not override)
-	   ;; Cannot override existing fontification.
-	   (or (text-property-not-all start end 'syntax-table nil)
-	       (put-text-property start end 'syntax-table value)))
-	  ((eq override t)
-	   ;; Override existing fontification.
-	   (put-text-property start end 'syntax-table value))
-	  ((eq override 'keep)
-	   ;; Keep existing fontification.
-	   (font-lock-fillin-text-property start end 'syntax-table value)))))
+    (if (not start)
+	;; No match but we might not signal an error.
+	(or (nth 3 highlight)
+	    (error "No match %d in highlight %S" match highlight))
+      (when (and (consp value) (not (numberp (car value))))
+	(setq value (eval value)))
+      (when (stringp value) (setq value (string-to-syntax value)))
+      ;; Flush the syntax-cache.  I believe this is not necessary for
+      ;; font-lock's use of syntax-ppss, but I'm not 100% sure and it can
+      ;; still be necessary for other users of syntax-ppss anyway.
+      (syntax-ppss-after-change-function start)
+      (cond
+       ((not override)
+	;; Cannot override existing fontification.
+	(or (text-property-not-all start end 'syntax-table nil)
+	    (put-text-property start end 'syntax-table value)))
+       ((eq override t)
+	;; Override existing fontification.
+	(put-text-property start end 'syntax-table value))
+       ((eq override 'keep)
+	;; Keep existing fontification.
+	(font-lock-fillin-text-property start end 'syntax-table value))))))
 
 (defun font-lock-fontify-syntactic-anchored-keywords (keywords limit)
   "Fontify according to KEYWORDS until LIMIT.
@@ -1481,57 +1223,28 @@ START should be at the beginning of a line."
 
 ;;; 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.
-;; Previously, `font-lock-cache-position' was just a buffer position.  However,
-;; under certain situations, this occasionally resulted in mis-fontification.
-;; I think the "situations" were deletion with Lazy Lock mode's deferral.  sm.
-(defvar font-lock-cache-state nil)
-(defvar font-lock-cache-position nil)
-
-(defun font-lock-fontify-syntactically-region (start end &optional loudly)
+(defun font-lock-fontify-syntactically-region (start end &optional loudly ppss)
   "Put proper face on each string and comment between START and END.
 START should be at the beginning of a line."
-  (let ((cache (marker-position font-lock-cache-position))
-	state face beg)
+  (let (state face beg)
     (if loudly (message "Fontifying %s... (syntactically...)" (buffer-name)))
     (goto-char start)
     ;;
     ;; Find the state at the `beginning-of-line' before `start'.
-    (if (eq start cache)
-	;; Use the cache for the state of `start'.
-	(setq state font-lock-cache-state)
-      ;; Find the state of `start'.
-      (if (null font-lock-beginning-of-syntax-function)
-	  ;; Use the state at the previous cache position, if any, or
-	  ;; otherwise calculate from `point-min'.
-	  (if (or (null cache) (< start cache))
-	      (setq state (parse-partial-sexp (point-min) start))
-	    (setq state (parse-partial-sexp cache start nil nil
-					    font-lock-cache-state)))
-	;; Call the function to move outside any syntactic block.
-	(funcall font-lock-beginning-of-syntax-function)
-	(setq state (parse-partial-sexp (point) start)))
-      ;; Cache the state and position of `start'.
-      (setq font-lock-cache-state state)
-      (set-marker font-lock-cache-position start))
-    ;;
-    ;; If the region starts inside a string or comment, show the extent of it.
-    (when (or (nth 3 state) (nth 4 state))
-      (setq face (funcall font-lock-syntactic-face-function state) beg (point))
-      (setq state (parse-partial-sexp (point) end nil nil state 'syntax-table))
-      (put-text-property beg (point) 'face face))
+    (setq state (or ppss (syntax-ppss start)))
     ;;
     ;; Find each interesting place between here and `end'.
-    (while (and (< (point) end)
-		(progn
-		  (setq state (parse-partial-sexp (point) end nil nil state
-						  'syntax-table))
-		  (or (nth 3 state) (nth 4 state))))
-      (setq face (funcall font-lock-syntactic-face-function state)
-	    beg (nth 8 state))
-      (setq state (parse-partial-sexp (point) end nil nil state 'syntax-table))
-      (put-text-property beg (point) 'face face))))
+    (while
+	(progn
+	  (when (or (nth 3 state) (nth 4 state))
+	    (setq face (funcall font-lock-syntactic-face-function state))
+	    (setq beg (max (nth 8 state) start))
+	    (setq state (parse-partial-sexp (point) end nil nil state
+					    'syntax-table))
+	    (when face (put-text-property beg (point) 'face face)))
+	  (setq state (parse-partial-sexp (point) end nil nil state
+					  'syntax-table))
+	  (< (point) end)))))
 
 ;;; End of Syntactic fontification functions.
 
@@ -1543,26 +1256,31 @@ HIGHLIGHT should be of the form MATCH-HIGHLIGHT, see `font-lock-keywords'."
   (let* ((match (nth 0 highlight))
 	 (start (match-beginning match)) (end (match-end match))
 	 (override (nth 2 highlight)))
-    (cond ((not start)
-	   ;; No match but we might not signal an error.
-	   (or (nth 3 highlight)
-	       (error "No match %d in highlight %S" match highlight)))
-	  ((not override)
-	   ;; Cannot override existing fontification.
-	   (or (text-property-not-all start end 'face nil)
-	       (put-text-property start end 'face (eval (nth 1 highlight)))))
-	  ((eq override t)
-	   ;; Override existing fontification.
-	   (put-text-property start end 'face (eval (nth 1 highlight))))
-	  ((eq override 'prepend)
-	   ;; Prepend to existing fontification.
-	   (font-lock-prepend-text-property start end 'face (eval (nth 1 highlight))))
-	  ((eq override 'append)
-	   ;; Append to existing fontification.
-	   (font-lock-append-text-property start end 'face (eval (nth 1 highlight))))
-	  ((eq override 'keep)
-	   ;; Keep existing fontification.
-	   (font-lock-fillin-text-property start end 'face (eval (nth 1 highlight)))))))
+    (if (not start)
+	;; No match but we might not signal an error.
+	(or (nth 3 highlight)
+	    (error "No match %d in highlight %S" match highlight))
+      (let ((val (eval (nth 1 highlight))))
+	(when (eq (car-safe val) 'face)
+	  (add-text-properties start end (cddr val))
+	  (setq val (cadr val)))
+	(cond
+	 ((not override)
+	  ;; Cannot override existing fontification.
+	  (or (text-property-not-all start end 'face nil)
+	      (put-text-property start end 'face val)))
+	 ((eq override t)
+	  ;; Override existing fontification.
+	  (put-text-property start end 'face val))
+	 ((eq override 'prepend)
+	  ;; Prepend to existing fontification.
+	  (font-lock-prepend-text-property start end 'face val))
+	 ((eq override 'append)
+	  ;; Append to existing fontification.
+	  (font-lock-append-text-property start end 'face val))
+	 ((eq override 'keep)
+	  ;; Keep existing fontification.
+	  (font-lock-fillin-text-property start end 'face val)))))))
 
 (defsubst font-lock-fontify-anchored-keywords (keywords limit)
   "Fontify according to KEYWORDS until LIMIT.
@@ -1600,9 +1318,11 @@ LIMIT can be modified by the value of its PRE-MATCH-FORM."
 
 (defun font-lock-fontify-keywords-region (start end &optional loudly)
   "Fontify according to `font-lock-keywords' between START and END.
-START should be at the beginning of a line."
+START should be at the beginning of a line.
+LOUDLY, if non-nil, allows progress-meter bar."
   (unless (eq (car font-lock-keywords) t)
-    (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords)))
+    (setq font-lock-keywords
+	  (font-lock-compile-keywords font-lock-keywords t)))
   (let ((case-fold-search font-lock-keywords-case-fold-search)
 	(keywords (cdr font-lock-keywords))
 	(bufname (buffer-name)) (count 0)
@@ -1648,13 +1368,33 @@ START should be at the beginning of a line."
 
 ;; Various functions.
 
-(defun font-lock-compile-keywords (keywords)
+(defun font-lock-compile-keywords (keywords &optional regexp)
   "Compile KEYWORDS into the form (t KEYWORD ...).
 Here KEYWORD is of the form (MATCHER HIGHLIGHT ...) as shown in the
-`font-lock-keywords' doc string."
+`font-lock-keywords' doc string.
+If REGEXP is non-nil, it means these keywords are used for
+`font-lock-keywords' rather than for `font-lock-syntactic-keywords'."
   (if (eq (car-safe keywords) t)
       keywords
-    (cons t (mapcar 'font-lock-compile-keyword keywords))))
+    (setq keywords (cons t (mapcar 'font-lock-compile-keyword keywords)))
+    (if (and regexp
+	     (eq (or syntax-begin-function
+		     font-lock-beginning-of-syntax-function)
+		 'beginning-of-defun)
+	     (not beginning-of-defun-function))
+	;; Try to detect when a string or comment contains something that
+	;; looks like a defun and would thus confuse font-lock.
+	(nconc keywords
+	       `((,(if defun-prompt-regexp
+		       (concat "^\\(?:" defun-prompt-regexp "\\)?\\s(")
+		     "^\\s(")
+		  (0
+		   (if (memq (get-text-property (1- (point)) 'face)
+			     '(font-lock-string-face font-lock-doc-face
+			       font-lock-comment-face))
+		       font-lock-warning-face)
+		   prepend)))))
+    keywords))
 
 (defun font-lock-compile-keyword (keyword)
   (cond ((nlistp keyword)			; MATCHER
@@ -1703,82 +1443,51 @@ A LEVEL of nil is equal to a LEVEL of 0, a LEVEL of t is equal to
 	(t
 	 (car keywords))))
 
-(defvar font-lock-set-defaults nil)	; Whether we have set up defaults.
-
-(defun font-lock-set-defaults ()
-  "Set fontification defaults appropriately for this mode.
-Sets various variables using `font-lock-defaults' (or, if nil, using
-`font-lock-defaults-alist') and `font-lock-maximum-decoration'."
-  ;; Set fontification defaults iff not previously set.
-  (unless font-lock-set-defaults
-    (set (make-local-variable 'font-lock-set-defaults)		t)
-    (set (make-local-variable 'font-lock-cache-state)		nil)
-    (set (make-local-variable 'font-lock-cache-position)	(make-marker))
-    (make-local-variable 'font-lock-fontified)
-    (make-local-variable 'font-lock-multiline)
-    (let* ((defaults (or font-lock-defaults
-			 (cdr (assq major-mode font-lock-defaults-alist))))
-	   (keywords
-	    (font-lock-choose-keywords (nth 0 defaults)
-	     (font-lock-value-in-major-mode font-lock-maximum-decoration)))
-	   (local (cdr (assq major-mode font-lock-keywords-alist)))
-	   (removed-keywords
-	    (cdr-safe (assq major-mode font-lock-removed-keywords-alist))))
-      ;; Regexp fontification?
-      (set (make-local-variable 'font-lock-keywords)
-	   (font-lock-compile-keywords (font-lock-eval-keywords keywords)))
-      ;; Local fontification?
-      (while local
-	(font-lock-add-keywords nil (car (car local)) (cdr (car local)))
-	(setq local (cdr local)))
-      (when removed-keywords
-	(font-lock-remove-keywords nil removed-keywords))
-      ;; Syntactic fontification?
-      (when (nth 1 defaults)
-	(set (make-local-variable 'font-lock-keywords-only) t))
-      ;; Case fold during regexp fontification?
-      (when (nth 2 defaults)
-	(set (make-local-variable 'font-lock-keywords-case-fold-search) t))
-      ;; Syntax table for regexp and syntactic fontification?
-      (when (nth 3 defaults)
-	(let ((slist (nth 3 defaults)))
-	  (set (make-local-variable 'font-lock-syntax-table)
-	       (copy-syntax-table (syntax-table)))
-	  (while slist
-	    ;; The character to modify may be a single CHAR or a STRING.
-	    (let ((chars (if (numberp (car (car slist)))
-			     (list (car (car slist)))
-			   (mapcar 'identity (car (car slist)))))
-		  (syntax (cdr (car slist))))
-	      (while chars
-		(modify-syntax-entry (car chars) syntax font-lock-syntax-table)
-		(setq chars (cdr chars)))
-	      (setq slist (cdr slist))))))
-      ;; Syntax function for syntactic fontification?
-      (when (nth 4 defaults)
-	(set (make-local-variable 'font-lock-beginning-of-syntax-function)
-	     (nth 4 defaults)))
-      ;; Variable alist?
-      (dolist (x (nthcdr 5 defaults))
-	(let ((variable (car x)) (value (cdr x)))
-	  (unless (boundp variable)
-	    (set variable nil))		;why ?
-	  (set (make-local-variable variable) value))))))
-
-(defun font-lock-unset-defaults ()
-  "Unset fontification defaults.  See function `font-lock-set-defaults'."
-  (setq font-lock-set-defaults			nil
-	font-lock-keywords			nil
-	font-lock-keywords-only			nil
-	font-lock-keywords-case-fold-search	nil
-	font-lock-syntax-table			nil
-	font-lock-beginning-of-syntax-function	nil)
+(defun font-lock-set-defaults-1 ()
   (let* ((defaults (or font-lock-defaults
 		       (cdr (assq major-mode font-lock-defaults-alist))))
-	 (alist (nthcdr 5 defaults)))
-    (while alist
-      (set (car (car alist)) (default-value (car (car alist))))
-      (setq alist (cdr alist)))))
+	 (keywords
+	  (font-lock-choose-keywords (nth 0 defaults)
+				     (font-lock-value-in-major-mode font-lock-maximum-decoration)))
+	 (local (cdr (assq major-mode font-lock-keywords-alist)))
+	 (removed-keywords
+	  (cdr-safe (assq major-mode font-lock-removed-keywords-alist))))
+    (set (make-local-variable 'font-lock-defaults) defaults)
+    ;; Syntactic fontification?
+    (when (nth 1 defaults)
+      (set (make-local-variable 'font-lock-keywords-only) t))
+    ;; Case fold during regexp fontification?
+    (when (nth 2 defaults)
+      (set (make-local-variable 'font-lock-keywords-case-fold-search) t))
+    ;; Syntax table for regexp and syntactic fontification?
+    (when (nth 3 defaults)
+      (set (make-local-variable 'font-lock-syntax-table)
+	   (copy-syntax-table (syntax-table)))
+      (dolist (selem (nth 3 defaults))
+	;; The character to modify may be a single CHAR or a STRING.
+	(let ((syntax (cdr selem)))
+	  (dolist (char (if (numberp (car selem))
+			    (list (car selem))
+			  (mapcar 'identity (car selem))))
+	    (modify-syntax-entry char syntax font-lock-syntax-table)))))
+    ;; Syntax function for syntactic fontification?
+    (when (nth 4 defaults)
+      (set (make-local-variable 'font-lock-beginning-of-syntax-function)
+	   (nth 4 defaults)))
+    ;; Variable alist?
+    (dolist (x (nthcdr 5 defaults))
+      (set (make-local-variable (car x)) (cdr x)))
+    ;; Setup `font-lock-keywords' last because its value might depend
+    ;; on other settings (e.g. font-lock-compile-keywords uses
+    ;; font-lock-beginning-of-syntax-function).
+    (set (make-local-variable 'font-lock-keywords)
+	 (font-lock-compile-keywords (font-lock-eval-keywords keywords) t))
+    ;; Local fontification?
+    (while local
+      (font-lock-add-keywords nil (car (car local)) (cdr (car local)))
+      (setq local (cdr local)))
+    (when removed-keywords
+      (font-lock-remove-keywords nil removed-keywords))))
 
 ;;; Colour etc. support.
 
@@ -1804,9 +1513,9 @@ Sets various variables using `font-lock-defaults' (or, if nil, using
 	    (when background
 	      (setq face-spec (cons ':background (cons background face-spec))))
 	    (when bold-p
-	      (setq face-spec (append '(:bold t) face-spec)))
+	      (setq face-spec (append '(:weight bold) face-spec)))
 	    (when italic-p
-	      (setq face-spec (append '(:italic t) face-spec)))
+	      (setq face-spec (append '(:slant italic) face-spec)))
 	    (when underline-p
 	      (setq face-spec (append '(:underline t) face-spec)))
 	    (custom-declare-face face (list (list t face-spec)) nil)))))))
@@ -1817,22 +1526,22 @@ Sets various variables using `font-lock-defaults' (or, if nil, using
   '((((type tty pc) (class color) (background light)) (:foreground "red"))
     (((type tty pc) (class color) (background dark)) (:foreground "red1"))
     (((class grayscale) (background light))
-     (:foreground "DimGray" :bold t :italic t))
+     (:foreground "DimGray" :weight bold :slant italic))
     (((class grayscale) (background dark))
-     (:foreground "LightGray" :bold t :italic t))
+     (:foreground "LightGray" :weight bold :slant italic))
     (((class color) (background light)) (:foreground "Firebrick"))
     (((class color) (background dark)) (:foreground "chocolate1"))
-    (t (:bold t :italic t)))
+    (t (:weight bold :slant italic)))
   "Font Lock mode face used to highlight comments."
   :group 'font-lock-highlighting-faces)
 
 (defface font-lock-string-face
   '((((type tty) (class color)) (:foreground "green"))
-    (((class grayscale) (background light)) (:foreground "DimGray" :italic t))
-    (((class grayscale) (background dark)) (:foreground "LightGray" :italic t))
+    (((class grayscale) (background light)) (:foreground "DimGray" :slant italic))
+    (((class grayscale) (background dark)) (:foreground "LightGray" :slant italic))
     (((class color) (background light)) (:foreground "RosyBrown"))
     (((class color) (background dark)) (:foreground "LightSalmon"))
-    (t (:italic t)))
+    (t (:slant italic)))
   "Font Lock mode face used to highlight strings."
   :group 'font-lock-highlighting-faces)
 
@@ -1843,21 +1552,21 @@ Sets various variables using `font-lock-defaults' (or, if nil, using
 
 (defface font-lock-keyword-face
   '((((type tty) (class color)) (:foreground "cyan" :weight bold))
-    (((class grayscale) (background light)) (:foreground "LightGray" :bold t))
-    (((class grayscale) (background dark)) (:foreground "DimGray" :bold t))
+    (((class grayscale) (background light)) (:foreground "LightGray" :weight bold))
+    (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold))
     (((class color) (background light)) (:foreground "Purple"))
     (((class color) (background dark)) (:foreground "Cyan"))
-    (t (:bold t)))
+    (t (:weight bold)))
   "Font Lock mode face used to highlight keywords."
   :group 'font-lock-highlighting-faces)
 
 (defface font-lock-builtin-face
   '((((type tty) (class color)) (:foreground "blue" :weight light))
-    (((class grayscale) (background light)) (:foreground "LightGray" :bold t))
-    (((class grayscale) (background dark)) (:foreground "DimGray" :bold t))
+    (((class grayscale) (background light)) (:foreground "LightGray" :weight bold))
+    (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold))
     (((class color) (background light)) (:foreground "Orchid"))
     (((class color) (background dark)) (:foreground "LightSteelBlue"))
-    (t (:bold t)))
+    (t (:weight bold)))
   "Font Lock mode face used to highlight builtins."
   :group 'font-lock-highlighting-faces)
 
@@ -1865,49 +1574,49 @@ Sets various variables using `font-lock-defaults' (or, if nil, using
   '((((type tty) (class color)) (:foreground "blue" :weight bold))
     (((class color) (background light)) (:foreground "Blue"))
     (((class color) (background dark)) (:foreground "LightSkyBlue"))
-    (t (:inverse-video t :bold t)))
+    (t (:inverse-video t :weight bold)))
   "Font Lock mode face used to highlight function names."
   :group 'font-lock-highlighting-faces)
 
 (defface font-lock-variable-name-face
   '((((type tty) (class color)) (:foreground "yellow" :weight light))
     (((class grayscale) (background light))
-     (:foreground "Gray90" :bold t :italic t))
+     (:foreground "Gray90" :weight bold :slant italic))
     (((class grayscale) (background dark))
-     (:foreground "DimGray" :bold t :italic t))
+     (:foreground "DimGray" :weight bold :slant italic))
     (((class color) (background light)) (:foreground "DarkGoldenrod"))
     (((class color) (background dark)) (:foreground "LightGoldenrod"))
-    (t (:bold t :italic t)))
+    (t (:weight bold :slant italic)))
   "Font Lock mode face used to highlight variable names."
   :group 'font-lock-highlighting-faces)
 
 (defface font-lock-type-face
   '((((type tty) (class color)) (:foreground "green"))
-    (((class grayscale) (background light)) (:foreground "Gray90" :bold t))
-    (((class grayscale) (background dark)) (:foreground "DimGray" :bold t))
+    (((class grayscale) (background light)) (:foreground "Gray90" :weight bold))
+    (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold))
     (((class color) (background light)) (:foreground "ForestGreen"))
     (((class color) (background dark)) (:foreground "PaleGreen"))
-    (t (:bold t :underline t)))
+    (t (:weight bold :underline t)))
   "Font Lock mode face used to highlight type and classes."
   :group 'font-lock-highlighting-faces)
 
 (defface font-lock-constant-face
   '((((type tty) (class color)) (:foreground "magenta"))
     (((class grayscale) (background light))
-     (:foreground "LightGray" :bold t :underline t))
+     (:foreground "LightGray" :weight bold :underline t))
     (((class grayscale) (background dark))
-     (:foreground "Gray50" :bold t :underline t))
+     (:foreground "Gray50" :weight bold :underline t))
     (((class color) (background light)) (:foreground "CadetBlue"))
     (((class color) (background dark)) (:foreground "Aquamarine"))
-    (t (:bold t :underline t)))
+    (t (:weight bold :underline t)))
   "Font Lock mode face used to highlight constants and labels."
   :group 'font-lock-highlighting-faces)
 
 (defface font-lock-warning-face
   '((((type tty) (class color)) (:foreground "red"))
-    (((class color) (background light)) (:foreground "Red" :bold t))
-    (((class color) (background dark)) (:foreground "Pink" :bold t))
-    (t (:inverse-video t :bold t)))
+    (((class color) (background light)) (:foreground "Red" :weight bold))
+    (((class color) (background dark)) (:foreground "Pink" :weight bold))
+    (t (:inverse-video t :weight bold)))
   "Font Lock mode face used to highlight warnings."
   :group 'font-lock-highlighting-faces)
 
@@ -2042,15 +1751,27 @@ The item is delimited by (match-beginning 1) and (match-end 1).
 If (match-beginning 2) is non-nil, the item is followed by a `('.
 
 This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
-  (when (looking-at "[ \t*]*\\(\\sw+\\)[ \t]*\\((\\)?")
+  (when (looking-at "[ \n\t*]*\\(\\sw+\\)[ \t\n]*\\(((?\\)?")
+    (when (and (match-end 2) (> (- (match-end 2) (match-beginning 2)) 1))
+      ;; If `word' is followed by a double open-paren, it's probably
+      ;; a macro used for "int myfun P_ ((int arg1))".  Let's go back one
+      ;; word to try and match `myfun' rather than `P_'.
+      (let ((pos (point)))
+	(skip-chars-backward " \t\n")
+	(skip-syntax-backward "w")
+	(unless (looking-at "\\(\\sw+\\)[ \t\n]*\\sw*_\\sw*[ \t\n]*\\((\\)?")
+	  ;; Looks like it was something else, so go back to where we
+	  ;; were and reset the match data by rematching.
+	  (goto-char pos)
+	  (looking-at "[ \n\t*]*\\(\\sw+\\)[ \t\n]*\\(((?\\)?"))))
     (save-match-data
       (condition-case nil
 	  (save-restriction
-	    ;; Restrict to the end of line, currently guaranteed to be LIMIT.
+	    ;; Restrict to the LIMIT.
 	    (narrow-to-region (point-min) limit)
 	    (goto-char (match-end 1))
 	    ;; Move over any item value, etc., to the next item.
-	    (while (not (looking-at "[ \t]*\\(\\(,\\)\\|;\\|$\\)"))
+	    (while (not (looking-at "[ \t\n]*\\(\\(,\\)\\|;\\|\\'\\)"))
 	      (goto-char (or (scan-sexps (point) 1) (point-max))))
 	    (goto-char (match-end 2)))
 	(error t)))))
@@ -2142,7 +1863,7 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
       '("`\\(\\sw\\sw+\\)'" 1 font-lock-constant-face prepend)
       ;;
       ;; Constant values.
-      '("\\<:\\sw\\sw+\\>" 0 font-lock-builtin-face)
+      '("\\<:\\sw+\\>" 0 font-lock-builtin-face)
       ;;
       ;; ELisp and CLisp `&' keywords as types.
       '("\\&\\sw+\\>" . font-lock-type-face)
@@ -2179,17 +1900,26 @@ The value of this variable is used when Font Lock mode is turned on."
 
 (defcustom c++-font-lock-extra-types
   '("\\sw+_t"
-    "\\([iof]\\|str\\)+stream\\(buf\\)?" "ios"
+
     "string" "rope"
+
     "list" "slist"
     "deque" "vector" "bit_vector"
+
     "set" "multiset"
     "map" "multimap"
-    "hash\\(_\\(m\\(ap\\|ulti\\(map\\|set\\)\\)\\|set\\)\\)?"
     "stack" "queue" "priority_queue"
     "type_info"
-    "iterator" "const_iterator" "reverse_iterator" "const_reverse_iterator"
-    "reference" "const_reference")
+
+    ;; (regexp-opt '("ios_base" "ios" "istream" "ostream" "istringstream" "ifstream" "iostream" "ofstream" "ostringstream" "fstream" "stringstream"))
+    "fstream\\|i\\(?:fstream\\|os\\(?:_base\\|tream\\)?\\|str\\(?:\\(?:ingstr\\)?eam\\)\\)\\|\\(?:o\\(?:f\\|string\\)?\\|string\\)stream"
+
+    ;; (regexp-opt '("hash" "hash_set" "hash_map" "hash_multiset" "hash_multimap"))
+    "hash\\(?:_\\(?:m\\(?:ap\\|ulti\\(?:map\\|set\\)\\)\\|set\\)\\)?"
+
+    ;; (regexp-opt '("pointer" "const_pointer" "reference" "const_reference" "iterator" "const_iterator" "reverse_iterator" "const_reverse_iterator" "size_type" "difference_type" "allocator_type"))
+    "allocator_type\\|const_\\(?:iterator\\|pointer\\|re\\(?:ference\\|verse_iterator\\)\\)\\|difference_type\\|iterator\\|pointer\\|re\\(?:ference\\|verse_iterator\\)\\|size_type"
+    )
   "*List of extra types to fontify in C++ mode.
 Each list item should be a regexp not containing word-delimiters.
 For example, a value of (\"string\") means the word string is treated as a type
@@ -2210,11 +1940,12 @@ The value of this variable is used when Font Lock mode is turned on."
   :group 'font-lock-extra-types)
 
 (defcustom java-font-lock-extra-types
-  '("[A-Z\300-\326\330-\337]\\sw*[a-z]\\sw*")
+  '("[A-Z\300-\326\330-\337]\\sw*[a-z]\\sw*" "URL")
   "*List of extra types to fontify in Java mode.
 Each list item should be a regexp not containing word-delimiters.
-For example, a value of (\"[A-Z\300-\326\330-\337]\\\\sw*[a-z]\\\\sw*\") means capitalised
-words (and words conforming to the Java id spec) are treated as type names.
+For example, a value of (\"[A-Z\300-\326\330-\337]\\\\sw*[a-z]\\\\sw*\" \"URL\") means
+capitalised words (that conform to the Java id spec) and URL are treated as
+type names.
 
 The value of this variable is used when Font Lock mode is turned on."
   :type 'font-lock-extra-types-widget
@@ -2236,17 +1967,6 @@ The value of this variable is used when Font Lock mode is turned on."
 ;; more is a plus!  [Ha ha ha.]  And more means plus!  [Ho ho ho.]  The future
 ;; is C++!  [Ohhh!]  The Third Millennium Award...  Will be ours!  [Roar.]
 
-(defconst c-font-lock-keywords-1 nil
-  "Subdued level highlighting for C mode.")
-
-(defconst c-font-lock-keywords-2 nil
-  "Medium level highlighting for C mode.
-See also `c-font-lock-extra-types'.")
-
-(defconst c-font-lock-keywords-3 nil
-  "Gaudy level highlighting for C mode.
-See also `c-font-lock-extra-types'.")
-
 (let* ((c-keywords
 	(eval-when-compile
 	  (regexp-opt '("break" "continue" "do" "else" "for" "if" "return"
@@ -2255,7 +1975,9 @@ See also `c-font-lock-extra-types'.")
 			"typedef" "extern" "auto" "register" "static"
 			"volatile" "const"
 			;; Dan Nicolaescu <done@gnu.org> says this is new.
-			"restrict"))))
+			"restrict"
+			;; Henrik Enberg <henrik@enberg.org> says this is new.
+			"inline"))))
        (c-type-specs
 	(eval-when-compile
 	  (regexp-opt '("enum" "struct" "union"))))
@@ -2267,7 +1989,9 @@ See also `c-font-lock-extra-types'.")
 	   ,(eval-when-compile
 	      (regexp-opt
 	       '("char" "short" "int" "long" "signed" "unsigned"
-		 "float" "double" "void" "complex")))
+		 "float" "double" "void" "complex"
+		 ;; Henrik Enberg <henrik@enberg.org> says these are new.
+		 "_Complex" "_Imaginary" "_Bool")))
 	   c-font-lock-extra-types)
 	  "\\|"))
        (c-type-names-depth
@@ -2279,7 +2003,7 @@ See also `c-font-lock-extra-types'.")
 	     "ifndef" "include" "line" "pragma" "undef"))))
        (c-preprocessor-directives-depth
 	(regexp-opt-depth c-preprocessor-directives)))
- (setq c-font-lock-keywords-1
+ (defconst c-font-lock-keywords-1
   (list
    ;;
    ;; These are all anchored at the beginning of line for speed.
@@ -2309,9 +2033,10 @@ See also `c-font-lock-extra-types'.")
 	    "\\)\\>[ \t!]*\\(\\sw+\\)?")
     '(1 font-lock-builtin-face)
     (list (+ 2 c-preprocessor-directives-depth)
-	  'font-lock-variable-name-face nil t))))
+	  'font-lock-variable-name-face nil t)))
+  "Subdued level highlighting for C mode.")
 
- (setq c-font-lock-keywords-2
+ (defconst c-font-lock-keywords-2
   (append c-font-lock-keywords-1
    (list
     ;;
@@ -2332,15 +2057,19 @@ See also `c-font-lock-extra-types'.")
        (save-excursion (skip-chars-forward "^:\n") (point))
        nil
        (1 font-lock-constant-face nil t)))
-    ;; Anders Lindgren <andersl@andersl.com> points out that it is quicker to
-    ;; use MATCH-ANCHORED to effectively anchor the regexp on the left.
+    ;; Anders Lindgren <andersl@andersl.com> points out that it is quicker
+    ;; to use MATCH-ANCHORED to effectively anchor the regexp on the left.
     ;; This must come after the one for keywords and targets.
-    '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$"
+    ;; Note: the lack of `:' in the first char-range prevents `bar' from being
+    ;; highlighted in "foo: bar:".  But adding `:' would break cases like
+    ;; "test1 ? test2 ? foo : bar : baz".
+    '(":" ("\\(?:^\\|[{};]\\)[ \t]*\\(\\sw+\\)[ \t]*:"
 	   (beginning-of-line) (end-of-line)
 	   (1 font-lock-constant-face)))
-    )))
+    ))
+  "Medium level highlighting for C mode.  See also `c-font-lock-extra-types'.")
 
- (setq c-font-lock-keywords-3
+ (defconst c-font-lock-keywords-3
   (append c-font-lock-keywords-2
    ;;
    ;; More complicated regexps for more complete highlighting for types.
@@ -2352,52 +2081,68 @@ See also `c-font-lock-extra-types'.")
       (list (concat "\\<\\(" ,c-type-names "\\)\\>"
 		    "\\([ \t*&]+\\sw+\\>\\)*")
 	    ;; Fontify each declaration item.
-	    (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-names-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)))))
+	    `(font-lock-match-c-style-declaration-item-and-skip-to-next
+	      ;; Start with point after all type specifiers.
+	      (prog1 (progn (skip-chars-forward "^;{}") (point))
+		(goto-char (or (match-beginning
+				,(+ ,c-type-names-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 all storage specs and types, plus their items.
-    `(eval .
-      (list (concat "\\<\\(" ,c-type-specs "\\)\\>"
-		    "[ \t]*\\(\\sw+\\)?")
-	  (list 1 'font-lock-keyword-face)
-	  (list ,(+ c-type-specs-depth 2) 'font-lock-type-face nil t)
-	  (list 'font-lock-match-c-style-declaration-item-and-skip-to-next
-		  nil 
-		  ;; Finish with point after the variable name if
-		  ;; there is one.
-		  `(if (match-end 2) 
-		       (goto-char (match-end 2)))
-		  ;; Fontify as a variable or function name.
-		  '(1 (if (match-beginning 2)
-			  font-lock-function-name-face
-			font-lock-variable-name-face) nil t))))
+    `(,(concat "\\<\\(" c-type-specs "\\)\\>" "[ \t]*\\(\\sw+\\)?")
+      (1 font-lock-keyword-face)
+      (,(+ c-type-specs-depth 2) font-lock-type-face nil t)
+      (font-lock-match-c-style-declaration-item-and-skip-to-next
+       (save-excursion (skip-chars-forward "^;{}") (point))
+       ;; Finish with point after the variable name if
+       ;; there is one.
+       (if (match-end 2)
+	   (goto-char (match-end 2)))
+       ;; Fontify as a variable or function name.
+       (1 (if (match-beginning 2)
+	      font-lock-function-name-face
+	    font-lock-variable-name-face) nil t)))
     ;;
     ;; Fontify structures, or typedef names, plus their items.
     '("\\(}\\)[ \t*]*\\sw"
       (font-lock-match-c-style-declaration-item-and-skip-to-next
-       (goto-char (match-end 1)) nil
+       (prog1 (progn (skip-chars-forward "^;{}") (point))
+	 (goto-char (match-end 1))) nil
        (1 font-lock-type-face)))
     ;;
     ;; Fontify anything at beginning of line as a declaration or definition.
     '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*"
       (1 font-lock-type-face)
       (font-lock-match-c-style-declaration-item-and-skip-to-next
-       (goto-char (or (match-beginning 2) (match-end 1))) nil
+       (prog1 (progn (skip-chars-forward "^;{}") (point))
+	 (goto-char (or (match-beginning 2) (match-end 1)))) nil
        (1 (if (match-beginning 2)
 	      font-lock-function-name-face
 	    font-lock-variable-name-face))))
-    )))
- )
+    ))
+  "Gaudy level highlighting for C mode.
+See also `c-font-lock-extra-types'."))
+
+(defun c-font-lock-syntactic-face-function (state)
+  (save-excursion
+    (if (nth 3 state)
+	;; Check whether the string is properly terminated.
+	(let ((nstate (parse-partial-sexp (point) (line-end-position)
+					  nil nil state 'syntax-table)))
+	  (if (and (eolp) (not (nth 5 nstate)) (nth 3 nstate))
+	      ;; We're inside a string, at EOL and there was no \.
+	      font-lock-warning-face
+	    font-lock-string-face))
+      (goto-char (nth 8 state))
+      ;; `doxygen' uses /*! while others use /**.
+      (if (looking-at "/\\*[*!]\n")
+	  font-lock-doc-face font-lock-comment-face))))
 
 (defvar c-font-lock-keywords c-font-lock-keywords-1
   "Default expressions to highlight in C mode.
@@ -2405,17 +2150,6 @@ See also `c-font-lock-extra-types'.")
 
 ;;; C++.
 
-(defconst c++-font-lock-keywords-1 nil
-  "Subdued level highlighting for C++ mode.")
-
-(defconst c++-font-lock-keywords-2 nil
-  "Medium level highlighting for C++ mode.
-See also `c++-font-lock-extra-types'.")
-
-(defconst c++-font-lock-keywords-3 nil
-  "Gaudy level highlighting for C++ mode.
-See also `c++-font-lock-extra-types'.")
-
 (defun font-lock-match-c++-style-declaration-item-and-skip-to-next (limit)
   ;; Regexp matches after point:		word<word>::word (
   ;;						^^^^ ^^^^   ^^^^ ^
@@ -2428,13 +2162,13 @@ See also `c++-font-lock-extra-types'.")
   (when (looking-at (eval-when-compile
 		      (concat
 		       ;; Skip any leading whitespace.
-		       "[ \t*&]*"
+		       "[ \t\n*&]*"
 		       ;; This is `c++-type-spec' from below.  (Hint hint!)
 		       "\\(\\sw+\\)"				; The instance?
-		       "\\([ \t]*<\\([^>\n]+\\)[ \t*&]*>\\)?"	; Or template?
-		       "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)*"	; Or member?
+		       "\\([ \t\n]*<\\(\\(?:[^<>]\\|<[^>]+>\\)+\\)[ \t\n*&]*>\\)?"	; Or template?
+		       "\\([ \t\n]*::[ \t\n*~]*\\(\\sw+\\)\\)*"	; Or member?
 		       ;; Match any trailing parenthesis.
-		       "[ \t]*\\((\\)?")))
+		       "[ \t\n]*\\((\\)?")))
     (save-match-data
       (condition-case nil
 	  (save-restriction
@@ -2442,7 +2176,7 @@ See also `c++-font-lock-extra-types'.")
 	    (narrow-to-region (point-min) limit)
 	    (goto-char (match-end 1))
 	    ;; Move over any item value, etc., to the next item.
-	    (while (not (looking-at "[ \t]*\\(\\(,\\)\\|;\\|$\\)"))
+	    (while (not (looking-at "[ \t\n]*\\(\\(,\\)\\|;\\|\\'\\)"))
 	      (goto-char (or (scan-sexps (point) 1) (point-max))))
 	    (goto-char (match-end 2)))
 	(error t)))))
@@ -2473,13 +2207,18 @@ See also `c++-font-lock-extra-types'.")
 	     "typeid"
 	     ;; Branko Cibej <branko.cibej@hermes.si> says this is new.
 	     "export"
+	     ;; Copied from C.  wsnyder@wsnyder.org says C++ needs it too.
+	     "restrict"
 	     ;; Mark Mitchell <mmitchell@usa.net> says these are new.
 	     "mutable" "explicit"
 	     ;; Alain Picard <ap@abelard.apana.org.au> suggests treating these
 	     ;; as keywords not types.
 	     "typedef" "template"
 	     "extern" "auto" "register" "const" "volatile" "static"
-	     "inline" "friend" "virtual"))))
+	     "inline" "friend" "virtual"
+	     ;; Standard C++ operator names.
+	     "and" "and_eq" "bitand" "bitor" "compl" "not" "not_eq"
+	     "or" "or_eq" "xor" "xor_eq"))))
        (c++-operators
 	(eval-when-compile
 	  (regexp-opt
@@ -2511,7 +2250,7 @@ See also `c++-font-lock-extra-types'.")
        ;; A brave attempt to match templates following a type and/or match
        ;; class membership.  See and sync the above function
        ;; `font-lock-match-c++-style-declaration-item-and-skip-to-next'.
-       (c++-type-suffix (concat "\\([ \t]*<\\([^>\n]+\\)[ \t*&]*>\\)?"
+       (c++-type-suffix (concat "\\([ \t]*<\\(\\(?:[^<>\n]\\|<[^>\n]+>\\)+\\)[ \t*&]*>\\)?"
 				"\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)*"))
        (c++-type-suffix-depth (regexp-opt-depth c++-type-suffix))
        ;; If the string is a type, it may be followed by the cruft above.
@@ -2522,7 +2261,7 @@ See also `c++-font-lock-extra-types'.")
        (c++-type-depth `(regexp-opt-depth
 			 (concat ,c++-type-names ,c++-type-suffix)))
        )
- (setq c++-font-lock-keywords-1
+ (defconst c++-font-lock-keywords-1
   (append
    ;;
    ;; The list `c-font-lock-keywords-1' less that for function names.
@@ -2536,9 +2275,10 @@ See also `c++-font-lock-extra-types'.")
 		font-lock-function-name-face))
 	  '(3 font-lock-type-face nil t)
 	  '(5 font-lock-function-name-face nil t))
-    )))
+    ))
+  "Subdued level highlighting for C++ mode.")
 
- (setq c++-font-lock-keywords-2
+ (defconst c++-font-lock-keywords-2
   (append c++-font-lock-keywords-1
    (list
     ;;
@@ -2577,9 +2317,11 @@ See also `c++-font-lock-extra-types'.")
     ;;
     ;; Eric Hopper <hopper@omnifarious.mn.org> says `true' and `false' are new.
     '("\\<\\(false\\|true\\)\\>" . font-lock-constant-face)
-    )))
+    ))
+  "Medium level highlighting for C++ mode.
+See also `c++-font-lock-extra-types'.")
 
- (setq c++-font-lock-keywords-3
+ (defconst c++-font-lock-keywords-3
   (append c++-font-lock-keywords-2
    ;;
    ;; More complicated regexps for more complete highlighting for types.
@@ -2590,79 +2332,82 @@ See also `c++-font-lock-extra-types'.")
       (list (concat "\\<\\(" ,c++-type-names "\\)\\>" ,c++-type-suffix
 		    "\\([ \t*&]+" ,c++-type-spec "\\)*")
 	    ;; The name of any template type.
-	    (list (+ ,c++-type-names-depth 3) 'font-lock-type-face nil t)
+	    `(,(+ ,c++-type-names-depth 3) font-lock-type-face nil t)
 	    ;; Fontify each declaration item.
-	    (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)
-			    ((and (match-beginning 6) (c-at-toplevel-p))
-			     font-lock-function-name-face)
-			    (t
-			     font-lock-variable-name-face)))
-		  '(3 font-lock-type-face nil t)
-		  '(5 (if (match-beginning 6)
-			  font-lock-function-name-face
-			font-lock-variable-name-face) nil t))))
+	    `(font-lock-match-c++-style-declaration-item-and-skip-to-next
+	      ;; Start with point after all type specifiers.
+	      (prog1 (progn (skip-chars-forward "^;{}") (point))
+		(goto-char (or (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)
+		       ((and (match-beginning 6) (c-at-toplevel-p))
+			font-lock-function-name-face)
+		       (t
+			font-lock-variable-name-face)))
+	      (3 font-lock-type-face nil t)
+	      (5 (if (match-beginning 6)
+		     font-lock-function-name-face
+		   font-lock-variable-name-face) nil t))))
     ;;
     ;; Fontify all storage specs and types, plus their items.
-    `(eval .
-      (list (concat "\\<" ,c++-type-specs "\\>" ,c++-type-suffix
-		    "[ \t]*\\(" ,c++-type-spec "\\)?")
-	    ;; The name of any template type.
-	    (list ,(+ c++-type-specs-depth 2) 'font-lock-type-face nil t)
-	    ;; The name of any type.
-	    (list (+ ,c++-type-specs-depth ,c++-type-suffix-depth 2)
-		  'font-lock-type-face nil t)
-	    ;; Fontify each declaration item.
-	    (list 'font-lock-match-c++-style-declaration-item-and-skip-to-next
-		  ;; Start with point after all type specifiers.
-		  nil
-		  ;; Finish with point after first type specifier.
-		  nil
-		  ;; Fontify as a variable or function name.
-		  '(1 (cond ((or (match-beginning 2) (match-beginning 4))
-			     font-lock-type-face)
-			    ((and (match-beginning 6) (c-at-toplevel-p))
-			     font-lock-function-name-face)
-			    (t
-			     font-lock-variable-name-face)))
-		  '(3 font-lock-type-face nil t)
-		  '(5 (if (match-beginning 6)
-			  font-lock-function-name-face
-			font-lock-variable-name-face) nil t))
-	    ))
+    `(,(concat "\\<" c++-type-specs "\\>" c++-type-suffix
+	       "[ \t]*\\(" c++-type-spec "\\)?")
+      ;; The name of any template type.
+      (,(+ c++-type-specs-depth 2) 'font-lock-type-face nil t)
+      ;; The name of any type.
+      (,(+ c++-type-specs-depth c++-type-suffix-depth 2)
+       font-lock-type-face nil t)
+      ;; Fontify each declaration item.
+      (font-lock-match-c++-style-declaration-item-and-skip-to-next
+       ;; Start with point after all type specifiers.
+       (save-excursion (skip-chars-forward "^;{}") (point))
+       ;; Finish with point after first type specifier.
+       nil
+       ;; Fontify as a variable or function name.
+       (1 (cond ((or (match-beginning 2) (match-beginning 4))
+		 font-lock-type-face)
+		((and (match-beginning 6) (c-at-toplevel-p))
+		 font-lock-function-name-face)
+		(t
+		 font-lock-variable-name-face)))
+       (3 font-lock-type-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"
       (font-lock-match-c++-style-declaration-item-and-skip-to-next
-       (goto-char (match-end 1)) nil
+       (prog1 (progn (skip-chars-forward "^;{}") (point))
+	 (goto-char (match-end 1))) nil
        (1 font-lock-type-face)))
     ;;
     ;; Fontify anything at beginning of line as a declaration or definition.
-    (list (concat "^\\(" c++-type-spec "[ \t*&]*\\)+")
-	  '(font-lock-match-c++-style-declaration-item-and-skip-to-next
-	    (goto-char (match-beginning 1))
-	    (goto-char (match-end 1))
-	    (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-type-face nil t)
-	    (5 (if (match-beginning 6)
-		   font-lock-function-name-face
-		 font-lock-variable-name-face) nil t)))
+    `(,(concat "^\\(" c++-type-spec "[ \t*&]*\\)+")
+      (font-lock-match-c++-style-declaration-item-and-skip-to-next
+       (prog1 (progn (skip-chars-forward "^;{}") (point))
+	 (goto-char (match-beginning 1)))
+       (goto-char (match-end 1))
+       (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-type-face nil t)
+       (5 (if (match-beginning 6)
+	      font-lock-function-name-face
+	    font-lock-variable-name-face) nil t)))
     ;;
     ;; Fontify constructors and destructors inside class declarations.
     '(font-lock-match-c++-structor-declaration
       (3 font-lock-function-name-face t))
-    )))
+    ))
+  "Gaudy level highlighting for C++ mode.
+See also `c++-font-lock-extra-types'.")
  )
 
 (defvar c++-font-lock-keywords c++-font-lock-keywords-1
@@ -2671,17 +2416,6 @@ See also `c++-font-lock-extra-types'.")
 
 ;;; Objective-C.
 
-(defconst objc-font-lock-keywords-1 nil
-  "Subdued level highlighting for Objective-C mode.")
-
-(defconst objc-font-lock-keywords-2 nil
-  "Medium level highlighting for Objective-C mode.
-See also `objc-font-lock-extra-types'.")
-
-(defconst objc-font-lock-keywords-3 nil
-  "Gaudy level highlighting for Objective-C mode.
-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
@@ -2710,7 +2444,7 @@ See also `objc-font-lock-extra-types'.")
        (objc-type-names-depth
 	`(regexp-opt-depth ,objc-type-names))
        )
- (setq objc-font-lock-keywords-1
+ (defconst objc-font-lock-keywords-1
   (append
    ;;
    ;; The list `c-font-lock-keywords-1' less that for function names.
@@ -2737,9 +2471,10 @@ See also `objc-font-lock-extra-types'.")
 	   (beginning-of-line) (end-of-line)
 	   (1 font-lock-function-name-face nil t)
 	   (3 font-lock-variable-name-face)))
-    )))
+    ))
+  "Subdued level highlighting for Objective-C mode.")
 
- (setq objc-font-lock-keywords-2
+ (defconst objc-font-lock-keywords-2
   (append objc-font-lock-keywords-1
    (list
     ;;
@@ -2764,9 +2499,11 @@ See also `objc-font-lock-extra-types'.")
     ;;
     ;; Fontify null object pointers.
     '("\\<[Nn]il\\>" . font-lock-constant-face)
-    )))
+    ))
+  "Medium level highlighting for Objective-C mode.
+See also `objc-font-lock-extra-types'.")
 
- (setq objc-font-lock-keywords-3
+ (defconst objc-font-lock-keywords-3
   (append objc-font-lock-keywords-2
    ;;
    ;; More complicated regexps for more complete highlighting for types.
@@ -2778,49 +2515,50 @@ See also `objc-font-lock-extra-types'.")
       (list (concat "\\<\\(" ,objc-type-names "\\)\\>"
 		    "\\([ \t*&]+\\sw+\\>\\)*")
 	    ;; Fontify each declaration item.
-	    (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-names-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)))))
+	    `(font-lock-match-c-style-declaration-item-and-skip-to-next
+	      ;; Start with point after all type specifiers.
+	      (prog1 (progn (skip-chars-forward "^;{}") (point))
+		(goto-char (or (match-beginning
+				,(+ ,objc-type-names-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 all storage specs and types, plus their items.
-    `(eval .
-      (list (concat "\\<\\(" ,objc-type-specs "[ \t]*\\)+\\>"
-		    "[ \t]*\\(\\sw+\\)?")
-	    ;; The name of any type.
-	    (list ,(+ objc-type-specs-depth 2) 'font-lock-type-face nil t)
-	    ;; Fontify each declaration item.
-	    (list 'font-lock-match-c++-style-declaration-item-and-skip-to-next
-		  nil nil
-		  ;; Fontify as a variable or function name.
-		  '(1 (if (match-beginning 2)
-			  font-lock-function-name-face
-			font-lock-variable-name-face)))
-	    ))
+    `(,(concat "\\<\\(" objc-type-specs "[ \t]*\\)+\\>" "[ \t]*\\(\\sw+\\)?")
+      ;; The name of any type.
+      (,(+ objc-type-specs-depth 2) font-lock-type-face nil t)
+      ;; Fontify each declaration item.
+      (font-lock-match-c++-style-declaration-item-and-skip-to-next
+       (save-excursion (skip-chars-forward "^;{}") (point)) nil
+       ;; 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"
       (font-lock-match-c-style-declaration-item-and-skip-to-next
-       (goto-char (match-end 1)) nil
+       (prog1 (progn (skip-chars-forward "^;{}") (point))
+	 (goto-char (match-end 1))) nil
        (1 font-lock-type-face)))
     ;;
     ;; Fontify anything at beginning of line as a declaration or definition.
     '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*"
       (1 font-lock-type-face)
       (font-lock-match-c-style-declaration-item-and-skip-to-next
-       (goto-char (or (match-beginning 2) (match-end 1))) nil
+       (prog1 (progn (skip-chars-forward "^;{}") (point))
+	 (goto-char (or (match-beginning 2) (match-end 1)))) nil
        (1 (if (match-beginning 2)
 	      font-lock-function-name-face
 	    font-lock-variable-name-face))))
-    )))
+    ))
+  "Gaudy level highlighting for Objective-C mode.
+See also `objc-font-lock-extra-types'.")
  )
 
 (defvar objc-font-lock-keywords objc-font-lock-keywords-1
@@ -2829,17 +2567,6 @@ See also `objc-font-lock-extra-types'.")
 
 ;;; Java.
 
-(defconst java-font-lock-keywords-1 nil
-  "Subdued level highlighting for Java mode.")
-
-(defconst java-font-lock-keywords-2 nil
-  "Medium level highlighting for Java mode.
-See also `java-font-lock-extra-types'.")
-
-(defconst java-font-lock-keywords-3 nil
-  "Gaudy level highlighting for Java mode.
-See also `java-font-lock-extra-types'.")
-
 ;; Regexps written with help from Fred White <fwhite@bbn.com>,
 ;; Anders Lindgren <andersl@andersl.com> and Carl Manning <caroma@ai.mit.edu>.
 (let* ((java-keywords
@@ -2855,7 +2582,7 @@ See also `java-font-lock-extra-types'.")
        ;; Classes immediately followed by an object name.
        (java-type-names
 	`(mapconcat 'identity
-	  (cons
+          (cons
 	   ,(eval-when-compile
 	      (regexp-opt '("boolean" "char" "byte" "short" "int" "long"
 			    "float" "double" "void")))
@@ -2874,7 +2601,7 @@ See also `java-font-lock-extra-types'.")
 	     ;; Carl Manning <caroma@ai.mit.edu> says this is new.
 	     "strictfp"))))
        )
- (setq java-font-lock-keywords-1
+ (defconst java-font-lock-keywords-1
   (list
    ;;
    ;; Fontify class names.
@@ -2887,9 +2614,10 @@ See also `java-font-lock-extra-types'.")
      (2 font-lock-constant-face nil t)
      ("\\=\\.\\(\\*\\|\\sw+\\)" nil nil
       (1 font-lock-constant-face nil t)))
-   ))
+   )
+  "Subdued level highlighting for Java mode.")
 
- (setq java-font-lock-keywords-2
+ (defconst java-font-lock-keywords-2
   (append java-font-lock-keywords-1
    (list
     ;;
@@ -2927,9 +2655,11 @@ See also `java-font-lock-extra-types'.")
     '("@\\(exception\\|throws\\)\\>[ \t]*\\(\\S-+\\)?"
       (1 font-lock-constant-face prepend)
       (2 font-lock-type-face prepend t))
-    )))
+    ))
+  "Medium level highlighting for Java mode.
+See also `java-font-lock-extra-types'.")
 
- (setq java-font-lock-keywords-3
+ (defconst java-font-lock-keywords-3
   (append java-font-lock-keywords-2
    ;;
    ;; More complicated regexps for more complete highlighting for types.
@@ -2942,34 +2672,36 @@ See also `java-font-lock-extra-types'.")
 		    "\\([ \t]*\\[[ \t]*\\]\\)*"
 		    "\\([ \t]*\\sw\\)")
 	    ;; Fontify each declaration item.
-	    (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-type-names-depth 3)))
-		  (list 'goto-char (list 'match-beginning
-					 (+ ,java-type-names-depth 3)))
-		  ;; Fontify as a variable or function name.
-		  '(1 (if (match-beginning 2)
-			  font-lock-function-name-face
-			font-lock-variable-name-face)))))
+	    `(font-lock-match-c-style-declaration-item-and-skip-to-next
+	      ;; Start and finish with point after the type specifier.
+	      (prog1 (progn (skip-chars-forward "^;{}") (point))
+		(goto-char (match-beginning ,(+ ,java-type-names-depth 3))))
+	      (goto-char (match-beginning ,(+ ,java-type-names-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 eventually followed by an item or items.
-    (list (concat "\\<\\(" java-type-specs "\\)\\>"
-		  "\\([ \t]+\\sw+\\>"
-		  "\\([ \t]*\\[[ \t]*\\]\\)*"
-		  "\\)*")
-	  ;; 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 5) (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))))
-    )))
- )
+    `(,(concat "\\<\\(" java-type-specs "\\)\\>"
+	       "\\([ \t]+\\sw+\\>"
+	       "\\([ \t]*\\[[ \t]*\\]\\)*"
+	       "\\)*")
+      ;; Fontify each declaration item.
+      (font-lock-match-c-style-declaration-item-and-skip-to-next
+       ;; Start with point after all type specifiers.
+       (prog1 (progn (skip-chars-forward "^;{}") (point))
+	 (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.
+       (1 (if (match-beginning 2)
+	      font-lock-function-name-face
+	    font-lock-variable-name-face))))
+    ))
+  "Gaudy level highlighting for Java mode.
+See also `java-font-lock-extra-types'.")
+  )
 
 (defvar java-font-lock-keywords java-font-lock-keywords-1
   "Default expressions to highlight in Java mode.
@@ -2977,7 +2709,27 @@ See also `java-font-lock-extra-types'.")
 
 ;; Provide ourselves:
 
+(defun java-font-lock-syntactic-face-function (state)
+  (save-excursion
+    (if (nth 3 state)
+	;; Check whether the string is properly terminated.
+	(let ((nstate (parse-partial-sexp (point) (line-end-position)
+					  nil nil state 'syntax-table)))
+	  (if (and (eolp) (nth 3 nstate))
+	      ;; We're inside a string, at EOL. The JLS says that:
+              ;; It is a compile-time error for a line terminator to
+              ;; appear after the opening " and before the closing
+              ;; matching ".
+	      font-lock-warning-face
+	    font-lock-string-face))
+      (goto-char (nth 8 state))
+      (if (looking-at "/\\*\\*")
+          font-lock-doc-face
+        font-lock-comment-face))))
+
 (provide 'font-lock)
-(require 'jit-lock)
+
+(when (eq font-lock-support-mode 'jit-lock-mode)
+  (require 'jit-lock))
 
 ;;; font-lock.el ends here