Index: lispref/text.texi =================================================================== RCS file: /cvsroot/emacs/emacs/lispref/text.texi,v retrieving revision 1.54 diff -u -d -r1.54 text.texi --- lispref/text.texi 30 Apr 2002 17:55:02 -0000 1.54 +++ lispref/text.texi 17 May 2002 01:03:53 -0000 @@ -2653,8 +2653,22 @@ @code{(:foreground @var{color-name})}, and likewise for the background. @end itemize address@hidden Lock Mode}, for information on how to update @code{face} -properties automatically based on the contents of the text. +You can use Font Lock Mode (@pxref{Font Lock Mode}), to dynamically +update @code{face} properties based on the contents of the text. + address@hidden font-lock-face address@hidden font-lock-face @r{(text property)} +For special buffers which are not intended to be user-editable, or for +static areas of text which are always fontified in the same way, the address@hidden property is a simpler alternative to @code{face} +properties. This property is the same in all respects as the address@hidden property, but its display is conditional upon the value of +the @code{font-lock-mode} variable. If text has both a @code{face} +and @code{font-lock-face} property, then the @code{face} property +takes precedence. For more information about controlling buffer +fontification, see @ref{Font Lock Mode}. + +This property is new in Emacs 21.4. @item mouse-face @kindex mouse-face @r{(text property)} Index: src/xfaces.c =================================================================== RCS file: /cvsroot/emacs/emacs/src/xfaces.c,v retrieving revision 1.252 diff -u -d -r1.252 xfaces.c --- src/xfaces.c 26 Apr 2002 23:39:05 -0000 1.252 +++ src/xfaces.c 17 May 2002 01:04:33 -0000 @@ -400,11 +400,16 @@ Lisp_Object Qforeground_color, Qbackground_color; -/* The symbols `face' and `mouse-face' used as text properties. */ +/* The symbols `face', `font-lock-face', and `mouse-face' used as text + properties. */ -Lisp_Object Qface; +Lisp_Object Qface, Qfont_lock_face; extern Lisp_Object Qmouse_face; +/* The symbol `font-lock-mode'. This variable is defined in + "font-core.el". */ +Lisp_Object Qfont_lock_mode; + /* Error symbol for wrong_type_argument in load_pixmap. */ Lisp_Object Qbitmap_spec_p; @@ -6829,13 +6834,24 @@ if (pos < region_beg && region_beg < endpos) endpos = region_beg; - /* Get the `face' or `mouse_face' text property at POS, and - determine the next position at which the property changes. */ + /* Get the `face', `font-lock-face', or `mouse_face' text property + at POS, and determine the next position at which the property + changes. */ prop = Fget_text_property (position, propname, w->buffer); XSETFASTINT (limit1, (limit < endpos ? limit : endpos)); end = Fnext_single_property_change (position, propname, w->buffer, limit1); if (INTEGERP (end)) endpos = XINT (end); + /* If someone has unbound `font-lock-mode', we take that to be true. + This shouldn't cause a problem. */ + if (NILP (prop) && !mouse + && !NILP (find_symbol_value (Qfont_lock_mode))) + { + prop = Fget_text_property (position, Qfont_lock_face, w->buffer); + end = Fnext_single_property_change (position, Qfont_lock_face, w->buffer, limit1); + if (INTEGERP (end) && XINT (end) < endpos) + endpos = XINT (end); + } /* Look at properties from overlays. */ { @@ -7109,6 +7125,10 @@ { Qface = intern ("face"); staticpro (&Qface); + Qfont_lock_face = intern ("font-lock-face"); + staticpro (&Qfont_lock_face); + Qfont_lock_mode = intern ("font-lock-mode"); + staticpro (&Qfont_lock_mode); Qbitmap_spec_p = intern ("bitmap-spec-p"); staticpro (&Qbitmap_spec_p); Qframe_update_face_colors = intern ("frame-update-face-colors"); Index: src/xdisp.c =================================================================== RCS file: /cvsroot/emacs/emacs/src/xdisp.c,v retrieving revision 1.750 diff -u -d -r1.750 xdisp.c --- src/xdisp.c 26 Apr 2002 23:39:05 -0000 1.750 +++ src/xdisp.c 17 May 2002 01:04:34 -0000 @@ -210,7 +210,7 @@ extern int minibuffer_auto_raise; -extern Lisp_Object Qface; +extern Lisp_Object Qface, Qfont_lock_face; extern Lisp_Object Voverriding_local_map; extern Lisp_Object Voverriding_local_map_menu_flag; @@ -653,6 +653,7 @@ /* Handle `face' before `display' because some sub-properties of `display' need to know the face. */ {&Qface, FACE_PROP_IDX, handle_face_prop}, + {&Qfont_lock_face, FONT_LOCK_FACE_PROP_IDX,handle_face_prop}, {&Qdisplay, DISPLAY_PROP_IDX, handle_display_prop}, {&Qinvisible, INVISIBLE_PROP_IDX, handle_invisible_prop}, {&Qcomposition, COMPOSITION_PROP_IDX, handle_composition_prop}, Index: src/dispextern.h =================================================================== RCS file: /cvsroot/emacs/emacs/src/dispextern.h,v retrieving revision 1.133 diff -u -d -r1.133 dispextern.h --- src/dispextern.h 29 Apr 2002 09:04:36 -0000 1.133 +++ src/dispextern.h 17 May 2002 01:04:34 -0000 @@ -1546,6 +1546,7 @@ { FONTIFIED_PROP_IDX, FACE_PROP_IDX, + FONT_LOCK_FACE_PROP_IDX, INVISIBLE_PROP_IDX, DISPLAY_PROP_IDX, COMPOSITION_PROP_IDX, Index: src/Makefile.in =================================================================== RCS file: /cvsroot/emacs/emacs/src/Makefile.in,v retrieving revision 1.254 diff -u -d -r1.254 Makefile.in --- src/Makefile.in 26 Apr 2002 23:39:05 -0000 1.254 +++ src/Makefile.in 17 May 2002 01:04:34 -0000 @@ -813,6 +813,7 @@ ../lisp/startup.elc \ ../lisp/subr.elc \ ../lisp/term/tty-colors.elc \ + ../lisp/font-core.elc \ ../lisp/textmodes/fill.elc \ ../lisp/textmodes/page.elc \ ../lisp/textmodes/paragraphs.elc \ Index: lisp/font-lock.el =================================================================== RCS file: /cvsroot/emacs/emacs/lisp/font-lock.el,v retrieving revision 1.195 diff -u -d -u -r1.195 font-lock.el --- lisp/font-lock.el 30 Mar 2002 08:08:54 -0000 1.195 +++ lisp/font-lock.el 17 May 2002 00:58:27 -0000 @@ -446,106 +446,6 @@ 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 @@ -657,14 +557,6 @@ Currently, valid mode names are `fast-lock-mode', `jit-lock-mode' and `lazy-lock-mode'. This is normally set via `font-lock-defaults'.") -(defvar font-lock-multiline nil - "Whether font-lock should cater to multiline keywords. -If nil, don't try to handle multiline patterns. -If t, always handle multiline patterns. -If `undecided', don't try to handle multiline patterns until you see one. -Major/minor modes can set this variable if they know which option applies.") - -(defvar font-lock-fontified nil) ; Whether we have fontified the buffer. ;; Font Lock mode. @@ -698,94 +590,6 @@ (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)) - - ;; Turn on Font Lock mode. - (when font-lock-mode - (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. - (let ((max-size (font-lock-value-in-major-mode font-lock-maximum-size))) - (cond (font-lock-fontified - nil) - ((or (null max-size) (> max-size (buffer-size))) - (font-lock-fontify-buffer)) - (font-lock-verbose - (message "Fontifying %s...buffer size greater than font-lock-maximum-size" - (buffer-name)))))) - ;; Turn off Font Lock mode. - (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))) - -;;;###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. MODE should be a symbol, the major mode command name, such as `c-mode' @@ -937,94 +741,6 @@ (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 @@ -1718,60 +1434,50 @@ (t (car keywords)))) -(defvar font-lock-set-defaults nil) ; Whether we have set up defaults. - -(defun font-lock-set-defaults () - "Set fontification defaults appropriately for this mode. -Sets various variables using `font-lock-defaults' (or, if nil, using -`font-lock-defaults-alist') and `font-lock-maximum-decoration'." - ;; Set fontification defaults iff not previously set. - (unless font-lock-set-defaults - (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))) - (local (cdr (assq major-mode font-lock-keywords-alist))) - (removed-keywords - (cdr-safe (assq major-mode font-lock-removed-keywords-alist)))) - ;; Syntactic fontification? - (when (nth 1 defaults) - (set (make-local-variable 'font-lock-keywords-only) t)) - ;; Case fold during regexp fontification? - (when (nth 2 defaults) - (set (make-local-variable 'font-lock-keywords-case-fold-search) t)) - ;; Syntax table for regexp and syntactic fontification? - (when (nth 3 defaults) - (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)) - (set (make-local-variable (car x)) (cdr x))) - ;; Setup `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-compile-keywords (font-lock-eval-keywords keywords) t)) - ;; 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))))) +(defun font-lock-set-defaults-1 () + (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))) + (local (cdr (assq major-mode font-lock-keywords-alist))) + (removed-keywords + (cdr-safe (assq major-mode font-lock-removed-keywords-alist)))) + ;; Syntactic fontification? + (when (nth 1 defaults) + (set (make-local-variable 'font-lock-keywords-only) t)) + ;; Case fold during regexp fontification? + (when (nth 2 defaults) + (set (make-local-variable 'font-lock-keywords-case-fold-search) t)) + ;; Syntax table for regexp and syntactic fontification? + (when (nth 3 defaults) + (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)) + (set (make-local-variable (car x)) (cdr x))) + ;; Setup `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-compile-keywords (font-lock-eval-keywords keywords) t)) + ;; 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)))) ;;; Colour etc. support. Index: lisp/replace.el =================================================================== RCS file: /cvsroot/emacs/emacs/lisp/replace.el,v retrieving revision 1.143 diff -u -d -u -r1.143 replace.el --- lisp/replace.el 15 May 2002 19:35:54 -0000 1.143 +++ lisp/replace.el 17 May 2002 00:58:27 -0000 @@ -453,6 +453,11 @@ "Arguments to pass to `occur-1' to revert an Occur mode buffer. See `occur-revert-function'.") +(defcustom occur-mode-hook '(font-lock-mode) + "Hooks run when `occur' is called." + :type 'hook + :group 'matching) + (put 'occur-mode 'mode-class 'special) (defun occur-mode () "Major mode for output from \\[occur]. @@ -466,9 +471,7 @@ (setq major-mode 'occur-mode) (setq mode-name "Occur") (make-local-variable 'revert-buffer-function) - (set (make-local-variable 'font-lock-defaults) - '(nil t nil nil nil - (font-lock-fontify-region-function . occur-fontify-region-function))) + (set (make-local-variable 'font-lock-defaults) 'core-only) (setq revert-buffer-function 'occur-revert-function) (set (make-local-variable 'revert-buffer-function) 'occur-revert-function) (make-local-variable 'occur-revert-arguments) @@ -702,7 +705,8 @@ (or nlines list-matching-lines-default-context-lines) (and case-fold-search (isearch-no-upper-case-p regexp t)) - nil nil nil nil))) + list-matching-lines-buffer-name-face nil + list-matching-lines-face nil))) (let* ((diff (- (length bufs) (length active-bufs))) (bufcount (- (length bufs) diff)) (msg (concat @@ -787,7 +791,7 @@ (append '(occur-match t) (when match-face - `(face ,match-face))) + `(font-lock-face ,match-face))) curstring) (setq start (match-end 0)))) ;; Generate the string to insert for this match @@ -796,7 +800,7 @@ (apply #'propertize (format "%6d:" lines) (append (when prefix-face - `(face prefix-face)) + `(font-lock-face prefix-face)) '(occur-prefix t))) curstring "\n")) @@ -841,36 +845,11 @@ (add-text-properties beg end (append (when title-face - `(face ,title-face)) + `(font-lock-face ,title-face)) `(occur-title ,buf)))) (goto-char (point-min))))))) ;; Return the number of matches globalcount))) - -(defun occur-fontify-on-property (prop face beg end) - (let ((prop-beg (or (and (get-text-property (point) prop) (point)) - (next-single-property-change (point) prop nil end)))) - (when (and prop-beg (not (= prop-beg end))) - (let ((prop-end (next-single-property-change beg prop nil end))) - (when (and prop-end (not (= prop-end end))) - (put-text-property prop-beg prop-end 'face face) - prop-end))))) - -(defun occur-fontify-region-function (beg end &optional verbose) - (when verbose (message "Fontifying...")) - (let ((inhibit-read-only t)) - (save-excursion - (dolist (e `((occur-title . ,list-matching-lines-buffer-name-face) - (occur-match . ,list-matching-lines-face))) - ; (occur-prefix . ,list-matching-lines-prefix-face))) - (goto-char beg) - (let ((change-end nil)) - (while (setq change-end (occur-fontify-on-property (car e) - (cdr e) - (point) - end)) - (goto-char change-end)))))) - (when verbose (message "Fontifying...done"))) ;; It would be nice to use \\[...], but there is no reasonable way --- /dev/null Wed Dec 31 19:00:00 1969 +++ lisp/font-core.el Thu May 16 19:05:06 2002 @@ -0,0 +1,337 @@ +;;; font-core.el --- Core interface to font-lock + +;; Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999, 2000, 2001, 2002 +;; Free Software Foundation, Inc. + +;; Maintainer: FSF +;; Keywords: languages, faces + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 2, or (at your option) +;; any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs; see the file COPYING. If not, write to the +;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, +;; Boston, MA 02111-1307, USA. + +;;; Code: + +;; 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. + +If this variable is `core-only', then the main machinery of Font Lock +will not be used; `font-lock-face' text properties are still +respected. Otherwise, this variable 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'.") +(make-variable-buffer-local 'font-lock-defaults) + +;; This variable is used where font-lock.el itself supplies the +;; keywords. Really, this shouldn't need to be in font-core.el, but +;; we can't avoid it. In the future, this stuff will hopefully be +;; moved to cc-mode itself. +(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-multiline nil + "Whether font-lock should cater to multiline keywords. +If nil, don't try to handle multiline patterns. +If t, always handle multiline patterns. +If `undecided', don't try to handle multiline patterns until you see one. +Major/minor modes can set this variable if they know which option applies.") + +(defvar font-lock-fontified nil) ; Whether we have fontified the buffer. + +(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)) + + ;; Turn on Font Lock mode. + (when font-lock-mode + (font-lock-set-defaults) + (unless (eq font-lock-defaults 'core-only) + (add-hook 'after-change-functions 'font-lock-after-change-function t t) + (font-lock-turn-on-thing-lock) + ;; Fontify the buffer if we have to. + (let ((max-size (font-lock-value-in-major-mode font-lock-maximum-size))) + (cond (font-lock-fontified + nil) + ((or (null max-size) (> max-size (buffer-size))) + (font-lock-fontify-buffer)) + (font-lock-verbose + (message "Fontifying %s...buffer size greater than font-lock-maximum-size" + (buffer-name))))))) + ;; Turn off Font Lock mode. + (unless font-lock-mode + (unless (eq font-lock-defaults 'core-only) + (remove-hook 'after-change-functions 'font-lock-after-change-function t) + (font-lock-unfontify-buffer) + (font-lock-turn-off-thing-lock)))) + +(defun turn-on-font-lock () + "Turn on Font Lock mode (only if the terminal can display it)." + (unless font-lock-mode + (font-lock-mode))) + +(defvar font-lock-set-defaults nil) ; Whether we have set up defaults. + +(defun font-lock-set-defaults () + "Set fontification defaults appropriately for this mode. +Sets various variables using `font-lock-defaults' (or, if nil, using +`font-lock-defaults-alist') and `font-lock-maximum-decoration'." + (unless font-lock-set-defaults + (set (make-local-variable 'font-lock-set-defaults) t) + (make-local-variable 'font-lock-fontified) + (make-local-variable 'font-lock-multiline) + ;; Detect if this is a simple mode, which doesn't use any + ;; syntactic fontification functions. + (unless (eq font-lock-defaults 'core-only) + (require 'font-lock) + (font-lock-set-defaults-1)))) + +;;; 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 + font-lock-category-alist + (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)))) + +(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. + +(provide 'font-core) + +;;; font-core.el ends here +