[Emacs-diffs] Changes to emacs/lisp/repeat.el,v

[Martin Rudalics]

CVSROOT:        /sources/emacs
Module name:    emacs
Changes by:     Martin Rudalics <m061211>       08/01/20 10:34:58

Index: repeat.el
===================================================================
RCS file: /sources/emacs/emacs/lisp/repeat.el,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -b -r1.23 -r1.24
--- repeat.el   8 Jan 2008 20:44:58 -0000       1.23
+++ repeat.el   20 Jan 2008 10:34:58 -0000      1.24
@@ -200,6 +200,14 @@
 (defvar repeat-previous-repeated-command nil
   "The previous repeated command.")
 
+;; The following variable counts repeated self-insertions.  The idea is
+;; that repeating a self-insertion command and subsequently undoing it
+;; should have almost the same effect as if the characters were inserted
+;; manually.  The basic difference is that we leave in one undo-boundary
+;; between the original insertion and its first repetition.
+(defvar repeat-undo-count nil
+  "Number of self-insertions since last `undo-boundary'.")
+
 ;;;###autoload
 (defun repeat (repeat-arg)
   "Repeat most recently executed command.
@@ -246,12 +254,6 @@
   ;; needs to be saved.
   (let ((repeat-repeat-char
          (if (eq repeat-on-final-keystroke t)
-            ;; The following commented out since it's equivalent to
-            ;; last-comment-char (martin 2007-08-29).
-;;;              ;; allow any final input event that was a character
-;;;              (when (eq last-command-char
-;;;                        last-command-event)
-;;;                last-command-char)
             last-command-char
            ;; allow only specified final keystrokes
            (car (memq last-command-char
@@ -293,11 +295,22 @@
                  (i 0))
              ;; Run pre- and post-command hooks for self-insertion too.
              (run-hooks 'pre-command-hook)
+             (cond
+              ((not repeat-undo-count))
+              ((< repeat-undo-count 20)
+               ;; Don't make an undo-boundary here.
+               (setq repeat-undo-count (1+ repeat-undo-count)))
+              (t
+               ;; Make an undo-boundary after 20 repetitions only.
+               (undo-boundary)
+               (setq repeat-undo-count 1)))
              (while (< i count)
                (repeat-self-insert insertion)
                (setq i (1+ i)))
              (run-hooks 'post-command-hook)))
        (let ((indirect (indirect-function last-repeatable-command)))
+         ;; Make each repetition undo separately.
+         (undo-boundary)
          (if (or (stringp indirect)
                  (vectorp indirect))
              ;; Bind real-last-command so that executing the macro does
@@ -314,12 +327,20 @@
       ;; (only 32 repetitions are possible given the default value of 200 for
       ;; max-lisp-eval-depth), but if I now locally disable the repeat char I
       ;; can iterate indefinitely here around a single level of recursion.
-      (let (repeat-on-final-keystroke)
+      (let (repeat-on-final-keystroke
+           ;; Bind `undo-inhibit-record-point' to t in order to avoid
+           ;; recording point in `buffer-undo-list' here.  We have to
+           ;; do this since the command loop does not set the last
+           ;; position of point thus confusing the point recording
+           ;; mechanism when inserting or deleting text.
+           (undo-inhibit-record-point t))
        (setq real-last-command 'repeat)
+       (setq repeat-undo-count 1)
+       (unwind-protect
         (while (eq (read-event) repeat-repeat-char)
-         ;; Make each repetition undo separately.
-         (undo-boundary)
           (repeat repeat-arg))
+         ;; Make sure `repeat-undo-count' is reset.
+         (setq repeat-undo-count nil))
         (setq unread-command-events (list last-input-event))))))
 
 (defun repeat-self-insert (string)