Bind inhibit-modification-hooks rather than a/b-c-f
[emacs.git] / lisp / jit-lock.el
blob8c798d5c4d0d21b1abb05fa12d82a934583a0864
1 ;;; jit-lock.el --- just-in-time fontification -*- lexical-binding: t -*-
3 ;; Copyright (C) 1998, 2000-2015 Free Software Foundation, Inc.
5 ;; Author: Gerd Moellmann <gerd@gnu.org>
6 ;; Keywords: faces files
7 ;; Package: emacs
9 ;; This file is part of GNU Emacs.
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 3 of the License, or
14 ;; (at your option) any later version.
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.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
24 ;;; Commentary:
26 ;; Just-in-time fontification, triggered by C redisplay code.
28 ;;; Code:
31 (eval-when-compile
32 (defmacro with-buffer-prepared-for-jit-lock (&rest body)
33 "Execute BODY in current buffer, overriding several variables.
34 Preserves the `buffer-modified-p' state of the current buffer."
35 (declare (debug t))
36 `(let ((inhibit-point-motion-hooks t))
37 (with-silent-modifications
38 ,@body))))
40 ;;; Customization.
42 (defgroup jit-lock nil
43 "Font Lock support mode to fontify just-in-time."
44 :version "21.1"
45 :group 'font-lock)
47 (defcustom jit-lock-chunk-size 500
48 "Jit-lock fontifies chunks of at most this many characters at a time.
50 This variable controls both display-time and stealth fontification."
51 :type 'integer
52 :group 'jit-lock)
55 (defcustom jit-lock-stealth-time nil
56 "Time in seconds to wait before beginning stealth fontification.
57 Stealth fontification occurs if there is no input within this time.
58 If nil, stealth fontification is never performed.
60 The value of this variable is used when JIT Lock mode is turned on."
61 :type '(choice (const :tag "never" nil)
62 (number :tag "seconds" :value 16))
63 :group 'jit-lock)
66 (defcustom jit-lock-stealth-nice 0.5
67 "Time in seconds to pause between chunks of stealth fontification.
68 Each iteration of stealth fontification is separated by this amount of time,
69 thus reducing the demand that stealth fontification makes on the system.
70 If nil, means stealth fontification is never paused.
71 To reduce machine load during stealth fontification, at the cost of stealth
72 taking longer to fontify, you could increase the value of this variable.
73 See also `jit-lock-stealth-load'."
74 :type '(choice (const :tag "never" nil)
75 (number :tag "seconds"))
76 :group 'jit-lock)
79 (defcustom jit-lock-stealth-load
80 (if (condition-case nil (load-average) (error)) 200)
81 "Load in percentage above which stealth fontification is suspended.
82 Stealth fontification pauses when the system short-term load average (as
83 returned by the function `load-average' if supported) goes above this level,
84 thus reducing the demand that stealth fontification makes on the system.
85 If nil, means stealth fontification is never suspended.
86 To reduce machine load during stealth fontification, at the cost of stealth
87 taking longer to fontify, you could reduce the value of this variable.
88 See also `jit-lock-stealth-nice'."
89 :type (if (condition-case nil (load-average) (error))
90 '(choice (const :tag "never" nil)
91 (integer :tag "load"))
92 '(const :format "%t: unsupported\n" nil))
93 :group 'jit-lock)
96 (defcustom jit-lock-stealth-verbose nil
97 "If non-nil, means stealth fontification should show status messages."
98 :type 'boolean
99 :group 'jit-lock)
102 (defvaralias 'jit-lock-defer-contextually 'jit-lock-contextually)
103 (defcustom jit-lock-contextually 'syntax-driven
104 "If non-nil, means fontification should be syntactically true.
105 If nil, means fontification occurs only on those lines modified. This
106 means where modification on a line causes syntactic change on subsequent lines,
107 those subsequent lines are not refontified to reflect their new context.
108 If t, means fontification occurs on those lines modified and all
109 subsequent lines. This means those subsequent lines are refontified to reflect
110 their new syntactic context, after `jit-lock-context-time' seconds.
111 If any other value, e.g., `syntax-driven', means syntactically true
112 fontification occurs only if syntactic fontification is performed using the
113 buffer mode's syntax table, i.e., only if `font-lock-keywords-only' is nil.
115 The value of this variable is used when JIT Lock mode is turned on."
116 :type '(choice (const :tag "never" nil)
117 (const :tag "always" t)
118 (other :tag "syntax-driven" syntax-driven))
119 :group 'jit-lock)
121 (defcustom jit-lock-context-time 0.5
122 "Idle time after which text is contextually refontified, if applicable."
123 :type '(number :tag "seconds")
124 :group 'jit-lock)
126 (defcustom jit-lock-defer-time nil ;; 0.25
127 "Idle time after which deferred fontification should take place.
128 If nil, fontification is not deferred.
129 If 0, then fontification is only deferred while there is input pending."
130 :group 'jit-lock
131 :type '(choice (const :tag "never" nil)
132 (number :tag "seconds")))
134 ;;; Variables that are not customizable.
136 (defvar-local jit-lock-mode nil
137 "Non-nil means Just-in-time Lock mode is active.")
139 (defvar-local jit-lock-functions nil
140 "Functions to do the actual fontification.
141 They are called with two arguments: the START and END of the region to fontify.")
143 (defvar-local jit-lock-context-unfontify-pos nil
144 "Consider text after this position as contextually unfontified.
145 If nil, contextual fontification is disabled.")
147 (defvar jit-lock-stealth-timer nil
148 "Timer for stealth fontification in Just-in-time Lock mode.")
149 (defvar jit-lock-stealth-repeat-timer nil
150 "Timer for repeated stealth fontification in Just-in-time Lock mode.")
151 (defvar jit-lock-context-timer nil
152 "Timer for context fontification in Just-in-time Lock mode.")
153 (defvar jit-lock-defer-timer nil
154 "Timer for deferred fontification in Just-in-time Lock mode.")
156 (defvar jit-lock-defer-buffers nil
157 "List of buffers with pending deferred fontification.")
158 (defvar jit-lock-stealth-buffers nil
159 "List of buffers that are being fontified stealthily.")
161 ;;; JIT lock mode
163 (defun jit-lock-mode (arg)
164 "Toggle Just-in-time Lock mode.
165 Turn Just-in-time Lock mode on if and only if ARG is non-nil.
166 Enable it automatically by customizing group `font-lock'.
168 When Just-in-time Lock mode is enabled, fontification is different in the
169 following ways:
171 - Demand-driven buffer fontification triggered by Emacs C code.
172 This means initial fontification of the whole buffer does not occur.
173 Instead, fontification occurs when necessary, such as when scrolling
174 through the buffer would otherwise reveal unfontified areas. This is
175 useful if buffer fontification is too slow for large buffers.
177 - Stealthy buffer fontification if `jit-lock-stealth-time' is non-nil.
178 This means remaining unfontified areas of buffers are fontified if Emacs has
179 been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle.
180 This is useful if any buffer has any deferred fontification.
182 - Deferred context fontification if `jit-lock-contextually' is
183 non-nil. This means fontification updates the buffer corresponding to
184 true syntactic context, after `jit-lock-context-time' seconds of Emacs
185 idle time, while Emacs remains idle. Otherwise, fontification occurs
186 on modified lines only, and subsequent lines can remain fontified
187 corresponding to previous syntactic contexts. This is useful where
188 strings or comments span lines.
190 Stealth fontification only occurs while the system remains unloaded.
191 If the system load rises above `jit-lock-stealth-load' percent, stealth
192 fontification is suspended. Stealth fontification intensity is controlled via
193 the variable `jit-lock-stealth-nice'.
195 If you need to debug code run from jit-lock, see `jit-lock-debug-mode'."
196 (setq jit-lock-mode arg)
197 (cond
198 ((buffer-base-buffer)
199 ;; We're in an indirect buffer. This doesn't work because jit-lock relies
200 ;; on the `fontified' text-property which is shared with the base buffer.
201 (setq jit-lock-mode nil)
202 (message "Not enabling jit-lock: it does not work in indirect buffer"))
204 (jit-lock-mode ;; Turn Just-in-time Lock mode on.
206 ;; Mark the buffer for refontification.
207 (jit-lock-refontify)
209 ;; Install an idle timer for stealth fontification.
210 (when (and jit-lock-stealth-time (null jit-lock-stealth-timer))
211 (setq jit-lock-stealth-timer
212 (run-with-idle-timer jit-lock-stealth-time t
213 'jit-lock-stealth-fontify)))
215 ;; Create, but do not activate, the idle timer for repeated
216 ;; stealth fontification.
217 (when (and jit-lock-stealth-time (null jit-lock-stealth-repeat-timer))
218 (setq jit-lock-stealth-repeat-timer (timer-create))
219 (timer-set-function jit-lock-stealth-repeat-timer
220 'jit-lock-stealth-fontify '(t)))
222 ;; Init deferred fontification timer.
223 (when (and jit-lock-defer-time (null jit-lock-defer-timer))
224 (setq jit-lock-defer-timer
225 (run-with-idle-timer jit-lock-defer-time t
226 'jit-lock-deferred-fontify)))
228 ;; Initialize contextual fontification if requested.
229 (when (eq jit-lock-contextually t)
230 (unless jit-lock-context-timer
231 (setq jit-lock-context-timer
232 (run-with-idle-timer jit-lock-context-time t
233 'jit-lock-context-fontify)))
234 (setq jit-lock-context-unfontify-pos
235 (or jit-lock-context-unfontify-pos (point-max))))
237 ;; Setup our hooks.
238 (add-hook 'after-change-functions 'jit-lock-after-change nil t)
239 (add-hook 'fontification-functions 'jit-lock-function))
241 ;; Turn Just-in-time Lock mode off.
243 ;; Cancel our idle timers.
244 (when (and (or jit-lock-stealth-timer jit-lock-defer-timer
245 jit-lock-context-timer)
246 ;; Only if there's no other buffer using them.
247 (not (catch 'found
248 (dolist (buf (buffer-list))
249 (with-current-buffer buf
250 (when jit-lock-mode (throw 'found t)))))))
251 (when jit-lock-stealth-timer
252 (cancel-timer jit-lock-stealth-timer)
253 (setq jit-lock-stealth-timer nil))
254 (when jit-lock-context-timer
255 (cancel-timer jit-lock-context-timer)
256 (setq jit-lock-context-timer nil))
257 (when jit-lock-defer-timer
258 (cancel-timer jit-lock-defer-timer)
259 (setq jit-lock-defer-timer nil)))
261 ;; Remove hooks.
262 (remove-hook 'after-change-functions 'jit-lock-after-change t)
263 (remove-hook 'fontification-functions 'jit-lock-function))))
265 (define-minor-mode jit-lock-debug-mode
266 "Minor mode to help debug code run from jit-lock.
267 When this minor mode is enabled, jit-lock runs as little code as possible
268 during redisplay and moves the rest to a timer, where things
269 like `debug-on-error' and Edebug can be used."
270 :global t :group 'jit-lock
271 (when jit-lock-defer-timer
272 (cancel-timer jit-lock-defer-timer)
273 (setq jit-lock-defer-timer nil))
274 (when jit-lock-debug-mode
275 (setq jit-lock-defer-timer
276 (run-with-idle-timer 0 t #'jit-lock--debug-fontify))))
278 (defvar jit-lock--debug-fontifying nil)
280 (defun jit-lock--debug-fontify ()
281 "Fontify what was deferred for debugging."
282 (when (and (not jit-lock--debug-fontifying)
283 jit-lock-defer-buffers (not memory-full))
284 (let ((jit-lock--debug-fontifying t)
285 (inhibit-debugger nil)) ;FIXME: Not sufficient!
286 ;; Mark the deferred regions back to `fontified = nil'
287 (dolist (buffer jit-lock-defer-buffers)
288 (when (buffer-live-p buffer)
289 (with-current-buffer buffer
290 ;; (message "Jit-Debug %s" (buffer-name))
291 (with-buffer-prepared-for-jit-lock
292 (let ((pos (point-min)))
293 (while
294 (progn
295 (when (eq (get-text-property pos 'fontified) 'defer)
296 (let ((beg pos)
297 (end (setq pos (next-single-property-change
298 pos 'fontified
299 nil (point-max)))))
300 (put-text-property beg end 'fontified nil)
301 (jit-lock-fontify-now beg end)))
302 (setq pos (next-single-property-change
303 pos 'fontified)))))))))
304 (setq jit-lock-defer-buffers nil))))
306 (defun jit-lock-register (fun &optional contextual)
307 "Register FUN as a fontification function to be called in this buffer.
308 FUN will be called with two arguments START and END indicating the region
309 that needs to be (re)fontified.
310 If non-nil, CONTEXTUAL means that a contextual fontification would be useful."
311 (add-hook 'jit-lock-functions fun nil t)
312 (when (and contextual jit-lock-contextually)
313 (setq-local jit-lock-contextually t))
314 (jit-lock-mode t))
316 (defun jit-lock-unregister (fun)
317 "Unregister FUN as a fontification function.
318 Only applies to the current buffer."
319 (remove-hook 'jit-lock-functions fun t)
320 (unless jit-lock-functions (jit-lock-mode nil)))
322 (defun jit-lock-refontify (&optional beg end)
323 "Force refontification of the region BEG..END (default whole buffer)."
324 (with-buffer-prepared-for-jit-lock
325 (save-restriction
326 (widen)
327 (put-text-property (or beg (point-min)) (or end (point-max))
328 'fontified nil))))
330 ;;; On demand fontification.
332 (defun jit-lock-function (start)
333 "Fontify current buffer starting at position START.
334 This function is added to `fontification-functions' when `jit-lock-mode'
335 is active."
336 (when (and jit-lock-mode (not memory-full))
337 (if (not (and jit-lock-defer-timer
338 (or (not (eq jit-lock-defer-time 0))
339 (input-pending-p))))
340 ;; No deferral.
341 (jit-lock-fontify-now start (+ start jit-lock-chunk-size))
342 ;; Record the buffer for later fontification.
343 (unless (memq (current-buffer) jit-lock-defer-buffers)
344 (push (current-buffer) jit-lock-defer-buffers))
345 ;; Mark the area as defer-fontified so that the redisplay engine
346 ;; is happy and so that the idle timer can find the places to fontify.
347 (with-buffer-prepared-for-jit-lock
348 (put-text-property start
349 (next-single-property-change
350 start 'fontified nil
351 (min (point-max) (+ start jit-lock-chunk-size)))
352 'fontified 'defer)))))
354 (defun jit-lock--run-functions (beg end)
355 (let ((tight-beg nil) (tight-end nil)
356 (loose-beg beg) (loose-end end))
357 (run-hook-wrapped
358 'jit-lock-functions
359 (lambda (fun)
360 (pcase-let*
361 ((res (funcall fun beg end))
362 (`(,this-beg . ,this-end)
363 (if (eq (car-safe res) 'jit-lock-bounds)
364 (cdr res) (cons beg end))))
365 ;; If all functions don't fontify the same region, we currently
366 ;; just try to "still be correct". But we could go further and for
367 ;; the chunks of text that was fontified by some functions but not
368 ;; all, we could add text-properties indicating which functions were
369 ;; already run to avoid running them redundantly when we get to
370 ;; those chunks.
371 (setq tight-beg (max (or tight-beg (point-min)) this-beg))
372 (setq tight-end (min (or tight-end (point-max)) this-end))
373 (setq loose-beg (min loose-beg this-beg))
374 (setq loose-end (max loose-end this-end))
375 nil)))
376 `(,(min tight-beg beg) ,(max tight-end end) ,loose-beg ,loose-end)))
378 (defun jit-lock-fontify-now (&optional start end)
379 "Fontify current buffer from START to END.
380 Defaults to the whole buffer. END can be out of bounds."
381 (with-buffer-prepared-for-jit-lock
382 (save-excursion
383 (unless start (setq start (point-min)))
384 (setq end (if end (min end (point-max)) (point-max)))
385 ;; This did bind `font-lock-beginning-of-syntax-function' to
386 ;; nil at some point, for an unknown reason. Don't do this; it
387 ;; can make highlighting slow due to expensive calls to
388 ;; `parse-partial-sexp' in function
389 ;; `font-lock-fontify-syntactically-region'. Example: paging
390 ;; from the end of a buffer to its start, can do repeated
391 ;; `parse-partial-sexp' starting from `point-min', which can
392 ;; take a long time in a large buffer.
393 (let ((orig-start start) next)
394 (save-match-data
395 ;; Fontify chunks beginning at START. The end of a
396 ;; chunk is either `end', or the start of a region
397 ;; before `end' that has already been fontified.
398 (while (and start (< start end))
399 ;; Determine the end of this chunk.
400 (setq next (or (text-property-any start end 'fontified t)
401 end))
403 ;; Fontify the chunk, and mark it as fontified.
404 ;; We mark it first, to make sure that we don't indefinitely
405 ;; re-execute this fontification if an error occurs.
406 (put-text-property start next 'fontified t)
407 (pcase-let
408 ;; `tight' is the part we've fully refontified, and `loose'
409 ;; is the part we've partly refontified (some of the
410 ;; functions have refontified it but maybe not all).
411 ((`(,tight-beg ,tight-end ,loose-beg ,_loose-end)
412 (condition-case err
413 (jit-lock--run-functions start next)
414 ;; If the user quits (which shouldn't happen in normal
415 ;; on-the-fly jit-locking), make sure the fontification
416 ;; will be performed before displaying the block again.
417 (quit (put-text-property start next 'fontified nil)
418 (signal (car err) (cdr err))))))
420 ;; In case we fontified more than requested, take advantage of the
421 ;; good news.
422 (when (or (< tight-beg start) (> tight-end next))
423 (put-text-property tight-beg tight-end 'fontified t))
425 ;; Make sure the contextual refontification doesn't re-refontify
426 ;; what's already been refontified.
427 (when (and jit-lock-context-unfontify-pos
428 (< jit-lock-context-unfontify-pos tight-end)
429 (>= jit-lock-context-unfontify-pos tight-beg)
430 ;; Don't move boundary forward if we have to
431 ;; refontify previous text. Otherwise, we risk moving
432 ;; it past the end of the multiline property and thus
433 ;; forget about this multiline region altogether.
434 (not (get-text-property tight-beg
435 'jit-lock-defer-multiline)))
436 (setq jit-lock-context-unfontify-pos tight-end))
438 ;; The redisplay engine has already rendered the buffer up-to
439 ;; `orig-start' and won't notice if the above jit-lock-functions
440 ;; changed the appearance of any part of the buffer prior
441 ;; to that. So if `loose-beg' is before `orig-start', we need to
442 ;; cause a new redisplay cycle after this one so that the changes
443 ;; are properly reflected on screen.
444 ;; To make such repeated redisplay happen less often, we can
445 ;; eagerly extend the refontified region with
446 ;; jit-lock-after-change-extend-region-functions.
447 (when (< loose-beg orig-start)
448 (run-with-timer 0 nil #'jit-lock-force-redisplay
449 (copy-marker loose-beg)
450 (copy-marker orig-start)))
452 ;; Find the start of the next chunk, if any.
453 (setq start
454 (text-property-any tight-end end 'fontified nil)))))))))
456 (defun jit-lock-force-redisplay (start end)
457 "Force the display engine to re-render START's buffer from START to END.
458 This applies to the buffer associated with marker START."
459 (when (marker-buffer start)
460 (with-current-buffer (marker-buffer start)
461 (with-buffer-prepared-for-jit-lock
462 (when (> end (point-max))
463 (setq end (point-max) start (min start end)))
464 (when (< start (point-min))
465 (setq start (point-min) end (max start end)))
466 ;; Don't cause refontification (it's already been done), but just do
467 ;; some random buffer change, so as to force redisplay.
468 (put-text-property start end 'fontified t)))))
470 ;;; Stealth fontification.
472 (defsubst jit-lock-stealth-chunk-start (around)
473 "Return the start of the next chunk to fontify around position AROUND.
474 Value is nil if there is nothing more to fontify."
475 (if (zerop (buffer-size))
477 (let* ((next (text-property-not-all around (point-max) 'fontified t))
478 (prev (previous-single-property-change around 'fontified))
479 (prop (get-text-property (max (point-min) (1- around))
480 'fontified))
481 (start (cond
482 ((null prev)
483 ;; There is no property change between AROUND
484 ;; and the start of the buffer. If PROP is
485 ;; non-nil, everything in front of AROUND is
486 ;; fontified, otherwise nothing is fontified.
487 (if (eq prop t)
489 (max (point-min)
490 (- around (/ jit-lock-chunk-size 2)))))
491 ((eq prop t)
492 ;; PREV is the start of a region of fontified
493 ;; text containing AROUND. Start fontifying a
494 ;; chunk size before the end of the unfontified
495 ;; region in front of that.
496 (max (or (previous-single-property-change prev 'fontified)
497 (point-min))
498 (- prev jit-lock-chunk-size)))
500 ;; PREV is the start of a region of unfontified
501 ;; text containing AROUND. Start at PREV or
502 ;; chunk size in front of AROUND, whichever is
503 ;; nearer.
504 (max prev (- around jit-lock-chunk-size)))))
505 (result (cond ((null start) next)
506 ((null next) start)
507 ((< (- around start) (- next around)) start)
508 (t next))))
509 result)))
511 (defun jit-lock-stealth-fontify (&optional repeat)
512 "Fontify buffers stealthily.
513 This function is called repeatedly after Emacs has become idle for
514 `jit-lock-stealth-time' seconds. Optional argument REPEAT is expected
515 non-nil in a repeated invocation of this function."
516 ;; Cancel timer for repeated invocations.
517 (unless repeat
518 (cancel-timer jit-lock-stealth-repeat-timer))
519 (unless (or executing-kbd-macro
520 memory-full
521 (window-minibuffer-p)
522 ;; For first invocation set up `jit-lock-stealth-buffers'.
523 ;; In repeated invocations it's already been set up.
524 (null (if repeat
525 jit-lock-stealth-buffers
526 (setq jit-lock-stealth-buffers (buffer-list)))))
527 (let ((buffer (car jit-lock-stealth-buffers))
528 (delay 0)
529 minibuffer-auto-raise
530 message-log-max
531 start)
532 (if (and jit-lock-stealth-load
533 ;; load-average can return nil. The w32 emulation does
534 ;; that during the first few dozens of seconds after
535 ;; startup.
536 (> (or (car (load-average)) 0) jit-lock-stealth-load))
537 ;; Wait a little if load is too high.
538 (setq delay jit-lock-stealth-time)
539 (if (buffer-live-p buffer)
540 (with-current-buffer buffer
541 (if (and jit-lock-mode
542 (setq start (jit-lock-stealth-chunk-start (point))))
543 ;; Fontify one block of at most `jit-lock-chunk-size'
544 ;; characters.
545 (with-temp-message (if jit-lock-stealth-verbose
546 (concat "JIT stealth lock "
547 (buffer-name)))
548 (jit-lock-fontify-now start
549 (+ start jit-lock-chunk-size))
550 ;; Run again after `jit-lock-stealth-nice' seconds.
551 (setq delay (or jit-lock-stealth-nice 0)))
552 ;; Nothing to fontify here. Remove this buffer from
553 ;; `jit-lock-stealth-buffers' and run again immediately.
554 (setq jit-lock-stealth-buffers (cdr jit-lock-stealth-buffers))))
555 ;; Buffer is no longer live. Remove it from
556 ;; `jit-lock-stealth-buffers' and run again immediately.
557 (setq jit-lock-stealth-buffers (cdr jit-lock-stealth-buffers))))
558 ;; Call us again.
559 (when jit-lock-stealth-buffers
560 (timer-set-idle-time jit-lock-stealth-repeat-timer (current-idle-time))
561 (timer-inc-time jit-lock-stealth-repeat-timer delay)
562 (timer-activate-when-idle jit-lock-stealth-repeat-timer t)))))
565 ;;; Deferred fontification.
567 (defun jit-lock-deferred-fontify ()
568 "Fontify what was deferred."
569 (when (and jit-lock-defer-buffers (not memory-full))
570 ;; Mark the deferred regions back to `fontified = nil'
571 (dolist (buffer jit-lock-defer-buffers)
572 (when (buffer-live-p buffer)
573 (with-current-buffer buffer
574 ;; (message "Jit-Defer %s" (buffer-name))
575 (with-buffer-prepared-for-jit-lock
576 (let ((pos (point-min)))
577 (while
578 (progn
579 (when (eq (get-text-property pos 'fontified) 'defer)
580 (put-text-property
581 pos (setq pos (next-single-property-change
582 pos 'fontified nil (point-max)))
583 'fontified nil))
584 (setq pos (next-single-property-change
585 pos 'fontified)))))))))
586 ;; Force fontification of the visible parts.
587 (let ((buffers jit-lock-defer-buffers)
588 (jit-lock-defer-timer nil))
589 (setq jit-lock-defer-buffers nil)
590 ;; (message "Jit-Defer Now")
591 (unless (redisplay) ;FIXME: Should we `force'?
592 (setq jit-lock-defer-buffers buffers))
593 ;; (message "Jit-Defer Done")
597 (defun jit-lock-context-fontify ()
598 "Refresh fontification to take new context into account."
599 (unless memory-full
600 (dolist (buffer (buffer-list))
601 (with-current-buffer buffer
602 (when jit-lock-context-unfontify-pos
603 ;; (message "Jit-Context %s" (buffer-name))
604 (save-restriction
605 ;; Don't be blindsided by narrowing that starts in the middle
606 ;; of a jit-lock-defer-multiline.
607 (widen)
608 (when (and (>= jit-lock-context-unfontify-pos (point-min))
609 (< jit-lock-context-unfontify-pos (point-max)))
610 ;; If we're in text that matches a complex multi-line
611 ;; font-lock pattern, make sure the whole text will be
612 ;; redisplayed eventually.
613 ;; Despite its name, we treat jit-lock-defer-multiline here
614 ;; rather than in jit-lock-defer since it has to do with multiple
615 ;; lines, i.e. with context.
616 (when (get-text-property jit-lock-context-unfontify-pos
617 'jit-lock-defer-multiline)
618 (setq jit-lock-context-unfontify-pos
619 (or (previous-single-property-change
620 jit-lock-context-unfontify-pos
621 'jit-lock-defer-multiline)
622 (point-min))))
623 (with-buffer-prepared-for-jit-lock
624 ;; Force contextual refontification.
625 (remove-text-properties
626 jit-lock-context-unfontify-pos (point-max)
627 '(fontified nil jit-lock-defer-multiline nil)))
628 (setq jit-lock-context-unfontify-pos (point-max)))))))))
630 (defvar jit-lock-start) (defvar jit-lock-end) ; Dynamically scoped variables.
631 (defvar jit-lock-after-change-extend-region-functions nil
632 "Hook that can extend the text to refontify after a change.
633 This is run after every buffer change. The functions are called with
634 the three arguments of `after-change-functions': START END OLD-LEN.
635 The extended region to refontify is returned indirectly by modifying
636 the variables `jit-lock-start' and `jit-lock-end'.
638 Note that extending the region this way is not strictly necessary, except
639 that the nature of the redisplay code tends to otherwise leave some of
640 the rehighlighted text displayed with the old highlight until the next
641 redisplay (see comment about repeated redisplay in `jit-lock-fontify-now').")
643 (defun jit-lock-after-change (start end old-len)
644 "Mark the rest of the buffer as not fontified after a change.
645 Installed on `after-change-functions'.
646 START and END are the start and end of the changed text. OLD-LEN
647 is the pre-change length.
648 This function ensures that lines following the change will be refontified
649 in case the syntax of those lines has changed. Refontification
650 will take place when text is fontified stealthily."
651 (when (and jit-lock-mode (not memory-full))
652 (let ((jit-lock-start start)
653 (jit-lock-end end))
654 (with-buffer-prepared-for-jit-lock
655 (run-hook-with-args 'jit-lock-after-change-extend-region-functions
656 start end old-len)
657 ;; Make sure we change at least one char (in case of deletions).
658 (setq jit-lock-end (min (max jit-lock-end (1+ start)) (point-max)))
659 ;; Request refontification.
660 (save-restriction
661 (widen)
662 (put-text-property jit-lock-start jit-lock-end 'fontified nil)))
663 ;; Mark the change for deferred contextual refontification.
664 (when jit-lock-context-unfontify-pos
665 (setq jit-lock-context-unfontify-pos
666 ;; Here we use `start' because nothing guarantees that the
667 ;; text between start and end will be otherwise refontified:
668 ;; usually it will be refontified by virtue of being
669 ;; displayed, but if it's outside of any displayed area in the
670 ;; buffer, only jit-lock-context-* will re-fontify it.
671 (min jit-lock-context-unfontify-pos jit-lock-start))))))
673 (provide 'jit-lock)
675 ;;; jit-lock.el ends here