(jit-lock-function, jit-lock-stealth-fontify)

(jit-lock-deferred-fontify, jit-lock-context-fontify)
(jit-lock-after-change): Test memory-full.

1 files changed, 32 insertions, 30 deletions

diff --git a/lisp/jit-lock.el b/lisp/jit-lock.el
index 9e6121c17a1..d3e3be12073 100644
--- a/lisp/jit-lock.el
+++ b/lisp/jit-lock.el
@@ -299,7 +299,7 @@ Only applies to the current buffer."
   "Fontify current buffer starting at position START.
 This function is added to `fontification-functions' when `jit-lock-mode'
 is active."
-  (when (and jit-lock-mode (not (memory-full-p)))
+  (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))
@@ -427,6 +427,7 @@ This functions is called after Emacs has been idle for
 `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))
@@ -490,7 +491,7 @@ This functions is called after Emacs has been idle for
 
 (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)
@@ -517,33 +518,34 @@ This functions is called after Emacs has been idle for
 
 (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.
@@ -553,7 +555,7 @@ is the pre-change length.
 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 (and jit-lock-mode (not (memory-full-p)))
+  (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