(repeat-undo-count): New variable.

(repeat): For self-insertions make undo boundary only after 20
repetitions.  Inhibit point recording when repeat-repeat-char is
non-nil.

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 9d845f233e3dc9eef4d7a0596fe3b8f661222b03..800fb5a0571644bb84b46d3447d3bd23a662b925 100644 (file)
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,10 @@
+2008-01-20  Martin Rudalics  <rudalics@gmx.at>
+
+       * repeat.el (repeat-undo-count): New variable.
+       (repeat): For self-insertions make undo boundary only after 20
+       repetitions.  Inhibit point recording when repeat-repeat-char is
+       non-nil.
+
 2008-01-19  Reiner Steib  <Reiner.Steib@gmx.de>
 
        * net/imap.el (imap-ping-server): New variable.

diff --git a/lisp/repeat.el b/lisp/repeat.el
index 8e97abf32e9a0ec8f868c0039b0acf14ee2d21b2..fdeec47f7c42dfc2c08e275a653771c7c1518da1 100644 (file)
--- a/lisp/repeat.el
+++ b/lisp/repeat.el
@@ -200,6 +200,14 @@ this function is always whether the value of `this-command' would've been
 (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 @@ recently executed command not bound to an input event\"."
   ;; 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 @@ recently executed command not bound to an input event\"."
                  (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 @@ recently executed command not bound to an input event\"."
       ;; (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)
-        (while (eq (read-event) repeat-repeat-char)
-         ;; Make each repetition undo separately.
-         (undo-boundary)
-          (repeat repeat-arg))
+       (setq repeat-undo-count 1)
+       (unwind-protect
+           (while (eq (read-event) repeat-repeat-char)
+             (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)