;;; jit-lock.el --- just-in-time fontification
-;; Copyright (C) 1998, 2000, 2001, 2004 Free Software Foundation, Inc.
+;; Copyright (C) 1998, 2000, 2001, 2002, 2003, 2004,
+;; 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
;; Author: Gerd Moellmann <gerd@gnu.org>
;; Keywords: faces files
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
+;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
(eval-when-compile
+ (require 'cl)
+
(defmacro with-buffer-unmodified (&rest body)
"Eval BODY, preserving the current buffer's modified state."
+ (declare (debug t))
(let ((modified (make-symbol "modified")))
`(let ((,modified (buffer-modified-p)))
(unwind-protect
(defmacro with-buffer-prepared-for-jit-lock (&rest body)
"Execute BODY in current buffer, overriding several variables.
Preserves the `buffer-modified-p' state of the current buffer."
+ (declare (debug t))
`(with-buffer-unmodified
(let ((buffer-undo-list t)
(inhibit-read-only t)
(defgroup jit-lock nil
"Font Lock support mode to fontify just-in-time."
- :link '(custom-manual "(emacs)Support Modes")
:version "21.1"
:group 'font-lock)
(defcustom jit-lock-chunk-size 500
- "*Jit-lock chunks of this many characters, or smaller."
+ "*Jit-lock fontifies chunks of at most this many characters at a time.
+
+This variable controls both display-time and stealth fontification."
:type 'integer
:group 'jit-lock)
-(defcustom jit-lock-stealth-time 3
+(defcustom jit-lock-stealth-time nil
"*Time in seconds to wait before beginning stealth fontification.
Stealth fontification occurs if there is no input within this time.
If nil, stealth fontification is never performed.
The value of this variable is used when JIT Lock mode is turned on."
:type '(choice (const :tag "never" nil)
- (number :tag "seconds"))
+ (number :tag "seconds" :value 16))
:group 'jit-lock)
-(defcustom jit-lock-stealth-nice 0.125
+(defcustom jit-lock-stealth-nice 0.5
"*Time in seconds to pause between chunks of stealth fontification.
Each iteration of stealth fontification is separated by this amount of time,
thus reducing the demand that stealth fontification makes on the system.
those subsequent lines are not refontified to reflect their new context.
If t, means fontification occurs on those lines modified and all
subsequent lines. This means those subsequent lines are refontified to reflect
-their new syntactic context, either immediately or when scrolling into them.
+their new syntactic context, after `jit-lock-context-time' seconds.
If any other value, e.g., `syntax-driven', means syntactically true
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.
(other :tag "syntax-driven" syntax-driven))
:group 'jit-lock)
+(defcustom jit-lock-context-time 0.5
+ "Idle time after which text is contextually refontified, if applicable."
+ :type '(number :tag "seconds")
+ :group 'jit-lock)
+
(defcustom jit-lock-defer-time nil ;; 0.25
"Idle time after which deferred fontification should take place.
If nil, fontification is not deferred."
(defvar jit-lock-stealth-timer nil
"Timer for stealth fontification in Just-in-time Lock mode.")
-
+(defvar jit-lock-stealth-repeat-timer nil
+ "Timer for repeated stealth fontification in Just-in-time Lock mode.")
+(defvar jit-lock-context-timer nil
+ "Timer for context fontification in Just-in-time Lock mode.")
(defvar jit-lock-defer-timer nil
"Timer for deferred fontification in Just-in-time Lock mode.")
(defvar jit-lock-defer-buffers nil
"List of buffers with pending deferred fontification.")
+(defvar jit-lock-stealth-buffers nil
+ "List of buffers that are being fontified stealthily.")
\f
;;; JIT lock mode
- Deferred context fontification if `jit-lock-contextually' is
non-nil. This means fontification updates the buffer corresponding to
- true syntactic context, after `jit-lock-stealth-time' seconds of Emacs
+ true syntactic context, after `jit-lock-context-time' seconds of Emacs
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
(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
;; 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
+ 'jit-lock-context-fontify)))
(setq jit-lock-context-unfontify-pos
(or jit-lock-context-unfontify-pos (point-max))))
;; Turn Just-in-time Lock mode off.
(t
;; Cancel our idle timers.
- (when (and (or jit-lock-stealth-timer jit-lock-defer-timer)
+ (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))
(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-hook 'after-change-functions 'jit-lock-after-change t)
(remove-hook 'fontification-functions 'jit-lock-function))))
-;;;###autoload
(defun jit-lock-register (fun &optional contextual)
"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
"Fontify current buffer starting at position START.
This function is added to `fontification-functions' when `jit-lock-mode'
is active."
- (when jit-lock-mode
- (if (null jit-lock-defer-time)
+ (when (and jit-lock-mode (not memory-full))
+ (if (null jit-lock-defer-timer)
;; No deferral.
(jit-lock-fontify-now start (+ start jit-lock-chunk-size))
;; Record the buffer for later fontification.
;; from the end of a buffer to its start, can do repeated
;; `parse-partial-sexp' starting from `point-min', which can
;; take a long time in a large buffer.
- (let (next)
+ (let ((orig-start start) next)
(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.
- (while start
+ (while (and start (< start end))
;; Determine the end of this chunk.
(setq next (or (text-property-any start end 'fontified t)
end))
(goto-char next) (setq next (line-beginning-position 2))
(goto-char start) (setq start (line-beginning-position))
+ ;; 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 next)
+ (>= jit-lock-context-unfontify-pos start)
+ ;; 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 start 'jit-lock-defer-multiline)))
+ (setq jit-lock-context-unfontify-pos next))
+
;; 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.
(quit (put-text-property start next 'fontified nil)
(funcall 'signal (car err) (cdr err))))
+ ;; 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 `start' is before `orig-start', we need to
+ ;; cause a new redisplay cycle after this one so that any 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 (< start orig-start)
+ (run-with-timer 0 nil 'jit-lock-force-redisplay
+ (current-buffer) start orig-start))
+
;; Find the start of the next chunk, if any.
(setq start (text-property-any next end 'fontified nil))))))))
+(defun jit-lock-force-redisplay (buf start end)
+ "Force the display engine to re-render buffer BUF from START to END."
+ (with-current-buffer buf
+ (with-buffer-prepared-for-jit-lock
+ ;; 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))))
+
+
\f
;;; Stealth fontification.
(t next))))
result))))
-
-(defun jit-lock-stealth-fontify ()
+(defun jit-lock-stealth-fontify (&optional repeat)
"Fontify buffers stealthily.
-This functions is called after Emacs has been idle for
-`jit-lock-stealth-time' seconds."
- ;; I used to check `inhibit-read-only' here, but I can't remember why. -stef
+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))
(unless (or executing-kbd-macro
- (window-minibuffer-p (selected-window)))
- (let ((buffers (buffer-list))
+ memory-full
+ (window-minibuffer-p (selected-window))
+ ;; 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)
minibuffer-auto-raise
- message-log-max)
- (with-local-quit
- (while (and buffers (not (input-pending-p)))
- (with-current-buffer (pop buffers)
- (when jit-lock-mode
- ;; This is funny. Calling sit-for with 3rd arg non-nil
- ;; so that it doesn't redisplay, internally calls
- ;; wait_reading_process_input also with a parameter
- ;; saying "don't redisplay." Since this function here
- ;; is called periodically, this effectively leads to
- ;; process output not being redisplayed at all because
- ;; redisplay_internal is never called. (That didn't
- ;; work in the old redisplay either.) So, we learn that
- ;; we mustn't call sit-for that way here. But then, we
- ;; have to be cautious not to call sit-for in a widened
- ;; buffer, since this could display hidden parts of that
- ;; buffer. This explains the seemingly weird use of
- ;; save-restriction/widen here.
-
- (with-temp-message (if jit-lock-stealth-verbose
- (concat "JIT stealth lock "
- (buffer-name)))
-
- ;; Perform deferred unfontification, if any.
- (when jit-lock-context-unfontify-pos
- (save-restriction
- (widen)
- (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.
- (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
- (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)))))
-
- ;; In the following code, the `sit-for' calls cause a
- ;; redisplay, so it's required that the
- ;; buffer-modified flag of a buffer that is displayed
- ;; has the right value---otherwise the mode line of
- ;; an unmodified buffer would show a `*'.
- (let (start
- (nice (or jit-lock-stealth-nice 0))
- (point (point-min)))
- (while (and (setq start
- (jit-lock-stealth-chunk-start point))
- (sit-for nice))
-
- ;; fontify a block.
- (jit-lock-fontify-now start (+ start jit-lock-chunk-size))
- ;; If stealth jit-locking is done backwards, this leads to
- ;; excessive O(n^2) refontification. -stef
- ;; (when (>= jit-lock-context-unfontify-pos start)
- ;; (setq jit-lock-context-unfontify-pos end))
-
- ;; Wait a little if load is too high.
- (when (and jit-lock-stealth-load
- (> (car (load-average)) jit-lock-stealth-load))
- (sit-for (or jit-lock-stealth-time 30)))))))))))))
-
+ message-log-max
+ start)
+ (if (and jit-lock-stealth-load
+ (> (car (load-average)) jit-lock-stealth-load))
+ ;; 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)))))
\f
;;; Deferred fontification.
(defun jit-lock-deferred-fontify ()
"Fontify what was deferred."
- (when jit-lock-defer-buffers
+ (when (and jit-lock-defer-buffers (not memory-full))
;; Mark the deferred regions back to `fontified = nil'
(dolist (buffer jit-lock-defer-buffers)
(when (buffer-live-p buffer)
(setq pos (next-single-property-change pos 'fontified)))))))))
(setq jit-lock-defer-buffers nil)
;; Force fontification of the visible parts.
- (let ((jit-lock-defer-time nil))
+ (let ((jit-lock-defer-timer nil))
;; (message "Jit-Defer Now")
(sit-for 0)
;; (message "Jit-Defer Done")
)))
+(defun jit-lock-context-fontify ()
+ "Refresh fontification to take new context into account."
+ (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
+ (widen)
+ (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)))))))))
+
+(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'.
+
+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').")
+
(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'.
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."
- (when jit-lock-mode
- (save-excursion
+ (when (and jit-lock-mode (not memory-full))
+ (let ((jit-lock-start start)
+ (jit-lock-end end))
(with-buffer-prepared-for-jit-lock
- ;; It's important that the `fontified' property be set from the
- ;; beginning of the line, else font-lock will properly change the
- ;; text's face, but the display will have been done already and will
- ;; be inconsistent with the buffer's content.
- (goto-char start)
- (setq start (line-beginning-position))
-
- ;; If we're in text that matches a multi-line font-lock pattern,
- ;; make sure the whole text will be redisplayed.
- ;; I'm not sure this is ever necessary and/or sufficient. -stef
- (when (get-text-property start 'font-lock-multiline)
- (setq start (or (previous-single-property-change
- start 'font-lock-multiline)
- (point-min))))
-
- ;; Make sure we change at least one char (in case of deletions).
- (setq end (min (max end (1+ start)) (point-max)))
- ;; Request refontification.
- (put-text-property start end 'fontified nil))
+ (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.
+ (put-text-property jit-lock-start jit-lock-end 'fontified nil))
;; Mark the change for deferred contextual refontification.
(when jit-lock-context-unfontify-pos
- (setq jit-lock-context-unfontify-pos
- (min jit-lock-context-unfontify-pos start))))))
+ (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))))))
(provide 'jit-lock)
-;;; arch-tag: 56b5de6e-f581-453b-bb97-49c39372ff9e
+;; arch-tag: 56b5de6e-f581-453b-bb97-49c39372ff9e
;;; jit-lock.el ends here