(line-move): Turn off intangibility for intermediate stops.

1 files changed, 71 insertions, 60 deletions

diff --git a/lisp/simple.el b/lisp/simple.el
index b7515e2015e..943155cfab4 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -1601,67 +1601,78 @@ When the `track-eol' feature is doing its job, the value is 9999.")
   "*Non-nil means \\[next-line] and \\[previous-line] ignore invisible lines.
 Outline mode sets this.")
 
+;; This is the guts of next-line and previous-line.
+;; Arg says how many lines to move.
 (defun line-move (arg)
-  (if (not (or (eq last-command 'next-line)
-               (eq last-command 'previous-line)))
-      (setq temporary-goal-column
-            (if (and track-eol (eolp)
-                     ;; Don't count beg of empty line as end of line
-                     ;; unless we just did explicit end-of-line.
-                     (or (not (bolp)) (eq last-command 'end-of-line)))
-                9999
-              (current-column))))
-  (if (and (not (integerp selective-display))
-           (not line-move-ignore-invisible))
-      ;; Use just newline characters.
-      (or (if (> arg 0)
-              (progn (if (> arg 1) (forward-line (1- arg)))
-                     ;; This way of moving forward ARG lines
-                     ;; verifies that we have a newline after the last one.
-                     ;; It doesn't get confused by intangible text.
-                     (end-of-line)
-                     (zerop (forward-line 1)))
-            (and (zerop (forward-line arg))
-                 (bolp)))
-          (signal (if (< arg 0)
-                      'beginning-of-buffer
-                    'end-of-buffer)
-                  nil))
-    ;; Move by arg lines, but ignore invisible ones.
-    (while (> arg 0)
-      (end-of-line)
-      (and (zerop (vertical-motion 1))
-           (signal 'end-of-buffer nil))
-      ;; If the following character is currently invisible,
-      ;; skip all characters with that same `invisible' property value.
-      (while (and (not (eobp))
-                  (let ((prop
-                         (get-char-property (point) 'invisible)))
-                    (if (eq buffer-invisibility-spec t)
-                        prop
-                      (or (memq prop buffer-invisibility-spec)
-                          (assq prop buffer-invisibility-spec)))))
-        (if (get-text-property (point) 'invisible)
-            (goto-char (next-single-property-change (point) 'invisible))
-          (goto-char (next-overlay-change (point)))))
-      (setq arg (1- arg)))
-    (while (< arg 0)
-      (beginning-of-line)
-      (and (zerop (vertical-motion -1))
-           (signal 'beginning-of-buffer nil))
-      (while (and (not (bobp))
-                  (let ((prop
-                         (get-char-property (1- (point)) 'invisible)))
-                    (if (eq buffer-invisibility-spec t)
-                        prop
-                      (or (memq prop buffer-invisibility-spec)
-                          (assq prop buffer-invisibility-spec)))))
-        (if (get-text-property (1- (point)) 'invisible)
-            (goto-char (previous-single-property-change (point) 'invisible))
-          (goto-char (previous-overlay-change (point)))))
-      (setq arg (1+ arg))))
-  (move-to-column (or goal-column temporary-goal-column))
-  nil)
+  (let (new)
+    ;; Don't run any point-motion hooks, and disregard intangibility,
+    ;; for intermediate positions.
+    (let ((inhibit-point-motion-hooks t))
+      (save-excursion
+        (if (not (or (eq last-command 'next-line)
+                     (eq last-command 'previous-line)))
+            (setq temporary-goal-column
+                  (if (and track-eol (eolp)
+                           ;; Don't count beg of empty line as end of line
+                           ;; unless we just did explicit end-of-line.
+                           (or (not (bolp)) (eq last-command 'end-of-line)))
+                      9999
+                    (current-column))))
+        (if (and (not (integerp selective-display))
+                 (not line-move-ignore-invisible))
+            ;; Use just newline characters.
+            (or (if (> arg 0)
+                    (progn (if (> arg 1) (forward-line (1- arg)))
+                           ;; This way of moving forward ARG lines
+                           ;; verifies that we have a newline after the last one.
+                           ;; It doesn't get confused by intangible text.
+                           (end-of-line)
+                           (zerop (forward-line 1)))
+                  (and (zerop (forward-line arg))
+                       (bolp)))
+                (signal (if (< arg 0)
+                            'beginning-of-buffer
+                          'end-of-buffer)
+                        nil))
+          ;; Move by arg lines, but ignore invisible ones.
+          (while (> arg 0)
+            (end-of-line)
+            (and (zerop (vertical-motion 1))
+                 (signal 'end-of-buffer nil))
+            ;; If the following character is currently invisible,
+            ;; skip all characters with that same `invisible' property value.
+            (while (and (not (eobp))
+                        (let ((prop
+                               (get-char-property (point) 'invisible)))
+                          (if (eq buffer-invisibility-spec t)
+                              prop
+                            (or (memq prop buffer-invisibility-spec)
+                                (assq prop buffer-invisibility-spec)))))
+              (if (get-text-property (point) 'invisible)
+                  (goto-char (next-single-property-change (point) 'invisible))
+                (goto-char (next-overlay-change (point)))))
+            (setq arg (1- arg)))
+          (while (< arg 0)
+            (beginning-of-line)
+            (and (zerop (vertical-motion -1))
+                 (signal 'beginning-of-buffer nil))
+            (while (and (not (bobp))
+                        (let ((prop
+                               (get-char-property (1- (point)) 'invisible)))
+                          (if (eq buffer-invisibility-spec t)
+                              prop
+                            (or (memq prop buffer-invisibility-spec)
+                                (assq prop buffer-invisibility-spec)))))
+              (if (get-text-property (1- (point)) 'invisible)
+                  (goto-char (previous-single-property-change (point) 'invisible))
+                (goto-char (previous-overlay-change (point)))))
+            (setq arg (1+ arg))))
+        (move-to-column (or goal-column temporary-goal-column))
+        (setq new (point))))
+    ;; Run any point-motion hooks, deal with intangible text, etc.,
+    ;; once and for all, for the entire motion we did.
+    (goto-char new)
+    nil))
 
 ;;; Many people have said they rarely use this feature, and often type
 ;;; it by accident.  Maybe it shouldn't even be on a key.