1 ;;; fast-lock.el --- Automagic text properties caching for fast Font Lock mode.
3 ;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
5 ;; Author: Simon Marshall <simon@gnu.ai.mit.edu>
6 ;; Keywords: faces files
9 ;;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software; you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs; see the file COPYING. If not, write to the
23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 ;; Boston, MA 02111-1307, USA.
28 ;; Lazy Lock mode is a Font Lock support mode.
29 ;; It makes visiting a file in Font Lock mode faster by restoring its face text
30 ;; properties from automatically saved associated Font Lock cache files.
32 ;; See caveats and feedback below.
33 ;; See also the lazy-lock package. (But don't use the two at the same time!)
37 ;; Put in your ~/.emacs:
39 ;; (setq font-lock-support-mode 'fast-lock-mode)
41 ;; Start up a new Emacs and use font-lock as usual (except that you can use the
42 ;; so-called "gaudier" fontification regexps on big files without frustration).
44 ;; When you visit a file (which has `font-lock-mode' enabled) that has a
45 ;; corresponding Font Lock cache file associated with it, the Font Lock cache
46 ;; will be loaded from that file instead of being generated by Font Lock code.
50 ;; A cache will be saved when visiting a compressed file using crypt++, but not
51 ;; be read. This is a "feature"/"consequence"/"bug" of crypt++.
53 ;; Version control packages are likely to stamp all over file modification
54 ;; times. Therefore the act of checking out may invalidate a cache.
60 ;; Make sure fast-lock.el is supported.
61 (if (and (eq system-type 'ms-dos) (not (msdos-long-file-names)))
62 (error "`fast-lock' was written for long file name systems"))
66 ;; We don't do this at the top-level as we only use non-autoloaded macros.
69 ;; We use this to preserve or protect things when modifying text properties.
70 (defmacro save-buffer-state (varlist &rest body)
71 "Bind variables according to VARLIST and eval BODY restoring buffer state."
72 (` (let* ((,@ (append varlist
73 '((modified (buffer-modified-p)) (buffer-undo-list t)
74 (inhibit-read-only t) (inhibit-point-motion-hooks t)
75 before-change-functions after-change-functions
76 deactivate-mark buffer-file-name buffer-file-truename))))
78 (when (and (not modified) (buffer-modified-p))
79 (set-buffer-modified-p nil)))))
80 (put 'save-buffer-state 'lisp-indent-function 1)
82 ;; We use this to verify that a face should be saved.
83 (defmacro fast-lock-save-facep (face)
84 "Return non-nil if FACE is one of `fast-lock-save-faces'."
85 (` (or (null fast-lock-save-faces)
86 (if (symbolp (, face))
87 (memq (, face) fast-lock-save-faces)
88 (let ((faces (, face)))
89 (while (unless (memq (car faces) fast-lock-save-faces)
90 (setq faces (cdr faces))))
93 ;(defun fast-lock-submit-bug-report ()
94 ; "Submit via mail a bug report on fast-lock.el."
96 ; (let ((reporter-prompt-for-summary-p t))
97 ; (reporter-submit-bug-report "simon@gnu.ai.mit.edu" "fast-lock 3.12"
98 ; '(fast-lock-cache-directories fast-lock-minimum-size
99 ; fast-lock-save-others fast-lock-save-events fast-lock-save-faces
104 ;I want to report a bug. I've read the `Bugs' section of `Info' on Emacs, so I
105 ;know how to make a clear and unambiguous report. To reproduce the bug:
107 ;Start a fresh editor via `" invocation-name " -no-init-file -no-site-file'.
108 ;In the `*scratch*' buffer, evaluate:"))))
110 (defvar fast-lock-mode nil) ; Whether we are turned on.
111 (defvar fast-lock-cache-timestamp nil) ; For saving/reading.
112 (defvar fast-lock-cache-filename nil) ; For deleting.
116 (defgroup fast-lock nil
117 "Font Lock support mode to cache fontification."
118 :link '(custom-manual "(emacs)Support Modes")
121 (defcustom fast-lock-cache-directories '("." "~/.emacs-flc")
122 ; - `internal', keep each file's Font Lock cache file in the same file.
123 ; - `external', keep each file's Font Lock cache file in the same directory.
124 "*Directories in which Font Lock cache files are saved and read.
125 Each item should be either DIR or a cons pair of the form (REGEXP . DIR) where
126 DIR is a directory name (relative or absolute) and REGEXP is a regexp.
128 An attempt will be made to save or read Font Lock cache files using these items
129 until one succeeds (i.e., until a readable or writable one is found). If an
130 item contains REGEXP, DIR is used only if the buffer file name matches REGEXP.
133 (let ((home (expand-file-name (abbreviate-file-name (file-truename \"~/\")))))
134 (list (cons (concat \"^\" (regexp-quote home)) \".\") \"~/.emacs-flc\"))
136 ((\"^/your/true/home/directory/\" . \".\") \"~/.emacs-flc\")
138 would cause a file's current directory to be used if the file is under your
139 home directory hierarchy, or otherwise the absolute directory `~/.emacs-flc'."
140 :type '(repeat (radio (cons :tag "Matching"
141 (regexp :tag "regexp")
142 (directory :tag "directory"))
143 (directory :tag "directory")))
146 (defcustom fast-lock-minimum-size (* 25 1024)
147 "*Minimum size of a buffer for cached fontification.
148 Only buffers more than this can have associated Font Lock cache files saved.
149 If nil, means cache files are never created.
150 If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
151 where MAJOR-MODE is a symbol or t (meaning the default). For example:
152 ((c-mode . 25600) (c++-mode . 25600) (rmail-mode . 1048576))
153 means that the minimum size is 25K for buffers in C or C++ modes, one megabyte
154 for buffers in Rmail mode, and size is irrelevant otherwise."
155 :type '(choice (const :tag "none" nil)
156 (integer :tag "size")
157 (repeat :menu-tag "mode specific" :tag "mode specific"
159 (cons :tag "Instance"
162 (symbol :tag "name"))
164 (const :tag "none" nil)
165 (integer :tag "size")))))
168 (defcustom fast-lock-save-events '(kill-buffer kill-emacs)
169 "*Events under which caches will be saved.
170 Valid events are `save-buffer', `kill-buffer' and `kill-emacs'.
171 If concurrent editing sessions use the same associated cache file for a file's
172 buffer, then you should add `save-buffer' to this list."
173 :type '(set (const :tag "buffer saving" save-buffer)
174 (const :tag "buffer killing" kill-buffer)
175 (const :tag "emacs killing" kill-emacs))
178 (defcustom fast-lock-save-others t
179 "*If non-nil, save Font Lock cache files irrespective of file owner.
180 If nil, means only buffer files known to be owned by you can have associated
181 Font Lock cache files saved. Ownership may be unknown for networked files."
185 (defcustom fast-lock-verbose font-lock-verbose
186 "*If non-nil, means show status messages for cache processing.
187 If a number, only buffers greater than this size have processing messages."
188 :type '(choice (const :tag "never" nil)
189 (const :tag "always" t)
190 (integer :tag "size"))
193 (defvar fast-lock-save-faces
194 (when (save-match-data (string-match "XEmacs" (emacs-version)))
195 ;; XEmacs uses extents for everything, so we have to pick the right ones.
197 "Faces that will be saved in a Font Lock cache file.
198 If nil, means information for all faces will be saved.")
203 (defun fast-lock-mode (&optional arg)
204 "Toggle Fast Lock mode.
205 With arg, turn Fast Lock mode on if and only if arg is positive and the buffer
206 is associated with a file. Enable it automatically in your `~/.emacs' by:
208 (setq font-lock-support-mode 'fast-lock-mode)
210 If Fast Lock mode is enabled, and the current buffer does not contain any text
211 properties, any associated Font Lock cache is used if its timestamp matches the
212 buffer's file, and its `font-lock-keywords' match those that you are using.
214 Font Lock caches may be saved:
215 - When you save the file's buffer.
216 - When you kill an unmodified file's buffer.
217 - When you exit Emacs, for all unmodified or saved buffers.
218 Depending on the value of `fast-lock-save-events'.
219 See also the commands `fast-lock-read-cache' and `fast-lock-save-cache'.
221 Use \\[font-lock-fontify-buffer] to fontify the buffer if the cache is bad.
223 Various methods of control are provided for the Font Lock cache. In general,
224 see variable `fast-lock-cache-directories' and function `fast-lock-cache-name'.
225 For saving, see variables `fast-lock-minimum-size', `fast-lock-save-events',
226 `fast-lock-save-others' and `fast-lock-save-faces'."
228 ;; Only turn on if we are visiting a file. We could use `buffer-file-name',
229 ;; but many packages temporarily wrap that to nil when doing their own thing.
230 (set (make-local-variable 'fast-lock-mode)
231 (and buffer-file-truename
232 (not (memq 'fast-lock-mode font-lock-inhibit-thing-lock))
233 (if arg (> (prefix-numeric-value arg) 0) (not fast-lock-mode))))
234 (if (and fast-lock-mode (not font-lock-mode))
235 ;; Turned on `fast-lock-mode' rather than `font-lock-mode'.
236 (let ((font-lock-support-mode 'fast-lock-mode))
238 ;; Let's get down to business.
239 (set (make-local-variable 'fast-lock-cache-timestamp) nil)
240 (set (make-local-variable 'fast-lock-cache-filename) nil)
241 (when (and fast-lock-mode (not font-lock-fontified))
242 (fast-lock-read-cache))))
244 (defun fast-lock-read-cache ()
245 "Read the Font Lock cache for the current buffer.
247 The following criteria must be met for a Font Lock cache file to be read:
248 - Fast Lock mode must be turned on in the buffer.
249 - The buffer must not be modified.
250 - The buffer's `font-lock-keywords' must match the cache's.
251 - The buffer file's timestamp must match the cache's.
252 - Criteria imposed by `fast-lock-cache-directories'.
254 See `fast-lock-mode'."
256 (let ((directories fast-lock-cache-directories)
257 (modified (buffer-modified-p)) (inhibit-read-only t)
258 (fontified font-lock-fontified))
259 (set (make-local-variable 'font-lock-fontified) nil)
260 ;; Keep trying directories until fontification is turned off.
261 (while (and directories (not font-lock-fontified))
262 (let ((directory (fast-lock-cache-directory (car directories) nil)))
265 (setq fast-lock-cache-filename (fast-lock-cache-name directory))
266 (when (file-readable-p fast-lock-cache-filename)
267 (load fast-lock-cache-filename t t t)))
268 (error nil) (quit nil))
269 (setq directories (cdr directories))))
270 ;; Unset `fast-lock-cache-filename', and restore `font-lock-fontified', if
271 ;; we don't use a cache. (Note that `fast-lock-cache-data' sets the value
272 ;; of `fast-lock-cache-timestamp'.)
273 (set-buffer-modified-p modified)
274 (unless font-lock-fontified
275 (setq fast-lock-cache-filename nil font-lock-fontified fontified))))
277 (defun fast-lock-save-cache (&optional buffer)
278 "Save the Font Lock cache of BUFFER or the current buffer.
280 The following criteria must be met for a Font Lock cache file to be saved:
281 - Fast Lock mode must be turned on in the buffer.
282 - The event must be one of `fast-lock-save-events'.
283 - The buffer must be at least `fast-lock-minimum-size' bytes long.
284 - The buffer file must be owned by you, or `fast-lock-save-others' must be t.
285 - The buffer must contain at least one `face' text property.
286 - The buffer must not be modified.
287 - The buffer file's timestamp must be the same as the file's on disk.
288 - The on disk file's timestamp must be different than the buffer's cache.
289 - Criteria imposed by `fast-lock-cache-directories'.
291 See `fast-lock-mode'."
296 (let ((min-size (font-lock-value-in-major-mode fast-lock-minimum-size))
297 (file-timestamp (visited-file-modtime)) (saved nil))
298 (when (and fast-lock-mode
300 ;; "Only save if the buffer matches the file, the file has
301 ;; changed, and it was changed by the current emacs session."
303 ;; Only save if the buffer is not modified,
304 ;; (i.e., so we don't save for something not on disk)
305 (not (buffer-modified-p))
306 ;; and the file's timestamp is the same as the buffer's,
307 ;; (i.e., someone else hasn't written the file in the meantime)
308 (verify-visited-file-modtime (current-buffer))
309 ;; and the file's timestamp is different from the cache's.
310 ;; (i.e., a save has occurred since the cache was read)
311 (not (equal fast-lock-cache-timestamp file-timestamp))
313 ;; Only save if user's restrictions are satisfied.
314 (and min-size (>= (buffer-size) min-size))
315 (or fast-lock-save-others
316 (eq (user-uid) (nth 2 (file-attributes buffer-file-name))))
318 ;; Only save if there are `face' properties to save.
319 (text-property-not-all (point-min) (point-max) 'face nil))
321 ;; Try each directory until we manage to save or the user quits.
322 (let ((directories fast-lock-cache-directories))
323 (while (and directories (memq saved '(nil error)))
324 (let* ((dir (fast-lock-cache-directory (car directories) t))
325 (file (and dir (fast-lock-cache-name dir))))
326 (when (and file (file-writable-p file))
327 (setq saved (fast-lock-save-cache-1 file file-timestamp)))
328 (setq directories (cdr directories)))))))))
331 (defun turn-on-fast-lock ()
332 "Unconditionally turn on Fast Lock mode."
337 (defun fast-lock-after-fontify-buffer ()
338 ;; Delete the Font Lock cache file used to restore fontification, if any.
339 (when fast-lock-cache-filename
340 (if (file-writable-p fast-lock-cache-filename)
341 (delete-file fast-lock-cache-filename)
342 (message "File %s font lock cache cannot be deleted" (buffer-name))))
343 ;; Flag so that a cache will be saved later even if the file is never saved.
344 (setq fast-lock-cache-timestamp nil))
346 (defalias 'fast-lock-after-unfontify-buffer
349 ;; Miscellaneous Functions:
351 (defun fast-lock-save-cache-after-save-file ()
352 ;; Do `fast-lock-save-cache' if `save-buffer' is on `fast-lock-save-events'.
353 (when (memq 'save-buffer fast-lock-save-events)
354 (fast-lock-save-cache)))
356 (defun fast-lock-save-cache-before-kill-buffer ()
357 ;; Do `fast-lock-save-cache' if `kill-buffer' is on `fast-lock-save-events'.
358 (when (memq 'kill-buffer fast-lock-save-events)
359 (fast-lock-save-cache)))
361 (defun fast-lock-save-caches-before-kill-emacs ()
362 ;; Do `fast-lock-save-cache's if `kill-emacs' is on `fast-lock-save-events'.
363 (when (memq 'kill-emacs fast-lock-save-events)
364 (mapcar 'fast-lock-save-cache (buffer-list))))
366 (defun fast-lock-cache-directory (directory create)
367 "Return usable directory based on DIRECTORY.
368 Returns nil if the directory does not exist, or, if CREATE non-nil, cannot be
369 created. DIRECTORY may be a string or a cons pair of the form (REGEXP . DIR).
370 See `fast-lock-cache-directories'."
372 (cond ((not buffer-file-name)
373 ;; Should never be nil, but `crypt++' screws it up.
379 ;; A directory iff the file name matches the regexp.
380 (let ((bufile (expand-file-name buffer-file-truename))
381 (case-fold-search nil))
382 (when (save-match-data (string-match (car directory) bufile))
383 (cdr directory)))))))
386 ((file-accessible-directory-p dir)
390 (progn (make-directory dir t) dir)
393 ;; If you are wondering why we only hash if the directory is not ".", rather
394 ;; than if `file-name-absolute-p', it is because if we just appended ".flc" for
395 ;; relative cache directories (that are not ".") then it is possible that more
396 ;; than one file would have the same cache name in that directory, if the luser
397 ;; made a link from one relative cache directory to another. (Phew!)
398 (defun fast-lock-cache-name (directory)
399 "Return full cache path name using caching DIRECTORY.
400 If DIRECTORY is `.', the path is the buffer file name appended with `.flc'.
401 Otherwise, the path name is constructed from DIRECTORY and the buffer's true
402 abbreviated file name, with all `/' characters in the name replaced with `#'
403 characters, and appended with `.flc'.
405 If the same file has different cache path names when edited on different
406 machines, e.g., on one machine the cache file name has the prefix `#home',
407 perhaps due to automount, try putting in your `~/.emacs' something like:
409 (setq directory-abbrev-alist (cons '(\"^/home/\" . \"/\") directory-abbrev-alist))
411 Emacs automagically removes the common `/tmp_mnt' automount prefix by default.
413 See `fast-lock-cache-directory'."
414 (if (string-equal directory ".")
415 (concat buffer-file-name ".flc")
416 (let* ((bufile (expand-file-name buffer-file-truename))
418 (if (eq system-type 'emx)
419 '((?/ . (?#)) (?# . (?# ?#)) (?: . (?\;)) (?\; . (?\; ?\;)))
420 '((?/ . (?#)) (?# . (?# ?#)))))
422 (function (lambda (c) (or (cdr (assq c chars-alist)) (list c))))))
424 (file-name-as-directory (expand-file-name directory))
425 (mapconcat 'char-to-string (apply 'append (mapcar mapchars bufile)) "")
428 ;; Font Lock Cache Processing Functions:
430 (defun fast-lock-save-cache-1 (file timestamp)
431 ;; Save the FILE with the TIMESTAMP as:
432 ;; (fast-lock-cache-data Version=2 TIMESTAMP font-lock-keywords PROPERTIES).
433 ;; Returns non-nil if a save was attempted to a writable cache file.
434 (let ((tpbuf (generate-new-buffer " *fast-lock*"))
435 (verbose (if (numberp fast-lock-verbose)
436 (> (buffer-size) fast-lock-verbose)
439 (if verbose (message "Saving %s font lock cache..." (buffer-name)))
442 (print (list 'fast-lock-cache-data 2
443 (list 'quote timestamp)
444 (list 'quote font-lock-keywords)
445 (list 'quote (fast-lock-get-face-properties)))
448 (write-region (point-min) (point-max) file nil 'quietly)
449 (setq fast-lock-cache-timestamp timestamp
450 fast-lock-cache-filename file))
451 (error (setq saved 'error)) (quit (setq saved 'quit)))
453 (if verbose (message "Saving %s font lock cache...%s" (buffer-name)
454 (cond ((eq saved 'error) "failed")
455 ((eq saved 'quit) "aborted")
457 ;; We return non-nil regardless of whether a failure occurred.
460 (defun fast-lock-cache-data (version timestamp keywords properties
462 ;; Change from (HIGH LOW) for back compatibility. Remove for version 3!
463 (when (consp (cdr-safe timestamp))
464 (setcdr timestamp (nth 1 timestamp)))
465 ;; Compile `font-lock-keywords' and KEYWORDS in case one is and one isn't.
466 (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords)
467 keywords (font-lock-compile-keywords keywords))
468 ;; Use the Font Lock cache PROPERTIES if we're using cache VERSION format 2,
469 ;; the current buffer's file timestamp matches the TIMESTAMP, and the current
470 ;; buffer's font-lock-keywords are the same as KEYWORDS.
471 (let ((buf-timestamp (visited-file-modtime))
472 (verbose (if (numberp fast-lock-verbose)
473 (> (buffer-size) fast-lock-verbose)
476 (if (or (/= version 2)
478 (not (equal timestamp buf-timestamp))
479 (not (equal keywords font-lock-keywords)))
481 (if verbose (message "Loading %s font lock cache..." (buffer-name)))
483 (fast-lock-set-face-properties properties)
484 (error (setq loaded 'error)) (quit (setq loaded 'quit)))
485 (if verbose (message "Loading %s font lock cache...%s" (buffer-name)
486 (cond ((eq loaded 'error) "failed")
487 ((eq loaded 'quit) "aborted")
489 (setq font-lock-fontified (eq loaded t)
490 fast-lock-cache-timestamp (and (eq loaded t) timestamp))))
492 ;; Text Properties Processing Functions:
494 ;; This is fast, but fails if adjacent characters have different `face' text
495 ;; properties. Maybe that's why I dropped it in the first place?
496 ;(defun fast-lock-get-face-properties ()
497 ; "Return a list of all `face' text properties in the current buffer.
498 ;Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
499 ;where VALUE is a `face' property value and STARTx and ENDx are positions."
502 ; (let ((start (text-property-not-all (point-min) (point-max) 'face nil))
503 ; (limit (point-max)) end properties value cell)
505 ; (setq end (next-single-property-change start 'face nil limit)
506 ; value (get-text-property start 'face))
507 ; ;; Make, or add to existing, list of regions with same `face'.
508 ; (if (setq cell (assq value properties))
509 ; (setcdr cell (cons start (cons end (cdr cell))))
510 ; (setq properties (cons (list value start end) properties)))
511 ; (setq start (next-single-property-change end 'face)))
514 ;; This is slow, but copes if adjacent characters have different `face' text
515 ;; properties, but fails if they are lists.
516 ;(defun fast-lock-get-face-properties ()
517 ; "Return a list of all `face' text properties in the current buffer.
518 ;Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
519 ;where VALUE is a `face' property value and STARTx and ENDx are positions.
520 ;Only those `face' VALUEs in `fast-lock-save-faces' are returned."
523 ; (let ((faces (or fast-lock-save-faces (face-list))) (limit (point-max))
524 ; properties regions face start end)
526 ; (setq face (car faces) faces (cdr faces) regions () end (point-min))
527 ; ;; Make a list of start/end regions with `face' property face.
528 ; (while (setq start (text-property-any end limit 'face face))
529 ; (setq end (or (text-property-not-all start limit 'face face) limit)
530 ; regions (cons start (cons end regions))))
531 ; ;; Add `face' face's regions, if any, to properties.
533 ; (push (cons face regions) properties)))
536 (defun fast-lock-get-face-properties ()
537 "Return a list of all `face' text properties in the current buffer.
538 Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
539 where VALUE is a `face' property value and STARTx and ENDx are positions."
542 (let ((start (text-property-not-all (point-min) (point-max) 'face nil))
543 end properties value cell)
545 (setq end (next-single-property-change start 'face nil (point-max))
546 value (get-text-property start 'face))
547 ;; Make, or add to existing, list of regions with same `face'.
548 (cond ((setq cell (assoc value properties))
549 (setcdr cell (cons start (cons end (cdr cell)))))
550 ((fast-lock-save-facep value)
551 (push (list value start end) properties)))
552 (setq start (text-property-not-all end (point-max) 'face nil)))
555 (defun fast-lock-set-face-properties (properties)
556 "Set all `face' text properties to PROPERTIES in the current buffer.
557 Any existing `face' text properties are removed first.
558 See `fast-lock-get-face-properties' for the format of PROPERTIES."
559 (save-buffer-state (plist regions)
562 (font-lock-unfontify-region (point-min) (point-max))
564 (setq plist (list 'face (car (car properties)))
565 regions (cdr (car properties))
566 properties (cdr properties))
567 ;; Set the `face' property for each start/end region.
569 (set-text-properties (nth 0 regions) (nth 1 regions) plist)
570 (setq regions (nthcdr 2 regions)))))))
572 ;; Functions for XEmacs:
574 (when (save-match-data (string-match "XEmacs" (emacs-version)))
576 ;; It would be better to use XEmacs' `map-extents' over extents with a
577 ;; `font-lock' property, but `face' properties are on different extents.
578 (defun fast-lock-get-face-properties ()
579 "Return a list of all `face' text properties in the current buffer.
580 Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
581 where VALUE is a `face' property value and STARTx and ENDx are positions.
582 Only those `face' VALUEs in `fast-lock-save-faces' are returned."
585 (let ((properties ()) cell)
587 (function (lambda (extent ignore)
588 (let ((value (extent-face extent)))
589 ;; We're only interested if it's one of `fast-lock-save-faces'.
590 (when (and value (fast-lock-save-facep value))
591 (let ((start (extent-start-position extent))
592 (end (extent-end-position extent)))
593 ;; Make or add to existing list of regions with the same
594 ;; `face' property value.
595 (if (setq cell (assoc value properties))
596 (setcdr cell (cons start (cons end (cdr cell))))
597 (push (list value start end) properties))))
598 ;; Return nil to keep `map-extents' going.
602 ;; Make extents just like XEmacs' font-lock.el does.
603 (defun fast-lock-set-face-properties (properties)
604 "Set all `face' text properties to PROPERTIES in the current buffer.
605 Any existing `face' text properties are removed first.
606 See `fast-lock-get-face-properties' for the format of PROPERTIES."
609 (font-lock-unfontify-region (point-min) (point-max))
611 (let ((face (car (car properties)))
612 (regions (cdr (car properties))))
613 ;; Set the `face' property, etc., for each start/end region.
615 (font-lock-set-face (nth 0 regions) (nth 1 regions) face)
616 (setq regions (nthcdr 2 regions)))
617 (setq properties (cdr properties))))))
619 ;; XEmacs 19.12 font-lock.el's `font-lock-fontify-buffer' runs a hook.
620 (add-hook 'font-lock-after-fontify-buffer-hook
621 'fast-lock-after-fontify-buffer))
623 (unless (boundp 'font-lock-inhibit-thing-lock)
624 (defvar font-lock-inhibit-thing-lock nil
625 "List of Font Lock mode related modes that should not be turned on."))
627 (unless (fboundp 'font-lock-value-in-major-mode)
628 (defun font-lock-value-in-major-mode (alist)
629 ;; Return value in ALIST for `major-mode'.
631 (cdr (or (assq major-mode alist) (assq t alist)))
634 (unless (fboundp 'font-lock-compile-keywords)
635 (defalias 'font-lock-compile-keywords 'identity))
637 ;; Install ourselves:
639 (add-hook 'after-save-hook 'fast-lock-save-cache-after-save-file)
640 (add-hook 'kill-buffer-hook 'fast-lock-save-cache-before-kill-buffer)
641 (add-hook 'kill-emacs-hook 'fast-lock-save-caches-before-kill-emacs)
644 (when (fboundp 'add-minor-mode)
645 (defvar fast-lock-mode nil)
646 (add-minor-mode 'fast-lock-mode nil))
648 (unless (assq 'fast-lock-mode minor-mode-alist)
649 (setq minor-mode-alist (append minor-mode-alist '((fast-lock-mode nil)))))
651 ;; Provide ourselves:
655 ;;; fast-lock.el ends here