From a62e3c6f35f76a6bb22dc28f23df2d609993eb37 Mon Sep 17 00:00:00 2001 From: Stefan Monnier Date: Sun, 8 Oct 2000 19:01:17 +0000 Subject: [PATCH] Don't require font-lock any more. (jit-lock-functions): Make buffer-local. (jit-lock-saved-fontify-buffer-function): Remove. (jit-lock-mode): Remove autoload cookie. Remove font-lock specific code. (jit-lock-unregister): Don't bother handling complex hooks any more. (jit-lock-refontify): New function. (jit-lock-fontify-buffer): Use it. (jit-lock-function-1): Replaced by jit-lock-fontify-now. (jit-lock-fontify-now): Renamed from jit-lock-function-1. Add optional args START and END. Never call font-lock-fontify-region directly. (jit-lock-function, jit-lock-stealth-fontify): Use it. --- lisp/jit-lock.el | 91 ++++++++++++++---------------------------------- 1 file changed, 27 insertions(+), 64 deletions(-) diff --git a/lisp/jit-lock.el b/lisp/jit-lock.el index 3b672aaf680..e4323a0bdde 100644 --- a/lisp/jit-lock.el +++ b/lisp/jit-lock.el @@ -30,8 +30,6 @@ ;;; Code: -(require 'font-lock) - (eval-when-compile (defmacro with-buffer-unmodified (&rest body) "Eval BODY, preserving the current buffer's modified state." @@ -141,23 +139,19 @@ The value of this variable is used when JIT Lock mode is turned on." (defvar 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-first-unfontify-pos nil - "Consider text after this position as unfontified. + "Consider text after this position as contextually 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.") - ;;; JIT lock mode -;;;###autoload (defun jit-lock-mode (arg) "Toggle Just-in-time Lock mode. Turn Just-in-time Lock mode on if and only if ARG is non-nil. @@ -193,21 +187,8 @@ the variable `jit-lock-stealth-nice'." (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 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)) + ;; Mark the buffer for refontification + (jit-lock-refontify) ;; Install an idle timer for stealth fontification. (when (and jit-lock-stealth-time (null jit-lock-stealth-timer)) @@ -217,19 +198,12 @@ the variable `jit-lock-stealth-nice'." 'jit-lock-stealth-fontify))) ;; Initialize deferred contextual fontification if requested. - (when (or (eq jit-lock-defer-contextually t) - (and jit-lock-defer-contextually - (boundp 'font-lock-keywords-only) - (null font-lock-keywords-only))) + (when (eq jit-lock-defer-contextually t) (setq jit-lock-first-unfontify-pos (or 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) + ;; Setup our hooks. (add-hook 'after-change-functions 'jit-lock-after-change nil t) - - ;; Install the fontification hook. (add-hook 'fontification-functions 'jit-lock-function)) ;; Turn Just-in-time Lock mode off. @@ -239,17 +213,8 @@ the variable `jit-lock-stealth-nice'." (cancel-timer jit-lock-stealth-timer) (setq jit-lock-stealth-timer nil)) - ;; 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 hooks. (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 @@ -267,21 +232,20 @@ If non-nil, CONTEXTUAL means that a contextual fontification would be useful." "Unregister FUN as a fontification function. Only applies to the current buffer." (remove-hook 'jit-lock-functions fun t) - (when (or (null jit-lock-functions) - (and (equal jit-lock-functions '(t)) - (null (default-value 'jit-lock-functions)))) - (jit-lock-mode nil))) + (unless jit-lock-functions (jit-lock-mode nil))) ;; 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 () +(defalias 'jit-lock-fontify-buffer 'jit-lock-refontify) +(defun jit-lock-refontify (&optional beg end) + "Force refontification of the region BEG..END (default whole buffer)." (with-buffer-prepared-for-jit-lock (save-restriction (widen) - (add-text-properties (point-min) (point-max) '(fontified nil))))) - + (add-text-properties (or beg (point-min)) (or end (point-max)) + '(fontified nil))))) ;;; On demand fontification. @@ -290,17 +254,19 @@ Only applies to the current buffer." This function is added to `fontification-functions' when `jit-lock-mode' is active." (when jit-lock-mode - (jit-lock-function-1 start))) + (jit-lock-fontify-now start (+ start jit-lock-chunk-size)))) - -(defun jit-lock-function-1 (start) - "Fontify current buffer starting at position START." + +(defun jit-lock-fontify-now (&optional start end) + "Fontify current buffer from START to END. +Defaults to the whole buffer. END can be out of bounds." (with-buffer-prepared-for-jit-lock (save-excursion (save-restriction (widen) - (let ((end (min (point-max) (+ start jit-lock-chunk-size))) - (font-lock-beginning-of-syntax-function nil) + (unless start (setq start (point-min))) + (setq end (if end (min end (point-max)) (point-max))) + (let ((font-lock-beginning-of-syntax-function nil) next) (save-match-data ;; Fontify chunks beginning at START. The end of a @@ -317,18 +283,14 @@ is active." ;; Until someone has a better idea, let's start ;; at the start of the line containing START and ;; stop at the start of the line following NEXT. - (goto-char next) - (setq next (line-beginning-position 2)) - (goto-char start) - (setq start (line-beginning-position)) - + (goto-char next) (setq next (line-beginning-position 2)) + (goto-char start) (setq start (line-beginning-position)) + ;; 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. (add-text-properties start next '(fontified t)) - (if jit-lock-functions - (run-hook-with-args 'jit-lock-functions start next) - (font-lock-fontify-region start next)) + (run-hook-with-args 'jit-lock-functions start next) ;; Find the start of the next chunk, if any. (setq start (text-property-any next end 'fontified nil))))))))) @@ -441,7 +403,8 @@ This functions is called after Emacs has been idle for ;; Unless there's input pending now, fontify. (unless (input-pending-p) - (jit-lock-function-1 start)))))))))))) + (jit-lock-fontify-now + start (+ start jit-lock-chunk-size))))))))))))) -- 2.39.2