/[emacs]/emacs/lisp/font-lock.el
ViewVC logotype

Diff of /emacs/lisp/font-lock.el

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.197.2.1 by miles, Fri Apr 4 06:20:05 2003 UTC revision 1.197.2.2 by miles, Tue Oct 14 23:51:04 2003 UTC
# Line 1  Line 1 
1  ;;; font-lock.el --- Electric font lock mode  ;;; font-lock.el --- Electric font lock mode
2    
3  ;; Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999, 2000, 2001, 2002  ;; Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999, 2000, 2001, 02, 2003
4  ;;  Free Software Foundation, Inc.  ;;  Free Software Foundation, Inc.
5    
6  ;; Author: jwz, then rms, then sm  ;; Author: jwz, then rms, then sm
# Line 339  If a number, only buffers greater than t Line 339  If a number, only buffers greater than t
339  (defvar font-lock-warning-face          'font-lock-warning-face  (defvar font-lock-warning-face          'font-lock-warning-face
340    "Face name to use for things that should stand out.")    "Face name to use for things that should stand out.")
341    
342    (defvar font-lock-preprocessor-face     'font-lock-preprocessor-face
343      "Face name to use for preprocessor directives.")
344    
345  (defvar font-lock-reference-face        'font-lock-constant-face)  (defvar font-lock-reference-face        'font-lock-constant-face)
346  (make-obsolete-variable 'font-lock-reference-face 'font-lock-constant-face)  (make-obsolete-variable 'font-lock-reference-face 'font-lock-constant-face)
347    
# Line 562  This is normally set via `font-lock-defa Line 565  This is normally set via `font-lock-defa
565  Currently, valid mode names are `fast-lock-mode', `jit-lock-mode' and  Currently, valid mode names are `fast-lock-mode', `jit-lock-mode' and
566  `lazy-lock-mode'.  This is normally set via `font-lock-defaults'.")  `lazy-lock-mode'.  This is normally set via `font-lock-defaults'.")
567    
568    (defvar font-lock-multiline nil
569      "Whether font-lock should cater to multiline keywords.
570    If nil, don't try to handle multiline patterns.
571    If t, always handle multiline patterns.
572    If `undecided', don't try to handle multiline patterns until you see one.
573    Major/minor modes can set this variable if they know which option applies.")
574    
575    (defvar font-lock-fontified nil)        ; Whether we have fontified the buffer.
576    
577  ;; Font Lock mode.  ;; Font Lock mode.
578    
# Line 595  Currently, valid mode names are `fast-lo Line 606  Currently, valid mode names are `fast-lo
606    (defvar font-lock-face-attributes))   ; Obsolete but respected if set.    (defvar font-lock-face-attributes))   ; Obsolete but respected if set.
607    
608  ;;;###autoload  ;;;###autoload
609    (defun font-lock-mode-internal (arg)
610      ;; Turn on Font Lock mode.
611      (when arg
612        (add-hook 'after-change-functions 'font-lock-after-change-function t t)
613        (font-lock-set-defaults)
614        (font-lock-turn-on-thing-lock)
615        ;; Fontify the buffer if we have to.
616        (let ((max-size (font-lock-value-in-major-mode font-lock-maximum-size)))
617          (cond (font-lock-fontified
618                 nil)
619                ((or (null max-size) (> max-size (buffer-size)))
620                 (font-lock-fontify-buffer))
621                (font-lock-verbose
622                 (message "Fontifying %s...buffer size greater than font-lock-maximum-size"
623                          (buffer-name))))))
624      ;; Turn off Font Lock mode.
625      (unless font-lock-mode
626        (remove-hook 'after-change-functions 'font-lock-after-change-function t)
627        (font-lock-unfontify-buffer)
628        (font-lock-turn-off-thing-lock)))
629    
630    ;;;###autoload
631  (defun font-lock-add-keywords (mode keywords &optional append)  (defun font-lock-add-keywords (mode keywords &optional append)
632    "Add highlighting KEYWORDS for MODE.    "Add highlighting KEYWORDS for MODE.
633  MODE should be a symbol, the major mode command name, such as `c-mode'  MODE should be a symbol, the major mode command name, such as `c-mode'
# Line 1443  A LEVEL of nil is equal to a LEVEL of 0, Line 1476  A LEVEL of nil is equal to a LEVEL of 0,
1476          (t          (t
1477           (car keywords))))           (car keywords))))
1478    
1479  (defun font-lock-set-defaults-1 ()  (defvar font-lock-set-defaults nil)     ; Whether we have set up defaults.
1480    (let* ((defaults (or font-lock-defaults  
1481                         (cdr (assq major-mode font-lock-defaults-alist))))  (defun font-lock-set-defaults ()
1482           (keywords    "Set fontification defaults appropriately for this mode.
1483            (font-lock-choose-keywords (nth 0 defaults)  Sets various variables using `font-lock-defaults' (or, if nil, using
1484                                       (font-lock-value-in-major-mode font-lock-maximum-decoration)))  `font-lock-defaults-alist') and `font-lock-maximum-decoration'."
1485           (local (cdr (assq major-mode font-lock-keywords-alist)))    ;; Set fontification defaults iff not previously set.
1486           (removed-keywords    (unless font-lock-set-defaults
1487            (cdr-safe (assq major-mode font-lock-removed-keywords-alist))))      (set (make-local-variable 'font-lock-set-defaults) t)
1488      (set (make-local-variable 'font-lock-defaults) defaults)      (make-local-variable 'font-lock-fontified)
1489      ;; Syntactic fontification?      (make-local-variable 'font-lock-multiline)
1490      (when (nth 1 defaults)      (let* ((defaults (or font-lock-defaults
1491        (set (make-local-variable 'font-lock-keywords-only) t))                           (cdr (assq major-mode font-lock-defaults-alist))))
1492      ;; Case fold during regexp fontification?             (keywords
1493      (when (nth 2 defaults)              (font-lock-choose-keywords (nth 0 defaults)
1494        (set (make-local-variable 'font-lock-keywords-case-fold-search) t))                                         (font-lock-value-in-major-mode font-lock-maximum-decoration)))
1495      ;; Syntax table for regexp and syntactic fontification?             (local (cdr (assq major-mode font-lock-keywords-alist)))
1496      (when (nth 3 defaults)             (removed-keywords
1497        (set (make-local-variable 'font-lock-syntax-table)              (cdr-safe (assq major-mode font-lock-removed-keywords-alist))))
1498             (copy-syntax-table (syntax-table)))        (set (make-local-variable 'font-lock-defaults) defaults)
1499        (dolist (selem (nth 3 defaults))        ;; Syntactic fontification?
1500          ;; The character to modify may be a single CHAR or a STRING.        (when (nth 1 defaults)
1501          (let ((syntax (cdr selem)))          (set (make-local-variable 'font-lock-keywords-only) t))
1502            (dolist (char (if (numberp (car selem))        ;; Case fold during regexp fontification?
1503                              (list (car selem))        (when (nth 2 defaults)
1504                            (mapcar 'identity (car selem))))          (set (make-local-variable 'font-lock-keywords-case-fold-search) t))
1505              (modify-syntax-entry char syntax font-lock-syntax-table)))))        ;; Syntax table for regexp and syntactic fontification?
1506      ;; Syntax function for syntactic fontification?        (when (nth 3 defaults)
1507      (when (nth 4 defaults)          (set (make-local-variable 'font-lock-syntax-table)
1508        (set (make-local-variable 'font-lock-beginning-of-syntax-function)               (copy-syntax-table (syntax-table)))
1509             (nth 4 defaults)))          (dolist (selem (nth 3 defaults))
1510      ;; Variable alist?            ;; The character to modify may be a single CHAR or a STRING.
1511      (dolist (x (nthcdr 5 defaults))            (let ((syntax (cdr selem)))
1512        (set (make-local-variable (car x)) (cdr x)))              (dolist (char (if (numberp (car selem))
1513      ;; Setup `font-lock-keywords' last because its value might depend                                (list (car selem))
1514      ;; on other settings (e.g. font-lock-compile-keywords uses                              (mapcar 'identity (car selem))))
1515      ;; font-lock-beginning-of-syntax-function).                (modify-syntax-entry char syntax font-lock-syntax-table)))))
1516      (set (make-local-variable 'font-lock-keywords)        ;; Syntax function for syntactic fontification?
1517           (font-lock-compile-keywords (font-lock-eval-keywords keywords) t))        (when (nth 4 defaults)
1518      ;; Local fontification?          (set (make-local-variable 'font-lock-beginning-of-syntax-function)
1519      (while local               (nth 4 defaults)))
1520        (font-lock-add-keywords nil (car (car local)) (cdr (car local)))        ;; Variable alist?
1521        (setq local (cdr local)))        (dolist (x (nthcdr 5 defaults))
1522      (when removed-keywords          (set (make-local-variable (car x)) (cdr x)))
1523        (font-lock-remove-keywords nil removed-keywords))))        ;; Setup `font-lock-keywords' last because its value might depend
1524          ;; on other settings (e.g. font-lock-compile-keywords uses
1525          ;; font-lock-beginning-of-syntax-function).
1526          (set (make-local-variable 'font-lock-keywords)
1527               (font-lock-compile-keywords (font-lock-eval-keywords keywords) t))
1528          ;; Local fontification?
1529          (while local
1530            (font-lock-add-keywords nil (car (car local)) (cdr (car local)))
1531            (setq local (cdr local)))
1532          (when removed-keywords
1533            (font-lock-remove-keywords nil removed-keywords)))))
1534    
1535  ;;; Colour etc. support.  ;;; Colour etc. support.
1536    
# Line 1620  A LEVEL of nil is equal to a LEVEL of 0, Line 1663  A LEVEL of nil is equal to a LEVEL of 0,
1663    "Font Lock mode face used to highlight warnings."    "Font Lock mode face used to highlight warnings."
1664    :group 'font-lock-highlighting-faces)    :group 'font-lock-highlighting-faces)
1665    
1666    (defface font-lock-preprocessor-face
1667      '((t :inherit 'font-lock-builtin-face))
1668      "Font Lock mode face used to highlight preprocessor directives."
1669      :group 'font-lock-highlighting-faces)
1670    
1671  ;;; End of Colour etc. support.  ;;; End of Colour etc. support.
1672    
1673  ;;; Menu support.  ;;; Menu support.
# Line 1728  A LEVEL of nil is equal to a LEVEL of 0, Line 1776  A LEVEL of nil is equal to a LEVEL of 0,
1776  ;;; Various regexp information shared by several modes.  ;;; Various regexp information shared by several modes.
1777  ;;; Information specific to a single mode should go in its load library.  ;;; Information specific to a single mode should go in its load library.
1778    
1779  ;; Font Lock support for C, C++, Objective-C and Java modes will one day be in  ;; Font Lock support for C, C++, Objective-C and Java modes is now in
1780  ;; some cc-font.el (and required by cc-mode.el).  However, the below function  ;; cc-fonts.el (and required by cc-mode.el).  However, the below function
1781  ;; should stay in font-lock.el, since it is used by other libraries.  sm.  ;; should stay in font-lock.el, since it is used by other libraries.  sm.
1782    
1783  (defun font-lock-match-c-style-declaration-item-and-skip-to-next (limit)  (defun font-lock-match-c-style-declaration-item-and-skip-to-next (limit)
# Line 1876  This function could be MATCHER in a MATC Line 1924  This function could be MATCHER in a MATC
1924  (defvar lisp-font-lock-keywords lisp-font-lock-keywords-1  (defvar lisp-font-lock-keywords lisp-font-lock-keywords-1
1925    "Default expressions to highlight in Lisp modes.")    "Default expressions to highlight in Lisp modes.")
1926    
 ;;; User choices.  
   
 ;; These provide a means to fontify types not defined by the language.  Those  
 ;; types might be the user's own or they might be generally accepted and used.  
 ;; Generally accepted types are used to provide default variable values.  
   
 (define-widget 'font-lock-extra-types-widget 'radio  
   "Widget `:type' for members of the custom group `font-lock-extra-types'.  
 Members should `:load' the package `font-lock' to use this widget."  
   :args '((const :tag "none" nil)  
           (repeat :tag "types" regexp)))  
   
 (defcustom c-font-lock-extra-types '("FILE" "\\sw+_t" "Lisp_Object")  
   "*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 (\"FILE\" \"\\\\sw+_t\") means the word FILE and words  
 ending in _t 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  
   :group 'font-lock-extra-types)  
   
 (defcustom c++-font-lock-extra-types  
   '("\\sw+_t"  
   
     "string" "rope"  
   
     "list" "slist"  
     "deque" "vector" "bit_vector"  
   
     "set" "multiset"  
     "map" "multimap"  
     "stack" "queue" "priority_queue"  
     "type_info"  
   
     ;; (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  
 name.  
   
 The value of this variable is used when Font Lock mode is turned on."  
   :type 'font-lock-extra-types-widget  
   :group 'font-lock-extra-types)  
   
 (defcustom 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 not containing word-delimiters.  
 For example, a value of (\"Class\" \"BOOL\" \"IMP\" \"SEL\") means the words  
 Class, BOOL, IMP and SEL 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  
   :group 'font-lock-extra-types)  
   
 (defcustom java-font-lock-extra-types  
   '("[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*\" \"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  
   :group 'font-lock-extra-types)  
   
 ;;; C.  
   
 ;; [Murmur murmur murmur] Maestro, drum-roll please...  [Murmur murmur murmur.]  
 ;; Ahem.  [Murmur murmur murmur] Lay-dees an Gennel-men.  [Murmur murmur shhh!]  
 ;; I am most proud and humbly honoured today [murmur murmur cough] to present  
 ;; to you good people, the winner of the Second Millennium Award for The Most  
 ;; Hairy Language Syntax.  [Ahhh!]  All rise please.  [Shuffle shuffle  
 ;; shuffle.]  And a round of applause please.  For...  The C Language!  [Roar.]  
 ;;  
 ;; Thank you...  You are too kind...  It is with a feeling of great privilege  
 ;; and indeed emotion [sob] that I accept this award.  It has been a long hard  
 ;; road.  But we know our destiny.  And our future.  For we must not rest.  
 ;; There are more tokens to overload, more shoehorn, more methodologies.  But  
 ;; 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.]  
   
 (let* ((c-keywords  
         (eval-when-compile  
           (regexp-opt '("break" "continue" "do" "else" "for" "if" "return"  
                         "switch" "while" "sizeof"  
                         ;; Type related, but we don't do anything special.  
                         "typedef" "extern" "auto" "register" "static"  
                         "volatile" "const"  
                         ;; Dan Nicolaescu <done@gnu.org> says this is new.  
                         "restrict"  
                         ;; Henrik Enberg <henrik@enberg.org> says this is new.  
                         "inline"))))  
        (c-type-specs  
         (eval-when-compile  
           (regexp-opt '("enum" "struct" "union"))))  
        (c-type-specs-depth  
         (regexp-opt-depth c-type-specs))  
        (c-type-names  
         `(mapconcat 'identity  
           (cons  
            ,(eval-when-compile  
               (regexp-opt  
                '("char" "short" "int" "long" "signed" "unsigned"  
                  "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  
         `(regexp-opt-depth ,c-type-names))  
        (c-preprocessor-directives  
         (eval-when-compile  
           (regexp-opt  
            '("define"  "elif" "else" "endif" "error" "file" "if" "ifdef"  
              "ifndef" "include" "line" "pragma" "undef"))))  
        (c-preprocessor-directives-depth  
         (regexp-opt-depth c-preprocessor-directives)))  
   
  (defconst c-font-lock-keywords-1  
   (list  
    ;;  
    ;; These are all anchored at the beginning of line for speed.  
    ;; Note that `c++-font-lock-keywords-1' depends on `c-font-lock-keywords-1'.  
    ;;  
    ;; Fontify function name definitions (GNU style; without type on line).  
    '("^\\(\\sw+\\)[ \t]*(" 1 font-lock-function-name-face)  
    ;;  
    ;; Fontify error directives.  
    '("^#[ \t]*error[ \t]+\\(.+\\)" 1 font-lock-warning-face prepend)  
    ;;  
    ;; Fontify filenames in #include <...> preprocessor directives as strings.  
    '("^#[ \t]*\\(import\\|include\\)[ \t]*\\(<[^>\"\n]*>?\\)"  
      2 font-lock-string-face)  
    ;;  
    ;; Fontify function macro names.  
    '("^#[ \t]*define[ \t]+\\(\\sw+\\)(" 1 font-lock-function-name-face)  
    ;;  
    ;; Fontify symbol names in #elif or #if ... defined preprocessor directives.  
    '("^#[ \t]*\\(elif\\|if\\)\\>"  
      ("\\<\\(defined\\)\\>[ \t]*(?\\(\\sw+\\)?" nil nil  
       (1 font-lock-builtin-face) (2 font-lock-variable-name-face nil t)))  
    ;;  
    ;; Fontify otherwise as symbol names, and the preprocessor directive names.  
    (list  
     (concat "^#[ \t]*\\(" c-preprocessor-directives  
             "\\)\\>[ \t!]*\\(\\sw+\\)?")  
     '(1 font-lock-builtin-face)  
     (list (+ 2 c-preprocessor-directives-depth)  
           'font-lock-variable-name-face nil t)))  
   "Subdued level highlighting for C mode.")  
   
  (defconst c-font-lock-keywords-2  
   (append c-font-lock-keywords-1  
    (list  
     ;;  
     ;; Simple regexps for speed.  
     ;;  
     ;; Fontify all type names.  
     `(eval .  
       (cons (concat "\\<\\(" ,c-type-names "\\)\\>") 'font-lock-type-face))  
     ;;  
     ;; Fontify all builtin keywords (except case, default and goto; see below).  
     (concat "\\<\\(" c-keywords "\\|" c-type-specs "\\)\\>")  
     ;;  
     ;; Fontify case/goto keywords and targets, and case default/goto tags.  
     '("\\<\\(case\\|goto\\)\\>"  
       (1 font-lock-keyword-face)  
       ("\\(-[0-9]+\\|\\sw+\\)"  
        ;; Return limit of search.  
        (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.  
     ;; This must come after the one for keywords and targets.  
     ;; 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'.")  
   
  (defconst c-font-lock-keywords-3  
   (append c-font-lock-keywords-2  
    ;;  
    ;; More complicated regexps for more complete highlighting for types.  
    ;; We still have to fontify type specifiers individually, as C is so hairy.  
    (list  
     ;;  
     ;; Fontify all storage types, plus their items.  
     `(eval .  
       (list (concat "\\<\\(" ,c-type-names "\\)\\>"  
                     "\\([ \t*&]+\\sw+\\>\\)*")  
             ;; 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  
                                 ,(+ ,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.  
     `(,(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  
        (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  
        (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.  
 See also `c-font-lock-extra-types'.")  
   
 ;;; C++.  
   
 (defun font-lock-match-c++-style-declaration-item-and-skip-to-next (limit)  
   ;; Regexp matches after point:                word<word>::word (  
   ;;                                            ^^^^ ^^^^   ^^^^ ^  
   ;; Where the match subexpressions are:          1    3      5  6  
   ;;  
   ;; Item is delimited by (match-beginning 1) and (match-end 1).  
   ;; If (match-beginning 3) is non-nil, that part of the item incloses a `<>'.  
   ;; If (match-beginning 5) is non-nil, that part of the item follows a `::'.  
   ;; If (match-beginning 6) is non-nil, the item is followed by a `('.  
   (when (looking-at (eval-when-compile  
                       (concat  
                        ;; Skip any leading whitespace.  
                        "[ \t\n*&]*"  
                        ;; This is `c++-type-spec' from below.  (Hint hint!)  
                        "\\(\\sw+\\)"                            ; The instance?  
                        "\\([ \t\n]*<\\(\\(?:[^<>]\\|<[^>]+>\\)+\\)[ \t\n*&]*>\\)?"      ; Or template?  
                        "\\([ \t\n]*::[ \t\n*~]*\\(\\sw+\\)\\)*" ; Or member?  
                        ;; Match any trailing parenthesis.  
                        "[ \t\n]*\\((\\)?")))  
     (save-match-data  
       (condition-case nil  
           (save-restriction  
             ;; Restrict to the end of line, currently guaranteed to be 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\n]*\\(\\(,\\)\\|;\\|\\'\\)"))  
               (goto-char (or (scan-sexps (point) 1) (point-max))))  
             (goto-char (match-end 2)))  
         (error t)))))  
   
 (defun font-lock-match-c++-structor-declaration (limit)  
   ;; Match C++ constructors and destructors inside class declarations.  
   (let ((res nil)  
         (regexp (concat "^\\s-+\\(\\(virtual\\|explicit\\)\\s-+\\)*~?\\(\\<"  
                         (mapconcat 'identity  
                                    c++-font-lock-extra-types "\\|")  
                         "\\>\\)\\s-*("  
                         ;; Don't match function pointer declarations, e.g.:  
                         ;;    Foo (*fptr)();  
                         "\\s-*[^*( \t]")))  
     (while (progn (setq res (re-search-forward regexp limit t))  
                   (and res  
                        (save-excursion  
                          (beginning-of-line)  
                          (save-match-data  
                            (not (vectorp (c-at-toplevel-p))))))))  
     res))  
   
 (let* ((c++-keywords  
         (eval-when-compile  
           (regexp-opt  
            '("break" "continue" "do" "else" "for" "if" "return" "switch"  
              "while" "asm" "catch" "delete" "new" "sizeof" "this" "throw" "try"  
              "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"  
              ;; 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  
            ;; Taken from Stroustrup, minus keywords otherwise fontified.  
            '("+" "-" "*" "/" "%" "^" "&" "|" "~" "!" "=" "<" ">" "+=" "-="  
              "*=" "/=" "%=" "^=" "&=" "|=" "<<" ">>" ">>=" "<<=" "==" "!="  
              "<=" ">=" "&&" "||" "++" "--" "->*" "," "->" "[]" "()"))))  
        (c++-type-specs  
         (eval-when-compile  
           (regexp-opt  
            '("class" "public" "private" "protected" "typename"  
              "struct" "union" "enum" "namespace" "using"  
              ;; Eric Hopper <hopper@omnifarious.mn.org> says these are new.  
              "static_cast" "dynamic_cast" "const_cast" "reinterpret_cast") t)))  
        (c++-type-specs-depth  
         (regexp-opt-depth c++-type-specs))  
        (c++-type-names  
         `(mapconcat 'identity  
           (cons  
            ,(eval-when-compile  
               (regexp-opt  
                '("signed" "unsigned" "short" "long"  
                  "int" "char" "float" "double" "void"  
                  "bool" "complex")))  
            c++-font-lock-extra-types)  
           "\\|"))  
        (c++-type-names-depth `(regexp-opt-depth ,c++-type-names))  
        ;;  
        ;; 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]\\|<[^>\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.  
        (c++-type-spec (concat "\\(\\sw+\\)\\>" c++-type-suffix))  
        (c++-type-spec-depth (regexp-opt-depth c++-type-spec))  
        ;;  
        ;; Parenthesis depth of user-defined types not forgetting their cruft.  
        (c++-type-depth `(regexp-opt-depth  
                          (concat ,c++-type-names ,c++-type-suffix)))  
        )  
  (defconst c++-font-lock-keywords-1  
   (append  
    ;;  
    ;; The list `c-font-lock-keywords-1' less that for function names.  
    (cdr c-font-lock-keywords-1)  
    (list  
     ;;  
     ;; Fontify function name definitions, possibly incorporating class names.  
     (list (concat "^" c++-type-spec "[ \t]*(")  
           '(1 (if (or (match-beginning 2) (match-beginning 4))  
                   font-lock-type-face  
                 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.")  
   
  (defconst c++-font-lock-keywords-2  
   (append c++-font-lock-keywords-1  
    (list  
     ;;  
     ;; The list `c-font-lock-keywords-2' for C++ plus operator overloading.  
     `(eval .  
       (cons (concat "\\<\\(" ,c++-type-names "\\)\\>")  
             'font-lock-type-face))  
     ;;  
     ;; Fontify operator overloading.  
     (list (concat "\\<\\(operator\\)\\>[ \t]*\\(" c++-operators "\\)?")  
           '(1 font-lock-keyword-face)  
           '(2 font-lock-builtin-face nil t))  
     ;;  
     ;; Fontify case/goto keywords and targets, and case default/goto tags.  
     '("\\<\\(case\\|goto\\)\\>"  
       (1 font-lock-keyword-face)  
       ("\\(-[0-9]+\\|\\sw+\\)[ \t]*\\(::\\)?"  
        ;; Return limit of search.  
        (save-excursion  
          (while (progn  
                   (skip-chars-forward "^:\n")  
                   (looking-at "::"))  
            (forward-char 2))  
          (point))  
        nil  
        (1 (if (match-beginning 2)  
               font-lock-type-face  
             font-lock-constant-face) nil t)))  
     ;; This must come after the one for keywords and targets.  
     '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:\\($\\|[^:]\\)"  
            (beginning-of-line) (end-of-line)  
            (1 font-lock-constant-face)))  
     ;;  
     ;; Fontify other builtin keywords.  
     (concat "\\<\\(" c++-keywords "\\|" c++-type-specs "\\)\\>")  
     ;;  
     ;; 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'.")  
   
  (defconst c++-font-lock-keywords-3  
   (append c++-font-lock-keywords-2  
    ;;  
    ;; More complicated regexps for more complete highlighting for types.  
    (list  
     ;;  
     ;; Fontify all storage classes and type specifiers, plus their items.  
     `(eval .  
       (list (concat "\\<\\(" ,c++-type-names "\\)\\>" ,c++-type-suffix  
                     "\\([ \t*&]+" ,c++-type-spec "\\)*")  
             ;; The name of any template type.  
             `(,(+ ,c++-type-names-depth 3) 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.  
               (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.  
     `(,(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  
        (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.  
     `(,(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  
   "Default expressions to highlight in C++ mode.  
 See also `c++-font-lock-extra-types'.")  
   
 ;;; Objective-C.  
   
 ;; Regexps written with help from Stephen Peters <speters@us.oracle.com> and  
 ;; Jacques Duthen Prestataire <duthen@cegelec-red.fr>.  
 (let* ((objc-keywords  
         (eval-when-compile  
           (regexp-opt '("break" "continue" "do" "else" "for" "if" "return"  
                         "switch" "while" "sizeof" "self" "super"  
                         "typedef" "auto" "extern" "static"  
                         "volatile" "const"))))  
        (objc-type-specs  
         (eval-when-compile  
           (regexp-opt  
            '("register" "struct" "union" "enum"  
              "oneway" "in" "out" "inout" "bycopy" "byref") t)))  
        (objc-type-specs-depth  
         (regexp-opt-depth objc-type-specs))  
        (objc-type-names  
         `(mapconcat 'identity  
           (cons  
            ,(eval-when-compile  
               (regexp-opt  
                '("signed" "unsigned" "short" "long"  
                  "int" "char" "float" "double" "void"  
                  "id")))  
            objc-font-lock-extra-types)  
           "\\|"))  
        (objc-type-names-depth  
         `(regexp-opt-depth ,objc-type-names))  
        )  
  (defconst objc-font-lock-keywords-1  
   (append  
    ;;  
    ;; The list `c-font-lock-keywords-1' less that for function names.  
    (cdr c-font-lock-keywords-1)  
    (list  
     ;;  
     ;; Fontify compiler directives.  
     '("@\\(\\sw+\\)\\>"  
       (1 font-lock-keyword-face)  
       ("\\=[ \t:<,]*\\(\\sw+\\)" nil nil  
        (1 font-lock-type-face)))  
     ;;  
     ;; Fontify method names and arguments.  Oh Lordy!  
     ;; First, on the same line as the function declaration.  
     '("^[+-][ \t]*\\(PRIVATE\\>\\)?[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)"  
       (1 font-lock-keyword-face nil t)  
       (3 font-lock-function-name-face)  
       ("\\=[ \t]*\\(\\sw+\\)?:[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)"  
        nil nil  
        (1 font-lock-function-name-face nil t)  
        (3 font-lock-variable-name-face)))  
     ;; Second, on lines following the function declaration.  
     '(":" ("^[ \t]*\\(\\sw+\\)?:[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)"  
            (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.")  
   
  (defconst objc-font-lock-keywords-2  
   (append objc-font-lock-keywords-1  
    (list  
     ;;  
     ;; Simple regexps for speed.  
     ;;  
     ;; Fontify all type specifiers.  
     `(eval .  
       (cons (concat "\\<\\(" ,objc-type-names "\\)\\>")  
             'font-lock-type-face))  
     ;;  
     ;; Fontify all builtin keywords (except case, default and goto; see below).  
     (concat "\\<\\(" objc-keywords "\\|" objc-type-specs "\\)\\>")  
     ;;  
     ;; Fontify case/goto keywords and targets, and case default/goto tags.  
     '("\\<\\(case\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?"  
       (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))  
     ;; Fontify tags iff sole statement on line, otherwise we detect selectors.  
     ;; This must come after the one for keywords and targets.  
     '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$"  
            (beginning-of-line) (end-of-line)  
            (1 font-lock-constant-face)))  
     ;;  
     ;; Fontify null object pointers.  
     '("\\<[Nn]il\\>" . font-lock-constant-face)  
     ))  
   "Medium level highlighting for Objective-C mode.  
 See also `objc-font-lock-extra-types'.")  
   
  (defconst objc-font-lock-keywords-3  
   (append objc-font-lock-keywords-2  
    ;;  
    ;; More complicated regexps for more complete highlighting for types.  
    ;; We still have to fontify type specifiers individually, as C is so hairy.  
    (list  
     ;;  
     ;; Fontify all storage classes and type specifiers, plus their items.  
     `(eval .  
       (list (concat "\\<\\(" ,objc-type-names "\\)\\>"  
                     "\\([ \t*&]+\\sw+\\>\\)*")  
             ;; 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  
                                 ,(+ ,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.  
     `(,(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  
        (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  
        (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  
   "Default expressions to highlight in Objective-C mode.  
 See also `objc-font-lock-extra-types'.")  
   
 ;;; Java.  
   
 ;; 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  
         (eval-when-compile  
           (regexp-opt  
            '("catch" "do" "else" "super" "this" "finally" "for" "if"  
              ;; Anders Lindgren <andersl@andersl.com> says these have gone.  
              ;; "cast" "byvalue" "future" "generic" "operator" "var"  
              ;; "inner" "outer" "rest"  
              "implements" "extends" "throws" "instanceof" "new"  
              "interface" "return" "switch" "throw" "try" "while"))))  
        ;;  
        ;; Classes immediately followed by an object name.  
        (java-type-names  
         `(mapconcat 'identity  
           (cons  
            ,(eval-when-compile  
               (regexp-opt '("boolean" "char" "byte" "short" "int" "long"  
                             "float" "double" "void")))  
            java-font-lock-extra-types)  
           "\\|"))  
        (java-type-names-depth `(regexp-opt-depth ,java-type-names))  
        ;;  
        ;; These are eventually followed by an object name.  
        (java-type-specs  
         (eval-when-compile  
           (regexp-opt  
            '("abstract" "const" "final" "synchronized" "transient" "static"  
              ;; Anders Lindgren <andersl@andersl.com> says this has gone.  
              ;; "threadsafe"  
              "volatile" "public" "private" "protected" "native"  
              ;; Carl Manning <caroma@ai.mit.edu> says this is new.  
              "strictfp"))))  
        )  
  (defconst java-font-lock-keywords-1  
   (list  
    ;;  
    ;; Fontify class names.  
    '("\\<\\(class\\)\\>[ \t]*\\(\\sw+\\)?"  
      (1 font-lock-keyword-face) (2 font-lock-type-face nil t))  
    ;;  
    ;; Fontify package names in import directives.  
    '("\\<\\(import\\|package\\)\\>[ \t]*\\(\\sw+\\)?"  
      (1 font-lock-keyword-face)  
      (2 font-lock-constant-face nil t)  
      ("\\=\\.\\(\\*\\|\\sw+\\)" nil nil  
       (1 font-lock-constant-face nil t)))  
    )  
   "Subdued level highlighting for Java mode.")  
   
  (defconst java-font-lock-keywords-2  
   (append java-font-lock-keywords-1  
    (list  
     ;;  
     ;; Fontify class names.  
     `(eval .  
       (cons (concat "\\<\\(" ,java-type-names "\\)\\>[^.]")  
             '(1 font-lock-type-face)))  
     ;;  
     ;; Fontify all builtin keywords (except below).  
     (concat "\\<\\(" java-keywords "\\|" java-type-specs "\\)\\>")  
     ;;  
     ;; Fontify keywords and targets, and case default/goto tags.  
     (list "\\<\\(break\\|case\\|continue\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?"  
           '(1 font-lock-keyword-face) '(2 font-lock-constant-face nil t))  
     ;; This must come after the one for keywords and targets.  
     '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$"  
            (beginning-of-line) (end-of-line)  
            (1 font-lock-constant-face)))  
     ;;  
     ;; Fontify all constants.  
     '("\\<\\(false\\|null\\|true\\)\\>" . font-lock-constant-face)  
     ;;  
     ;; Javadoc tags within comments.  
     (list  
      (concat "@\\("  
              "author\\|deprecated\\|exception"  
              "\\|link\\|return\\|see\\|serial\\|serialData\\|serialField"  
              "\\|since\\|throws"  
              "\\|version"  
              "\\)\\>")  
      '(1 font-lock-constant-face prepend))  
     '("@\\(param\\)\\>[ \t]*\\(\\sw+\\)?"  
       (1 font-lock-constant-face prepend)  
       (2 font-lock-variable-name-face prepend t))  
     '("@\\(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'.")  
   
  (defconst java-font-lock-keywords-3  
   (append java-font-lock-keywords-2  
    ;;  
    ;; More complicated regexps for more complete highlighting for types.  
    ;; We still have to fontify type specifiers individually, as Java is hairy.  
    (list  
     ;;  
     ;; Fontify random types immediately followed by an item or items.  
     `(eval .  
       (list (concat "\\<\\(" ,java-type-names "\\)\\>"  
                     "\\([ \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.  
               (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.  
     `(,(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.  
 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))))  
   
1927  (provide 'font-lock)  (provide 'font-lock)
1928    
1929  (when (eq font-lock-support-mode 'jit-lock-mode)  (when (eq font-lock-support-mode 'jit-lock-mode)
1930    (require 'jit-lock))    (require 'jit-lock))
1931    
1932    ;;; arch-tag: 682327e4-64d8-4057-b20b-1fbb9f1fc54c
1933  ;;; font-lock.el ends here  ;;; font-lock.el ends here

Legend:
Removed from v.1.197.2.1  
changed lines
  Added in v.1.197.2.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26