lisp/jit-lock.el

   1 ;;; jit-lock.el --- just-in-time fontification
   2
   3 ;; Copyright (C) 1998, 2000, 2001, 2002, 2003, 2004,
   4 ;;   2005, 2006 Free Software Foundation, Inc.
   5
   6 ;; Author: Gerd Moellmann <gerd@gnu.org>
   7 ;; Keywords: faces files
   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., 51 Franklin Street, Fifth Floor,
  24 ;; Boston, MA 02110-1301, USA.
  25
  26 ;;; Commentary:
  27
  28 ;; Just-in-time fontification, triggered by C redisplay code.
  29
  30 ;;; Code:
  31
  32
  33 (eval-when-compile
  34   (defmacro with-buffer-unmodified (&rest body)
  35     "Eval BODY, preserving the current buffer's modified state."
  36     (declare (debug t))
  37     (let ((modified (make-symbol "modified")))
  38       `(let ((,modified (buffer-modified-p)))
  39          (unwind-protect
  40              (progn ,@body)
  41            (unless ,modified
  42              (restore-buffer-modified-p nil))))))
  43
  44   (defmacro with-buffer-prepared-for-jit-lock (&rest body)
  45     "Execute BODY in current buffer, overriding several variables.
  46 Preserves the `buffer-modified-p' state of the current buffer."
  47     (declare (debug t))
  48     `(with-buffer-unmodified
  49       (let ((buffer-undo-list t)
  50             (inhibit-read-only t)
  51             (inhibit-point-motion-hooks t)
  52             (inhibit-modification-hooks t)
  53             deactivate-mark
  54             buffer-file-name
  55             buffer-file-truename)
  56         ,@body))))
  57
  58
  59 \f
  60 ;;; Customization.
  61
  62 (defgroup jit-lock nil
  63   "Font Lock support mode to fontify just-in-time."
  64   :version "21.1"
  65   :group 'font-lock)
  66
  67 (defcustom jit-lock-chunk-size 500
  68   "*Jit-lock fontifies chunks of at most this many characters at a time.
  69
  70 This variable controls both display-time and stealth fontification."
  71   :type 'integer
  72   :group 'jit-lock)
  73
  74
  75 (defcustom jit-lock-stealth-time 16
  76   "*Time in seconds to wait before beginning stealth fontification.
  77 Stealth fontification occurs if there is no input within this time.
  78 If nil, stealth fontification is never performed.
  79
  80 The value of this variable is used when JIT Lock mode is turned on."
  81   :type '(choice (const :tag "never" nil)
  82                  (number :tag "seconds"))
  83   :group 'jit-lock)
  84
  85
  86 (defcustom jit-lock-stealth-nice 0.5
  87   "*Time in seconds to pause between chunks of stealth fontification.
  88 Each iteration of stealth fontification is separated by this amount of time,
  89 thus reducing the demand that stealth fontification makes on the system.
  90 If nil, means stealth fontification is never paused.
  91 To reduce machine load during stealth fontification, at the cost of stealth
  92 taking longer to fontify, you could increase the value of this variable.
  93 See also `jit-lock-stealth-load'."
  94   :type '(choice (const :tag "never" nil)
  95                  (number :tag "seconds"))
  96   :group 'jit-lock)
  97
  98
  99 (defcustom jit-lock-stealth-load
 100   (if (condition-case nil (load-average) (error)) 200)
 101   "*Load in percentage above which stealth fontification is suspended.
 102 Stealth fontification pauses when the system short-term load average (as
 103 returned by the function `load-average' if supported) goes above this level,
 104 thus reducing the demand that stealth fontification makes on the system.
 105 If nil, means stealth fontification is never suspended.
 106 To reduce machine load during stealth fontification, at the cost of stealth
 107 taking longer to fontify, you could reduce the value of this variable.
 108 See also `jit-lock-stealth-nice'."
 109   :type (if (condition-case nil (load-average) (error))
 110             '(choice (const :tag "never" nil)
 111                      (integer :tag "load"))
 112           '(const :format "%t: unsupported\n" nil))
 113   :group 'jit-lock)
 114
 115
 116 (defcustom jit-lock-stealth-verbose nil
 117   "*If non-nil, means stealth fontification should show status messages."
 118   :type 'boolean
 119   :group 'jit-lock)
 120
 121
 122 (defvaralias 'jit-lock-defer-contextually 'jit-lock-contextually)
 123 (defcustom jit-lock-contextually 'syntax-driven
 124   "*If non-nil, means fontification should be syntactically true.
 125 If nil, means fontification occurs only on those lines modified.  This
 126 means where modification on a line causes syntactic change on subsequent lines,
 127 those subsequent lines are not refontified to reflect their new context.
 128 If t, means fontification occurs on those lines modified and all
 129 subsequent lines.  This means those subsequent lines are refontified to reflect
 130 their new syntactic context, after `jit-lock-context-time' seconds.
 131 If any other value, e.g., `syntax-driven', means syntactically true
 132 fontification occurs only if syntactic fontification is performed using the
 133 buffer mode's syntax table, i.e., only if `font-lock-keywords-only' is nil.
 134
 135 The value of this variable is used when JIT Lock mode is turned on."
 136   :type '(choice (const :tag "never" nil)
 137                  (const :tag "always" t)
 138                  (other :tag "syntax-driven" syntax-driven))
 139   :group 'jit-lock)
 140
 141 (defcustom jit-lock-context-time 0.5
 142   "Idle time after which text is contextually refontified, if applicable."
 143   :type '(number :tag "seconds")
 144   :group 'jit-lock)
 145
 146 (defcustom jit-lock-defer-time nil ;; 0.25
 147   "Idle time after which deferred fontification should take place.
 148 If nil, fontification is not deferred."
 149   :group 'jit-lock
 150   :type '(choice (const :tag "never" nil)
 151                  (number :tag "seconds")))
 152 \f
 153 ;;; Variables that are not customizable.
 154
 155 (defvar jit-lock-mode nil
 156   "Non-nil means Just-in-time Lock mode is active.")
 157 (make-variable-buffer-local 'jit-lock-mode)
 158
 159 (defvar jit-lock-functions nil
 160   "Functions to do the actual fontification.
 161 They are called with two arguments: the START and END of the region to fontify.")
 162 (make-variable-buffer-local 'jit-lock-functions)
 163
 164 (defvar jit-lock-context-unfontify-pos nil
 165   "Consider text after this position as contextually unfontified.
 166 If nil, contextual fontification is disabled.")
 167 (make-variable-buffer-local 'jit-lock-context-unfontify-pos)
 168
 169
 170 (defvar jit-lock-stealth-timer nil
 171   "Timer for stealth fontification in Just-in-time Lock mode.")
 172 (defvar jit-lock-context-timer nil
 173   "Timer for context fontification in Just-in-time Lock mode.")
 174 (defvar jit-lock-defer-timer nil
 175   "Timer for deferred fontification in Just-in-time Lock mode.")
 176
 177 (defvar jit-lock-defer-buffers nil
 178   "List of buffers with pending deferred fontification.")
 179 \f
 180 ;;; JIT lock mode
 181
 182 (defun jit-lock-mode (arg)
 183   "Toggle Just-in-time Lock mode.
 184 Turn Just-in-time Lock mode on if and only if ARG is non-nil.
 185 Enable it automatically by customizing group `font-lock'.
 186
 187 When Just-in-time Lock mode is enabled, fontification is different in the
 188 following ways:
 189
 190 - Demand-driven buffer fontification triggered by Emacs C code.
 191   This means initial fontification of the whole buffer does not occur.
 192   Instead, fontification occurs when necessary, such as when scrolling
 193   through the buffer would otherwise reveal unfontified areas.  This is
 194   useful if buffer fontification is too slow for large buffers.
 195
 196 - Stealthy buffer fontification if `jit-lock-stealth-time' is non-nil.
 197   This means remaining unfontified areas of buffers are fontified if Emacs has
 198   been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle.
 199   This is useful if any buffer has any deferred fontification.
 200
 201 - Deferred context fontification if `jit-lock-contextually' is
 202   non-nil.  This means fontification updates the buffer corresponding to
 203   true syntactic context, after `jit-lock-context-time' seconds of Emacs
 204   idle time, while Emacs remains idle.  Otherwise, fontification occurs
 205   on modified lines only, and subsequent lines can remain fontified
 206   corresponding to previous syntactic contexts.  This is useful where
 207   strings or comments span lines.
 208
 209 Stealth fontification only occurs while the system remains unloaded.
 210 If the system load rises above `jit-lock-stealth-load' percent, stealth
 211 fontification is suspended.  Stealth fontification intensity is controlled via
 212 the variable `jit-lock-stealth-nice'."
 213   (setq jit-lock-mode arg)
 214   (cond (;; Turn Just-in-time Lock mode on.
 215          jit-lock-mode
 216
 217          ;; Mark the buffer for refontification.
 218          (jit-lock-refontify)
 219
 220          ;; Install an idle timer for stealth fontification.
 221          (when (and jit-lock-stealth-time (null jit-lock-stealth-timer))
 222            (setq jit-lock-stealth-timer
 223                  (run-with-idle-timer jit-lock-stealth-time t
 224                                       'jit-lock-stealth-fontify)))
 225
 226          ;; Init deferred fontification timer.
 227          (when (and jit-lock-defer-time (null jit-lock-defer-timer))
 228            (setq jit-lock-defer-timer
 229                  (run-with-idle-timer jit-lock-defer-time t
 230                                       'jit-lock-deferred-fontify)))
 231
 232          ;; Initialize contextual fontification if requested.
 233          (when (eq jit-lock-contextually t)
 234            (unless jit-lock-context-timer
 235              (setq jit-lock-context-timer
 236                    (run-with-idle-timer jit-lock-context-time t
 237                                         'jit-lock-context-fontify)))
 238            (setq jit-lock-context-unfontify-pos
 239                  (or jit-lock-context-unfontify-pos (point-max))))
 240
 241          ;; Setup our hooks.
 242          (add-hook 'after-change-functions 'jit-lock-after-change nil t)
 243          (add-hook 'fontification-functions 'jit-lock-function))
 244
 245         ;; Turn Just-in-time Lock mode off.
 246         (t
 247          ;; Cancel our idle timers.
 248          (when (and (or jit-lock-stealth-timer jit-lock-defer-timer
 249                         jit-lock-context-timer)
 250                     ;; Only if there's no other buffer using them.
 251                     (not (catch 'found
 252                            (dolist (buf (buffer-list))
 253                              (with-current-buffer buf
 254                                (when jit-lock-mode (throw 'found t)))))))
 255            (when jit-lock-stealth-timer
 256              (cancel-timer jit-lock-stealth-timer)
 257              (setq jit-lock-stealth-timer nil))
 258            (when jit-lock-context-timer
 259              (cancel-timer jit-lock-context-timer)
 260              (setq jit-lock-context-timer nil))
 261            (when jit-lock-defer-timer
 262              (cancel-timer jit-lock-defer-timer)
 263              (setq jit-lock-defer-timer nil)))
 264
 265          ;; Remove hooks.
 266          (remove-hook 'after-change-functions 'jit-lock-after-change t)
 267          (remove-hook 'fontification-functions 'jit-lock-function))))
 268
 269 (defun jit-lock-register (fun &optional contextual)
 270   "Register FUN as a fontification function to be called in this buffer.
 271 FUN will be called with two arguments START and END indicating the region
 272 that needs to be (re)fontified.
 273 If non-nil, CONTEXTUAL means that a contextual fontification would be useful."
 274   (add-hook 'jit-lock-functions fun nil t)
 275   (when (and contextual jit-lock-contextually)
 276     (set (make-local-variable 'jit-lock-contextually) t))
 277   (jit-lock-mode t))
 278
 279 (defun jit-lock-unregister (fun)
 280   "Unregister FUN as a fontification function.
 281 Only applies to the current buffer."
 282   (remove-hook 'jit-lock-functions fun t)
 283   (unless jit-lock-functions (jit-lock-mode nil)))
 284
 285 ;; This function is used to prevent font-lock-fontify-buffer from
 286 ;; fontifying eagerly the whole buffer.  This is important for
 287 ;; things like CWarn mode which adds/removes a few keywords and
 288 ;; does a refontify (which takes ages on large files).
 289 (defun jit-lock-refontify (&optional beg end)
 290   "Force refontification of the region BEG..END (default whole buffer)."
 291   (with-buffer-prepared-for-jit-lock
 292    (save-restriction
 293      (widen)
 294      (put-text-property (or beg (point-min)) (or end (point-max))
 295                         'fontified nil))))
 296 \f
 297 ;;; On demand fontification.
 298
 299 (defun jit-lock-function (start)
 300   "Fontify current buffer starting at position START.
 301 This function is added to `fontification-functions' when `jit-lock-mode'
 302 is active."
 303   (when (and jit-lock-mode (not memory-full))
 304     (if (null jit-lock-defer-timer)
 305         ;; No deferral.
 306         (jit-lock-fontify-now start (+ start jit-lock-chunk-size))
 307       ;; Record the buffer for later fontification.
 308       (unless (memq (current-buffer) jit-lock-defer-buffers)
 309         (push (current-buffer) jit-lock-defer-buffers))
 310       ;; Mark the area as defer-fontified so that the redisplay engine
 311       ;; is happy and so that the idle timer can find the places to fontify.
 312       (with-buffer-prepared-for-jit-lock
 313        (put-text-property start
 314                           (next-single-property-change
 315                            start 'fontified nil
 316                            (min (point-max) (+ start jit-lock-chunk-size)))
 317                           'fontified 'defer)))))
 318
 319 (defun jit-lock-fontify-now (&optional start end)
 320   "Fontify current buffer from START to END.
 321 Defaults to the whole buffer.  END can be out of bounds."
 322   (with-buffer-prepared-for-jit-lock
 323    (save-excursion
 324      (unless start (setq start (point-min)))
 325      (setq end (if end (min end (point-max)) (point-max)))
 326      ;; This did bind `font-lock-beginning-of-syntax-function' to
 327      ;; nil at some point, for an unknown reason.  Don't do this; it
 328      ;; can make highlighting slow due to expensive calls to
 329      ;; `parse-partial-sexp' in function
 330      ;; `font-lock-fontify-syntactically-region'.  Example: paging
 331      ;; from the end of a buffer to its start, can do repeated
 332      ;; `parse-partial-sexp' starting from `point-min', which can
 333      ;; take a long time in a large buffer.
 334      (let (next)
 335        (save-match-data
 336          ;; Fontify chunks beginning at START.  The end of a
 337          ;; chunk is either `end', or the start of a region
 338          ;; before `end' that has already been fontified.
 339          (while start
 340            ;; Determine the end of this chunk.
 341            (setq next (or (text-property-any start end 'fontified t)
 342                           end))
 343
 344            ;; Decide which range of text should be fontified.
 345            ;; The problem is that START and NEXT may be in the
 346            ;; middle of something matched by a font-lock regexp.
 347            ;; Until someone has a better idea, let's start
 348            ;; at the start of the line containing START and
 349            ;; stop at the start of the line following NEXT.
 350            (goto-char next)  (setq next (line-beginning-position 2))
 351            (goto-char start) (setq start (line-beginning-position))
 352
 353            ;; Make sure the contextual refontification doesn't re-refontify
 354            ;; what's already been refontified.
 355            (when (and jit-lock-context-unfontify-pos
 356                       (< jit-lock-context-unfontify-pos next)
 357                       (>= jit-lock-context-unfontify-pos start)
 358                       ;; Don't move boundary forward if we have to
 359                       ;; refontify previous text.  Otherwise, we risk moving
 360                       ;; it past the end of the multiline property and thus
 361                       ;; forget about this multiline region altogether.
 362                       (not (get-text-property start 'jit-lock-defer-multiline)))
 363              (setq jit-lock-context-unfontify-pos next))
 364
 365            ;; Fontify the chunk, and mark it as fontified.
 366            ;; We mark it first, to make sure that we don't indefinitely
 367            ;; re-execute this fontification if an error occurs.
 368            (put-text-property start next 'fontified t)
 369            (condition-case err
 370                (run-hook-with-args 'jit-lock-functions start next)
 371              ;; If the user quits (which shouldn't happen in normal on-the-fly
 372              ;; jit-locking), make sure the fontification will be performed
 373              ;; before displaying the block again.
 374              (quit (put-text-property start next 'fontified nil)
 375                    (funcall 'signal (car err) (cdr err))))
 376
 377            ;; Find the start of the next chunk, if any.
 378            (setq start (text-property-any next end 'fontified nil))))))))
 379
 380 \f
 381 ;;; Stealth fontification.
 382
 383 (defsubst jit-lock-stealth-chunk-start (around)
 384   "Return the start of the next chunk to fontify around position AROUND..
 385 Value is nil if there is nothing more to fontify."
 386   (if (zerop (buffer-size))
 387       nil
 388     (save-restriction
 389       (widen)
 390       (let* ((next (text-property-not-all around (point-max) 'fontified t))
 391              (prev (previous-single-property-change around 'fontified))
 392              (prop (get-text-property (max (point-min) (1- around))
 393                                       'fontified))
 394              (start (cond
 395                      ((null prev)
 396                       ;; There is no property change between AROUND
 397                       ;; and the start of the buffer.  If PROP is
 398                       ;; non-nil, everything in front of AROUND is
 399                       ;; fontified, otherwise nothing is fontified.
 400                       (if (eq prop t)
 401                           nil
 402                         (max (point-min)
 403                              (- around (/ jit-lock-chunk-size 2)))))
 404                      ((eq prop t)
 405                       ;; PREV is the start of a region of fontified
 406                       ;; text containing AROUND.  Start fontifying a
 407                       ;; chunk size before the end of the unfontified
 408                       ;; region in front of that.
 409                       (max (or (previous-single-property-change prev 'fontified)
 410                                (point-min))
 411                            (- prev jit-lock-chunk-size)))
 412                      (t
 413                       ;; PREV is the start of a region of unfontified
 414                       ;; text containing AROUND.  Start at PREV or
 415                       ;; chunk size in front of AROUND, whichever is
 416                       ;; nearer.
 417                       (max prev (- around jit-lock-chunk-size)))))
 418              (result (cond ((null start) next)
 419                            ((null next) start)
 420                            ((< (- around start) (- next around)) start)
 421                            (t next))))
 422         result))))
 423
 424
 425 (defun jit-lock-stealth-fontify ()
 426   "Fontify buffers stealthily.
 427 This functions is called after Emacs has been idle for
 428 `jit-lock-stealth-time' seconds."
 429   ;; I used to check `inhibit-read-only' here, but I can't remember why.  -stef
 430   (unless (or executing-kbd-macro
 431               memory-full
 432               (window-minibuffer-p (selected-window)))
 433     (let ((buffers (buffer-list))
 434           (outer-buffer (current-buffer))
 435           minibuffer-auto-raise
 436           message-log-max)
 437       (with-local-quit
 438         (while (and buffers (not (input-pending-p)))
 439           (with-current-buffer (pop buffers)
 440             (when jit-lock-mode
 441               ;; This is funny.  Calling sit-for with 3rd arg non-nil
 442               ;; so that it doesn't redisplay, internally calls
 443               ;; wait_reading_process_input also with a parameter
 444               ;; saying "don't redisplay."  Since this function here
 445               ;; is called periodically, this effectively leads to
 446               ;; process output not being redisplayed at all because
 447               ;; redisplay_internal is never called.  (That didn't
 448               ;; work in the old redisplay either.)  So, we learn that
 449               ;; we mustn't call sit-for that way here.  But then, we
 450               ;; have to be cautious not to call sit-for in a widened
 451               ;; buffer, since this could display hidden parts of that
 452               ;; buffer.  This explains the seemingly weird use of
 453               ;; save-restriction/widen here.
 454
 455               (with-temp-message (if jit-lock-stealth-verbose
 456                                      (concat "JIT stealth lock "
 457                                              (buffer-name)))
 458
 459                 ;; In the following code, the `sit-for' calls cause a
 460                 ;; redisplay, so it's required that the
 461                 ;; buffer-modified flag of a buffer that is displayed
 462                 ;; has the right value---otherwise the mode line of
 463                 ;; an unmodified buffer would show a `*'.
 464                 (let (start
 465                       (nice (or jit-lock-stealth-nice 0))
 466                       (point (point-min)))
 467                   (while (and (setq start
 468                                     (jit-lock-stealth-chunk-start point))
 469                               ;; In case sit-for runs any timers,
 470                               ;; give them the expected current buffer.
 471                               (with-current-buffer outer-buffer
 472                                 (sit-for nice)))
 473
 474                     ;; fontify a block.
 475                     (jit-lock-fontify-now start (+ start jit-lock-chunk-size))
 476                     ;; If stealth jit-locking is done backwards, this leads to
 477                     ;; excessive O(n^2) refontification.   -stef
 478                     ;; (when (>= jit-lock-context-unfontify-pos start)
 479                     ;;   (setq jit-lock-context-unfontify-pos end))
 480
 481                     ;; Wait a little if load is too high.
 482                     (when (and jit-lock-stealth-load
 483                                (> (car (load-average)) jit-lock-stealth-load))
 484                       ;; In case sit-for runs any timers,
 485                       ;; give them the expected current buffer.
 486                       (with-current-buffer outer-buffer
 487                         (sit-for (or jit-lock-stealth-time 30))))))))))))))
 488
 489
 490 \f
 491 ;;; Deferred fontification.
 492
 493 (defun jit-lock-deferred-fontify ()
 494   "Fontify what was deferred."
 495   (when (and jit-lock-defer-buffers (not memory-full))
 496     ;; Mark the deferred regions back to `fontified = nil'
 497     (dolist (buffer jit-lock-defer-buffers)
 498       (when (buffer-live-p buffer)
 499         (with-current-buffer buffer
 500           ;; (message "Jit-Defer %s" (buffer-name))
 501           (with-buffer-prepared-for-jit-lock
 502            (let ((pos (point-min)))
 503              (while
 504                  (progn
 505                    (when (eq (get-text-property pos 'fontified) 'defer)
 506                      (put-text-property
 507                       pos (setq pos (next-single-property-change
 508                                      pos 'fontified nil (point-max)))
 509                       'fontified nil))
 510                    (setq pos (next-single-property-change pos 'fontified)))))))))
 511     (setq jit-lock-defer-buffers nil)
 512     ;; Force fontification of the visible parts.
 513     (let ((jit-lock-defer-timer nil))
 514       ;; (message "Jit-Defer Now")
 515       (sit-for 0)
 516       ;; (message "Jit-Defer Done")
 517       )))
 518
 519
 520 (defun jit-lock-context-fontify ()
 521   "Refresh fontification to take new context into account."
 522   (unless memory-full
 523     (dolist (buffer (buffer-list))
 524       (with-current-buffer buffer
 525         (when jit-lock-context-unfontify-pos
 526           ;; (message "Jit-Context %s" (buffer-name))
 527           (save-restriction
 528             (widen)
 529             (when (and (>= jit-lock-context-unfontify-pos (point-min))
 530                        (< jit-lock-context-unfontify-pos (point-max)))
 531               ;; If we're in text that matches a complex multi-line
 532               ;; font-lock pattern, make sure the whole text will be
 533               ;; redisplayed eventually.
 534               ;; Despite its name, we treat jit-lock-defer-multiline here
 535               ;; rather than in jit-lock-defer since it has to do with multiple
 536               ;; lines, i.e. with context.
 537               (when (get-text-property jit-lock-context-unfontify-pos
 538                                        'jit-lock-defer-multiline)
 539                 (setq jit-lock-context-unfontify-pos
 540                       (or (previous-single-property-change
 541                            jit-lock-context-unfontify-pos
 542                            'jit-lock-defer-multiline)
 543                           (point-min))))
 544               (with-buffer-prepared-for-jit-lock
 545                ;; Force contextual refontification.
 546                (remove-text-properties
 547                 jit-lock-context-unfontify-pos (point-max)
 548                 '(fontified nil jit-lock-defer-multiline nil)))
 549               (setq jit-lock-context-unfontify-pos (point-max)))))))))
 550
 551 (defun jit-lock-after-change (start end old-len)
 552   "Mark the rest of the buffer as not fontified after a change.
 553 Installed on `after-change-functions'.
 554 START and END are the start and end of the changed text.  OLD-LEN
 555 is the pre-change length.
 556 This function ensures that lines following the change will be refontified
 557 in case the syntax of those lines has changed.  Refontification
 558 will take place when text is fontified stealthily."
 559   (when (and jit-lock-mode (not memory-full))
 560     (let ((region (font-lock-extend-region start end old-len)))
 561       (save-excursion
 562         (with-buffer-prepared-for-jit-lock
 563          ;; It's important that the `fontified' property be set from the
 564          ;; beginning of the line, else font-lock will properly change the
 565          ;; text's face, but the display will have been done already and will
 566          ;; be inconsistent with the buffer's content.
 567          ;;
 568          ;; FIXME!!! (Alan Mackenzie, 2006-03-14): If start isn't at a BOL,
 569          ;; expanding the region to BOL might mis-fontify, should the BOL not
 570          ;; be at a "safe" position.
 571          (setq start (if region
 572                          (car region)
 573                        (goto-char start)
 574                        (line-beginning-position)))
 575
 576          ;; If we're in text that matches a multi-line font-lock pattern,
 577          ;; make sure the whole text will be redisplayed.
 578          ;; I'm not sure this is ever necessary and/or sufficient.  -stef
 579          (when (get-text-property start 'font-lock-multiline)
 580            (setq start (or (previous-single-property-change
 581                             start 'font-lock-multiline)
 582                            (point-min))))
 583
 584          (if region (setq end (cdr region)))
 585          ;; Make sure we change at least one char (in case of deletions).
 586          (setq end (min (max end (1+ start)) (point-max)))
 587          ;; Request refontification.
 588          (put-text-property start end 'fontified nil))
 589         ;; Mark the change for deferred contextual refontification.
 590         (when jit-lock-context-unfontify-pos
 591           (setq jit-lock-context-unfontify-pos
 592                 ;; Here we use `start' because nothing guarantees that the
 593                 ;; text between start and end will be otherwise refontified:
 594                 ;; usually it will be refontified by virtue of being
 595                 ;; displayed, but if it's outside of any displayed area in the
 596                 ;; buffer, only jit-lock-context-* will re-fontify it.
 597                 (min jit-lock-context-unfontify-pos start)))))))
 598
 599 (provide 'jit-lock)
 600
 601 ;; arch-tag: 56b5de6e-f581-453b-bb97-49c39372ff9e
 602 ;;; jit-lock.el ends here