X-Git-Url: https://git.hcoop.net/bpt/emacs.git/blobdiff_plain/558371ba97c5936cde40bd049941635fd9efff6c..f6101ac9afdd509b502dcfab369ad61eba37287d:/lisp/font-lock.el diff --git a/lisp/font-lock.el b/lisp/font-lock.el index 228359f375..c17949c0c9 100644 --- a/lisp/font-lock.el +++ b/lisp/font-lock.el @@ -1,7 +1,7 @@ ;;; font-lock.el --- Electric font lock mode -;; Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999, 2000, 2001 -;; Free Software Foundation, Inc. +;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, +;; 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. ;; Author: jwz, then rms, then sm ;; Maintainer: FSF @@ -152,9 +152,9 @@ ;; "Default expressions to highlight in Foo mode.") ;; ;; (add-hook 'foo-mode-hook -;; (function (lambda () -;; (make-local-variable 'font-lock-defaults) -;; (setq font-lock-defaults '(foo-font-lock-keywords t))))) +;; (lambda () +;; (make-local-variable 'font-lock-defaults) +;; (setq font-lock-defaults '(foo-font-lock-keywords t)))) ;;; Adding Font Lock support for modes: @@ -207,8 +207,10 @@ ;;; Code: +(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") @@ -226,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. @@ -337,14 +330,25 @@ 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: (defvar font-lock-keywords nil "A list of the keywords to highlight. -Each element should have one of these forms: +There are two kinds of values: user-level, and compiled. + +A user-level keywords list is what a major mode or the user would +set up. Normally the list would come from `font-lock-defaults'. +through selection of a fontification level and evaluation of any +contained expressions. You can also alter it by calling +`font-lock-add-keywords' or `font-lock-remove-keywords' with MODE = nil. + +Each element in a user-level keywords list should have one of these forms: MATCHER (MATCHER . MATCH) @@ -354,8 +358,9 @@ Each element should have one of these forms: (eval . FORM) 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). +call to make the search (called with one argument, the limit of the search; +it should return non-nil, move point, and set `match-data' appropriately iff +it succeeds; like `re-search-forward' would). MATCHER regexps can be generated via the function `regexp-opt'. FORM is an expression, whose value should be a keyword element, evaluated when @@ -442,107 +447,14 @@ support modes like jit-lock or lazy-lock. This variable is set by major modes via the variable `font-lock-defaults'. Be careful when composing regexps for this list; a poorly written pattern can -dramatically slow things down!") - -;; This variable is used by mode packages that support Font Lock mode by -;; defining their own keywords to use for `font-lock-keywords'. (The mode -;; command should make it buffer-local and set it to provide the set up.) -(defvar font-lock-defaults nil - "Defaults for Font Lock mode specified by the major mode. -Defaults should be of the form: - - (KEYWORDS KEYWORDS-ONLY CASE-FOLD SYNTAX-ALIST SYNTAX-BEGIN ...) - -KEYWORDS may be a symbol (a variable or function whose value is the keywords to -use for fontification) or a list of symbols. If KEYWORDS-ONLY is non-nil, -syntactic fontification (strings and comments) is not performed. -If CASE-FOLD is non-nil, the case of the keywords is ignored when fontifying. -If SYNTAX-ALIST is non-nil, it should be a list of cons pairs of the form -\(CHAR-OR-STRING . STRING) used to set the local Font Lock syntax table, for -keyword and syntactic fontification (see `modify-syntax-entry'). - -If SYNTAX-BEGIN is non-nil, it should be a function with no args used to move -backwards outside any enclosing syntactic block, for syntactic fontification. -Typical values are `beginning-of-line' (i.e., the start of the line is known to -be outside a syntactic block), or `beginning-of-defun' for programming modes or -`backward-paragraph' for textual modes (i.e., the mode-dependent function is -known to move outside a syntactic block). If nil, the beginning of the buffer -is used as a position outside of a syntactic block, in the worst case. - -These item elements are used by Font Lock mode to set the variables -`font-lock-keywords', `font-lock-keywords-only', -`font-lock-keywords-case-fold-search', `font-lock-syntax-table' and -`font-lock-beginning-of-syntax-function', respectively. - -Further item elements are alists of the form (VARIABLE . VALUE) and are in no -particular order. Each VARIABLE is made buffer-local before set to VALUE. - -Currently, appropriate variables include `font-lock-mark-block-function'. -If this is non-nil, it should be a function with no args used to mark any -enclosing block of text, for fontification via \\[font-lock-fontify-block]. -Typical values are `mark-defun' for programming modes or `mark-paragraph' for -textual modes (i.e., the mode-dependent function is known to put point and mark -around a text block relevant to that mode). - -Other variables include that for syntactic keyword fontification, -`font-lock-syntactic-keywords' -and those for buffer-specialised fontification functions, -`font-lock-fontify-buffer-function', `font-lock-unfontify-buffer-function', -`font-lock-fontify-region-function', `font-lock-unfontify-region-function', -`font-lock-inhibit-thing-lock' and `font-lock-maximum-size'.") -;;;###autoload -(make-variable-buffer-local 'font-lock-defaults) - -;; This variable is used where font-lock.el itself supplies the keywords. -(defvar font-lock-defaults-alist - (let (;; We use `beginning-of-defun', rather than nil, for SYNTAX-BEGIN. - ;; Thus the calculation of the cache is usually faster but not - ;; infallible, so we risk mis-fontification. sm. - (c-mode-defaults - '((c-font-lock-keywords c-font-lock-keywords-1 - c-font-lock-keywords-2 c-font-lock-keywords-3) - nil nil ((?_ . "w")) beginning-of-defun - (font-lock-mark-block-function . mark-defun))) - (c++-mode-defaults - '((c++-font-lock-keywords c++-font-lock-keywords-1 - c++-font-lock-keywords-2 c++-font-lock-keywords-3) - nil nil ((?_ . "w")) beginning-of-defun - (font-lock-mark-block-function . mark-defun))) - (objc-mode-defaults - '((objc-font-lock-keywords objc-font-lock-keywords-1 - objc-font-lock-keywords-2 objc-font-lock-keywords-3) - nil nil ((?_ . "w") (?$ . "w")) nil - (font-lock-mark-block-function . mark-defun))) - (java-mode-defaults - '((java-font-lock-keywords java-font-lock-keywords-1 - java-font-lock-keywords-2 java-font-lock-keywords-3) - nil nil ((?_ . "w") (?$ . "w")) nil - (font-lock-mark-block-function . mark-defun))) - (lisp-mode-defaults - '((lisp-font-lock-keywords - lisp-font-lock-keywords-1 lisp-font-lock-keywords-2) - nil nil (("+-*/.<>=!?$%_&~^:" . "w")) beginning-of-defun - (font-lock-mark-block-function . mark-defun)))) - (list - (cons 'c-mode c-mode-defaults) - (cons 'c++-mode c++-mode-defaults) - (cons 'objc-mode objc-mode-defaults) - (cons 'java-mode java-mode-defaults) - (cons 'emacs-lisp-mode lisp-mode-defaults) - (cons 'lisp-mode lisp-mode-defaults) - (cons 'lisp-interaction-mode lisp-mode-defaults))) - "Alist of fall-back Font Lock defaults for major modes. - -This variable should not be used any more. -Set the buffer-local `font-lock-keywords' in the major mode instead. +dramatically slow things down! -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) +A compiled keywords list starts with t. It is produced internal +by `font-lock-compile-keywords' from a user-level keywords list. +Its second element is the user-level keywords list that was +compiled. The remaining elements have the same form as +user-level keywords, but normally their values have been +optimized.") (defvar font-lock-keywords-alist nil "*Alist of `font-lock-keywords' local to a `major-mode'. @@ -616,14 +528,18 @@ This is normally set via `font-lock-defaults'.") If this is nil, the major mode's syntax table is used. This is normally set via `font-lock-defaults'.") -;; If this is nil, we only use the beginning of the buffer if we can't use -;; `font-lock-cache-position' and `font-lock-cache-state'. (defvar font-lock-beginning-of-syntax-function nil - "*Non-nil means use this function to move back outside of a syntactic block. -When called with no args it should leave point at the beginning of any -enclosing syntactic block. -If this is nil, the beginning of the buffer is used (in the worst case). -This is normally set via `font-lock-defaults'.") + "*Non-nil means use this function to move back outside all constructs. +When called with no args it should move point backward to a place which +is not in a string or comment and not within any bracket-pairs (or else, +a place such that any bracket-pairs outside it can be ignored for Emacs +syntax analysis and fontification). + +If this is nil, the beginning of the buffer is used, which is +always correct but tends to be slow. +This is normally set via `font-lock-defaults'. +This variable is semi-obsolete; we recommend setting +`syntax-begin-function' instead.") (defvar font-lock-mark-block-function nil "*Non-nil means use this function to mark a block of text. @@ -676,14 +592,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 - (when (and (not modified) (buffer-modified-p)) - (set-buffer-modified-p nil)))) + (let ((modified (make-symbol "modified"))) + `(let* ,(append varlist + `((,modified (buffer-modified-p)) + (buffer-undo-list t) + (inhibit-read-only t) + (inhibit-point-motion-hooks t) + (inhibit-modification-hooks t) + deactivate-mark + buffer-file-name + buffer-file-truename)) + (progn + ,@body) + (unless ,modified + (restore-buffer-modified-p nil))))) (put 'save-buffer-state 'lisp-indent-function 1) (def-edebug-spec save-buffer-state let) ;; @@ -691,70 +613,10 @@ 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 - (add-hook 'after-change-functions 'font-lock-after-change-function nil t) + (when arg + (add-hook 'after-change-functions 'font-lock-after-change-function t t) (font-lock-set-defaults) (font-lock-turn-on-thing-lock) ;; Fontify the buffer if we have to. @@ -770,14 +632,7 @@ buffer local value for `font-lock-defaults', via its mode hook." (unless font-lock-mode (remove-hook 'after-change-functions 'font-lock-after-change-function t) (font-lock-unfontify-buffer) - (font-lock-turn-off-thing-lock) - (font-lock-unset-defaults))) - -;;;###autoload -(defun turn-on-font-lock () - "Turn on Font Lock mode (only if the terminal can display it)." - (unless font-lock-mode - (font-lock-mode))) + (font-lock-turn-off-thing-lock))) ;;;###autoload (defun font-lock-add-keywords (mode keywords &optional append) @@ -803,7 +658,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 @@ -820,16 +675,26 @@ see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types', (font-lock-update-removed-keyword-alist mode keywords append)) (t ;; Otherwise set or add the keywords now. + ;; This is a no-op if it has been done already in this buffer. (font-lock-set-defaults) - (if (eq append 'set) - (setq font-lock-keywords keywords) - (font-lock-remove-keywords nil keywords) ;to avoid duplicates - (let ((old (if (eq (car-safe font-lock-keywords) t) - (cdr font-lock-keywords) - font-lock-keywords))) - (setq font-lock-keywords (if append - (append old keywords) - (append keywords old)))))))) + (let ((was-compiled (eq (car font-lock-keywords) t))) + ;; Bring back the user-level (uncompiled) keywords. + (if was-compiled + (setq font-lock-keywords (cadr font-lock-keywords))) + ;; Now modify or replace them. + (if (eq append 'set) + (setq font-lock-keywords keywords) + (font-lock-remove-keywords nil keywords) ;to avoid duplicates + (let ((old (if (eq (car-safe font-lock-keywords) t) + (cdr font-lock-keywords) + font-lock-keywords))) + (setq font-lock-keywords (if append + (append old keywords) + (append keywords old))))) + ;; If the keywords were compiled before, compile them again. + (if was-compiled + (set (make-local-variable 'font-lock-keywords) + (font-lock-compile-keywords font-lock-keywords t))))))) (defun font-lock-update-removed-keyword-alist (mode keywords append) ;; Update `font-lock-removed-keywords-alist' when adding new @@ -923,101 +788,21 @@ subtle problems due to details of the implementation." (t ;; Otherwise remove it immediately. (font-lock-set-defaults) - (setq font-lock-keywords (copy-sequence font-lock-keywords)) - (dolist (keyword keywords) - (setq font-lock-keywords - (delete keyword - ;; The keywords might be compiled. - (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. + (let ((was-compiled (eq (car font-lock-keywords) t))) + ;; Bring back the user-level (uncompiled) keywords. + (if was-compiled + (setq font-lock-keywords (cadr font-lock-keywords))) + + ;; Edit them. + (setq font-lock-keywords (copy-sequence font-lock-keywords)) + (dolist (keyword keywords) + (setq font-lock-keywords + (delete keyword font-lock-keywords))) + + ;; If the keywords were compiled before, compile them again. + (if was-compiled + (set (make-local-variable 'font-lock-keywords) + (font-lock-compile-keywords font-lock-keywords t))))))) ;;; Font Lock Support mode. @@ -1061,9 +846,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 +869,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 +898,7 @@ The value of this variable is used when Font Lock mode is turned on." ;; ;; (jit-lock-mode ;; (jit-lock-after-unfontify-buffer)) - (lazy-lock-mode + ((and (boundp 'lazy-lock-mode) lazy-lock-mode) (lazy-lock-after-unfontify-buffer)))) ;;; End of Font Lock Support mode. @@ -1195,10 +980,7 @@ The value of this variable is used when Font Lock mode is turned on." (font-lock-after-fontify-buffer) (setq font-lock-fontified t))) ;; We don't restore the old fontification, so it's best to unfontify. - (quit (font-lock-unfontify-buffer)))) - ;; Make sure we undo `font-lock-keywords' etc. - (unless font-lock-mode - (font-lock-unset-defaults))))) + (quit (font-lock-unfontify-buffer))))))) (defun font-lock-default-unfontify-buffer () ;; Make sure we unfontify etc. in the whole buffer. @@ -1208,13 +990,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,16 +1040,24 @@ The value of this variable is used when Font Lock mode is turned on." ; (or (nth 4 state) (nth 7 state)))) ; (font-lock-fontify-keywords-region beg end)) +(defvar font-lock-extra-managed-props nil + "Additional text properties managed by font-lock. +This is used by `font-lock-default-unfontify-region' to decide +what properties to clear before refontifying a region.") + (defun font-lock-default-unfontify-region (beg end) (save-buffer-state nil - (remove-text-properties beg end - (if font-lock-syntactic-keywords - '(face nil syntax-table nil font-lock-multiline nil) - '(face nil font-lock-multiline nil))))) + (remove-list-of-text-properties + beg end (append + font-lock-extra-managed-props + (if font-lock-syntactic-keywords + '(syntax-table face font-lock-multiline) + '(face font-lock-multiline)))))) ;; Called when any modification is made to buffer text. (defun font-lock-after-change-function (beg end old-len) - (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. @@ -1294,7 +1089,8 @@ delimit the region to fontify." (font-lock-fontify-region (point) (mark))) ((error quit) (message "Fontifying block...%s" error-data))))))) -(define-key facemenu-keymap "\M-g" 'font-lock-fontify-block) +(if (boundp 'facemenu-keymap) + (define-key facemenu-keymap "\M-g" 'font-lock-fontify-block)) ;;; End of Fontification functions. @@ -1397,23 +1193,28 @@ see `font-lock-syntactic-keywords'." (start (match-beginning match)) (end (match-end match)) (value (nth 1 highlight)) (override (nth 2 highlight))) - (when (and (consp value) (not (numberp (car value)))) - (setq value (eval value))) - (when (stringp value) (setq value (string-to-syntax value))) - (cond ((not start) - ;; No match but we might not signal an error. - (or (nth 3 highlight) - (error "No match %d in highlight %S" match highlight))) - ((not override) - ;; Cannot override existing fontification. - (or (text-property-not-all start end 'syntax-table nil) - (put-text-property start end 'syntax-table value))) - ((eq override t) - ;; Override existing fontification. - (put-text-property start end 'syntax-table value)) - ((eq override 'keep) - ;; Keep existing fontification. - (font-lock-fillin-text-property start end 'syntax-table value))))) + (if (not start) + ;; No match but we might not signal an error. + (or (nth 3 highlight) + (error "No match %d in highlight %S" match highlight)) + (when (and (consp value) (not (numberp (car value)))) + (setq value (eval value))) + (when (stringp value) (setq value (string-to-syntax value))) + ;; Flush the syntax-cache. I believe this is not necessary for + ;; font-lock's use of syntax-ppss, but I'm not 100% sure and it can + ;; still be necessary for other users of syntax-ppss anyway. + (syntax-ppss-after-change-function start) + (cond + ((not override) + ;; Cannot override existing fontification. + (or (text-property-not-all start end 'syntax-table nil) + (put-text-property start end 'syntax-table value))) + ((eq override t) + ;; Override existing fontification. + (put-text-property start end 'syntax-table value)) + ((eq override 'keep) + ;; Keep existing fontification. + (font-lock-fillin-text-property start end 'syntax-table value)))))) (defun font-lock-fontify-syntactic-anchored-keywords (keywords limit) "Fontify according to KEYWORDS until LIMIT. @@ -1457,7 +1258,7 @@ START should be at the beginning of a line." font-lock-syntactic-keywords))) ;; Get down to business. (let ((case-fold-search font-lock-keywords-case-fold-search) - (keywords (cdr font-lock-syntactic-keywords)) + (keywords (cddr font-lock-syntactic-keywords)) keyword matcher highlights) (while keywords ;; Find an occurrence of `matcher' from `start' to `end'. @@ -1481,57 +1282,28 @@ START should be at the beginning of a line." ;;; Syntactic fontification functions. -;; These record the parse state at a particular position, always the start of a -;; line. Used to make `font-lock-fontify-syntactically-region' faster. -;; Previously, `font-lock-cache-position' was just a buffer position. However, -;; under certain situations, this occasionally resulted in mis-fontification. -;; I think the "situations" were deletion with Lazy Lock mode's deferral. sm. -(defvar font-lock-cache-state nil) -(defvar font-lock-cache-position nil) - -(defun font-lock-fontify-syntactically-region (start end &optional loudly) +(defun font-lock-fontify-syntactically-region (start end &optional loudly ppss) "Put proper face on each string and comment between START and END. START should be at the beginning of a line." - (let ((cache (marker-position font-lock-cache-position)) - state face beg) + (let (state face beg) (if loudly (message "Fontifying %s... (syntactically...)" (buffer-name))) (goto-char start) ;; - ;; Find the state at the `beginning-of-line' before `start'. - (if (eq start cache) - ;; Use the cache for the state of `start'. - (setq state font-lock-cache-state) - ;; Find the state of `start'. - (if (null font-lock-beginning-of-syntax-function) - ;; Use the state at the previous cache position, if any, or - ;; otherwise calculate from `point-min'. - (if (or (null cache) (< start cache)) - (setq state (parse-partial-sexp (point-min) start)) - (setq state (parse-partial-sexp cache start nil nil - font-lock-cache-state))) - ;; Call the function to move outside any syntactic block. - (funcall font-lock-beginning-of-syntax-function) - (setq state (parse-partial-sexp (point) start))) - ;; Cache the state and position of `start'. - (setq font-lock-cache-state state) - (set-marker font-lock-cache-position start)) - ;; - ;; If the region starts inside a string or comment, show the extent of it. - (when (or (nth 3 state) (nth 4 state)) - (setq face (funcall font-lock-syntactic-face-function state) beg (point)) - (setq state (parse-partial-sexp (point) end nil nil state 'syntax-table)) - (put-text-property beg (point) 'face face)) + ;; Find the `start' state. + (setq state (or ppss (syntax-ppss start))) ;; ;; Find each interesting place between here and `end'. - (while (and (< (point) end) - (progn - (setq state (parse-partial-sexp (point) end nil nil state - 'syntax-table)) - (or (nth 3 state) (nth 4 state)))) - (setq face (funcall font-lock-syntactic-face-function state) - beg (nth 8 state)) - (setq state (parse-partial-sexp (point) end nil nil state 'syntax-table)) - (put-text-property beg (point) 'face face)))) + (while + (progn + (when (or (nth 3 state) (nth 4 state)) + (setq face (funcall font-lock-syntactic-face-function state)) + (setq beg (max (nth 8 state) start)) + (setq state (parse-partial-sexp (point) end nil nil state + 'syntax-table)) + (when face (put-text-property beg (point) 'face face))) + (< (point) end)) + (setq state (parse-partial-sexp (point) end nil nil state + 'syntax-table))))) ;;; End of Syntactic fontification functions. @@ -1543,26 +1315,37 @@ HIGHLIGHT should be of the form MATCH-HIGHLIGHT, see `font-lock-keywords'." (let* ((match (nth 0 highlight)) (start (match-beginning match)) (end (match-end match)) (override (nth 2 highlight))) - (cond ((not start) - ;; No match but we might not signal an error. - (or (nth 3 highlight) - (error "No match %d in highlight %S" match highlight))) - ((not override) - ;; Cannot override existing fontification. - (or (text-property-not-all start end 'face nil) - (put-text-property start end 'face (eval (nth 1 highlight))))) - ((eq override t) - ;; Override existing fontification. - (put-text-property start end 'face (eval (nth 1 highlight)))) - ((eq override 'prepend) - ;; Prepend to existing fontification. - (font-lock-prepend-text-property start end 'face (eval (nth 1 highlight)))) - ((eq override 'append) - ;; Append to existing fontification. - (font-lock-append-text-property start end 'face (eval (nth 1 highlight)))) - ((eq override 'keep) - ;; Keep existing fontification. - (font-lock-fillin-text-property start end 'face (eval (nth 1 highlight))))))) + (if (not start) + ;; No match but we might not signal an error. + (or (nth 3 highlight) + (error "No match %d in highlight %S" match highlight)) + (let ((val (eval (nth 1 highlight)))) + (when (eq (car-safe val) 'face) + (add-text-properties start end (cddr val)) + (setq val (cadr val))) + (cond + ((not (or val (eq override t))) + ;; If `val' is nil, don't do anything. It is important to do it + ;; explicitly, because when adding nil via things like + ;; font-lock-append-text-property, the property is actually + ;; changed from to () which is undesirable. --Stef + nil) + ((not override) + ;; Cannot override existing fontification. + (or (text-property-not-all start end 'face nil) + (put-text-property start end 'face val))) + ((eq override t) + ;; Override existing fontification. + (put-text-property start end 'face val)) + ((eq override 'prepend) + ;; Prepend to existing fontification. + (font-lock-prepend-text-property start end 'face val)) + ((eq override 'append) + ;; Append to existing fontification. + (font-lock-append-text-property start end 'face val)) + ((eq override 'keep) + ;; Keep existing fontification. + (font-lock-fillin-text-property start end 'face val))))))) (defsubst font-lock-fontify-anchored-keywords (keywords limit) "Fontify according to KEYWORDS until LIMIT. @@ -1600,11 +1383,13 @@ LIMIT can be modified by the value of its PRE-MATCH-FORM." (defun font-lock-fontify-keywords-region (start end &optional loudly) "Fontify according to `font-lock-keywords' between START and END. -START should be at the beginning of a line." +START should be at the beginning of a line. +LOUDLY, if non-nil, allows progress-meter bar." (unless (eq (car font-lock-keywords) t) - (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords))) + (setq font-lock-keywords + (font-lock-compile-keywords font-lock-keywords t))) (let ((case-fold-search font-lock-keywords-case-fold-search) - (keywords (cdr font-lock-keywords)) + (keywords (cddr font-lock-keywords)) (bufname (buffer-name)) (count 0) keyword matcher highlights) ;; @@ -1648,13 +1433,35 @@ START should be at the beginning of a line." ;; Various functions. -(defun font-lock-compile-keywords (keywords) - "Compile KEYWORDS into the form (t KEYWORD ...). -Here KEYWORD is of the form (MATCHER HIGHLIGHT ...) as shown in the -`font-lock-keywords' doc string." +(defun font-lock-compile-keywords (keywords &optional regexp) + "Compile KEYWORDS into the form (t KEYWORDS COMPILED...) +Here each COMPILED is of the form (MATCHER HIGHLIGHT ...) as shown in the +`font-lock-keywords' doc string. +If REGEXP is non-nil, it means these keywords are used for +`font-lock-keywords' rather than for `font-lock-syntactic-keywords'." (if (eq (car-safe keywords) t) keywords - (cons t (mapcar 'font-lock-compile-keyword keywords)))) + (setq keywords + (cons t (cons keywords + (mapcar 'font-lock-compile-keyword keywords)))) + (if (and regexp + (eq (or syntax-begin-function + font-lock-beginning-of-syntax-function) + 'beginning-of-defun) + (not beginning-of-defun-function)) + ;; Try to detect when a string or comment contains something that + ;; looks like a defun and would thus confuse font-lock. + (nconc keywords + `((,(if defun-prompt-regexp + (concat "^\\(?:" defun-prompt-regexp "\\)?\\s(") + "^\\s(") + (0 + (if (memq (get-text-property (match-beginning 0) 'face) + '(font-lock-string-face font-lock-doc-face + font-lock-comment-face)) + font-lock-warning-face) + prepend))))) + keywords)) (defun font-lock-compile-keyword (keyword) (cond ((nlistp keyword) ; MATCHER @@ -1711,28 +1518,20 @@ Sets various variables using `font-lock-defaults' (or, if nil, using `font-lock-defaults-alist') and `font-lock-maximum-decoration'." ;; Set fontification defaults iff not previously set. (unless font-lock-set-defaults - (set (make-local-variable 'font-lock-set-defaults) t) - (set (make-local-variable 'font-lock-cache-state) nil) - (set (make-local-variable 'font-lock-cache-position) (make-marker)) + (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)))) + (cdr (assq major-mode + (with-no-warnings + 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)))) - ;; Regexp fontification? - (set (make-local-variable 'font-lock-keywords) - (font-lock-compile-keywords (font-lock-eval-keywords keywords))) - ;; Local fontification? - (while local - (font-lock-add-keywords nil (car (car local)) (cdr (car local))) - (setq local (cdr local))) - (when removed-keywords - (font-lock-remove-keywords nil removed-keywords)) + (set (make-local-variable 'font-lock-defaults) defaults) ;; Syntactic fontification? (when (nth 1 defaults) (set (make-local-variable 'font-lock-keywords-only) t)) @@ -1741,44 +1540,37 @@ Sets various variables using `font-lock-defaults' (or, if nil, using (set (make-local-variable 'font-lock-keywords-case-fold-search) t)) ;; Syntax table for regexp and syntactic fontification? (when (nth 3 defaults) - (let ((slist (nth 3 defaults))) - (set (make-local-variable 'font-lock-syntax-table) - (copy-syntax-table (syntax-table))) - (while slist - ;; The character to modify may be a single CHAR or a STRING. - (let ((chars (if (numberp (car (car slist))) - (list (car (car slist))) - (mapcar 'identity (car (car slist))))) - (syntax (cdr (car slist)))) - (while chars - (modify-syntax-entry (car chars) syntax font-lock-syntax-table) - (setq chars (cdr chars))) - (setq slist (cdr slist)))))) + (set (make-local-variable 'font-lock-syntax-table) + (copy-syntax-table (syntax-table))) + (dolist (selem (nth 3 defaults)) + ;; The character to modify may be a single CHAR or a STRING. + (let ((syntax (cdr selem))) + (dolist (char (if (numberp (car selem)) + (list (car selem)) + (mapcar 'identity (car selem)))) + (modify-syntax-entry char syntax font-lock-syntax-table))))) ;; Syntax function for syntactic fontification? (when (nth 4 defaults) (set (make-local-variable 'font-lock-beginning-of-syntax-function) (nth 4 defaults))) ;; Variable alist? (dolist (x (nthcdr 5 defaults)) - (let ((variable (car x)) (value (cdr x))) - (unless (boundp variable) - (set variable nil)) ;why ? - (set (make-local-variable variable) value)))))) - -(defun font-lock-unset-defaults () - "Unset fontification defaults. See function `font-lock-set-defaults'." - (setq font-lock-set-defaults nil - font-lock-keywords nil - font-lock-keywords-only nil - font-lock-keywords-case-fold-search nil - font-lock-syntax-table nil - font-lock-beginning-of-syntax-function nil) - (let* ((defaults (or font-lock-defaults - (cdr (assq major-mode font-lock-defaults-alist)))) - (alist (nthcdr 5 defaults))) - (while alist - (set (car (car alist)) (default-value (car (car alist)))) - (setq alist (cdr alist))))) + (set (make-local-variable (car x)) (cdr x))) + ;; Set up `font-lock-keywords' last because its value might depend + ;; on other settings (e.g. font-lock-compile-keywords uses + ;; font-lock-beginning-of-syntax-function). + (set (make-local-variable 'font-lock-keywords) + (font-lock-eval-keywords keywords)) + ;; Local fontification? + (while local + (font-lock-add-keywords nil (car (car local)) (cdr (car local))) + (setq local (cdr local))) + (when removed-keywords + (font-lock-remove-keywords nil removed-keywords)) + ;; Now compile the keywords. + (unless (eq (car font-lock-keywords) t) + (set (make-local-variable 'font-lock-keywords) + (font-lock-compile-keywords font-lock-keywords t)))))) ;;; Colour etc. support. @@ -1804,9 +1596,9 @@ Sets various variables using `font-lock-defaults' (or, if nil, using (when background (setq face-spec (cons ':background (cons background face-spec)))) (when bold-p - (setq face-spec (append '(:bold t) face-spec))) + (setq face-spec (append '(:weight bold) face-spec))) (when italic-p - (setq face-spec (append '(:italic t) face-spec))) + (setq face-spec (append '(:slant italic) face-spec))) (when underline-p (setq face-spec (append '(:underline t) face-spec))) (custom-declare-face face (list (list t face-spec)) nil))))))) @@ -1814,25 +1606,35 @@ 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 "lightred")) - (((class grayscale) (background light)) - (:foreground "DimGray" :bold t :italic t)) + '((((class grayscale) (background light)) + (:foreground "DimGray" :weight bold :slant italic)) (((class grayscale) (background dark)) - (:foreground "LightGray" :bold t :italic t)) - (((class color) (background light)) (:foreground "Firebrick")) - (((class color) (background dark)) (:foreground "chocolate1")) - (t (:bold t :italic t))) + (:foreground "LightGray" :weight bold :slant italic)) + (((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" :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))) + '((((class grayscale) (background light)) (:foreground "DimGray" :slant italic)) + (((class grayscale) (background dark)) (:foreground "LightGray" :slant italic)) + (((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) @@ -1842,75 +1644,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" :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))) + '((((class grayscale) (background light)) (:foreground "LightGray" :weight bold)) + (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold)) + (((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" :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))) + '((((class grayscale) (background light)) (:foreground "LightGray" :weight bold)) + (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold)) + (((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")) - (t (:inverse-video t :bold t))) + '((((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)) - (:foreground "Gray90" :bold t :italic t)) + '((((class grayscale) (background light)) + (:foreground "Gray90" :weight bold :slant italic)) (((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))) + (:foreground "DimGray" :weight bold :slant italic)) + (((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" :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))) + '((((class grayscale) (background light)) (:foreground "Gray90" :weight bold)) + (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold)) + (((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)) - (:foreground "LightGray" :bold t :underline t)) + '((((class grayscale) (background light)) + (:foreground "LightGray" :weight bold :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))) + (:foreground "Gray50" :weight bold :underline t)) + (((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" :bold t)) - (((class color) (background dark)) (:foreground "Pink" :bold t)) - (t (:inverse-video t :bold t))) + '((((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. @@ -2019,8 +1840,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) @@ -2031,7 +1852,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 ( @@ -2042,15 +1863,27 @@ The item is delimited by (match-beginning 1) and (match-end 1). If (match-beginning 2) is non-nil, the item is followed by a `('. This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." - (when (looking-at "[ \t*]*\\(\\sw+\\)[ \t]*\\((\\)?") + (when (looking-at "[ \n\t*]*\\(\\sw+\\)[ \t\n]*\\(((?\\)?") + (when (and (match-end 2) (> (- (match-end 2) (match-beginning 2)) 1)) + ;; If `word' is followed by a double open-paren, it's probably + ;; a macro used for "int myfun P_ ((int arg1))". Let's go back one + ;; word to try and match `myfun' rather than `P_'. + (let ((pos (point))) + (skip-chars-backward " \t\n") + (skip-syntax-backward "w") + (unless (looking-at "\\(\\sw+\\)[ \t\n]*\\sw+[ \t\n]*\\(((?\\)?") + ;; Looks like it was something else, so go back to where we + ;; were and reset the match data by rematching. + (goto-char pos) + (looking-at "[ \n\t*]*\\(\\sw+\\)[ \t\n]*\\(((?\\)?")))) (save-match-data (condition-case nil (save-restriction - ;; Restrict to the end of line, currently guaranteed to be LIMIT. + ;; Restrict to the LIMIT. (narrow-to-region (point-min) limit) (goto-char (match-end 1)) ;; Move over any item value, etc., to the next item. - (while (not (looking-at "[ \t]*\\(\\(,\\)\\|;\\|$\\)")) + (while (not (looking-at "[ \t\n]*\\(\\(,\\)\\|;\\|\\'\\)")) (goto-char (or (scan-sexps (point) 1) (point-max)))) (goto-char (match-end 2))) (error t))))) @@ -2064,7 +1897,7 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." ;; Definitions. (list (concat "(\\(def\\(" ;; Function declarations. - "\\(advice\\|alias\\|generic\\|macro\\*?\\|method\\|" + "\\(advice\\|varalias\\|alias\\|generic\\|macro\\*?\\|method\\|" "setf\\|subst\\*?\\|un\\*?\\|" "ine-\\(condition\\|\\(?:derived\\|minor\\)-mode\\|" "method-combination\\|setf-expander\\|skeleton\\|widget\\|" @@ -2072,7 +1905,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'\(]*" @@ -2104,10 +1937,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) ;; @@ -2117,12 +1953,19 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." '("when" "unless" "case" "ecase" "typecase" "etypecase" "ccase" "ctypecase" "handler-case" "handler-bind" "restart-bind" "restart-case" "in-package" - "cerror" "break" "ignore-errors" + "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) + "destructuring-bind" "macrolet" "tagbody" "block" "go" + "multiple-value-bind" "multiple-value-prog1" + "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) ;; @@ -2133,7 +1976,7 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." '(2 font-lock-constant-face nil t)) ;; ;; Erroneous structures. - '("(\\(abort\\|assert\\|error\\|signal\\)\\>" 1 font-lock-warning-face) + '("(\\(abort\\|assert\\|warn\\|check-type\\|cerror\\|error\\|signal\\)\\>" 1 font-lock-warning-face) ;; ;; Words inside \\[] tend to be for `substitute-command-keys'. '("\\\\\\\\\\[\\(\\sw+\\)]" 1 font-lock-constant-face prepend) @@ -2142,838 +1985,23 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." '("`\\(\\sw\\sw+\\)'" 1 font-lock-constant-face prepend) ;; ;; Constant values. - '("\\<:\\sw\\sw+\\>" 0 font-lock-builtin-face) + '("\\<:\\sw+\\>" 0 font-lock-builtin-face) ;; ;; ELisp and CLisp `&' keywords as types. '("\\&\\sw+\\>" . font-lock-type-face) ;; - ;; 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*") - "*List of extra types to fontify in Java mode. -Each list item should be a regexp not containing word-delimiters. -For example, a value of (\"[A-Z\300-\326\330-\337]\\\\sw*[a-z]\\\\sw*\") means capitalised -words (and words conforming to the Java id spec) are treated as type names. - -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.] - -(defconst c-font-lock-keywords-1 nil - "Subdued level highlighting for C mode.") - -(defconst c-font-lock-keywords-2 nil - "Medium level highlighting for C mode. -See also `c-font-lock-extra-types'.") - -(defconst c-font-lock-keywords-3 nil - "Gaudy level highlighting for C mode. -See also `c-font-lock-extra-types'.") - -(let* ((c-keywords - (eval-when-compile - (regexp-opt '("break" "continue" "do" "else" "for" "if" "return" - "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")))) - (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"))) - 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))) - (setq 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)))) - - (setq 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. - '(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$" - (beginning-of-line) (end-of-line) - (1 font-lock-constant-face))) - ))) - - (setq 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. - (list 'font-lock-match-c-style-declaration-item-and-skip-to-next - ;; Start with point after all type specifiers. - (list 'goto-char (list 'or - (list 'match-beginning - (+ ,c-type-names-depth 2)) - '(match-end 1))) - ;; Finish with point after first type specifier. - '(goto-char (match-end 1)) - ;; Fontify as a variable or function name. - '(1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face))))) - ;; - ;; 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 font-lock-type-face))) - ;; - ;; Fontify anything at beginning of line as a declaration or definition. - '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*" - (1 font-lock-type-face) - (font-lock-match-c-style-declaration-item-and-skip-to-next - (goto-char (or (match-beginning 2) (match-end 1))) nil - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-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++. - -(defconst c++-font-lock-keywords-1 nil - "Subdued level highlighting for C++ mode.") - -(defconst c++-font-lock-keywords-2 nil - "Medium level highlighting for C++ mode. -See also `c++-font-lock-extra-types'.") - -(defconst c++-font-lock-keywords-3 nil - "Gaudy level highlighting for C++ mode. -See also `c++-font-lock-extra-types'.") - -(defun font-lock-match-c++-style-declaration-item-and-skip-to-next (limit) - ;; Regexp matches after point: word::word ( - ;; ^^^^ ^^^^ ^^^^ ^ - ;; 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*&]*" - ;; 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 - ;; 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]*\\(\\(,\\)\\|;\\|$\\)")) - (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")))) - (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]+\\)[ \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 - ;; - ;; 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)) - ))) - - (setq 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) - ))) - - (setq 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. - (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. - (list 'goto-char (list 'or (list 'match-beginning - (+ ,c++-type-depth 2)) - '(match-end 1))) - ;; Finish with point after first type specifier. - '(goto-char (match-end 1)) - ;; Fontify as a variable or function name. - '(1 (cond ((or (match-beginning 2) (match-beginning 4)) - font-lock-type-face) - ((and (match-beginning 6) (c-at-toplevel-p)) - font-lock-function-name-face) - (t - font-lock-variable-name-face))) - '(3 font-lock-type-face nil t) - '(5 (if (match-beginning 6) - font-lock-function-name-face - font-lock-variable-name-face) nil t)))) - ;; - ;; 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 font-lock-type-face))) - ;; - ;; Fontify anything at beginning of line as a declaration or definition. - (list (concat "^\\(" c++-type-spec "[ \t*&]*\\)+") - '(font-lock-match-c++-style-declaration-item-and-skip-to-next - (goto-char (match-beginning 1)) - (goto-char (match-end 1)) - (1 (cond ((or (match-beginning 2) (match-beginning 4)) - font-lock-type-face) - ((match-beginning 6) font-lock-function-name-face) - (t font-lock-variable-name-face))) - (3 font-lock-type-face nil t) - (5 (if (match-beginning 6) - font-lock-function-name-face - font-lock-variable-name-face) nil t))) - ;; - ;; Fontify constructors and destructors inside class declarations. - '(font-lock-match-c++-structor-declaration - (3 font-lock-function-name-face t)) - ))) - ) - -(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. - -(defconst objc-font-lock-keywords-1 nil - "Subdued level highlighting for Objective-C mode.") - -(defconst objc-font-lock-keywords-2 nil - "Medium level highlighting for Objective-C mode. -See also `objc-font-lock-extra-types'.") - -(defconst objc-font-lock-keywords-3 nil - "Gaudy level highlighting for Objective-C mode. -See also `objc-font-lock-extra-types'.") - -;; Regexps written with help from Stephen Peters 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)) - ) - (setq 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))) - ))) - - (setq 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) - ))) - - (setq 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. - (list 'font-lock-match-c-style-declaration-item-and-skip-to-next - ;; Start with point after all type specifiers. - (list 'goto-char - (list 'or (list 'match-beginning - (+ ,objc-type-names-depth 2)) - '(match-end 1))) - ;; Finish with point after first type specifier. - '(goto-char (match-end 1)) - ;; Fontify as a variable or function name. - '(1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face))))) - ;; - ;; 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 font-lock-type-face))) - ;; - ;; Fontify anything at beginning of line as a declaration or definition. - '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*" - (1 font-lock-type-face) - (font-lock-match-c-style-declaration-item-and-skip-to-next - (goto-char (or (match-beginning 2) (match-end 1))) nil - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face)))) - ))) - ) - -(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. - -(defconst java-font-lock-keywords-1 nil - "Subdued level highlighting for Java mode.") - -(defconst java-font-lock-keywords-2 nil - "Medium level highlighting for Java mode. -See also `java-font-lock-extra-types'.") - -(defconst java-font-lock-keywords-3 nil - "Gaudy level highlighting for Java mode. -See also `java-font-lock-extra-types'.") - -;; Regexps written with help from Fred White , -;; 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")))) - ) - (setq 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))) - )) - - (setq 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)) - ))) - - (setq 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. - (list 'font-lock-match-c-style-declaration-item-and-skip-to-next - ;; Start and finish with point after the type specifier. - (list 'goto-char (list 'match-beginning - (+ ,java-type-names-depth 3))) - (list 'goto-char (list 'match-beginning - (+ ,java-type-names-depth 3))) - ;; Fontify as a variable or function name. - '(1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face))))) - ;; - ;; Fontify those that are eventually followed by an item or items. - (list (concat "\\<\\(" java-type-specs "\\)\\>" - "\\([ \t]+\\sw+\\>" - "\\([ \t]*\\[[ \t]*\\]\\)*" - "\\)*") - ;; Fontify each declaration item. - '(font-lock-match-c-style-declaration-item-and-skip-to-next - ;; Start with point after all type specifiers. - (goto-char (or (match-beginning 5) (match-end 1))) - ;; Finish with point after first type specifier. - (goto-char (match-end 1)) - ;; Fontify as a variable or function name. - (1 (if (match-beginning 2) - font-lock-function-name-face - font-lock-variable-name-face)))) - ))) - ) - -(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: - (provide 'font-lock) -(require 'jit-lock) +;; arch-tag: 682327e4-64d8-4057-b20b-1fbb9f1fc54c ;;; font-lock.el ends here