X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/b3f1e48a47d5ef1a397a4244e3203acc7aa29f87..a568a2cc4fb321d9370a94136a9a36960e58b20e:/lisp/font-lock.el diff --git a/lisp/font-lock.el b/lisp/font-lock.el index 308a3e2789..044c414d84 100644 --- a/lisp/font-lock.el +++ b/lisp/font-lock.el @@ -1,6 +1,6 @@ ;;; font-lock.el --- Electric font lock mode -;; Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999, 2000, 2001 +;; Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999, 2000, 2001, 02, 2003, 2004 ;; Free Software Foundation, Inc. ;; Author: jwz, then rms, then sm @@ -152,9 +152,9 @@ ;; "Default expressions to highlight in Foo mode.") ;; ;; (add-hook 'foo-mode-hook -;; (function (lambda () -;; (make-local-variable 'font-lock-defaults) -;; (setq font-lock-defaults '(foo-font-lock-keywords t))))) +;; (lambda () +;; (make-local-variable 'font-lock-defaults) +;; (setq font-lock-defaults '(foo-font-lock-keywords t)))) ;;; Adding Font Lock support for modes: @@ -210,7 +210,7 @@ (require 'syntax) ;; Define core `font-lock' group. -(defgroup font-lock nil +(defgroup font-lock '((jit-lock custom-group)) "Font Lock mode text highlighting package." :link '(custom-manual "(emacs)Font Lock") :link '(custom-manual "(elisp)Font Lock Mode") @@ -228,22 +228,13 @@ ;; 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. @@ -339,8 +330,11 @@ If a number, only buffers greater than this size have fontification messages." (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'.") +(defvar font-lock-preprocessor-face 'font-lock-preprocessor-face + "Face name to use for preprocessor directives.") + +(defvar font-lock-reference-face 'font-lock-constant-face) +(make-obsolete-variable 'font-lock-reference-face 'font-lock-constant-face) ;; Fontification variables: @@ -446,106 +440,6 @@ This variable is set by major modes via the variable `font-lock-defaults'. Be careful when composing regexps for this list; a poorly written pattern can dramatically slow things down!") -;; This variable is used by mode packages that support Font Lock mode by -;; defining their own keywords to use for `font-lock-keywords'. (The mode -;; command should make it buffer-local and set it to provide the set up.) -(defvar font-lock-defaults nil - "Defaults for Font Lock mode specified by the major mode. -Defaults should be of the form: - - (KEYWORDS KEYWORDS-ONLY CASE-FOLD SYNTAX-ALIST SYNTAX-BEGIN ...) - -KEYWORDS may be a symbol (a variable or function whose value is the keywords to -use for fontification) or a list of symbols. If KEYWORDS-ONLY is non-nil, -syntactic fontification (strings and comments) is not performed. -If CASE-FOLD is non-nil, the case of the keywords is ignored when fontifying. -If SYNTAX-ALIST is non-nil, it should be a list of cons pairs of the form -\(CHAR-OR-STRING . STRING) used to set the local Font Lock syntax table, for -keyword and syntactic fontification (see `modify-syntax-entry'). - -If SYNTAX-BEGIN is non-nil, it should be a function with no args used to move -backwards outside any enclosing syntactic block, for syntactic fontification. -Typical values are `beginning-of-line' (i.e., the start of the line is known to -be outside a syntactic block), or `beginning-of-defun' for programming modes or -`backward-paragraph' for textual modes (i.e., the mode-dependent function is -known to move outside a syntactic block). If nil, the beginning of the buffer -is used as a position outside of a syntactic block, in the worst case. - -These item elements are used by Font Lock mode to set the variables -`font-lock-keywords', `font-lock-keywords-only', -`font-lock-keywords-case-fold-search', `font-lock-syntax-table' and -`font-lock-beginning-of-syntax-function', respectively. - -Further item elements are alists of the form (VARIABLE . VALUE) and are in no -particular order. Each VARIABLE is made buffer-local before set to VALUE. - -Currently, appropriate variables include `font-lock-mark-block-function'. -If this is non-nil, it should be a function with no args used to mark any -enclosing block of text, for fontification via \\[font-lock-fontify-block]. -Typical values are `mark-defun' for programming modes or `mark-paragraph' for -textual modes (i.e., the mode-dependent function is known to put point and mark -around a text block relevant to that mode). - -Other variables include that for syntactic keyword fontification, -`font-lock-syntactic-keywords' -and those for buffer-specialised fontification functions, -`font-lock-fontify-buffer-function', `font-lock-unfontify-buffer-function', -`font-lock-fontify-region-function', `font-lock-unfontify-region-function', -`font-lock-inhibit-thing-lock' and `font-lock-maximum-size'.") -;;;###autoload -(make-variable-buffer-local 'font-lock-defaults) - -;; This variable is used where font-lock.el itself supplies the keywords. -(defvar font-lock-defaults-alist - (let (;; We use `beginning-of-defun', rather than nil, for SYNTAX-BEGIN. - ;; Thus the calculation of the cache is usually faster but not - ;; infallible, so we risk mis-fontification. sm. - (c-mode-defaults - '((c-font-lock-keywords c-font-lock-keywords-1 - c-font-lock-keywords-2 c-font-lock-keywords-3) - nil nil ((?_ . "w")) beginning-of-defun - (font-lock-syntactic-face-function - . c-font-lock-syntactic-face-function) - (font-lock-mark-block-function . mark-defun))) - (c++-mode-defaults - '((c++-font-lock-keywords c++-font-lock-keywords-1 - c++-font-lock-keywords-2 c++-font-lock-keywords-3) - nil nil ((?_ . "w")) beginning-of-defun - (font-lock-syntactic-face-function - . c-font-lock-syntactic-face-function) - (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-syntactic-face-function - . c-font-lock-syntactic-face-function) - (font-lock-mark-block-function . mark-defun))) - (java-mode-defaults - '((java-font-lock-keywords java-font-lock-keywords-1 - java-font-lock-keywords-2 java-font-lock-keywords-3) - nil nil ((?_ . "w") (?$ . "w")) nil - (font-lock-syntactic-face-function - . java-font-lock-syntactic-face-function) - (font-lock-mark-block-function . mark-defun)))) - (list - (cons 'c-mode c-mode-defaults) - (cons 'c++-mode c++-mode-defaults) - (cons 'objc-mode objc-mode-defaults) - (cons 'java-mode java-mode-defaults))) - "Alist of fall-back Font Lock defaults for major modes. - -This variable should not be used any more. -Set the buffer-local `font-lock-keywords' in the major mode instead. - -Each item should be a list of the form: - - (MAJOR-MODE . FONT-LOCK-DEFAULTS) - -where MAJOR-MODE is a symbol and FONT-LOCK-DEFAULTS is a list of default -settings. See the variable `font-lock-defaults', which takes precedence.") -(make-obsolete-variable 'font-lock-defaults-alist 'font-lock-defaults) - (defvar font-lock-keywords-alist nil "*Alist of `font-lock-keywords' local to a `major-mode'. This is normally set via `font-lock-add-keywords' and @@ -619,12 +513,17 @@ If this is nil, the major mode's syntax table is used. This is normally set via `font-lock-defaults'.") (defvar font-lock-beginning-of-syntax-function nil - "*Non-nil means use this function to move back outside of a syntactic block. -When called with no args it should leave point at the beginning of any -enclosing syntactic block. -If this is nil, the beginning of the buffer is used (in the worst case). + "*Non-nil means use this function to move back outside all constructs. +When called with no args it should move point backward to a place which +is not in a string or comment and not within any bracket-pairs (or else, +a place such that any bracket-pairs outside it can be ignored for Emacs +syntax analysis and fontification). + +If this is nil, the beginning of the buffer is used, which is +always correct but tends to be slow. This is normally set via `font-lock-defaults'. -It is preferable to set `syntax-begin-function' instead.") +This variable is semi-obsolete; we recommend setting +`syntax-begin-function' instead.") (defvar font-lock-mark-block-function nil "*Non-nil means use this function to mark a block of text. @@ -677,14 +576,20 @@ Major/minor modes can set this variable if they know which option applies.") ;; We use this to preserve or protect things when modifying text properties. (defmacro save-buffer-state (varlist &rest body) "Bind variables according to VARLIST and eval BODY restoring buffer state." - `(let* ,(append varlist - '((modified (buffer-modified-p)) (buffer-undo-list t) - (inhibit-read-only t) (inhibit-point-motion-hooks t) - (inhibit-modification-hooks t) - deactivate-mark buffer-file-name buffer-file-truename)) - ,@body - (unless modified - (restore-buffer-modified-p nil)))) + (let ((modified (make-symbol "modified"))) + `(let* ,(append varlist + `((,modified (buffer-modified-p)) + (buffer-undo-list t) + (inhibit-read-only t) + (inhibit-point-motion-hooks t) + (inhibit-modification-hooks t) + deactivate-mark + buffer-file-name + buffer-file-truename)) + (progn + ,@body) + (unless ,modified + (restore-buffer-modified-p nil))))) (put 'save-buffer-state 'lisp-indent-function 1) (def-edebug-spec save-buffer-state let) ;; @@ -692,69 +597,9 @@ Major/minor modes can set this variable if they know which option applies.") (defvar font-lock-face-attributes)) ; Obsolete but respected if set. ;;;###autoload -(define-minor-mode font-lock-mode - "Toggle Font Lock mode. -With arg, turn Font Lock mode off if and only if arg is a non-positive -number; if arg is nil, toggle Font Lock mode; anything else turns Font -Lock on. -\(Font Lock is also known as \"syntax highlighting\".) - -When Font Lock mode is enabled, text is fontified as you type it: - - - Comments are displayed in `font-lock-comment-face'; - - Strings are displayed in `font-lock-string-face'; - - Certain other expressions are displayed in other faces according to the - value of the variable `font-lock-keywords'. - -To customize the faces (colors, fonts, etc.) used by Font Lock for -fontifying different parts of buffer text, use \\[customize-face]. - -You can enable Font Lock mode in any major mode automatically by turning on in -the major mode's hook. For example, put in your ~/.emacs: - - (add-hook 'c-mode-hook 'turn-on-font-lock) - -Alternatively, you can use Global Font Lock mode to automagically turn on Font -Lock mode in buffers whose major mode supports it and whose major mode is one -of `font-lock-global-modes'. For example, put in your ~/.emacs: - - (global-font-lock-mode t) - -There are a number of support modes that may be used to speed up Font Lock mode -in various ways, specified via the variable `font-lock-support-mode'. Where -major modes support different levels of fontification, you can use the variable -`font-lock-maximum-decoration' to specify which level you generally prefer. -When you turn Font Lock mode on/off the buffer is fontified/defontified, though -fontification occurs only if the buffer is less than `font-lock-maximum-size'. - -For example, to specify that Font Lock mode use use Lazy Lock mode as a support -mode and use maximum levels of fontification, put in your ~/.emacs: - - (setq font-lock-support-mode 'lazy-lock-mode) - (setq font-lock-maximum-decoration t) - -To add your own highlighting for some major mode, and modify the highlighting -selected automatically via the variable `font-lock-maximum-decoration', you can -use `font-lock-add-keywords'. - -To fontify a buffer, without turning on Font Lock mode and regardless of buffer -size, you can use \\[font-lock-fontify-buffer]. - -To fontify a block (the function or paragraph containing point, or a number of -lines around point), perhaps because modification on the current line caused -syntactic change on other lines, you can use \\[font-lock-fontify-block]. - -See the variable `font-lock-defaults-alist' for the Font Lock mode default -settings. You can set your own default settings for some mode, by setting a -buffer local value for `font-lock-defaults', via its mode hook." - nil nil nil - ;; Don't turn on Font Lock mode if we don't have a display (we're running a - ;; batch job) or if the buffer is invisible (the name starts with a space). - (when (or noninteractive (eq (aref (buffer-name) 0) ?\ )) - (setq font-lock-mode nil)) - +(defun font-lock-mode-internal (arg) ;; Turn on Font Lock mode. - (when font-lock-mode + (when arg (add-hook 'after-change-functions 'font-lock-after-change-function t t) (font-lock-set-defaults) (font-lock-turn-on-thing-lock) @@ -773,12 +618,6 @@ buffer local value for `font-lock-defaults', via its mode hook." (font-lock-unfontify-buffer) (font-lock-turn-off-thing-lock))) -;;;###autoload -(defun turn-on-font-lock () - "Turn on Font Lock mode (only if the terminal can display it)." - (unless font-lock-mode - (font-lock-mode))) - ;;;###autoload (defun font-lock-add-keywords (mode keywords &optional append) "Add highlighting KEYWORDS for MODE. @@ -803,7 +642,7 @@ When used from an elisp package (such as a minor mode), it is recommended to use nil for MODE (and place the call in a loop or on a hook) to avoid subtle problems due to details of the implementation. -Note that some modes have specialised support for additional patterns, e.g., +Note that some modes have specialized support for additional patterns, e.g., see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types', `objc-font-lock-extra-types' and `java-font-lock-extra-types'." (cond (mode @@ -931,94 +770,6 @@ subtle problems due to details of the implementation." (delete (font-lock-compile-keyword keyword) font-lock-keywords))))))) -;;; Global Font Lock mode. - -;; A few people have hassled in the past for a way to make it easier to turn on -;; Font Lock mode, without the user needing to know for which modes s/he has to -;; turn it on, perhaps the same way hilit19.el/hl319.el does. I've always -;; balked at that way, as I see it as just re-moulding the same problem in -;; another form. That is; some person would still have to keep track of which -;; modes (which may not even be distributed with Emacs) support Font Lock mode. -;; The list would always be out of date. And that person might have to be me. - -;; Implementation. -;; -;; In a previous discussion the following hack came to mind. It is a gross -;; hack, but it generally works. We use the convention that major modes start -;; by calling the function `kill-all-local-variables', which in turn runs -;; functions on the hook variable `change-major-mode-hook'. We attach our -;; function `font-lock-change-major-mode' to that hook. Of course, when this -;; hook is run, the major mode is in the process of being changed and we do not -;; know what the final major mode will be. So, `font-lock-change-major-mode' -;; only (a) notes the name of the current buffer, and (b) adds our function -;; `turn-on-font-lock-if-enabled' to the hook variables `find-file-hooks' and -;; `post-command-hook' (for buffers that are not visiting files). By the time -;; the functions on the first of these hooks to be run are run, the new major -;; mode is assumed to be in place. This way we get a Font Lock function run -;; when a major mode is turned on, without knowing major modes or their hooks. -;; -;; Naturally this requires that (a) major modes run `kill-all-local-variables', -;; as they are supposed to do, and (b) the major mode is in place after the -;; file is visited or the command that ran `kill-all-local-variables' has -;; finished, whichever the sooner. Arguably, any major mode that does not -;; follow the convension (a) is broken, and I can't think of any reason why (b) -;; would not be met (except `gnudoit' on non-files). However, it is not clean. -;; -;; Probably the cleanest solution is to have each major mode function run some -;; hook, e.g., `major-mode-hook', but maybe implementing that change is -;; impractical. I am personally against making `setq' a macro or be advised, -;; or have a special function such as `set-major-mode', but maybe someone can -;; come up with another solution? - -;; User interface. -;; -;; Although Global Font Lock mode is a pseudo-mode, I think that the user -;; interface should conform to the usual Emacs convention for modes, i.e., a -;; command to toggle the feature (`global-font-lock-mode') with a variable for -;; finer control of the mode's behaviour (`font-lock-global-modes'). -;; -;; The feature should not be enabled by loading font-lock.el, since other -;; mechanisms for turning on Font Lock mode, such as M-x font-lock-mode RET or -;; (add-hook 'c-mode-hook 'turn-on-font-lock), would cause Font Lock mode to be -;; turned on everywhere. That would not be intuitive or informative because -;; loading a file tells you nothing about the feature or how to control it. It -;; would also be contrary to the Principle of Least Surprise. sm. - -(defcustom font-lock-global-modes t - "*Modes for which Font Lock mode is automagically turned on. -Global Font Lock mode is controlled by the command `global-font-lock-mode'. -If nil, means no modes have Font Lock mode automatically turned on. -If t, all modes that support Font Lock mode have it automatically turned on. -If a list, it should be a list of `major-mode' symbol names for which Font Lock -mode should be automatically turned on. The sense of the list is negated if it -begins with `not'. For example: - (c-mode c++-mode) -means that Font Lock mode is turned on for buffers in C and C++ modes only." - :type '(choice (const :tag "none" nil) - (const :tag "all" t) - (set :menu-tag "mode specific" :tag "modes" - :value (not) - (const :tag "Except" not) - (repeat :inline t (symbol :tag "mode")))) - :group 'font-lock) - -(defun turn-on-font-lock-if-enabled () - (when (and (or font-lock-defaults - (assq major-mode font-lock-defaults-alist)) - (or (eq font-lock-global-modes t) - (if (eq (car-safe font-lock-global-modes) 'not) - (not (memq major-mode (cdr font-lock-global-modes))) - (memq major-mode font-lock-global-modes)))) - (let (inhibit-quit) - (turn-on-font-lock)))) - -;;;###autoload -(easy-mmode-define-global-mode - global-font-lock-mode font-lock-mode turn-on-font-lock-if-enabled - :extra-args (dummy)) - -;;; End of Global Font Lock mode. - ;;; Font Lock Support mode. ;; This is the code used to interface font-lock.el with any of its add-on @@ -1061,9 +812,9 @@ The value of this variable is used when Font Lock mode is turned on." :version "21.1" :group 'font-lock) -(defvar fast-lock-mode nil) -(defvar lazy-lock-mode nil) -(defvar jit-lock-mode nil) +(defvar fast-lock-mode) +(defvar lazy-lock-mode) +(defvar jit-lock-mode) (defun font-lock-turn-on-thing-lock () (let ((thing-mode (font-lock-value-in-major-mode font-lock-support-mode))) @@ -1084,26 +835,26 @@ The value of this variable is used when Font Lock mode is turned on." (not font-lock-keywords-only)))))) (defun font-lock-turn-off-thing-lock () - (cond (fast-lock-mode + (cond ((and (boundp 'fast-lock-mode) fast-lock-mode) (fast-lock-mode -1)) - (jit-lock-mode + ((and (boundp 'jit-lock-mode) jit-lock-mode) (jit-lock-unregister 'font-lock-fontify-region) ;; Reset local vars to the non-jit-lock case. (kill-local-variable 'font-lock-fontify-buffer-function)) - (lazy-lock-mode + ((and (boundp 'lazy-lock-mode) lazy-lock-mode) (lazy-lock-mode -1)))) (defun font-lock-after-fontify-buffer () - (cond (fast-lock-mode + (cond ((and (boundp 'fast-lock-mode) fast-lock-mode) (fast-lock-after-fontify-buffer)) ;; Useless now that jit-lock intercepts font-lock-fontify-buffer. -sm ;; (jit-lock-mode ;; (jit-lock-after-fontify-buffer)) - (lazy-lock-mode + ((and (boundp 'lazy-lock-mode) lazy-lock-mode) (lazy-lock-after-fontify-buffer)))) (defun font-lock-after-unfontify-buffer () - (cond (fast-lock-mode + (cond ((and (boundp 'fast-lock-mode) fast-lock-mode) (fast-lock-after-unfontify-buffer)) ;; Useless as well. It's only called when: ;; - turning off font-lock: it does not matter if we leave spurious @@ -1113,7 +864,7 @@ The value of this variable is used when Font Lock mode is turned on." ;; ;; (jit-lock-mode ;; (jit-lock-after-unfontify-buffer)) - (lazy-lock-mode + ((and (boundp 'lazy-lock-mode) lazy-lock-mode) (lazy-lock-after-unfontify-buffer)))) ;;; End of Font Lock Support mode. @@ -1205,13 +956,18 @@ The value of this variable is used when Font Lock mode is turned on." (font-lock-after-unfontify-buffer) (setq font-lock-fontified nil))) +(defvar font-lock-dont-widen nil + "If non-nil, font-lock will work on the non-widened buffer. +Useful for things like RMAIL and Info where the whole buffer is not +a very meaningful entity to highlight.") + (defun font-lock-default-fontify-region (beg end loudly) (save-buffer-state ((parse-sexp-lookup-properties font-lock-syntactic-keywords) (old-syntax-table (syntax-table))) (unwind-protect (save-restriction - (widen) + (unless font-lock-dont-widen (widen)) ;; Use the fontification syntax table, if any. (when font-lock-syntax-table (set-syntax-table font-lock-syntax-table)) @@ -1253,23 +1009,21 @@ The value of this variable is used when Font Lock mode is turned on." (defvar font-lock-extra-managed-props nil "Additional text properties managed by font-lock. This is used by `font-lock-default-unfontify-region' to decide -what properties to clear before refontifying a region. -Since it is more or less directly passed to `remove-text-properties', -it should have the shape of a property list (i.e. every other element -is ignored).") +what properties to clear before refontifying a region.") (defun font-lock-default-unfontify-region (beg end) (save-buffer-state nil - (remove-text-properties + (remove-list-of-text-properties beg end (append font-lock-extra-managed-props (if font-lock-syntactic-keywords - '(face nil syntax-table nil font-lock-multiline nil) - '(face nil font-lock-multiline nil)))))) + '(syntax-table face font-lock-multiline) + '(face font-lock-multiline)))))) ;; Called when any modification is made to buffer text. (defun font-lock-after-change-function (beg end old-len) - (let ((inhibit-point-motion-hooks t)) + (let ((inhibit-point-motion-hooks t) + (inhibit-quit t)) (save-excursion (save-match-data ;; Rescan between start of lines enclosing the region. @@ -1301,7 +1055,8 @@ delimit the region to fontify." (font-lock-fontify-region (point) (mark))) ((error quit) (message "Fontifying block...%s" error-data))))))) -(define-key facemenu-keymap "\M-g" 'font-lock-fontify-block) +(if (boundp 'facemenu-keymap) + (define-key facemenu-keymap "\M-g" 'font-lock-fontify-block)) ;;; End of Fontification functions. @@ -1588,7 +1343,8 @@ LIMIT can be modified by the value of its PRE-MATCH-FORM." (defun font-lock-fontify-keywords-region (start end &optional loudly) "Fontify according to `font-lock-keywords' between START and END. -START should be at the beginning of a line." +START should be at the beginning of a line. +LOUDLY, if non-nil, allows progress-meter bar." (unless (eq (car font-lock-keywords) t) (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords t))) @@ -1720,17 +1476,18 @@ Sets various variables using `font-lock-defaults' (or, if nil, using `font-lock-defaults-alist') and `font-lock-maximum-decoration'." ;; Set fontification defaults iff not previously set. (unless font-lock-set-defaults - (set (make-local-variable 'font-lock-set-defaults) t) + (set (make-local-variable 'font-lock-set-defaults) t) (make-local-variable 'font-lock-fontified) (make-local-variable 'font-lock-multiline) (let* ((defaults (or font-lock-defaults (cdr (assq major-mode font-lock-defaults-alist)))) (keywords (font-lock-choose-keywords (nth 0 defaults) - (font-lock-value-in-major-mode font-lock-maximum-decoration))) + (font-lock-value-in-major-mode font-lock-maximum-decoration))) (local (cdr (assq major-mode font-lock-keywords-alist))) (removed-keywords (cdr-safe (assq major-mode font-lock-removed-keywords-alist)))) + (set (make-local-variable 'font-lock-defaults) defaults) ;; Syntactic fontification? (when (nth 1 defaults) (set (make-local-variable 'font-lock-keywords-only) t)) @@ -1801,24 +1558,34 @@ Sets various variables using `font-lock-defaults' (or, if nil, using ;; But now we do it the custom way. Note that `defface' will not overwrite any ;; faces declared above via `custom-declare-face'. (defface font-lock-comment-face - '((((type tty pc) (class color) (background light)) (:foreground "red")) - (((type tty pc) (class color) (background dark)) (:foreground "red1")) - (((class grayscale) (background light)) + '((((class grayscale) (background light)) (:foreground "DimGray" :weight bold :slant italic)) (((class grayscale) (background dark)) (:foreground "LightGray" :weight bold :slant italic)) - (((class color) (background light)) (:foreground "Firebrick")) - (((class color) (background dark)) (:foreground "chocolate1")) + (((class color) (min-colors 88) (background light)) + (:foreground "Firebrick")) + (((class color) (min-colors 88) (background dark)) + (:foreground "chocolate1")) + (((class color) (min-colors 16) (background light)) + (:foreground "red")) + (((class color) (min-colors 16) (background dark)) + (:foreground "red1")) + (((class color) (min-colors 8) (background light)) + (:foreground "red")) + (((class color) (min-colors 8) (background dark)) + (:foreground "red1")) (t (:weight bold :slant italic))) "Font Lock mode face used to highlight comments." :group 'font-lock-highlighting-faces) (defface font-lock-string-face - '((((type tty) (class color)) (:foreground "green")) - (((class grayscale) (background light)) (:foreground "DimGray" :slant italic)) + '((((class grayscale) (background light)) (:foreground "DimGray" :slant italic)) (((class grayscale) (background dark)) (:foreground "LightGray" :slant italic)) - (((class color) (background light)) (:foreground "RosyBrown")) - (((class color) (background dark)) (:foreground "LightSalmon")) + (((class color) (min-colors 88) (background light)) (:foreground "RosyBrown")) + (((class color) (min-colors 88) (background dark)) (:foreground "LightSalmon")) + (((class color) (min-colors 16) (background light)) (:foreground "RosyBrown")) + (((class color) (min-colors 16) (background dark)) (:foreground "LightSalmon")) + (((class color) (min-colors 8)) (:foreground "green")) (t (:slant italic))) "Font Lock mode face used to highlight strings." :group 'font-lock-highlighting-faces) @@ -1829,75 +1596,94 @@ Sets various variables using `font-lock-defaults' (or, if nil, using :group 'font-lock-highlighting-faces) (defface font-lock-keyword-face - '((((type tty) (class color)) (:foreground "cyan" :weight bold)) - (((class grayscale) (background light)) (:foreground "LightGray" :weight bold)) + '((((class grayscale) (background light)) (:foreground "LightGray" :weight bold)) (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold)) - (((class color) (background light)) (:foreground "Purple")) - (((class color) (background dark)) (:foreground "Cyan")) + (((class color) (min-colors 88) (background light)) (:foreground "Purple")) + (((class color) (min-colors 88) (background dark)) (:foreground "Cyan")) + (((class color) (min-colors 16) (background light)) (:foreground "Purple")) + (((class color) (min-colors 16) (background dark)) (:foreground "Cyan")) + (((class color) (min-colors 8)) (:foreground "cyan" :weight bold)) (t (:weight bold))) "Font Lock mode face used to highlight keywords." :group 'font-lock-highlighting-faces) (defface font-lock-builtin-face - '((((type tty) (class color)) (:foreground "blue" :weight light)) - (((class grayscale) (background light)) (:foreground "LightGray" :weight bold)) + '((((class grayscale) (background light)) (:foreground "LightGray" :weight bold)) (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold)) - (((class color) (background light)) (:foreground "Orchid")) - (((class color) (background dark)) (:foreground "LightSteelBlue")) + (((class color) (min-colors 88) (background light)) (:foreground "Orchid")) + (((class color) (min-colors 88) (background dark)) (:foreground "LightSteelBlue")) + (((class color) (min-colors 16) (background light)) (:foreground "Orchid")) + (((class color) (min-colors 16) (background dark)) (:foreground "LightSteelBlue")) + (((class color) (min-colors 8)) (:foreground "blue" :weight bold)) (t (:weight bold))) "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")) + '((((class color) (min-colors 88) (background light)) (:foreground "Blue")) + (((class color) (min-colors 88) (background dark)) (:foreground "LightSkyBlue")) + (((class color) (min-colors 16) (background light)) (:foreground "Blue")) + (((class color) (min-colors 16) (background dark)) (:foreground "LightSkyBlue")) + (((class color) (min-colors 8)) (:foreground "blue" :weight bold)) (t (:inverse-video t :weight bold))) "Font Lock mode face used to highlight function names." :group 'font-lock-highlighting-faces) (defface font-lock-variable-name-face - '((((type tty) (class color)) (:foreground "yellow" :weight light)) - (((class grayscale) (background light)) + '((((class grayscale) (background light)) (:foreground "Gray90" :weight bold :slant italic)) (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold :slant italic)) - (((class color) (background light)) (:foreground "DarkGoldenrod")) - (((class color) (background dark)) (:foreground "LightGoldenrod")) + (((class color) (min-colors 88) (background light)) (:foreground "DarkGoldenrod")) + (((class color) (min-colors 88) (background dark)) (:foreground "LightGoldenrod")) + (((class color) (min-colors 16) (background light)) (:foreground "DarkGoldenrod")) + (((class color) (min-colors 16) (background dark)) (:foreground "LightGoldenrod")) + (((class color) (min-colors 8)) (:foreground "yellow" :weight light)) (t (:weight bold :slant italic))) "Font Lock mode face used to highlight variable names." :group 'font-lock-highlighting-faces) (defface font-lock-type-face - '((((type tty) (class color)) (:foreground "green")) - (((class grayscale) (background light)) (:foreground "Gray90" :weight bold)) + '((((class grayscale) (background light)) (:foreground "Gray90" :weight bold)) (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold)) - (((class color) (background light)) (:foreground "ForestGreen")) - (((class color) (background dark)) (:foreground "PaleGreen")) + (((class color) (min-colors 88) (background light)) (:foreground "ForestGreen")) + (((class color) (min-colors 88) (background dark)) (:foreground "PaleGreen")) + (((class color) (min-colors 16) (background light)) (:foreground "ForestGreen")) + (((class color) (min-colors 16) (background dark)) (:foreground "PaleGreen")) + (((class color) (min-colors 8)) (:foreground "green")) (t (:weight bold :underline t))) "Font Lock mode face used to highlight type and classes." :group 'font-lock-highlighting-faces) (defface font-lock-constant-face - '((((type tty) (class color)) (:foreground "magenta")) - (((class grayscale) (background light)) + '((((class grayscale) (background light)) (:foreground "LightGray" :weight bold :underline t)) (((class grayscale) (background dark)) (:foreground "Gray50" :weight bold :underline t)) - (((class color) (background light)) (:foreground "CadetBlue")) - (((class color) (background dark)) (:foreground "Aquamarine")) + (((class color) (min-colors 88) (background light)) (:foreground "CadetBlue")) + (((class color) (min-colors 88) (background dark)) (:foreground "Aquamarine")) + (((class color) (min-colors 16) (background light)) (:foreground "CadetBlue")) + (((class color) (min-colors 16) (background dark)) (:foreground "Aquamarine")) + (((class color) (min-colors 8)) (:foreground "magenta")) (t (:weight bold :underline t))) "Font Lock mode face used to highlight constants and labels." :group 'font-lock-highlighting-faces) (defface font-lock-warning-face - '((((type tty) (class color)) (:foreground "red")) - (((class color) (background light)) (:foreground "Red" :weight bold)) - (((class color) (background dark)) (:foreground "Pink" :weight bold)) + '((((class color) (min-colors 88) (background light)) (:foreground "Red" :weight bold)) + (((class color) (min-colors 88) (background dark)) (:foreground "Pink" :weight bold)) + (((class color) (min-colors 16) (background light)) (:foreground "Red" :weight bold)) + (((class color) (min-colors 16) (background dark)) (:foreground "Pink" :weight bold)) + (((class color) (min-colors 8)) (:foreground "red")) (t (:inverse-video t :weight bold))) "Font Lock mode face used to highlight warnings." :group 'font-lock-highlighting-faces) +(defface font-lock-preprocessor-face + '((t :inherit font-lock-builtin-face)) + "Font Lock mode face used to highlight preprocessor directives." + :group 'font-lock-highlighting-faces) + ;;; End of Colour etc. support. ;;; Menu support. @@ -2006,8 +1792,8 @@ Sets various variables using `font-lock-defaults' (or, if nil, using ;;; Various regexp information shared by several modes. ;;; Information specific to a single mode should go in its load library. -;; Font Lock support for C, C++, Objective-C and Java modes will one day be in -;; some cc-font.el (and required by cc-mode.el). However, the below function +;; Font Lock support for C, C++, Objective-C and Java modes is now in +;; cc-fonts.el (and required by cc-mode.el). However, the below function ;; should stay in font-lock.el, since it is used by other libraries. sm. (defun font-lock-match-c-style-declaration-item-and-skip-to-next (limit) @@ -2018,7 +1804,7 @@ Does not move further than LIMIT. 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 +it) is expected to be 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 ( @@ -2037,7 +1823,7 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." (let ((pos (point))) (skip-chars-backward " \t\n") (skip-syntax-backward "w") - (unless (looking-at "\\(\\sw+\\)[ \t\n]*\\sw*_\\sw*[ \t\n]*\\((\\)?") + (unless (looking-at "\\(\\sw+\\)[ \t\n]*\\sw+[ \t\n]*\\(((?\\)?") ;; Looks like it was something else, so go back to where we ;; were and reset the match data by rematching. (goto-char pos) @@ -2071,7 +1857,7 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." ;; Variable declarations. "\\(const\\(ant\\)?\\|custom\\|face\\|parameter\\|var\\)\\|" ;; Structure declarations. - "\\(class\\|group\\|package\\|struct\\|type\\)" + "\\(class\\|group\\|theme\\|package\\|struct\\|type\\)" "\\)\\)\\>" ;; Any whitespace and defined object. "[ \t'\(]*" @@ -2103,10 +1889,13 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." "condition-case" "track-mouse" "eval-after-load" "eval-and-compile" "eval-when-compile" "eval-when" + "with-category-table" "with-current-buffer" "with-electric-help" + "with-local-quit" "with-no-warnings" "with-output-to-string" "with-output-to-temp-buffer" + "with-selected-window" "with-syntax-table" "with-temp-buffer" "with-temp-file" "with-temp-message" - "with-timeout") t) + "with-timeout" "with-timeout-handler") t) "\\>") 1) ;; @@ -2121,7 +1910,13 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." "proclaim" "declaim" "declare" "symbol-macrolet" "lexical-let" "lexical-let*" "flet" "labels" "compiler-let" "destructuring-bind" "macrolet" "tagbody" "block" - "return" "return-from") t) + "return" "return-from" + "with-accessors" "with-compilation-unit" + "with-condition-restarts" "with-hash-table-iterator" + "with-input-from-string" "with-open-file" + "with-open-stream" "with-output-to-string" + "with-package-iterator" "with-simple-restart" + "with-slots" "with-standard-io-syntax") t) "\\>") 1) ;; @@ -2146,857 +1941,18 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." ;; ELisp and CLisp `&' keywords as types. '("\\&\\sw+\\>" . font-lock-type-face) ;; - ;; CL `with-' and `do-' constructs - '("(\\(\\(do-\\|with-\\)\\(\\s_\\|\\w\\)*\\)" 1 font-lock-keyword-face) +;;; This is too general -- rms. +;;; A user complained that he has functions whose names start with `do' +;;; and that they get the wrong color. +;;; ;; CL `with-' and `do-' constructs +;;; '("(\\(\\(do-\\|with-\\)\\(\\s_\\|\\w\\)*\\)" 1 font-lock-keyword-face) ))) "Gaudy level highlighting for Lisp modes.") (defvar lisp-font-lock-keywords lisp-font-lock-keywords-1 "Default expressions to highlight in Lisp 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 accepted types are used to provide default variable values. - -(define-widget 'font-lock-extra-types-widget 'radio - "Widget `:type' for members of the custom group `font-lock-extra-types'. -Members should `:load' the package `font-lock' to use this widget." - :args '((const :tag "none" nil) - (repeat :tag "types" regexp))) - -(defcustom c-font-lock-extra-types '("FILE" "\\sw+_t" "Lisp_Object") - "*List of extra types to fontify in C mode. -Each list item should be a regexp not containing word-delimiters. -For example, a value of (\"FILE\" \"\\\\sw+_t\") means the word FILE and words -ending in _t are treated as type names. - -The value of this variable is used when Font Lock mode is turned on." - :type 'font-lock-extra-types-widget - :group 'font-lock-extra-types) - -(defcustom c++-font-lock-extra-types - '("\\sw+_t" - "\\([iof]\\|str\\)+stream\\(buf\\)?" "ios" - "string" "rope" - "list" "slist" - "deque" "vector" "bit_vector" - "set" "multiset" - "map" "multimap" - "hash\\(_\\(m\\(ap\\|ulti\\(map\\|set\\)\\)\\|set\\)\\)?" - "stack" "queue" "priority_queue" - "type_info" - "iterator" "const_iterator" "reverse_iterator" "const_reverse_iterator" - "reference" "const_reference") - "*List of extra types to fontify in C++ mode. -Each list item should be a regexp not containing word-delimiters. -For example, a value of (\"string\") means the word string is treated as a type -name. - -The value of this variable is used when Font Lock mode is turned on." - :type 'font-lock-extra-types-widget - :group 'font-lock-extra-types) - -(defcustom objc-font-lock-extra-types '("Class" "BOOL" "IMP" "SEL") - "*List of extra types to fontify in Objective-C mode. -Each list item should be a regexp not containing word-delimiters. -For example, a value of (\"Class\" \"BOOL\" \"IMP\" \"SEL\") means the words -Class, BOOL, IMP and SEL are treated as type names. - -The value of this variable is used when Font Lock mode is turned on." - :type 'font-lock-extra-types-widget - :group 'font-lock-extra-types) - -(defcustom java-font-lock-extra-types - '("[A-Z\300-\326\330-\337]\\sw*[a-z]\\sw*" "URL") - "*List of extra types to fontify in Java mode. -Each list item should be a regexp not containing word-delimiters. -For example, a value of (\"[A-Z\300-\326\330-\337]\\\\sw*[a-z]\\\\sw*\" \"URL\") means -capitalised words (that conform to the Java id spec) and URL are treated as -type names. - -The value of this variable is used when Font Lock mode is turned on." - :type 'font-lock-extra-types-widget - :group 'font-lock-extra-types) - -;;; C. - -;; [Murmur murmur murmur] Maestro, drum-roll please... [Murmur murmur murmur.] -;; Ahem. [Murmur murmur murmur] Lay-dees an Gennel-men. [Murmur murmur shhh!] -;; I am most proud and humbly honoured today [murmur murmur cough] to present -;; to you good people, the winner of the Second Millennium Award for The Most -;; Hairy Language Syntax. [Ahhh!] All rise please. [Shuffle shuffle -;; shuffle.] And a round of applause please. For... The C Language! [Roar.] -;; -;; Thank you... You are too kind... It is with a feeling of great privilege -;; and indeed emotion [sob] that I accept this award. It has been a long hard -;; road. But we know our destiny. And our future. For we must not rest. -;; There are more tokens to overload, more shoehorn, more methodologies. But -;; more is a plus! [Ha ha ha.] And more means plus! [Ho ho ho.] The future -;; is C++! [Ohhh!] The Third Millennium Award... Will be ours! [Roar.] - -(let* ((c-keywords - (eval-when-compile - (regexp-opt '("break" "continue" "do" "else" "for" "if" "return" - "switch" "while" "sizeof" - ;; Type related, but we don't do anything special. - "typedef" "extern" "auto" "register" "static" - "volatile" "const" - ;; Dan Nicolaescu says this is new. - "restrict" - ;; Henrik Enberg says this is new. - "inline")))) - (c-type-specs - (eval-when-compile - (regexp-opt '("enum" "struct" "union")))) - (c-type-specs-depth - (regexp-opt-depth c-type-specs)) - (c-type-names - `(mapconcat 'identity - (cons - ,(eval-when-compile - (regexp-opt - '("char" "short" "int" "long" "signed" "unsigned" - "float" "double" "void" "complex" - ;; Henrik Enberg says these are new. - "_Complex" "_Imaginary" "_Bool"))) - c-font-lock-extra-types) - "\\|")) - (c-type-names-depth - `(regexp-opt-depth ,c-type-names)) - (c-preprocessor-directives - (eval-when-compile - (regexp-opt - '("define" "elif" "else" "endif" "error" "file" "if" "ifdef" - "ifndef" "include" "line" "pragma" "undef")))) - (c-preprocessor-directives-depth - (regexp-opt-depth c-preprocessor-directives))) - (defconst c-font-lock-keywords-1 - (list - ;; - ;; These are all anchored at the beginning of line for speed. - ;; Note that `c++-font-lock-keywords-1' depends on `c-font-lock-keywords-1'. - ;; - ;; Fontify function name definitions (GNU style; without type on line). - '("^\\(\\sw+\\)[ \t]*(" 1 font-lock-function-name-face) - ;; - ;; Fontify error directives. - '("^#[ \t]*error[ \t]+\\(.+\\)" 1 font-lock-warning-face prepend) - ;; - ;; Fontify filenames in #include <...> preprocessor directives as strings. - '("^#[ \t]*\\(import\\|include\\)[ \t]*\\(<[^>\"\n]*>?\\)" - 2 font-lock-string-face) - ;; - ;; Fontify function macro names. - '("^#[ \t]*define[ \t]+\\(\\sw+\\)(" 1 font-lock-function-name-face) - ;; - ;; Fontify symbol names in #elif or #if ... defined preprocessor directives. - '("^#[ \t]*\\(elif\\|if\\)\\>" - ("\\<\\(defined\\)\\>[ \t]*(?\\(\\sw+\\)?" nil nil - (1 font-lock-builtin-face) (2 font-lock-variable-name-face nil t))) - ;; - ;; Fontify otherwise as symbol names, and the preprocessor directive names. - (list - (concat "^#[ \t]*\\(" c-preprocessor-directives - "\\)\\>[ \t!]*\\(\\sw+\\)?") - '(1 font-lock-builtin-face) - (list (+ 2 c-preprocessor-directives-depth) - 'font-lock-variable-name-face nil t))) - "Subdued level highlighting for C mode.") - - (defconst c-font-lock-keywords-2 - (append c-font-lock-keywords-1 - (list - ;; - ;; Simple regexps for speed. - ;; - ;; Fontify all type names. - `(eval . - (cons (concat "\\<\\(" ,c-type-names "\\)\\>") 'font-lock-type-face)) - ;; - ;; Fontify all builtin keywords (except case, default and goto; see below). - (concat "\\<\\(" c-keywords "\\|" c-type-specs "\\)\\>") - ;; - ;; Fontify case/goto keywords and targets, and case default/goto tags. - '("\\<\\(case\\|goto\\)\\>" - (1 font-lock-keyword-face) - ("\\(-[0-9]+\\|\\sw+\\)" - ;; Return limit of search. - (save-excursion (skip-chars-forward "^:\n") (point)) - nil - (1 font-lock-constant-face nil t))) - ;; Anders Lindgren points out that it is quicker - ;; to use MATCH-ANCHORED to effectively anchor the regexp on the left. - ;; This must come after the one for keywords and targets. - ;; Note: the lack of `:' in the first char-range prevents `bar' from being - ;; highlighted in "foo: bar:". But adding `:' would break cases like - ;; "test1 ? test2 ? foo : bar : baz". - '(":" ("\\(?:^\\|[{};]\\)[ \t]*\\(\\sw+\\)[ \t]*:" - (beginning-of-line) (end-of-line) - (1 font-lock-constant-face))) - )) - "Medium level highlighting for C mode. See also `c-font-lock-extra-types'.") - - (defconst c-font-lock-keywords-3 - (append c-font-lock-keywords-2 - ;; - ;; More complicated regexps for more complete highlighting for types. - ;; We still have to fontify type specifiers individually, as C is so hairy. - (list - ;; - ;; Fontify all storage types, plus their items. - `(eval . - (list (concat "\\<\\(" ,c-type-names "\\)\\>" - "\\([ \t*&]+\\sw+\\>\\)*") - ;; Fontify each declaration item. - `(font-lock-match-c-style-declaration-item-and-skip-to-next - ;; Start with point after all type specifiers. - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (or (match-beginning - ,(+ ,c-type-names-depth 2)) - (match-end 1)))) - ;; Finish with point after first type specifier. - (goto-char (match-end 1)) - ;; Fontify as a variable or function name. - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face))))) - ;; - ;; Fontify all storage specs and types, plus their items. - `(,(concat "\\<\\(" c-type-specs "\\)\\>" "[ \t]*\\(\\sw+\\)?") - (1 font-lock-keyword-face) - (,(+ c-type-specs-depth 2) font-lock-type-face nil t) - (font-lock-match-c-style-declaration-item-and-skip-to-next - (save-excursion (skip-chars-forward "^;{}") (point)) - ;; Finish with point after the variable name if - ;; there is one. - (if (match-end 2) - (goto-char (match-end 2))) - ;; Fontify as a variable or function name. - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face) nil t))) - ;; - ;; Fontify structures, or typedef names, plus their items. - '("\\(}\\)[ \t*]*\\sw" - (font-lock-match-c-style-declaration-item-and-skip-to-next - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (match-end 1))) nil - (1 font-lock-type-face))) - ;; - ;; Fontify anything at beginning of line as a declaration or definition. - '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*" - (1 font-lock-type-face) - (font-lock-match-c-style-declaration-item-and-skip-to-next - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (or (match-beginning 2) (match-end 1)))) nil - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face)))) - )) - "Gaudy level highlighting for C mode. -See also `c-font-lock-extra-types'.")) - -(defun c-font-lock-syntactic-face-function (state) - (save-excursion - (if (nth 3 state) - ;; Check whether the string is properly terminated. - (let ((nstate (parse-partial-sexp (point) (line-end-position) - nil nil state 'syntax-table))) - (if (and (eolp) (not (nth 5 nstate)) (nth 3 nstate)) - ;; We're inside a string, at EOL and there was no \. - font-lock-warning-face - font-lock-string-face)) - (goto-char (nth 8 state)) - ;; `doxygen' uses /*! while others use /**. - (if (looking-at "/\\*[*!]\n") - font-lock-doc-face font-lock-comment-face)))) - -(defvar c-font-lock-keywords c-font-lock-keywords-1 - "Default expressions to highlight in C mode. -See also `c-font-lock-extra-types'.") - -;;; C++. - -(defun font-lock-match-c++-style-declaration-item-and-skip-to-next (limit) - ;; Regexp matches after point: word::word ( - ;; ^^^^ ^^^^ ^^^^ ^ - ;; Where the match subexpressions are: 1 3 5 6 - ;; - ;; Item is delimited by (match-beginning 1) and (match-end 1). - ;; If (match-beginning 3) is non-nil, that part of the item incloses a `<>'. - ;; If (match-beginning 5) is non-nil, that part of the item follows a `::'. - ;; If (match-beginning 6) is non-nil, the item is followed by a `('. - (when (looking-at (eval-when-compile - (concat - ;; Skip any leading whitespace. - "[ \t\n*&]*" - ;; This is `c++-type-spec' from below. (Hint hint!) - "\\(\\sw+\\)" ; The instance? - "\\([ \t\n]*<\\(\\(?:[^<>]\\|<[^>]+>\\)+\\)[ \t\n*&]*>\\)?" ; Or template? - "\\([ \t\n]*::[ \t\n*~]*\\(\\sw+\\)\\)*" ; Or member? - ;; Match any trailing parenthesis. - "[ \t\n]*\\((\\)?"))) - (save-match-data - (condition-case nil - (save-restriction - ;; Restrict to the end of line, currently guaranteed to be LIMIT. - (narrow-to-region (point-min) limit) - (goto-char (match-end 1)) - ;; Move over any item value, etc., to the next item. - (while (not (looking-at "[ \t\n]*\\(\\(,\\)\\|;\\|\\'\\)")) - (goto-char (or (scan-sexps (point) 1) (point-max)))) - (goto-char (match-end 2))) - (error t))))) - -(defun font-lock-match-c++-structor-declaration (limit) - ;; Match C++ constructors and destructors inside class declarations. - (let ((res nil) - (regexp (concat "^\\s-+\\(\\(virtual\\|explicit\\)\\s-+\\)*~?\\(\\<" - (mapconcat 'identity - c++-font-lock-extra-types "\\|") - "\\>\\)\\s-*(" - ;; Don't match function pointer declarations, e.g.: - ;; Foo (*fptr)(); - "\\s-*[^*( \t]"))) - (while (progn (setq res (re-search-forward regexp limit t)) - (and res - (save-excursion - (beginning-of-line) - (save-match-data - (not (vectorp (c-at-toplevel-p)))))))) - res)) - -(let* ((c++-keywords - (eval-when-compile - (regexp-opt - '("break" "continue" "do" "else" "for" "if" "return" "switch" - "while" "asm" "catch" "delete" "new" "sizeof" "this" "throw" "try" - "typeid" - ;; Branko Cibej 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" - ;; Standard C++ operator names. - "and" "and_eq" "bitand" "bitor" "compl" "not" "not_eq" - "or" "or_eq" "xor" "xor_eq")))) - (c++-operators - (eval-when-compile - (regexp-opt - ;; Taken from Stroustrup, minus keywords otherwise fontified. - '("+" "-" "*" "/" "%" "^" "&" "|" "~" "!" "=" "<" ">" "+=" "-=" - "*=" "/=" "%=" "^=" "&=" "|=" "<<" ">>" ">>=" "<<=" "==" "!=" - "<=" ">=" "&&" "||" "++" "--" "->*" "," "->" "[]" "()")))) - (c++-type-specs - (eval-when-compile - (regexp-opt - '("class" "public" "private" "protected" "typename" - "struct" "union" "enum" "namespace" "using" - ;; Eric Hopper says these are new. - "static_cast" "dynamic_cast" "const_cast" "reinterpret_cast") t))) - (c++-type-specs-depth - (regexp-opt-depth c++-type-specs)) - (c++-type-names - `(mapconcat 'identity - (cons - ,(eval-when-compile - (regexp-opt - '("signed" "unsigned" "short" "long" - "int" "char" "float" "double" "void" - "bool" "complex"))) - c++-font-lock-extra-types) - "\\|")) - (c++-type-names-depth `(regexp-opt-depth ,c++-type-names)) - ;; - ;; A brave attempt to match templates following a type and/or match - ;; class membership. See and sync the above function - ;; `font-lock-match-c++-style-declaration-item-and-skip-to-next'. - (c++-type-suffix (concat "\\([ \t]*<\\(\\(?:[^<>\n]\\|<[^>\n]+>\\)+\\)[ \t*&]*>\\)?" - "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)*")) - (c++-type-suffix-depth (regexp-opt-depth c++-type-suffix)) - ;; If the string is a type, it may be followed by the cruft above. - (c++-type-spec (concat "\\(\\sw+\\)\\>" c++-type-suffix)) - (c++-type-spec-depth (regexp-opt-depth c++-type-spec)) - ;; - ;; Parenthesis depth of user-defined types not forgetting their cruft. - (c++-type-depth `(regexp-opt-depth - (concat ,c++-type-names ,c++-type-suffix))) - ) - (defconst c++-font-lock-keywords-1 - (append - ;; - ;; The list `c-font-lock-keywords-1' less that for function names. - (cdr c-font-lock-keywords-1) - (list - ;; - ;; Fontify function name definitions, possibly incorporating class names. - (list (concat "^" c++-type-spec "[ \t]*(") - '(1 (if (or (match-beginning 2) (match-beginning 4)) - font-lock-type-face - font-lock-function-name-face)) - '(3 font-lock-type-face nil t) - '(5 font-lock-function-name-face nil t)) - )) - "Subdued level highlighting for C++ mode.") - - (defconst c++-font-lock-keywords-2 - (append c++-font-lock-keywords-1 - (list - ;; - ;; The list `c-font-lock-keywords-2' for C++ plus operator overloading. - `(eval . - (cons (concat "\\<\\(" ,c++-type-names "\\)\\>") - 'font-lock-type-face)) - ;; - ;; Fontify operator overloading. - (list (concat "\\<\\(operator\\)\\>[ \t]*\\(" c++-operators "\\)?") - '(1 font-lock-keyword-face) - '(2 font-lock-builtin-face nil t)) - ;; - ;; Fontify case/goto keywords and targets, and case default/goto tags. - '("\\<\\(case\\|goto\\)\\>" - (1 font-lock-keyword-face) - ("\\(-[0-9]+\\|\\sw+\\)[ \t]*\\(::\\)?" - ;; Return limit of search. - (save-excursion - (while (progn - (skip-chars-forward "^:\n") - (looking-at "::")) - (forward-char 2)) - (point)) - nil - (1 (if (match-beginning 2) - font-lock-type-face - font-lock-constant-face) nil t))) - ;; This must come after the one for keywords and targets. - '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:\\($\\|[^:]\\)" - (beginning-of-line) (end-of-line) - (1 font-lock-constant-face))) - ;; - ;; Fontify other builtin keywords. - (concat "\\<\\(" c++-keywords "\\|" c++-type-specs "\\)\\>") - ;; - ;; Eric Hopper says `true' and `false' are new. - '("\\<\\(false\\|true\\)\\>" . font-lock-constant-face) - )) - "Medium level highlighting for C++ mode. -See also `c++-font-lock-extra-types'.") - - (defconst c++-font-lock-keywords-3 - (append c++-font-lock-keywords-2 - ;; - ;; More complicated regexps for more complete highlighting for types. - (list - ;; - ;; Fontify all storage classes and type specifiers, plus their items. - `(eval . - (list (concat "\\<\\(" ,c++-type-names "\\)\\>" ,c++-type-suffix - "\\([ \t*&]+" ,c++-type-spec "\\)*") - ;; The name of any template type. - `(,(+ ,c++-type-names-depth 3) font-lock-type-face nil t) - ;; Fontify each declaration item. - `(font-lock-match-c++-style-declaration-item-and-skip-to-next - ;; Start with point after all type specifiers. - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (or (match-beginning - ,(+ ,c++-type-depth 2)) - (match-end 1)))) - ;; Finish with point after first type specifier. - (goto-char (match-end 1)) - ;; Fontify as a variable or function name. - (1 (cond ((or (match-beginning 2) (match-beginning 4)) - font-lock-type-face) - ((and (match-beginning 6) (c-at-toplevel-p)) - font-lock-function-name-face) - (t - font-lock-variable-name-face))) - (3 font-lock-type-face nil t) - (5 (if (match-beginning 6) - font-lock-function-name-face - font-lock-variable-name-face) nil t)))) - ;; - ;; Fontify all storage specs and types, plus their items. - `(,(concat "\\<" c++-type-specs "\\>" c++-type-suffix - "[ \t]*\\(" c++-type-spec "\\)?") - ;; The name of any template type. - (,(+ c++-type-specs-depth 2) 'font-lock-type-face nil t) - ;; The name of any type. - (,(+ c++-type-specs-depth c++-type-suffix-depth 2) - font-lock-type-face nil t) - ;; Fontify each declaration item. - (font-lock-match-c++-style-declaration-item-and-skip-to-next - ;; Start with point after all type specifiers. - (save-excursion (skip-chars-forward "^;{}") (point)) - ;; Finish with point after first type specifier. - nil - ;; Fontify as a variable or function name. - (1 (cond ((or (match-beginning 2) (match-beginning 4)) - font-lock-type-face) - ((and (match-beginning 6) (c-at-toplevel-p)) - font-lock-function-name-face) - (t - font-lock-variable-name-face))) - (3 font-lock-type-face nil t) - (5 (if (match-beginning 6) - font-lock-function-name-face - font-lock-variable-name-face) nil t))) - ;; - ;; Fontify structures, or typedef names, plus their items. - '("\\(}\\)[ \t*]*\\sw" - (font-lock-match-c++-style-declaration-item-and-skip-to-next - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (match-end 1))) nil - (1 font-lock-type-face))) - ;; - ;; Fontify anything at beginning of line as a declaration or definition. - `(,(concat "^\\(" c++-type-spec "[ \t*&]*\\)+") - (font-lock-match-c++-style-declaration-item-and-skip-to-next - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (match-beginning 1))) - (goto-char (match-end 1)) - (1 (cond ((or (match-beginning 2) (match-beginning 4)) - font-lock-type-face) - ((match-beginning 6) font-lock-function-name-face) - (t font-lock-variable-name-face))) - (3 font-lock-type-face nil t) - (5 (if (match-beginning 6) - font-lock-function-name-face - font-lock-variable-name-face) nil t))) - ;; - ;; Fontify constructors and destructors inside class declarations. - '(font-lock-match-c++-structor-declaration - (3 font-lock-function-name-face t)) - )) - "Gaudy level highlighting for C++ mode. -See also `c++-font-lock-extra-types'.") - ) - -(defvar c++-font-lock-keywords c++-font-lock-keywords-1 - "Default expressions to highlight in C++ mode. -See also `c++-font-lock-extra-types'.") - -;;; Objective-C. - -;; Regexps written with help from Stephen Peters and -;; Jacques Duthen Prestataire . -(let* ((objc-keywords - (eval-when-compile - (regexp-opt '("break" "continue" "do" "else" "for" "if" "return" - "switch" "while" "sizeof" "self" "super" - "typedef" "auto" "extern" "static" - "volatile" "const")))) - (objc-type-specs - (eval-when-compile - (regexp-opt - '("register" "struct" "union" "enum" - "oneway" "in" "out" "inout" "bycopy" "byref") t))) - (objc-type-specs-depth - (regexp-opt-depth objc-type-specs)) - (objc-type-names - `(mapconcat 'identity - (cons - ,(eval-when-compile - (regexp-opt - '("signed" "unsigned" "short" "long" - "int" "char" "float" "double" "void" - "id"))) - objc-font-lock-extra-types) - "\\|")) - (objc-type-names-depth - `(regexp-opt-depth ,objc-type-names)) - ) - (defconst objc-font-lock-keywords-1 - (append - ;; - ;; The list `c-font-lock-keywords-1' less that for function names. - (cdr c-font-lock-keywords-1) - (list - ;; - ;; Fontify compiler directives. - '("@\\(\\sw+\\)\\>" - (1 font-lock-keyword-face) - ("\\=[ \t:<,]*\\(\\sw+\\)" nil nil - (1 font-lock-type-face))) - ;; - ;; Fontify method names and arguments. Oh Lordy! - ;; First, on the same line as the function declaration. - '("^[+-][ \t]*\\(PRIVATE\\>\\)?[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)" - (1 font-lock-keyword-face nil t) - (3 font-lock-function-name-face) - ("\\=[ \t]*\\(\\sw+\\)?:[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)" - nil nil - (1 font-lock-function-name-face nil t) - (3 font-lock-variable-name-face))) - ;; Second, on lines following the function declaration. - '(":" ("^[ \t]*\\(\\sw+\\)?:[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)" - (beginning-of-line) (end-of-line) - (1 font-lock-function-name-face nil t) - (3 font-lock-variable-name-face))) - )) - "Subdued level highlighting for Objective-C mode.") - - (defconst objc-font-lock-keywords-2 - (append objc-font-lock-keywords-1 - (list - ;; - ;; Simple regexps for speed. - ;; - ;; Fontify all type specifiers. - `(eval . - (cons (concat "\\<\\(" ,objc-type-names "\\)\\>") - 'font-lock-type-face)) - ;; - ;; Fontify all builtin keywords (except case, default and goto; see below). - (concat "\\<\\(" objc-keywords "\\|" objc-type-specs "\\)\\>") - ;; - ;; Fontify case/goto keywords and targets, and case default/goto tags. - '("\\<\\(case\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?" - (1 font-lock-keyword-face) (2 font-lock-constant-face nil t)) - ;; Fontify tags iff sole statement on line, otherwise we detect selectors. - ;; This must come after the one for keywords and targets. - '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$" - (beginning-of-line) (end-of-line) - (1 font-lock-constant-face))) - ;; - ;; Fontify null object pointers. - '("\\<[Nn]il\\>" . font-lock-constant-face) - )) - "Medium level highlighting for Objective-C mode. -See also `objc-font-lock-extra-types'.") - - (defconst objc-font-lock-keywords-3 - (append objc-font-lock-keywords-2 - ;; - ;; More complicated regexps for more complete highlighting for types. - ;; We still have to fontify type specifiers individually, as C is so hairy. - (list - ;; - ;; Fontify all storage classes and type specifiers, plus their items. - `(eval . - (list (concat "\\<\\(" ,objc-type-names "\\)\\>" - "\\([ \t*&]+\\sw+\\>\\)*") - ;; Fontify each declaration item. - `(font-lock-match-c-style-declaration-item-and-skip-to-next - ;; Start with point after all type specifiers. - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (or (match-beginning - ,(+ ,objc-type-names-depth 2)) - (match-end 1)))) - ;; Finish with point after first type specifier. - (goto-char (match-end 1)) - ;; Fontify as a variable or function name. - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face))))) - ;; - ;; Fontify all storage specs and types, plus their items. - `(,(concat "\\<\\(" objc-type-specs "[ \t]*\\)+\\>" "[ \t]*\\(\\sw+\\)?") - ;; The name of any type. - (,(+ objc-type-specs-depth 2) font-lock-type-face nil t) - ;; Fontify each declaration item. - (font-lock-match-c++-style-declaration-item-and-skip-to-next - (save-excursion (skip-chars-forward "^;{}") (point)) nil - ;; Fontify as a variable or function name. - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face)))) - ;; - ;; Fontify structures, or typedef names, plus their items. - '("\\(}\\)[ \t*]*\\sw" - (font-lock-match-c-style-declaration-item-and-skip-to-next - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (match-end 1))) nil - (1 font-lock-type-face))) - ;; - ;; Fontify anything at beginning of line as a declaration or definition. - '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*" - (1 font-lock-type-face) - (font-lock-match-c-style-declaration-item-and-skip-to-next - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (or (match-beginning 2) (match-end 1)))) nil - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face)))) - )) - "Gaudy level highlighting for Objective-C mode. -See also `objc-font-lock-extra-types'.") - ) - -(defvar objc-font-lock-keywords objc-font-lock-keywords-1 - "Default expressions to highlight in Objective-C mode. -See also `objc-font-lock-extra-types'.") - -;;; Java. - -;; Regexps written with help from Fred White , -;; Anders Lindgren and Carl Manning . -(let* ((java-keywords - (eval-when-compile - (regexp-opt - '("catch" "do" "else" "super" "this" "finally" "for" "if" - ;; Anders Lindgren says these have gone. - ;; "cast" "byvalue" "future" "generic" "operator" "var" - ;; "inner" "outer" "rest" - "implements" "extends" "throws" "instanceof" "new" - "interface" "return" "switch" "throw" "try" "while")))) - ;; - ;; Classes immediately followed by an object name. - (java-type-names - `(mapconcat 'identity - (cons - ,(eval-when-compile - (regexp-opt '("boolean" "char" "byte" "short" "int" "long" - "float" "double" "void"))) - java-font-lock-extra-types) - "\\|")) - (java-type-names-depth `(regexp-opt-depth ,java-type-names)) - ;; - ;; These are eventually followed by an object name. - (java-type-specs - (eval-when-compile - (regexp-opt - '("abstract" "const" "final" "synchronized" "transient" "static" - ;; Anders Lindgren says this has gone. - ;; "threadsafe" - "volatile" "public" "private" "protected" "native" - ;; Carl Manning says this is new. - "strictfp")))) - ) - (defconst java-font-lock-keywords-1 - (list - ;; - ;; Fontify class names. - '("\\<\\(class\\)\\>[ \t]*\\(\\sw+\\)?" - (1 font-lock-keyword-face) (2 font-lock-type-face nil t)) - ;; - ;; Fontify package names in import directives. - '("\\<\\(import\\|package\\)\\>[ \t]*\\(\\sw+\\)?" - (1 font-lock-keyword-face) - (2 font-lock-constant-face nil t) - ("\\=\\.\\(\\*\\|\\sw+\\)" nil nil - (1 font-lock-constant-face nil t))) - ) - "Subdued level highlighting for Java mode.") - - (defconst java-font-lock-keywords-2 - (append java-font-lock-keywords-1 - (list - ;; - ;; Fontify class names. - `(eval . - (cons (concat "\\<\\(" ,java-type-names "\\)\\>[^.]") - '(1 font-lock-type-face))) - ;; - ;; Fontify all builtin keywords (except below). - (concat "\\<\\(" java-keywords "\\|" java-type-specs "\\)\\>") - ;; - ;; Fontify keywords and targets, and case default/goto tags. - (list "\\<\\(break\\|case\\|continue\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?" - '(1 font-lock-keyword-face) '(2 font-lock-constant-face nil t)) - ;; This must come after the one for keywords and targets. - '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$" - (beginning-of-line) (end-of-line) - (1 font-lock-constant-face))) - ;; - ;; Fontify all constants. - '("\\<\\(false\\|null\\|true\\)\\>" . font-lock-constant-face) - ;; - ;; Javadoc tags within comments. - (list - (concat "@\\(" - "author\\|deprecated\\|exception" - "\\|link\\|return\\|see\\|serial\\|serialData\\|serialField" - "\\|since\\|throws" - "\\|version" - "\\)\\>") - '(1 font-lock-constant-face prepend)) - '("@\\(param\\)\\>[ \t]*\\(\\sw+\\)?" - (1 font-lock-constant-face prepend) - (2 font-lock-variable-name-face prepend t)) - '("@\\(exception\\|throws\\)\\>[ \t]*\\(\\S-+\\)?" - (1 font-lock-constant-face prepend) - (2 font-lock-type-face prepend t)) - )) - "Medium level highlighting for Java mode. -See also `java-font-lock-extra-types'.") - - (defconst java-font-lock-keywords-3 - (append java-font-lock-keywords-2 - ;; - ;; More complicated regexps for more complete highlighting for types. - ;; We still have to fontify type specifiers individually, as Java is hairy. - (list - ;; - ;; Fontify random types immediately followed by an item or items. - `(eval . - (list (concat "\\<\\(" ,java-type-names "\\)\\>" - "\\([ \t]*\\[[ \t]*\\]\\)*" - "\\([ \t]*\\sw\\)") - ;; Fontify each declaration item. - `(font-lock-match-c-style-declaration-item-and-skip-to-next - ;; Start and finish with point after the type specifier. - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (match-beginning ,(+ ,java-type-names-depth 3)))) - (goto-char (match-beginning ,(+ ,java-type-names-depth 3))) - ;; Fontify as a variable or function name. - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face))))) - ;; - ;; Fontify those that are eventually followed by an item or items. - `(,(concat "\\<\\(" java-type-specs "\\)\\>" - "\\([ \t]+\\sw+\\>" - "\\([ \t]*\\[[ \t]*\\]\\)*" - "\\)*") - ;; Fontify each declaration item. - (font-lock-match-c-style-declaration-item-and-skip-to-next - ;; Start with point after all type specifiers. - (prog1 (progn (skip-chars-forward "^;{}") (point)) - (goto-char (or (match-beginning 5) (match-end 1)))) - ;; Finish with point after first type specifier. - (goto-char (match-end 1)) - ;; Fontify as a variable or function name. - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face)))) - )) - "Gaudy level highlighting for Java mode. -See also `java-font-lock-extra-types'.") - ) - -(defvar java-font-lock-keywords java-font-lock-keywords-1 - "Default expressions to highlight in Java mode. -See also `java-font-lock-extra-types'.") - -;; Provide ourselves: - -(defun java-font-lock-syntactic-face-function (state) - (save-excursion - (if (nth 3 state) - ;; Check whether the string is properly terminated. - (let ((nstate (parse-partial-sexp (point) (line-end-position) - nil nil state 'syntax-table))) - (if (and (eolp) (nth 3 nstate)) - ;; We're inside a string, at EOL. The JLS says that: - ;; It is a compile-time error for a line terminator to - ;; appear after the opening " and before the closing - ;; matching ". - font-lock-warning-face - font-lock-string-face)) - (goto-char (nth 8 state)) - (if (looking-at "/\\*\\*") - font-lock-doc-face - font-lock-comment-face)))) - (provide 'font-lock) -(when (eq font-lock-support-mode 'jit-lock-mode) - (require 'jit-lock)) - +;;; arch-tag: 682327e4-64d8-4057-b20b-1fbb9f1fc54c ;;; font-lock.el ends here