Merge from emacs-24; up to 2012-12-24T15:56:17Z!eliz@gnu.org

[bpt/emacs.git] / lisp / jit-lock.el

diff --git a/lisp/jit-lock.el b/lisp/jit-lock.el
index 668f1ec..d879735 100644 (file)
--- a/lisp/jit-lock.el
+++ b/lisp/jit-lock.el
@@ -132,20 +132,16 @@ If nil, fontification is not deferred."
 \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.")
@@ -305,7 +301,7 @@ 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-contextually)
-    (set (make-local-variable 'jit-lock-contextually) t))
+    (setq-local jit-lock-contextually t))
   (jit-lock-mode t))
 
 (defun jit-lock-unregister (fun)
@@ -439,41 +435,39 @@ Defaults to the whole buffer.  END can be out of bounds."
 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))))
+    (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.
@@ -564,7 +558,9 @@ non-nil in a repeated invocation of this function."
        (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