;;; jit-lock.el --- just-in-time fontification
-;; Copyright (C) 1998, 2000, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 1998, 2000, 2001, 2004 Free Software Foundation, Inc.
;; Author: Gerd Moellmann <gerd@gnu.org>
;; Keywords: faces files
(eval-when-compile
(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)
\f
;;; Customization.
+(defgroup jit-lock nil
+ "Font Lock support mode to fontify just-in-time."
+ :version "21.1"
+ :group 'font-lock)
+
(defcustom jit-lock-chunk-size 500
"*Jit-lock chunks of this many characters, or smaller."
:type 'integer
:group 'jit-lock)
-(defcustom jit-lock-defer-contextually 'syntax-driven
- "*If non-nil, means deferred fontification should be syntactically true.
-If nil, means deferred fontification occurs only on those lines modified. This
+(defvaralias 'jit-lock-defer-contextually 'jit-lock-contextually)
+(defcustom jit-lock-contextually 'syntax-driven
+ "*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.
-If t, means deferred fontification occurs on those lines modified and all
+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.
-If any other value, e.g., `syntax-driven', means deferred syntactically true
+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"))
+
(defcustom jit-lock-defer-time nil ;; 0.25
"Idle time after which deferred fontification should take place.
If nil, fontification is not deferred."
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-first-unfontify-pos nil
+(defvar 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-first-unfontify-pos)
+(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-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-buffers nil
+(defvar jit-lock-defer-buffers nil
"List of buffers with pending deferred fontification.")
\f
;;; JIT lock mode
been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle.
This is useful if any buffer has any deferred fontification.
-- Deferred context fontification if `jit-lock-defer-contextually' is
+- 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-defer-time t
'jit-lock-deferred-fontify)))
- ;; Initialize deferred contextual fontification if requested.
- (when (eq jit-lock-defer-contextually t)
- (setq jit-lock-first-unfontify-pos
- (or jit-lock-first-unfontify-pos (point-max))))
+ ;; 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))))
;; Setup our hooks.
(add-hook 'after-change-functions 'jit-lock-after-change nil t)
;; 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)))
that needs to be (re)fontified.
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-defer-contextually)
- (set (make-local-variable 'jit-lock-defer-contextually) t))
+ (when (and contextual jit-lock-contextually)
+ (set (make-local-variable 'jit-lock-contextually) t))
(jit-lock-mode t))
(defun jit-lock-unregister (fun)
;; No deferral.
(jit-lock-fontify-now start (+ start jit-lock-chunk-size))
;; Record the buffer for later fontification.
- (unless (memq (current-buffer) jit-lock-buffers)
- (push (current-buffer) jit-lock-buffers))
+ (unless (memq (current-buffer) jit-lock-defer-buffers)
+ (push (current-buffer) jit-lock-defer-buffers))
;; 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
;; 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)
- (run-hook-with-args 'jit-lock-functions start next)
+ (condition-case err
+ (run-hook-with-args 'jit-lock-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)
+ (funcall 'signal (car err) (cdr err))))
;; Find the start of the next chunk, if any.
(setq start (text-property-any next end 'fontified nil))))))))
(let ((buffers (buffer-list))
minibuffer-auto-raise
message-log-max)
- (while (and buffers (not (input-pending-p)))
- (let ((buffer (car buffers)))
- (setq buffers (cdr buffers))
-
- (with-current-buffer buffer
+ (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
(concat "JIT stealth lock "
(buffer-name)))
- ;; Perform deferred unfontification, if any.
- (when jit-lock-first-unfontify-pos
- (save-restriction
- (widen)
- (when (and (>= jit-lock-first-unfontify-pos (point-min))
- (< jit-lock-first-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-first-unfontify-pos
- 'jit-lock-defer-multiline)
- (setq jit-lock-first-unfontify-pos
- (or (previous-single-property-change
- jit-lock-first-unfontify-pos
- 'jit-lock-defer-multiline)
- (point-min))))
- (with-buffer-prepared-for-jit-lock
- (remove-text-properties
- jit-lock-first-unfontify-pos (point-max)
- '(fontified nil jit-lock-defer-multiline nil)))
- (setq jit-lock-first-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
(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-first-unfontify-pos start)
- ;; (setq jit-lock-first-unfontify-pos end))
+ ;; (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
(defun jit-lock-deferred-fontify ()
"Fontify what was deferred."
- (when jit-lock-buffers
+ (when jit-lock-defer-buffers
;; Mark the deferred regions back to `fontified = nil'
- (dolist (buffer jit-lock-buffers)
+ (dolist (buffer jit-lock-defer-buffers)
(when (buffer-live-p buffer)
(with-current-buffer buffer
;; (message "Jit-Defer %s" (buffer-name))
pos 'fontified nil (point-max)))
'fontified nil))
(setq pos (next-single-property-change pos 'fontified)))))))))
- (setq jit-lock-buffers nil)
+ (setq jit-lock-defer-buffers nil)
;; Force fontification of the visible parts.
(let ((jit-lock-defer-time nil))
;; (message "Jit-Defer Now")
)))
+(defun jit-lock-context-fontify ()
+ "Refresh fontification to take new context into account."
+ (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))))))))
+
(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'.
;; Request refontification.
(put-text-property start end 'fontified nil))
;; Mark the change for deferred contextual refontification.
- (when jit-lock-first-unfontify-pos
- (setq jit-lock-first-unfontify-pos
- (min jit-lock-first-unfontify-pos start))))))
+ (when jit-lock-context-unfontify-pos
+ (setq jit-lock-context-unfontify-pos
+ (min jit-lock-context-unfontify-pos start))))))
(provide 'jit-lock)
+;;; arch-tag: 56b5de6e-f581-453b-bb97-49c39372ff9e
;;; jit-lock.el ends here
HCoop / bpt / emacs.git / blobdiff