lisp/fast-lock.el

   1 ;;; fast-lock.el --- Automagic text properties caching for fast Font Lock mode.
   2
   3 ;; Copyright (C) 1994, 1995 Free Software Foundation, Inc.
   4
   5 ;; Author: Simon Marshall <simon@gnu.ai.mit.edu>
   6 ;; Keywords: faces files
   7 ;; Version: 3.06
   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
  23 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  24
  25 ;;; Commentary:
  26
  27 ;; Purpose:
  28 ;;
  29 ;; To make visiting a file in `font-lock-mode' faster by restoring its face
  30 ;; text 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 ;; (add-hook 'font-lock-mode-hook 'turn-on-fast-lock)
  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
  56 ;; Feedback:
  57 ;;
  58 ;; Feedback is welcome.
  59 ;; To submit a bug report (or make comments) please use the mechanism provided:
  60 ;;
  61 ;; M-x fast-lock-submit-bug-report RET
  62 \f
  63 (require 'font-lock)
  64
  65 (eval-when-compile
  66   ;; Shut Emacs' byte-compiler up (cf. stop me getting mail from users).
  67   (setq byte-compile-warnings '(free-vars callargs redefine)))
  68
  69 (defun fast-lock-submit-bug-report ()
  70   "Submit via mail a bug report on fast-lock.el."
  71   (interactive)
  72   (let ((reporter-prompt-for-summary-p t))
  73     (reporter-submit-bug-report "simon@gnu.ai.mit.edu" "fast-lock 3.06"
  74      '(fast-lock-cache-directories fast-lock-minimum-size
  75        fast-lock-save-others fast-lock-save-events fast-lock-save-faces)
  76      nil nil
  77      (concat "Hi Si.,
  78
  79 I want to report a bug.  I've read the `Bugs' section of `Info' on Emacs, so I
  80 know how to make a clear and unambiguous report.  To reproduce the bug:
  81
  82 Start a fresh Emacs via `" invocation-name " -no-init-file -no-site-file'.
  83 In the `*scratch*' buffer, evaluate:"))))
  84
  85 ;;;###autoload
  86 (defvar fast-lock-mode nil)             ; for modeline
  87 (defvar fast-lock-cache-timestamp nil)  ; for saving/reading
  88 (defvar fast-lock-cache-filename nil)   ; for deleting
  89 \f
  90 ;; User Variables:
  91
  92 (defvar fast-lock-cache-directories '("." "~/.emacs-flc")
  93 ; - `internal', keep each file's Font Lock cache file in the same file.
  94 ; - `external', keep each file's Font Lock cache file in the same directory.
  95   "Directories in which Font Lock cache files are saved and read.
  96 Each item should be either DIR or a cons pair of the form (REGEXP . DIR) where
  97 DIR is a directory name (relative or absolute) and REGEXP is a regexp.
  98
  99 An attempt will be made to save or read Font Lock cache files using these items
 100 until one succeeds (i.e., until a readable or writable one is found).  If an
 101 item contains REGEXP, DIR is used only if the buffer file name matches REGEXP.
 102 For example:
 103
 104  (list (cons (concat \"^\" (regexp-quote (expand-file-name \"~\"))) \".\")
 105        \"~/.emacs-flc\")
 106
 107 would cause a file's current directory to be used if the file is under your
 108 home directory hierarchy, or otherwise the absolute directory `~/.emacs-flc'.")
 109
 110 (defvar fast-lock-minimum-size (* 25 1024)
 111   "If non-nil, the minimum size for buffers.
 112 Only buffers more than this can have associated Font Lock cache files saved.
 113 If nil, means size is irrelevant.")
 114
 115 (defvar fast-lock-save-events '(kill-buffer kill-emacs)
 116   "A list of events under which caches will be saved.
 117 Valid events are `save-buffer', `kill-buffer' and `kill-emacs'.
 118 If concurrent editing sessions use the same associated cache file for a file's
 119 buffer, then you should add `save-buffer' to this list.")
 120
 121 (defvar fast-lock-save-others t
 122   "If non-nil, save Font Lock cache files irrespective of file owner.
 123 If nil, means only buffer files known to be owned by you can have associated
 124 Font Lock cache files saved.  Ownership may be unknown for networked files.")
 125
 126 (defvar fast-lock-save-faces
 127   ;; Since XEmacs uses extents for everything, we have to pick the right ones.
 128   ;; In XEmacs 19.12 we can't identify which text properties are font-lock's.
 129   (if (save-match-data (string-match "XEmacs" (emacs-version)))
 130       '(font-lock-string-face font-lock-doc-string-face font-lock-type-face
 131         font-lock-function-name-face font-lock-comment-face
 132         font-lock-keyword-face)
 133     ;; For Emacs 19.29 I don't think this is generally necessary.
 134     ;(mapcar 'eval (mapcar 'car font-lock-face-attributes))
 135     )
 136   "A list of faces that will be saved in a Font Lock cache file.
 137 If nil, means information for all faces will be saved.")
 138 \f
 139 ;; User Functions:
 140
 141 ;;;###autoload
 142 (defun fast-lock-mode (&optional arg)
 143   "Toggle Fast Lock mode.
 144 With arg, turn Fast Lock mode on if and only if arg is positive and the buffer
 145 is associated with a file.  Enable it automatically in your `~/.emacs' by:
 146
 147  (add-hook 'font-lock-mode-hook 'turn-on-fast-lock)
 148
 149 If Fast Lock mode is enabled, and the current buffer does not contain any text
 150 properties, any associated Font Lock cache is used if its timestamp matches the
 151 buffer's file, and its `font-lock-keywords' match those that you are using.
 152
 153 Font Lock caches may be saved:
 154  - When you save the file's buffer.
 155  - When you kill an unmodified file's buffer.
 156  - When you exit Emacs, for all unmodified or saved buffers.
 157 Depending on the value of `fast-lock-save-events'.
 158 See also the commands `fast-lock-read-cache' and `fast-lock-save-cache'.
 159
 160 Use \\[font-lock-fontify-buffer] to fontify the buffer if the cache is bad.
 161
 162 Various methods of control are provided for the Font Lock cache.  In general,
 163 see variable `fast-lock-cache-directories' and function `fast-lock-cache-name'.
 164 For saving, see variables `fast-lock-minimum-size', `fast-lock-save-events',
 165 `fast-lock-save-others' and `fast-lock-save-faces'.
 166
 167 Use \\[fast-lock-submit-bug-report] to send bug reports or feedback."
 168   (interactive "P")
 169   (set (make-local-variable 'fast-lock-mode)
 170        (and (buffer-file-name)
 171             (if arg (> (prefix-numeric-value arg) 0) (not fast-lock-mode))))
 172   (if (and fast-lock-mode (not font-lock-mode))
 173       ;; Turned on `fast-lock-mode' rather than using `font-lock-mode-hook'.
 174       (progn
 175         (add-hook 'font-lock-mode-hook 'turn-on-fast-lock)
 176         (font-lock-mode 1))
 177     ;; Let's get down to business.
 178     (set (make-local-variable 'fast-lock-cache-timestamp) nil)
 179     (set (make-local-variable 'fast-lock-cache-filename) nil)
 180     (if (and fast-lock-mode (not font-lock-fontified))
 181         (fast-lock-read-cache))))
 182
 183 (defun fast-lock-read-cache ()
 184   "Read the Font Lock cache for the current buffer.
 185
 186 The following criteria must be met for a Font Lock cache file to be read:
 187  - Fast Lock mode must be turned on in the buffer.
 188  - The buffer must not be modified.
 189  - The buffer's `font-lock-keywords' must match the cache's.
 190  - The buffer file's timestamp must match the cache's.
 191  - Criteria imposed by `fast-lock-cache-directories'.
 192
 193 See `fast-lock-mode'."
 194   (interactive)
 195   (let ((directories fast-lock-cache-directories)
 196         (modified (buffer-modified-p)) (inhibit-read-only t)
 197         (fontified font-lock-fontified))
 198     (setq fast-lock-cache-filename nil)
 199     (set (make-local-variable 'font-lock-fontified) nil)
 200     ;; Keep trying directories until fontification is turned off.
 201     (while (and directories (not font-lock-fontified))
 202       (let* ((directory (fast-lock-cache-directory (car directories) nil))
 203              (file (and directory (fast-lock-cache-name directory))))
 204         (condition-case nil
 205             (and file (file-readable-p file) (load file t t t))
 206           (error nil) (quit nil))
 207         (setq directories (cdr directories))))
 208     (set-buffer-modified-p modified)
 209     (or font-lock-fontified (setq font-lock-fontified fontified))))
 210
 211 (defun fast-lock-save-cache (&optional buffer)
 212   "Save the Font Lock cache of BUFFER or the current buffer.
 213
 214 The following criteria must be met for a Font Lock cache file to be saved:
 215  - Fast Lock mode must be turned on in the buffer.
 216  - The event must be one of `fast-lock-save-events'.
 217  - The buffer must be at least `fast-lock-minimum-size' bytes long.
 218  - The buffer file must be owned by you, or `fast-lock-save-others' must be t.
 219  - The buffer must contain at least one `face' text property.
 220  - The buffer must not be modified.
 221  - The buffer file's timestamp must be the same as the file's on disk.
 222  - The on disk file's timestamp must be different than the buffer's cache.
 223  - Criteria imposed by `fast-lock-cache-directories'.
 224
 225 See `fast-lock-mode'."
 226   (interactive)
 227   (save-excursion
 228     (and buffer (set-buffer buffer))
 229     (let ((file-timestamp (visited-file-modtime)) (saved nil))
 230       (if (and fast-lock-mode
 231                ;;
 232                ;; "Only save if the buffer matches the file, the file has
 233                ;; changed, and it was changed by the current emacs session."
 234                ;;
 235                ;; Only save if the buffer is not modified,
 236                ;; (i.e., so we don't save for something not on disk)
 237                (not (buffer-modified-p))
 238                ;; and the file's timestamp is the same as the buffer's,
 239                ;; (i.e., someone else hasn't written the file in the meantime)
 240                (verify-visited-file-modtime (current-buffer))
 241                ;; and the file's timestamp is different from the cache's.
 242                ;; (i.e., a save has occurred since the cache was read)
 243                (not (equal fast-lock-cache-timestamp file-timestamp))
 244                ;;
 245                ;; Only save if user's restrictions are satisfied.
 246                (or (not fast-lock-minimum-size)
 247                    (<= fast-lock-minimum-size (buffer-size)))
 248                (or fast-lock-save-others
 249                    (eq (user-uid) (nth 2 (file-attributes buffer-file-name))))
 250                ;;
 251                ;; Only save if there are `face' properties to save.
 252                (text-property-not-all (point-min) (point-max) 'face nil))
 253           ;; Try each directory until we manage to save or the user quits.
 254           (let ((directories fast-lock-cache-directories))
 255             (while (and directories (memq saved '(nil error)))
 256               (let* ((dir (fast-lock-cache-directory (car directories) t))
 257                      (file (and dir (fast-lock-cache-name dir))))
 258                 (if (and file (file-writable-p file))
 259                     (setq saved (fast-lock-save-cache-1 file file-timestamp)))
 260                 (setq directories (cdr directories)))))))))
 261
 262 ;;;###autoload
 263 (defun turn-on-fast-lock ()
 264   "Unconditionally turn on Fast Lock mode."
 265   (fast-lock-mode 1))
 266 \f
 267 ;;; API Functions:
 268
 269 (defun fast-lock-after-fontify-buffer ()
 270   ;; Delete the Font Lock cache file used to restore fontification, if any.
 271   (if fast-lock-cache-filename
 272       (if (file-writable-p fast-lock-cache-filename)
 273           (delete-file fast-lock-cache-filename)
 274         (message "File %s font lock cache cannot be deleted" (buffer-name))))
 275   ;; Flag so that a cache will be saved later even if the file is never saved.
 276   (setq fast-lock-cache-timestamp nil))
 277 \f
 278 ;; Miscellaneous Functions:
 279
 280 (defun fast-lock-after-save-hook ()
 281   ;; Do `fast-lock-save-cache' if `save-buffer' is on `fast-lock-save-events'.
 282   (if (memq 'save-buffer fast-lock-save-events)
 283       (fast-lock-save-cache)))
 284
 285 (defun fast-lock-kill-buffer-hook ()
 286   ;; Do `fast-lock-save-cache' if `kill-buffer' is on `fast-lock-save-events'.
 287   (if (memq 'kill-buffer fast-lock-save-events)
 288       (fast-lock-save-cache)))
 289
 290 (defun fast-lock-kill-emacs-hook ()
 291   ;; Do `fast-lock-save-cache's if `kill-emacs' is on `fast-lock-save-events'.
 292   (if (memq 'kill-emacs fast-lock-save-events)
 293       (mapcar 'fast-lock-save-cache (buffer-list))))
 294
 295 (defun fast-lock-cache-directory (directory create)
 296   "Return usable directory based on DIRECTORY.
 297 Returns nil if the directory does not exist, or, if CREATE non-nil, cannot be
 298 created.  DIRECTORY may be a string or a cons pair of the form (REGEXP . DIR).
 299 See `fast-lock-cache-directories'."
 300   (let ((dir
 301          (cond ((not buffer-file-name)
 302                 ;; Should never be nil, but `crypt++' screws it up.
 303                 nil)
 304                ((stringp directory)
 305                 ;; Just a directory.
 306                 directory)
 307                (t
 308                 ;; A directory iff the file name matches the regexp.
 309                 (let ((bufile (expand-file-name buffer-file-truename))
 310                       (case-fold-search nil))
 311                   (if (save-match-data (string-match (car directory) bufile))
 312                       (cdr directory)))))))
 313     (cond ((not dir)
 314            nil)
 315           ((file-accessible-directory-p dir)
 316            dir)
 317           (create
 318            (condition-case nil
 319                (progn (make-directory dir t) dir)
 320              (error nil))))))
 321
 322 (defun fast-lock-cache-name (directory)
 323   "Return full cache path name using caching DIRECTORY.
 324 If DIRECTORY is `.', the path is the buffer file name appended with `.flc'.
 325 Otherwise, the path name is constructed from DIRECTORY and the buffer's true
 326 abbreviated file name, with all `/' characters in the name replaced with `#'
 327 characters, and appended with `.flc'.
 328
 329 See `fast-lock-mode'."
 330   (if (string-equal directory ".")
 331       (concat buffer-file-name ".flc")
 332     (let* ((bufile (expand-file-name buffer-file-truename))
 333            (chars-alist
 334             (if (eq system-type 'emx)
 335                 '((?/ . (?#)) (?# . (?# ?#)) (?: . (?\;)) (?\; . (?\; ?\;)))
 336               '((?/ . (?#)) (?# . (?# ?#)))))
 337            (mapchars
 338             (function (lambda (c) (or (cdr (assq c chars-alist)) (list c))))))
 339       (concat
 340        (file-name-as-directory (expand-file-name directory))
 341        (mapconcat 'char-to-string (apply 'append (mapcar mapchars bufile)) "")
 342        ".flc"))))
 343 \f
 344 ;; Font Lock Cache Processing Functions:
 345
 346 (defun fast-lock-save-cache-1 (file timestamp)
 347   ;; Save the FILE with the TIMESTAMP as:
 348   ;; (fast-lock-cache-data Version=2 TIMESTAMP font-lock-keywords PROPERTIES).
 349   ;; Returns non-nil if a save was attempted to a writable cache file.
 350   (let ((tpbuf (generate-new-buffer " *fast-lock*"))
 351         (buname (buffer-name)) (saved t))
 352     (message "Saving %s font lock cache..." buname)
 353     (condition-case nil
 354         (save-excursion
 355           (print (list 'fast-lock-cache-data 2
 356                        (list 'quote timestamp)
 357                        (list 'quote font-lock-keywords)
 358                        (list 'quote (fast-lock-get-face-properties)))
 359                  tpbuf)
 360           (set-buffer tpbuf)
 361           (write-region (point-min) (point-max) file nil 'quietly)
 362           (setq fast-lock-cache-timestamp timestamp
 363                 fast-lock-cache-filename file))
 364       (error (setq saved 'error)) (quit (setq saved 'quit)))
 365     (kill-buffer tpbuf)
 366     (message "Saving %s font lock cache... %s." buname
 367              (cond ((eq saved 'error) "failed")
 368                    ((eq saved 'quit) "aborted")
 369                    (t "done")))
 370     ;; We return non-nil regardless of whether a failure occurred.
 371     saved))
 372
 373 (defun fast-lock-cache-data (version timestamp keywords properties
 374                              &rest ignored)
 375   ;; Change from (HIGH LOW) for back compatibility.  Remove for version 3!
 376   (if (consp (cdr-safe timestamp)) (setcdr timestamp (nth 1 timestamp)))
 377   ;; Compile KEYWORDS and `font-lock-keywords' in case one is and one isn't.
 378   (let ((current font-lock-keywords))
 379     (setq keywords (font-lock-compile-keywords keywords)
 380           font-lock-keywords (font-lock-compile-keywords current)))
 381   ;; Use the Font Lock cache PROPERTIES if we're using cache VERSION format 2,
 382   ;; the current buffer's file timestamp matches the TIMESTAMP, and the current
 383   ;; buffer's font-lock-keywords are the same as KEYWORDS.
 384   (let ((buf-timestamp (visited-file-modtime))
 385         (buname (buffer-name)) (loaded t))
 386     (if (or (/= version 2)
 387             (buffer-modified-p)
 388             (not (equal timestamp buf-timestamp))
 389             (not (equal keywords font-lock-keywords)))
 390         (setq loaded nil)
 391       (message "Loading %s font lock cache..." buname)
 392       (condition-case nil
 393           (fast-lock-set-face-properties properties)
 394         (error (setq loaded 'error)) (quit (setq loaded 'quit)))
 395       (message "Loading %s font lock cache... %s." buname
 396                (cond ((eq loaded 'error) "failed")
 397                      ((eq loaded 'quit) "aborted")
 398                      (t "done"))))
 399     ;; If we used the text properties, stop fontification and keep timestamp.
 400     ;; Kludge warning: `file' comes from sole caller `fast-lock-read-cache'.
 401     (setq font-lock-fontified (eq loaded t)
 402           fast-lock-cache-timestamp (and (eq loaded t) timestamp)
 403           fast-lock-cache-filename (and (eq loaded t) file))))
 404 \f
 405 ;; Text Properties Processing Functions:
 406
 407 ;; This is faster, but fails if adjacent characters have different `face' text
 408 ;; properties.  Maybe that's why I dropped it in the first place?
 409 ;(defun fast-lock-get-face-properties ()
 410 ;  "Return a list of all `face' text properties in the current buffer.
 411 ;Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
 412 ;where VALUE is a `face' property value and STARTx and ENDx are positions."
 413 ;  (save-restriction
 414 ;    (widen)
 415 ;    (let ((start (text-property-not-all (point-min) (point-max) 'face nil))
 416 ;         (limit (point-max)) end properties value cell)
 417 ;      (while start
 418 ;       (setq end (next-single-property-change start 'face nil limit)
 419 ;             value (get-text-property start 'face))
 420 ;       ;; Make, or add to existing, list of regions with same `face'.
 421 ;       (if (setq cell (assq value properties))
 422 ;           (setcdr cell (cons start (cons end (cdr cell))))
 423 ;         (setq properties (cons (list value start end) properties)))
 424 ;       (setq start (next-single-property-change end 'face)))
 425 ;      properties)))
 426
 427 (defun fast-lock-get-face-properties ()
 428   "Return a list of all `face' text properties in the current buffer.
 429 Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
 430 where VALUE is a `face' property value and STARTx and ENDx are positions.
 431 Only those `face' VALUEs in `fast-lock-save-faces' are returned."
 432   (save-restriction
 433     (widen)
 434     (let ((faces (or fast-lock-save-faces (face-list))) (limit (point-max))
 435           properties regions face start end)
 436       (while faces
 437         (setq face (car faces) faces (cdr faces) regions () end (point-min))
 438         ;; Make a list of start/end regions with `face' property face.
 439         (while (setq start (text-property-any end limit 'face face))
 440           (setq end (or (text-property-not-all start limit 'face face) limit)
 441                 regions (cons start (cons end regions))))
 442         ;; Add `face' face's regions, if any, to properties.
 443         (if regions (setq properties (cons (cons face regions) properties))))
 444       properties)))
 445
 446 (defun fast-lock-set-face-properties (properties)
 447   "Set all `face' text properties to PROPERTIES in the current buffer.
 448 Any existing `face' text properties are removed first.  Leaves buffer modified.
 449 See `fast-lock-get-face-properties' for the format of PROPERTIES."
 450   (save-restriction
 451     (widen)
 452     (font-lock-unfontify-region (point-min) (point-max))
 453     (while properties
 454       (let ((plist (list 'face (car (car properties))))
 455             (regions (cdr (car properties))))
 456         ;; Set the `face' property for each start/end region.
 457         (while regions
 458           (set-text-properties (nth 0 regions) (nth 1 regions) plist)
 459           (setq regions (nthcdr 2 regions)))
 460         (setq properties (cdr properties))))))
 461 \f
 462 ;; Functions for XEmacs:
 463
 464 (if (save-match-data (string-match "XEmacs" (emacs-version)))
 465     ;; It would be better to use XEmacs 19.12's `map-extents' over extents with
 466     ;; `font-lock' property, but `face' properties are on different extents.
 467     (defun fast-lock-get-face-properties ()
 468       "Return a list of all `face' text properties in the current buffer.
 469 Each element of the list is of the form (VALUE START1 END1 START2 END2 ...)
 470 where VALUE is a `face' property value and STARTx and ENDx are positions.
 471 Only those `face' VALUEs in `fast-lock-save-faces' are returned."
 472       (save-restriction
 473         (widen)
 474         (let ((properties ()) cell)
 475           (map-extents
 476            (function
 477             (lambda (extent ignore)
 478               (let ((value (extent-face extent)))
 479                 ;; We're only interested if it's one of `fast-lock-save-faces'.
 480                 (if (and value (or (null fast-lock-save-faces)
 481                                    (memq value fast-lock-save-faces)))
 482                     (let ((start (extent-start-position extent))
 483                           (end (extent-end-position extent)))
 484                       ;; Make or add to existing list of regions with the same
 485                       ;; `face' property value.
 486                       (if (setq cell (assq value properties))
 487                           (setcdr cell (cons start (cons end (cdr cell))))
 488                         (setq properties (cons (list value start end)
 489                                                properties)))))
 490                 ;; Return nil to keep `map-extents' going.
 491                 nil))))
 492           properties))))
 493
 494 (if (save-match-data (string-match "XEmacs" (emacs-version)))
 495     ;; Make extents just like XEmacs's font-lock.el does.
 496     (defun fast-lock-set-face-properties (properties)
 497       "Set all `face' text properties to PROPERTIES in the current buffer.
 498 Any existing `face' text properties are removed first.
 499 See `fast-lock-get-face-properties' for the format of PROPERTIES."
 500       (save-restriction
 501         (widen)
 502         (font-lock-unfontify-region (point-min) (point-max))
 503         (while properties
 504           (let ((face (car (car properties)))
 505                 (regions (cdr (car properties))))
 506             ;; Set the `face' property, etc., for each start/end region.
 507             (while regions
 508               (font-lock-set-face (nth 0 regions) (nth 1 regions) face)
 509               (setq regions (nthcdr 2 regions)))
 510             (setq properties (cdr properties)))))))
 511
 512 (or (fboundp 'font-lock-compile-keywords)
 513     (defalias 'font-lock-compile-keywords 'identity))
 514 \f
 515 ;; Install ourselves:
 516
 517 ;; We don't install ourselves on `font-lock-mode-hook' as packages with similar
 518 ;; functionality exist, and fast-lock.el should be dumpable.
 519 (add-hook 'after-save-hook 'fast-lock-after-save-hook)
 520 (add-hook 'kill-buffer-hook 'fast-lock-kill-buffer-hook)
 521 (add-hook 'kill-emacs-hook 'fast-lock-kill-emacs-hook)
 522
 523 ;; Maybe save on the modeline?
 524 ;;(setcdr (assq 'font-lock-mode minor-mode-alist) '(" Fast"))
 525
 526 (or (assq 'fast-lock-mode minor-mode-alist)
 527     (setq minor-mode-alist (cons '(fast-lock-mode " Fast") minor-mode-alist)))
 528
 529 ;; Provide ourselves:
 530
 531 (provide 'fast-lock)
 532
 533 ;;; fast-lock.el ends here