jit-lock.el 32.5 KB
Newer Older
1
;;; jit-lock.el --- just-in-time fontification  -*- lexical-binding: t -*-
Gerd Moellmann's avatar
Gerd Moellmann committed
2

Paul Eggert's avatar
Paul Eggert committed
3
;; Copyright (C) 1998, 2000-2019 Free Software Foundation, Inc.
Gerd Moellmann's avatar
Gerd Moellmann committed
4 5 6

;; Author: Gerd Moellmann <gerd@gnu.org>
;; Keywords: faces files
7
;; Package: emacs
Gerd Moellmann's avatar
Gerd Moellmann committed
8 9 10

;; This file is part of GNU Emacs.

11
;; GNU Emacs is free software: you can redistribute it and/or modify
Gerd Moellmann's avatar
Gerd Moellmann committed
12
;; it under the terms of the GNU General Public License as published by
13 14
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
Gerd Moellmann's avatar
Gerd Moellmann committed
15 16 17 18 19 20 21

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
22
;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
Gerd Moellmann's avatar
Gerd Moellmann committed
23 24 25 26 27 28 29 30 31

;;; Commentary:

;; Just-in-time fontification, triggered by C redisplay code.

;;; Code:


(eval-when-compile
32
  (defmacro with-buffer-prepared-for-jit-lock (&rest body)
Gerd Moellmann's avatar
Gerd Moellmann committed
33 34
    "Execute BODY in current buffer, overriding several variables.
Preserves the `buffer-modified-p' state of the current buffer."
35
    (declare (debug t))
36 37 38
    `(let ((inhibit-point-motion-hooks t))
       (with-silent-modifications
         ,@body))))
Gerd Moellmann's avatar
Gerd Moellmann committed
39 40 41

;;; Customization.

42 43 44 45 46
(defgroup jit-lock nil
  "Font Lock support mode to fontify just-in-time."
  :version "21.1"
  :group 'font-lock)

Gerd Moellmann's avatar
Gerd Moellmann committed
47
(defcustom jit-lock-chunk-size 500
Lute Kamstra's avatar
Lute Kamstra committed
48
  "Jit-lock fontifies chunks of at most this many characters at a time.
49 50

This variable controls both display-time and stealth fontification."
Gerd Moellmann's avatar
Gerd Moellmann committed
51 52 53 54
  :type 'integer
  :group 'jit-lock)


55
(defcustom jit-lock-stealth-time nil
Lute Kamstra's avatar
Lute Kamstra committed
56
  "Time in seconds to wait before beginning stealth fontification.
Gerd Moellmann's avatar
Gerd Moellmann committed
57
Stealth fontification occurs if there is no input within this time.
58
If nil, stealth fontification is never performed.
Gerd Moellmann's avatar
Gerd Moellmann committed
59 60 61

The value of this variable is used when JIT Lock mode is turned on."
  :type '(choice (const :tag "never" nil)
62
		 (number :tag "seconds" :value 16))
Gerd Moellmann's avatar
Gerd Moellmann committed
63 64 65
  :group 'jit-lock)


66
(defcustom jit-lock-stealth-nice 0.5
Lute Kamstra's avatar
Lute Kamstra committed
67
  "Time in seconds to pause between chunks of stealth fontification.
Gerd Moellmann's avatar
Gerd Moellmann committed
68 69 70 71 72 73 74
Each iteration of stealth fontification is separated by this amount of time,
thus reducing the demand that stealth fontification makes on the system.
If nil, means stealth fontification is never paused.
To reduce machine load during stealth fontification, at the cost of stealth
taking longer to fontify, you could increase the value of this variable.
See also `jit-lock-stealth-load'."
  :type '(choice (const :tag "never" nil)
75
		 (number :tag "seconds"))
Gerd Moellmann's avatar
Gerd Moellmann committed
76
  :group 'jit-lock)
77

Gerd Moellmann's avatar
Gerd Moellmann committed
78 79 80

(defcustom jit-lock-stealth-load
  (if (condition-case nil (load-average) (error)) 200)
Lute Kamstra's avatar
Lute Kamstra committed
81
  "Load in percentage above which stealth fontification is suspended.
Gerd Moellmann's avatar
Gerd Moellmann committed
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
Stealth fontification pauses when the system short-term load average (as
returned by the function `load-average' if supported) goes above this level,
thus reducing the demand that stealth fontification makes on the system.
If nil, means stealth fontification is never suspended.
To reduce machine load during stealth fontification, at the cost of stealth
taking longer to fontify, you could reduce the value of this variable.
See also `jit-lock-stealth-nice'."
  :type (if (condition-case nil (load-average) (error))
	    '(choice (const :tag "never" nil)
		     (integer :tag "load"))
	  '(const :format "%t: unsupported\n" nil))
  :group 'jit-lock)


(defcustom jit-lock-stealth-verbose nil
Lute Kamstra's avatar
Lute Kamstra committed
97
  "If non-nil, means stealth fontification should show status messages."
Gerd Moellmann's avatar
Gerd Moellmann committed
98 99 100 101
  :type 'boolean
  :group 'jit-lock)


102 103
(defvaralias 'jit-lock-defer-contextually 'jit-lock-contextually)
(defcustom jit-lock-contextually 'syntax-driven
Lute Kamstra's avatar
Lute Kamstra committed
104
  "If non-nil, means fontification should be syntactically true.
105
If nil, means fontification occurs only on those lines modified.  This
Gerd Moellmann's avatar
Gerd Moellmann committed
106 107
means where modification on a line causes syntactic change on subsequent lines,
those subsequent lines are not refontified to reflect their new context.
108
If t, means fontification occurs on those lines modified and all
Gerd Moellmann's avatar
Gerd Moellmann committed
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
Gerd Moellmann's avatar
Gerd Moellmann committed
112 113 114 115 116 117 118 119 120
fontification occurs only if syntactic fontification is performed using the
buffer mode's syntax table, i.e., only if `font-lock-keywords-only' is nil.

The value of this variable is used when JIT Lock mode is turned on."
  :type '(choice (const :tag "never" nil)
		 (const :tag "always" t)
		 (other :tag "syntax-driven" syntax-driven))
  :group 'jit-lock)

121 122
(defcustom jit-lock-context-time 0.5
  "Idle time after which text is contextually refontified, if applicable."
123 124 125
  :type '(number :tag "seconds")
  :group 'jit-lock)

126 127 128 129 130 131 132 133 134 135 136
(defcustom jit-lock-antiblink-grace 2
  "Like `jit-lock-context-time' but for unterminated multiline strings.
Setting this to a positive number of seconds helps avoid the
fontification \"blinking\" behaviour observed when adding
temporarily unterminated strings to source code.  If the user has
recently created an unterminated string at EOL, allow for an idle
\"grace\" period to elapse before deciding it is a multi-line
string and fontifying the remainder of the buffer accordingly."
  :type '(number :tag "seconds")
  :group 'jit-lock)

137
(defcustom jit-lock-defer-time nil ;; 0.25
138
  "Idle time after which deferred fontification should take place.
139 140
If nil, fontification is not deferred.
If 0, then fontification is only deferred while there is input pending."
141 142 143
  :group 'jit-lock
  :type '(choice (const :tag "never" nil)
	         (number :tag "seconds")))
Gerd Moellmann's avatar
Gerd Moellmann committed
144 145 146

;;; Variables that are not customizable.

147
(defvar-local jit-lock-mode nil
Gerd Moellmann's avatar
Gerd Moellmann committed
148 149
  "Non-nil means Just-in-time Lock mode is active.")

150
(defvar-local jit-lock-functions nil
151 152
  "Functions to do the actual fontification.
They are called with two arguments: the START and END of the region to fontify.")
Gerd Moellmann's avatar
Gerd Moellmann committed
153

154
(defvar-local jit-lock-context-unfontify-pos nil
155
  "Consider text after this position as contextually unfontified.
156
If nil, contextual fontification is disabled.")
Gerd Moellmann's avatar
Gerd Moellmann committed
157 158 159

(defvar jit-lock-stealth-timer nil
  "Timer for stealth fontification in Just-in-time Lock mode.")
160 161
(defvar jit-lock-stealth-repeat-timer nil
  "Timer for repeated stealth fontification in Just-in-time Lock mode.")
162 163
(defvar jit-lock-context-timer nil
  "Timer for context fontification in Just-in-time Lock mode.")
164 165 166
(defvar jit-lock-defer-timer nil
  "Timer for deferred fontification in Just-in-time Lock mode.")

167
(defvar jit-lock-defer-buffers nil
168
  "List of buffers with pending deferred fontification.")
169 170
(defvar jit-lock-stealth-buffers nil
  "List of buffers that are being fontified stealthily.")
171 172

(defvar jit-lock--antiblink-grace-timer nil
173 174 175
  "Idle timer for fontifying unterminated string or comment, or nil.")
(defvar jit-lock--antiblink-l-b-p (make-marker)
  "Last line beginning position (l-b-p) after last command (a marker).")
176 177 178 179
(defvar jit-lock--antiblink-i-s-o-c nil
  "In string or comment (i-s-o-c) after last command (a boolean).")


Gerd Moellmann's avatar
Gerd Moellmann committed
180 181 182 183 184

;;; JIT lock mode

(defun jit-lock-mode (arg)
  "Toggle Just-in-time Lock mode.
185
Turn Just-in-time Lock mode on if and only if ARG is non-nil.
Gerd Moellmann's avatar
Gerd Moellmann committed
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
Enable it automatically by customizing group `font-lock'.

When Just-in-time Lock mode is enabled, fontification is different in the
following ways:

- Demand-driven buffer fontification triggered by Emacs C code.
  This means initial fontification of the whole buffer does not occur.
  Instead, fontification occurs when necessary, such as when scrolling
  through the buffer would otherwise reveal unfontified areas.  This is
  useful if buffer fontification is too slow for large buffers.

- Stealthy buffer fontification if `jit-lock-stealth-time' is non-nil.
  This means remaining unfontified areas of buffers are fontified if Emacs has
  been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle.
  This is useful if any buffer has any deferred fontification.

202
- Deferred context fontification if `jit-lock-contextually' is
Gerd Moellmann's avatar
Gerd Moellmann committed
203
  non-nil.  This means fontification updates the buffer corresponding to
204
  true syntactic context, after `jit-lock-context-time' seconds of Emacs
Gerd Moellmann's avatar
Gerd Moellmann committed
205 206 207 208 209 210 211 212
  idle time, while Emacs remains idle.  Otherwise, fontification occurs
  on modified lines only, and subsequent lines can remain fontified
  corresponding to previous syntactic contexts.  This is useful where
  strings or comments span lines.

Stealth fontification only occurs while the system remains unloaded.
If the system load rises above `jit-lock-stealth-load' percent, stealth
fontification is suspended.  Stealth fontification intensity is controlled via
Glenn Morris's avatar
Glenn Morris committed
213 214 215
the variable `jit-lock-stealth-nice'.

If you need to debug code run from jit-lock, see `jit-lock-debug-mode'."
216
  (setq jit-lock-mode arg)
217
  (cond
218 219 220 221 222
   ((and (buffer-base-buffer)
         jit-lock-mode)
    ;; We're in an indirect buffer, and we're turning the mode on.
    ;; This doesn't work because jit-lock relies on the `fontified'
    ;; text-property which is shared with the base buffer.
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
    (setq jit-lock-mode nil)
    (message "Not enabling jit-lock: it does not work in indirect buffer"))

   (jit-lock-mode ;; Turn Just-in-time Lock mode on.

    ;; Mark the buffer for refontification.
    (jit-lock-refontify)

    ;; Install an idle timer for stealth fontification.
    (when (and jit-lock-stealth-time (null jit-lock-stealth-timer))
      (setq jit-lock-stealth-timer
            (run-with-idle-timer jit-lock-stealth-time t
                                 'jit-lock-stealth-fontify)))

    ;; Create, but do not activate, the idle timer for repeated
    ;; stealth fontification.
    (when (and jit-lock-stealth-time (null jit-lock-stealth-repeat-timer))
      (setq jit-lock-stealth-repeat-timer (timer-create))
      (timer-set-function jit-lock-stealth-repeat-timer
                          'jit-lock-stealth-fontify '(t)))

    ;; Init deferred fontification timer.
    (when (and jit-lock-defer-time (null jit-lock-defer-timer))
      (setq jit-lock-defer-timer
            (run-with-idle-timer jit-lock-defer-time t
                                 'jit-lock-deferred-fontify)))

    ;; Initialize contextual fontification if requested.
    (when (eq jit-lock-contextually t)
      (unless jit-lock-context-timer
        (setq jit-lock-context-timer
              (run-with-idle-timer jit-lock-context-time t
255 256 257 258
                                   (lambda ()
                                     (unless jit-lock--antiblink-grace-timer
                                       (jit-lock-context-fontify))))))
      (add-hook 'post-command-hook 'jit-lock--antiblink-post-command nil t)
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
      (setq jit-lock-context-unfontify-pos
            (or jit-lock-context-unfontify-pos (point-max))))

    ;; Setup our hooks.
    (add-hook 'after-change-functions 'jit-lock-after-change nil t)
    (add-hook 'fontification-functions 'jit-lock-function))

   ;; Turn Just-in-time Lock mode off.
   (t
    ;; Cancel our idle timers.
    (when (and (or jit-lock-stealth-timer jit-lock-defer-timer
                   jit-lock-context-timer)
               ;; Only if there's no other buffer using them.
               (not (catch 'found
                      (dolist (buf (buffer-list))
                        (with-current-buffer buf
                          (when jit-lock-mode (throw 'found t)))))))
      (when jit-lock-stealth-timer
        (cancel-timer jit-lock-stealth-timer)
        (setq jit-lock-stealth-timer nil))
      (when jit-lock-context-timer
        (cancel-timer jit-lock-context-timer)
        (setq jit-lock-context-timer nil))
      (when jit-lock-defer-timer
        (cancel-timer jit-lock-defer-timer)
        (setq jit-lock-defer-timer nil)))

    ;; Remove hooks.
    (remove-hook 'after-change-functions 'jit-lock-after-change t)
    (remove-hook 'fontification-functions 'jit-lock-function))))
Gerd Moellmann's avatar
Gerd Moellmann committed
289

290 291
(define-minor-mode jit-lock-debug-mode
  "Minor mode to help debug code run from jit-lock.
292

293 294 295
When this minor mode is enabled, jit-lock runs as little code as possible
during redisplay and moves the rest to a timer, where things
like `debug-on-error' and Edebug can be used."
Glenn Morris's avatar
Glenn Morris committed
296
  :global t :group 'jit-lock
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
  (when jit-lock-defer-timer
    (cancel-timer jit-lock-defer-timer)
    (setq jit-lock-defer-timer nil))
  (when jit-lock-debug-mode
    (setq jit-lock-defer-timer
          (run-with-idle-timer 0 t #'jit-lock--debug-fontify))))

(defvar jit-lock--debug-fontifying nil)

(defun jit-lock--debug-fontify ()
  "Fontify what was deferred for debugging."
  (when (and (not jit-lock--debug-fontifying)
             jit-lock-defer-buffers (not memory-full))
    (let ((jit-lock--debug-fontifying t)
          (inhibit-debugger nil))       ;FIXME: Not sufficient!
      ;; Mark the deferred regions back to `fontified = nil'
      (dolist (buffer jit-lock-defer-buffers)
        (when (buffer-live-p buffer)
          (with-current-buffer buffer
            ;; (message "Jit-Debug %s" (buffer-name))
            (with-buffer-prepared-for-jit-lock
                (let ((pos (point-min)))
                  (while
                      (progn
                        (when (eq (get-text-property pos 'fontified) 'defer)
                          (let ((beg pos)
                                (end (setq pos (next-single-property-change
                                                pos 'fontified
                                                nil (point-max)))))
                            (put-text-property beg end 'fontified nil)
                            (jit-lock-fontify-now beg end)))
                        (setq pos (next-single-property-change
                                   pos 'fontified)))))))))
      (setq jit-lock-defer-buffers nil))))

332
(defun jit-lock-register (fun &optional contextual)
333 334
  "Register FUN as a fontification function to be called in this buffer.
FUN will be called with two arguments START and END indicating the region
335 336
that needs to be (re)fontified.
If non-nil, CONTEXTUAL means that a contextual fontification would be useful."
337
  (add-hook 'jit-lock-functions fun nil t)
338
  (when (and contextual jit-lock-contextually)
339
    (setq-local jit-lock-contextually t))
340 341 342
  (jit-lock-mode t))

(defun jit-lock-unregister (fun)
343
  "Unregister FUN as a fontification function.
344 345
Only applies to the current buffer."
  (remove-hook 'jit-lock-functions fun t)
346
  (unless jit-lock-functions (jit-lock-mode nil)))
Gerd Moellmann's avatar
Gerd Moellmann committed
347

348 349
(defun jit-lock-refontify (&optional beg end)
  "Force refontification of the region BEG..END (default whole buffer)."
350
  (with-buffer-prepared-for-jit-lock
351 352
   (save-restriction
     (widen)
353 354
     (put-text-property (or beg (point-min)) (or end (point-max))
			'fontified nil))))
Gerd Moellmann's avatar
Gerd Moellmann committed
355 356 357 358 359 360 361

;;; On demand fontification.

(defun jit-lock-function (start)
  "Fontify current buffer starting at position START.
This function is added to `fontification-functions' when `jit-lock-mode'
is active."
362
  (when (and jit-lock-mode (not memory-full))
363 364 365
    (if (not (and jit-lock-defer-timer
                  (or (not (eq jit-lock-defer-time 0))
                      (input-pending-p))))
366 367 368
	;; No deferral.
	(jit-lock-fontify-now start (+ start jit-lock-chunk-size))
      ;; Record the buffer for later fontification.
369 370
      (unless (memq (current-buffer) jit-lock-defer-buffers)
	(push (current-buffer) jit-lock-defer-buffers))
371 372 373 374 375 376 377 378
      ;; Mark the area as defer-fontified so that the redisplay engine
      ;; is happy and so that the idle timer can find the places to fontify.
      (with-buffer-prepared-for-jit-lock
       (put-text-property start
			  (next-single-property-change
			   start 'fontified nil
			   (min (point-max) (+ start jit-lock-chunk-size)))
			  'fontified 'defer)))))
379

380 381 382 383 384 385 386 387 388 389 390
(defun jit-lock--run-functions (beg end)
  (let ((tight-beg nil) (tight-end nil)
        (loose-beg beg) (loose-end end))
    (run-hook-wrapped
     'jit-lock-functions
     (lambda (fun)
       (pcase-let*
           ((res (funcall fun beg end))
            (`(,this-beg . ,this-end)
             (if (eq (car-safe res) 'jit-lock-bounds)
                 (cdr res) (cons beg end))))
391 392 393 394 395 396 397
         ;; If all functions don't fontify the same region, we currently
         ;; just try to "still be correct".  But we could go further and for
         ;; the chunks of text that was fontified by some functions but not
         ;; all, we could add text-properties indicating which functions were
         ;; already run to avoid running them redundantly when we get to
         ;; those chunks.
         (setq tight-beg (max (or tight-beg (point-min)) this-beg))
398 399
         (setq tight-end (min (or tight-end (point-max)) this-end))
         (setq loose-beg (min loose-beg this-beg))
400 401 402 403
         (setq loose-end (max loose-end this-end))
         nil)))
    `(,(min tight-beg beg) ,(max tight-end end) ,loose-beg ,loose-end)))

404 405 406
(defun jit-lock-fontify-now (&optional start end)
  "Fontify current buffer from START to END.
Defaults to the whole buffer.  END can be out of bounds."
407
  (with-buffer-prepared-for-jit-lock
408
   (save-excursion
409 410
     (unless start (setq start (point-min)))
     (setq end (if end (min end (point-max)) (point-max)))
411
     (let ((orig-start start) next)
412 413 414 415
       (save-match-data
	 ;; Fontify chunks beginning at START.  The end of a
	 ;; chunk is either `end', or the start of a region
	 ;; before `end' that has already been fontified.
416
	 (while (and start (< start end))
417 418 419 420
	   ;; Determine the end of this chunk.
	   (setq next (or (text-property-any start end 'fontified t)
			  end))

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
           ;; Avoid unnecessary work if the chunk is empty (bug#23278).
           (when (> next start)
             ;; Fontify the chunk, and mark it as fontified.
             ;; We mark it first, to make sure that we don't indefinitely
             ;; re-execute this fontification if an error occurs.
             (put-text-property start next 'fontified t)
             (pcase-let
                 ;; `tight' is the part we've fully refontified, and `loose'
                 ;; is the part we've partly refontified (some of the
                 ;; functions have refontified it but maybe not all).
                 ((`(,tight-beg ,tight-end ,loose-beg ,_loose-end)
                   (condition-case err
                       (jit-lock--run-functions start next)
                     ;; If the user quits (which shouldn't happen in normal
                     ;; on-the-fly jit-locking), make sure the fontification
                     ;; will be performed before displaying the block again.
                     (quit (put-text-property start next 'fontified nil)
                           (signal (car err) (cdr err))))))

               ;; In case we fontified more than requested, take advantage of the
               ;; good news.
               (when (or (< tight-beg start) (> tight-end next))
                 (put-text-property tight-beg tight-end 'fontified t))

               ;; Make sure the contextual refontification doesn't re-refontify
               ;; what's already been refontified.
               (when (and jit-lock-context-unfontify-pos
                          (< jit-lock-context-unfontify-pos tight-end)
                          (>= jit-lock-context-unfontify-pos tight-beg)
                          ;; Don't move boundary forward if we have to
                          ;; refontify previous text.  Otherwise, we risk moving
                          ;; it past the end of the multiline property and thus
                          ;; forget about this multiline region altogether.
                          (not (get-text-property tight-beg
                                                  'jit-lock-defer-multiline)))
                 (setq jit-lock-context-unfontify-pos tight-end))

               ;; The redisplay engine has already rendered the buffer up-to
               ;; `orig-start' and won't notice if the above jit-lock-functions
               ;; changed the appearance of any part of the buffer prior
               ;; to that.  So if `loose-beg' is before `orig-start', we need to
               ;; cause a new redisplay cycle after this one so that the changes
               ;; are properly reflected on screen.
               ;; To make such repeated redisplay happen less often, we can
               ;; eagerly extend the refontified region with
               ;; jit-lock-after-change-extend-region-functions.
               (when (< loose-beg orig-start)
                 (run-with-timer 0 nil #'jit-lock-force-redisplay
                                 (copy-marker loose-beg)
                                 (copy-marker orig-start)))

               ;; Skip to the end of the fully refontified part.
               (setq start tight-end)))
           ;; Find the start of the next chunk, if any.
           (setq start
                 (text-property-any start end 'fontified nil))))))))
Gerd Moellmann's avatar
Gerd Moellmann committed
477

478
(defun jit-lock-force-redisplay (start end)
479 480
  "Force the display engine to re-render START's buffer from START to END.
This applies to the buffer associated with marker START."
481 482 483 484 485 486 487 488 489 490
  (when (marker-buffer start)
    (with-current-buffer (marker-buffer start)
      (with-buffer-prepared-for-jit-lock
       (when (> end (point-max))
         (setq end (point-max) start (min start end)))
       (when (< start (point-min))
         (setq start (point-min) end (max start end)))
       ;; Don't cause refontification (it's already been done), but just do
       ;; some random buffer change, so as to force redisplay.
       (put-text-property start end 'fontified t)))))
Gerd Moellmann's avatar
Gerd Moellmann committed
491 492 493 494

;;; Stealth fontification.

(defsubst jit-lock-stealth-chunk-start (around)
495
  "Return the start of the next chunk to fontify around position AROUND.
Gerd Moellmann's avatar
Gerd Moellmann committed
496
Value is nil if there is nothing more to fontify."
497 498
  (if (zerop (buffer-size))
      nil
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
    (let* ((next (text-property-not-all around (point-max) 'fontified t))
           (prev (previous-single-property-change around 'fontified))
           (prop (get-text-property (max (point-min) (1- around))
                                    'fontified))
           (start (cond
                   ((null prev)
                    ;; There is no property change between AROUND
                    ;; and the start of the buffer.  If PROP is
                    ;; non-nil, everything in front of AROUND is
                    ;; fontified, otherwise nothing is fontified.
                    (if (eq prop t)
                        nil
                      (max (point-min)
                           (- around (/ jit-lock-chunk-size 2)))))
                   ((eq prop t)
                    ;; PREV is the start of a region of fontified
                    ;; text containing AROUND.  Start fontifying a
                    ;; chunk size before the end of the unfontified
                    ;; region in front of that.
                    (max (or (previous-single-property-change prev 'fontified)
                             (point-min))
                         (- prev jit-lock-chunk-size)))
                   (t
                    ;; PREV is the start of a region of unfontified
                    ;; text containing AROUND.  Start at PREV or
                    ;; chunk size in front of AROUND, whichever is
                    ;; nearer.
                    (max prev (- around jit-lock-chunk-size)))))
           (result (cond ((null start) next)
                         ((null next) start)
                         ((< (- around start) (- next around)) start)
                         (t next))))
      result)))
532

533
(defun jit-lock-stealth-fontify (&optional repeat)
Gerd Moellmann's avatar
Gerd Moellmann committed
534
  "Fontify buffers stealthily.
535 536 537 538 539 540
This function is called repeatedly after Emacs has become idle for
`jit-lock-stealth-time' seconds.  Optional argument REPEAT is expected
non-nil in a repeated invocation of this function."
  ;; Cancel timer for repeated invocations.
  (unless repeat
    (cancel-timer jit-lock-stealth-repeat-timer))
Gerd Moellmann's avatar
Gerd Moellmann committed
541
  (unless (or executing-kbd-macro
542
	      memory-full
543
	      (window-minibuffer-p)
544 545 546 547 548 549 550
	      ;; For first invocation set up `jit-lock-stealth-buffers'.
	      ;; In repeated invocations it's already been set up.
	      (null (if repeat
			jit-lock-stealth-buffers
		      (setq jit-lock-stealth-buffers (buffer-list)))))
    (let ((buffer (car jit-lock-stealth-buffers))
	  (delay 0)
Gerd Moellmann's avatar
Gerd Moellmann committed
551
	  minibuffer-auto-raise
552 553 554
	  message-log-max
	  start)
      (if (and jit-lock-stealth-load
555 556 557 558
	       ;; load-average can return nil.  The w32 emulation does
	       ;; that during the first few dozens of seconds after
	       ;; startup.
	       (> (or (car (load-average)) 0) jit-lock-stealth-load))
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
	  ;; Wait a little if load is too high.
	  (setq delay jit-lock-stealth-time)
	(if (buffer-live-p buffer)
	    (with-current-buffer buffer
	      (if (and jit-lock-mode
		       (setq start (jit-lock-stealth-chunk-start (point))))
		  ;; Fontify one block of at most `jit-lock-chunk-size'
		  ;; characters.
		  (with-temp-message (if jit-lock-stealth-verbose
					 (concat "JIT stealth lock "
						 (buffer-name)))
		    (jit-lock-fontify-now start
					  (+ start jit-lock-chunk-size))
		    ;; Run again after `jit-lock-stealth-nice' seconds.
		    (setq delay (or jit-lock-stealth-nice 0)))
		;; Nothing to fontify here.  Remove this buffer from
		;; `jit-lock-stealth-buffers' and run again immediately.
		(setq jit-lock-stealth-buffers (cdr jit-lock-stealth-buffers))))
	  ;; Buffer is no longer live.  Remove it from
	  ;; `jit-lock-stealth-buffers' and run again immediately.
	  (setq jit-lock-stealth-buffers (cdr jit-lock-stealth-buffers))))
      ;; Call us again.
      (when jit-lock-stealth-buffers
	(timer-set-idle-time jit-lock-stealth-repeat-timer (current-idle-time))
	(timer-inc-time jit-lock-stealth-repeat-timer delay)
	(timer-activate-when-idle jit-lock-stealth-repeat-timer t)))))
Gerd Moellmann's avatar
Gerd Moellmann committed
585 586 587 588


;;; Deferred fontification.

589 590
(defun jit-lock-deferred-fontify ()
  "Fontify what was deferred."
591
  (when (and jit-lock-defer-buffers (not memory-full))
592
    ;; Mark the deferred regions back to `fontified = nil'
593
    (dolist (buffer jit-lock-defer-buffers)
594 595 596 597 598 599 600 601 602 603 604 605
      (when (buffer-live-p buffer)
	(with-current-buffer buffer
	  ;; (message "Jit-Defer %s" (buffer-name))
	  (with-buffer-prepared-for-jit-lock
	   (let ((pos (point-min)))
	     (while
		 (progn
		   (when (eq (get-text-property pos 'fontified) 'defer)
		     (put-text-property
		      pos (setq pos (next-single-property-change
				     pos 'fontified nil (point-max)))
		      'fontified nil))
606 607
		   (setq pos (next-single-property-change
                              pos 'fontified)))))))))
608
    ;; Force fontification of the visible parts.
609 610 611
    (let ((buffers jit-lock-defer-buffers)
          (jit-lock-defer-timer nil))
      (setq jit-lock-defer-buffers nil)
612
      ;; (message "Jit-Defer Now")
613 614
      (unless (redisplay)                       ;FIXME: Should we `force'?
        (setq jit-lock-defer-buffers buffers))
615 616
      ;; (message "Jit-Defer Done")
      )))
617

618

619 620
(defun jit-lock-context-fontify ()
  "Refresh fontification to take new context into account."
621 622 623 624 625 626
  (unless memory-full
    (dolist (buffer (buffer-list))
      (with-current-buffer buffer
	(when jit-lock-context-unfontify-pos
	  ;; (message "Jit-Context %s" (buffer-name))
	  (save-restriction
627 628
            ;; Don't be blindsided by narrowing that starts in the middle
            ;; of a jit-lock-defer-multiline.
629
	    (widen)
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
	    (when (and (>= jit-lock-context-unfontify-pos (point-min))
		       (< jit-lock-context-unfontify-pos (point-max)))
	      ;; If we're in text that matches a complex multi-line
	      ;; font-lock pattern, make sure the whole text will be
	      ;; redisplayed eventually.
	      ;; Despite its name, we treat jit-lock-defer-multiline here
	      ;; rather than in jit-lock-defer since it has to do with multiple
	      ;; lines, i.e. with context.
	      (when (get-text-property jit-lock-context-unfontify-pos
				       'jit-lock-defer-multiline)
		(setq jit-lock-context-unfontify-pos
		      (or (previous-single-property-change
			   jit-lock-context-unfontify-pos
			   'jit-lock-defer-multiline)
			  (point-min))))
	      (with-buffer-prepared-for-jit-lock
	       ;; Force contextual refontification.
	       (remove-text-properties
		jit-lock-context-unfontify-pos (point-max)
		'(fontified nil jit-lock-defer-multiline nil)))
	      (setq jit-lock-context-unfontify-pos (point-max)))))))))
651

652 653 654 655 656 657 658 659
(defvar jit-lock-start) (defvar jit-lock-end) ; Dynamically scoped variables.
(defvar jit-lock-after-change-extend-region-functions nil
  "Hook that can extend the text to refontify after a change.
This is run after every buffer change.  The functions are called with
the three arguments of `after-change-functions': START END OLD-LEN.
The extended region to refontify is returned indirectly by modifying
the variables `jit-lock-start' and `jit-lock-end'.

660 661 662 663
Note that extending the region this way is not strictly necessary, except
that the nature of the redisplay code tends to otherwise leave some of
the rehighlighted text displayed with the old highlight until the next
redisplay (see comment about repeated redisplay in `jit-lock-fontify-now').")
664

Gerd Moellmann's avatar
Gerd Moellmann committed
665 666 667 668 669 670 671 672
(defun jit-lock-after-change (start end old-len)
  "Mark the rest of the buffer as not fontified after a change.
Installed on `after-change-functions'.
START and END are the start and end of the changed text.  OLD-LEN
is the pre-change length.
This function ensures that lines following the change will be refontified
in case the syntax of those lines has changed.  Refontification
will take place when text is fontified stealthily."
673
  (when (and jit-lock-mode (not memory-full))
674 675 676
    (let ((jit-lock-start start)
          (jit-lock-end end))
      (with-buffer-prepared-for-jit-lock
Alan Mackenzie's avatar
Alan Mackenzie committed
677 678 679 680 681 682 683 684
       (run-hook-with-args 'jit-lock-after-change-extend-region-functions
			   start end old-len)
       ;; Make sure we change at least one char (in case of deletions).
       (setq jit-lock-end (min (max jit-lock-end (1+ start)) (point-max)))
       ;; Request refontification.
       (save-restriction
	 (widen)
	 (put-text-property jit-lock-start jit-lock-end 'fontified nil)))
685 686 687 688 689 690 691 692 693
      ;; Mark the change for deferred contextual refontification.
      (when jit-lock-context-unfontify-pos
        (setq jit-lock-context-unfontify-pos
              ;; Here we use `start' because nothing guarantees that the
              ;; text between start and end will be otherwise refontified:
              ;; usually it will be refontified by virtue of being
              ;; displayed, but if it's outside of any displayed area in the
              ;; buffer, only jit-lock-context-* will re-fontify it.
              (min jit-lock-context-unfontify-pos jit-lock-start))))))
694

695
(defun jit-lock--antiblink-post-command ()
696 697
  (let* ((new-l-b-p (copy-marker (line-beginning-position)))
         (l-b-p-2 (line-beginning-position 2))
698 699
         (same-line
          (and jit-lock-antiblink-grace
700 701 702 703 704 705
               (not (= new-l-b-p l-b-p-2))
               (eq (marker-buffer jit-lock--antiblink-l-b-p) (current-buffer))
               (= new-l-b-p jit-lock--antiblink-l-b-p)))
         (new-i-s-o-c
          (and same-line
               (nth 8 (save-excursion (syntax-ppss l-b-p-2))))))
706 707 708 709 710
    (cond (;; opened a new multiline string...
           (and same-line
                (null jit-lock--antiblink-i-s-o-c) new-i-s-o-c)
           ;; assert that the grace timer is null and schedule it
           (when jit-lock--antiblink-grace-timer
711
             (message "internal warning: `jit-lock--antiblink-grace-timer' not null"))
712 713 714 715 716 717 718 719 720 721 722 723 724 725
           (setq jit-lock--antiblink-grace-timer
                 (run-with-idle-timer jit-lock-antiblink-grace nil
                                      (lambda ()
                                        (jit-lock-context-fontify)
                                        (setq jit-lock--antiblink-grace-timer nil)))))
          (;; closed an unterminated multiline string.
           (and same-line
                (null new-i-s-o-c) jit-lock--antiblink-i-s-o-c)
           ;; Kill the grace timer, might already have run and died.
           ;; Don't refontify immediately: it adds an unreasonable
           ;; delay to a well-behaved operation.  Leave it for the
           ;; `jit-lock-context-timer' as usual.
           (when jit-lock--antiblink-grace-timer
             (cancel-timer jit-lock--antiblink-grace-timer)
726
             (setq jit-lock--antiblink-grace-timer nil)))
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
          (same-line
           ;; in same line, but no state change, leave everything as it was
           )
          (t
           ;; left the line somehow or customized feature away, etc
           ;; kill timer if running, resume normal operation.
           (when jit-lock--antiblink-grace-timer
             ;; Do refontify immediately, adding a small delay.  This
             ;; is per Lars' request, and it makes sense because we
             ;; should remark somehow that we are leaving the unstable
             ;; state.
             (jit-lock-context-fontify)
             (cancel-timer jit-lock--antiblink-grace-timer)
             (setq jit-lock--antiblink-grace-timer nil))))
    ;; update variables
742
    (setq jit-lock--antiblink-l-b-p   new-l-b-p
743 744
          jit-lock--antiblink-i-s-o-c new-i-s-o-c)))

Gerd Moellmann's avatar
Gerd Moellmann committed
745 746
(provide 'jit-lock)

747
;;; jit-lock.el ends here