(unless ,modified
(restore-buffer-modified-p nil)))))
- (defmacro with-buffer-prepared-for-font-lock (&rest body)
+ (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."
`(with-buffer-unmodified
(let ((buffer-undo-list t)
(inhibit-read-only t)
(inhibit-point-motion-hooks t)
- before-change-functions
- after-change-functions
+ (inhibit-modification-hooks t)
deactivate-mark
buffer-file-name
buffer-file-truename)
;;; Customization.
(defcustom jit-lock-chunk-size 500
- "*Font-lock chunks of this many characters, or smaller."
+ "*Jit-lock chunks of this many characters, or smaller."
:type 'integer
:group 'jit-lock)
(defvar jit-lock-first-unfontify-pos nil
- "Consider text after this position as unfontified.")
+ "Consider text after this position as unfontified.
+If nil, contextual fontification is disabled.")
(make-variable-buffer-local 'jit-lock-first-unfontify-pos)
(defvar jit-lock-stealth-timer nil
"Timer for stealth fontification in Just-in-time Lock mode.")
+(defvar jit-lock-saved-fontify-buffer-function nil
+ "Value of `font-lock-fontify-buffer-function' before jit-lock's activation.")
\f
;;; JIT lock mode
;;;###autoload
(defun jit-lock-mode (arg)
"Toggle Just-in-time Lock mode.
-With arg, turn Just-in-time Lock mode on if and only if arg is positive.
+Turn Just-in-time Lock mode on if and only if ARG is non-nil.
Enable it automatically by customizing group `font-lock'.
When Just-in-time Lock mode is enabled, fontification is different in the
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
-the variable `jit-lock-stealth-nice' and `jit-lock-stealth-lines'."
- (interactive "P")
- (setq jit-lock-mode (if arg
- (> (prefix-numeric-value arg) 0)
- (not jit-lock-mode)))
- (cond ((and jit-lock-mode
- (or (not (boundp 'font-lock-mode))
- (not font-lock-mode)))
- ;; If font-lock is not on, turn it on, with Just-in-time
- ;; Lock mode as support mode; font-lock will call us again.
- (let ((font-lock-support-mode 'jit-lock-mode))
- (font-lock-mode t)))
-
- ;; Turn Just-in-time Lock mode on.
- (jit-lock-mode
+the variable `jit-lock-stealth-nice'."
+ (setq jit-lock-mode arg)
+ (cond (;; Turn Just-in-time Lock mode on.
+ jit-lock-mode
+
+ ;; Mark the buffer for refontification
+ ;; (in case spurious `fontified' text-props were left around).
+ (jit-lock-fontify-buffer)
+
;; Setting `font-lock-fontified' makes font-lock believe the
;; buffer is already fontified, so that it won't highlight
- ;; the whole buffer.
- (make-local-variable 'font-lock-fontified)
- (setq font-lock-fontified t)
+ ;; the whole buffer or bail out on a large buffer.
+ (set (make-local-variable 'font-lock-fontified) t)
+
+ ;; Setup JIT font-lock-fontify-buffer.
+ (unless jit-lock-saved-fontify-buffer-function
+ (set (make-local-variable 'jit-lock-saved-fontify-buffer-function)
+ font-lock-fontify-buffer-function)
+ (set (make-local-variable 'font-lock-fontify-buffer-function)
+ 'jit-lock-fontify-buffer))
- (setq jit-lock-first-unfontify-pos nil)
-
;; Install an idle timer for stealth fontification.
(when (and jit-lock-stealth-time
(null jit-lock-stealth-timer))
- (setq jit-lock-stealth-timer
+ (setq jit-lock-stealth-timer
(run-with-idle-timer jit-lock-stealth-time
jit-lock-stealth-time
'jit-lock-stealth-fontify)))
- ;; Add a hook for deferred contectual fontification.
+ ;; Initialize deferred contextual fontification if requested.
(when (or (eq jit-lock-defer-contextually 'always)
(and (not (eq jit-lock-defer-contextually 'never))
(null font-lock-keywords-only)))
- (add-hook 'after-change-functions 'jit-lock-after-change))
+ (setq jit-lock-first-unfontify-pos (point-max)))
+
+ ;; Setup our after-change-function
+ ;; and remove font-lock's (if any).
+ (remove-hook 'after-change-functions 'font-lock-after-change-function t)
+ (add-hook 'after-change-functions 'jit-lock-after-change nil t)
;; Install the fontification hook.
(add-hook 'fontification-functions 'jit-lock-function))
(cancel-timer jit-lock-stealth-timer)
(setq jit-lock-stealth-timer nil))
- ;; Remove hooks.
- (remove-hook 'after-change-functions 'jit-lock-after-change)
+ ;; Restore non-JIT font-lock-fontify-buffer.
+ (when jit-lock-saved-fontify-buffer-function
+ (set (make-local-variable 'font-lock-fontify-buffer-function)
+ jit-lock-saved-fontify-buffer-function)
+ (setq jit-lock-saved-fontify-buffer-function nil))
+
+ ;; Remove hooks (and restore font-lock's if necessary).
+ (remove-hook 'after-change-functions 'jit-lock-after-change t)
+ (when font-lock-mode
+ (add-hook 'after-change-functions
+ 'font-lock-after-change-function nil t))
(remove-hook 'fontification-functions 'jit-lock-function))))
-;;;###autoload
-(defun turn-on-jit-lock ()
- "Unconditionally turn on Just-in-time Lock mode."
- (jit-lock-mode 1))
-
+;; This function is used to prevent font-lock-fontify-buffer from
+;; fontifying eagerly the whole buffer. This is important for
+;; things like CWarn mode which adds/removes a few keywords and
+;; does a refontify (which takes ages on large files).
+(defun jit-lock-fontify-buffer ()
+ (with-buffer-prepared-for-jit-lock
+ (save-restriction
+ (widen)
+ (add-text-properties (point-min) (point-max) '(fontified nil)))))
\f
;;; On demand fontification.
(defun jit-lock-function-1 (start)
- "Fontify current buffer starting at position START.
-This function is added to `fontification-functions' when `jit-lock-mode'
-is active."
- (with-buffer-prepared-for-font-lock
+ "Fontify current buffer starting at position START."
+ (with-buffer-prepared-for-jit-lock
(save-excursion
(save-restriction
(widen)
;; Restore previous buffer settings.
(set-syntax-table old-syntax-table))))))
-
-(defun jit-lock-after-fontify-buffer ()
- "Mark the current buffer as fontified.
-Called from `font-lock-after-fontify-buffer."
- (with-buffer-prepared-for-font-lock
- (add-text-properties (point-min) (point-max) '(fontified t))))
-
-
-(defun jit-lock-after-unfontify-buffer ()
- "Mark the current buffer as unfontified.
-Called from `font-lock-after-fontify-buffer."
- (with-buffer-prepared-for-font-lock
- (remove-text-properties (point-min) (point-max) '(fontified nil))))
-
-
\f
;;; Stealth fontification.
(- around (/ jit-lock-chunk-size 2)))))
(prop
;; PREV is the start of a region of fontified
- ;; text containing AROUND. Start fontfifying a
+ ;; 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)
(widen)
(when (and (>= jit-lock-first-unfontify-pos (point-min))
(< jit-lock-first-unfontify-pos (point-max)))
- (with-buffer-prepared-for-font-lock
+ (with-buffer-prepared-for-jit-lock
(put-text-property jit-lock-first-unfontify-pos
(point-max) 'fontified nil))
- (setq jit-lock-first-unfontify-pos 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
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."
- ;; Don't do much here---removing text properties is too slow for
- ;; fast typers, giving them the impression of Emacs not being
- ;; very responsive.
(when jit-lock-mode
- (setq jit-lock-first-unfontify-pos
- (if jit-lock-first-unfontify-pos
- (min jit-lock-first-unfontify-pos start)
- start))))
+ (save-excursion
+ (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))
+ ;; 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))
+ ;; 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))))))
-
(provide 'jit-lock)
;; jit-lock.el ends here