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

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