]> code.delx.au - gnu-emacs/blob - lisp/jit-lock.el
(global-auto-revert-non-file-buffers): Point Info links to the main manual,
[gnu-emacs] / 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