code.delx.au - gnu-emacs/blob - lisp/fast-lock.el

   1 ;;; fast-lock.el --- Automagic text properties caching for fast Font Lock mode.
   2
   3 ;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
   4
   5 ;; Author: Simon Marshall <simon@gnu.ai.mit.edu>
   6 ;; Keywords: faces files
   7 ;; Version: 3.12.01
   8
   9 ;;; This file is part of GNU Emacs.
  10
  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)
  14 ;; any later version.
  15
  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.
  20
  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.
  25
  26 ;;; Commentary:
  27
  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.
  31 ;;
  32 ;; See caveats and feedback below.
  33 ;; See also the lazy-lock package.  (But don't use the two at the same time!)
  34
  35 ;; Installation:
  36 ;;
  37 ;; Put in your ~/.emacs:
  38 ;;
  39 ;; (setq font-lock-support-mode 'fast-lock-mode)
  40 ;;
  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).
  43 ;;
  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.
  47
  48 ;; Caveats:
  49 ;;
  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++.
  52 ;;
  53 ;; Version control packages are likely to stamp all over file modification
  54 ;; times.  Therefore the act of checking out may invalidate a cache.
  55 \f
  56 ;; History:
  57 ;;
  58 ;; 0.02--1.00:
  59 ;; - Changed name from turbo-prop to fast-lock.  Automagic for font-lock only
  60 ;; - Made `fast-lock-mode' a minor mode, like G. Dinesh Dutt's fss-mode
  61 ;; 1.00--1.01:
  62 ;; - Turn on `fast-lock-mode' only if `buffer-file-name' or `interactive-p'
  63 ;; - Made `fast-lock-file-name' use `buffer-name' if `buffer-file-name' is nil
  64 ;; - Moved save-all conditions to `fast-lock-save-cache'
  65 ;; - Added `fast-lock-save-text-properties' to `kill-buffer-hook'
  66 ;; 1.01--2.00: complete rewrite---not worth the space to document
  67 ;; - Changed structure of text properties cache and threw out file mod checks
  68 ;; 2.00--2.01:
  69 ;; - Made `condition-case' forms understand `quit'.
  70 ;; - Made `fast-lock' require `font-lock'
  71 ;; - Made `fast-lock-cache-name' chase links (from Ben Liblit)
  72 ;; 2.01--3.00:
  73 ;; - Changed structure of cache to include `font-lock-keywords' (from rms)
  74 ;; - Changed `fast-lock-cache-mechanisms' to `fast-lock-cache-directories'
  75 ;; - Removed `fast-lock-read-others'
  76 ;; - Made `fast-lock-read-cache' ignore cache owner
  77 ;; - Made `fast-lock-save-cache-external' create cache directory
  78 ;; - Made `fast-lock-save-cache-external' save `font-lock-keywords'
  79 ;; - Made `fast-lock-cache-data' check `font-lock-keywords'
  80 ;; 3.00--3.01: incorporated port of 2.00 to Lucid, made by Barry Warsaw
  81 ;; - Package now provides itself
  82 ;; - Lucid: Use `font-lock-any-extents-p' for `font-lock-any-properties-p'
  83 ;; - Lucid: Use `list-faces' for `face-list'
  84 ;; - Lucid: Added `set-text-properties'
  85 ;; - Lucid: Made `turn-on-fast-lock' pass 1 not t to `fast-lock-mode'
  86 ;; - Removed test for `fast-lock-mode' from `fast-lock-read-cache'
  87 ;; - Lucid: Added Lucid-specific `fast-lock-get-face-properties'
  88 ;; 3.01--3.02: now works with Lucid Emacs, thanks to Barry Warsaw
  89 ;; - Made `fast-lock-cache-name' map ":" to ";" for OS/2 (from Serganova Vera)
  90 ;; - Made `fast-lock-cache-name' use abbreviated file name (from Barry Warsaw)
  91 ;; - Lucid: Separated handlers for `error' and `quit' for `condition-case'
  92 ;; 3.02--3.03:
  93 ;; - Changed `fast-lock-save-cache-external' to `fast-lock-save-cache-data'
  94 ;; - Lucid: Added Lucid-specific `fast-lock-set-face-properties'
  95 ;; 3.03--3.04:
  96 ;; - Corrected `subrp' test of Lucid code
  97 ;; - Replaced `font-lock-any-properties-p' with `text-property-not-all'
  98 ;; - Lucid: Made `fast-lock-set-face-properties' put `text-prop' on extents
  99 ;; - Made `fast-lock-cache-directories' a regexp alist (from Colin Rafferty)
 100 ;; - Made `fast-lock-cache-directory' to return a usable cache file directory
 101 ;; 3.04--3.05:
 102 ;; - Lucid: Fix for XEmacs 19.11 `text-property-not-all'
 103 ;; - Replaced `subrp' test of Lucid code with `emacs-version' `string-match'
 104 ;; - Made `byte-compile-warnings' omit `unresolved' on compilation
 105 ;; - Made `fast-lock-save-cache-data' use a buffer (from Rick Sladkey)
 106 ;; - Reverted to old `fast-lock-get-face-properties' (from Rick Sladkey)
 107 ;; 3.05--3.06: incorporated hack of 3.03, made by Jonathan Stigelman (Stig)
 108 ;; - Reverted to 3.04 version of `fast-lock-get-face-properties'
 109 ;; - XEmacs: Removed `list-faces' `defalias'
 110 ;; - Made `fast-lock-mode' and `turn-on-fast-lock' succeed `autoload' cookies
 111 ;; - Added `fast-lock-submit-bug-report'
 112 ;; - Renamed `fast-lock-save-size' to `fast-lock-minimum-size'
 113 ;; - Made `fast-lock-save-cache' output a message if no save ever attempted
 114 ;; - Made `fast-lock-save-cache-data' output a message if save attempted
 115 ;; - Made `fast-lock-cache-data' output a message if load attempted
 116 ;; - Made `fast-lock-save-cache-data' do `condition-case' not `unwind-protect'
 117 ;; - Made `fast-lock-save-cache' and `fast-lock-read-cache' return nothing
 118 ;; - Made `fast-lock-save-cache' check `buffer-modified-p' (Stig)
 119 ;; - Added `fast-lock-save-events'
 120 ;; - Added `fast-lock-after-save-hook' to `after-save-hook' (Stig)
 121 ;; - Added `fast-lock-kill-buffer-hook' to `kill-buffer-hook'
 122 ;; - Changed `fast-lock-save-caches' to `fast-lock-kill-emacs-hook'
 123 ;; - Added `fast-lock-kill-emacs-hook' to `kill-emacs-hook'
 124 ;; - Made `fast-lock-save-cache' check `verify-visited-file-modtime' (Stig)
 125 ;; - Made `visited-file-modtime' be the basis of the timestamp (Stig)
 126 ;; - Made `fast-lock-save-cache-1' and `fast-lock-cache-data' use/reformat it
 127 ;; - Added `fast-lock-cache-filename' to keep track of the cache file name
 128 ;; - Added `fast-lock-after-fontify-buffer'
 129 ;; - Added `fast-lock-save-faces' list of faces to save (idea from Stig/Tibor)
 130 ;; - Made `fast-lock-get-face-properties' functions use it
 131 ;; - XEmacs: Made `fast-lock-set-face-properties' do extents the Font Lock way
 132 ;; - XEmacs: Removed fix for `text-property-not-all' (19.11 support dropped)
 133 ;; - Made `fast-lock-mode' ensure `font-lock-mode' is on
 134 ;; - Made `fast-lock-save-cache' do `cdr-safe' not `cdr' (from Dave Foster)
 135 ;; - Made `fast-lock-save-cache' do `set-buffer' first (from Dave Foster)
 136 ;; - Made `fast-lock-save-cache' loop until saved or quit (from Georg Nikodym)
 137 ;; - Made `fast-lock-cache-data' check `buffer-modified-p'
 138 ;; - Made `fast-lock-cache-data' do `font-lock-compile-keywords' if necessary
 139 ;; - XEmacs: Made `font-lock-compile-keywords' `defalias'
 140 ;; 3.06--3.07:
 141 ;; - XEmacs: Add `fast-lock-after-fontify-buffer' to the Font Lock hook
 142 ;; - Made `fast-lock-cache-name' explain the use of `directory-abbrev-alist'
 143 ;; - Made `fast-lock-mode' use `buffer-file-truename' not `buffer-file-name'
 144 ;; 3.07--3.08:
 145 ;; - Made `fast-lock-read-cache' set `fast-lock-cache-filename'
 146 ;; 3.08--3.09:
 147 ;; - Made `fast-lock-save-cache' cope if `fast-lock-minimum-size' is an a list
 148 ;; - Made `fast-lock-mode' respect the value of `font-lock-inhibit-thing-lock'
 149 ;; - Added `fast-lock-after-unfontify-buffer'
 150 ;; 3.09--3.10:
 151 ;; - Rewrite for Common Lisp macros
 152 ;; - Made fast-lock.el barf on a crap 8+3 pseudo-OS (Eli Zaretskii help)
 153 ;; - XEmacs: Made `add-minor-mode' succeed `autoload' cookie
 154 ;; - XEmacs: Made `fast-lock-save-faces' default to `font-lock-face-list'
 155 ;; - Made `fast-lock-save-cache' use `font-lock-value-in-major-mode'
 156 ;; - Wrap with `save-buffer-state' (Ray Van Tassle report)
 157 ;; - Made `fast-lock-mode' wrap `font-lock-support-mode'
 158 ;; 3.10--3.11:
 159 ;; - Made `fast-lock-get-face-properties' cope with face lists
 160 ;; - Added `fast-lock-verbose'
 161 ;; - XEmacs: Add `font-lock-value-in-major-mode' if necessary
 162 ;; - Removed `fast-lock-submit-bug-report' and bade farewell
 163 ;; 3.11--3.12:
 164 ;; - Added Custom support (Hrvoje Niksic help)
 165 ;; - Made `save-buffer-state' wrap `inhibit-point-motion-hooks'
 166 ;; - Made `fast-lock-cache-data' simplify calls of `font-lock-compile-keywords'
 167 ;; 3.12--3.13:
 168 ;; - Removed `byte-*' variables from `eval-when-compile' (Erik Naggum hint)
 169 \f
 170 ;;; Code:
 171
 172 (require 'font-lock)
 173
 174 ;; Make sure fast-lock.el is supported.
 175 (if (and (eq system-type 'ms-dos) (not (msdos-long-file-names)))
 176     (error "`fast-lock' was written for long file name systems"))
 177
 178 (eval-when-compile
 179   ;;
 180   ;; We don't do this at the top-level as we only use non-autoloaded macros.
 181   (require 'cl)
 182   ;;
 183   ;; We use this to preserve or protect things when modifying text properties.
 184   (defmacro save-buffer-state (varlist &rest body)
 185     "Bind variables according to VARLIST and eval BODY restoring buffer state."
 186     (` (let* ((,@ (append varlist
 187                    '((modified (buffer-modified-p)) (buffer-undo-list t)
 188                      (inhibit-read-only t) (inhibit-point-motion-hooks t)
 189                      before-change-functions after-change-functions
 190                      deactivate-mark buffer-file-name buffer-file-truename))))
 191          (,@ body)
 192          (when (and (not modified) (buffer-modified-p))
 193            (set-buffer-modified-p nil)))))
 194   (put 'save-buffer-state 'lisp-indent-function 1)
 195   ;;
 196   ;; We use this to verify that a face should be saved.
 197   (defmacro fast-lock-save-facep (face)
 198     "Return non-nil if FACE is one of `fast-lock-save-faces'."
 199     (` (or (null fast-lock-save-faces)
 200            (if (symbolp (, face))
 201                (memq (, face) fast-lock-save-faces)
 202              (let ((faces (, face)))
 203                (while (unless (memq (car faces) fast-lock-save-faces)
 204                         (setq faces (cdr faces))))
 205                faces)))))
 206   ;;
 207   ;; We use this for compatibility with a future Emacs.
 208   (or (fboundp 'defcustom)
 209       (defmacro defcustom (symbol value doc &rest args)
 210         (` (defvar (, symbol) (, value) (, doc))))))
 211
 212 ;(defun fast-lock-submit-bug-report ()
 213 ;  "Submit via mail a bug report on fast-lock.el."
 214 ;  (interactive)
 215 ;  (let ((reporter-prompt-for-summary-p t))
 216 ;    (reporter-submit-bug-report "simon@gnu.ai.mit.edu" "fast-lock 3.12.01"
 217 ;     '(fast-lock-cache-directories fast-lock-minimum-size
 218 ;       fast-lock-save-others fast-lock-save-events fast-lock-save-faces
 219 ;       fast-lock-verbose)
 220 ;     nil nil
 221 ;     (concat "Hi Si.,
 222 ;
 223 ;I want to report a bug.  I've read the `Bugs' section of `Info' on Emacs, so I
 224 ;know how to make a clear and unambiguous report.  To reproduce the bug:
 225 ;
 226 ;Start a fresh editor via `" invocation-name " -no-init-file -no-site-file'.
 227 ;In the `*scratch*' buffer, evaluate:"))))
 228
 229 (defvar fast-lock-mode nil)             ; Whether we are turned on.
 230 (defvar fast-lock-cache-timestamp nil)  ; For saving/reading.
 231 (defvar fast-lock-cache-filename nil)   ; For deleting.
 232 \f
 233 ;; User Variables:
 234
 235 (defcustom fast-lock-cache-directories '("." "~/.emacs-flc")
 236 ; - `internal', keep each file's Font Lock cache file in the same file.
 237 ; - `external', keep each file's Font Lock cache file in the same directory.
 238   "*Directories in which Font Lock cache files are saved and read.
 239 Each item should be either DIR or a cons pair of the form (REGEXP . DIR) where
 240 DIR is a directory name (relative or absolute) and REGEXP is a regexp.
 241
 242 An attempt will be made to save or read Font Lock cache files using these items
 243 until one succeeds (i.e., until a readable or writable one is found).  If an
 244 item contains REGEXP, DIR is used only if the buffer file name matches REGEXP.
 245 For example:
 246
 247  (let ((home (expand-file-name (abbreviate-file-name (file-truename \"~/\")))))
 248    (list (cons (concat \"^\" (regexp-quote home)) \".\") \"~/.emacs-flc\"))
 249     =>
 250  ((\"^/your/true/home/directory/\" . \".\") \"~/.emacs-flc\")
 251
 252 would cause a file's current directory to be used if the file is under your
 253 home directory hierarchy, or otherwise the absolute directory `~/.emacs-flc'."
 254   :type '(repeat (radio (directory :tag "directory")
 255                         (cons :tag "Matching"
 256                               (regexp :tag "regexp")
 257                               (directory :tag "directory"))))
 258   :group 'fast-lock)
 259
 260 (defcustom fast-lock-minimum-size (* 25 1024)
 261   "*Minimum size of a buffer for cached fontification.
 262 Only buffers more than this can have associated Font Lock cache files saved.
 263 If nil, means cache files are never created.
 264 If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
 265 where MAJOR-MODE is a symbol or t (meaning the default).  For example:
 266  ((c-mode . 25600) (c++-mode . 25600) (rmail-mode . 1048576))
 267 means that the minimum size is 25K for buffers in C or C++ modes, one megabyte
 268 for buffers in Rmail mode, and size is irrelevant otherwise."
 269   :type '(choice (const :tag "none" nil)
 270                  (integer :tag "size")
 271                  (repeat :menu-tag "mode specific" :tag "mode specific"
 272                          :value ((t . nil))
 273                          (cons :tag "Instance"
 274                                (radio :tag "Mode"
 275                                       (const :tag "all" t)
 276                                       (symbol :tag "name"))
 277                                (radio :tag "Size"
 278                                       (const :tag "none" nil)
 279                                       (integer :tag "size")))))
 280   :group 'fast-lock)
 281
 282 (defcustom fast-lock-save-events '(kill-buffer kill-emacs)
 283   "*Events under which caches will be saved.
 284 Valid events are `save-buffer', `kill-buffer' and `kill-emacs'.
 285 If concurrent editing sessions use the same associated cache file for a file's
 286 buffer, then you should add `save-buffer' to this list."
 287   :type '(set (const :tag "buffer saving" save-buffer)
 288               (const :tag "buffer killing" kill-buffer)
 289               (const :tag "emacs killing" kill-emacs))
 290   :group 'fast-lock)
 291
 292 (defcustom fast-lock-save-others t
 293   "*If non-nil, save Font Lock cache files irrespective of file owner.
 294 If nil, means only buffer files known to be owned by you can have associated
 295 Font Lock cache files saved.  Ownership may be unknown for networked files."
 296   :type 'boolean
 297   :group 'fast-lock)
 298
 299 (defcustom fast-lock-verbose font-lock-verbose
 300   "*If non-nil, means show status messages for cache processing.
 301 If a number, only buffers greater than this size have processing messages."
 302   :type '(choice (const :tag "never" nil)
 303                  (const :tag "always" t)
 304                  (integer :tag "size"))
 305   :group 'fast-lock)
 306
 307 (defvar fast-lock-save-faces
 308   (when (save-match-data (string-match "XEmacs" (emacs-version)))
 309     ;; XEmacs uses extents for everything, so we have to pick the right ones.
 310     font-lock-face-list)
 311   "Faces that will be saved in a Font Lock cache file.
 312 If nil, means information for all faces will be saved.")
 313 \f
 314 ;; User Functions:
 315
 316 ;;;###autoload
 317 (defun fast-lock-mode (&optional arg)
 318   "Toggle Fast Lock mode.
 319 With arg, turn Fast Lock mode on if and only if arg is positive and the buffer
 320 is associated with a file.  Enable it automatically in your `~/.emacs' by:
 321
 322  (setq font-lock-support-mode 'fast-lock-mode)
 323
 324 If Fast Lock mode is enabled, and the current buffer does not contain any text
 325 properties, any associated Font Lock cache is used if its timestamp matches the
 326 buffer's file, and its `font-lock-keywords' match those that you are using.
 327
 328 Font Lock caches may be saved:
 329 - When you save the file's buffer.
 330 - When you kill an unmodified file's buffer.
 331 - When you exit Emacs, for all unmodified or saved buffers.
 332 Depending on the value of `fast-lock-save-events'.
 333 See also the commands `fast-lock-read-cache' and `fast-lock-save-cache'.
 334
 335 Use \\[font-lock-fontify-buffer] to fontify the buffer if the cache is bad.
 336
 337 Various methods of control are provided for the Font Lock cache.  In general,
 338 see variable `fast-lock-cache-directories' and function `fast-lock-cache-name'.
 339 For saving, see variables `fast-lock-minimum-size', `fast-lock-save-events',
 340 `fast-lock-save-others' and `fast-lock-save-faces'."
 341   (interactive "P")
 342   ;; Only turn on if we are visiting a file.  We could use `buffer-file-name',
 343   ;; but many packages temporarily wrap that to nil when doing their own thing.
 344   (set (make-local-variable 'fast-lock-mode)
 345        (and buffer-file-truename
 346             (not (memq 'fast-lock-mode font-lock-inhibit-thing-lock))
 347             (if arg (> (prefix-numeric-value arg) 0) (not fast-lock-mode))))
 348   (if (and fast-lock-mode (not font-lock-mode))
 349       ;; Turned on `fast-lock-mode' rather than `font-lock-mode'.
 350       (let ((font-lock-support-mode 'fast-lock-mode))
 351         (font-lock-mode t))
 352     ;; Let's get down to business.
 353     (set (make-local-variable 'fast-lock-cache-timestamp) nil)
 354     (set (make-local-variable 'fast-lock-cache-filename) nil)
 355     (when (and fast-lock-mode (not font-lock-fontified))
 356       (fast-lock-read-cache))))
 357
 358 (defun fast-lock-read-cache ()
 359   "Read the Font Lock cache for the current buffer.
 360
 361 The following criteria must be met for a Font Lock cache file to be read:
 362 - Fast Lock mode must be turned on in the buffer.
 363 - The buffer must not be modified.
 364 - The buffer's `font-lock-keywords' must match the cache's.
 365 - The buffer file's timestamp must match the cache's.
 366 - Criteria imposed by `fast-lock-cache-directories'.
 367
 368 See `fast-lock-mode'."
 369   (interactive)
 370   (let ((directories fast-lock-cache-directories)
 371         (modified (buffer-modified-p)) (inhibit-read-only t)
 372         (fontified font-lock-fontified))
 373     (set (make-local-variable 'font-lock-fontified) nil)
 374     ;; Keep trying directories until fontification is turned off.
 375     (while (and directories (not font-lock-fontified))
 376       (let ((directory (fast-lock-cache-directory (car directories) nil)))
 377         (condition-case nil
 378             (when directory
 379               (setq fast-lock-cache-filename (fast-lock-cache-name directory))
 380               (when (file-readable-p fast-lock-cache-filename)
 381                 (load fast-lock-cache-filename t t t)))
 382           (error nil) (quit nil))
 383         (setq directories (cdr directories))))
 384     ;; Unset `fast-lock-cache-filename', and restore `font-lock-fontified', if
 385     ;; we don't use a cache.  (Note that `fast-lock-cache-data' sets the value
 386     ;; of `fast-lock-cache-timestamp'.)
 387     (set-buffer-modified-p modified)
 388     (unless font-lock-fontified
 389       (setq fast-lock-cache-filename nil font-lock-fontified fontified))))
 390
 391 (defun fast-lock-save-cache (&optional buffer)
 392   "Save the Font Lock cache of BUFFER or the current buffer.
 393
 394 The following criteria must be met for a Font Lock cache file to be saved:
 395 - Fast Lock mode must be turned on in the buffer.
 396 - The event must be one of `fast-lock-save-events'.
 397 - The buffer must be at least `fast-lock-minimum-size' bytes long.
 398 - The buffer file must be owned by you, or `fast-lock-save-others' must be t.
 399 - The buffer must contain at least one `face' text property.
 400 - The buffer must not be modified.
 401 - The buffer file's timestamp must be the same as the file's on disk.
 402 - The on disk file's timestamp must be different than the buffer's cache.
 403 - Criteria imposed by `fast-lock-cache-directories'.
 404
 405 See `fast-lock-mode'."
 406   (interactive)
 407   (save-excursion
 408     (when buffer
 409       (set-buffer buffer))
 410     (let ((min-size (font-lock-value-in-major-mode fast-lock-minimum-size))
 411           (file-timestamp (visited-file-modtime)) (saved nil))
 412       (when (and fast-lock-mode
 413              ;;
 414              ;; "Only save if the buffer matches the file, the file has
 415              ;; changed, and it was changed by the current emacs session."
 416              ;;
 417              ;; Only save if the buffer is not modified,
 418              ;; (i.e., so we don't save for something not on disk)
 419              (not (buffer-modified-p))
 420              ;; and the file's timestamp is the same as the buffer's,
 421              ;; (i.e., someone else hasn't written the file in the meantime)
 422              (verify-visited-file-modtime (current-buffer))
 423              ;; and the file's timestamp is different from the cache's.
 424              ;; (i.e., a save has occurred since the cache was read)
 425              (not (equal fast-lock-cache-timestamp file-timestamp))
 426              ;;
 427              ;; Only save if user's restrictions are satisfied.
 428              (and min-size (>= (buffer-size) min-size))
 429              (or fast-lock-save-others
 430                  (eq (user-uid) (nth 2 (file-attributes buffer-file-name))))
 431              ;;
 432              ;; Only save if there are `face' properties to save.
 433              (text-property-not-all (point-min) (point-max) 'face nil))
 434         ;;
 435         ;; Try each directory until we manage to save or the user quits.
 436         (let ((directories fast-lock-cache-directories))
 437           (while (and directories (memq saved '(nil error)))
 438             (let* ((dir (fast-lock-cache-directory (car directories) t))
 439                    (file (and dir (fast-lock-cache-name dir))))
 440               (when (and file (file-writable-p file))
 441                 (setq saved (fast-lock-save-cache-1 file file-timestamp)))
 442               (setq directories (cdr directories)))))))))
 443
 444 ;;;###autoload
 445 (defun turn-on-fast-lock ()
 446   "Unconditionally turn on Fast Lock mode."
 447   (fast-lock-mode t))
 448 \f
 449 ;;; API Functions:
 450
 451 (defun fast-lock-after-fontify-buffer ()
 452   ;; Delete the Font Lock cache file used to restore fontification, if any.
 453   (when fast-lock-cache-filename
 454     (if (file-writable-p fast-lock-cache-filename)
 455         (delete-file fast-lock-cache-filename)
 456       (message "File %s font lock cache cannot be deleted" (buffer-name))))
 457   ;; Flag so that a cache will be saved later even if the file is never saved.
 458   (setq fast-lock-cache-timestamp nil))
 459
 460 (defalias 'fast-lock-after-unfontify-buffer
 461   'ignore)
 462 \f
 463 ;; Miscellaneous Functions:
 464
 465 (defun fast-lock-save-cache-after-save-file ()
 466   ;; Do `fast-lock-save-cache' if `save-buffer' is on `fast-lock-save-events'.
 467   (when (memq 'save-buffer fast-lock-save-events)
 468     (fast-lock-save-cache)))
 469
 470 (defun fast-lock-save-cache-before-kill-buffer ()
 471   ;; Do `fast-lock-save-cache' if `kill-buffer' is on `fast-lock-save-events'.
 472   (when (memq 'kill-buffer fast-lock-save-events)
 473     (fast-lock-save-cache)))
 474
 475 (defun fast-lock-save-caches-before-kill-emacs ()
 476   ;; Do `fast-lock-save-cache's if `kill-emacs' is on `fast-lock-save-events'.
 477   (when (memq 'kill-emacs fast-lock-save-events)
 478     (mapcar 'fast-lock-save-cache (buffer-list))))
 479
 480 (defun fast-lock-cache-directory (directory create)
 481   "Return usable directory based on DIRECTORY.
 482 Returns nil if the directory does not exist, or, if CREATE non-nil, cannot be
 483 created.  DIRECTORY may be a string or a cons pair of the form (REGEXP . DIR).
 484 See `fast-lock-cache-directories'."
 485   (let ((dir
 486          (cond ((not buffer-file-name)
 487                 ;; Should never be nil, but `crypt++' screws it up.
 488                 nil)
 489                ((stringp directory)
 490                 ;; Just a directory.
 491                 directory)
 492                (t
 493                 ;; A directory iff the file name matches the regexp.
 494                 (let ((bufile (expand-file-name buffer-file-truename))
 495                       (case-fold-search nil))
 496                   (when (save-match-data (string-match (car directory) bufile))
 497                     (cdr directory)))))))
 498     (cond ((not dir)
 499            nil)
 500           ((file-accessible-directory-p dir)
 501            dir)
 502           (create
 503            (condition-case nil
 504                (progn (make-directory dir t) dir)
 505              (error nil))))))
 506
 507 ;; If you are wondering why we only hash if the directory is not ".", rather
 508 ;; than if `file-name-absolute-p', it is because if we just appended ".flc" for
 509 ;; relative cache directories (that are not ".") then it is possible that more
 510 ;; than one file would have the same cache name in that directory, if the luser
 511 ;; made a link from one relative cache directory to another.  (Phew!)
 512 (defun fast-lock-cache-name (directory)
 513   "Return full cache path name using caching DIRECTORY.
 514 If DIRECTORY is `.', the path is the buffer file name appended with `.flc'.
 515 Otherwise, the path name is constructed from DIRECTORY and the buffer's true
 516 abbreviated file name, with all `/' characters in the name replaced with `#'
 517 characters, and appended with `.flc'.
 518
 519 If the same file has different cache path names when edited on different
 520 machines, e.g., on one machine the cache file name has the prefix `#home',
 521 perhaps due to automount, try putting in your `~/.emacs' something like:
 522
 523  (setq directory-abbrev-alist (cons '(\"^/home/\" . \"/\") directory-abbrev-alist))
 524
 525 Emacs automagically removes the common `/tmp_mnt' automount prefix by default.
 526
 527 See `fast-lock-cache-directory'."
 528   (if (string-equal directory ".")
 529       (concat buffer-file-name ".flc")
 530     (let* ((bufile (expand-file-name buffer-file-truename))
 531            (chars-alist
 532             (if (eq system-type 'emx)
 533                 '((?/ . (?#)) (?# . (?# ?#)) (?: . (?\;)) (?\; . (?\; ?\;)))
 534               '((?/ . (?#)) (?# . (?# ?#)))))
 535            (mapchars
 536             (function (lambda (c) (or (cdr (assq c chars-alist)) (list c))))))
 537       (concat
 538        (file-name-as-directory (expand-file-name directory))
 539        (mapconcat 'char-to-string (apply 'append (mapcar mapchars bufile)) "")
 540        ".flc"))))
 541 \f
 542 ;; Font Lock Cache Processing Functions:
 543
 544 (defun fast-lock-save-cache-1 (file timestamp)
 545   ;; Save the FILE with the TIMESTAMP as:
 546   ;; (fast-lock-cache-data Version=2 TIMESTAMP font-lock-keywords PROPERTIES).
 547   ;; Returns non-nil if a save was attempted to a writable cache file.
 548   (let ((tpbuf (generate-new-buffer " *fast-lock*"))
 549         (verbose (if (numberp fast-lock-verbose)
 550                      (> (buffer-size) fast-lock-verbose)
 551                    fast-lock-verbose))
 552         (saved t))
 553     (if verbose (message "Saving %s font lock cache..." (buffer-name)))
 554     (condition-case nil
 555         (save-excursion
 556           (print (list 'fast-lock-cache-data 2
 557                        (list 'quote timestamp)
 558                        (list 'quote font-lock-keywords)
 559                        (list 'quote (fast-lock-get-face-properties)))
 560                  tpbuf)
 561           (set-buffer tpbuf)
 562           (write-region (point-min) (point-max) file nil 'quietly)
 563           (setq fast-lock-cache-timestamp timestamp
 564                 fast-lock-cache-filename file))
 565       (error (setq saved 'error)) (quit (setq saved 'quit)))
 566     (kill-buffer tpbuf)
 567     (if verbose (message "Saving %s font lock cache...%s" (buffer-name)
 568                          (cond ((eq saved 'error) "failed")
 569                                ((eq saved 'quit) "aborted")
 570                                (t "done"))))
 571     ;; We return non-nil regardless of whether a failure occurred.
 572     saved))
 573
 574 (defun fast-lock-cache-data (version timestamp keywords properties
 575                              &rest ignored)
 576   ;; Change from (HIGH LOW) for back compatibility.  Remove for version 3!
 577   (when (consp (cdr-safe timestamp))
 578     (setcdr timestamp (nth 1 timestamp)))
 579   ;; Compile `font-lock-keywords' and KEYWORDS in case one is and one isn't.
 580   (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords)
 581         keywords (font-lock-compile-keywords keywords))
 582   ;; Use the Font Lock cache PROPERTIES if we're using cache VERSION format 2,
 583   ;; the current buffer's file timestamp matches the TIMESTAMP, and the current
 584   ;; buffer's font-lock-keywords are the same as KEYWORDS.
 585   (let ((buf-timestamp (visited-file-modtime))
 586         (verbose (if (numberp fast-lock-verbose)
 587                      (> (buffer-size) fast-lock-verbose)
 588                    fast-lock-verbose))
 589         (loaded t))
 590     (if (or (/= version 2)
 591             (buffer-modified-p)
 592             (not (equal timestamp buf-timestamp))
 593             (not (equal keywords font-lock-keywords)))
 594         (setq loaded nil)
 595       (if verbose (message "Loading %s font lock cache..." (buffer-name)))
 596       (condition-case nil
 597           (fast-lock-set-face-properties properties)
 598         (error (setq loaded 'error)) (quit (setq loaded 'quit)))
 599       (if verbose (message "Loading %s font lock cache...%s" (buffer-name)
 600                            (cond ((eq loaded 'error) "failed")
 601                                  ((eq loaded 'quit) "aborted")
 602                                  (t "done")))))
 603     (setq font-lock-fontified (eq loaded t)
 604           fast-lock-cache-timestamp (and (eq loaded t) timestamp))))
 605 \f
 606 ;; Text Properties Processing Functions:
 607
 608 ;; This is fast, but fails if adjacent characters have different `face' text
 609 ;; properties.  Maybe that's why I dropped it in the first place?
 610 ;(defun fast-lock-get-face-properties ()
 611 ;  "Return a list of all `face' text properties in the current buffer.
 612 ;Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
 613 ;where VALUE is a `face' property value and STARTx and ENDx are positions."
 614 ;  (save-restriction
 615 ;    (widen)
 616 ;    (let ((start (text-property-not-all (point-min) (point-max) 'face nil))
 617 ;         (limit (point-max)) end properties value cell)
 618 ;      (while start
 619 ;       (setq end (next-single-property-change start 'face nil limit)
 620 ;             value (get-text-property start 'face))
 621 ;       ;; Make, or add to existing, list of regions with same `face'.
 622 ;       (if (setq cell (assq value properties))
 623 ;           (setcdr cell (cons start (cons end (cdr cell))))
 624 ;         (setq properties (cons (list value start end) properties)))
 625 ;       (setq start (next-single-property-change end 'face)))
 626 ;      properties)))
 627
 628 ;; This is slow, but copes if adjacent characters have different `face' text
 629 ;; properties, but fails if they are lists.
 630 ;(defun fast-lock-get-face-properties ()
 631 ;  "Return a list of all `face' text properties in the current buffer.
 632 ;Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
 633 ;where VALUE is a `face' property value and STARTx and ENDx are positions.
 634 ;Only those `face' VALUEs in `fast-lock-save-faces' are returned."
 635 ;  (save-restriction
 636 ;    (widen)
 637 ;    (let ((faces (or fast-lock-save-faces (face-list))) (limit (point-max))
 638 ;         properties regions face start end)
 639 ;      (while faces
 640 ;       (setq face (car faces) faces (cdr faces) regions () end (point-min))
 641 ;       ;; Make a list of start/end regions with `face' property face.
 642 ;       (while (setq start (text-property-any end limit 'face face))
 643 ;         (setq end (or (text-property-not-all start limit 'face face) limit)
 644 ;               regions (cons start (cons end regions))))
 645 ;       ;; Add `face' face's regions, if any, to properties.
 646 ;       (when regions
 647 ;         (push (cons face regions) properties)))
 648 ;      properties)))
 649
 650 (defun fast-lock-get-face-properties ()
 651   "Return a list of all `face' text properties in the current buffer.
 652 Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
 653 where VALUE is a `face' property value and STARTx and ENDx are positions."
 654   (save-restriction
 655     (widen)
 656     (let ((start (text-property-not-all (point-min) (point-max) 'face nil))
 657           end properties value cell)
 658       (while start
 659         (setq end (next-single-property-change start 'face nil (point-max))
 660               value (get-text-property start 'face))
 661         ;; Make, or add to existing, list of regions with same `face'.
 662         (cond ((setq cell (assoc value properties))
 663                (setcdr cell (cons start (cons end (cdr cell)))))
 664               ((fast-lock-save-facep value)
 665                (push (list value start end) properties)))
 666         (setq start (text-property-not-all end (point-max) 'face nil)))
 667       properties)))
 668
 669 (defun fast-lock-set-face-properties (properties)
 670   "Set all `face' text properties to PROPERTIES in the current buffer.
 671 Any existing `face' text properties are removed first.
 672 See `fast-lock-get-face-properties' for the format of PROPERTIES."
 673   (save-buffer-state (plist regions)
 674     (save-restriction
 675       (widen)
 676       (font-lock-unfontify-region (point-min) (point-max))
 677       (while properties
 678         (setq plist (list 'face (car (car properties)))
 679               regions (cdr (car properties))
 680               properties (cdr properties))
 681         ;; Set the `face' property for each start/end region.
 682         (while regions
 683           (set-text-properties (nth 0 regions) (nth 1 regions) plist)
 684           (setq regions (nthcdr 2 regions)))))))
 685 \f
 686 ;; Functions for XEmacs:
 687
 688 (when (save-match-data (string-match "XEmacs" (emacs-version)))
 689   ;;
 690   ;; It would be better to use XEmacs' `map-extents' over extents with a
 691   ;; `font-lock' property, but `face' properties are on different extents.
 692   (defun fast-lock-get-face-properties ()
 693     "Return a list of all `face' text properties in the current buffer.
 694 Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
 695 where VALUE is a `face' property value and STARTx and ENDx are positions.
 696 Only those `face' VALUEs in `fast-lock-save-faces' are returned."
 697     (save-restriction
 698       (widen)
 699       (let ((properties ()) cell)
 700         (map-extents
 701          (function (lambda (extent ignore)
 702             (let ((value (extent-face extent)))
 703               ;; We're only interested if it's one of `fast-lock-save-faces'.
 704               (when (and value (fast-lock-save-facep value))
 705                 (let ((start (extent-start-position extent))
 706                       (end (extent-end-position extent)))
 707                   ;; Make or add to existing list of regions with the same
 708                   ;; `face' property value.
 709                   (if (setq cell (assoc value properties))
 710                       (setcdr cell (cons start (cons end (cdr cell))))
 711                     (push (list value start end) properties))))
 712               ;; Return nil to keep `map-extents' going.
 713               nil))))
 714         properties)))
 715   ;;
 716   ;; Make extents just like XEmacs' font-lock.el does.
 717   (defun fast-lock-set-face-properties (properties)
 718     "Set all `face' text properties to PROPERTIES in the current buffer.
 719 Any existing `face' text properties are removed first.
 720 See `fast-lock-get-face-properties' for the format of PROPERTIES."
 721     (save-restriction
 722       (widen)
 723       (font-lock-unfontify-region (point-min) (point-max))
 724       (while properties
 725         (let ((face (car (car properties)))
 726               (regions (cdr (car properties))))
 727           ;; Set the `face' property, etc., for each start/end region.
 728           (while regions
 729             (font-lock-set-face (nth 0 regions) (nth 1 regions) face)
 730             (setq regions (nthcdr 2 regions)))
 731           (setq properties (cdr properties))))))
 732   ;;
 733   ;; XEmacs 19.12 font-lock.el's `font-lock-fontify-buffer' runs a hook.
 734   (add-hook 'font-lock-after-fontify-buffer-hook
 735             'fast-lock-after-fontify-buffer))
 736
 737 (unless (boundp 'font-lock-inhibit-thing-lock)
 738   (defvar font-lock-inhibit-thing-lock nil
 739     "List of Font Lock mode related modes that should not be turned on."))
 740
 741 (unless (fboundp 'font-lock-value-in-major-mode)
 742   (defun font-lock-value-in-major-mode (alist)
 743     ;; Return value in ALIST for `major-mode'.
 744     (if (consp alist)
 745         (cdr (or (assq major-mode alist) (assq t alist)))
 746       alist)))
 747
 748 (unless (fboundp 'font-lock-compile-keywords)
 749   (defalias 'font-lock-compile-keywords 'identity))
 750 \f
 751 ;; Install ourselves:
 752
 753 (add-hook 'after-save-hook 'fast-lock-save-cache-after-save-file)
 754 (add-hook 'kill-buffer-hook 'fast-lock-save-cache-before-kill-buffer)
 755 (add-hook 'kill-emacs-hook 'fast-lock-save-caches-before-kill-emacs)
 756
 757 ;;;###autoload
 758 (when (fboundp 'add-minor-mode)
 759   (defvar fast-lock-mode nil)
 760   (add-minor-mode 'fast-lock-mode nil))
 761 ;;;###dont-autoload
 762 (unless (assq 'fast-lock-mode minor-mode-alist)
 763   (setq minor-mode-alist (append minor-mode-alist '((fast-lock-mode nil)))))
 764
 765 ;; Provide ourselves:
 766
 767 (provide 'fast-lock)
 768
 769 ;;; fast-lock.el ends here