X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/46f26fcf29c75548e793e6625d7b3b1f73db1d05..a1051b732b5997340eb2aa4ced6fc7a94bf5e0b1:/lisp/font-lock.el diff --git a/lisp/font-lock.el b/lisp/font-lock.el index 6007c1869c..9dcb8a3fac 100644 --- a/lisp/font-lock.el +++ b/lisp/font-lock.el @@ -1,8 +1,8 @@ ;;; font-lock.el --- Electric font lock mode -;; Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc. +;; Copyright (C) 1992-1999 Free Software Foundation, Inc. -;; Author: jwz, then rms, then sm +;; Author: jwz, then rms, then sm ;; Maintainer: FSF ;; Keywords: languages, faces @@ -210,6 +210,7 @@ (defgroup font-lock nil "Font Lock mode text highlighting package." :link '(custom-manual "(emacs)Font Lock") + :link '(custom-manual "(elisp)Font Lock Mode") :group 'faces) (defgroup font-lock-highlighting-faces nil @@ -233,10 +234,17 @@ :link '(custom-manual "(emacs)Support Modes") :load 'lazy-lock :group 'font-lock) + +(defgroup jit-lock nil + "Font Lock support mode to fontify just-in-time." + :link '(custom-manual "(emacs)Support Modes") + :version "21.1" + :load 'jit-lock + :group 'font-lock) ;; User variables. -(defcustom font-lock-maximum-size (* 250 1024) +(defcustom font-lock-maximum-size 256000 "*Maximum size of a buffer for buffer fontification. Only buffers less than this can be fontified when Font Lock mode is turned on. If nil, means size is irrelevant. @@ -283,11 +291,11 @@ decoration for buffers in C++ mode, and level 1 decoration otherwise." (integer :tag "level" 1))))) :group 'font-lock) -(defcustom font-lock-verbose (* 0 1024) +(defcustom font-lock-verbose 0 "*If non-nil, means show status messages for buffer fontification. If a number, only buffers greater than this size have fontification messages." :type '(choice (const :tag "never" nil) - (const :tag "always" t) + (other :tag "always" t) (integer :tag "size")) :group 'font-lock) @@ -295,7 +303,7 @@ If a number, only buffers greater than this size have fontification messages." (defvar font-lock-keywords nil "A list of the keywords to highlight. -Each element should be of the form: +Each element should have one of these forms: MATCHER (MATCHER . MATCH) @@ -310,16 +318,19 @@ FORM is an expression, whose value should be a keyword element, evaluated when the keyword is (first) used in a buffer. This feature can be used to provide a keyword that can only be generated when Font Lock mode is actually turned on. -For highlighting single items, typically only MATCH-HIGHLIGHT is required. +For highlighting single items, for example each instance of the word \"foo\", +typically only MATCH-HIGHLIGHT is required. However, if an item or (typically) items are to be highlighted following the -instance of another item (the anchor) then MATCH-ANCHORED may be required. +instance of another item (the anchor), for example each instance of the +word \"bar\" following the word \"anchor\" then MATCH-ANCHORED may be required. MATCH-HIGHLIGHT should be of the form: (MATCH FACENAME OVERRIDE LAXMATCH) -Where MATCHER can be either the regexp to search for, or the function name to -call to make the search (called with one argument, the limit of the search). +where MATCHER can be either the regexp to search for, or the function name to +call to make the search (called with one argument, the limit of the search) and +return non-nil if it succeeds (and set `match-data' appropriately). MATCHER regexps can be generated via the function `regexp-opt'. MATCH is the subexpression of MATCHER to be highlighted. MATCH can be calculated via the function `regexp-opt-depth'. FACENAME is an expression whose value is the face @@ -333,20 +344,25 @@ If LAXMATCH is non-nil, no error is signaled if there is no MATCH in MATCHER. For example, an element of the form highlights (if not already highlighted): - \"\\\\\\=\" Discrete occurrences of \"foo\" in the value of the + \"\\\\\\=\" discrete occurrences of \"foo\" in the value of the variable `font-lock-keyword-face'. - (\"fu\\\\(bar\\\\)\" . 1) Substring \"bar\" within all occurrences of \"fubar\" in + (\"fu\\\\(bar\\\\)\" . 1) substring \"bar\" within all occurrences of \"fubar\" in the value of `font-lock-keyword-face'. (\"fubar\" . fubar-face) Occurrences of \"fubar\" in the value of `fubar-face'. (\"foo\\\\|bar\" 0 foo-bar-face t) - Occurrences of either \"foo\" or \"bar\" in the value + occurrences of either \"foo\" or \"bar\" in the value of `foo-bar-face', even if already highlighted. + (fubar-match 1 fubar-face) + the first subexpression within all occurrences of + whatever the function `fubar-match' finds and matches + in the value of `fubar-face'. MATCH-ANCHORED should be of the form: (MATCHER PRE-MATCH-FORM POST-MATCH-FORM MATCH-HIGHLIGHT ...) -Where MATCHER is as for MATCH-HIGHLIGHT with one exception; see below. +where MATCHER is a regexp to search for or the function name to call to make +the search, as for MATCH-HIGHLIGHT above, but with one exception; see below. PRE-MATCH-FORM and POST-MATCH-FORM are evaluated before the first, and after the last, instance MATCH-ANCHORED's MATCHER is used. Therefore they can be used to initialise before, and cleanup after, MATCHER is used. Typically, @@ -358,7 +374,7 @@ For example, an element of the form highlights (if not already highlighted): (\"\\\\\\=\" (0 anchor-face) (\"\\\\\\=\" nil nil (0 item-face))) - Discrete occurrences of \"anchor\" in the value of `anchor-face', and subsequent + discrete occurrences of \"anchor\" in the value of `anchor-face', and subsequent discrete occurrences of \"item\" (on the same line) in the value of `item-face'. (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil. Therefore \"item\" is initially searched for starting from the end of the match of \"anchor\", and @@ -372,9 +388,6 @@ PRE-MATCH-FORM is evaluated, that position is used as the limit of the search. It is generally a bad idea to return a position greater than the end of the line, i.e., cause the MATCHER search to span lines. -Note that the MATCH-ANCHORED feature is experimental; in the future, we may -replace it with other ways of providing this functionality. - These regular expressions should not match text which spans lines. While \\[font-lock-fontify-buffer] handles multi-line patterns correctly, updating when you edit the buffer does not, since it considers text one line at a time. @@ -423,7 +436,9 @@ Typical values are `mark-defun' for programming modes or `mark-paragraph' for textual modes (i.e., the mode-dependent function is known to put point and mark around a text block relevant to that mode). -Other variables include those for buffer-specialised fontification functions, +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'.") @@ -437,55 +452,36 @@ Other variables include those for buffer-specialised fontification functions, '((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 - ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP. - ;(font-lock-comment-start-regexp . "/[*/]") (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 - ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP. - ;(font-lock-comment-start-regexp . "/[*/]") (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 - ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP. - ;(font-lock-comment-start-regexp . "/[*/]") (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") (?. . "w")) nil - ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP. - ;(font-lock-comment-start-regexp . "/[*/]") + 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 - ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP. - ;(font-lock-comment-start-regexp . ";") - (font-lock-mark-block-function . mark-defun))) - (scheme-mode-defaults - '((scheme-font-lock-keywords - scheme-font-lock-keywords-1 scheme-font-lock-keywords-2) - nil t (("+-*/.<>=!?$%_&~^:" . "w")) beginning-of-defun - ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP. - ;(font-lock-comment-start-regexp . ";") (font-lock-mark-block-function . mark-defun))) ;; For TeX modes we could use `backward-paragraph' for the same reason. ;; But we don't, because paragraph breaks are arguably likely enough to ;; occur within a genuine syntactic block to make it too risky. ;; However, we do specify a MARK-BLOCK function as that cannot result - ;; in a mis-fontification even if it might not fontify enough. --sm. + ;; in a mis-fontification even if it might not fontify enough. sm. (tex-mode-defaults '((tex-font-lock-keywords tex-font-lock-keywords-1 tex-font-lock-keywords-2) nil nil ((?$ . "\"")) nil - ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP. - ;(font-lock-comment-start-regexp . "%") (font-lock-mark-block-function . mark-paragraph))) ) (list @@ -494,13 +490,10 @@ Other variables include those for buffer-specialised fontification functions, (cons 'objc-mode objc-mode-defaults) (cons 'java-mode java-mode-defaults) (cons 'emacs-lisp-mode lisp-mode-defaults) - (cons 'inferior-scheme-mode scheme-mode-defaults) (cons 'latex-mode tex-mode-defaults) (cons 'lisp-mode lisp-mode-defaults) (cons 'lisp-interaction-mode lisp-mode-defaults) (cons 'plain-tex-mode tex-mode-defaults) - (cons 'scheme-mode scheme-mode-defaults) - (cons 'scheme-interaction-mode scheme-mode-defaults) (cons 'slitex-mode tex-mode-defaults) (cons 'tex-mode tex-mode-defaults))) "Alist of fall-back Font Lock defaults for major modes. @@ -535,6 +528,27 @@ where SYNTAX can be of the form (SYNTAX-CODE . MATCHING-CHAR), the name of a syntax table, or an expression whose value is such a form or a syntax table. OVERRIDE cannot be `prepend' or `append'. +For example, an element of the form highlights syntactically: + + (\"\\\\$\\\\(#\\\\)\" 1 (1 . nil)) + + a hash character when following a dollar character, with a SYNTAX-CODE of + 1 (meaning punctuation syntax). Assuming that the buffer syntax table does + specify hash characters to have comment start syntax, the element will only + highlight hash characters that do not follow dollar characters as comments + syntactically. + + (\"\\\\('\\\\).\\\\('\\\\)\" + (1 (7 . ?')) + (2 (7 . ?'))) + + both single quotes which surround a single character, with a SYNTAX-CODE of + 7 (meaning string quote syntax) and a MATCHING-CHAR of a single quote (meaning + a single quote matches a single quote). Assuming that the buffer syntax table + does not specify single quotes to have quote syntax, the element will only + highlight single quotes of the form 'c' as strings syntactically. + Other forms, such as foo'bar or 'fubar', will not be highlighted as strings. + This is normally set via `font-lock-defaults'.") (defvar font-lock-syntax-table nil @@ -557,14 +571,6 @@ When called with no args it should leave point at the beginning of any enclosing textual block and mark at the end. This is normally set via `font-lock-defaults'.") -;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP. -;(defvar font-lock-comment-start-regexp nil -; "*Regexp to match the start of a comment. -;This need not discriminate between genuine comments and quoted comment -;characters or comment characters within strings. -;If nil, `comment-start-skip' is used instead; see that variable for more info. -;This is normally set via `font-lock-defaults'.") - (defvar font-lock-fontify-buffer-function 'font-lock-default-fontify-buffer "Function to use for fontifying the buffer. This is normally set via `font-lock-defaults'.") @@ -587,8 +593,8 @@ This is normally set via `font-lock-defaults'.") (defvar font-lock-inhibit-thing-lock nil "List of Font Lock mode related modes that should not be turned on. -Currently, valid mode names as `fast-lock-mode' and `lazy-lock-mode'. -This is normally set via `font-lock-defaults'.") +Currently, valid mode names as `fast-lock-mode', `jit-lock-mode' and +`lazy-lock-mode'. This is normally set via `font-lock-defaults'.") (defvar font-lock-mode nil) ; Whether we are turned on/modeline. (defvar font-lock-fontified nil) ; Whether we have fontified the buffer. @@ -616,7 +622,13 @@ This is normally set via `font-lock-defaults'.") (,@ body) (when (and (not modified) (buffer-modified-p)) (set-buffer-modified-p nil))))) - (put 'save-buffer-state 'lisp-indent-function 1)) + (put 'save-buffer-state 'lisp-indent-function 1) + ;; + ;; Shut up the byte compiler. + (defvar global-font-lock-mode) ; Now a defcustom. + (defvar font-lock-face-attributes) ; Obsolete but respected if set. + (defvar font-lock-string-face) ; Used in syntactic fontification. + (defvar font-lock-comment-face)) ;;;###autoload (defun font-lock-mode (&optional arg) @@ -704,7 +716,7 @@ buffer local value for `font-lock-defaults', via its mode hook." (defun turn-on-font-lock () "Turn on Font Lock mode conditionally. Turn on only if the terminal can display it." - (when (and (not font-lock-mode) window-system) + (when (and (not font-lock-mode) (or window-system (tty-display-color-p))) (font-lock-mode))) ;;;###autoload @@ -813,28 +825,37 @@ Returns the new status of Global Font Lock mode (non-nil means on). When Global Font Lock mode is enabled, Font Lock mode is automagically turned on in a buffer if its major mode is one of `font-lock-global-modes'." (interactive "P\np") - (let ((off-p (if arg - (<= (prefix-numeric-value arg) 0) - global-font-lock-mode))) - (if off-p - (remove-hook 'find-file-hooks 'turn-on-font-lock-if-enabled) - (add-hook 'find-file-hooks 'turn-on-font-lock-if-enabled) - (add-hook 'post-command-hook 'turn-on-font-lock-if-enabled) - (setq font-lock-buffers (buffer-list))) + (let ((on-p (if arg + (> (prefix-numeric-value arg) 0) + (not global-font-lock-mode)))) + (cond (on-p + (add-hook 'find-file-hooks 'turn-on-font-lock-if-enabled) + (add-hook 'post-command-hook 'turn-on-font-lock-if-enabled) + (setq font-lock-buffers (buffer-list))) + (t + (remove-hook 'find-file-hooks 'turn-on-font-lock-if-enabled) + (mapcar (function (lambda (buffer) + (with-current-buffer buffer + (when font-lock-mode + (font-lock-mode))))) + (buffer-list)))) (when message - (message "Global Font Lock mode is now %s." (if off-p "OFF" "ON"))) - (setq global-font-lock-mode (not off-p)))) + (message "Global Font Lock mode %s." (if on-p "enabled" "disabled"))) + (setq global-font-lock-mode on-p))) -;; Naughty hack. This variable was originally a `defvar' to keep track of +;; This variable was originally a `defvar' to keep track of ;; whether Global Font Lock mode was turned on or not. As a `defcustom' with ;; special `:set' and `:require' forms, we can provide custom mode control. +;;;###autoload (defcustom global-font-lock-mode nil "Toggle Global Font Lock mode. When Global Font Lock mode is enabled, Font Lock mode is automagically turned on in a buffer if its major mode is one of `font-lock-global-modes'. -You must modify via \\[customize] for this variable to have an effect." +Setting this variable directly does not take effect; +use either \\[customize] or the function `global-font-lock-mode'." :set (lambda (symbol value) (global-font-lock-mode (or value 0))) + :initialize 'custom-initialize-default :type 'boolean :group 'font-lock :require 'font-lock) @@ -900,11 +921,12 @@ means that Font Lock mode is turned on for buffers in C and C++ modes only." ;; `font-lock-after-fontify-buffer' and/or `font-lock-after-unfontify-buffer' ;; themselves. -(defcustom font-lock-support-mode nil +(defcustom font-lock-support-mode 'jit-lock-mode "*Support mode for Font Lock mode. Support modes speed up Font Lock mode by being choosy about when fontification -occurs. Known support modes are Fast Lock mode (symbol `fast-lock-mode') and -Lazy Lock mode (symbol `lazy-lock-mode'). See those modes for more info. +occurs. Known support modes are Fast Lock mode (symbol `fast-lock-mode'), +Lazy Lock mode (symbol `lazy-lock-mode'), and Just-in-time Lock mode (symbol +`jit-lock-mode'. See those modes for more info. If nil, means support for Font Lock mode is never performed. If a symbol, use that support mode. If a list, each element should be of the form (MAJOR-MODE . SUPPORT-MODE), @@ -917,43 +939,55 @@ The value of this variable is used when Font Lock mode is turned on." :type '(choice (const :tag "none" nil) (const :tag "fast lock" fast-lock-mode) (const :tag "lazy lock" lazy-lock-mode) + (const :tag "jit lock" jit-lock-mode) (repeat :menu-tag "mode specific" :tag "mode specific" :value ((t . lazy-lock-mode)) (cons :tag "Instance" (radio :tag "Mode" (const :tag "all" t) (symbol :tag "name")) - (radio :tag "Decoration" + (radio :tag "Support" + (const :tag "none" nil) (const :tag "fast lock" fast-lock-mode) - (const :tag "lazy lock" lazy-lock-mode))) + (const :tag "lazy lock" lazy-lock-mode) + (const :tag "JIT lock" jit-lock-mode))) )) :group 'font-lock) (defvar fast-lock-mode nil) (defvar lazy-lock-mode nil) +(defvar jit-lock-mode nil) (defun font-lock-turn-on-thing-lock () (let ((thing-mode (font-lock-value-in-major-mode font-lock-support-mode))) (cond ((eq thing-mode 'fast-lock-mode) (fast-lock-mode t)) ((eq thing-mode 'lazy-lock-mode) - (lazy-lock-mode t))))) + (lazy-lock-mode t)) + ((eq thing-mode 'jit-lock-mode) + (jit-lock-mode t))))) (defun font-lock-turn-off-thing-lock () (cond (fast-lock-mode (fast-lock-mode nil)) + (jit-lock-mode + (jit-lock-mode nil)) (lazy-lock-mode (lazy-lock-mode nil)))) (defun font-lock-after-fontify-buffer () (cond (fast-lock-mode (fast-lock-after-fontify-buffer)) + (jit-lock-mode + (jit-lock-after-fontify-buffer)) (lazy-lock-mode (lazy-lock-after-fontify-buffer)))) (defun font-lock-after-unfontify-buffer () (cond (fast-lock-mode (fast-lock-after-unfontify-buffer)) + (jit-lock-mode + (jit-lock-after-unfontify-buffer)) (lazy-lock-mode (lazy-lock-after-unfontify-buffer)))) @@ -1020,27 +1054,26 @@ The value of this variable is used when Font Lock mode is turned on." (let ((verbose (if (numberp font-lock-verbose) (> (buffer-size) font-lock-verbose) font-lock-verbose))) - (when verbose - (message "Fontifying %s..." (buffer-name))) - ;; Make sure we have the right `font-lock-keywords' etc. - (unless font-lock-mode - (font-lock-set-defaults)) - ;; Make sure we fontify etc. in the whole buffer. - (save-restriction - (widen) - (condition-case nil - (save-excursion - (save-match-data - (font-lock-fontify-region (point-min) (point-max) verbose) - (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)) - (if verbose (message "Fontifying %s...%s" (buffer-name) - (if font-lock-fontified "done" "quit"))))) + (with-temp-message + (when verbose + (format "Fontifying %s..." (buffer-name))) + ;; Make sure we have the right `font-lock-keywords' etc. + (unless font-lock-mode + (font-lock-set-defaults)) + ;; Make sure we fontify etc. in the whole buffer. + (save-restriction + (widen) + (condition-case nil + (save-excursion + (save-match-data + (font-lock-fontify-region (point-min) (point-max) verbose) + (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))))) (defun font-lock-default-unfontify-buffer () ;; Make sure we unfontify etc. in the whole buffer. @@ -1060,6 +1093,16 @@ The value of this variable is used when Font Lock mode is turned on." ;; Use the fontification syntax table, if any. (when font-lock-syntax-table (set-syntax-table font-lock-syntax-table)) + ;; check to see if we should expand the beg/end area for + ;; proper multiline matches + (setq beg (if (get-text-property beg 'font-lock-multiline) + (or (previous-single-property-change + beg 'font-lock-multiline) + (point-min)) + beg)) + (setq end (or (text-property-any end (point-max) + 'font-lock-multiline nil) + (point-max))) ;; Now do the fontification. (font-lock-unfontify-region beg end) (when font-lock-syntactic-keywords @@ -1080,7 +1123,10 @@ The value of this variable is used when Font Lock mode is turned on." (defun font-lock-default-unfontify-region (beg end) (save-buffer-state nil - (remove-text-properties beg end '(face nil syntax-table 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))))) ;; Called when any modification is made to buffer text. (defun font-lock-after-change-function (beg end old-len) @@ -1219,7 +1265,7 @@ see `font-lock-syntactic-keywords'." (start (match-beginning match)) (end (match-end match)) (value (nth 1 highlight)) (override (nth 2 highlight))) - (unless (numberp (car value)) + (unless (numberp (car-safe value)) (setq value (eval value))) (cond ((not start) ;; No match but we might not signal an error. @@ -1390,12 +1436,16 @@ HIGHLIGHT should be of the form MATCH-HIGHLIGHT, see `font-lock-keywords'." KEYWORDS should be of the form MATCH-ANCHORED, see `font-lock-keywords', LIMIT can be modified by the value of its PRE-MATCH-FORM." (let ((matcher (nth 0 keywords)) (lowdarks (nthcdr 3 keywords)) highlights + (lead-start (match-beginning 0)) ;; Evaluate PRE-MATCH-FORM. (pre-match-value (eval (nth 1 keywords)))) ;; Set LIMIT to value of PRE-MATCH-FORM or the end of line. - (if (and (numberp pre-match-value) (> pre-match-value (point))) - (setq limit pre-match-value) - (save-excursion (end-of-line) (setq limit (point)))) + (if (not (and (numberp pre-match-value) (> pre-match-value (point)))) + (save-excursion (end-of-line) (setq limit (point))) + (setq limit pre-match-value) + (when (>= pre-match-value (save-excursion (forward-line 1) (point))) + ;; this is a multiline anchored match + (put-text-property (point) limit 'font-lock-multiline t))) (save-match-data ;; Find an occurrence of `matcher' before `limit'. (while (if (stringp matcher) @@ -1427,9 +1477,17 @@ START should be at the beginning of a line." ;; Find an occurrence of `matcher' from `start' to `end'. (setq keyword (car keywords) matcher (car keyword)) (goto-char start) - (while (if (stringp matcher) - (re-search-forward matcher end t) - (funcall matcher end)) + (while (and (< (point) end) + (if (stringp matcher) + (re-search-forward matcher end t) + (funcall matcher end))) + (when (and (match-beginning 0) + (>= (point) + (save-excursion (goto-char (match-beginning 0)) + (forward-line 1) (point)))) + ;; this is a multiline regexp match + (put-text-property (match-beginning 0) (point) + 'font-lock-multiline t)) ;; Apply each highlight to this instance of `matcher', which may be ;; specific highlights or more keywords anchored to `matcher'. (setq highlights (cdr keyword)) @@ -1541,8 +1599,7 @@ Sets various variables using `font-lock-defaults' (or, if nil, using (mapcar 'identity (car (car slist))))) (syntax (cdr (car slist)))) (while chars - (modify-syntax-entry (car chars) syntax - font-lock-syntax-table) + (modify-syntax-entry (car chars) syntax font-lock-syntax-table) (setq chars (cdr chars))) (setq slist (cdr slist)))))) ;; Syntax function for syntactic fontification? @@ -1600,14 +1657,17 @@ Sets various variables using `font-lock-defaults' (or, if nil, using "Face name to use for variable names.") (defvar font-lock-type-face 'font-lock-type-face - "Face name to use for type names.") + "Face name to use for type and class names.") -(defvar font-lock-reference-face 'font-lock-reference-face - "Face name to use for reference names.") +(defvar font-lock-constant-face 'font-lock-constant-face + "Face name to use for constant and label names.") (defvar font-lock-warning-face 'font-lock-warning-face "Face name to use for things that should stand out.") +(defvar font-lock-reference-face 'font-lock-constant-face + "This variable is obsolete. Use font-lock-constant-face.") + ;; Originally face attributes were specified via `font-lock-face-attributes'. ;; Users then changed the default face attributes by setting that variable. ;; However, we try and be back-compatible and respect its value if set except @@ -1640,7 +1700,8 @@ Sets various variables using `font-lock-defaults' (or, if nil, using ;; But now we do it the custom way. Note that `defface' will not overwrite any ;; faces declared above via `custom-declare-face'. (defface font-lock-comment-face - '((((class grayscale) (background light)) + '((((type tty) (class color)) (:foreground "red")) + (((class grayscale) (background light)) (:foreground "DimGray" :bold t :italic t)) (((class grayscale) (background dark)) (:foreground "LightGray" :bold t :italic t)) @@ -1651,7 +1712,8 @@ Sets various variables using `font-lock-defaults' (or, if nil, using :group 'font-lock-highlighting-faces) (defface font-lock-string-face - '((((class grayscale) (background light)) (:foreground "DimGray" :italic t)) + '((((type tty) (class color)) (:foreground "green")) + (((class grayscale) (background light)) (:foreground "DimGray" :italic t)) (((class grayscale) (background dark)) (:foreground "LightGray" :italic t)) (((class color) (background light)) (:foreground "RosyBrown")) (((class color) (background dark)) (:foreground "LightSalmon")) @@ -1660,7 +1722,8 @@ Sets various variables using `font-lock-defaults' (or, if nil, using :group 'font-lock-highlighting-faces) (defface font-lock-keyword-face - '((((class grayscale) (background light)) (:foreground "LightGray" :bold t)) + '((((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 color) (background light)) (:foreground "Purple")) (((class color) (background dark)) (:foreground "Cyan")) @@ -1669,7 +1732,8 @@ Sets various variables using `font-lock-defaults' (or, if nil, using :group 'font-lock-highlighting-faces) (defface font-lock-builtin-face - '((((class grayscale) (background light)) (:foreground "LightGray" :bold t)) + '((((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 color) (background light)) (:foreground "Orchid")) (((class color) (background dark)) (:foreground "LightSteelBlue")) @@ -1678,14 +1742,16 @@ Sets various variables using `font-lock-defaults' (or, if nil, using :group 'font-lock-highlighting-faces) (defface font-lock-function-name-face - '((((class color) (background light)) (:foreground "Blue")) + '((((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))) "Font Lock mode face used to highlight function names." :group 'font-lock-highlighting-faces) (defface font-lock-variable-name-face - '((((class grayscale) (background light)) + '((((type tty) (class color)) (:foreground "yellow" :weight light)) + (((class grayscale) (background light)) (:foreground "Gray90" :bold t :italic t)) (((class grayscale) (background dark)) (:foreground "DimGray" :bold t :italic t)) @@ -1696,27 +1762,30 @@ Sets various variables using `font-lock-defaults' (or, if nil, using :group 'font-lock-highlighting-faces) (defface font-lock-type-face - '((((class grayscale) (background light)) (:foreground "Gray90" :bold t)) + '((((type tty) (class color)) (:foreground "green")) + (((class grayscale) (background light)) (:foreground "Gray90" :bold t)) (((class grayscale) (background dark)) (:foreground "DimGray" :bold t)) (((class color) (background light)) (:foreground "ForestGreen")) (((class color) (background dark)) (:foreground "PaleGreen")) (t (:bold t :underline t))) - "Font Lock mode face used to highlight types." + "Font Lock mode face used to highlight type and classes." :group 'font-lock-highlighting-faces) -(defface font-lock-reference-face - '((((class grayscale) (background light)) +(defface font-lock-constant-face + '((((type tty) (class color)) (:foreground "magenta")) + (((class grayscale) (background light)) (:foreground "LightGray" :bold t :underline t)) (((class grayscale) (background dark)) (:foreground "Gray50" :bold t :underline t)) (((class color) (background light)) (:foreground "CadetBlue")) (((class color) (background dark)) (:foreground "Aquamarine")) (t (:bold t :underline t))) - "Font Lock mode face used to highlight references." + "Font Lock mode face used to highlight constants and labels." :group 'font-lock-highlighting-faces) (defface font-lock-warning-face - '((((class color) (background light)) (:foreground "Red" :bold t)) + '((((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))) "Font Lock mode face used to highlight warnings." @@ -1733,7 +1802,7 @@ Sets various variables using `font-lock-defaults' (or, if nil, using ;; the entry for "Text Properties" something like: ;; ;; (define-key menu-bar-edit-menu [font-lock] -;; '("Syntax Highlighting" . font-lock-menu)) +;; (cons "Syntax Highlighting" font-lock-menu)) ;; ;; and remove a single ";" from the beginning of each line in the rest of this ;; section. Probably the mechanism for telling the menu code what are menu @@ -1766,7 +1835,7 @@ Sets various variables using `font-lock-defaults' (or, if nil, using ; (put 'font-lock-fontify-less 'menu-enable '(identity))) ; ;;; Put the appropriate symbol property values on now. See above. -;(put 'global-font-lock-mode 'menu-selected 'global-font-lock-mode)) +;(put 'global-font-lock-mode 'menu-selected 'global-font-lock-mode) ;(put 'font-lock-mode 'menu-selected 'font-lock-mode) ;(put 'font-lock-fontify-more 'menu-enable '(nth 2 font-lock-fontify-level)) ;(put 'font-lock-fontify-less 'menu-enable '(nth 1 font-lock-fontify-level)) @@ -1875,27 +1944,27 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." ;; Definitions. (list (concat "(\\(def\\(" ;; Function declarations. - "\\(advice\\|alias\\|" - "ine-\\(derived-mode\\|function\\|skeleton\\|widget\\)\\|" - "macro\\|subst\\|un\\)\\|" + "\\(advice\\|alias\\|generic\\|macro\\*?\\|method\\|" + "setf\\|subst\\*?\\|un\\*?\\|" + "ine-\\(condition\\|derived-mode\\|function\\|" + "method-combination\\|setf-expander\\|skeleton\\|widget\\|" + "\\(compiler\\|modify\\|symbol\\)-macro\\)\\)\\|" ;; Variable declarations. - "\\(const\\|custom\\|face\\|var\\)\\|" + "\\(const\\(ant\\)?\\|custom\\|face\\|parameter\\|var\\)\\|" ;; Structure declarations. - "\\(class\\|group\\|struct\\|type\\)" + "\\(class\\|group\\|package\\|struct\\|type\\)" "\\)\\)\\>" ;; Any whitespace and defined object. "[ \t'\(]*" "\\(\\sw+\\)?") '(1 font-lock-keyword-face) - '(7 (cond ((match-beginning 3) font-lock-function-name-face) - ((match-beginning 5) font-lock-variable-name-face) + '(9 (cond ((match-beginning 3) font-lock-function-name-face) + ((match-beginning 6) font-lock-variable-name-face) (t font-lock-type-face)) nil t)) ;; ;; Emacs Lisp autoload cookies. - '("^;;;\\(###\\)\\(autoload\\)\\>" - (1 font-lock-reference-face prepend) - (2 font-lock-warning-face prepend)) + '("^;;;###\\(autoload\\)" 1 font-lock-warning-face prepend) )) "Subdued level highlighting for Lisp modes.") @@ -1907,17 +1976,18 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." ;; Control structures. Emacs Lisp forms. (cons (concat "(" (regexp-opt - '("cond" "if" "while" "catch" "throw" "let" "let*" + '("cond" "if" "while" "let" "let*" "prog" "progn" "progv" "prog1" "prog2" "prog*" - "closure" "preparse-closure" "make-closure" - "inline" "save-restriction" "save-excursion" + "inline" "lambda" "save-restriction" "save-excursion" "save-window-excursion" "save-selected-window" "save-match-data" "save-current-buffer" "unwind-protect" - "condition-case" "track-mouse" "dont-compile" + "condition-case" "track-mouse" "eval-after-load" "eval-and-compile" "eval-when-compile" - "eval-when" "with-output-to-temp-buffer" "with-timeout" - "with-current-buffer" "with-temp-buffer" - "with-temp-file") t) + "eval-when" + "with-current-buffer" "with-electric-help" + "with-output-to-string" "with-output-to-temp-buffer" + "with-temp-buffer" "with-temp-file" "with-temp-message" + "with-timeout") t) "\\>") 1) ;; @@ -1925,92 +1995,43 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." (cons (concat "(" (regexp-opt '("when" "unless" "case" "ecase" "typecase" "etypecase" - "loop" "do" "do*" "dotimes" "dolist" - "proclaim" "declaim" "declare" - "lexical-let" "lexical-let*" "flet" "labels" + "ccase" "ctypecase" "handler-case" "handler-bind" + "restart-bind" "restart-case" "in-package" + "cerror" "break" "ignore-errors" + "loop" "do" "do*" "dotimes" "dolist" "the" "locally" + "proclaim" "declaim" "declare" "symbol-macrolet" + "lexical-let" "lexical-let*" "flet" "labels" "compiler-let" + "destructuring-bind" "macrolet" "tagbody" "block" "return" "return-from") t) "\\>") 1) ;; - ;; Feature symbols as references. - '("(\\(featurep\\|provide\\|require\\)\\>[ \t']*\\(\\sw+\\)?" - (1 font-lock-keyword-face) (2 font-lock-reference-face nil t)) + ;; Exit/Feature symbols as constants. + (list (concat "(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\>" + "[ \t']*\\(\\sw+\\)?") + '(1 font-lock-keyword-face) + '(2 font-lock-constant-face nil t)) + ;; + ;; Erroneous structures. + '("(\\(abort\\|assert\\|error\\|signal\\)\\>" 1 font-lock-warning-face) ;; ;; Words inside \\[] tend to be for `substitute-command-keys'. - '("\\\\\\\\\\[\\(\\sw+\\)]" 1 font-lock-reference-face prepend) + '("\\\\\\\\\\[\\(\\sw+\\)]" 1 font-lock-constant-face prepend) ;; ;; Words inside `' tend to be symbol names. - '("`\\(\\sw\\sw+\\)'" 1 font-lock-reference-face prepend) + '("`\\(\\sw\\sw+\\)'" 1 font-lock-constant-face prepend) ;; - ;; CLisp `:' keywords as builtins. + ;; Constant values. '("\\<:\\sw\\sw+\\>" 0 font-lock-builtin-face) ;; ;; ELisp and CLisp `&' keywords as types. - '("\\<\\&\\sw+\\>" . font-lock-type-face) + '("\\&\\sw+\\>" . font-lock-type-face) ))) "Gaudy level highlighting for Lisp modes.") (defvar lisp-font-lock-keywords lisp-font-lock-keywords-1 "Default expressions to highlight in Lisp modes.") -;; Scheme. - -(defconst scheme-font-lock-keywords-1 - (eval-when-compile - (list - ;; - ;; Declarations. Hannes Haug says - ;; this works for SOS, STklos, SCOOPS, Meroon and Tiny CLOS. - (list (concat "(\\(define\\(" - ;; Function names. - "\\(\\|-\\(generic\\(\\|-procedure\\)\\|method\\)\\)\\|" - ;; Macro names, as variable names. A bit dubious, this. - "\\(-syntax\\)\\|" - ;; Class names. - "-class" - "\\)\\)\\>" - ;; Any whitespace and declared object. - "[ \t]*(?" - "\\(\\sw+\\)?") - '(1 font-lock-keyword-face) - '(7 (cond ((match-beginning 3) font-lock-function-name-face) - ((match-beginning 6) font-lock-variable-name-face) - (t font-lock-type-face)) - nil t)) - )) - "Subdued expressions to highlight in Scheme modes.") - -(defconst scheme-font-lock-keywords-2 - (append scheme-font-lock-keywords-1 - (eval-when-compile - (list - ;; - ;; Control structures. - (cons - (concat - "(" (regexp-opt - '("begin" "call-with-current-continuation" "call/cc" - "call-with-input-file" "call-with-output-file" "case" "cond" - "do" "else" "for-each" "if" "lambda" - "let" "let*" "let-syntax" "letrec" "letrec-syntax" - ;; Hannes Haug wants: - "and" "or" "delay" - ;; Stefan Monnier says don't bother: - ;;"quasiquote" "quote" "unquote" "unquote-splicing" - "map" "syntax" "syntax-rules") t) - "\\>") 1) - ;; - ;; David Fox for SOS/STklos class specifiers. - '("\\<<\\sw+>\\>" . font-lock-type-face) - ;; - ;; Scheme `:' keywords as references. - '("\\<:\\sw+\\>" . font-lock-reference-face) - ))) - "Gaudy expressions to highlight in Scheme modes.") - -(defvar scheme-font-lock-keywords scheme-font-lock-keywords-1 - "Default expressions to highlight in Scheme modes.") - ;; TeX. ;(defvar tex-font-lock-keywords @@ -2018,7 +2039,7 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." ; '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}" ; 2 font-lock-function-name-face) ; ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}" -; 2 font-lock-reference-face) +; 2 font-lock-constant-face) ; ;; It seems a bit dubious to use `bold' and `italic' faces since we might ; ;; not be able to display those fonts. ; ("{\\\\bf\\([^}]+\\)}" 1 'bold keep) @@ -2029,7 +2050,7 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." ; '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}" ; 2 font-lock-function-name-face) ; ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}" -; 2 font-lock-reference-face) +; 2 font-lock-constant-face) ; ("^[ \t]*\\\\def\\\\\\(\\(\\w\\|@\\)+\\)" 1 font-lock-function-name-face) ; "\\\\\\([a-zA-Z@]+\\|.\\)" ; ;; It seems a bit dubious to use `bold' and `italic' faces since we might @@ -2124,9 +2145,9 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." '("label" "ref" "pageref" "vref" "eqref") t)) (citations-opt (regexp-opt - '("cite" "caption" "index" "glossary" + '("cite" "nocite" "caption" "index" "glossary" "footnote" "footnotemark" "footnotetext") - t)) + t)) ;; ;; Names of commands that should be fontified. (specials (regexp-opt @@ -2149,10 +2170,10 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." ;; Citation args. (list (concat slash citations arg) (+ (regexp-opt-depth citations) arg-depth) - 'font-lock-reference-face) + 'font-lock-constant-face) (list (concat slash citations-opt opt arg) (+ (regexp-opt-depth citations-opt) opt-depth arg-depth) - 'font-lock-reference-face) + 'font-lock-constant-face) ;; ;; Command names, special and general. (cons (concat slash specials) 'font-lock-warning-face) @@ -2171,9 +2192,9 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." '(quote bold-italic) 'keep) ;; ;; Old-style bf/em/it/sl. Stop at `\\' and un-escaped `&', for tables. - (list (concat "\\\\\\(\\(bf\\)\\|em\\|it\\(em\\)?\\|sl\\)\\>" + (list (concat "\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>" "\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)") - 4 '(if (match-beginning 2) 'bold 'italic) 'keep) + 3 '(if (match-beginning 2) 'bold 'italic) 'keep) )))) "Gaudy expressions to highlight in TeX modes.") @@ -2202,7 +2223,19 @@ 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 '("string") +(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") "*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 @@ -2222,10 +2255,11 @@ 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+") +(defcustom java-font-lock-extra-types + '("[A-Z\300-\326\330-\337]\\sw*[a-z]\\sw*") "*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+\") means capitalised +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. The value of this variable is used when Font Lock mode is turned on." @@ -2262,18 +2296,28 @@ See also `c-font-lock-extra-types'.") (let* ((c-keywords (eval-when-compile (regexp-opt '("break" "continue" "do" "else" "for" "if" "return" - "switch" "while") t))) - (c-type-types + "switch" "while" "sizeof" + ;; Type related, but we don't do anything special. + "typedef" "extern" "auto" "register" "static" + "volatile" "const" + ;; Dan Nicolaescu says this is new. + "restrict") t))) + (c-type-specs + (eval-when-compile + (regexp-opt '("enum" "struct" "union") t))) + (c-type-specs-depth + (regexp-opt-depth c-type-specs)) + (c-type-names `(mapconcat 'identity (cons (,@ (eval-when-compile (regexp-opt - '("auto" "extern" "register" "static" "typedef" "struct" - "union" "enum" "signed" "unsigned" "short" "long" - "int" "char" "float" "double" "void" "volatile" "const")))) + '("char" "short" "int" "long" "signed" "unsigned" + "float" "double" "void" "complex")))) c-font-lock-extra-types) "\\|")) - (c-type-depth `(regexp-opt-depth (,@ c-type-types))) + (c-type-names-depth + `(regexp-opt-depth (,@ c-type-names))) ) (setq c-font-lock-keywords-1 (list @@ -2288,7 +2332,7 @@ See also `c-font-lock-extra-types'.") '("^#[ \t]*error[ \t]+\\(.+\\)" 1 font-lock-warning-face prepend) ;; ;; Fontify filenames in #include <...> preprocessor directives as strings. - '("^#[ \t]*\\(import\\|include\\)[ \t]+\\(<[^>\"\n]*>?\\)" + '("^#[ \t]*\\(import\\|include\\)[ \t]*\\(<[^>\"\n]*>?\\)" 2 font-lock-string-face) ;; ;; Fontify function macro names. @@ -2297,11 +2341,11 @@ See also `c-font-lock-extra-types'.") ;; Fontify symbol names in #elif or #if ... defined preprocessor directives. '("^#[ \t]*\\(elif\\|if\\)\\>" ("\\<\\(defined\\)\\>[ \t]*(?\\(\\sw+\\)?" nil nil - (1 font-lock-reference-face) (2 font-lock-variable-name-face nil t))) + (1 font-lock-builtin-face) (2 font-lock-variable-name-face nil t))) ;; ;; Fontify otherwise as symbol names, and the preprocessor directive names. - '("^#[ \t]*\\(\\sw+\\)\\>[ \t]*\\(\\sw+\\)?" - (1 font-lock-reference-face) (2 font-lock-variable-name-face nil t)) + '("^#[ \t]*\\(\\sw+\\)\\>[ \t!]*\\(\\sw+\\)?" + (1 font-lock-builtin-face) (2 font-lock-variable-name-face nil t)) )) (setq c-font-lock-keywords-2 @@ -2310,21 +2354,22 @@ See also `c-font-lock-extra-types'.") ;; ;; Simple regexps for speed. ;; - ;; Fontify all type specifiers. + ;; Fontify all type names. `(eval . - (cons (concat "\\<\\(" (,@ c-type-types) "\\)\\>") 'font-lock-type-face)) + (cons (concat "\\<\\(" (,@ c-type-names) "\\)\\>") 'font-lock-type-face)) ;; ;; Fontify all builtin keywords (except case, default and goto; see below). - (concat "\\<" c-keywords "\\>") + (concat "\\<\\(" c-keywords "\\|" c-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-reference-face nil t)) - ;; Anders Lindgren points out that it is quicker to use - ;; MATCH-ANCHORED to effectively anchor the regexp on the left. - '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:" + (1 font-lock-keyword-face) (2 font-lock-constant-face nil t)) + ;; Anders Lindgren 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]*$" (beginning-of-line) (end-of-line) - (1 font-lock-reference-face))) + (1 font-lock-constant-face))) ))) (setq c-font-lock-keywords-3 @@ -2334,15 +2379,16 @@ See also `c-font-lock-extra-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. + ;; Fontify all storage types, plus their items. `(eval . - (list (concat "\\<\\(" (,@ c-type-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-depth) 2)) + (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)) @@ -2351,13 +2397,24 @@ See also `c-font-lock-extra-types'.") 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 nil + ;; 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 - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face)))) + (1 font-lock-type-face))) ;; ;; Fontify anything at beginning of line as a declaration or definition. '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*" @@ -2403,7 +2460,7 @@ See also `c++-font-lock-extra-types'.") ;; This is `c++-type-spec' from below. (Hint hint!) "\\(\\sw+\\)" ; The instance? "\\([ \t]*<\\([^>\n]+\\)[ \t*&]*>\\)?" ; Or template? - "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)?" ; Or member? + "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)*" ; Or member? ;; Match any trailing parenthesis. "[ \t]*\\((\\)?"))) (save-match-data @@ -2422,10 +2479,17 @@ See also `c++-font-lock-extra-types'.") (eval-when-compile (regexp-opt '("break" "continue" "do" "else" "for" "if" "return" "switch" - "while" "asm" "catch" "delete" "new" "operator" "sizeof" "this" - "throw" "try" - ;; Eric Hopper says these are new. - "static_cast" "dynamic_cast" "const_cast" "reinterpret_cast") t))) + "while" "asm" "catch" "delete" "new" "sizeof" "this" "throw" "try" + "typeid" + ;; Branko Cibej says this is new. + "export" + ;; Mark Mitchell says these are new. + "mutable" "explicit" + ;; Alain Picard suggests treating these + ;; as keywords not types. + "typedef" "template" + "extern" "auto" "register" "const" "volatile" "static" + "inline" "friend" "virtual") t))) (c++-operators (eval-when-compile (regexp-opt @@ -2433,30 +2497,40 @@ See also `c++-font-lock-extra-types'.") '("+" "-" "*" "/" "%" "^" "&" "|" "~" "!" "=" "<" ">" "+=" "-=" "*=" "/=" "%=" "^=" "&=" "|=" "<<" ">>" ">>=" "<<=" "==" "!=" "<=" ">=" "&&" "||" "++" "--" "->*" "," "->" "[]" "()")))) - (c++-type-types + (c++-type-specs + (eval-when-compile + (regexp-opt + '("class" "public" "private" "protected" "typename" + "struct" "union" "enum" "namespace" "using" + ;; Eric Hopper 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 - '("auto" "extern" "register" "static" "typedef" "struct" - "union" "enum" "signed" "unsigned" "short" "long" - "int" "char" "float" "double" "void" "volatile" "const" - "inline" "friend" "bool" "virtual" "complex" "template" - "namespace" "using")))) + '("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]+\\)[ \t*&]*>\\)?" - "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)?")) + "\\([ \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-types) (,@ c++-type-suffix)))) + (concat (,@ c++-type-names) (,@ c++-type-suffix)))) ) (setq c++-font-lock-keywords-1 (append @@ -2465,22 +2539,12 @@ See also `c++-font-lock-extra-types'.") (cdr c-font-lock-keywords-1) (list ;; - ;; Class names etc. - (list (concat "\\<\\(class\\|public\\|private\\|protected\\)\\>[ \t]*" - "\\(" c++-type-spec "\\)?") - '(1 font-lock-type-face) - '(3 (if (match-beginning 6) - font-lock-type-face - font-lock-function-name-face) nil t) - '(5 font-lock-function-name-face nil t) - '(7 font-lock-function-name-face nil t)) - ;; ;; 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-function-name-face nil t) + '(3 font-lock-type-face nil t) '(5 font-lock-function-name-face nil t)) ))) @@ -2490,7 +2554,7 @@ See also `c++-font-lock-extra-types'.") ;; ;; The list `c-font-lock-keywords-2' for C++ plus operator overloading. `(eval . - (cons (concat "\\<\\(" (,@ c++-type-types) "\\)\\>") + (cons (concat "\\<\\(" (,@ c++-type-names) "\\)\\>") 'font-lock-type-face)) ;; ;; Fontify operator overloading. @@ -2500,16 +2564,17 @@ See also `c++-font-lock-extra-types'.") ;; ;; Fontify case/goto keywords and targets, and case default/goto tags. '("\\<\\(case\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?" - (1 font-lock-keyword-face) (2 font-lock-reference-face nil t)) + (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]*:\\($\\|[^:]\\)" (beginning-of-line) (end-of-line) - (1 font-lock-reference-face))) + (1 font-lock-constant-face))) ;; ;; Fontify other builtin keywords. - (concat "\\<" c++-keywords "\\>") + (concat "\\<\\(" c++-keywords "\\|" c++-type-specs "\\)\\>") ;; ;; Eric Hopper says `true' and `false' are new. - '("\\<\\(false\\|true\\)\\>" . font-lock-reference-face) + '("\\<\\(false\\|true\\)\\>" . font-lock-constant-face) ))) (setq c++-font-lock-keywords-3 @@ -2520,8 +2585,10 @@ See also `c++-font-lock-extra-types'.") ;; ;; Fontify all storage classes and type specifiers, plus their items. `(eval . - (list (concat "\\<\\(" (,@ c++-type-types) "\\)\\>" (,@ c++-type-suffix) + (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) ;; Fontify each declaration item. (list 'font-lock-match-c++-style-declaration-item-and-skip-to-next ;; Start with point after all type specifiers. @@ -2533,20 +2600,48 @@ See also `c++-font-lock-extra-types'.") ;; Fontify as a variable or function name. '(1 (cond ((or (match-beginning 2) (match-beginning 4)) font-lock-type-face) - ((match-beginning 6) font-lock-function-name-face) - (t font-lock-variable-name-face))) - '(3 font-lock-function-name-face nil t) + ((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)) + )) + ;; ;; 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 - (1 (if (match-beginning 6) - font-lock-function-name-face - font-lock-variable-name-face)))) + (1 font-lock-type-face))) ;; ;; Fontify anything at beginning of line as a declaration or definition. (list (concat "^\\(" c++-type-spec "[ \t*&]*\\)+") @@ -2557,7 +2652,7 @@ See also `c++-font-lock-extra-types'.") font-lock-type-face) ((match-beginning 6) font-lock-function-name-face) (t font-lock-variable-name-face))) - (3 font-lock-function-name-face nil t) + (3 font-lock-type-face nil t) (5 (if (match-beginning 6) font-lock-function-name-face font-lock-variable-name-face) nil t))) @@ -2586,19 +2681,28 @@ See also `objc-font-lock-extra-types'.") (let* ((objc-keywords (eval-when-compile (regexp-opt '("break" "continue" "do" "else" "for" "if" "return" - "switch" "while" "sizeof" "self" "super") t))) - (objc-type-types + "switch" "while" "sizeof" "self" "super" + "typedef" "auto" "extern" "static" + "volatile" "const") t))) + (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 - '("auto" "extern" "register" "static" "typedef" "struct" - "union" "enum" "signed" "unsigned" "short" "long" - "int" "char" "float" "double" "void" "volatile" "const" - "id" "oneway" "in" "out" "inout" "bycopy" "byref")))) + '("signed" "unsigned" "short" "long" + "int" "char" "float" "double" "void" + "id")))) objc-font-lock-extra-types) "\\|")) - (objc-type-depth `(regexp-opt-depth (,@ objc-type-types))) + (objc-type-names-depth + `(regexp-opt-depth (,@ objc-type-names))) ) (setq objc-font-lock-keywords-1 (append @@ -2610,26 +2714,23 @@ See also `objc-font-lock-extra-types'.") ;; Fontify compiler directives. '("@\\(\\sw+\\)\\>" (1 font-lock-keyword-face) - ("\\=[ \t:<(,]*\\(\\sw+\\)" nil nil - (1 font-lock-function-name-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-type-face nil t) - (3 font-lock-type-face nil t) - (4 font-lock-function-name-face) - ("\\=[ \t]*\\(\\sw+\\)?:[ \t]*\\((\\([^)\n]+\\))\\)?[ \t]*\\(\\sw+\\)" + '("^[+-][ \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-type-face nil t) - (4 font-lock-variable-name-face))) + (3 font-lock-variable-name-face))) ;; Second, on lines following the function declaration. - '(":" ("^[ \t]*\\(\\sw+\\)?:[ \t]*\\((\\([^)\n]+\\))\\)?[ \t]*\\(\\sw+\\)" + '(":" ("^[ \t]*\\(\\sw+\\)?:[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)" (beginning-of-line) (end-of-line) (1 font-lock-function-name-face nil t) - (3 font-lock-type-face nil t) - (4 font-lock-variable-name-face))) + (3 font-lock-variable-name-face))) ))) (setq objc-font-lock-keywords-2 @@ -2640,22 +2741,23 @@ See also `objc-font-lock-extra-types'.") ;; ;; Fontify all type specifiers. `(eval . - (cons (concat "\\<\\(" (,@ objc-type-types) "\\)\\>") + (cons (concat "\\<\\(" (,@ objc-type-names) "\\)\\>") 'font-lock-type-face)) ;; ;; Fontify all builtin keywords (except case, default and goto; see below). - (concat "\\<" objc-keywords "\\>") + (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-reference-face nil t)) + (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-reference-face))) + (1 font-lock-constant-face))) ;; ;; Fontify null object pointers. - '("\\<\\(Nil\\|nil\\)\\>" 1 font-lock-reference-face) + '("\\<[Nn]il\\>" . font-lock-constant-face) ))) (setq objc-font-lock-keywords-3 @@ -2667,14 +2769,15 @@ See also `objc-font-lock-extra-types'.") ;; ;; Fontify all storage classes and type specifiers, plus their items. `(eval . - (list (concat "\\<\\(" (,@ objc-type-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-depth) 2)) - '(match-end 1))) + (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. @@ -2682,13 +2785,26 @@ See also `objc-font-lock-extra-types'.") 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))) + )) + ;; ;; 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 - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face)))) + (1 font-lock-type-face))) ;; ;; Fontify anything at beginning of line as a declaration or definition. '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*" @@ -2718,86 +2834,83 @@ See also `java-font-lock-extra-types'.") "Gaudy level highlighting for Java mode. See also `java-font-lock-extra-types'.") -;; Regexps written with help from Fred White and -;; Anders Lindgren . +;; Regexps written with help from Fred White , +;; Anders Lindgren and Carl Manning . (let* ((java-keywords (eval-when-compile (regexp-opt '("catch" "do" "else" "super" "this" "finally" "for" "if" - ;; Anders Lindgren says these have gone. + ;; Anders Lindgren says these have gone. ;; "cast" "byvalue" "future" "generic" "operator" "var" ;; "inner" "outer" "rest" + "implements" "extends" "throws" "instanceof" "new" "interface" "return" "switch" "throw" "try" "while") t))) ;; - ;; These are immediately followed by an object name. - (java-minor-types - (eval-when-compile - (regexp-opt '("boolean" "char" "byte" "short" "int" "long" - "float" "double" "void")))) + ;; 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-major-types + (java-type-specs (eval-when-compile (regexp-opt '("abstract" "const" "final" "synchronized" "transient" "static" - ;; Anders Lindgren says this has gone. + ;; Anders Lindgren says this has gone. ;; "threadsafe" - "volatile" "public" "private" "protected" "native")))) - ;; - ;; Random types immediately followed by an object name. - (java-other-types - '(mapconcat 'identity (cons "\\sw+\\.\\sw+" java-font-lock-extra-types) - "\\|")) - (java-other-depth `(regexp-opt-depth (,@ java-other-types))) + "volatile" "public" "private" "protected" "native" + ;; Carl Manning says this is new. + "strictfp")))) ) (setq java-font-lock-keywords-1 (list ;; ;; Fontify class names. '("\\<\\(class\\)\\>[ \t]*\\(\\sw+\\)?" - (1 font-lock-type-face) (2 font-lock-function-name-face nil t)) + (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-reference-face nil t)) + (1 font-lock-keyword-face) + (2 font-lock-constant-face nil t) + ("\\=\\.\\(\\*\\|\\sw+\\)" nil nil + (1 font-lock-constant-face nil t))) )) (setq java-font-lock-keywords-2 (append java-font-lock-keywords-1 (list ;; - ;; Fontify all builtin type specifiers. - (cons (concat "\\<\\(" java-minor-types "\\|" java-major-types "\\)\\>") - 'font-lock-type-face) + ;; Fontify class names. + `(eval . + (cons (concat "\\<\\(" (,@ java-type-names) "\\)\\>[^.]") + '(1 font-lock-type-face))) ;; ;; Fontify all builtin keywords (except below). - (concat "\\<" java-keywords "\\>") + (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-reference-face nil t)) - '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:" + '(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-reference-face))) - ;; - ;; Fontify keywords and types; the first can be followed by a type list. - (list (concat "\\<\\(" - "implements\\|throws\\|" - "\\(extends\\|instanceof\\|new\\)" - "\\)\\>[ \t]*\\(\\sw+\\)?") - '(1 font-lock-keyword-face) '(3 font-lock-type-face nil t) - '("\\=[ \t]*,[ \t]*\\(\\sw+\\)" - (if (match-beginning 2) (goto-char (match-end 2))) nil - (1 font-lock-type-face))) + (1 font-lock-constant-face))) ;; ;; Fontify all constants. - '("\\<\\(false\\|null\\|true\\)\\>" . font-lock-reference-face) + '("\\<\\(false\\|null\\|true\\)\\>" . font-lock-constant-face) ;; ;; Javadoc tags within comments. '("@\\(author\\|exception\\|return\\|see\\|version\\)\\>" - (1 font-lock-reference-face prepend)) + (1 font-lock-constant-face prepend)) '("@\\(param\\)\\>[ \t]*\\(\\sw+\\)?" - (1 font-lock-reference-face prepend) + (1 font-lock-constant-face prepend) (2 font-lock-variable-name-face prepend t)) ))) @@ -2808,50 +2921,25 @@ See also `java-font-lock-extra-types'.") ;; We still have to fontify type specifiers individually, as Java is hairy. (list ;; - ;; Fontify random types in casts. - `(eval . - (list (concat "(\\(" (,@ java-other-types) "\\))" - "[ \t]*\\(\\sw\\|[\"\(]\\)") - ;; Fontify the type name. - '(1 font-lock-type-face))) - ;; ;; Fontify random types immediately followed by an item or items. `(eval . - (list (concat "\\<\\(" (,@ java-other-types) "\\)\\>" - "\\([ \t]*\\[[ \t]*\\]\\)*" - "[ \t]*\\sw") - ;; Fontify the type name. - '(1 font-lock-type-face))) - `(eval . - (list (concat "\\<\\(" (,@ java-other-types) "\\)\\>" + (list (concat "\\<\\(" (,@ java-type-names) "\\)\\>" "\\([ \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-other-depth) 3))) + (+ (,@ java-type-names-depth) 3))) (list 'goto-char (list 'match-beginning - (+ (,@ java-other-depth) 3))) + (+ (,@ 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 immediately followed by an item or items. - (list (concat "\\<\\(" java-minor-types "\\)\\>" - "\\([ \t]*\\[[ \t]*\\]\\)*") - ;; Fontify each declaration item. - '(font-lock-match-c-style-declaration-item-and-skip-to-next - ;; Start and finish with point after the type specifier. - nil (goto-char (match-end 0)) - ;; 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-major-types "\\)\\>" + (list (concat "\\<\\(" java-type-specs "\\)\\>" "\\([ \t]+\\sw+\\>" "\\([ \t]*\\[[ \t]*\\]\\)*" "\\)*") @@ -2875,7 +2963,7 @@ See also `java-font-lock-extra-types'.") ;; Install ourselves: (unless (assq 'font-lock-mode minor-mode-alist) - (push '(font-lock-mode " Font") minor-mode-alist)) + (push '(font-lock-mode nil) minor-mode-alist)) ;; Provide ourselves: