X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/2d63aa6734ae5696e9a15a1ec59a2315abdd6076..a1051b732b5997340eb2aa4ced6fc7a94bf5e0b1:/lisp/font-lock.el diff --git a/lisp/font-lock.el b/lisp/font-lock.el index 5186399ba3..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 @@ -60,16 +60,40 @@ ;; properties appropriately. ;; ;; Fontification normally involves syntactic (i.e., strings and comments) and -;; regexp (i.e., keywords and everything else) passes. The syntactic pass -;; involves a syntax table and a syntax parsing function to determine the -;; context of different parts of a region of text. It is necessary because -;; generally strings and/or comments can span lines, and so the context of a -;; given region is not necessarily apparent from the content of that region. -;; Because the regexp pass only works within a given region, it is not -;; generally appropriate for syntactic fontification. The regexp pass involves -;; searching for given regexps (or calling given functions) within the given -;; region. For each match of the regexp (or non-nil value of the called -;; function), `face' text properties are added appropriately. +;; regexp (i.e., keywords and everything else) passes. There are actually +;; three passes; (a) the syntactic keyword pass, (b) the syntactic pass and (c) +;; the keyword pass. Confused? +;; +;; The syntactic keyword pass places `syntax-table' text properties in the +;; buffer according to the variable `font-lock-syntactic-keywords'. It is +;; necessary because Emacs' syntax table is not powerful enough to describe all +;; the different syntactic constructs required by the sort of people who decide +;; that a single quote can be syntactic or not depending on the time of day. +;; (What sort of person could decide to overload the meaning of a quote?) +;; Obviously the syntactic keyword pass must occur before the syntactic pass. +;; +;; The syntactic pass places `face' text properties in the buffer according to +;; syntactic context, i.e., according to the buffer's syntax table and buffer +;; text's `syntax-table' text properties. It involves using a syntax parsing +;; function to determine the context of different parts of a region of text. A +;; syntax parsing function is necessary because generally strings and/or +;; comments can span lines, and so the context of a given region is not +;; necessarily apparent from the content of that region. Because the keyword +;; pass only works within a given region, it is not generally appropriate for +;; syntactic fontification. This is the first fontification pass that makes +;; changes visible to the user; it fontifies strings and comments. +;; +;; The keyword pass places `face' text properties in the buffer according to +;; the variable `font-lock-keywords'. It involves searching for given regexps +;; (or calling given search functions) within the given region. This is the +;; second fontification pass that makes changes visible to the user; it +;; fontifies language reserved words, etc. +;; +;; Oh, and the answer is, "Yes, obviously just about everything should be done +;; in a single syntactic pass, but the only syntactic parser available +;; understands only strings and comments." Perhaps one day someone will write +;; some syntactic parsers for common languages and a son-of-font-lock.el could +;; use them rather then relying so heavily on the keyword (regexp) pass. ;;; How Font Lock mode supports modes or is supported by modes: @@ -92,10 +116,9 @@ ;; See the documentation for the variable `font-lock-keywords'. ;; -;; Nasty regexps of the form "bar\\(\\|lo\\)\\|f\\(oo\\|u\\(\\|bar\\)\\)\\|lo" -;; are made thusly: (make-regexp '("foo" "fu" "fubar" "bar" "barlo" "lo")) for -;; efficiency. See /pub/gnu/emacs/elisp-archive/functions/make-regexp.el.Z on -;; archive.cis.ohio-state.edu for this and other functions not just by sm. +;; Efficient regexps for use as MATCHERs for `font-lock-keywords' and +;; `font-lock-syntactic-keywords' can be generated via the function +;; `regexp-opt', and their depth counted via the function `regexp-opt-depth'. ;;; Adding patterns for modes that already support Font Lock: @@ -183,14 +206,67 @@ ;;; Code: +;; Define core `font-lock' group. +(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 + "Faces for highlighting text." + :prefix "font-lock-" + :group 'font-lock) + +(defgroup font-lock-extra-types nil + "Extra mode-specific type names for highlighting declarations." + :group 'font-lock) + +;; Define support mode groups here to impose `font-lock' group order. +(defgroup fast-lock nil + "Font Lock support mode to cache fontification." + :link '(custom-manual "(emacs)Support Modes") + :load 'fast-lock + :group 'font-lock) + +(defgroup lazy-lock nil + "Font Lock support mode to fontify lazily." + :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. -(defvar font-lock-verbose (* 0 1024) - "*If non-nil, means show status messages for buffer fontification. -If a number, only buffers greater than this size have fontification messages.") - -;;;###autoload -(defvar font-lock-maximum-decoration t +(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. +If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE), +where MAJOR-MODE is a symbol or t (meaning the default). For example: + ((c-mode . 256000) (c++-mode . 256000) (rmail-mode . 1048576)) +means that the maximum size is 250K for buffers in C or C++ modes, one megabyte +for buffers in Rmail mode, and size is irrelevant otherwise." + :type '(choice (const :tag "none" nil) + (integer :tag "size") + (repeat :menu-tag "mode specific" :tag "mode specific" + :value ((t . nil)) + (cons :tag "Instance" + (radio :tag "Mode" + (const :tag "all" t) + (symbol :tag "name")) + (radio :tag "Size" + (const :tag "none" nil) + (integer :tag "size"))))) + :group 'font-lock) + +(defcustom font-lock-maximum-decoration t "*Maximum decoration level for fontification. If nil, use the default decoration (typically the minimum available). If t, use the maximum decoration available. @@ -199,57 +275,35 @@ If a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL), where MAJOR-MODE is a symbol or t (meaning the default). For example: ((c-mode . t) (c++-mode . 2) (t . 1)) means use the maximum decoration available for buffers in C mode, level 2 -decoration for buffers in C++ mode, and level 1 decoration otherwise.") - -;;;###autoload -(defvar font-lock-maximum-size (* 250 1024) - "*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. -If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE), -where MAJOR-MODE is a symbol or t (meaning the default). For example: - ((c-mode . 256000) (c++-mode . 256000) (rmail-mode . 1048576)) -means that the maximum size is 250K for buffers in C or C++ modes, one megabyte -for buffers in Rmail mode, and size is irrelevant otherwise.") +decoration for buffers in C++ mode, and level 1 decoration otherwise." + :type '(choice (const :tag "default" nil) + (const :tag "maximum" t) + (integer :tag "level" 1) + (repeat :menu-tag "mode specific" :tag "mode specific" + :value ((t . t)) + (cons :tag "Instance" + (radio :tag "Mode" + (const :tag "all" t) + (symbol :tag "name")) + (radio :tag "Decoration" + (const :tag "default" nil) + (const :tag "maximum" t) + (integer :tag "level" 1))))) + :group 'font-lock) + +(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) + (other :tag "always" t) + (integer :tag "size")) + :group 'font-lock) ;; Fontification variables: -;; Originally these variable values were face names such as `bold' etc. -;; Now we create our own faces, but we keep these variables for compatibility -;; and they give users another mechanism for changing face appearance. -;; We now allow a FACENAME in `font-lock-keywords' to be any expression that -;; returns a face. So the easiest thing is to continue using these variables, -;; rather than sometimes evaling FACENAME and sometimes not. sm. -(defvar font-lock-comment-face 'font-lock-comment-face - "Face to use for comments.") - -(defvar font-lock-string-face 'font-lock-string-face - "Face to use for strings.") - -(defvar font-lock-keyword-face 'font-lock-keyword-face - "Face to use for keywords.") - -(defvar font-lock-builtin-face 'font-lock-builtin-face - "Face to use for builtins.") - -(defvar font-lock-function-name-face 'font-lock-function-name-face - "Face to use for function names.") - -(defvar font-lock-variable-name-face 'font-lock-variable-name-face - "Face to use for variable names.") - -(defvar font-lock-type-face 'font-lock-type-face - "Face to use for type names.") - -(defvar font-lock-reference-face 'font-lock-reference-face - "Face to use for reference names.") - -(defvar font-lock-warning-face 'font-lock-warning-face - "Face to use for things that should stand out.") - (defvar font-lock-keywords nil - "*A list of the keywords to highlight. -Each element should be of the form: + "A list of the keywords to highlight. +Each element should have one of these forms: MATCHER (MATCHER . MATCH) @@ -264,20 +318,23 @@ 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). -MATCH is the subexpression of MATCHER to be highlighted. MATCH can be -calculated via the function `font-lock-keyword-depth'. FACENAME is an -expression whose value is the face name to use. FACENAME's default attributes -can be defined via the variable `font-lock-face-attributes'. +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 +name to use. Face default attributes can be modified via \\[customize]. OVERRIDE and LAXMATCH are flags. If OVERRIDE is t, existing fontification can be overwritten. If `keep', only parts not already fontified are highlighted. @@ -287,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, @@ -312,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 @@ -326,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. @@ -377,11 +436,12 @@ 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-comment-start-regexp', `font-lock-inhibit-thing-lock' and -`font-lock-maximum-size'.") +`font-lock-inhibit-thing-lock' and `font-lock-maximum-size'.") ;; This variable is used where font-lock.el itself supplies the keywords. (defvar font-lock-defaults-alist @@ -392,45 +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 - (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") (?~ . "w")) beginning-of-defun - (font-lock-comment-start-regexp . "/[*/]") + nil nil ((?_ . "w")) beginning-of-defun (font-lock-mark-block-function . mark-defun))) (objc-mode-defaults '((objc-font-lock-keywords objc-font-lock-keywords-1 objc-font-lock-keywords-2 objc-font-lock-keywords-3) nil nil ((?_ . "w") (?$ . "w")) nil - (font-lock-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 - (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 - (font-lock-comment-start-regexp . ";") - (font-lock-mark-block-function . mark-defun))) - (scheme-mode-defaults - '(scheme-font-lock-keywords - nil t (("+-*/.<>=!?$%_&~^:" . "w")) beginning-of-defun - (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 nil nil ((?$ . "\"")) nil - (font-lock-comment-start-regexp . "%") + '((tex-font-lock-keywords + tex-font-lock-keywords-1 tex-font-lock-keywords-2) + nil nil ((?$ . "\"")) nil (font-lock-mark-block-function . mark-paragraph))) ) (list @@ -439,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. @@ -468,6 +516,41 @@ This is normally set via `font-lock-defaults'.") "*Non-nil means the patterns in `font-lock-keywords' are case-insensitive. This is normally set via `font-lock-defaults'.") +(defvar font-lock-syntactic-keywords nil + "A list of the syntactic keywords to highlight. +Can be the list or the name of a function or variable whose value is the list. +See `font-lock-keywords' for a description of the form of this list; +the differences are listed below. MATCH-HIGHLIGHT should be of the form: + + (MATCH SYNTAX OVERRIDE LAXMATCH) + +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 "Non-nil means use this syntax table for fontifying. If this is nil, the major mode's syntax table is used. @@ -488,13 +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'.") -(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'.") @@ -517,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. @@ -539,14 +615,20 @@ This is normally set via `font-lock-defaults'.") (defmacro save-buffer-state (varlist &rest body) "Bind variables according to VARLIST and eval BODY restoring buffer state." (` (let* ((,@ (append varlist - '((modified (buffer-modified-p)) - (inhibit-read-only t) (buffer-undo-list t) + '((modified (buffer-modified-p)) (buffer-undo-list t) + (inhibit-read-only t) (inhibit-point-motion-hooks t) before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename)))) (,@ 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) @@ -595,11 +677,9 @@ To fontify a block (the function or paragraph containing point, or a number of lines around point), perhaps because modification on the current line caused syntactic change on other lines, you can use \\[font-lock-fontify-block]. -The default Font Lock mode faces and their attributes are defined in the -variable `font-lock-face-attributes', and Font Lock mode default settings in -the variable `font-lock-defaults-alist'. You can set your own default settings -for some mode, by setting a buffer local value for `font-lock-defaults', via -its mode hook." +See the variable `font-lock-defaults-alist' for the Font Lock mode default +settings. You can set your own default settings for some mode, by setting a +buffer local value for `font-lock-defaults', via its mode hook." (interactive "P") ;; Don't turn on Font Lock mode if we don't have a display (we're running a ;; batch job) or if the buffer is invisible (the name starts with a space). @@ -636,7 +716,7 @@ 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 @@ -734,19 +814,6 @@ see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types', ;; would also be contrary to the Principle of Least Surprise. sm. (defvar font-lock-buffers nil) ; For remembering buffers. -(defvar global-font-lock-mode nil) - -;;;###autoload -(defvar font-lock-global-modes t - "*Modes for which Font Lock mode is automagically turned on. -Global Font Lock mode is controlled by the `global-font-lock-mode' command. -If nil, means no modes have Font Lock mode automatically turned on. -If t, all modes that support Font Lock mode have it automatically turned on. -If a list, it should be a list of `major-mode' symbol names for which Font Lock -mode should be automatically turned on. The sense of the list is negated if it -begins with `not'. For example: - (c-mode c++-mode) -means that Font Lock mode is turned on for buffers in C and C++ modes only.") ;;;###autoload (defun global-font-lock-mode (&optional arg message) @@ -758,17 +825,58 @@ 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))) + +;; 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'. +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) + +(defcustom font-lock-global-modes t + "*Modes for which Font Lock mode is automagically turned on. +Global Font Lock mode is controlled by the `global-font-lock-mode' command. +If nil, means no modes have Font Lock mode automatically turned on. +If t, all modes that support Font Lock mode have it automatically turned on. +If a list, it should be a list of `major-mode' symbol names for which Font Lock +mode should be automatically turned on. The sense of the list is negated if it +begins with `not'. For example: + (c-mode c++-mode) +means that Font Lock mode is turned on for buffers in C and C++ modes only." + :type '(choice (const :tag "none" nil) + (const :tag "all" t) + (set :menu-tag "mode specific" :tag "modes" + :value (not) + (const :tag "Except" not) + (repeat :inline t (symbol :tag "mode")))) + :group 'font-lock) (defun font-lock-change-major-mode () ;; Turn off Font Lock mode if it's on. @@ -813,12 +921,12 @@ turned on in a buffer if its major mode is one of `font-lock-global-modes'." ;; `font-lock-after-fontify-buffer' and/or `font-lock-after-unfontify-buffer' ;; themselves. -;;;###autoload -(defvar 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), @@ -827,33 +935,59 @@ where MAJOR-MODE is a symbol or t (meaning the default). For example: means that Fast Lock mode is used to support Font Lock mode for buffers in C or C++ modes, and Lazy Lock mode is used to support Font Lock mode otherwise. -The value of this variable is used when Font Lock mode is turned on.") +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 "Support" + (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))) + )) + :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)))) @@ -889,14 +1023,14 @@ The value of this variable is used when Font Lock mode is turned on.") ;; A further reason to use the fontification indirection feature is when the ;; default syntactual fontification, or the default fontification in general, ;; is not flexible enough for a particular major mode. For example, perhaps -;; comments are just too hairy for `font-lock-fontify-syntactically-region' and -;; `font-lock-comment-start-regexp' to cope with. You need to write your own -;; version of that function, e.g., `hairy-fontify-syntactically-region', and -;; make your own version of `hairy-fontify-region' call it before calling +;; comments are just too hairy for `font-lock-fontify-syntactically-region' to +;; cope with. You need to write your own version of that function, e.g., +;; `hairy-fontify-syntactically-region', and make your own version of +;; `hairy-fontify-region' call that function before calling ;; `font-lock-fontify-keywords-region' for the normal regexp fontification ;; pass. And Hairy mode would set `font-lock-defaults' so that font-lock.el ;; would call your region fontification function instead of its own. For -;; example, TeX modes could fontify {\foo ...} and \bar{...} etc. multi-line +;; example, TeX modes could fontify {\foo ...} and \bar{...} etc. multi-line ;; directives correctly and cleanly. (It is the same problem as fontifying ;; multi-line strings and comments; regexps are not appropriate for the job.) @@ -920,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. @@ -951,15 +1084,29 @@ The value of this variable is used when Font Lock mode is turned on.") (setq font-lock-fontified nil))) (defun font-lock-default-fontify-region (beg end loudly) - (save-buffer-state ((old-syntax-table (syntax-table))) + (save-buffer-state + ((parse-sexp-lookup-properties font-lock-syntactic-keywords) + (old-syntax-table (syntax-table))) (unwind-protect (save-restriction (widen) ;; 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 + (font-lock-fontify-syntactic-keywords-region beg end)) (unless font-lock-keywords-only (font-lock-fontify-syntactically-region beg end loudly)) (font-lock-fontify-keywords-region beg end loudly)) @@ -976,16 +1123,20 @@ 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)))) + (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) - (save-excursion - (save-match-data - ;; Rescan between start of lines enclosing the region. - (font-lock-fontify-region - (progn (goto-char beg) (beginning-of-line) (point)) - (progn (goto-char end) (forward-line 1) (point)))))) + (let ((inhibit-point-motion-hooks t)) + (save-excursion + (save-match-data + ;; Rescan between start of lines enclosing the region. + (font-lock-fontify-region + (progn (goto-char beg) (beginning-of-line) (point)) + (progn (goto-char end) (forward-line 1) (point))))))) (defun font-lock-fontify-block (&optional arg) "Fontify some lines the way `font-lock-fontify-buffer' would. @@ -995,7 +1146,8 @@ no ARG is given and `font-lock-mark-block-function' is nil. If `font-lock-mark-block-function' non-nil and no ARG is given, it is used to delimit the region to fontify." (interactive "P") - (let (font-lock-beginning-of-syntax-function deactivate-mark) + (let ((inhibit-point-motion-hooks t) font-lock-beginning-of-syntax-function + deactivate-mark) ;; Make sure we have the right `font-lock-keywords' etc. (if (not font-lock-mode) (font-lock-set-defaults)) (save-excursion @@ -1014,120 +1166,6 @@ delimit the region to fontify." ;;; End of Fontification functions. -;;; Syntactic fontification functions. - -;; These record the parse state at a particular position, always the start of a -;; line. Used to make `font-lock-fontify-syntactically-region' faster. -;; Previously, `font-lock-cache-position' was just a buffer position. However, -;; under certain situations, this occasionally resulted in mis-fontification. -;; I think the "situations" were deletion with Lazy Lock mode's deferral. sm. -(defvar font-lock-cache-state nil) -(defvar font-lock-cache-position nil) - -(defun font-lock-fontify-syntactically-region (start end &optional loudly) - "Put proper face on each string and comment between START and END. -START should be at the beginning of a line." - (let ((synstart (cond (font-lock-comment-start-regexp - (concat "\\s\"\\|" font-lock-comment-start-regexp)) - (comment-start-skip - (concat "\\s\"\\|" comment-start-skip)) - (t - "\\s\""))) - (cache (marker-position font-lock-cache-position)) - state prev here beg) - (if loudly (message "Fontifying %s... (syntactically...)" (buffer-name))) - (goto-char start) - ;; - ;; Find the state at the `beginning-of-line' before `start'. - (if (eq start cache) - ;; Use the cache for the state of `start'. - (setq state font-lock-cache-state) - ;; Find the state of `start'. - (if (null font-lock-beginning-of-syntax-function) - ;; Use the state at the previous cache position, if any, or - ;; otherwise calculate from `point-min'. - (if (or (null cache) (< start cache)) - (setq state (parse-partial-sexp (point-min) start)) - (setq state (parse-partial-sexp cache start nil nil - font-lock-cache-state))) - ;; Call the function to move outside any syntactic block. - (funcall font-lock-beginning-of-syntax-function) - (setq state (parse-partial-sexp (point) start))) - ;; Cache the state and position of `start'. - (setq font-lock-cache-state state) - (set-marker font-lock-cache-position start)) - ;; - ;; If the region starts inside a string, show the extent of it. - (when (nth 3 state) - (setq here (point)) - (while (and (re-search-forward "\\s\"" end 'move) - ;; Verify the state so we don't get fooled by quoting. - (nth 3 (parse-partial-sexp here (point) nil nil state)))) - (put-text-property here (point) 'face font-lock-string-face) - (setq state (parse-partial-sexp here (point) nil nil state))) - ;; - ;; Likewise for a comment. - (when (or (nth 4 state) (nth 7 state)) - (let ((comstart (cond (font-lock-comment-start-regexp - font-lock-comment-start-regexp) - (comment-start-skip - (concat "\\s<\\|" comment-start-skip)) - (t - "\\s<"))) - (count 1)) - (setq here (point)) - (condition-case nil - (save-restriction - (narrow-to-region (point-min) end) - ;; Go back to the real start of the comment. - (re-search-backward comstart) - (forward-comment 1) - ;; If there is more than one comment type, then the previous - ;; comment start might not be the real comment start. - ;; For example, in C++ code, `here' might be on a line following - ;; a // comment that is actually within a /* */ comment. - (while (<= (point) here) - (goto-char here) - (re-search-backward comstart nil nil (incf count)) - (forward-comment 1)) - ;; Go back to the real end of the comment. - (skip-chars-backward " \t")) - (error (goto-char end))) - (put-text-property here (point) 'face font-lock-comment-face) - (setq state (parse-partial-sexp here (point) nil nil state)))) - ;; - ;; Find each interesting place between here and `end'. - (while (and (< (point) end) - (setq prev (point)) - (re-search-forward synstart end t) - (setq state (parse-partial-sexp prev (point) nil nil state))) - (cond ((nth 3 state) - ;; - ;; Found a real string start. - (setq here (point) beg (match-beginning 0)) - (condition-case nil - (save-restriction - (narrow-to-region (point-min) end) - (goto-char (scan-sexps beg 1))) - (error (goto-char end))) - (put-text-property beg (point) 'face font-lock-string-face) - (setq state (parse-partial-sexp here (point) nil nil state))) - ((or (nth 4 state) (nth 7 state)) - ;; - ;; Found a real comment start. - (setq here (point) beg (or (match-end 1) (match-beginning 0))) - (goto-char beg) - (condition-case nil - (save-restriction - (narrow-to-region (point-min) end) - (forward-comment 1) - (skip-chars-backward " \t")) - (error (goto-char end))) - (put-text-property beg (point) 'face font-lock-comment-face) - (setq state (parse-partial-sexp here (point) nil nil state))))))) - -;;; End of Syntactic fontification functions. - ;;; Additional text property functions. ;; The following text property functions should be builtins. This means they @@ -1209,7 +1247,162 @@ Optional argument OBJECT is the string or buffer containing the text." ;;; End of Additional text property functions. -;;; Regexp fontification functions. +;;; Syntactic regexp fontification functions. + +;; These syntactic keyword pass functions are identical to those keyword pass +;; functions below, with the following exceptions; (a) they operate on +;; `font-lock-syntactic-keywords' of course, (b) they are all `defun' as speed +;; is less of an issue, (c) eval of property value does not occur JIT as speed +;; is less of an issue, (d) OVERRIDE cannot be `prepend' or `append' as it +;; makes no sense for `syntax-table' property values, (e) they do not do it +;; LOUDLY as it is not likely to be intensive. + +(defun font-lock-apply-syntactic-highlight (highlight) + "Apply HIGHLIGHT following a match. +HIGHLIGHT should be of the form MATCH-HIGHLIGHT, +see `font-lock-syntactic-keywords'." + (let* ((match (nth 0 highlight)) + (start (match-beginning match)) (end (match-end match)) + (value (nth 1 highlight)) + (override (nth 2 highlight))) + (unless (numberp (car-safe value)) + (setq value (eval value))) + (cond ((not start) + ;; No match but we might not signal an error. + (or (nth 3 highlight) + (error "No match %d in highlight %S" match highlight))) + ((not override) + ;; Cannot override existing fontification. + (or (text-property-not-all start end 'syntax-table nil) + (put-text-property start end 'syntax-table value))) + ((eq override t) + ;; Override existing fontification. + (put-text-property start end 'syntax-table value)) + ((eq override 'keep) + ;; Keep existing fontification. + (font-lock-fillin-text-property start end 'syntax-table value))))) + +(defun font-lock-fontify-syntactic-anchored-keywords (keywords limit) + "Fontify according to KEYWORDS until LIMIT. +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 + ;; 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)))) + (save-match-data + ;; Find an occurrence of `matcher' before `limit'. + (while (if (stringp matcher) + (re-search-forward matcher limit t) + (funcall matcher limit)) + ;; Apply each highlight to this instance of `matcher'. + (setq highlights lowdarks) + (while highlights + (font-lock-apply-syntactic-highlight (car highlights)) + (setq highlights (cdr highlights))))) + ;; Evaluate POST-MATCH-FORM. + (eval (nth 2 keywords)))) + +(defun font-lock-fontify-syntactic-keywords-region (start end) + "Fontify according to `font-lock-syntactic-keywords' between START and END. +START should be at the beginning of a line." + ;; If `font-lock-syntactic-keywords' is a symbol, get the real keywords. + (when (symbolp font-lock-syntactic-keywords) + (setq font-lock-syntactic-keywords (font-lock-eval-keywords + font-lock-syntactic-keywords))) + ;; If `font-lock-syntactic-keywords' is not compiled, compile it. + (unless (eq (car font-lock-syntactic-keywords) t) + (setq font-lock-syntactic-keywords (font-lock-compile-keywords + font-lock-syntactic-keywords))) + ;; Get down to business. + (let ((case-fold-search font-lock-keywords-case-fold-search) + (keywords (cdr font-lock-syntactic-keywords)) + keyword matcher highlights) + (while keywords + ;; 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)) + ;; Apply each highlight to this instance of `matcher', which may be + ;; specific highlights or more keywords anchored to `matcher'. + (setq highlights (cdr keyword)) + (while highlights + (if (numberp (car (car highlights))) + (font-lock-apply-syntactic-highlight (car highlights)) + (font-lock-fontify-syntactic-anchored-keywords (car highlights) + end)) + (setq highlights (cdr highlights)))) + (setq keywords (cdr keywords))))) + +;;; End of Syntactic regexp fontification functions. + +;;; Syntactic fontification functions. + +;; These record the parse state at a particular position, always the start of a +;; line. Used to make `font-lock-fontify-syntactically-region' faster. +;; Previously, `font-lock-cache-position' was just a buffer position. However, +;; under certain situations, this occasionally resulted in mis-fontification. +;; I think the "situations" were deletion with Lazy Lock mode's deferral. sm. +(defvar font-lock-cache-state nil) +(defvar font-lock-cache-position nil) + +(defun font-lock-fontify-syntactically-region (start end &optional loudly) + "Put proper face on each string and comment between START and END. +START should be at the beginning of a line." + (let ((cache (marker-position font-lock-cache-position)) + state string beg) + (if loudly (message "Fontifying %s... (syntactically...)" (buffer-name))) + (goto-char start) + ;; + ;; Find the state at the `beginning-of-line' before `start'. + (if (eq start cache) + ;; Use the cache for the state of `start'. + (setq state font-lock-cache-state) + ;; Find the state of `start'. + (if (null font-lock-beginning-of-syntax-function) + ;; Use the state at the previous cache position, if any, or + ;; otherwise calculate from `point-min'. + (if (or (null cache) (< start cache)) + (setq state (parse-partial-sexp (point-min) start)) + (setq state (parse-partial-sexp cache start nil nil + font-lock-cache-state))) + ;; Call the function to move outside any syntactic block. + (funcall font-lock-beginning-of-syntax-function) + (setq state (parse-partial-sexp (point) start))) + ;; Cache the state and position of `start'. + (setq font-lock-cache-state state) + (set-marker font-lock-cache-position start)) + ;; + ;; If the region starts inside a string or comment, show the extent of it. + (when (or (nth 3 state) (nth 4 state)) + (setq string (nth 3 state) beg (point)) + (setq state (parse-partial-sexp (point) end nil nil state 'syntax-table)) + (put-text-property beg (point) 'face + (if string + font-lock-string-face + font-lock-comment-face))) + ;; + ;; Find each interesting place between here and `end'. + (while (and (< (point) end) + (progn + (setq state (parse-partial-sexp (point) end nil nil state + 'syntax-table)) + (or (nth 3 state) (nth 4 state)))) + (setq string (nth 3 state) beg (nth 8 state)) + (setq state (parse-partial-sexp (point) end nil nil state 'syntax-table)) + (put-text-property beg (point) 'face + (if string + font-lock-string-face + font-lock-comment-face))))) + +;;; End of Syntactic fontification functions. + +;;; Keyword regexp fontification functions. (defsubst font-lock-apply-highlight (highlight) "Apply HIGHLIGHT following a match. @@ -1243,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) @@ -1265,10 +1462,10 @@ LIMIT can be modified by the value of its PRE-MATCH-FORM." (defun font-lock-fontify-keywords-region (start end &optional loudly) "Fontify according to `font-lock-keywords' between START and END. START should be at the beginning of a line." + (unless (eq (car font-lock-keywords) t) + (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords))) (let ((case-fold-search font-lock-keywords-case-fold-search) - (keywords (cdr (if (eq (car-safe font-lock-keywords) t) - font-lock-keywords - (font-lock-compile-keywords)))) + (keywords (cdr font-lock-keywords)) (bufname (buffer-name)) (count 0) keyword matcher highlights) ;; @@ -1280,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)) @@ -1293,18 +1498,16 @@ START should be at the beginning of a line." (setq highlights (cdr highlights)))) (setq keywords (cdr keywords))))) -;;; End of Regexp fontification functions. +;;; End of Keyword regexp fontification functions. ;; Various functions. -(defun font-lock-compile-keywords (&optional keywords) - ;; Compile `font-lock-keywords' into the form (t KEYWORD ...) where KEYWORD - ;; is the (MATCHER HIGHLIGHT ...) shown in the variable's doc string. - (let ((keywords (or keywords font-lock-keywords))) - (setq font-lock-keywords - (if (eq (car-safe keywords) t) - keywords - (cons t (mapcar 'font-lock-compile-keyword keywords)))))) +(defun font-lock-compile-keywords (keywords) + ;; Compile KEYWORDS into the form (t KEYWORD ...) where KEYWORD is of the + ;; form (MATCHER HIGHLIGHT ...) as shown in `font-lock-keywords' doc string. + (if (eq (car-safe keywords) t) + keywords + (cons t (mapcar 'font-lock-compile-keyword keywords)))) (defun font-lock-compile-keyword (keyword) (cond ((nlistp keyword) ; MATCHER @@ -1325,6 +1528,14 @@ START should be at the beginning of a line." (t ; (MATCHER HIGHLIGHT ...) keyword))) +(defun font-lock-eval-keywords (keywords) + ;; Evalulate KEYWORDS if a function (funcall) or variable (eval) name. + (if (listp keywords) + keywords + (font-lock-eval-keywords (if (fboundp keywords) + (funcall keywords) + (eval keywords))))) + (defun font-lock-value-in-major-mode (alist) ;; Return value in ALIST for `major-mode', or ALIST if it is not an alist. ;; Structure is ((MAJOR-MODE . VALUE) ...) where MAJOR-MODE may be t. @@ -1350,8 +1561,6 @@ START should be at the beginning of a line." "Set fontification defaults appropriately for this mode. Sets various variables using `font-lock-defaults' (or, if nil, using `font-lock-defaults-alist') and `font-lock-maximum-decoration'." - ;; Set face defaults. - (font-lock-make-faces) ;; Set fontification defaults. (make-local-variable 'font-lock-fontified) ;; Set iff not previously set. @@ -1367,7 +1576,7 @@ Sets various variables using `font-lock-defaults' (or, if nil, using (local (cdr (assq major-mode font-lock-keywords-alist)))) ;; Regexp fontification? (set (make-local-variable 'font-lock-keywords) - (if (fboundp keywords) (funcall keywords) (eval keywords))) + (font-lock-compile-keywords (font-lock-eval-keywords keywords))) ;; Local fontification? (while local (font-lock-add-keywords nil (car (car local)) (cdr (car local))) @@ -1390,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? @@ -1401,8 +1609,11 @@ Sets various variables using `font-lock-defaults' (or, if nil, using ;; Variable alist? (let ((alist (nthcdr 5 defaults))) (while alist - (set (make-local-variable (car (car alist))) (cdr (car alist))) - (setq alist (cdr alist))))))) + (let ((variable (car (car alist))) (value (cdr (car alist)))) + (unless (boundp variable) + (set variable nil)) + (set (make-local-variable variable) value) + (setq alist (cdr alist)))))))) (defun font-lock-unset-defaults () "Unset fontification defaults. See `font-lock-set-defaults'." @@ -1421,213 +1632,164 @@ Sets various variables using `font-lock-defaults' (or, if nil, using ;;; Colour etc. support. -;; This section of code is crying out for revision. Come on down, custom.el? - -;; To begin with, `display-type' and `background-mode' are `frame-parameters' -;; so we don't have to calculate them here anymore. But all the face stuff -;; should be frame-local (and thus display-local) anyway. Because we're not -;; sure what support Emacs is going to have for general frame-local face -;; attributes, we leave this section of code as it is. For now. sm. - -(defvar font-lock-display-type nil - "A symbol indicating the display Emacs is running under. -The symbol should be one of `color', `grayscale' or `mono'. -If Emacs guesses this display attribute wrongly, either set this variable in -your `~/.emacs' or set the resource `Emacs.displayType' in your `~/.Xdefaults'. -See also `font-lock-background-mode' and `font-lock-face-attributes'.") - -(defvar font-lock-background-mode nil - "A symbol indicating the Emacs background brightness. -The symbol should be one of `light' or `dark'. -If Emacs guesses this frame attribute wrongly, either set this variable in -your `~/.emacs' or set the resource `Emacs.backgroundMode' in your -`~/.Xdefaults'. -See also `font-lock-display-type' and `font-lock-face-attributes'.") - -(defvar font-lock-face-attributes nil - "A list of default attributes to use for face attributes. -Each element of the list should be of the form - - (FACE FOREGROUND BACKGROUND BOLD-P ITALIC-P UNDERLINE-P) - -where FACE could be one of the face symbols `font-lock-comment-face', -`font-lock-string-face', `font-lock-keyword-face', `font-lock-builtin-face', -`font-lock-type-face', `font-lock-function-name-face', -`font-lock-variable-name-face', `font-lock-reference-face' and -`font-lock-warning-face', or any other face symbols and attributes may be -specified here and used in `font-lock-keywords'. - -Subsequent element items should be the attributes for the corresponding -Font Lock mode faces. Attributes FOREGROUND and BACKGROUND should be strings -\(default if nil), while BOLD-P, ITALIC-P, and UNDERLINE-P should specify the -corresponding face attributes (yes if non-nil). For example: - - (setq font-lock-face-attributes '((font-lock-warning-face \"HotPink\" nil t t) - (font-lock-comment-face \"Red\"))) - -in your ~/.emacs makes a garish bold-italic warning face and red comment face. - -Emacs uses default attributes based on display type and background brightness. -See variables `font-lock-display-type' and `font-lock-background-mode'. - -Resources can be used to over-ride these face attributes. For example, the -resource `Emacs.font-lock-comment-face.attributeUnderline' can be used to -specify the UNDERLINE-P attribute for face `font-lock-comment-face'.") - -(defun font-lock-make-faces (&optional override) - "Make faces from `font-lock-face-attributes'. -A default list is used if this is nil. -If optional OVERRIDE is non-nil, faces that already exist are reset. -See `font-lock-make-face' and `list-faces-display'." - ;; We don't need to `setq' any of these variables, but the user can see what - ;; is being used if we do. - (unless font-lock-display-type - (setq font-lock-display-type - (let ((display-resource (x-get-resource ".displayType" "DisplayType"))) - (cond (display-resource (intern (downcase display-resource))) - ((x-display-color-p) 'color) - ((x-display-grayscale-p) 'grayscale) - (t 'mono))))) - (unless font-lock-background-mode - (setq font-lock-background-mode - (let ((bg-resource (x-get-resource ".backgroundMode" "BackgroundMode")) - (params (frame-parameters))) - (cond (bg-resource (intern (downcase bg-resource))) - ((eq system-type 'ms-dos) - (if (string-match "light" (cdr (assq 'background-color params))) - 'light - 'dark)) - ((< (apply '+ (x-color-values - (cdr (assq 'background-color params)))) - (* (apply '+ (x-color-values "white")) .6)) - 'dark) - (t 'light))))) - (let ((face-attributes - (let ((light-bg (eq font-lock-background-mode 'light))) - (cond ((memq font-lock-display-type '(mono monochrome)) - ;; Emacs 19.25's font-lock defaults: - ;;'((font-lock-comment-face nil nil nil t nil) - ;; (font-lock-string-face nil nil nil nil t) - ;; (font-lock-keyword-face nil nil t nil nil) - ;; (font-lock-function-name-face nil nil t t nil) - ;; (font-lock-type-face nil nil nil t nil)) - (list '(font-lock-comment-face nil nil t t nil) - '(font-lock-string-face nil nil nil t nil) - '(font-lock-keyword-face nil nil t nil nil) - '(font-lock-builtin-face nil nil t nil nil) - (list - 'font-lock-function-name-face - (cdr (assq 'background-color (frame-parameters))) - (cdr (assq 'foreground-color (frame-parameters))) - t nil nil) - '(font-lock-variable-name-face nil nil t t nil) - '(font-lock-type-face nil nil t nil t) - '(font-lock-reference-face nil nil t nil t) - (list - 'font-lock-warning-face - (cdr (assq 'background-color (frame-parameters))) - (cdr (assq 'foreground-color (frame-parameters))) - t nil nil))) - ((memq font-lock-display-type '(grayscale greyscale - grayshade greyshade)) - (list - (list 'font-lock-comment-face - (if light-bg "DimGray" "LightGray") nil t t nil) - (list 'font-lock-string-face - (if light-bg "DimGray" "LightGray") nil nil t nil) - (list 'font-lock-keyword-face - nil (if light-bg "LightGray" "DimGray") t nil nil) - (list 'font-lock-builtin-face - nil (if light-bg "LightGray" "DimGray") t nil nil) - (list 'font-lock-function-name-face - (cdr (assq 'background-color (frame-parameters))) - (cdr (assq 'foreground-color (frame-parameters))) - t nil nil) - (list 'font-lock-variable-name-face - nil (if light-bg "Gray90" "DimGray") t t nil) - (list 'font-lock-type-face - nil (if light-bg "Gray80" "DimGray") t nil nil) - (list 'font-lock-reference-face - nil (if light-bg "LightGray" "Gray50") t nil t) - (list 'font-lock-warning-face - (cdr (assq 'background-color (frame-parameters))) - (cdr (assq 'foreground-color (frame-parameters))) - t nil nil))) - (light-bg ; light colour background - '((font-lock-comment-face "Firebrick") - (font-lock-string-face "RosyBrown") - (font-lock-keyword-face "Purple") - (font-lock-builtin-face "Orchid") - (font-lock-function-name-face "Blue") - (font-lock-variable-name-face "DarkGoldenrod") - (font-lock-type-face "DarkOliveGreen") - (font-lock-reference-face "CadetBlue") - (font-lock-warning-face "Red" nil t nil nil))) - (t ; dark colour background - '((font-lock-comment-face "OrangeRed") - (font-lock-string-face "LightSalmon") - (font-lock-keyword-face "Cyan") - (font-lock-builtin-face "LightSteelBlue") - (font-lock-function-name-face "LightSkyBlue") - (font-lock-variable-name-face "LightGoldenrod") - (font-lock-type-face "PaleGreen") - (font-lock-reference-face "Aquamarine") - (font-lock-warning-face "Pink" nil t nil nil))))))) +;; Originally these variable values were face names such as `bold' etc. +;; Now we create our own faces, but we keep these variables for compatibility +;; and they give users another mechanism for changing face appearance. +;; We now allow a FACENAME in `font-lock-keywords' to be any expression that +;; returns a face. So the easiest thing is to continue using these variables, +;; rather than sometimes evaling FACENAME and sometimes not. sm. +(defvar font-lock-comment-face 'font-lock-comment-face + "Face name to use for comments.") + +(defvar font-lock-string-face 'font-lock-string-face + "Face name to use for strings.") + +(defvar font-lock-keyword-face 'font-lock-keyword-face + "Face name to use for keywords.") + +(defvar font-lock-builtin-face 'font-lock-builtin-face + "Face name to use for builtins.") + +(defvar font-lock-function-name-face 'font-lock-function-name-face + "Face name to use for function names.") + +(defvar font-lock-variable-name-face 'font-lock-variable-name-face + "Face name to use for variable names.") + +(defvar font-lock-type-face 'font-lock-type-face + "Face name to use for type and class 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 +;; for faces where M-x customize has been used to save changes for the face. +(when (boundp 'font-lock-face-attributes) + (let ((face-attributes font-lock-face-attributes)) (while face-attributes - (unless (assq (car (car face-attributes)) font-lock-face-attributes) - (push (car face-attributes) font-lock-face-attributes)) - (setq face-attributes (cdr face-attributes)))) - ;; Now make the faces if we have to. - (mapcar (function - (lambda (face-attributes) - (let ((face (nth 0 face-attributes))) - (cond (override - ;; We can stomp all over it anyway. Get outta my face! - (font-lock-make-face face-attributes)) - ((and (boundp face) (facep (symbol-value face))) - ;; The variable exists and is already bound to a face. - nil) - ((facep face) - ;; We already have a face so we bind the variable to it. - (set face face)) - (t - ;; No variable or no face. - (font-lock-make-face face-attributes)))))) - font-lock-face-attributes)) - -(defun font-lock-make-face (face-attributes) - "Make a face from FACE-ATTRIBUTES. -FACE-ATTRIBUTES should be like an element `font-lock-face-attributes', so that -the face name is the first item in the list. A variable with the same name as -the face is also set; its value is the face name." - (let* ((face (nth 0 face-attributes)) - (face-name (symbol-name face)) - (set-p (function (lambda (face-name resource) - (x-get-resource (concat face-name ".attribute" resource) - (concat "Face.Attribute" resource))))) - (on-p (function (lambda (face-name resource) - (let ((set (funcall set-p face-name resource))) - (and set (member (downcase set) '("on" "true")))))))) - (make-face face) - (add-to-list 'facemenu-unlisted-faces face) - ;; Set attributes not set from X resources (and therefore `make-face'). - (or (funcall set-p face-name "Foreground") - (condition-case nil - (set-face-foreground face (nth 1 face-attributes)) - (error nil))) - (or (funcall set-p face-name "Background") - (condition-case nil - (set-face-background face (nth 2 face-attributes)) - (error nil))) - (if (funcall set-p face-name "Bold") - (and (funcall on-p face-name "Bold") (make-face-bold face nil t)) - (and (nth 3 face-attributes) (make-face-bold face nil t))) - (if (funcall set-p face-name "Italic") - (and (funcall on-p face-name "Italic") (make-face-italic face nil t)) - (and (nth 4 face-attributes) (make-face-italic face nil t))) - (or (funcall set-p face-name "Underline") - (set-face-underline-p face (nth 5 face-attributes))) - (set face face))) + (let* ((face-attribute (pop face-attributes)) + (face (car face-attribute))) + ;; Rustle up a `defface' SPEC from a `font-lock-face-attributes' entry. + (unless (get face 'saved-face) + (let ((foreground (nth 1 face-attribute)) + (background (nth 2 face-attribute)) + (bold-p (nth 3 face-attribute)) + (italic-p (nth 4 face-attribute)) + (underline-p (nth 5 face-attribute)) + face-spec) + (when foreground + (setq face-spec (cons ':foreground (cons foreground face-spec)))) + (when background + (setq face-spec (cons ':background (cons background face-spec)))) + (when bold-p + (setq face-spec (append '(:bold t) face-spec))) + (when italic-p + (setq face-spec (append '(:italic t) face-spec))) + (when underline-p + (setq face-spec (append '(:underline t) face-spec))) + (custom-declare-face face (list (list t face-spec)) nil))))))) + +;; 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 + '((((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)) + (((class color) (background light)) (:foreground "Firebrick")) + (((class color) (background dark)) (:foreground "OrangeRed")) + (t (:bold t :italic t))) + "Font Lock mode face used to highlight comments." + :group 'font-lock-highlighting-faces) + +(defface font-lock-string-face + '((((type tty) (class color)) (:foreground "green")) + (((class grayscale) (background light)) (:foreground "DimGray" :italic t)) + (((class grayscale) (background dark)) (:foreground "LightGray" :italic t)) + (((class color) (background light)) (:foreground "RosyBrown")) + (((class color) (background dark)) (:foreground "LightSalmon")) + (t (:italic t))) + "Font Lock mode face used to highlight strings." + :group 'font-lock-highlighting-faces) + +(defface font-lock-keyword-face + '((((type tty) (class color)) (:foreground "cyan" :weight bold)) + (((class grayscale) (background light)) (:foreground "LightGray" :bold t)) + (((class grayscale) (background dark)) (:foreground "DimGray" :bold t)) + (((class color) (background light)) (:foreground "Purple")) + (((class color) (background dark)) (:foreground "Cyan")) + (t (:bold t))) + "Font Lock mode face used to highlight keywords." + :group 'font-lock-highlighting-faces) + +(defface font-lock-builtin-face + '((((type tty) (class color)) (:foreground "blue" :weight light)) + (((class grayscale) (background light)) (:foreground "LightGray" :bold t)) + (((class grayscale) (background dark)) (:foreground "DimGray" :bold t)) + (((class color) (background light)) (:foreground "Orchid")) + (((class color) (background dark)) (:foreground "LightSteelBlue")) + (t (:bold t))) + "Font Lock mode face used to highlight builtins." + :group 'font-lock-highlighting-faces) + +(defface font-lock-function-name-face + '((((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 + '((((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)) + (((class color) (background light)) (:foreground "DarkGoldenrod")) + (((class color) (background dark)) (:foreground "LightGoldenrod")) + (t (:bold t :italic t))) + "Font Lock mode face used to highlight variable names." + :group 'font-lock-highlighting-faces) + +(defface font-lock-type-face + '((((type tty) (class color)) (:foreground "green")) + (((class grayscale) (background light)) (:foreground "Gray90" :bold t)) + (((class grayscale) (background dark)) (:foreground "DimGray" :bold t)) + (((class color) (background light)) (:foreground "ForestGreen")) + (((class color) (background dark)) (:foreground "PaleGreen")) + (t (:bold t :underline t))) + "Font Lock mode face used to highlight type and classes." + :group 'font-lock-highlighting-faces) + +(defface font-lock-constant-face + '((((type tty) (class color)) (:foreground "magenta")) + (((class grayscale) (background light)) + (:foreground "LightGray" :bold t :underline t)) + (((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 constants and labels." + :group 'font-lock-highlighting-faces) + +(defface font-lock-warning-face + '((((type tty) (class color)) (:foreground "red")) + (((class color) (background light)) (:foreground "Red" :bold t)) + (((class color) (background dark)) (:foreground "Pink" :bold t)) + (t (:inverse-video t :bold t))) + "Font Lock mode face used to highlight warnings." + :group 'font-lock-highlighting-faces) ;;; End of Colour etc. support. @@ -1640,7 +1802,7 @@ the face is also set; its value is the face name." ;; 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 @@ -1673,7 +1835,7 @@ the face is also set; its value is the face name." ; (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)) @@ -1746,10 +1908,11 @@ the face is also set; its value is the face name." Matches after point, but ignores leading whitespace and `*' characters. Does not move further than LIMIT. -The expected syntax of a declaration/definition item is `word', possibly ending -with optional whitespace and a `('. Everything following the item (but -belonging to it) is expected to by skip-able by `scan-sexps', and items are -expected to be separated with a `,' and to be terminated with a `;'. +The expected syntax of a declaration/definition item is `word' (preceded by +optional whitespace and `*' characters and proceeded by optional whitespace) +optionally followed by a `('. Everything following the item (but belonging to +it) is expected to by skip-able by `scan-sexps', and items are expected to be +separated with a `,' and to be terminated with a `;'. Thus the regexp matches after point: word ( ^^^^ ^ @@ -1771,44 +1934,37 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." (goto-char (or (scan-sexps (point) 1) (point-max)))) (goto-char (match-end 2))) (error t))))) - -(defun font-lock-keyword-depth (keyword) - "Return the depth of KEYWORD regexp. -This means the number of parenthesized expressions." - (let ((count 0) start) - (while (string-match "\\\\(" keyword start) - (setq start (match-end 0) count (1+ count))) - count)) - + +;; Lisp. (defconst lisp-font-lock-keywords-1 (eval-when-compile (list ;; - ;; Anything not a variable or type declaration is fontified as a function. - ;; It would be cleaner to allow preceding whitespace, but it would also be - ;; about five times slower. - (list (concat "^(\\(def\\(" + ;; Definitions. + (list (concat "(\\(def\\(" + ;; Function declarations. + "\\(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\\)\\|" - ;; Everything else is a function declaration. - "\\sw+" + "\\(class\\|group\\|package\\|struct\\|type\\)" "\\)\\)\\>" - ;; Any whitespace and declared object. + ;; Any whitespace and defined object. "[ \t'\(]*" "\\(\\sw+\\)?") '(1 font-lock-keyword-face) - '(5 (cond ((match-beginning 3) font-lock-variable-name-face) - ((match-beginning 4) font-lock-type-face) - (t font-lock-function-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.") @@ -1818,175 +1974,297 @@ This means the number of parenthesized expressions." (list ;; ;; Control structures. Emacs Lisp forms. - (cons (concat "(\\(" -; '("cond" "if" "while" "let\\*?" "prog[nv12*]?" "inline" "catch" "throw" -; "save-restriction" "save-excursion" "save-window-excursion" -; "save-selected-window" "save-match-data" "save-current-buffer" -; "unwind-protect" "condition-case" "track-mouse" "dont-compile" -; "eval-after-load" "eval-and-compile" "eval-when" "eval-when-compile" -; "with-output-to-temp-buffer" "with-timeout" "with-current-buffer" -; "with-temp-buffer" "with-temp-file") - "c\\(atch\\|ond\\(\\|ition-case\\)\\)\\|dont-compile\\|" - "eval-\\(a\\(fter-load\\|nd-compile\\)\\|" - "when\\(\\|-compile\\)\\)\\|" - "i\\(f\\|nline\\)\\|let\\*?\\|prog[nv12*]?\\|" - "save-\\(current-buffer\\|excursion\\|match-data\\|" - "restriction\\|selected-window\\|window-excursion\\)\\|" - "t\\(hrow\\|rack-mouse\\)\\|unwind-protect\\|" - "w\\(hile\\|ith-\\(current-buffer\\|" - "output-to-temp-buffer\\|" - "t\\(emp-\\(buffer\\|file\\)\\|imeout\\)\\)\\)" - "\\)\\>") + (cons (concat + "(" (regexp-opt + '("cond" "if" "while" "let" "let*" + "prog" "progn" "progv" "prog1" "prog2" "prog*" + "inline" "lambda" "save-restriction" "save-excursion" + "save-window-excursion" "save-selected-window" + "save-match-data" "save-current-buffer" "unwind-protect" + "condition-case" "track-mouse" + "eval-after-load" "eval-and-compile" "eval-when-compile" + "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) ;; ;; Control structures. Common Lisp forms. - (cons (concat "(\\(" -; '(make-regexp -; '("when" "unless" "case" "ecase" "typecase" "etypecase" -; "loop" "do\\*?" "dotimes" "dolist" -; "proclaim" "declaim" "declare" -; "lexical-let\\*?" "flet" "labels" "return" "return-from")) - "case\\|d\\(ecla\\(im\\|re\\)\\|o\\(\\*?\\|" - "list\\|times\\)\\)\\|e\\(case\\|typecase\\)\\|flet\\|" - "l\\(abels\\|exical-let\\*?\\|oop\\)\\|proclaim\\|" - "return\\(\\|-from\\)\\|typecase\\|unless\\|when" - "\\)\\>") + (cons (concat + "(" (regexp-opt + '("when" "unless" "case" "ecase" "typecase" "etypecase" + "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.") + +;; TeX. - -(defvar scheme-font-lock-keywords - (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)) - ;; - ;; Control structures. -;(make-regexp '("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-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")) - (cons - (concat "(\\(" - "and\\|begin\\|c\\(a\\(ll\\(-with-\\(current-continuation\\|" - "input-file\\|output-file\\)\\|/cc\\)\\|se\\)\\|ond\\)\\|" - "d\\(elay\\|o\\)\\|else\\|for-each\\|if\\|" - "l\\(ambda\\|et\\(-syntax\\|\\*?\\|rec\\(\\|-syntax\\)\\)\\)\\|" - "map\\|or\\|syntax\\(\\|-rules\\)" - "\\)\\>") 1) - ;; - ;; David Fox for SOS/STklos class specifiers. - '("\\<<\\sw+>\\>" . font-lock-type-face) - ;; - ;; Scheme `:' keywords as references. - '("\\<:\\sw+\\>" . font-lock-reference-face) - )) - "Default expressions to highlight in Scheme modes.") - - -(defvar tex-font-lock-keywords +;(defvar tex-font-lock-keywords ; ;; Regexps updated with help from Ulrik Dickow . ; '(("\\\\\\(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) ; ("{\\\\\\(em\\|it\\|sl\\)\\([^}]+\\)}" 2 'italic keep) ; ("\\\\\\([a-zA-Z@]+\\|.\\)" . font-lock-keyword-face) ; ("^[ \t\n]*\\\\def[\\\\@]\\(\\w+\\)" 1 font-lock-function-name-face keep)) - ;; Rewritten and extended for LaTeX2e by Ulrik Dickow . - '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}" - 2 font-lock-function-name-face) - ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}" - 2 font-lock-reference-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 - ;; not be able to display those fonts. - ;; LaTeX2e: \emph{This is emphasized}. - ("\\\\emph{\\([^}]+\\)}" 1 'italic keep) - ;; LaTeX2e: \textbf{This is bold}, \textit{...}, \textsl{...} - ("\\\\text\\(\\(bf\\)\\|it\\|sl\\){\\([^}]+\\)}" - 3 (if (match-beginning 2) 'bold 'italic) keep) - ;; Old-style bf/em/it/sl. Stop at `\\' and un-escaped `&', for good tables. - ("\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)" - 3 (if (match-beginning 2) 'bold 'italic) keep)) +; ;; Rewritten and extended for LaTeX2e by Ulrik Dickow . +; '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}" +; 2 font-lock-function-name-face) +; ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}" +; 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 +; ;; not be able to display those fonts. +; ;; LaTeX2e: \emph{This is emphasized}. +; ("\\\\emph{\\([^}]+\\)}" 1 'italic keep) +; ;; LaTeX2e: \textbf{This is bold}, \textit{...}, \textsl{...} +; ("\\\\text\\(\\(bf\\)\\|it\\|sl\\){\\([^}]+\\)}" +; 3 (if (match-beginning 2) 'bold 'italic) keep) +; ;; Old-style bf/em/it/sl. Stop at `\\' and un-escaped `&', for tables. +; ("\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)" +; 3 (if (match-beginning 2) 'bold 'italic) keep)) + +;; Rewritten with the help of Alexandra Bac . +(defconst tex-font-lock-keywords-1 + (eval-when-compile + (let* (;; + ;; Names of commands whose arg should be fontified as heading, etc. + (headings (regexp-opt '("title" "begin" "end") t)) + ;; These commands have optional args. + (headings-opt (regexp-opt + '("chapter" "part" + "section" "subsection" "subsubsection" + "section*" "subsection*" "subsubsection*" + "paragraph" "subparagraph" "subsubparagraph" + "paragraph*" "subparagraph*" "subsubparagraph*" + "newcommand" "renewcommand" "newenvironment" + "newtheorem" + "newcommand*" "renewcommand*" "newenvironment*" + "newtheorem*") + t)) + (variables (regexp-opt + '("newcounter" "newcounter*" "setcounter" "addtocounter" + "setlength" "addtolength" "settowidth") + t)) + (includes (regexp-opt + '("input" "include" "includeonly" "bibliography" + "epsfig" "psfig" "epsf") + t)) + (includes-opt (regexp-opt + '("nofiles" "usepackage" + "includegraphics" "includegraphics*") + t)) + ;; Miscellany. + (slash "\\\\") + (opt "\\(\\[[^]]*\\]\\)?") + (arg "{\\([^}]+\\)") + (opt-depth (regexp-opt-depth opt)) + (arg-depth (regexp-opt-depth arg)) + ) + (list + ;; + ;; Heading args. + (list (concat slash headings arg) + (+ (regexp-opt-depth headings) arg-depth) + 'font-lock-function-name-face) + (list (concat slash headings-opt opt arg) + (+ (regexp-opt-depth headings-opt) opt-depth arg-depth) + 'font-lock-function-name-face) + ;; + ;; Variable args. + (list (concat slash variables arg) + (+ (regexp-opt-depth variables) arg-depth) + 'font-lock-variable-name-face) + ;; + ;; Include args. + (list (concat slash includes arg) + (+ (regexp-opt-depth includes) arg-depth) + 'font-lock-builtin-face) + (list (concat slash includes-opt opt arg) + (+ (regexp-opt-depth includes-opt) opt-depth arg-depth) + 'font-lock-builtin-face) + ;; + ;; Definitions. I think. + '("^[ \t]*\\\\def\\\\\\(\\(\\w\\|@\\)+\\)" + 1 font-lock-function-name-face) + ))) + "Subdued expressions to highlight in TeX modes.") + +(defconst tex-font-lock-keywords-2 + (append tex-font-lock-keywords-1 + (eval-when-compile + (let* (;; + ;; Names of commands whose arg should be fontified with fonts. + (bold (regexp-opt '("bf" "textbf" "textsc" "textup" + "boldsymbol" "pmb") t)) + (italic (regexp-opt '("it" "textit" "textsl" "emph") t)) + (type (regexp-opt '("texttt" "textmd" "textrm" "textsf") t)) + ;; + ;; Names of commands whose arg should be fontified as a citation. + (citations (regexp-opt + '("label" "ref" "pageref" "vref" "eqref") + t)) + (citations-opt (regexp-opt + '("cite" "nocite" "caption" "index" "glossary" + "footnote" "footnotemark" "footnotetext") + t)) + ;; + ;; Names of commands that should be fontified. + (specials (regexp-opt + '("\\" + "linebreak" "nolinebreak" "pagebreak" "nopagebreak" + "newline" "newpage" "clearpage" "cleardoublepage" + "displaybreak" "allowdisplaybreaks" "enlargethispage") + t)) + (general "\\([a-zA-Z@]+\\**\\|[^ \t\n]\\)") + ;; + ;; Miscellany. + (slash "\\\\") + (opt "\\(\\[[^]]*\\]\\)?") + (arg "{\\([^}]+\\)") + (opt-depth (regexp-opt-depth opt)) + (arg-depth (regexp-opt-depth arg)) + ) + (list + ;; + ;; Citation args. + (list (concat slash citations arg) + (+ (regexp-opt-depth citations) arg-depth) + 'font-lock-constant-face) + (list (concat slash citations-opt opt arg) + (+ (regexp-opt-depth citations-opt) opt-depth arg-depth) + 'font-lock-constant-face) + ;; + ;; Command names, special and general. + (cons (concat slash specials) 'font-lock-warning-face) + (concat slash general) + ;; + ;; Font environments. It seems a bit dubious to use `bold' etc. faces + ;; since we might not be able to display those fonts. + (list (concat slash bold arg) + (+ (regexp-opt-depth bold) arg-depth) + '(quote bold) 'keep) + (list (concat slash italic arg) + (+ (regexp-opt-depth italic) arg-depth) + '(quote italic) 'keep) + (list (concat slash type arg) + (+ (regexp-opt-depth type) arg-depth) + '(quote bold-italic) 'keep) + ;; + ;; Old-style bf/em/it/sl. Stop at `\\' and un-escaped `&', for tables. + (list (concat "\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>" + "\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)") + 3 '(if (match-beginning 2) 'bold 'italic) 'keep) + )))) + "Gaudy expressions to highlight in TeX modes.") + +(defvar tex-font-lock-keywords tex-font-lock-keywords-1 "Default expressions to highlight in TeX modes.") ;;; 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 excepted types are used to provide default variable values. +;; 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))) -(defvar c-font-lock-extra-types '("FILE" "\\sw+_t") +(defcustom c-font-lock-extra-types '("FILE" "\\sw+_t") "*List of extra types to fontify in C mode. -Each list item should be a regexp without word-delimiters. +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.") - -(defvar c++-font-lock-extra-types nil +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" + "\\([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 without word-delimiters. -For example, a value of (\"String\") means the word String is treated as a type -name.") +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) -(defvar objc-font-lock-extra-types '("Class" "BOOL" "IMP" "SEL") +(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 without word-delimiters. +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.") +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) -(defvar 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 without word-delimiters. -For example, a value of (\"[A-Z\300-\326\330-\337]\\\\sw+\") means capitalised -words (and words conforming to the Java id spec) are treated as type names.") +Each list item should be a regexp not containing word-delimiters. +For example, a value of (\"[A-Z\300-\326\330-\337]\\\\sw*[a-z]\\\\sw*\") means capitalised +words (and words conforming to the Java id spec) are treated as type names. + +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. @@ -2016,21 +2294,30 @@ See also `c-font-lock-extra-types'.") See also `c-font-lock-extra-types'.") (let* ((c-keywords -; ("break" "continue" "do" "else" "for" "if" "return" "switch" "while") - "break\\|continue\\|do\\|else\\|for\\|if\\|return\\|switch\\|while") - (c-type-types -; ("auto" "extern" "register" "static" "typedef" "struct" "union" "enum" -; "signed" "unsigned" "short" "long" "int" "char" "float" "double" -; "void" "volatile" "const") + (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 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 - (,@ (concat "auto\\|c\\(har\\|onst\\)\\|double\\|" - "e\\(num\\|xtern\\)\\|float\\|int\\|long\\|register\\|" - "s\\(hort\\|igned\\|t\\(atic\\|ruct\\)\\)\\|typedef\\|" - "un\\(ion\\|signed\\)\\|vo\\(id\\|latile\\)")) + (,@ (eval-when-compile + (regexp-opt + '("char" "short" "int" "long" "signed" "unsigned" + "float" "double" "void" "complex")))) c-font-lock-extra-types) "\\|")) - (c-type-depth `(font-lock-keyword-depth (,@ c-type-types))) + (c-type-names-depth + `(regexp-opt-depth (,@ c-type-names))) ) (setq c-font-lock-keywords-1 (list @@ -2045,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. @@ -2054,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 @@ -2067,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 @@ -2091,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)) @@ -2108,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+\\>\\)*" @@ -2154,10 +2454,15 @@ See also `c++-font-lock-extra-types'.") ;; 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 "[ \t*&]*\\(\\sw+\\)" - "\\(<\\(\\sw+\\)[ \t*&]*>\\)?" - "\\([ \t]*::[ \t*]*\\(\\sw+\\)\\)?" - "[ \t]*\\((\\)?"))) + (concat + ;; Skip any leading whitespace. + "[ \t*&]*" + ;; This is `c++-type-spec' from below. (Hint hint!) + "\\(\\sw+\\)" ; The instance? + "\\([ \t]*<\\([^>\n]+\\)[ \t*&]*>\\)?" ; Or template? + "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)*" ; Or member? + ;; Match any trailing parenthesis. + "[ \t]*\\((\\)?"))) (save-match-data (condition-case nil (save-restriction @@ -2171,48 +2476,61 @@ See also `c++-font-lock-extra-types'.") (error t))))) (let* ((c++-keywords -; ("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") - (concat "asm\\|break\\|c\\(atch\\|on\\(st_cast\\|tinue\\)\\)\\|" - "d\\(elete\\|o\\|ynamic_cast\\)\\|else\\|for\\|if\\|new\\|" - "operator\\|re\\(interpret_cast\\|turn\\)\\|" - "s\\(izeof\\|tatic_cast\\|" - "witch\\)\\|t\\(h\\(is\\|row\\)\\|ry\\)\\|while")) + (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 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 - (mapconcat 'identity - (mapcar 'regexp-quote - ;; Taken from Stroustrup, minus keywords otherwise fontified. - (sort '("+" "-" "*" "/" "%" "^" "&" "|" "~" "!" "=" "<" ">" - "+=" "-=" "*=" "/=" "%=" "^=" "&=" "|=" "<<" ">>" - ">>=" "<<=" "==" "!=" "<=" ">=" "&&" "||" "++" "--" - "->*" "," "->" "[]" "()") - #'(lambda (a b) (> (length a) (length b))))) - "\\|")) - (c++-type-types -; ("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" -; ;; Eric Hopper says these are new. -; "namespace" "using") + (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 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 - (,@ (concat "auto\\|bool\\|c\\(har\\|o\\(mplex\\|nst\\)\\)\\|" - "double\\|e\\(num\\|xtern\\)\\|f\\(loat\\|riend\\)\\|" - "in\\(line\\|t\\)\\|long\\|namespace\\|register\\|" - "s\\(hort\\|igned\\|t\\(atic\\|ruct\\)\\)\\|" - "t\\(emplate\\|ypedef\\)\\|" - "u\\(n\\(ion\\|signed\\)\\|sing\\)\\|" - "v\\(irtual\\|o\\(id\\|latile\\)\\)")) ; 12 ()s deep. + (,@ (eval-when-compile + (regexp-opt + '("signed" "unsigned" "short" "long" + "int" "char" "float" "double" "void" + "bool" "complex")))) c++-font-lock-extra-types) "\\|")) - (c++-type-suffix (concat "\\(<\\(\\sw+\\)[ \t*&]*>\\)?" - "\\([ \t]*::[ \t*]*\\(\\sw+\\)\\)?")) - (c++-type-depth `(font-lock-keyword-depth - (concat (,@ c++-type-types) (,@ c++-type-suffix)))) + (c++-type-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+\\)\\)*")) + (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)))) ) (setq c++-font-lock-keywords-1 (append @@ -2221,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)) ))) @@ -2246,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. @@ -2256,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. - (cons (concat "\\<\\(" c++-keywords "\\)\\>") 'font-lock-keyword-face) + (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 @@ -2276,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. @@ -2289,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*&]*\\)+") @@ -2313,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))) @@ -2340,26 +2679,30 @@ See also `objc-font-lock-extra-types'.") ;; Regexps written with help from Stephen Peters and ;; Jacques Duthen Prestataire . (let* ((objc-keywords -; '("break" "continue" "do" "else" "for" "if" "return" "switch" "while" -; "sizeof" "self" "super") - (concat "break\\|continue\\|do\\|else\\|for\\|if\\|return\\|" - "s\\(elf\\|izeof\\|uper\\|witch\\)\\|while")) - (objc-type-types + (eval-when-compile + (regexp-opt '("break" "continue" "do" "else" "for" "if" "return" + "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 -; '("auto" "extern" "register" "static" "typedef" "struct" "union" -; "enum" "signed" "unsigned" "short" "long" "int" "char" -; "float" "double" "void" "volatile" "const" -; "id" "oneway" "in" "out" "inout" "bycopy" "byref") - (,@ (concat "auto\\|by\\(copy\\|ref\\)\\|c\\(har\\|onst\\)\\|" - "double\\|e\\(num\\|xtern\\)\\|float\\|" - "i\\([dn]\\|n\\(out\\|t\\)\\)\\|long\\|" - "o\\(neway\\|ut\\)\\|register\\|s\\(hort\\|igned\\|" - "t\\(atic\\|ruct\\)\\)\\|typedef\\|" - "un\\(ion\\|signed\\)\\|vo\\(id\\|latile\\)")) + (,@ (eval-when-compile + (regexp-opt + '("signed" "unsigned" "short" "long" + "int" "char" "float" "double" "void" + "id")))) objc-font-lock-extra-types) "\\|")) - (objc-type-depth `(font-lock-keyword-depth (,@ objc-type-types))) + (objc-type-names-depth + `(regexp-opt-depth (,@ objc-type-names))) ) (setq objc-font-lock-keywords-1 (append @@ -2371,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 @@ -2401,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 @@ -2428,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. @@ -2443,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+\\>\\)*" @@ -2479,91 +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 - (concat "\\<\\(" -; '("catch" "do" "else" "super" "this" "finally" "for" "if" -;; ;; Anders Lindgren says these have gone. -;; "cast" "byvalue" "future" "generic" "operator" "var" -;; "inner" "outer" "rest" -; "interface" "return" "switch" "throw" "try" "while") - "catch\\|do\\|else\\|f\\(inally\\|or\\)\\|" - "i\\(f\\|nterface\\)\\|return\\|s\\(uper\\|witch\\)\\|" - "t\\(h\\(is\\|row\\)\\|ry\\)\\|while" - "\\)\\>")) + (eval-when-compile + (regexp-opt + '("catch" "do" "else" "super" "this" "finally" "for" "if" + ;; 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 - (mapconcat 'identity - '("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 -; '("abstract" "const" "final" "synchronized" "transient" "static" -;; ;; Anders Lindgren says this has gone. -;; "threadsafe" -; "volatile" "public" "private" "protected" "native") - (concat "abstract\\|const\\|final\\|native\\|" - "p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|" - "s\\(tatic\\|ynchronized\\)\\|transient\\|volatile")) - ;; - ;; Random types immediately followed by an object name. - (java-other-types - '(mapconcat 'identity (cons "\\sw+\\.\\sw+" java-font-lock-extra-types) - "\\|")) - (java-other-depth `(font-lock-keyword-depth (,@ java-other-types))) - ) + (java-type-specs + (eval-when-compile + (regexp-opt + '("abstract" "const" "final" "synchronized" "transient" "static" + ;; Anders Lindgren says this has gone. + ;; "threadsafe" + "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)) ))) @@ -2574,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]*\\]\\)*" "\\)*") @@ -2641,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: