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, 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 ;; Lazy 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 \f
  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 \f
 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 \f
 257 ;; User Variables:
 258
 259 (defcustom fast-lock-minimum-size 25600
 260   "*Minimum size of a buffer for cached fontification.
 261 Only buffers more than this can have associated Font Lock cache files saved.
 262 If nil, means cache files are never created.
 263 If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
 264 where MAJOR-MODE is a symbol or t (meaning the default).  For example:
 265  ((c-mode . 25600) (c++-mode . 25600) (rmail-mode . 1048576))
 266 means that the minimum size is 25K for buffers in C or C++ modes, one megabyte
 267 for 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.
 285 Each item should be either DIR or a cons pair of the form (REGEXP . DIR) where
 286 DIR is a directory name (relative or absolute) and REGEXP is a regexp.
 287
 288 An attempt will be made to save or read Font Lock cache files using these items
 289 until one succeeds (i.e., until a readable or writable one is found).  If an
 290 item contains REGEXP, DIR is used only if the buffer file name matches REGEXP.
 291 For 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
 298 would cause a file's current directory to be used if the file is under your
 299 home 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.
 308 Valid events are `save-buffer', `kill-buffer' and `kill-emacs'.
 309 If concurrent editing sessions use the same associated cache file for a file's
 310 buffer, 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.
 318 If nil, means only buffer files known to be owned by you can have associated
 319 Font 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.
 325 If 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.
 336 If nil, means information for all faces will be saved.")
 337 \f
 338 ;; User Functions:
 339
 340 ;;;###autoload
 341 (defun fast-lock-mode (&optional arg)
 342   "Toggle Fast Lock mode.
 343 With arg, turn Fast Lock mode on if and only if arg is positive and the buffer
 344 is associated with a file.  Enable it automatically in your `~/.emacs' by:
 345
 346  (setq font-lock-support-mode 'fast-lock-mode)
 347
 348 If Fast Lock mode is enabled, and the current buffer does not contain any text
 349 properties, any associated Font Lock cache is used if its timestamp matches the
 350 buffer's file, and its `font-lock-keywords' match those that you are using.
 351
 352 Font 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.
 356 Depending on the value of `fast-lock-save-events'.
 357 See also the commands `fast-lock-read-cache' and `fast-lock-save-cache'.
 358
 359 Use \\[font-lock-fontify-buffer] to fontify the buffer if the cache is bad.
 360
 361 Various methods of control are provided for the Font Lock cache.  In general,
 362 see variable `fast-lock-cache-directories' and function `fast-lock-cache-name'.
 363 For 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
 385 The 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
 392 See `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
 418 The 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
 429 See `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 \f
 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 \f
 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.
 506 Returns nil if the directory does not exist, or, if CREATE non-nil, cannot be
 507 created.  DIRECTORY may be a string or a cons pair of the form (REGEXP . DIR).
 508 See `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 path name using caching DIRECTORY.
 538 If DIRECTORY is `.', the path is the buffer file name appended with `.flc'.
 539 Otherwise, the path name is constructed from DIRECTORY and the buffer's true
 540 abbreviated file name, with all `/' characters in the name replaced with `#'
 541 characters, and appended with `.flc'.
 542
 543 If the same file has different cache path names when edited on different
 544 machines, e.g., on one machine the cache file name has the prefix `#home',
 545 perhaps due to automount, try putting in your `~/.emacs' something like:
 546
 547  (setq directory-abbrev-alist (cons '(\"^/home/\" . \"/\") directory-abbrev-alist))
 548
 549 Emacs automagically removes the common `/tmp_mnt' automount prefix by default.
 550
 551 See `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))
 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 \f
 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 \f
 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.
 697 Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
 698 where 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.
 716 See `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.
 735 Any existing `syntax-table' and `face' text properties are removed first.
 736 See `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 \f
 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.
 768 Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
 769 where VALUE is a `face' property value and STARTx and ENDx are positions.
 770 Only 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.
 797 Any existing `face' text properties are removed first.
 798 See `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 \f
 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 ;;; fast-lock.el ends here