repeat.el 16.9 KB
Newer Older
Richard M. Stallman's avatar
Richard M. Stallman committed
1
;;; repeat.el --- convenient way to repeat the previous command
Richard M. Stallman's avatar
Richard M. Stallman committed
2

Glenn Morris's avatar
Glenn Morris committed
3
;; Copyright (C) 1998, 2001, 2002, 2003, 2004, 2005,
4
;;   2006 Free Software Foundation, Inc.
Richard M. Stallman's avatar
Richard M. Stallman committed
5 6 7 8

;; Author: Will Mengarini <seldon@eskimo.com>
;; Created: Mo 02 Mar 98
;; Version: 0.51, We 13 May 98
Richard M. Stallman's avatar
Richard M. Stallman committed
9
;; Keywords: convenience, vi, repeat
Richard M. Stallman's avatar
Richard M. Stallman committed
10 11 12

;; This file is part of GNU Emacs.

Gerd Moellmann's avatar
Gerd Moellmann committed
13
;; GNU Emacs is free software; you can redistribute it and/or modify
Richard M. Stallman's avatar
Richard M. Stallman committed
14 15 16 17
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

Gerd Moellmann's avatar
Gerd Moellmann committed
18
;; GNU Emacs is distributed in the hope that it will be useful,
Richard M. Stallman's avatar
Richard M. Stallman committed
19 20 21 22 23 24
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
Lute Kamstra's avatar
Lute Kamstra committed
25 26
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
Richard M. Stallman's avatar
Richard M. Stallman committed
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

;;; Commentary:

;; Sometimes the fastest way to get something done is just to lean on a key;
;; moving forward through a series of words by leaning on M-f is an example.
;; But 'forward-page is orthodoxily bound to C-x ], so moving forward through
;; several pages requires
;;   Loop until desired page is reached:
;;     Hold down control key with left pinkie.
;;     Tap <x>.
;;     Lift left pinkie off control key.
;;     Tap <]>.
;; This is a pain in the ass.

;; This package defines a command that repeats the preceding command,
Richard M. Stallman's avatar
Richard M. Stallman committed
42 43 44 45 46
;; whatever that was, including its arguments, whatever they were.
;; This command is connected to the key C-x z.
;; To repeat the previous command once, type C-x z.
;; To repeat it a second time immediately after, type just z.
;; By typing z again and again, you can repeat the command over and over.
Richard M. Stallman's avatar
Richard M. Stallman committed
47 48 49 50 51

;; This works correctly inside a keyboard macro as far as recording and
;; playback go, but `edit-kbd-macro' gets it wrong.  That shouldn't really
;; matter; if you need to edit something like
;;   C-x ]              ;; forward-page
Richard M. Stallman's avatar
Richard M. Stallman committed
52
;;   C-x z              ;; repeat
Richard M. Stallman's avatar
Richard M. Stallman committed
53 54
;;   zz                 ;; self-insert-command * 2
;;   C-x                ;; Control-X-prefix
Richard M. Stallman's avatar
Richard M. Stallman committed
55
;; you can just kill the bogus final 2 lines, then duplicate the repeat line
Richard M. Stallman's avatar
Richard M. Stallman committed
56
;; as many times as it's really needed.  Also, `edit-kbd-macro' works
Richard M. Stallman's avatar
Richard M. Stallman committed
57 58
;; correctly if `repeat' is invoked through a rebinding to a single keystroke
;; and the global variable repeat-on-final-keystroke is set to a value
Richard M. Stallman's avatar
Richard M. Stallman committed
59
;; that doesn't include that keystroke.  For example, the lines
Richard M. Stallman's avatar
Richard M. Stallman committed
60 61
;;   (global-set-key "\C-z" 'repeat)
;;   (setq repeat-on-final-keystroke "z")
Richard M. Stallman's avatar
Richard M. Stallman committed
62
;; in your .emacs would allow `edit-kbd-macro' to work correctly when C-z was
Richard M. Stallman's avatar
Richard M. Stallman committed
63 64
;; used in a keyboard macro to invoke `repeat', but would still allow C-x z
;; to be used for `repeat' elsewhere.  The real reason for documenting this
Richard M. Stallman's avatar
Richard M. Stallman committed
65 66 67 68 69
;; isn't that anybody would need it for the `edit-kbd-macro' problem, but
;; that there might be other unexpected ramifications of re-executing on
;; repetitions of the final keystroke, and this shows how to do workarounds.

;; If the preceding command had a prefix argument, that argument is applied
Richard M. Stallman's avatar
Richard M. Stallman committed
70
;; to the repeat command, unless the repeat command is given a new prefix
Richard M. Stallman's avatar
Richard M. Stallman committed
71 72 73 74
;; argument, in which case it applies that new prefix argument to the
;; preceding command.  This means a key sequence like C-u - C-x C-t can be
;; repeated.  (It shoves the preceding line upward in the buffer.)

Richard M. Stallman's avatar
Richard M. Stallman committed
75
;; Here are some other key sequences with which repeat might be useful:
Richard M. Stallman's avatar
Richard M. Stallman committed
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
;;   C-u - C-t      [shove preceding character backward in line]
;;   C-u - M-t      [shove preceding word backward in sentence]
;;         C-x ^    enlarge-window [one line] (assuming frame has > 1 window)
;;   C-u - C-x ^    [shrink window one line]
;;         C-x `    next-error
;;   C-u - C-x `    [previous error]
;;         C-x DEL  backward-kill-sentence
;;         C-x e    call-last-kbd-macro
;;         C-x r i  insert-register
;;         C-x r t  string-rectangle
;;         C-x TAB  indent-rigidly [one character]
;;   C-u - C-x TAB  [outdent rigidly one character]
;;         C-x {    shrink-window-horizontally
;;         C-x }    enlarge-window-horizontally

Richard M. Stallman's avatar
Richard M. Stallman committed
91 92 93
;; This command was first called `vi-dot', because
;; it was inspired by the `.' command in the vi editor,
;; but it was renamed to make its name more meaningful.
Richard M. Stallman's avatar
Richard M. Stallman committed
94 95 96 97 98

;;; Code:

;;;;; ************************* USER OPTIONS ************************** ;;;;;

Richard M. Stallman's avatar
Richard M. Stallman committed
99 100
(defcustom repeat-too-dangerous '(kill-this-buffer)
  "Commands too dangerous to repeat with \\[repeat]."
Richard M. Stallman's avatar
Richard M. Stallman committed
101 102
  :group 'convenience
  :type '(repeat function))
Richard M. Stallman's avatar
Richard M. Stallman committed
103 104 105

;; If the last command was self-insert-command, the char to be inserted was
;; obtained by that command from last-command-char, which has now been
Richard M. Stallman's avatar
Richard M. Stallman committed
106
;; clobbered by the command sequence that invoked `repeat'.  We could get it
Richard M. Stallman's avatar
Richard M. Stallman committed
107 108
;; from (recent-keys) & set last-command-char to that, "unclobbering" it, but
;; this has the disadvantage that if the user types a sequence of different
Richard M. Stallman's avatar
Richard M. Stallman committed
109
;; chars then invokes repeat, only the final char will be inserted.  In vi,
Richard M. Stallman's avatar
Richard M. Stallman committed
110 111
;; the dot command can reinsert the entire most-recently-inserted sequence.

Richard M. Stallman's avatar
Richard M. Stallman committed
112 113
(defvar repeat-message-function nil
  "If non-nil, function used by `repeat' command to say what it's doing.
Richard M. Stallman's avatar
Richard M. Stallman committed
114
Message is something like \"Repeating command glorp\".
Richard M. Stallman's avatar
Richard M. Stallman committed
115
To disable such messages, set this variable to `ignore'.  To customize
Richard M. Stallman's avatar
Richard M. Stallman committed
116 117 118
display, assign a function that takes one string as an arg and displays
it however you want.")

Richard M. Stallman's avatar
Richard M. Stallman committed
119 120 121
(defcustom repeat-on-final-keystroke t
  "Allow `repeat' to re-execute for repeating lastchar of a key sequence.
If this variable is t, `repeat' determines what key sequence
Richard M. Stallman's avatar
Richard M. Stallman committed
122 123
it was invoked by, extracts the final character of that sequence, and
re-executes as many times as that final character is hit; so for example
Richard M. Stallman's avatar
Richard M. Stallman committed
124
if `repeat' is bound to C-x z, typing C-x z z z repeats the previous command
Richard M. Stallman's avatar
Richard M. Stallman committed
125
3 times.  If this variable is a sequence of characters, then re-execution
Richard M. Stallman's avatar
Richard M. Stallman committed
126
only occurs if the final character by which `repeat' was invoked is a
Richard M. Stallman's avatar
Richard M. Stallman committed
127 128 129
member of that sequence.  If this variable is nil, no re-execution occurs."
  :group 'convenience
  :type 'boolean)
130

Richard M. Stallman's avatar
Richard M. Stallman committed
131 132 133 134 135
;;;;; ****************** HACKS TO THE REST OF EMACS ******************* ;;;;;

;; The basic strategy is to use last-command, a variable built in to Emacs.
;; There are 2 issues that complicate this strategy.  The first is that
;; last-command is given a bogus value when any kill command is executed;
Richard M. Stallman's avatar
Richard M. Stallman committed
136
;; this is done to make it easy for `yank-pop' to know that it's being invoked
Richard M. Stallman's avatar
Richard M. Stallman committed
137
;; after a kill command.  The second is that the meaning of the command is
Richard M. Stallman's avatar
Richard M. Stallman committed
138
;; often altered by the prefix arg, but although Emacs (19.34) has a
Richard M. Stallman's avatar
Richard M. Stallman committed
139 140 141 142 143 144
;; builtin prefix-arg specifying the arg for the next command, as well as a
;; builtin current-prefix-arg, it has no builtin last-prefix-arg.

;; There's a builtin (this-command-keys), the return value of which could be
;; executed with (command-execute), but there's no (last-command-keys).
;; Using (last-command-keys) if it existed wouldn't be optimal, however,
Richard M. Stallman's avatar
Richard M. Stallman committed
145
;; since it would complicate checking membership in repeat-too-dangerous.
Richard M. Stallman's avatar
Richard M. Stallman committed
146 147 148 149 150 151 152 153 154

;; It would of course be trivial to implement last-prefix-arg &
;; true-last-command by putting something in post-command-hook, but that
;; entails a performance hit; the approach taken below avoids that.

;; Coping with strings of self-insert commands gets hairy when they interact
;; with auto-filling.  Most problems are eliminated by remembering what we're
;; self-inserting, so we only need to get it from the undo information once.

Richard M. Stallman's avatar
Richard M. Stallman committed
155
(defvar repeat-last-self-insert nil
Richard M. Stallman's avatar
Richard M. Stallman committed
156 157 158 159 160
  "If last repeated command was `self-insert-command', it inserted this.")

;; That'll require another keystroke count so we know we're in a string of
;; repetitions of self-insert commands:

Richard M. Stallman's avatar
Richard M. Stallman committed
161
(defvar repeat-num-input-keys-at-self-insert -1
Richard M. Stallman's avatar
Richard M. Stallman committed
162 163
  "# key sequences read in Emacs session when `self-insert-command' repeated.")

Richard M. Stallman's avatar
Richard M. Stallman committed
164
;;;;; *************** ANALOGOUS HACKS TO `repeat' ITSELF **************** ;;;;;
Richard M. Stallman's avatar
Richard M. Stallman committed
165 166 167

;; That mechanism of checking num-input-keys to figure out what's really
;; going on can be useful to other commands that need to fine-tune their
Richard M. Stallman's avatar
Richard M. Stallman committed
168 169
;; interaction with repeat.  Instead of requiring them to advise repeat, we
;; can just defvar the value they need here, & setq it in the repeat command:
Richard M. Stallman's avatar
Richard M. Stallman committed
170

Richard M. Stallman's avatar
Richard M. Stallman committed
171 172
(defvar repeat-num-input-keys-at-repeat -1
  "# key sequences read in Emacs session when `repeat' last invoked.")
Richard M. Stallman's avatar
Richard M. Stallman committed
173 174 175 176 177

;; Also, we can assign a name to the test for which that variable is
;; intended, which thereby documents here how to use it, & makes code that
;; uses it self-documenting:

Richard M. Stallman's avatar
Richard M. Stallman committed
178 179
(defsubst repeat-is-really-this-command ()
  "Return t if this command is happening because user invoked `repeat'.
Richard M. Stallman's avatar
Richard M. Stallman committed
180 181
Usually, when a command is executing, the Emacs builtin variable
`this-command' identifies the command the user invoked.  Some commands modify
Richard M. Stallman's avatar
Richard M. Stallman committed
182
that variable on the theory they're doing more good than harm; `repeat' does
Richard M. Stallman's avatar
Richard M. Stallman committed
183
that, and usually does do more good than harm.  However, like all do-gooders,
Richard M. Stallman's avatar
Richard M. Stallman committed
184
sometimes `repeat' gets surprising results from its altruism.  The value of
Richard M. Stallman's avatar
Richard M. Stallman committed
185
this function is always whether the value of `this-command' would've been
Richard M. Stallman's avatar
Richard M. Stallman committed
186 187
'repeat if `repeat' hadn't modified it."
  (= repeat-num-input-keys-at-repeat num-input-keys))
Richard M. Stallman's avatar
Richard M. Stallman committed
188

Richard M. Stallman's avatar
Richard M. Stallman committed
189
;; An example of the use of (repeat-is-really-this-command) may still be
Richard M. Stallman's avatar
Richard M. Stallman committed
190 191 192
;; available in <http://www.eskimo.com/~seldon/dotemacs.el>; search for
;; "defun wm-switch-buffer".

Richard M. Stallman's avatar
Richard M. Stallman committed
193
;;;;; ******************* THE REPEAT COMMAND ITSELF ******************* ;;;;;
Richard M. Stallman's avatar
Richard M. Stallman committed
194

Dave Love's avatar
Dave Love committed
195 196 197
(defvar repeat-previous-repeated-command nil
  "The previous repeated command.")

Richard M. Stallman's avatar
Richard M. Stallman committed
198
;;;###autoload
Richard M. Stallman's avatar
Richard M. Stallman committed
199
(defun repeat (repeat-arg)
Richard M. Stallman's avatar
Richard M. Stallman committed
200
  "Repeat most recently executed command.
Karl Heuer's avatar
Karl Heuer committed
201 202
With prefix arg, apply new prefix arg to that command; otherwise, use
the prefix arg that was used before (if any).
Dave Love's avatar
Dave Love committed
203
This command is like the `.' command in the vi editor.
Richard M. Stallman's avatar
Richard M. Stallman committed
204 205 206

If this command is invoked by a multi-character key sequence, it can then
be repeated by repeating the final character of that sequence.  This behavior
Richard M. Stallman's avatar
Richard M. Stallman committed
207
can be modified by the global variable `repeat-on-final-keystroke'."
Richard M. Stallman's avatar
Richard M. Stallman committed
208 209 210 211 212 213
  ;; The most recently executed command could be anything, so surprises could
  ;; result if it were re-executed in a context where new dynamically
  ;; localized variables were shadowing global variables in a `let' clause in
  ;; here.  (Remember that GNU Emacs 19 is dynamically localized.)
  ;; To avoid that, I tried the `lexical-let' of the Common Lisp extensions,
  ;; but that entails a very noticeable performance hit, so instead I use the
Richard M. Stallman's avatar
Richard M. Stallman committed
214
  ;; "repeat-" prefix, reserved by this package, for *local* variables that
Richard M. Stallman's avatar
Richard M. Stallman committed
215 216
  ;; might be visible to re-executed commands, including this function's arg.
  (interactive "P")
Dave Love's avatar
Dave Love committed
217 218 219 220
  (when (eq real-last-command 'repeat)
    (setq real-last-command repeat-previous-repeated-command))
  (when (null real-last-command)
    (error "There is nothing to repeat"))
Richard M. Stallman's avatar
Richard M. Stallman committed
221 222 223 224
  (when (eq real-last-command 'mode-exit)
    (error "real-last-command is mode-exit & can't be repeated"))
  (when (memq real-last-command repeat-too-dangerous)
    (error "Command %S too dangerous to repeat automatically" real-last-command))
Dave Love's avatar
Dave Love committed
225 226 227
  (setq this-command                      real-last-command
        repeat-num-input-keys-at-repeat   num-input-keys)
  (setq repeat-previous-repeated-command this-command)
Richard M. Stallman's avatar
Richard M. Stallman committed
228 229
  (when (null repeat-arg)
    (setq repeat-arg last-prefix-arg))
Richard M. Stallman's avatar
Richard M. Stallman committed
230
  ;; Now determine whether to loop on repeated taps of the final character
Richard M. Stallman's avatar
Richard M. Stallman committed
231
  ;; of the key sequence that invoked repeat.  The Emacs global
Richard M. Stallman's avatar
Richard M. Stallman committed
232 233 234
  ;; last-command-char contains the final character now, but may not still
  ;; contain it after the previous command is repeated, so the character
  ;; needs to be saved.
Richard M. Stallman's avatar
Richard M. Stallman committed
235 236
  (let ((repeat-repeat-char
         (if (eq repeat-on-final-keystroke t)
Richard M. Stallman's avatar
Richard M. Stallman committed
237 238 239 240 241 242 243
             ;; allow any final input event that was a character
             (when (eq last-command-char
                       last-command-event)
               last-command-char)
           ;; allow only specified final keystrokes
           (car (memq last-command-char
                      (listify-key-sequence
Richard M. Stallman's avatar
Richard M. Stallman committed
244 245 246 247 248 249 250 251 252
                       repeat-on-final-keystroke))))))
    (if (memq real-last-command '(exit-minibuffer
				  minibuffer-complete-and-exit
				  self-insert-and-exit))
        (let ((repeat-command (car command-history)))
          (repeat-message "Repeating %S" repeat-command)
          (eval repeat-command))
      (if (null repeat-arg)
          (repeat-message "Repeating command %S" real-last-command)
253
        (setq current-prefix-arg                   repeat-arg)
Richard M. Stallman's avatar
Richard M. Stallman committed
254 255
        (repeat-message "Repeating command %S %S" repeat-arg real-last-command))
      (if (eq real-last-command 'self-insert-command)
Richard M. Stallman's avatar
Richard M. Stallman committed
256 257
          (let ((insertion
                 (if (<= (- num-input-keys
Richard M. Stallman's avatar
Richard M. Stallman committed
258
                            repeat-num-input-keys-at-self-insert)
Richard M. Stallman's avatar
Richard M. Stallman committed
259
                         1)
Richard M. Stallman's avatar
Richard M. Stallman committed
260
                     repeat-last-self-insert
Richard M. Stallman's avatar
Richard M. Stallman committed
261 262
                   (let ((range (nth 1 buffer-undo-list)))
                     (condition-case nil
Richard M. Stallman's avatar
Richard M. Stallman committed
263
                         (setq repeat-last-self-insert
Richard M. Stallman's avatar
Richard M. Stallman committed
264 265
                               (buffer-substring (car range)
                                                 (cdr range)))
266
                       (error (error "%s %s %s" ;Danger, Will Robinson!
Richard M. Stallman's avatar
Richard M. Stallman committed
267
                                     "repeat can't intuit what you"
Richard M. Stallman's avatar
Richard M. Stallman committed
268 269
                                     "inserted before auto-fill"
                                     "clobbered it, sorry")))))))
Richard M. Stallman's avatar
Richard M. Stallman committed
270
            (setq repeat-num-input-keys-at-self-insert num-input-keys)
271 272 273 274
	    ;; If the self-insert had a repeat count, INSERTION
	    ;; includes that many copies of the same character.
	    ;; So use just the first character
	    ;; and repeat it the right number of times.
Karl Heuer's avatar
Karl Heuer committed
275
	    (setq insertion (substring insertion -1))
276 277 278 279 280
	    (let ((count (prefix-numeric-value repeat-arg))
		  (i 0))
	      (while (< i count)
		(repeat-self-insert insertion)
		(setq i (1+ i)))))
Karl Heuer's avatar
Karl Heuer committed
281 282 283
	(let ((indirect (indirect-function real-last-command)))
	  (if (or (stringp indirect)
		  (vectorp indirect))
284 285 286 287
	      ;; Bind real-last-command so that executing the macro
	      ;; does not alter it.
	      (let ((real-last-command real-last-command))
		(execute-kbd-macro real-last-command))
288 289 290
            (run-hooks 'pre-command-hook)
	    (call-interactively real-last-command)
            (run-hooks 'post-command-hook)))))
Richard M. Stallman's avatar
Richard M. Stallman committed
291
    (when repeat-repeat-char
Richard M. Stallman's avatar
Richard M. Stallman committed
292 293 294 295 296
      ;; A simple recursion here gets into trouble with max-lisp-eval-depth
      ;; on long sequences of repetitions of a command like `forward-word'
      ;; (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.
Richard M. Stallman's avatar
Richard M. Stallman committed
297 298
      (let (repeat-on-final-keystroke)
        (while (eq (read-event) repeat-repeat-char)
299 300
	  ;; Make each repetition undo separately.
	  (undo-boundary)
Richard M. Stallman's avatar
Richard M. Stallman committed
301
          (repeat repeat-arg))
Richard M. Stallman's avatar
Richard M. Stallman committed
302 303
        (setq unread-command-events (list last-input-event))))))

Richard M. Stallman's avatar
Richard M. Stallman committed
304
(defun repeat-self-insert (string)
Richard M. Stallman's avatar
Richard M. Stallman committed
305 306 307 308 309 310
  (let ((i 0))
    (while (< i (length string))
      (let ((last-command-char (aref string i)))
	(self-insert-command 1))
      (setq i (1+ i)))))

Richard M. Stallman's avatar
Richard M. Stallman committed
311 312
(defun repeat-message (format &rest args)
  "Like `message' but displays with `repeat-message-function' if non-nil."
Richard M. Stallman's avatar
Richard M. Stallman committed
313
  (let ((message (apply 'format format args)))
Richard M. Stallman's avatar
Richard M. Stallman committed
314 315
    (if repeat-message-function
        (funcall repeat-message-function message)
Richard M. Stallman's avatar
Richard M. Stallman committed
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
      (message "%s" message))))

;; OK, there's one situation left where that doesn't work correctly: when the
;; most recent self-insertion provoked an auto-fill.  The problem is that
;; unravelling the undo information after an auto-fill is too hard, since all
;; kinds of stuff can get in there as a result of comment prefixes etc.  It'd
;; be possible to advise do-auto-fill to record the most recent
;; self-insertion before it does its thing, but that's a performance hit on
;; auto-fill, which already has performance problems; so it's better to just
;; leave it like this.  If text didn't provoke an auto-fill when the user
;; typed it, this'll correctly repeat its self-insertion, even if the
;; repetition does cause auto-fill.

;; If you wanted perfection, probably it'd be necessary to hack do-auto-fill
;; into 2 functions, maybe-do-auto-fill & really-do-auto-fill, because only
;; really-do-auto-fill should be advised.  As things are, either the undo
;; information would need to be scanned on every do-auto-fill invocation, or
;; the code at the top of do-auto-fill deciding whether filling is necessary
;; would need to be duplicated in the advice, wasting execution time when
;; filling does turn out to be necessary.

;; I thought maybe this story had a moral, something about functional
;; decomposition; but now I'm not even sure of that, since a function
;; call per se is a performance hit, & even the code that would
;; correspond to really-do-auto-fill has performance problems that
;; can make it necessary to stop typing while Emacs catches up.
;; Maybe the real moral is that perfection is a chimera.

;; Ah, hell, it's all going to fall into a black hole someday anyway.

;;;;; ************************* EMACS CONTROL ************************* ;;;;;

Richard M. Stallman's avatar
Richard M. Stallman committed
348
(provide 'repeat)
Richard M. Stallman's avatar
Richard M. Stallman committed
349

Miles Bader's avatar
Miles Bader committed
350
;;; arch-tag: cd569600-a1ad-4fa7-9062-bb91dfeaf1db
Richard M. Stallman's avatar
Richard M. Stallman committed
351
;;; repeat.el ends here