;;; 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 Free Software Foundation, Inc.
;; Author: Gerd Moellmann <gerd@gnu.org>
;; Keywords: faces files
;; 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:
: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-context-time 0.5
"Idle time after which text is contextually refontified, if applicable."
- :type '(number :tag "seconds"))
-
+ :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."
(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
+ (when (and jit-lock-mode (not memory-full))
(if (null jit-lock-defer-time)
;; No deferral.
(jit-lock-fontify-now start (+ start jit-lock-chunk-size))
(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.
`jit-lock-stealth-time' seconds."
;; I used to check `inhibit-read-only' here, but I can't remember why. -stef
(unless (or executing-kbd-macro
+ memory-full
(window-minibuffer-p (selected-window)))
(let ((buffers (buffer-list))
(outer-buffer (current-buffer))
(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)
(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))))))))
+ (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)))))))))
(defun jit-lock-after-change (start end old-len)
"Mark the rest of the buffer as not fontified after a change.
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
+ (when (and jit-lock-mode (not memory-full))
(save-excursion
(with-buffer-prepared-for-jit-lock
;; It's important that the `fontified' property be set from the
;; 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 start))))))
(provide 'jit-lock)
-;;; arch-tag: 56b5de6e-f581-453b-bb97-49c39372ff9e
+;; arch-tag: 56b5de6e-f581-453b-bb97-49c39372ff9e
;;; jit-lock.el ends here