;;; jit-lock.el --- just-in-time fontification
-;; Copyright (C) 1998, 2000, 2001, 2002, 2003, 2004,
-;; 2005, 2006 Free Software Foundation, Inc.
+;; Copyright (C) 1998, 2000-2013 Free Software Foundation, Inc.
;; Author: Gerd Moellmann <gerd@gnu.org>
;; Keywords: faces files
+;; Package: emacs
;; This file is part of GNU Emacs.
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; 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)
-;; any later version.
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.
;; 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., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; 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
- (progn ,@body)
- (unless ,modified
- (restore-buffer-modified-p nil))))))
-
(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)
- (inhibit-point-motion-hooks t)
- (inhibit-modification-hooks t)
- deactivate-mark
- buffer-file-name
- buffer-file-truename)
- ,@body))))
-
-
+ `(let ((inhibit-point-motion-hooks t))
+ (with-silent-modifications
+ ,@body))))
\f
;;; Customization.
:group 'font-lock)
(defcustom jit-lock-chunk-size 500
- "*Jit-lock fontifies chunks of at most this many characters at a time.
+ "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 16
- "*Time in seconds to wait before beginning stealth fontification.
+(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.5
- "*Time in seconds to pause between chunks of stealth fontification.
+ "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.
If nil, means stealth fontification is never paused.
(defcustom jit-lock-stealth-load
(if (condition-case nil (load-average) (error)) 200)
- "*Load in percentage above which stealth fontification is suspended.
+ "Load in percentage above which stealth fontification is suspended.
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.
(defcustom jit-lock-stealth-verbose nil
- "*If non-nil, means stealth fontification should show status messages."
+ "If non-nil, means stealth fontification should show status messages."
:type 'boolean
:group 'jit-lock)
(defvaralias 'jit-lock-defer-contextually 'jit-lock-contextually)
(defcustom jit-lock-contextually 'syntax-driven
- "*If non-nil, means fontification should be syntactically true.
+ "If non-nil, means fontification should be syntactically true.
If nil, means fontification occurs only on those lines modified. This
means where modification on a line causes syntactic change on subsequent lines,
those subsequent lines are not refontified to reflect their new context.
\f
;;; Variables that are not customizable.
-(defvar jit-lock-mode nil
+(defvar-local jit-lock-mode nil
"Non-nil means Just-in-time Lock mode is active.")
-(make-variable-buffer-local 'jit-lock-mode)
-(defvar jit-lock-functions nil
+(defvar-local jit-lock-functions nil
"Functions to do the actual fontification.
They are called with two arguments: the START and END of the region to fontify.")
-(make-variable-buffer-local 'jit-lock-functions)
-(defvar jit-lock-context-unfontify-pos nil
+(defvar-local jit-lock-context-unfontify-pos nil
"Consider text after this position as contextually unfontified.
If nil, contextual fontification is disabled.")
-(make-variable-buffer-local 'jit-lock-context-unfontify-pos)
-
(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
(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
(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
(remove-hook 'after-change-functions 'jit-lock-after-change t)
(remove-hook 'fontification-functions 'jit-lock-function))))
+(define-minor-mode jit-lock-debug-mode
+ "Minor mode to help debug code run from jit-lock.
+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."
+ :global t
+ (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))))
+
(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
If non-nil, CONTEXTUAL means that a contextual fontification would be useful."
(add-hook 'jit-lock-functions fun nil t)
(when (and contextual jit-lock-contextually)
- (set (make-local-variable 'jit-lock-contextually) t))
+ (setq-local jit-lock-contextually t))
(jit-lock-mode t))
(defun jit-lock-unregister (fun)
;; 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))
;; eagerly extend the refontified region with
;; jit-lock-after-change-extend-region-functions.
(when (< start orig-start)
- (lexical-let ((start start)
- (orig-start orig-start)
- (buf (current-buffer)))
- (run-with-timer
- 0 nil (lambda ()
- (with-buffer-prepared-for-jit-lock
- (put-text-property start orig-start
- 'fontified t buf))))))
+ (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.
(defsubst jit-lock-stealth-chunk-start (around)
- "Return the start of the next chunk to fontify around position AROUND..
+ "Return the start of the next chunk to fontify around position AROUND.
Value is nil if there is nothing more to fontify."
(if (zerop (buffer-size))
nil
- (save-restriction
- (widen)
- (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))))
-
-
-(defun jit-lock-stealth-fontify ()
+ (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)))
+
+(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
memory-full
- (window-minibuffer-p (selected-window)))
- (let ((buffers (buffer-list))
- (outer-buffer (current-buffer))
+ (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)))
-
- ;; 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))
- ;; In case sit-for runs any timers,
- ;; give them the expected current buffer.
- (with-current-buffer outer-buffer
- (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))
- ;; In case sit-for runs any timers,
- ;; give them the expected current buffer.
- (with-current-buffer outer-buffer
- (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.
pos (setq pos (next-single-property-change
pos 'fontified nil (point-max)))
'fontified nil))
- (setq pos (next-single-property-change pos 'fontified)))))))))
+ (setq pos (next-single-property-change
+ pos 'fontified)))))))))
(setq jit-lock-defer-buffers nil)
;; Force fontification of the visible parts.
(let ((jit-lock-defer-timer nil))
(when jit-lock-context-unfontify-pos
;; (message "Jit-Context %s" (buffer-name))
(save-restriction
- (widen)
+ ;; Don't be blindsided by narrowing that starts in the middle
+ ;; of a jit-lock-defer-multiline.
+ (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
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 in `jit-lock-fontify-now'.")
+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.
(provide 'jit-lock)
-;; arch-tag: 56b5de6e-f581-453b-bb97-49c39372ff9e
;;; jit-lock.el ends here
HCoop / bpt / emacs.git / blobdiff