aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorStefan Monnier2005-04-07 12:01:21 +0000
committerStefan Monnier2005-04-07 12:01:21 +0000
commit9f27bc82665bb4a50ea4cbc58f1aa400fc37246b (patch)
tree8fa166e5b858af357a908537aaffc081e31f6a84
parent11dd83c89907e16f0a58b3b373fa1afdd58dda6d (diff)
downloademacs-9f27bc82665bb4a50ea4cbc58f1aa400fc37246b.tar.gz
emacs-9f27bc82665bb4a50ea4cbc58f1aa400fc37246b.zip
Move to the obsolete subdir.
Diffstat
-rw-r--r--lisp/fast-lock.el863
-rw-r--r--lisp/lazy-lock.el1054
2 files changed, 0 insertions, 1917 deletions
diff --git a/lisp/fast-lock.el b/lisp/fast-lock.el
deleted file mode 100644
index 4a409bd77aa..00000000000
--- a/lisp/fast-lock.el
+++ /dev/null
@@ -1,863 +0,0 @@
1;;; fast-lock.el --- automagic text properties caching for fast Font Lock mode
2
3;; Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
4
5;; Author: Simon Marshall <simon@gnu.org>
6;; Maintainer: FSF
7;; Keywords: faces files
8;; Version: 3.14
9
10;; This file is part of GNU Emacs.
11
12;; GNU Emacs is free software; you can redistribute it and/or modify
13;; it under the terms of the GNU General Public License as published by
14;; the Free Software Foundation; either version 2, or (at your option)
15;; any later version.
16
17;; GNU Emacs is distributed in the hope that it will be useful,
18;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20;; GNU General Public License for more details.
21
22;; You should have received a copy of the GNU General Public License
23;; along with GNU Emacs; see the file COPYING. If not, write to the
24;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
25;; Boston, MA 02111-1307, USA.
26
27;;; Commentary:
28
29;; Fast Lock mode is a Font Lock support mode.
30;; It makes visiting a file in Font Lock mode faster by restoring its face text
31;; properties from automatically saved associated Font Lock cache files.
32;;
33;; See caveats and feedback below.
34;; See also the lazy-lock package. (But don't use the two at the same time!)
35
36;; Installation:
37;;
38;; Put in your ~/.emacs:
39;;
40;; (setq font-lock-support-mode 'fast-lock-mode)
41;;
42;; Start up a new Emacs and use font-lock as usual (except that you can use the
43;; so-called "gaudier" fontification regexps on big files without frustration).
44;;
45;; When you visit a file (which has `font-lock-mode' enabled) that has a
46;; corresponding Font Lock cache file associated with it, the Font Lock cache
47;; will be loaded from that file instead of being generated by Font Lock code.
48
49;; Caveats:
50;;
51;; A cache will be saved when visiting a compressed file using crypt++, but not
52;; be read. This is a "feature"/"consequence"/"bug" of crypt++.
53;;
54;; Version control packages are likely to stamp all over file modification
55;; times. Therefore the act of checking out may invalidate a cache.
56
57;; History:
58;;
59;; 0.02--1.00:
60;; - Changed name from turbo-prop to fast-lock. Automagic for font-lock only
61;; - Made `fast-lock-mode' a minor mode, like G. Dinesh Dutt's fss-mode
62;; 1.00--1.01:
63;; - Turn on `fast-lock-mode' only if `buffer-file-name' or `interactive-p'
64;; - Made `fast-lock-file-name' use `buffer-name' if `buffer-file-name' is nil
65;; - Moved save-all conditions to `fast-lock-save-cache'
66;; - Added `fast-lock-save-text-properties' to `kill-buffer-hook'
67;; 1.01--2.00: complete rewrite---not worth the space to document
68;; - Changed structure of text properties cache and threw out file mod checks
69;; 2.00--2.01:
70;; - Made `condition-case' forms understand `quit'.
71;; - Made `fast-lock' require `font-lock'
72;; - Made `fast-lock-cache-name' chase links (from Ben Liblit)
73;; 2.01--3.00:
74;; - Changed structure of cache to include `font-lock-keywords' (from rms)
75;; - Changed `fast-lock-cache-mechanisms' to `fast-lock-cache-directories'
76;; - Removed `fast-lock-read-others'
77;; - Made `fast-lock-read-cache' ignore cache owner
78;; - Made `fast-lock-save-cache-external' create cache directory
79;; - Made `fast-lock-save-cache-external' save `font-lock-keywords'
80;; - Made `fast-lock-cache-data' check `font-lock-keywords'
81;; 3.00--3.01: incorporated port of 2.00 to Lucid, made by Barry Warsaw
82;; - Package now provides itself
83;; - Lucid: Use `font-lock-any-extents-p' for `font-lock-any-properties-p'
84;; - Lucid: Use `list-faces' for `face-list'
85;; - Lucid: Added `set-text-properties'
86;; - Lucid: Made `turn-on-fast-lock' pass 1 not t to `fast-lock-mode'
87;; - Removed test for `fast-lock-mode' from `fast-lock-read-cache'
88;; - Lucid: Added Lucid-specific `fast-lock-get-face-properties'
89;; 3.01--3.02: now works with Lucid Emacs, thanks to Barry Warsaw
90;; - Made `fast-lock-cache-name' map ":" to ";" for OS/2 (from Serganova Vera)
91;; - Made `fast-lock-cache-name' use abbreviated file name (from Barry Warsaw)
92;; - Lucid: Separated handlers for `error' and `quit' for `condition-case'
93;; 3.02--3.03:
94;; - Changed `fast-lock-save-cache-external' to `fast-lock-save-cache-data'
95;; - Lucid: Added Lucid-specific `fast-lock-set-face-properties'
96;; 3.03--3.04:
97;; - Corrected `subrp' test of Lucid code
98;; - Replaced `font-lock-any-properties-p' with `text-property-not-all'
99;; - Lucid: Made `fast-lock-set-face-properties' put `text-prop' on extents
100;; - Made `fast-lock-cache-directories' a regexp alist (from Colin Rafferty)
101;; - Made `fast-lock-cache-directory' to return a usable cache file directory
102;; 3.04--3.05:
103;; - Lucid: Fix for XEmacs 19.11 `text-property-not-all'
104;; - Replaced `subrp' test of Lucid code with `emacs-version' `string-match'
105;; - Made `byte-compile-warnings' omit `unresolved' on compilation
106;; - Made `fast-lock-save-cache-data' use a buffer (from Rick Sladkey)
107;; - Reverted to old `fast-lock-get-face-properties' (from Rick Sladkey)
108;; 3.05--3.06: incorporated hack of 3.03, made by Jonathan Stigelman (Stig)
109;; - Reverted to 3.04 version of `fast-lock-get-face-properties'
110;; - XEmacs: Removed `list-faces' `defalias'
111;; - Made `fast-lock-mode' and `turn-on-fast-lock' succeed `autoload' cookies
112;; - Added `fast-lock-submit-bug-report'
113;; - Renamed `fast-lock-save-size' to `fast-lock-minimum-size'
114;; - Made `fast-lock-save-cache' output a message if no save ever attempted
115;; - Made `fast-lock-save-cache-data' output a message if save attempted
116;; - Made `fast-lock-cache-data' output a message if load attempted
117;; - Made `fast-lock-save-cache-data' do `condition-case' not `unwind-protect'
118;; - Made `fast-lock-save-cache' and `fast-lock-read-cache' return nothing
119;; - Made `fast-lock-save-cache' check `buffer-modified-p' (Stig)
120;; - Added `fast-lock-save-events'
121;; - Added `fast-lock-after-save-hook' to `after-save-hook' (Stig)
122;; - Added `fast-lock-kill-buffer-hook' to `kill-buffer-hook'
123;; - Changed `fast-lock-save-caches' to `fast-lock-kill-emacs-hook'
124;; - Added `fast-lock-kill-emacs-hook' to `kill-emacs-hook'
125;; - Made `fast-lock-save-cache' check `verify-visited-file-modtime' (Stig)
126;; - Made `visited-file-modtime' be the basis of the timestamp (Stig)
127;; - Made `fast-lock-save-cache-1' and `fast-lock-cache-data' use/reformat it
128;; - Added `fast-lock-cache-filename' to keep track of the cache file name
129;; - Added `fast-lock-after-fontify-buffer'
130;; - Added `fast-lock-save-faces' list of faces to save (idea from Stig/Tibor)
131;; - Made `fast-lock-get-face-properties' functions use it
132;; - XEmacs: Made `fast-lock-set-face-properties' do extents the Font Lock way
133;; - XEmacs: Removed fix for `text-property-not-all' (19.11 support dropped)
134;; - Made `fast-lock-mode' ensure `font-lock-mode' is on
135;; - Made `fast-lock-save-cache' do `cdr-safe' not `cdr' (from Dave Foster)
136;; - Made `fast-lock-save-cache' do `set-buffer' first (from Dave Foster)
137;; - Made `fast-lock-save-cache' loop until saved or quit (from Georg Nikodym)
138;; - Made `fast-lock-cache-data' check `buffer-modified-p'
139;; - Made `fast-lock-cache-data' do `font-lock-compile-keywords' if necessary
140;; - XEmacs: Made `font-lock-compile-keywords' `defalias'
141;; 3.06--3.07:
142;; - XEmacs: Add `fast-lock-after-fontify-buffer' to the Font Lock hook
143;; - Made `fast-lock-cache-name' explain the use of `directory-abbrev-alist'
144;; - Made `fast-lock-mode' use `buffer-file-truename' not `buffer-file-name'
145;; 3.07--3.08:
146;; - Made `fast-lock-read-cache' set `fast-lock-cache-filename'
147;; 3.08--3.09:
148;; - Made `fast-lock-save-cache' cope if `fast-lock-minimum-size' is an a list
149;; - Made `fast-lock-mode' respect the value of `font-lock-inhibit-thing-lock'
150;; - Added `fast-lock-after-unfontify-buffer'
151;; 3.09--3.10:
152;; - Rewrite for Common Lisp macros
153;; - Made fast-lock.el barf on a crap 8+3 pseudo-OS (Eli Zaretskii help)
154;; - XEmacs: Made `add-minor-mode' succeed `autoload' cookie
155;; - XEmacs: Made `fast-lock-save-faces' default to `font-lock-face-list'
156;; - Made `fast-lock-save-cache' use `font-lock-value-in-major-mode'
157;; - Wrap with `save-buffer-state' (Ray Van Tassle report)
158;; - Made `fast-lock-mode' wrap `font-lock-support-mode'
159;; 3.10--3.11:
160;; - Made `fast-lock-get-face-properties' cope with face lists
161;; - Added `fast-lock-verbose'
162;; - XEmacs: Add `font-lock-value-in-major-mode' if necessary
163;; - Removed `fast-lock-submit-bug-report' and bade farewell
164;; 3.11--3.12:
165;; - Added Custom support (Hrvoje Niksic help)
166;; - Made `save-buffer-state' wrap `inhibit-point-motion-hooks'
167;; - Made `fast-lock-cache-data' simplify calls of `font-lock-compile-keywords'
168;; 3.12--3.13:
169;; - Removed `byte-*' variables from `eval-when-compile' (Erik Naggum hint)
170;; - Changed structure of cache to include `font-lock-syntactic-keywords'
171;; - Made `fast-lock-save-cache-1' save syntactic fontification data
172;; - Made `fast-lock-cache-data' take syntactic fontification data
173;; - Added `fast-lock-get-syntactic-properties'
174;; - Renamed `fast-lock-set-face-properties' to `fast-lock-add-properties'
175;; - Made `fast-lock-add-properties' add syntactic and face fontification data
176;; 3.13--3.14:
177;; - Made `fast-lock-cache-name' cope with `windowsnt' (Geoff Voelker fix)
178;; - Made `fast-lock-verbose' use `other' widget (Andreas Schwab fix)
179;; - Used `with-temp-message' where possible to make messages temporary.
180
181;;; Code:
182
183(require 'font-lock)
184
185;; Make sure fast-lock.el is supported.
186(if (and (eq system-type 'ms-dos) (not (msdos-long-file-names)))
187 (error "`fast-lock' was written for long file name systems"))
188
189(eval-when-compile
190 ;;
191 ;; We don't do this at the top-level as we only use non-autoloaded macros.
192 (require 'cl)
193 ;;
194 ;; We use this to preserve or protect things when modifying text properties.
195 (defmacro save-buffer-state (varlist &rest body)
196 "Bind variables according to VARLIST and eval BODY restoring buffer state."
197 `(let* (,@(append varlist
198 '((modified (buffer-modified-p)) (buffer-undo-list t)
199 (inhibit-read-only t) (inhibit-point-motion-hooks t)
200 before-change-functions after-change-functions
201 deactivate-mark buffer-file-name buffer-file-truename)))
202 ,@body
203 (when (and (not modified) (buffer-modified-p))
204 (set-buffer-modified-p nil))))
205 (put 'save-buffer-state 'lisp-indent-function 1)
206 ;;
207 ;; We use this to verify that a face should be saved.
208 (defmacro fast-lock-save-facep (face)
209 "Return non-nil if FACE is one of `fast-lock-save-faces'."
210 `(or (null fast-lock-save-faces)
211 (if (symbolp ,face)
212 (memq ,face fast-lock-save-faces)
213 (let ((faces ,face))
214 (while (unless (memq (car faces) fast-lock-save-faces)
215 (setq faces (cdr faces))))
216 faces))))
217 ;;
218 ;; We use this for compatibility with a future Emacs.
219 (or (fboundp 'with-temp-message)
220 (defmacro with-temp-message (message &rest body)
221 `(let ((temp-message ,message) current-message)
222 (unwind-protect
223 (progn
224 (when temp-message
225 (setq current-message (current-message))
226 (message temp-message))
227 ,@body)
228 (when temp-message
229 (message current-message))))))
230 ;;
231 ;; We use this for compatibility with a future Emacs.
232 (or (fboundp 'defcustom)
233 (defmacro defcustom (symbol value doc &rest args)
234 `(defvar ,symbol ,value ,doc))))
235
236;(defun fast-lock-submit-bug-report ()
237; "Submit via mail a bug report on fast-lock.el."
238; (interactive)
239; (let ((reporter-prompt-for-summary-p t))
240; (reporter-submit-bug-report "simon@gnu.org" "fast-lock 3.14"
241; '(fast-lock-cache-directories fast-lock-minimum-size
242; fast-lock-save-others fast-lock-save-events fast-lock-save-faces
243; fast-lock-verbose)
244; nil nil
245; (concat "Hi Si.,
246;
247;I want to report a bug. I've read the `Bugs' section of `Info' on Emacs, so I
248;know how to make a clear and unambiguous report. To reproduce the bug:
249;
250;Start a fresh editor via `" invocation-name " -no-init-file -no-site-file'.
251;In the `*scratch*' buffer, evaluate:"))))
252
253(defvar fast-lock-mode nil) ; Whether we are turned on.
254(defvar fast-lock-cache-timestamp nil) ; For saving/reading.
255(defvar fast-lock-cache-filename nil) ; For deleting.
256
257;; User Variables:
258
259(defcustom fast-lock-minimum-size 25600
260 "*Minimum size of a buffer for cached fontification.
261Only buffers more than this can have associated Font Lock cache files saved.
262If nil, means cache files are never created.
263If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
264where MAJOR-MODE is a symbol or t (meaning the default). For example:
265 ((c-mode . 25600) (c++-mode . 25600) (rmail-mode . 1048576))
266means that the minimum size is 25K for buffers in C or C++ modes, one megabyte
267for buffers in Rmail mode, and size is irrelevant otherwise."
268 :type '(choice (const :tag "none" nil)
269 (integer :tag "size")
270 (repeat :menu-tag "mode specific" :tag "mode specific"
271 :value ((t . nil))
272 (cons :tag "Instance"
273 (radio :tag "Mode"
274 (const :tag "all" t)
275 (symbol :tag "name"))
276 (radio :tag "Size"
277 (const :tag "none" nil)
278 (integer :tag "size")))))
279 :group 'fast-lock)
280
281(defcustom fast-lock-cache-directories '("." "~/.emacs-flc")
282; - `internal', keep each file's Font Lock cache file in the same file.
283; - `external', keep each file's Font Lock cache file in the same directory.
284 "*Directories in which Font Lock cache files are saved and read.
285Each item should be either DIR or a cons pair of the form (REGEXP . DIR) where
286DIR is a directory name (relative or absolute) and REGEXP is a regexp.
287
288An attempt will be made to save or read Font Lock cache files using these items
289until one succeeds (i.e., until a readable or writable one is found). If an
290item contains REGEXP, DIR is used only if the buffer file name matches REGEXP.
291For example:
292
293 (let ((home (expand-file-name (abbreviate-file-name (file-truename \"~/\")))))
294 (list (cons (concat \"^\" (regexp-quote home)) \".\") \"~/.emacs-flc\"))
295 =>
296 ((\"^/your/true/home/directory/\" . \".\") \"~/.emacs-flc\")
297
298would cause a file's current directory to be used if the file is under your
299home directory hierarchy, or otherwise the absolute directory `~/.emacs-flc'."
300 :type '(repeat (radio (directory :tag "directory")
301 (cons :tag "Matching"
302 (regexp :tag "regexp")
303 (directory :tag "directory"))))
304 :group 'fast-lock)
305
306(defcustom fast-lock-save-events '(kill-buffer kill-emacs)
307 "*Events under which caches will be saved.
308Valid events are `save-buffer', `kill-buffer' and `kill-emacs'.
309If concurrent editing sessions use the same associated cache file for a file's
310buffer, then you should add `save-buffer' to this list."
311 :type '(set (const :tag "buffer saving" save-buffer)
312 (const :tag "buffer killing" kill-buffer)
313 (const :tag "emacs killing" kill-emacs))
314 :group 'fast-lock)
315
316(defcustom fast-lock-save-others t
317 "*If non-nil, save Font Lock cache files irrespective of file owner.
318If nil, means only buffer files known to be owned by you can have associated
319Font Lock cache files saved. Ownership may be unknown for networked files."
320 :type 'boolean
321 :group 'fast-lock)
322
323(defcustom fast-lock-verbose font-lock-verbose
324 "*If non-nil, means show status messages for cache processing.
325If a number, only buffers greater than this size have processing messages."
326 :type '(choice (const :tag "never" nil)
327 (other :tag "always" t)
328 (integer :tag "size"))
329 :group 'fast-lock)
330
331(defvar fast-lock-save-faces
332 (when (save-match-data (string-match "XEmacs" (emacs-version)))
333 ;; XEmacs uses extents for everything, so we have to pick the right ones.
334 font-lock-face-list)
335 "Faces that will be saved in a Font Lock cache file.
336If nil, means information for all faces will be saved.")
337
338;; User Functions:
339
340;;;###autoload
341(defun fast-lock-mode (&optional arg)
342 "Toggle Fast Lock mode.
343With arg, turn Fast Lock mode on if and only if arg is positive and the buffer
344is associated with a file. Enable it automatically in your `~/.emacs' by:
345
346 (setq font-lock-support-mode 'fast-lock-mode)
347
348If Fast Lock mode is enabled, and the current buffer does not contain any text
349properties, any associated Font Lock cache is used if its timestamp matches the
350buffer's file, and its `font-lock-keywords' match those that you are using.
351
352Font Lock caches may be saved:
353- When you save the file's buffer.
354- When you kill an unmodified file's buffer.
355- When you exit Emacs, for all unmodified or saved buffers.
356Depending on the value of `fast-lock-save-events'.
357See also the commands `fast-lock-read-cache' and `fast-lock-save-cache'.
358
359Use \\[font-lock-fontify-buffer] to fontify the buffer if the cache is bad.
360
361Various methods of control are provided for the Font Lock cache. In general,
362see variable `fast-lock-cache-directories' and function `fast-lock-cache-name'.
363For saving, see variables `fast-lock-minimum-size', `fast-lock-save-events',
364`fast-lock-save-others' and `fast-lock-save-faces'."
365 (interactive "P")
366 ;; Only turn on if we are visiting a file. We could use `buffer-file-name',
367 ;; but many packages temporarily wrap that to nil when doing their own thing.
368 (set (make-local-variable 'fast-lock-mode)
369 (and buffer-file-truename
370 (not (memq 'fast-lock-mode font-lock-inhibit-thing-lock))
371 (if arg (> (prefix-numeric-value arg) 0) (not fast-lock-mode))))
372 (if (and fast-lock-mode (not font-lock-mode))
373 ;; Turned on `fast-lock-mode' rather than `font-lock-mode'.
374 (let ((font-lock-support-mode 'fast-lock-mode))
375 (font-lock-mode t))
376 ;; Let's get down to business.
377 (set (make-local-variable 'fast-lock-cache-timestamp) nil)
378 (set (make-local-variable 'fast-lock-cache-filename) nil)
379 (when (and fast-lock-mode (not font-lock-fontified))
380 (fast-lock-read-cache))))
381
382(defun fast-lock-read-cache ()
383 "Read the Font Lock cache for the current buffer.
384
385The following criteria must be met for a Font Lock cache file to be read:
386- Fast Lock mode must be turned on in the buffer.
387- The buffer must not be modified.
388- The buffer's `font-lock-keywords' must match the cache's.
389- The buffer file's timestamp must match the cache's.
390- Criteria imposed by `fast-lock-cache-directories'.
391
392See `fast-lock-mode'."
393 (interactive)
394 (let ((directories fast-lock-cache-directories)
395 (modified (buffer-modified-p)) (inhibit-read-only t)
396 (fontified font-lock-fontified))
397 (set (make-local-variable 'font-lock-fontified) nil)
398 ;; Keep trying directories until fontification is turned off.
399 (while (and directories (not font-lock-fontified))
400 (let ((directory (fast-lock-cache-directory (car directories) nil)))
401 (condition-case nil
402 (when directory
403 (setq fast-lock-cache-filename (fast-lock-cache-name directory))
404 (when (file-readable-p fast-lock-cache-filename)
405 (load fast-lock-cache-filename t t t)))
406 (error nil) (quit nil))
407 (setq directories (cdr directories))))
408 ;; Unset `fast-lock-cache-filename', and restore `font-lock-fontified', if
409 ;; we don't use a cache. (Note that `fast-lock-cache-data' sets the value
410 ;; of `fast-lock-cache-timestamp'.)
411 (set-buffer-modified-p modified)
412 (unless font-lock-fontified
413 (setq fast-lock-cache-filename nil font-lock-fontified fontified))))
414
415(defun fast-lock-save-cache (&optional buffer)
416 "Save the Font Lock cache of BUFFER or the current buffer.
417
418The following criteria must be met for a Font Lock cache file to be saved:
419- Fast Lock mode must be turned on in the buffer.
420- The event must be one of `fast-lock-save-events'.
421- The buffer must be at least `fast-lock-minimum-size' bytes long.
422- The buffer file must be owned by you, or `fast-lock-save-others' must be t.
423- The buffer must contain at least one `face' text property.
424- The buffer must not be modified.
425- The buffer file's timestamp must be the same as the file's on disk.
426- The on disk file's timestamp must be different than the buffer's cache.
427- Criteria imposed by `fast-lock-cache-directories'.
428
429See `fast-lock-mode'."
430 (interactive)
431 (save-excursion
432 (when buffer
433 (set-buffer buffer))
434 (let ((min-size (font-lock-value-in-major-mode fast-lock-minimum-size))
435 (file-timestamp (visited-file-modtime)) (saved nil))
436 (when (and fast-lock-mode
437 ;;
438 ;; "Only save if the buffer matches the file, the file has
439 ;; changed, and it was changed by the current emacs session."
440 ;;
441 ;; Only save if the buffer is not modified,
442 ;; (i.e., so we don't save for something not on disk)
443 (not (buffer-modified-p))
444 ;; and the file's timestamp is the same as the buffer's,
445 ;; (i.e., someone else hasn't written the file in the meantime)
446 (verify-visited-file-modtime (current-buffer))
447 ;; and the file's timestamp is different from the cache's.
448 ;; (i.e., a save has occurred since the cache was read)
449 (not (equal fast-lock-cache-timestamp file-timestamp))
450 ;;
451 ;; Only save if user's restrictions are satisfied.
452 (and min-size (>= (buffer-size) min-size))
453 (or fast-lock-save-others
454 (eq (user-uid) (nth 2 (file-attributes buffer-file-name))))
455 ;;
456 ;; Only save if there are `face' properties to save.
457 (text-property-not-all (point-min) (point-max) 'face nil))
458 ;;
459 ;; Try each directory until we manage to save or the user quits.
460 (let ((directories fast-lock-cache-directories))
461 (while (and directories (memq saved '(nil error)))
462 (let* ((dir (fast-lock-cache-directory (car directories) t))
463 (file (and dir (fast-lock-cache-name dir))))
464 (when (and file (file-writable-p file))
465 (setq saved (fast-lock-save-cache-1 file file-timestamp)))
466 (setq directories (cdr directories)))))))))
467
468;;;###autoload
469(defun turn-on-fast-lock ()
470 "Unconditionally turn on Fast Lock mode."
471 (fast-lock-mode t))
472
473;;; API Functions:
474
475(defun fast-lock-after-fontify-buffer ()
476 ;; Delete the Font Lock cache file used to restore fontification, if any.
477 (when fast-lock-cache-filename
478 (if (file-writable-p fast-lock-cache-filename)
479 (delete-file fast-lock-cache-filename)
480 (message "File %s font lock cache cannot be deleted" (buffer-name))))
481 ;; Flag so that a cache will be saved later even if the file is never saved.
482 (setq fast-lock-cache-timestamp nil))
483
484(defalias 'fast-lock-after-unfontify-buffer
485 'ignore)
486
487;; Miscellaneous Functions:
488
489(defun fast-lock-save-cache-after-save-file ()
490 ;; Do `fast-lock-save-cache' if `save-buffer' is on `fast-lock-save-events'.
491 (when (memq 'save-buffer fast-lock-save-events)
492 (fast-lock-save-cache)))
493
494(defun fast-lock-save-cache-before-kill-buffer ()
495 ;; Do `fast-lock-save-cache' if `kill-buffer' is on `fast-lock-save-events'.
496 (when (memq 'kill-buffer fast-lock-save-events)
497 (fast-lock-save-cache)))
498
499(defun fast-lock-save-caches-before-kill-emacs ()
500 ;; Do `fast-lock-save-cache's if `kill-emacs' is on `fast-lock-save-events'.
501 (when (memq 'kill-emacs fast-lock-save-events)
502 (mapcar 'fast-lock-save-cache (buffer-list))))
503
504(defun fast-lock-cache-directory (directory create)
505 "Return usable directory based on DIRECTORY.
506Returns nil if the directory does not exist, or, if CREATE non-nil, cannot be
507created. DIRECTORY may be a string or a cons pair of the form (REGEXP . DIR).
508See `fast-lock-cache-directories'."
509 (let ((dir
510 (cond ((not buffer-file-name)
511 ;; Should never be nil, but `crypt++' screws it up.
512 nil)
513 ((stringp directory)
514 ;; Just a directory.
515 directory)
516 (t
517 ;; A directory iff the file name matches the regexp.
518 (let ((bufile (expand-file-name buffer-file-truename))
519 (case-fold-search nil))
520 (when (save-match-data (string-match (car directory) bufile))
521 (cdr directory)))))))
522 (cond ((not dir)
523 nil)
524 ((file-accessible-directory-p dir)
525 dir)
526 (create
527 (condition-case nil
528 (progn (make-directory dir t) dir)
529 (error nil))))))
530
531;; If you are wondering why we only hash if the directory is not ".", rather
532;; than if `file-name-absolute-p', it is because if we just appended ".flc" for
533;; relative cache directories (that are not ".") then it is possible that more
534;; than one file would have the same cache name in that directory, if the luser
535;; made a link from one relative cache directory to another. (Phew!)
536(defun fast-lock-cache-name (directory)
537 "Return full cache file name using caching DIRECTORY.
538If DIRECTORY is `.', the file name is the buffer file name appended with `.flc'.
539Otherwise, the file name is constructed from DIRECTORY and the buffer's true
540abbreviated file name, with all `/' characters in the name replaced with `#'
541characters, and appended with `.flc'.
542
543If the same file has different cache file names when edited on different
544machines, e.g., on one machine the cache file name has the prefix `#home',
545perhaps due to automount, try putting in your `~/.emacs' something like:
546
547 (setq directory-abbrev-alist (cons '(\"^/home/\" . \"/\") directory-abbrev-alist))
548
549Emacs automagically removes the common `/tmp_mnt' automount prefix by default.
550
551See `fast-lock-cache-directory'."
552 (if (string-equal directory ".")
553 (concat buffer-file-name ".flc")
554 (let* ((bufile (expand-file-name buffer-file-truename))
555 (chars-alist
556 (if (memq system-type '(emx windows-nt cygwin))
557 '((?/ . (?#)) (?# . (?# ?#)) (?: . (?\;)) (?\; . (?\; ?\;)))
558 '((?/ . (?#)) (?# . (?# ?#)))))
559 (mapchars
560 (function (lambda (c) (or (cdr (assq c chars-alist)) (list c))))))
561 (concat
562 (file-name-as-directory (expand-file-name directory))
563 (mapconcat 'char-to-string (apply 'append (mapcar mapchars bufile)) "")
564 ".flc"))))
565
566;; Font Lock Cache Processing Functions:
567
568;; The version 3 format of the cache is:
569;;
570;; (fast-lock-cache-data VERSION TIMESTAMP
571;; font-lock-syntactic-keywords SYNTACTIC-PROPERTIES
572;; font-lock-keywords FACE-PROPERTIES)
573
574(defun fast-lock-save-cache-1 (file timestamp)
575 ;; Save the FILE with the TIMESTAMP plus fontification data.
576 ;; Returns non-nil if a save was attempted to a writable cache file.
577 (let ((tpbuf (generate-new-buffer " *fast-lock*"))
578 (verbose (if (numberp fast-lock-verbose)
579 (> (buffer-size) fast-lock-verbose)
580 fast-lock-verbose))
581 (saved t))
582 (with-temp-message
583 (when verbose
584 (format "Saving %s font lock cache..." (buffer-name)))
585 (condition-case nil
586 (save-excursion
587 (print (list 'fast-lock-cache-data 3
588 (list 'quote timestamp)
589 (list 'quote font-lock-syntactic-keywords)
590 (list 'quote (fast-lock-get-syntactic-properties))
591 (list 'quote font-lock-keywords)
592 (list 'quote (fast-lock-get-face-properties)))
593 tpbuf)
594 (set-buffer tpbuf)
595 (write-region (point-min) (point-max) file nil 'quietly)
596 (setq fast-lock-cache-timestamp timestamp
597 fast-lock-cache-filename file))
598 (error (setq saved 'error)) (quit (setq saved 'quit)))
599 (kill-buffer tpbuf))
600 (cond ((eq saved 'quit)
601 (message "Saving %s font lock cache...quit" (buffer-name)))
602 ((eq saved 'error)
603 (message "Saving %s font lock cache...failed" (buffer-name))))
604 ;; We return non-nil regardless of whether a failure occurred.
605 saved))
606
607(defun fast-lock-cache-data (version timestamp
608 syntactic-keywords syntactic-properties
609 keywords face-properties
610 &rest ignored)
611 ;; Find value of syntactic keywords in case it is a symbol.
612 (setq font-lock-syntactic-keywords (font-lock-eval-keywords
613 font-lock-syntactic-keywords))
614 ;; Compile all keywords in case some are and some aren't.
615 (when font-lock-syntactic-keywords
616 (setq font-lock-syntactic-keywords (font-lock-compile-keywords
617 font-lock-syntactic-keywords)))
618 (when syntactic-keywords
619 (setq syntactic-keywords (font-lock-compile-keywords syntactic-keywords)))
620 (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords)
621 keywords (font-lock-compile-keywords keywords))
622 ;; Use the Font Lock cache SYNTACTIC-PROPERTIES and FACE-PROPERTIES if we're
623 ;; using cache VERSION format 3, the current buffer's file timestamp matches
624 ;; the TIMESTAMP, the current buffer's `font-lock-syntactic-keywords' are the
625 ;; same as SYNTACTIC-KEYWORDS, and the current buffer's `font-lock-keywords'
626 ;; are the same as KEYWORDS.
627 (let ((buf-timestamp (visited-file-modtime))
628 (verbose (if (numberp fast-lock-verbose)
629 (> (buffer-size) fast-lock-verbose)
630 fast-lock-verbose))
631 (loaded t))
632 (if (or (/= version 3)
633 (buffer-modified-p)
634 (not (equal timestamp buf-timestamp))
635 (not (equal syntactic-keywords font-lock-syntactic-keywords))
636 (not (equal keywords font-lock-keywords)))
637 (setq loaded nil)
638 (with-temp-message
639 (when verbose
640 (format "Loading %s font lock cache..." (buffer-name)))
641 (condition-case nil
642 (fast-lock-add-properties syntactic-properties face-properties)
643 (error (setq loaded 'error)) (quit (setq loaded 'quit))))
644 (cond ((eq loaded 'quit)
645 (message "Loading %s font lock cache...quit" (buffer-name)))
646 ((eq loaded 'error)
647 (message "Loading %s font lock cache...failed" (buffer-name)))))
648 (setq font-lock-fontified (eq loaded t)
649 fast-lock-cache-timestamp (and (eq loaded t) timestamp))))
650
651;; Text Properties Processing Functions:
652
653;; This is fast, but fails if adjacent characters have different `face' text
654;; properties. Maybe that's why I dropped it in the first place?
655;(defun fast-lock-get-face-properties ()
656; "Return a list of `face' text properties in the current buffer.
657;Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
658;where VALUE is a `face' property value and STARTx and ENDx are positions."
659; (save-restriction
660; (widen)
661; (let ((start (text-property-not-all (point-min) (point-max) 'face nil))
662; (limit (point-max)) end properties value cell)
663; (while start
664; (setq end (next-single-property-change start 'face nil limit)
665; value (get-text-property start 'face))
666; ;; Make, or add to existing, list of regions with same `face'.
667; (if (setq cell (assq value properties))
668; (setcdr cell (cons start (cons end (cdr cell))))
669; (setq properties (cons (list value start end) properties)))
670; (setq start (next-single-property-change end 'face)))
671; properties)))
672
673;; This is slow, but copes if adjacent characters have different `face' text
674;; properties, but fails if they are lists.
675;(defun fast-lock-get-face-properties ()
676; "Return a list of `face' text properties in the current buffer.
677;Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
678;where VALUE is a `face' property value and STARTx and ENDx are positions.
679;Only those `face' VALUEs in `fast-lock-save-faces' are returned."
680; (save-restriction
681; (widen)
682; (let ((faces (or fast-lock-save-faces (face-list))) (limit (point-max))
683; properties regions face start end)
684; (while faces
685; (setq face (car faces) faces (cdr faces) regions () end (point-min))
686; ;; Make a list of start/end regions with `face' property face.
687; (while (setq start (text-property-any end limit 'face face))
688; (setq end (or (text-property-not-all start limit 'face face) limit)
689; regions (cons start (cons end regions))))
690; ;; Add `face' face's regions, if any, to properties.
691; (when regions
692; (push (cons face regions) properties)))
693; properties)))
694
695(defun fast-lock-get-face-properties ()
696 "Return a list of `face' text properties in the current buffer.
697Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
698where VALUE is a `face' property value and STARTx and ENDx are positions."
699 (save-restriction
700 (widen)
701 (let ((start (text-property-not-all (point-min) (point-max) 'face nil))
702 end properties value cell)
703 (while start
704 (setq end (next-single-property-change start 'face nil (point-max))
705 value (get-text-property start 'face))
706 ;; Make, or add to existing, list of regions with same `face'.
707 (cond ((setq cell (assoc value properties))
708 (setcdr cell (cons start (cons end (cdr cell)))))
709 ((fast-lock-save-facep value)
710 (push (list value start end) properties)))
711 (setq start (text-property-not-all end (point-max) 'face nil)))
712 properties)))
713
714(defun fast-lock-get-syntactic-properties ()
715 "Return a list of `syntax-table' text properties in the current buffer.
716See `fast-lock-get-face-properties'."
717 (save-restriction
718 (widen)
719 (let ((start (text-property-not-all (point-min) (point-max) 'syntax-table
720 nil))
721 end properties value cell)
722 (while start
723 (setq end (next-single-property-change start 'syntax-table nil
724 (point-max))
725 value (get-text-property start 'syntax-table))
726 ;; Make, or add to existing, list of regions with same `syntax-table'.
727 (if (setq cell (assoc value properties))
728 (setcdr cell (cons start (cons end (cdr cell))))
729 (push (list value start end) properties))
730 (setq start (text-property-not-all end (point-max) 'syntax-table nil)))
731 properties)))
732
733(defun fast-lock-add-properties (syntactic-properties face-properties)
734 "Add `syntax-table' and `face' text properties to the current buffer.
735Any existing `syntax-table' and `face' text properties are removed first.
736See `fast-lock-get-face-properties'."
737 (save-buffer-state (plist regions)
738 (save-restriction
739 (widen)
740 (font-lock-unfontify-region (point-min) (point-max))
741 ;;
742 ;; Set the `syntax-table' property for each start/end region.
743 (while syntactic-properties
744 (setq plist (list 'syntax-table (car (car syntactic-properties)))
745 regions (cdr (car syntactic-properties))
746 syntactic-properties (cdr syntactic-properties))
747 (while regions
748 (add-text-properties (nth 0 regions) (nth 1 regions) plist)
749 (setq regions (nthcdr 2 regions))))
750 ;;
751 ;; Set the `face' property for each start/end region.
752 (while face-properties
753 (setq plist (list 'face (car (car face-properties)))
754 regions (cdr (car face-properties))
755 face-properties (cdr face-properties))
756 (while regions
757 (add-text-properties (nth 0 regions) (nth 1 regions) plist)
758 (setq regions (nthcdr 2 regions)))))))
759
760;; Functions for XEmacs:
761
762(when (save-match-data (string-match "XEmacs" (emacs-version)))
763 ;;
764 ;; It would be better to use XEmacs' `map-extents' over extents with a
765 ;; `font-lock' property, but `face' properties are on different extents.
766 (defun fast-lock-get-face-properties ()
767 "Return a list of `face' text properties in the current buffer.
768Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
769where VALUE is a `face' property value and STARTx and ENDx are positions.
770Only those `face' VALUEs in `fast-lock-save-faces' are returned."
771 (save-restriction
772 (widen)
773 (let ((properties ()) cell)
774 (map-extents
775 (function (lambda (extent ignore)
776 (let ((value (extent-face extent)))
777 ;; We're only interested if it's one of `fast-lock-save-faces'.
778 (when (and value (fast-lock-save-facep value))
779 (let ((start (extent-start-position extent))
780 (end (extent-end-position extent)))
781 ;; Make or add to existing list of regions with the same
782 ;; `face' property value.
783 (if (setq cell (assoc value properties))
784 (setcdr cell (cons start (cons end (cdr cell))))
785 (push (list value start end) properties))))
786 ;; Return nil to keep `map-extents' going.
787 nil))))
788 properties)))
789 ;;
790 ;; XEmacs does not support the `syntax-table' text property.
791 (defalias 'fast-lock-get-syntactic-properties
792 'ignore)
793 ;;
794 ;; Make extents just like XEmacs' font-lock.el does.
795 (defun fast-lock-add-properties (syntactic-properties face-properties)
796 "Set `face' text properties in the current buffer.
797Any existing `face' text properties are removed first.
798See `fast-lock-get-face-properties'."
799 (save-restriction
800 (widen)
801 (font-lock-unfontify-region (point-min) (point-max))
802 ;; Set the `face' property, etc., for each start/end region.
803 (while face-properties
804 (let ((face (car (car face-properties)))
805 (regions (cdr (car face-properties))))
806 (while regions
807 (font-lock-set-face (nth 0 regions) (nth 1 regions) face)
808 (setq regions (nthcdr 2 regions)))
809 (setq face-properties (cdr face-properties))))
810 ;; XEmacs does not support the `syntax-table' text property.
811 ))
812 ;;
813 ;; XEmacs 19.12 font-lock.el's `font-lock-fontify-buffer' runs a hook.
814 (add-hook 'font-lock-after-fontify-buffer-hook
815 'fast-lock-after-fontify-buffer))
816
817(unless (boundp 'font-lock-syntactic-keywords)
818 (defvar font-lock-syntactic-keywords nil))
819
820(unless (boundp 'font-lock-inhibit-thing-lock)
821 (defvar font-lock-inhibit-thing-lock nil))
822
823(unless (fboundp 'font-lock-compile-keywords)
824 (defalias 'font-lock-compile-keywords 'identity))
825
826(unless (fboundp 'font-lock-eval-keywords)
827 (defun font-lock-eval-keywords (keywords)
828 (if (symbolp keywords)
829 (font-lock-eval-keywords (if (fboundp keywords)
830 (funcall keywords)
831 (eval keywords)))
832 keywords)))
833
834(unless (fboundp 'font-lock-value-in-major-mode)
835 (defun font-lock-value-in-major-mode (alist)
836 (if (consp alist)
837 (cdr (or (assq major-mode alist) (assq t alist)))
838 alist)))
839
840(unless (fboundp 'current-message)
841 (defun current-message ()
842 ""))
843
844;; Install ourselves:
845
846(add-hook 'after-save-hook 'fast-lock-save-cache-after-save-file)
847(add-hook 'kill-buffer-hook 'fast-lock-save-cache-before-kill-buffer)
848(add-hook 'kill-emacs-hook 'fast-lock-save-caches-before-kill-emacs)
849
850;;;###autoload
851(when (fboundp 'add-minor-mode)
852 (defvar fast-lock-mode nil)
853 (add-minor-mode 'fast-lock-mode nil))
854;;;###dont-autoload
855(unless (assq 'fast-lock-mode minor-mode-alist)
856 (setq minor-mode-alist (append minor-mode-alist '((fast-lock-mode nil)))))
857
858;; Provide ourselves:
859
860(provide 'fast-lock)
861
862;;; arch-tag: 638c431e-8cae-4538-80a1-963ff97d233e
863;;; fast-lock.el ends here
diff --git a/lisp/lazy-lock.el b/lisp/lazy-lock.el
deleted file mode 100644
index 3547674bf36..00000000000
--- a/lisp/lazy-lock.el
+++ /dev/null
@@ -1,1054 +0,0 @@
1;;; lazy-lock.el --- lazy demand-driven fontification for fast Font Lock mode
2
3;; Copyright (C) 1994, 1995, 1996, 1997, 1998, 2001
4;; Free Software Foundation, Inc.
5
6;; Author: Simon Marshall <simon@gnu.org>
7;; Maintainer: FSF
8;; Keywords: faces files
9;; Version: 2.11
10
11;; This file is part of GNU Emacs.
12
13;; GNU Emacs is free software; you can redistribute it and/or modify
14;; it under the terms of the GNU General Public License as published by
15;; the Free Software Foundation; either version 2, or (at your option)
16;; any later version.
17
18;; GNU Emacs is distributed in the hope that it will be useful,
19;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21;; GNU General Public License for more details.
22
23;; You should have received a copy of the GNU General Public License
24;; along with GNU Emacs; see the file COPYING. If not, write to the
25;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
26;; Boston, MA 02111-1307, USA.
27
28;;; Commentary:
29
30;; Purpose:
31;;
32;; Lazy Lock mode is a Font Lock support mode.
33;; It makes visiting buffers in Font Lock mode faster by making fontification
34;; be demand-driven, deferred and stealthy, so that fontification only occurs
35;; when, and where, necessary.
36;;
37;; See caveats and feedback below.
38;; See also the fast-lock package. (But don't use them at the same time!)
39
40;; Installation:
41;;
42;; Put in your ~/.emacs:
43;;
44;; (setq font-lock-support-mode 'lazy-lock-mode)
45;;
46;; Start up a new Emacs and use font-lock as usual (except that you can use the
47;; so-called "gaudier" fontification regexps on big files without frustration).
48;;
49;; In a buffer (which has `font-lock-mode' enabled) which is at least
50;; `lazy-lock-minimum-size' characters long, buffer fontification will not
51;; occur and only the visible portion of the buffer will be fontified. Motion
52;; around the buffer will fontify those visible portions not previously
53;; fontified. If stealth fontification is enabled, buffer fontification will
54;; occur in invisible parts of the buffer after `lazy-lock-stealth-time'
55;; seconds of idle time. If on-the-fly fontification is deferred, on-the-fly
56;; fontification will occur after `lazy-lock-defer-time' seconds of idle time.
57
58;; User-visible differences with version 1:
59;;
60;; - Version 2 can defer on-the-fly fontification. Therefore you need not, and
61;; should not, use defer-lock.el with this version of lazy-lock.el.
62;;
63;; A number of variables have changed meaning:
64;;
65;; - A value of nil for the variable `lazy-lock-minimum-size' means never turn
66;; on demand-driven fontification. In version 1 this meant always turn on
67;; demand-driven fontification. If you really want demand-driven fontification
68;; regardless of buffer size, set this variable to 0.
69;;
70;; - The variable `lazy-lock-stealth-lines' cannot have a nil value. In
71;; version 1 this meant use `window-height' as the maximum number of lines to
72;; fontify as a stealth chunk. This makes no sense; stealth fontification is
73;; of a buffer, not a window.
74
75;; Implementation differences with version 1:
76;;
77;; - Version 1 of lazy-lock.el is a bit of a hack. Version 1 demand-driven
78;; fontification, the core feature of lazy-lock.el, is implemented by placing a
79;; function on `post-command-hook'. This function fontifies where necessary,
80;; i.e., where a window scroll has occurred. However, there are a number of
81;; problems with using `post-command-hook':
82;;
83;; (a) As the name suggests, `post-command-hook' is run after every command,
84;; i.e., frequently and regardless of whether scrolling has occurred.
85;; (b) Scrolling can occur during a command, when `post-command-hook' is not
86;; run, i.e., it is not necessarily run after scrolling has occurred.
87;; (c) When `post-command-hook' is run, there is nothing to suggest where
88;; scrolling might have occurred, i.e., which windows have scrolled.
89;;
90;; Thus lazy-lock.el's function is called almost as often as possible, usually
91;; when it need not be called, yet it is not always called when it is needed.
92;; Also, lazy-lock.el's function must check each window to see if a scroll has
93;; occurred there. Worse still, lazy-lock.el's function must fontify a region
94;; twice as large as necessary to make sure the window is completely fontified.
95;; Basically, `post-command-hook' is completely inappropriate for lazy-lock.el.
96;;
97;; Ideally, we want to attach lazy-lock.el's function to a hook that is run
98;; only when scrolling occurs, e.g., `window-start' has changed, and tells us
99;; as much information as we need, i.e., the window and its new buffer region.
100;; Richard Stallman implemented a `window-scroll-functions' for Emacs 19.30.
101;; Functions on it are run when `window-start' has changed, and are supplied
102;; with the window and the window's new `window-start' position. (It would be
103;; better if it also supplied the window's new `window-end' position, but that
104;; is calculated as part of the redisplay process, and the functions on
105;; `window-scroll-functions' are run before redisplay has finished.) Thus, the
106;; hook deals with the above problems (a), (b) and (c).
107;;
108;; If only life was that easy. Version 2 demand-driven fontification is mostly
109;; implemented by placing a function on `window-scroll-functions'. However,
110;; not all scrolling occurs when `window-start' has changed. A change in
111;; window size, e.g., via C-x 1, or a significant deletion, e.g., of a number
112;; of lines, causes text previously invisible (i.e., after `window-end') to
113;; become visible without changing `window-start'. Arguably, these events are
114;; not scrolling events, but fontification must occur for lazy-lock.el to work.
115;; Hooks `window-size-change-functions' and `redisplay-end-trigger-functions'
116;; were added for these circumstances.
117;;
118;; (Ben Wing thinks these hooks are "horribly horribly kludgy", and implemented
119;; a `pre-idle-hook', a `mother-of-all-post-command-hooks', for XEmacs 19.14.
120;; He then hacked up a version 1 lazy-lock.el to use `pre-idle-hook' rather
121;; than `post-command-hook'. Whereas functions on `post-command-hook' are
122;; called almost as often as possible, functions on `pre-idle-hook' really are
123;; called as often as possible, even when the mouse moves and, on some systems,
124;; while XEmacs is idle. Thus, the hook deals with the above problem (b), but
125;; unfortunately it makes (a) worse and does not address (c) at all.
126;;
127;; I freely admit that `redisplay-end-trigger-functions' and, to a much lesser
128;; extent, `window-size-change-functions' are not pretty. However, I feel that
129;; a `window-scroll-functions' feature is cleaner than a `pre-idle-hook', and
130;; the result is faster and smaller, less intrusive and more targeted, code.
131;; Since `pre-idle-hook' is pretty much like `post-command-hook', there is no
132;; point in making this version of lazy-lock.el work with it. Anyway, that's
133;; Lit 30 of my humble opinion.
134;;
135;; - Version 1 stealth fontification is also implemented by placing a function
136;; on `post-command-hook'. This function waits for a given amount of time,
137;; and, if Emacs remains idle, fontifies where necessary. Again, there are a
138;; number of problems with using `post-command-hook':
139;;
140;; (a) Functions on `post-command-hook' are run sequentially, so this function
141;; can interfere with other functions on the hook, and vice versa.
142;; (b) This function waits for a given amount of time, so it can interfere with
143;; various features that are dealt with by Emacs after a command, e.g.,
144;; region highlighting, asynchronous updating and keystroke echoing.
145;; (c) Fontification may be required during a command, when `post-command-hook'
146;; is not run. (Version 2 deferred fontification only.)
147;;
148;; Again, `post-command-hook' is completely inappropriate for lazy-lock.el.
149;; Richard Stallman and Morten Welinder implemented internal Timers and Idle
150;; Timers for Emacs 19.31. Functions can be run independently at given times
151;; or after given amounts of idle time. Thus, the feature deals with the above
152;; problems (a), (b) and (c). Version 2 deferral and stealth are implemented
153;; by functions on Idle Timers. (A function on XEmacs' `pre-idle-hook' is
154;; similar to an Emacs Idle Timer function with a fixed zero second timeout.)
155
156;; - Version 1 has the following problems (relative to version 2):
157;;
158;; (a) It is slow when it does its job.
159;; (b) It does not always do its job when it should.
160;; (c) It slows all interaction (when it doesn't need to do its job).
161;; (d) It interferes with other package functions on `post-command-hook'.
162;; (e) It interferes with Emacs things within the read-eval loop.
163;;
164;; Ben's hacked-up lazy-lock.el 1.14 almost solved (b) but made (c) worse.
165;;
166;; - Version 2 has the following additional features (relative to version 1):
167;;
168;; (a) It can defer fontification (both on-the-fly and on-scrolling).
169;; (b) It can fontify contextually (syntactically true on-the-fly).
170
171;; Caveats:
172;;
173;; Lazy Lock mode does not work efficiently with Outline mode.
174;; This is because when in Outline mode, although text may be not visible to
175;; you in the window, the text is visible to Emacs Lisp code (not surprisingly)
176;; and Lazy Lock fontifies it mercilessly. Maybe it will be fixed one day.
177;;
178;; Because buffer text is not necessarily fontified, other packages that expect
179;; buffer text to be fontified in Font Lock mode either might not work as
180;; expected, or might not display buffer text as expected. An example of the
181;; latter is `occur', which copies lines of buffer text into another buffer.
182;;
183;; In Emacs 19.30, Lazy Lock mode does not ensure that an existing buffer is
184;; fontified if it is made visible via a minibuffer-less command that replaces
185;; an existing window's buffer (e.g., via the Buffers menu). Upgrade!
186;;
187;; In Emacs 19.30, Lazy Lock mode does not work well with Transient Mark mode
188;; or modes based on Comint mode (e.g., Shell mode), and also interferes with
189;; the echoing of keystrokes in the minibuffer. This is because of the way
190;; deferral and stealth have to be implemented for Emacs 19.30. Upgrade!
191;;
192;; Currently XEmacs does not have the features to support this version of
193;; lazy-lock.el. Maybe it will one day.
194
195;; History:
196;;
197;; 1.15--2.00:
198;; - Rewrite for Emacs 19.30 and the features rms added to support lazy-lock.el
199;; so that it could work correctly and efficiently.
200;; - Many thanks to those who reported bugs, fixed bugs, made suggestions or
201;; otherwise contributed in the version 1 cycle; Jari Aalto, Kevin Broadey,
202;; Ulrik Dickow, Bill Dubuque, Bob Glickstein, Boris Goldowsky,
203;; Jonas Jarnestrom, David Karr, Michael Kifer, Erik Naggum, Rick Sladkey,
204;; Jim Thompson, Ben Wing, Ilya Zakharevich, and Richard Stallman.
205;; 2.00--2.01:
206;; - Made `lazy-lock-fontify-after-command' always `sit-for' and so redisplay
207;; - Use `buffer-name' not `buffer-live-p' (Bill Dubuque hint)
208;; - Made `lazy-lock-install' do `add-to-list' not `setq' of `current-buffer'
209;; - Made `lazy-lock-fontify-after-install' loop over buffer list
210;; - Made `lazy-lock-arrange-before-change' to arrange `window-end' triggering
211;; - Made `lazy-lock-let-buffer-state' wrap both `befter-change-functions'
212;; - Made `lazy-lock-fontify-region' do `condition-case' (Hyman Rosen report)
213;; 2.01--2.02:
214;; - Use `buffer-live-p' as `buffer-name' can barf (Richard Stanton report)
215;; - Made `lazy-lock-install' set `font-lock-fontified' (Kevin Davidson report)
216;; - Made `lazy-lock-install' add hooks only if needed
217;; - Made `lazy-lock-unstall' add `font-lock-after-change-function' if needed
218;; 2.02--2.03:
219;; - Made `lazy-lock-fontify-region' do `condition-case' for `quit' too
220;; - Made `lazy-lock-mode' respect the value of `font-lock-inhibit-thing-lock'
221;; - Added `lazy-lock-after-unfontify-buffer'
222;; - Removed `lazy-lock-fontify-after-install' hack
223;; - Made `lazy-lock-fontify-after-scroll' not `set-buffer' to `window-buffer'
224;; - Made `lazy-lock-fontify-after-trigger' not `set-buffer' to `window-buffer'
225;; - Made `lazy-lock-fontify-after-idle' be interruptible (Scott Burson hint)
226;; 2.03--2.04:
227;; - Rewrite for Emacs 19.31 idle timers
228;; - Renamed `buffer-windows' to `get-buffer-window-list'
229;; - Removed `buffer-live-p'
230;; - Made `lazy-lock-defer-after-change' always save `current-buffer'
231;; - Made `lazy-lock-fontify-after-defer' just process buffers
232;; - Made `lazy-lock-install-hooks' add hooks correctly (Kevin Broadey report)
233;; - Made `lazy-lock-install' cope if `lazy-lock-defer-time' is a list
234;; 2.04--2.05:
235;; - Rewrite for Common Lisp macros
236;; - Added `do-while' macro
237;; - Renamed `lazy-lock-let-buffer-state' macro to `save-buffer-state'
238;; - Returned `lazy-lock-fontify-after-install' hack (Darren Hall hint)
239;; - Added `lazy-lock-defer-on-scrolling' functionality (Scott Byer hint)
240;; - Made `lazy-lock-mode' wrap `font-lock-support-mode'
241;; 2.05--2.06:
242;; - Made `lazy-lock-fontify-after-defer' swap correctly (Scott Byer report)
243;; 2.06--2.07:
244;; - Added `lazy-lock-stealth-load' functionality (Rob Hooft hint)
245;; - Made `lazy-lock-unstall' call `lazy-lock-fontify-region' if needed
246;; - Made `lazy-lock-mode' call `lazy-lock-unstall' only if needed
247;; - Made `lazy-lock-defer-after-scroll' do `set-window-redisplay-end-trigger'
248;; - Added `lazy-lock-defer-contextually' functionality
249;; - Added `lazy-lock-defer-on-the-fly' from `lazy-lock-defer-time'
250;; - Renamed `lazy-lock-defer-driven' to `lazy-lock-defer-on-scrolling'
251;; - Removed `lazy-lock-submit-bug-report' and bade farewell
252;; 2.07--2.08:
253;; - Made `lazy-lock-fontify-conservatively' fontify around `window-point'
254;; - Made `save-buffer-state' wrap `inhibit-point-motion-hooks'
255;; - Added Custom support
256;; 2.08--2.09:
257;; - Removed `byte-*' variables from `eval-when-compile' (Erik Naggum hint)
258;; - Made various wrapping `inhibit-point-motion-hooks' (Vinicius Latorre hint)
259;; - Made `lazy-lock-fontify-after-idle' wrap `minibuffer-auto-raise'
260;; - Made `lazy-lock-fontify-after-defer' paranoid about deferred buffers
261;; 2.09--2.10:
262;; - Use `window-end' UPDATE arg for Emacs 20.4 and later.
263;; - Made deferral `widen' before unfontifying (Dan Nicolaescu report)
264;; - Use `lazy-lock-fontify-after-visage' for hideshow.el (Dan Nicolaescu hint)
265;; - Use `other' widget where possible (Andreas Schwab fix)
266;; 2.10--2.11:
267;; - Used `with-temp-message' where possible to make messages temporary.
268
269;;; Code:
270
271(require 'font-lock)
272
273(eval-when-compile
274 ;; We don't do this at the top-level as we only use non-autoloaded macros.
275 (require 'cl)
276 ;;
277 ;; We use this to preserve or protect things when modifying text properties.
278 (defmacro save-buffer-state (varlist &rest body)
279 "Bind variables according to VARLIST and eval BODY restoring buffer state."
280 `(let* (,@(append varlist
281 '((modified (buffer-modified-p))
282 (buffer-undo-list t)
283 (inhibit-read-only t)
284 (inhibit-point-motion-hooks t)
285 (inhibit-modification-hooks t)
286 deactivate-mark
287 buffer-file-name
288 buffer-file-truename)))
289 ,@body
290 (when (and (not modified) (buffer-modified-p))
291 (restore-buffer-modified-p nil))))
292 (put 'save-buffer-state 'lisp-indent-function 1)
293 ;;
294 ;; We use this for clarity and speed. Naughty but nice.
295 (defmacro do-while (test &rest body)
296 "(do-while TEST BODY...): eval BODY... and repeat if TEST yields non-nil.
297The order of execution is thus BODY, TEST, BODY, TEST and so on
298until TEST returns nil."
299 `(while (progn ,@body ,test)))
300 (put 'do-while 'lisp-indent-function (get 'while 'lisp-indent-function)))
301
302(defvar lazy-lock-mode nil) ; Whether we are turned on.
303(defvar lazy-lock-buffers nil) ; For deferral.
304(defvar lazy-lock-timers (cons nil nil)) ; For deferral and stealth.
305
306;; User Variables:
307
308(defcustom lazy-lock-minimum-size 25600
309 "*Minimum size of a buffer for demand-driven fontification.
310On-demand fontification occurs if the buffer size is greater than this value.
311If nil, means demand-driven fontification is never performed.
312If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
313where MAJOR-MODE is a symbol or t (meaning the default). For example:
314 ((c-mode . 25600) (c++-mode . 25600) (rmail-mode . 1048576))
315means that the minimum size is 25K for buffers in C or C++ modes, one megabyte
316for buffers in Rmail mode, and size is irrelevant otherwise.
317
318The value of this variable is used when Lazy Lock mode is turned on."
319 :type '(choice (const :tag "none" nil)
320 (integer :tag "size")
321 (repeat :menu-tag "mode specific" :tag "mode specific"
322 :value ((t . nil))
323 (cons :tag "Instance"
324 (radio :tag "Mode"
325 (const :tag "all" t)
326 (symbol :tag "name"))
327 (radio :tag "Size"
328 (const :tag "none" nil)
329 (integer :tag "size")))))
330 :group 'lazy-lock)
331
332(defcustom lazy-lock-defer-on-the-fly t
333 "*If non-nil, means fontification after a change should be deferred.
334If nil, means on-the-fly fontification is performed. This means when changes
335occur in the buffer, those areas are immediately fontified.
336If a list, it should be a list of `major-mode' symbol names for which deferred
337fontification should occur. The sense of the list is negated if it begins with
338`not'. For example:
339 (c-mode c++-mode)
340means that on-the-fly fontification is deferred for buffers in C and C++ modes
341only, and deferral does not occur otherwise.
342
343The value of this variable is used when Lazy Lock mode is turned on."
344 :type '(choice (const :tag "never" nil)
345 (const :tag "always" t)
346 (set :menu-tag "mode specific" :tag "modes"
347 :value (not)
348 (const :tag "Except" not)
349 (repeat :inline t (symbol :tag "mode"))))
350 :group 'lazy-lock)
351
352(defcustom lazy-lock-defer-on-scrolling nil
353 "*If non-nil, means fontification after a scroll should be deferred.
354If nil, means demand-driven fontification is performed. This means when
355scrolling into unfontified areas of the buffer, those areas are immediately
356fontified. Thus scrolling never presents unfontified areas. However, since
357fontification occurs during scrolling, scrolling may be slow.
358If t, means defer-driven fontification is performed. This means fontification
359of those areas is deferred. Thus scrolling may present momentarily unfontified
360areas. However, since fontification does not occur during scrolling, scrolling
361will be faster than demand-driven fontification.
362If any other value, e.g., `eventually', means demand-driven fontification is
363performed until the buffer is fontified, then buffer fontification becomes
364defer-driven. Thus scrolling never presents unfontified areas until the buffer
365is first fontified, after which subsequent scrolling may present future buffer
366insertions momentarily unfontified. However, since fontification does not
367occur during scrolling after the buffer is first fontified, scrolling will
368become faster. (But, since contextual changes continually occur, such a value
369makes little sense if `lazy-lock-defer-contextually' is non-nil.)
370
371The value of this variable is used when Lazy Lock mode is turned on."
372 :type '(choice (const :tag "never" nil)
373 (const :tag "always" t)
374 (other :tag "eventually" eventually))
375 :group 'lazy-lock)
376
377(defcustom lazy-lock-defer-contextually 'syntax-driven
378 "*If non-nil, means deferred fontification should be syntactically true.
379If nil, means deferred fontification occurs only on those lines modified. This
380means where modification on a line causes syntactic change on subsequent lines,
381those subsequent lines are not refontified to reflect their new context.
382If t, means deferred fontification occurs on those lines modified and all
383subsequent lines. This means those subsequent lines are refontified to reflect
384their new syntactic context, either immediately or when scrolling into them.
385If any other value, e.g., `syntax-driven', means deferred syntactically true
386fontification occurs only if syntactic fontification is performed using the
387buffer mode's syntax table, i.e., only if `font-lock-keywords-only' is nil.
388
389The value of this variable is used when Lazy Lock mode is turned on."
390 :type '(choice (const :tag "never" nil)
391 (const :tag "always" t)
392 (other :tag "syntax-driven" syntax-driven))
393 :group 'lazy-lock)
394
395(defcustom lazy-lock-defer-time
396 (if (featurep 'lisp-float-type) (/ (float 1) (float 4)) 1)
397 "*Time in seconds to delay before beginning deferred fontification.
398Deferred fontification occurs if there is no input within this time.
399If nil, means fontification is never deferred, regardless of the values of the
400variables `lazy-lock-defer-on-the-fly', `lazy-lock-defer-on-scrolling' and
401`lazy-lock-defer-contextually'.
402
403The value of this variable is used when Lazy Lock mode is turned on."
404 :type '(choice (const :tag "never" nil)
405 (number :tag "seconds"))
406 :group 'lazy-lock)
407
408(defcustom lazy-lock-stealth-time 30
409 "*Time in seconds to delay before beginning stealth fontification.
410Stealth fontification occurs if there is no input within this time.
411If nil, means stealth fontification is never performed.
412
413The value of this variable is used when Lazy Lock mode is turned on."
414 :type '(choice (const :tag "never" nil)
415 (number :tag "seconds"))
416 :group 'lazy-lock)
417
418(defcustom lazy-lock-stealth-lines (if font-lock-maximum-decoration 100 250)
419 "*Maximum size of a chunk of stealth fontification.
420Each iteration of stealth fontification can fontify this number of lines.
421To speed up input response during stealth fontification, at the cost of stealth
422taking longer to fontify, you could reduce the value of this variable."
423 :type '(integer :tag "lines")
424 :group 'lazy-lock)
425
426(defcustom lazy-lock-stealth-load
427 (if (condition-case nil (load-average) (error)) 200)
428 "*Load in percentage above which stealth fontification is suspended.
429Stealth fontification pauses when the system short-term load average (as
430returned by the function `load-average' if supported) goes above this level,
431thus reducing the demand that stealth fontification makes on the system.
432If nil, means stealth fontification is never suspended.
433To reduce machine load during stealth fontification, at the cost of stealth
434taking longer to fontify, you could reduce the value of this variable.
435See also `lazy-lock-stealth-nice'."
436 :type (if (condition-case nil (load-average) (error))
437 '(choice (const :tag "never" nil)
438 (integer :tag "load"))
439 '(const :format "%t: unsupported\n" nil))
440 :group 'lazy-lock)
441
442(defcustom lazy-lock-stealth-nice
443 (if (featurep 'lisp-float-type) (/ (float 1) (float 8)) 1)
444 "*Time in seconds to pause between chunks of stealth fontification.
445Each iteration of stealth fontification is separated by this amount of time,
446thus reducing the demand that stealth fontification makes on the system.
447If nil, means stealth fontification is never paused.
448To reduce machine load during stealth fontification, at the cost of stealth
449taking longer to fontify, you could increase the value of this variable.
450See also `lazy-lock-stealth-load'."
451 :type '(choice (const :tag "never" nil)
452 (number :tag "seconds"))
453 :group 'lazy-lock)
454
455(defcustom lazy-lock-stealth-verbose
456 (if (featurep 'lisp-float-type)
457 (and (not lazy-lock-defer-contextually) (not (null font-lock-verbose))))
458 "*If non-nil, means stealth fontification should show status messages."
459 :type 'boolean
460 :group 'lazy-lock)
461
462;; User Functions:
463
464;;;###autoload
465(defun lazy-lock-mode (&optional arg)
466 "Toggle Lazy Lock mode.
467With arg, turn Lazy Lock mode on if and only if arg is positive. Enable it
468automatically in your `~/.emacs' by:
469
470 (setq font-lock-support-mode 'lazy-lock-mode)
471
472For a newer font-lock support mode with similar functionality, see
473`jit-lock-mode'. Eventually, Lazy Lock mode will be deprecated in
474JIT Lock's favor.
475
476When Lazy Lock mode is enabled, fontification can be lazy in a number of ways:
477
478- Demand-driven buffer fontification if `lazy-lock-minimum-size' is non-nil.
479 This means initial fontification does not occur if the buffer is greater than
480 `lazy-lock-minimum-size' characters in length. Instead, fontification occurs
481 when necessary, such as when scrolling through the buffer would otherwise
482 reveal unfontified areas. This is useful if buffer fontification is too slow
483 for large buffers.
484
485- Deferred scroll fontification if `lazy-lock-defer-on-scrolling' is non-nil.
486 This means demand-driven fontification does not occur as you scroll.
487 Instead, fontification is deferred until after `lazy-lock-defer-time' seconds
488 of Emacs idle time, while Emacs remains idle. This is useful if
489 fontification is too slow to keep up with scrolling.
490
491- Deferred on-the-fly fontification if `lazy-lock-defer-on-the-fly' is non-nil.
492 This means on-the-fly fontification does not occur as you type. Instead,
493 fontification is deferred until after `lazy-lock-defer-time' seconds of Emacs
494 idle time, while Emacs remains idle. This is useful if fontification is too
495 slow to keep up with your typing.
496
497- Deferred context fontification if `lazy-lock-defer-contextually' is non-nil.
498 This means fontification updates the buffer corresponding to true syntactic
499 context, after `lazy-lock-defer-time' seconds of Emacs idle time, while Emacs
500 remains idle. Otherwise, fontification occurs on modified lines only, and
501 subsequent lines can remain fontified corresponding to previous syntactic
502 contexts. This is useful where strings or comments span lines.
503
504- Stealthy buffer fontification if `lazy-lock-stealth-time' is non-nil.
505 This means remaining unfontified areas of buffers are fontified if Emacs has
506 been idle for `lazy-lock-stealth-time' seconds, while Emacs remains idle.
507 This is useful if any buffer has any deferred fontification.
508
509Basic Font Lock mode on-the-fly fontification behaviour fontifies modified
510lines only. Thus, if `lazy-lock-defer-contextually' is non-nil, Lazy Lock mode
511on-the-fly fontification may fontify differently, albeit correctly. In any
512event, to refontify some lines you can use \\[font-lock-fontify-block].
513
514Stealth fontification only occurs while the system remains unloaded.
515If the system load rises above `lazy-lock-stealth-load' percent, stealth
516fontification is suspended. Stealth fontification intensity is controlled via
517the variable `lazy-lock-stealth-nice' and `lazy-lock-stealth-lines', and
518verbosity is controlled via the variable `lazy-lock-stealth-verbose'."
519 (interactive "P")
520 (let* ((was-on lazy-lock-mode)
521 (now-on (unless (memq 'lazy-lock-mode font-lock-inhibit-thing-lock)
522 (if arg (> (prefix-numeric-value arg) 0) (not was-on)))))
523 (cond ((and now-on (not font-lock-mode))
524 ;; Turned on `lazy-lock-mode' rather than `font-lock-mode'.
525 (let ((font-lock-support-mode 'lazy-lock-mode))
526 (font-lock-mode t)))
527 (now-on
528 ;; Turn ourselves on.
529 (set (make-local-variable 'lazy-lock-mode) t)
530 (lazy-lock-install))
531 (was-on
532 ;; Turn ourselves off.
533 (set (make-local-variable 'lazy-lock-mode) nil)
534 (lazy-lock-unstall)))))
535
536;;;###autoload
537(defun turn-on-lazy-lock ()
538 "Unconditionally turn on Lazy Lock mode."
539 (lazy-lock-mode t))
540
541(defun lazy-lock-install ()
542 (let ((min-size (font-lock-value-in-major-mode lazy-lock-minimum-size))
543 (defer-change (and lazy-lock-defer-time lazy-lock-defer-on-the-fly))
544 (defer-scroll (and lazy-lock-defer-time lazy-lock-defer-on-scrolling))
545 (defer-context (and lazy-lock-defer-time lazy-lock-defer-contextually
546 (or (eq lazy-lock-defer-contextually t)
547 (null font-lock-keywords-only)))))
548 ;;
549 ;; Tell Font Lock whether Lazy Lock will do fontification.
550 (make-local-variable 'font-lock-fontified)
551 (setq font-lock-fontified (and min-size (>= (buffer-size) min-size)))
552 ;;
553 ;; Add the text properties and fontify.
554 (if (not font-lock-fontified)
555 (lazy-lock-after-fontify-buffer)
556 ;; Make sure we fontify in any existing windows showing the buffer.
557 (let ((windows (get-buffer-window-list (current-buffer) 'nomini t)))
558 (lazy-lock-after-unfontify-buffer)
559 (while windows
560 (lazy-lock-fontify-conservatively (car windows))
561 (setq windows (cdr windows)))))
562 ;;
563 ;; Add the fontification hooks.
564 (lazy-lock-install-hooks
565 font-lock-fontified
566 (cond ((eq (car-safe defer-change) 'not)
567 (not (memq major-mode (cdr defer-change))))
568 ((listp defer-change)
569 (memq major-mode defer-change))
570 (t
571 defer-change))
572 (eq defer-scroll t)
573 defer-context)
574 ;;
575 ;; Add the fontification timers.
576 (lazy-lock-install-timers
577 (if (or defer-change defer-scroll defer-context) lazy-lock-defer-time)
578 lazy-lock-stealth-time)))
579
580(defun lazy-lock-install-hooks (fontifying
581 defer-change defer-scroll defer-context)
582 ;;
583 ;; Add hook if lazy-lock.el is fontifying on scrolling or is deferring.
584 (when (or fontifying defer-change defer-scroll defer-context)
585 (add-hook 'window-scroll-functions (if defer-scroll
586 'lazy-lock-defer-after-scroll
587 'lazy-lock-fontify-after-scroll)
588 nil t))
589 ;;
590 ;; Add hook if lazy-lock.el is fontifying and is not deferring changes.
591 (when (and fontifying (not defer-change) (not defer-context))
592 (add-hook 'before-change-functions 'lazy-lock-arrange-before-change nil t))
593 ;;
594 ;; Replace Font Lock mode hook.
595 (remove-hook 'after-change-functions 'font-lock-after-change-function t)
596 (add-hook 'after-change-functions
597 (cond ((and defer-change defer-context)
598 'lazy-lock-defer-rest-after-change)
599 (defer-change
600 'lazy-lock-defer-line-after-change)
601 (defer-context
602 'lazy-lock-fontify-rest-after-change)
603 (t
604 'lazy-lock-fontify-line-after-change))
605 nil t)
606 ;;
607 ;; Add package-specific hook.
608 (add-hook 'outline-view-change-hook 'lazy-lock-fontify-after-visage nil t)
609 (add-hook 'hs-hide-hook 'lazy-lock-fontify-after-visage nil t))
610
611(defun lazy-lock-install-timers (dtime stime)
612 ;; Schedule or re-schedule the deferral and stealth timers.
613 ;; The layout of `lazy-lock-timers' is:
614 ;; ((DEFER-TIME . DEFER-TIMER) (STEALTH-TIME . STEALTH-TIMER)
615 ;; If an idle timeout has changed, cancel the existing idle timer (if there
616 ;; is one) and schedule a new one (if the new idle timeout is non-nil).
617 (unless (eq dtime (car (car lazy-lock-timers)))
618 (let ((defer (car lazy-lock-timers)))
619 (when (cdr defer)
620 (cancel-timer (cdr defer)))
621 (setcar lazy-lock-timers (cons dtime (and dtime
622 (run-with-idle-timer dtime t 'lazy-lock-fontify-after-defer))))))
623 (unless (eq stime (car (cdr lazy-lock-timers)))
624 (let ((stealth (cdr lazy-lock-timers)))
625 (when (cdr stealth)
626 (cancel-timer (cdr stealth)))
627 (setcdr lazy-lock-timers (cons stime (and stime
628 (run-with-idle-timer stime t 'lazy-lock-fontify-after-idle)))))))
629
630(defun lazy-lock-unstall ()
631 ;;
632 ;; If Font Lock mode is still enabled, make sure that the buffer is
633 ;; fontified, and reinstall its hook. We must do this first.
634 (when font-lock-mode
635 (when (lazy-lock-unfontified-p)
636 (let ((verbose (if (numberp font-lock-verbose)
637 (> (buffer-size) font-lock-verbose)
638 font-lock-verbose)))
639 (with-temp-message
640 (when verbose
641 (format "Fontifying %s..." (buffer-name)))
642 ;; Make sure we fontify etc. in the whole buffer.
643 (save-restriction
644 (widen)
645 (lazy-lock-fontify-region (point-min) (point-max))))))
646 (add-hook 'after-change-functions 'font-lock-after-change-function nil t))
647 ;;
648 ;; Remove the text properties.
649 (lazy-lock-after-unfontify-buffer)
650 ;;
651 ;; Remove the fontification hooks.
652 (remove-hook 'window-scroll-functions 'lazy-lock-fontify-after-scroll t)
653 (remove-hook 'window-scroll-functions 'lazy-lock-defer-after-scroll t)
654 (remove-hook 'before-change-functions 'lazy-lock-arrange-before-change t)
655 (remove-hook 'after-change-functions 'lazy-lock-fontify-line-after-change t)
656 (remove-hook 'after-change-functions 'lazy-lock-fontify-rest-after-change t)
657 (remove-hook 'after-change-functions 'lazy-lock-defer-line-after-change t)
658 (remove-hook 'after-change-functions 'lazy-lock-defer-rest-after-change t)
659 (remove-hook 'outline-view-change-hook 'lazy-lock-fontify-after-visage t)
660 (remove-hook 'hs-hide-hook 'lazy-lock-fontify-after-visage t))
661
662;; Hook functions.
663
664;; Lazy Lock mode intervenes when (1) a previously invisible buffer region
665;; becomes visible, i.e., for demand- or defer-driven on-the-scroll
666;; fontification, (2) a buffer modification occurs, i.e., for defer-driven
667;; on-the-fly fontification, (3) Emacs becomes idle, i.e., for fontification of
668;; deferred fontification and stealth fontification, and (4) other special
669;; occasions.
670
671;; 1. There are three ways whereby this can happen.
672;;
673;; (a) Scrolling the window, either explicitly (e.g., `scroll-up') or
674;; implicitly (e.g., `search-forward'). Here, `window-start' changes.
675;; Fontification occurs by adding `lazy-lock-fontify-after-scroll' (for
676;; demand-driven fontification) or `lazy-lock-defer-after-scroll' (for
677;; defer-driven fontification) to the hook `window-scroll-functions'.
678
679(defun lazy-lock-fontify-after-scroll (window window-start)
680 ;; Called from `window-scroll-functions'.
681 ;; Fontify WINDOW from WINDOW-START following the scroll.
682 (let ((inhibit-point-motion-hooks t))
683 (lazy-lock-fontify-region window-start (window-end window t)))
684 ;; A prior deletion that did not cause scrolling, followed by a scroll, would
685 ;; result in an unnecessary trigger after this if we did not cancel it now.
686 (set-window-redisplay-end-trigger window nil))
687
688(defun lazy-lock-defer-after-scroll (window window-start)
689 ;; Called from `window-scroll-functions'.
690 ;; Defer fontification following the scroll. Save the current buffer so that
691 ;; we subsequently fontify in all windows showing the buffer.
692 (unless (memq (current-buffer) lazy-lock-buffers)
693 (push (current-buffer) lazy-lock-buffers))
694 ;; A prior deletion that did not cause scrolling, followed by a scroll, would
695 ;; result in an unnecessary trigger after this if we did not cancel it now.
696 (set-window-redisplay-end-trigger window nil))
697
698;; (b) Resizing the window, either explicitly (e.g., `enlarge-window') or
699;; implicitly (e.g., `delete-other-windows'). Here, `window-end' changes.
700;; Fontification occurs by adding `lazy-lock-fontify-after-resize' to the
701;; hook `window-size-change-functions'.
702
703(defun lazy-lock-fontify-after-resize (frame)
704 ;; Called from `window-size-change-functions'.
705 ;; Fontify windows in FRAME following the resize. We cannot use
706 ;; `window-start' or `window-end' so we fontify conservatively.
707 (save-excursion
708 (save-selected-window
709 (select-frame frame)
710 (walk-windows (function (lambda (window)
711 (set-buffer (window-buffer window))
712 (when lazy-lock-mode
713 (lazy-lock-fontify-conservatively window))
714 (set-window-redisplay-end-trigger window nil)))
715 'nomini frame))))
716
717;; (c) Deletion in the buffer. Here, a `window-end' marker can become visible.
718;; Fontification occurs by adding `lazy-lock-arrange-before-change' to
719;; `before-change-functions' and `lazy-lock-fontify-after-trigger' to the
720;; hook `redisplay-end-trigger-functions'. Before every deletion, the
721;; marker `window-redisplay-end-trigger' position is set to the soon-to-be
722;; changed `window-end' position. If the marker becomes visible,
723;; `lazy-lock-fontify-after-trigger' gets called. Ouch. Note that we only
724;; have to deal with this eventuality if there is no on-the-fly deferral.
725
726(defun lazy-lock-arrange-before-change (beg end)
727 ;; Called from `before-change-functions'.
728 ;; Arrange that if text becomes visible it will be fontified (if a deletion
729 ;; is pending, text might become visible at the bottom).
730 (unless (eq beg end)
731 (let ((windows (get-buffer-window-list (current-buffer) 'nomini t)) window)
732 (while windows
733 (setq window (car windows))
734 (unless (markerp (window-redisplay-end-trigger window))
735 (set-window-redisplay-end-trigger window (make-marker)))
736 (set-marker (window-redisplay-end-trigger window) (window-end window))
737 (setq windows (cdr windows))))))
738
739(defun lazy-lock-fontify-after-trigger (window trigger-point)
740 ;; Called from `redisplay-end-trigger-functions'.
741 ;; Fontify WINDOW from TRIGGER-POINT following the redisplay.
742 ;; We could probably just use `lazy-lock-fontify-after-scroll' without loss:
743 ;; (inline (lazy-lock-fontify-after-scroll window (window-start window)))
744 (let ((inhibit-point-motion-hooks t))
745 (lazy-lock-fontify-region trigger-point (window-end window t))))
746
747;; 2. Modified text must be marked as unfontified so it can be identified and
748;; fontified later when Emacs is idle. Deferral occurs by adding one of
749;; `lazy-lock-fontify-*-after-change' (for on-the-fly fontification) or
750;; `lazy-lock-defer-*-after-change' (for deferred fontification) to the
751;; hook `after-change-functions'.
752
753(defalias 'lazy-lock-fontify-line-after-change
754 ;; Called from `after-change-functions'.
755 ;; Fontify the current change.
756 'font-lock-after-change-function)
757
758(defun lazy-lock-fontify-rest-after-change (beg end old-len)
759 ;; Called from `after-change-functions'.
760 ;; Fontify the current change and defer fontification of the rest of the
761 ;; buffer. Save the current buffer so that we subsequently fontify in all
762 ;; windows showing the buffer.
763 (lazy-lock-fontify-line-after-change beg end old-len)
764 (save-buffer-state nil
765 (unless (memq (current-buffer) lazy-lock-buffers)
766 (push (current-buffer) lazy-lock-buffers))
767 (save-restriction
768 (widen)
769 (remove-text-properties end (point-max) '(lazy-lock nil)))))
770
771(defun lazy-lock-defer-line-after-change (beg end old-len)
772 ;; Called from `after-change-functions'.
773 ;; Defer fontification of the current change. Save the current buffer so
774 ;; that we subsequently fontify in all windows showing the buffer.
775 (save-buffer-state nil
776 (unless (memq (current-buffer) lazy-lock-buffers)
777 (push (current-buffer) lazy-lock-buffers))
778 (remove-text-properties (max (1- beg) (point-min))
779 (min (1+ end) (point-max))
780 '(lazy-lock nil))))
781
782(defun lazy-lock-defer-rest-after-change (beg end old-len)
783 ;; Called from `after-change-functions'.
784 ;; Defer fontification of the rest of the buffer. Save the current buffer so
785 ;; that we subsequently fontify in all windows showing the buffer.
786 (save-buffer-state nil
787 (unless (memq (current-buffer) lazy-lock-buffers)
788 (push (current-buffer) lazy-lock-buffers))
789 (save-restriction
790 (widen)
791 (remove-text-properties (max (1- beg) (point-min))
792 (point-max)
793 '(lazy-lock nil)))))
794
795;; 3. Deferred fontification and stealth fontification are done from these two
796;; functions. They are set up as Idle Timers.
797
798(defun lazy-lock-fontify-after-defer ()
799 ;; Called from `timer-idle-list'.
800 ;; Fontify all windows where deferral has occurred for its buffer.
801 (save-excursion
802 (while (and lazy-lock-buffers (not (input-pending-p)))
803 (let ((buffer (car lazy-lock-buffers)) windows)
804 ;; Paranoia: check that the buffer is still live and Lazy Lock mode on.
805 (when (buffer-live-p buffer)
806 (set-buffer buffer)
807 (when lazy-lock-mode
808 (setq windows (get-buffer-window-list buffer 'nomini t))
809 (while windows
810 (lazy-lock-fontify-window (car windows))
811 (setq windows (cdr windows)))))
812 (setq lazy-lock-buffers (cdr lazy-lock-buffers)))))
813 ;; Add hook if fontification should now be defer-driven in this buffer.
814 (when (and lazy-lock-mode lazy-lock-defer-on-scrolling
815 (memq 'lazy-lock-fontify-after-scroll window-scroll-functions)
816 (not (or (input-pending-p) (lazy-lock-unfontified-p))))
817 (remove-hook 'window-scroll-functions 'lazy-lock-fontify-after-scroll t)
818 (add-hook 'window-scroll-functions 'lazy-lock-defer-after-scroll nil t)))
819
820(defun lazy-lock-fontify-after-idle ()
821 ;; Called from `timer-idle-list'.
822 ;; Fontify all buffers that need it, stealthily while idle.
823 (unless (or executing-kbd-macro (window-minibuffer-p (selected-window)))
824 ;; Loop over all buffers, fontify stealthily for each if necessary.
825 (let ((buffers (buffer-list)) (continue t)
826 message message-log-max minibuffer-auto-raise)
827 (save-excursion
828 (do-while (and buffers continue)
829 (set-buffer (car buffers))
830 (if (not (and lazy-lock-mode (lazy-lock-unfontified-p)))
831 (setq continue (not (input-pending-p)))
832 ;; Fontify regions in this buffer while there is no input.
833 (with-temp-message
834 (when lazy-lock-stealth-verbose
835 "Fontifying stealthily...")
836 (do-while (and (lazy-lock-unfontified-p) continue)
837 (if (and lazy-lock-stealth-load
838 (> (car (load-average)) lazy-lock-stealth-load))
839 ;; Wait a while before continuing with the loop.
840 (progn
841 (when message
842 (message "Fontifying stealthily...suspended")
843 (setq message nil))
844 (setq continue (sit-for (or lazy-lock-stealth-time 30))))
845 ;; Fontify a chunk.
846 (when lazy-lock-stealth-verbose
847 (if message
848 (message "Fontifying stealthily... %2d%% of %s"
849 (lazy-lock-percent-fontified) (buffer-name))
850 (message "Fontifying stealthily...")
851 (setq message t)))
852 ;; Current buffer may have changed during `sit-for'.
853 (set-buffer (car buffers))
854 (lazy-lock-fontify-chunk)
855 (setq continue (sit-for (or lazy-lock-stealth-nice 0)))))))
856 (setq buffers (cdr buffers)))))))
857
858;; 4. Special circumstances.
859
860(defun lazy-lock-fontify-after-visage ()
861 ;; Called from `outline-view-change-hook' and `hs-hide-hook'.
862 ;; Fontify windows showing the current buffer, as its visibility has changed.
863 ;; This is a conspiracy hack between lazy-lock.el, outline.el and
864 ;; hideshow.el.
865 (let ((windows (get-buffer-window-list (current-buffer) 'nomini t)))
866 (while windows
867 (lazy-lock-fontify-conservatively (car windows))
868 (setq windows (cdr windows)))))
869
870(defun lazy-lock-after-fontify-buffer ()
871 ;; Called from `font-lock-after-fontify-buffer'.
872 ;; Mark the current buffer as fontified.
873 ;; This is a conspiracy hack between lazy-lock.el and font-lock.el.
874 (save-buffer-state nil
875 (add-text-properties (point-min) (point-max) '(lazy-lock t))))
876
877(defun lazy-lock-after-unfontify-buffer ()
878 ;; Called from `font-lock-after-unfontify-buffer'.
879 ;; Mark the current buffer as unfontified.
880 ;; This is a conspiracy hack between lazy-lock.el and font-lock.el.
881 (save-buffer-state nil
882 (remove-text-properties (point-min) (point-max) '(lazy-lock nil))))
883
884;; Fontification functions.
885
886;; If packages want to ensure that some region of the buffer is fontified, they
887;; should use this function. For an example, see ps-print.el.
888(defun lazy-lock-fontify-region (beg end)
889 ;; Fontify between BEG and END, where necessary, in the current buffer.
890 (save-restriction
891 (widen)
892 (when (setq beg (text-property-any beg end 'lazy-lock nil))
893 (save-excursion
894 (save-match-data
895 (save-buffer-state
896 ;; Ensure syntactic fontification is always correct.
897 (font-lock-beginning-of-syntax-function next)
898 ;; Find successive unfontified regions between BEG and END.
899 (condition-case data
900 (do-while beg
901 (setq next (or (text-property-any beg end 'lazy-lock t) end))
902 ;; Make sure the region end points are at beginning of line.
903 (goto-char beg)
904 (unless (bolp)
905 (beginning-of-line)
906 (setq beg (point)))
907 (goto-char next)
908 (unless (bolp)
909 (forward-line)
910 (setq next (point)))
911 ;; Fontify the region, then flag it as fontified.
912 (font-lock-fontify-region beg next)
913 (add-text-properties beg next '(lazy-lock t))
914 (setq beg (text-property-any next end 'lazy-lock nil)))
915 ((error quit) (message "Fontifying region...%s" data)))))))))
916
917(defun lazy-lock-fontify-chunk ()
918 ;; Fontify the nearest chunk, for stealth, in the current buffer.
919 (let ((inhibit-point-motion-hooks t))
920 (save-excursion
921 (save-restriction
922 (widen)
923 ;; Move to end of line in case the character at point is not fontified.
924 (end-of-line)
925 ;; Find where the previous (next) unfontified regions end (begin).
926 (let ((prev (previous-single-property-change (point) 'lazy-lock))
927 (next (text-property-any (point) (point-max) 'lazy-lock nil)))
928 ;; Fontify from the nearest unfontified position.
929 (if (or (null prev) (and next (< (- next (point)) (- (point) prev))))
930 ;; The next, or neither, region is the nearest not fontified.
931 (lazy-lock-fontify-region
932 (progn (goto-char (or next (point-min)))
933 (beginning-of-line)
934 (point))
935 (progn (goto-char (or next (point-min)))
936 (forward-line lazy-lock-stealth-lines)
937 (point)))
938 ;; The previous region is the nearest not fontified.
939 (lazy-lock-fontify-region
940 (progn (goto-char prev)
941 (forward-line (- lazy-lock-stealth-lines))
942 (point))
943 (progn (goto-char prev)
944 (forward-line)
945 (point)))))))))
946
947(defun lazy-lock-fontify-window (window)
948 ;; Fontify in WINDOW between `window-start' and `window-end'.
949 ;; We can only do this when we can use `window-start' and `window-end'.
950 (with-current-buffer (window-buffer window)
951 (lazy-lock-fontify-region (window-start window) (window-end window))))
952
953(defun lazy-lock-fontify-conservatively (window)
954 ;; Fontify in WINDOW conservatively around point.
955 ;; Where we cannot use `window-start' and `window-end' we do `window-height'
956 ;; lines around point. That way we guarantee to have done enough.
957 (with-current-buffer (window-buffer window)
958 (let ((inhibit-point-motion-hooks t))
959 (lazy-lock-fontify-region
960 (save-excursion
961 (goto-char (window-point window))
962 (vertical-motion (- (window-height window)) window) (point))
963 (save-excursion
964 (goto-char (window-point window))
965 (vertical-motion (window-height window) window) (point))))))
966
967(defun lazy-lock-unfontified-p ()
968 ;; Return non-nil if there is anywhere still to be fontified.
969 (save-restriction
970 (widen)
971 (text-property-any (point-min) (point-max) 'lazy-lock nil)))
972
973(defun lazy-lock-percent-fontified ()
974 ;; Return the percentage (of characters) of the buffer that are fontified.
975 (save-restriction
976 (widen)
977 (let ((beg (point-min)) (size 0) next)
978 ;; Find where the next fontified region begins.
979 (while (setq beg (text-property-any beg (point-max) 'lazy-lock t))
980 (setq next (or (text-property-any beg (point-max) 'lazy-lock nil)
981 (point-max)))
982 (incf size (- next beg))
983 (setq beg next))
984 ;; Float because using integer multiplication will frequently overflow.
985 (truncate (* (/ (float size) (point-max)) 100)))))
986
987;; Version dependent workarounds and fixes.
988
989(when (consp lazy-lock-defer-time)
990 ;;
991 ;; In 2.06.04 and below, `lazy-lock-defer-time' could specify modes and time.
992 (with-output-to-temp-buffer "*Help*"
993 (princ "The value of the variable `lazy-lock-defer-time' was\n ")
994 (princ lazy-lock-defer-time)
995 (princ "\n")
996 (princ "This variable cannot now be a list of modes and time,\n")
997 (princ "so instead use ")
998 (princ (substitute-command-keys "\\[customize-option]"))
999 (princ " to modify the variables, or put the forms:\n")
1000 (princ " (setq lazy-lock-defer-time ")
1001 (princ (cdr lazy-lock-defer-time))
1002 (princ ")\n")
1003 (princ " (setq lazy-lock-defer-on-the-fly '")
1004 (princ (car lazy-lock-defer-time))
1005 (princ ")\n")
1006 (princ "in your ~/.emacs. ")
1007 (princ "The above forms have been evaluated for this editor session,\n")
1008 (princ "but you should use ")
1009 (princ (substitute-command-keys "\\[customize-option]"))
1010 (princ " or change your ~/.emacs now."))
1011 (setq lazy-lock-defer-on-the-fly (car lazy-lock-defer-time)
1012 lazy-lock-defer-time (cdr lazy-lock-defer-time)))
1013
1014(when (boundp 'lazy-lock-defer-driven)
1015 ;;
1016 ;; In 2.06.04 and below, `lazy-lock-defer-driven' was the variable name.
1017 (with-output-to-temp-buffer "*Help*"
1018 (princ "The value of the variable `lazy-lock-defer-driven' is set to ")
1019 (if (memq lazy-lock-defer-driven '(nil t))
1020 (princ lazy-lock-defer-driven)
1021 (princ "`")
1022 (princ lazy-lock-defer-driven)
1023 (princ "'"))
1024 (princ ".\n")
1025 (princ "This variable is now called `lazy-lock-defer-on-scrolling',\n")
1026 (princ "so instead use ")
1027 (princ (substitute-command-keys "\\[customize-option]"))
1028 (princ " to modify the variable, or put the form:\n")
1029 (princ " (setq lazy-lock-defer-on-scrolling ")
1030 (unless (memq lazy-lock-defer-driven '(nil t))
1031 (princ "'"))
1032 (princ lazy-lock-defer-driven)
1033 (princ ")\n")
1034 (princ "in your ~/.emacs. ")
1035 (princ "The above form has been evaluated for this editor session,\n")
1036 (princ "but you should use ")
1037 (princ (substitute-command-keys "\\[customize-option]"))
1038 (princ " or change your ~/.emacs now."))
1039 (setq lazy-lock-defer-on-scrolling lazy-lock-defer-driven))
1040
1041;; Install ourselves:
1042
1043(add-hook 'window-size-change-functions 'lazy-lock-fontify-after-resize)
1044(add-hook 'redisplay-end-trigger-functions 'lazy-lock-fontify-after-trigger)
1045
1046(unless (assq 'lazy-lock-mode minor-mode-alist)
1047 (setq minor-mode-alist (append minor-mode-alist '((lazy-lock-mode nil)))))
1048
1049;; Provide ourselves:
1050
1051(provide 'lazy-lock)
1052
1053;;; arch-tag: c1776846-f046-4a45-9684-54b951b12fc9
1054;;; lazy-lock.el ends here
generated by cgit v1.2.1 (git 2.18.0) at 2026-01-23 00:03:18 +0000