From 5aa29679e1b852b258d6e7895cd55c250d568111 Mon Sep 17 00:00:00 2001 From: "Richard M. Stallman" Date: Sun, 23 Jun 1996 18:36:01 +0000 Subject: [PATCH] (font-lock-verbose): Default to 0. Doc fix. (font-lock-default-fontify-buffer): Interpret numeric value. (font-lock-fontified): Don't make it permanent-local. (font-lock-mode): Remove before-revert-hook and after-revert-hook code. Call font-lock-turn-on-thing-lock before font-lock-mode-hook. Doc fix. (font-lock-revert-setup, font-lock-revert-cleanup): Deleted. (font-lock-support-mode): New variable. (font-lock-turn-on-thing-lock): New function. Use it. (font-lock-turn-off-thing-lock): Renamed font-lock-thing-lock-cleanup. (font-lock-change-major-mode): Turn off Font Lock mode if it is on. Add font-lock-change-major-mode to change-major-mode-hook at top level. --- lisp/font-lock.el | 322 ++++++++++++++++++++++++++-------------------- 1 file changed, 182 insertions(+), 140 deletions(-) diff --git a/lisp/font-lock.el b/lisp/font-lock.el index f97722ac311..e7bb9e6e3c9 100644 --- a/lisp/font-lock.el +++ b/lisp/font-lock.el @@ -47,7 +47,8 @@ ;; Fontification for a particular mode may be available in a number of levels ;; of decoration. The higher the level, the more decoration, but the more time ;; it takes to fontify. See the variable `font-lock-maximum-decoration', and -;; also the variable `font-lock-maximum-size'. +;; also the variable `font-lock-maximum-size'. Support modes for Font Lock +;; mode can be used to speed up Font Lock mode. See `font-lock-support-mode'. ;; If you add patterns for a new mode, say foo.el's `foo-mode', say in which ;; you don't want syntactic fontification to occur, you can make Font Lock mode @@ -92,8 +93,9 @@ ;; User variables. -(defvar font-lock-verbose t - "*If non-nil, means show status messages when fontifying.") +(defvar font-lock-verbose (* 0 1024) + "*If non-nil, means show status messages for buffer fontification. +If a number, only buffers greater than this size have fontification messages.") ;;;###autoload (defvar font-lock-maximum-decoration nil @@ -103,9 +105,9 @@ If t, use the maximum decoration available. If a number, use that level of decoration (or if not available the maximum). If a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL), where MAJOR-MODE is a symbol or t (meaning the default). For example: - ((c++-mode . 2) (c-mode . t) (t . 1)) -means use level 2 decoration for buffers in `c++-mode', the maximum decoration -available for buffers in `c-mode', and level 1 decoration otherwise.") + ((c-mode . t) (c++-mode . 2) (t . 1)) +means use the maximum decoration available for buffers in C mode, level 2 +decoration for buffers in C++ mode, and level 1 decoration otherwise.") ;;;###autoload (defvar font-lock-maximum-size (* 250 1024) @@ -114,9 +116,9 @@ Only buffers less than this can be fontified when Font Lock mode is turned on. If nil, means size is irrelevant. If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE), where MAJOR-MODE is a symbol or t (meaning the default). For example: - ((c++-mode . 256000) (c-mode . 256000) (rmail-mode . 1048576)) -means that the maximum size is 250K for buffers in `c++-mode' or `c-mode', one -megabyte for buffers in `rmail-mode', and size is irrelevant otherwise.") + ((c-mode . 256000) (c++-mode . 256000) (rmail-mode . 1048576)) +means that the maximum size is 250K for buffers in C or C++ modes, one megabyte +for buffers in Rmail mode, and size is irrelevant otherwise.") ;; Fontification variables: @@ -245,17 +247,12 @@ The value should be like the `cdr' of an item in `font-lock-defaults-alist'.") (lisp-mode-defaults '((lisp-font-lock-keywords lisp-font-lock-keywords-1 lisp-font-lock-keywords-2) - nil nil - ((?: . "w") (?- . "w") (?* . "w") (?+ . "w") (?. . "w") (?< . "w") - (?> . "w") (?= . "w") (?! . "w") (?? . "w") (?$ . "w") (?% . "w") - (?_ . "w") (?& . "w") (?~ . "w") (?^ . "w") (?/ . "w")) - beginning-of-defun (font-lock-mark-block-function . mark-defun))) + nil nil (("+-*/.<>=!?$%_&~^:" . "w")) beginning-of-defun + (font-lock-mark-block-function . mark-defun))) (scheme-mode-defaults - '(scheme-font-lock-keywords nil t - ((?: . "w") (?- . "w") (?* . "w") (?+ . "w") (?. . "w") (?< . "w") - (?> . "w") (?= . "w") (?! . "w") (?? . "w") (?$ . "w") (?% . "w") - (?_ . "w") (?& . "w") (?~ . "w") (?^ . "w") (?/ . "w")) - beginning-of-defun (font-lock-mark-block-function . mark-defun))) + '(scheme-font-lock-keywords + nil t (("+-*/.<>=!?$%_&~^:" . "w")) beginning-of-defun + (font-lock-mark-block-function . mark-defun))) ;; For TeX modes we could use `backward-paragraph' for the same reason. ;; But we don't, because paragraph breaks are arguably likely enough to ;; occur within a genuine syntactic block to make it too risky. @@ -291,8 +288,8 @@ 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 . STRING) used to set the local Font Lock syntax table, for -keyword and syntactic fontification (see `modify-syntax-entry'). +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. @@ -319,8 +316,8 @@ around a text block relevant to that mode). Other variables include 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' and -`font-lock-inhibit-thing-lock'.") +`font-lock-fontify-region-function', `font-lock-unfontify-region-function', +`font-lock-maximum-size' and `font-lock-inhibit-thing-lock'.") (defvar font-lock-keywords-only nil "*Non-nil means Font Lock should not fontify comments or strings. @@ -377,13 +374,16 @@ This is normally set via `font-lock-defaults'.") (defvar font-lock-mode nil) ; For the modeline. (defvar font-lock-fontified nil) ; Whether we have fontified the buffer. -(put 'font-lock-fontified 'permanent-local t) ;;;###autoload (defvar font-lock-mode-hook nil "Function or functions to run on entry to Font Lock mode.") -;; User commands. +;; Font Lock mode. + +(eval-when-compile + ;; We don't do this at the top-level as we only use non-autoloaded macros. + (require 'cl)) ;;;###autoload (defun font-lock-mode (&optional arg) @@ -414,6 +414,9 @@ the variable `font-lock-defaults-alist'. You can set your own default settings for some mode, by setting a buffer local value for `font-lock-defaults', via its mode hook. +Font Lock mode has a number of support modes that may be used to speed up Font +Lock mode in various ways. See the variable `font-lock-support-mode'. + Where 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 @@ -428,47 +431,33 @@ syntactic change on other lines, you can use \\[font-lock-fontify-block]." (interactive "P") ;; Don't turn on Font Lock mode if we don't have a display (we're running a ;; batch job) or if the buffer is invisible (the name starts with a space). - (let ((maximum-size (font-lock-value-in-major-mode font-lock-maximum-size)) - (on-p (and (not noninteractive) + (let ((on-p (and (not noninteractive) (not (eq (aref (buffer-name) 0) ?\ )) (if arg (> (prefix-numeric-value arg) 0) (not font-lock-mode))))) - (if (not on-p) - (remove-hook 'after-change-functions 'font-lock-after-change-function - t) - (make-local-hook 'after-change-functions) - (add-hook 'after-change-functions 'font-lock-after-change-function - nil t)) (set (make-local-variable 'font-lock-mode) on-p) - (cond (on-p - (font-lock-set-defaults) - ;; If buffer is reverted, must clean up the state. - (make-local-hook 'before-revert-hook) - (make-local-hook 'after-revert-hook) - (add-hook 'before-revert-hook 'font-lock-revert-setup nil t) - (add-hook 'after-revert-hook 'font-lock-revert-cleanup nil t) - (run-hooks 'font-lock-mode-hook) - (cond (font-lock-fontified - nil) - ((or (null maximum-size) (<= (buffer-size) maximum-size) - (not (eq font-lock-fontify-buffer-function - (default-value - 'font-lock-fontify-buffer-function)))) - (font-lock-fontify-buffer)) - (font-lock-verbose - (message "Fontifying %s...buffer too big" (buffer-name))))) - (font-lock-fontified - (font-lock-unfontify-buffer) - (remove-hook 'before-revert-hook 'font-lock-revert-setup t) - (remove-hook 'after-revert-hook 'font-lock-revert-cleanup t) - (font-lock-thing-lock-cleanup) - (font-lock-unset-defaults)) - (t - (remove-hook 'before-revert-hook 'font-lock-revert-setup t) - (remove-hook 'after-revert-hook 'font-lock-revert-cleanup t) - (font-lock-thing-lock-cleanup) - (font-lock-unset-defaults))) + ;; Turn on Font Lock mode. + (when on-p + (make-local-hook 'after-change-functions) + (add-hook 'after-change-functions 'font-lock-after-change-function nil t) + (font-lock-set-defaults) + (font-lock-turn-on-thing-lock) + (run-hooks 'font-lock-mode-hook) + ;; 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 too big" (buffer-name)))))) + ;; Turn off Font Lock mode. + (when (not on-p) + (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)) (force-mode-line-update))) ;;;###autoload @@ -480,54 +469,74 @@ Turn on only if the buffer mode supports it and the terminal can display it." (or font-lock-defaults (assq major-mode font-lock-defaults-alist))) (font-lock-mode t))) -;; Code for Global Font Lock mode. - +;; 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, perhaps the same way hilit19.el/hl319.el does. I've always +;; 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. -;; In the latest of these discussions 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 +;; 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 variable `post-command-hook'. -;; By the time the functions on `post-command-hook' are run, the new major mode -;; is assumed to be in place. - +;; `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 -;; command that ran `kill-all-local-variables' has finished. 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. I don't know of any major -;; modes that do not follow the convension (a), but I'm sure there are some -;; obscure ones out there somewhere. Even if it works, it is still not clean. - +;; 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 -;; (space'n'speed), or have a special function such as `set-major-mode' (a -;; `major-mode-hook' is simpler), but maybe someone can come up with another -;; solution? --sm. +;; 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'). +;; +;; I don't think it is better that the feature be enabled via a variable, since +;; it does not conform to the usual convention. I don't think the feature +;; should be enabled by loading font-lock.el, since other mechanisms 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, and it is not intuitive or +;; informative because loading a file tells you nothing about the feature or +;; how to control it. It would be contrary to the Principle of Least Surprise. (defvar font-lock-buffers nil) ; For remembering buffers. -(defvar change-major-mode-hook nil) ; Make sure it's not void. +(defvar global-font-lock-mode nil) ;;;###autoload (defvar font-lock-global-modes t - "*Modes for which Font Lock mode is automatically turned on. + "*Modes for which Font Lock mode is automagically turned on. Global Font Lock mode is controlled by the `global-font-lock-mode' command. If nil, means no modes have Font Lock mode automatically turned on. If t, all modes that support Font Lock mode have it automatically turned on. -If a list, each element should be a major mode symbol name such as `c-mode'. -Font Lock is automatically turned on if the buffer major mode supports it and -is in this list. The sense of the list is negated if it begins with `not'.") +If a list, it should be a list of `major-mode' symbol names for which Font Lock +mode should be automatically turned on. The sense of the list is negated if it +begins with `not'. For example: + (c-mode c++-mode) +means that Font Lock mode is turned on for buffers in C and C++ modes only.") ;;;###autoload (defun global-font-lock-mode (&optional arg message) @@ -541,26 +550,27 @@ turned on in a buffer if its major mode is one of `font-lock-global-modes'." (interactive "P\np") (let ((off-p (if arg (<= (prefix-numeric-value arg) 0) - (memq 'font-lock-change-major-mode change-major-mode-hook)))) + global-font-lock-mode))) (if off-p - (remove-hook 'change-major-mode-hook 'font-lock-change-major-mode) - (add-hook 'change-major-mode-hook 'font-lock-change-major-mode) - (add-hook 'post-command-hook 'turn-on-font-lock-if-enabled) - ;; This is to make sure we fontify immediately - ;; when process filters (such as GUD) find files. + (remove-hook 'find-file-hooks 'turn-on-font-lock-if-enabled) (add-hook 'find-file-hooks 'turn-on-font-lock-if-enabled) + (add-hook 'post-command-hook 'turn-on-font-lock-if-enabled) (setq font-lock-buffers (buffer-list))) - (if message - (message "Global Font Lock mode is now %s." (if off-p "OFF" "ON"))) - (not off-p))) + (when message + (message "Global Font Lock mode is now %s." (if off-p "OFF" "ON"))) + (setq global-font-lock-mode (not off-p)))) (defun font-lock-change-major-mode () + ;; Turn off Font Lock mode if it's on. + (when font-lock-mode + (font-lock-mode nil)) ;; Gross hack warning: Delicate readers should avert eyes now. ;; Something is running `kill-all-local-variables', which generally means the ;; major mode is being changed. Run `turn-on-font-lock-if-enabled' after the - ;; current command has finished. - (add-hook 'post-command-hook 'turn-on-font-lock-if-enabled) - (add-to-list 'font-lock-buffers (current-buffer))) + ;; file is visited or the current command has finished. + (when global-font-lock-mode + (add-hook 'post-command-hook 'turn-on-font-lock-if-enabled) + (add-to-list 'font-lock-buffers (current-buffer)))) (defun turn-on-font-lock-if-enabled () ;; Gross hack warning: Delicate readers should avert eyes now. @@ -578,8 +588,64 @@ turned on in a buffer if its major mode is one of `font-lock-global-modes'." (turn-on-font-lock))))) (setq font-lock-buffers (cdr font-lock-buffers)))) +(add-hook 'change-major-mode-hook 'font-lock-change-major-mode) + ;; 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 +;; packages, and provide the user interface. Packages that have their own +;; local buffer fontification functions (see below) may have to call +;; `font-lock-after-fontify-buffer' and/or `font-lock-after-unfontify-buffer' +;; themselves. + +;;;###autoload +(defvar font-lock-support-mode nil + "*Support mode for Font Lock mode. +Support modes speed up Font Lock mode by being choosy about when fontification +occurs. Known support modes are Fast Lock mode (symbol `fast-lock-mode') and +Lazy Lock mode (symbol `lazy-lock-mode'). See those modes for more info. +If nil, means support for Font Lock mode is never performed. +If a symbol, use that support mode. +If a list, each element should be of the form (MAJOR-MODE . SUPPORT-MODE), +where MAJOR-MODE is a symbol or t (meaning the default). For example: + ((c-mode . fast-lock-mode) (c++-mode . fast-lock-mode) (t . lazy-lock-mode)) +means that Fast Lock mode is used to support Font Lock mode for buffers in C or +C++ modes, and Lazy Lock mode is used to support Font Lock mode otherwise. + +The value of this variable is used when Font Lock mode is turned on.") + +(defun font-lock-turn-on-thing-lock () + (let ((thing-mode (font-lock-value-in-major-mode font-lock-support-mode))) + (cond ((eq thing-mode 'fast-lock-mode) + (fast-lock-mode t)) + ((eq thing-mode 'lazy-lock-mode) + (lazy-lock-mode t))))) + +(defvar fast-lock-mode nil) +(defvar lazy-lock-mode nil) + +(defun font-lock-turn-off-thing-lock () + (cond (fast-lock-mode + (fast-lock-mode nil)) + (lazy-lock-mode + (lazy-lock-mode nil)))) + +(defun font-lock-after-fontify-buffer () + (cond (fast-lock-mode + (fast-lock-after-fontify-buffer)) + (lazy-lock-mode + (lazy-lock-after-fontify-buffer)))) + +(defun font-lock-after-unfontify-buffer () + (cond (fast-lock-mode + (fast-lock-after-unfontify-buffer)) + (lazy-lock-mode + (lazy-lock-after-unfontify-buffer)))) + +;; End of Font Lock Support mode. + ;; Fontification functions. ;;;###autoload @@ -599,7 +665,9 @@ turned on in a buffer if its major mode is one of `font-lock-global-modes'." (funcall font-lock-unfontify-region-function beg end)) (defun font-lock-default-fontify-buffer () - (let ((verbose (and font-lock-verbose (> (buffer-size) 0)))) + (let ((verbose (if (numberp font-lock-verbose) + (> (buffer-size) font-lock-verbose) + font-lock-verbose))) (if verbose (message "Fontifying %s..." (buffer-name))) ;; Make sure we have the right `font-lock-keywords' etc. (if (not font-lock-mode) (font-lock-set-defaults)) @@ -971,39 +1039,6 @@ START should be at the beginning of a line." ;; Various functions. -;; Turn off other related packages if they're on. I prefer a hook. --sm. -;; These explicit calls are easier to understand -;; because people know what they will do. -;; A hook is a mystery because it might do anything whatever. --rms. -(defun font-lock-thing-lock-cleanup () - (cond ((and (boundp 'fast-lock-mode) fast-lock-mode) - (fast-lock-mode -1)) - ((and (boundp 'lazy-lock-mode) lazy-lock-mode) - (lazy-lock-mode -1)))) - -;; Do something special for these packages after fontifying; I prefer a hook. -(defun font-lock-after-fontify-buffer () - (cond ((and (boundp 'fast-lock-mode) fast-lock-mode) - (fast-lock-after-fontify-buffer)) - ((and (boundp 'lazy-lock-mode) lazy-lock-mode) - (lazy-lock-after-fontify-buffer)))) - -;; Do something special for these packages after unfontifying; I prefer a hook. -(defun font-lock-after-unfontify-buffer () - (cond ((and (boundp 'fast-lock-mode) fast-lock-mode) - (fast-lock-after-unfontify-buffer)) - ((and (boundp 'lazy-lock-mode) lazy-lock-mode) - (lazy-lock-after-unfontify-buffer)))) - -;; If the buffer is about to be reverted, it won't be fontified afterward. -(defun font-lock-revert-setup () - (setq font-lock-fontified nil)) - -;; If the buffer has just been reverted, normally that turns off -;; Font Lock mode. So turn the mode back on if necessary. -(defalias 'font-lock-revert-cleanup - 'turn-on-font-lock) - (defun font-lock-compile-keywords (&optional keywords) ;; Compile `font-lock-keywords' into the form (t KEYWORD ...) where KEYWORD ;; is the (MATCHER HIGHLIGHT ...) shown in the variable's doc string. @@ -1076,9 +1111,16 @@ Sets various variables using `font-lock-defaults' (or, if nil, using (set (make-local-variable 'font-lock-syntax-table) (copy-syntax-table (syntax-table))) (while slist - (modify-syntax-entry (car (car slist)) (cdr (car slist)) - font-lock-syntax-table) - (setq slist (cdr 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)))))) ;; Syntax function for syntactic fontification? (if (nth 4 defaults) (set (make-local-variable 'font-lock-beginning-of-syntax-function) @@ -1499,8 +1541,8 @@ the face is also set; its value is the face name." ;; Fontify function macro names. '("^#[ \t]*define[ \t]+\\(\\sw+\\)(" 1 font-lock-function-name-face) ;; - ;; Fontify symbol names in #if ... defined preprocessor directives. - '("^#[ \t]*if\\>" + ;; Fontify symbol names in #elif or #if ... defined preprocessor directives. + '("^#[ \t]*\\(elif\\|if\\)\\>" ("\\<\\(defined\\)\\>[ \t]*(?\\(\\sw+\\)?" nil nil (1 font-lock-reference-face) (2 font-lock-variable-name-face nil t))) ;; @@ -1578,7 +1620,7 @@ the face is also set; its value is the face name." (1 (if (match-beginning 2) font-lock-type-face font-lock-function-name-face)) - (3 (if (match-beginning 2) font-lock-function-name-face) nil t)) + (3 font-lock-function-name-face nil t)) ))) (setq c++-font-lock-keywords-2 @@ -1686,8 +1728,8 @@ the face is also set; its value is the face name." ;; Install ourselves: -(or (assq 'font-lock-mode minor-mode-alist) - (setq minor-mode-alist (cons '(font-lock-mode " Font") minor-mode-alist))) +(unless (assq 'font-lock-mode minor-mode-alist) + (setq minor-mode-alist (cons '(font-lock-mode " Font") minor-mode-alist))) ;; Provide ourselves: -- 2.39.2