1;;; repeat.el --- convenient way to repeat the previous command 2 3;; Copyright (C) 1998, 2001, 2002, 2003, 2004, 2005, 4;; 2006, 2007 Free Software Foundation, Inc. 5 6;; Author: Will Mengarini <seldon@eskimo.com> 7;; Created: Mo 02 Mar 98 8;; Version: 0.51, We 13 May 98 9;; Keywords: convenience, vi, repeat 10 11;; This file is part of GNU Emacs. 12 13;; GNU Emacs is free software; you can redistribute it and/or modify 14;; it under the terms of the GNU General Public License as published by 15;; the Free Software Foundation; either version 2, or (at your option) 16;; any later version. 17 18;; GNU Emacs is distributed in the hope that it will be useful, 19;; but WITHOUT ANY WARRANTY; without even the implied warranty of 20;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21;; GNU General Public License for more details. 22 23;; You should have received a copy of the GNU General Public License 24;; along with GNU Emacs; see the file COPYING. If not, write to the 25;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 26;; Boston, MA 02110-1301, USA. 27 28;;; Commentary: 29 30;; Sometimes the fastest way to get something done is just to lean on a key; 31;; moving forward through a series of words by leaning on M-f is an example. 32;; But 'forward-page is orthodoxily bound to C-x ], so moving forward through 33;; several pages requires 34;; Loop until desired page is reached: 35;; Hold down control key with left pinkie. 36;; Tap <x>. 37;; Lift left pinkie off control key. 38;; Tap <]>. 39;; This is a pain in the ass. 40 41;; This package defines a command that repeats the preceding command, 42;; whatever that was, including its arguments, whatever they were. 43;; This command is connected to the key C-x z. 44;; To repeat the previous command once, type C-x z. 45;; To repeat it a second time immediately after, type just z. 46;; By typing z again and again, you can repeat the command over and over. 47 48;; This works correctly inside a keyboard macro as far as recording and 49;; playback go, but `edit-kbd-macro' gets it wrong. That shouldn't really 50;; matter; if you need to edit something like 51;; C-x ] ;; forward-page 52;; C-x z ;; repeat 53;; zz ;; self-insert-command * 2 54;; C-x ;; Control-X-prefix 55;; you can just kill the bogus final 2 lines, then duplicate the repeat line 56;; as many times as it's really needed. Also, `edit-kbd-macro' works 57;; correctly if `repeat' is invoked through a rebinding to a single keystroke 58;; and the global variable repeat-on-final-keystroke is set to a value 59;; that doesn't include that keystroke. For example, the lines 60;; (global-set-key "\C-z" 'repeat) 61;; (setq repeat-on-final-keystroke "z") 62;; in your .emacs would allow `edit-kbd-macro' to work correctly when C-z was 63;; used in a keyboard macro to invoke `repeat', but would still allow C-x z 64;; to be used for `repeat' elsewhere. The real reason for documenting this 65;; isn't that anybody would need it for the `edit-kbd-macro' problem, but 66;; that there might be other unexpected ramifications of re-executing on 67;; repetitions of the final keystroke, and this shows how to do workarounds. 68 69;; If the preceding command had a prefix argument, that argument is applied 70;; to the repeat command, unless the repeat command is given a new prefix 71;; argument, in which case it applies that new prefix argument to the 72;; preceding command. This means a key sequence like C-u - C-x C-t can be 73;; repeated. (It shoves the preceding line upward in the buffer.) 74 75;; Here are some other key sequences with which repeat might be useful: 76;; C-u - C-t [shove preceding character backward in line] 77;; C-u - M-t [shove preceding word backward in sentence] 78;; C-x ^ enlarge-window [one line] (assuming frame has > 1 window) 79;; C-u - C-x ^ [shrink window one line] 80;; C-x ` next-error 81;; C-u - C-x ` [previous error] 82;; C-x DEL backward-kill-sentence 83;; C-x e call-last-kbd-macro 84;; C-x r i insert-register 85;; C-x r t string-rectangle 86;; C-x TAB indent-rigidly [one character] 87;; C-u - C-x TAB [outdent rigidly one character] 88;; C-x { shrink-window-horizontally 89;; C-x } enlarge-window-horizontally 90 91;; This command was first called `vi-dot', because 92;; it was inspired by the `.' command in the vi editor, 93;; but it was renamed to make its name more meaningful. 94 95;;; Code: 96 97;;;;; ************************* USER OPTIONS ************************** ;;;;; 98 99(defcustom repeat-too-dangerous '(kill-this-buffer) 100 "Commands too dangerous to repeat with \\[repeat]." 101 :group 'convenience 102 :type '(repeat function)) 103 104;; If the last command was self-insert-command, the char to be inserted was 105;; obtained by that command from last-command-char, which has now been 106;; clobbered by the command sequence that invoked `repeat'. We could get it 107;; from (recent-keys) & set last-command-char to that, "unclobbering" it, but 108;; this has the disadvantage that if the user types a sequence of different 109;; chars then invokes repeat, only the final char will be inserted. In vi, 110;; the dot command can reinsert the entire most-recently-inserted sequence. 111 112(defvar repeat-message-function nil 113 "If non-nil, function used by `repeat' command to say what it's doing. 114Message is something like \"Repeating command glorp\". 115To disable such messages, set this variable to `ignore'. To customize 116display, assign a function that takes one string as an arg and displays 117it however you want.") 118 119(defcustom repeat-on-final-keystroke t 120 "Allow `repeat' to re-execute for repeating lastchar of a key sequence. 121If this variable is t, `repeat' determines what key sequence 122it was invoked by, extracts the final character of that sequence, and 123re-executes as many times as that final character is hit; so for example 124if `repeat' is bound to C-x z, typing C-x z z z repeats the previous command 1253 times. If this variable is a sequence of characters, then re-execution 126only occurs if the final character by which `repeat' was invoked is a 127member of that sequence. If this variable is nil, no re-execution occurs." 128 :group 'convenience 129 :type 'boolean) 130 131;;;;; ****************** HACKS TO THE REST OF EMACS ******************* ;;;;; 132 133;; The basic strategy is to use last-command, a variable built in to Emacs. 134;; There are 2 issues that complicate this strategy. The first is that 135;; last-command is given a bogus value when any kill command is executed; 136;; this is done to make it easy for `yank-pop' to know that it's being invoked 137;; after a kill command. The second is that the meaning of the command is 138;; often altered by the prefix arg, but although Emacs (19.34) has a 139;; builtin prefix-arg specifying the arg for the next command, as well as a 140;; builtin current-prefix-arg, it has no builtin last-prefix-arg. 141 142;; There's a builtin (this-command-keys), the return value of which could be 143;; executed with (command-execute), but there's no (last-command-keys). 144;; Using (last-command-keys) if it existed wouldn't be optimal, however, 145;; since it would complicate checking membership in repeat-too-dangerous. 146 147;; It would of course be trivial to implement last-prefix-arg & 148;; true-last-command by putting something in post-command-hook, but that 149;; entails a performance hit; the approach taken below avoids that. 150 151;; Coping with strings of self-insert commands gets hairy when they interact 152;; with auto-filling. Most problems are eliminated by remembering what we're 153;; self-inserting, so we only need to get it from the undo information once. 154 155(defvar repeat-last-self-insert nil 156 "If last repeated command was `self-insert-command', it inserted this.") 157 158;; That'll require another keystroke count so we know we're in a string of 159;; repetitions of self-insert commands: 160 161(defvar repeat-num-input-keys-at-self-insert -1 162 "# key sequences read in Emacs session when `self-insert-command' repeated.") 163 164;;;;; *************** ANALOGOUS HACKS TO `repeat' ITSELF **************** ;;;;; 165 166;; That mechanism of checking num-input-keys to figure out what's really 167;; going on can be useful to other commands that need to fine-tune their 168;; interaction with repeat. Instead of requiring them to advise repeat, we 169;; can just defvar the value they need here, & setq it in the repeat command: 170 171(defvar repeat-num-input-keys-at-repeat -1 172 "# key sequences read in Emacs session when `repeat' last invoked.") 173 174;; Also, we can assign a name to the test for which that variable is 175;; intended, which thereby documents here how to use it, & makes code that 176;; uses it self-documenting: 177 178(defsubst repeat-is-really-this-command () 179 "Return t if this command is happening because user invoked `repeat'. 180Usually, when a command is executing, the Emacs builtin variable 181`this-command' identifies the command the user invoked. Some commands modify 182that variable on the theory they're doing more good than harm; `repeat' does 183that, and usually does do more good than harm. However, like all do-gooders, 184sometimes `repeat' gets surprising results from its altruism. The value of 185this function is always whether the value of `this-command' would've been 186'repeat if `repeat' hadn't modified it." 187 (= repeat-num-input-keys-at-repeat num-input-keys)) 188 189;; An example of the use of (repeat-is-really-this-command) may still be 190;; available in <http://www.eskimo.com/~seldon/dotemacs.el>; search for 191;; "defun wm-switch-buffer". 192 193;;;;; ******************* THE REPEAT COMMAND ITSELF ******************* ;;;;; 194 195(defvar repeat-previous-repeated-command nil 196 "The previous repeated command.") 197 198;;;###autoload 199(defun repeat (repeat-arg) 200 "Repeat most recently executed command. 201With prefix arg, apply new prefix arg to that command; otherwise, use 202the prefix arg that was used before (if any). 203This command is like the `.' command in the vi editor. 204 205If this command is invoked by a multi-character key sequence, it can then 206be repeated by repeating the final character of that sequence. This behavior 207can be modified by the global variable `repeat-on-final-keystroke'." 208 ;; The most recently executed command could be anything, so surprises could 209 ;; result if it were re-executed in a context where new dynamically 210 ;; localized variables were shadowing global variables in a `let' clause in 211 ;; here. (Remember that GNU Emacs 19 is dynamically localized.) 212 ;; To avoid that, I tried the `lexical-let' of the Common Lisp extensions, 213 ;; but that entails a very noticeable performance hit, so instead I use the 214 ;; "repeat-" prefix, reserved by this package, for *local* variables that 215 ;; might be visible to re-executed commands, including this function's arg. 216 (interactive "P") 217 (when (eq real-last-command 'repeat) 218 (setq real-last-command repeat-previous-repeated-command)) 219 (when (null real-last-command) 220 (error "There is nothing to repeat")) 221 (when (eq real-last-command 'mode-exit) 222 (error "real-last-command is mode-exit & can't be repeated")) 223 (when (memq real-last-command repeat-too-dangerous) 224 (error "Command %S too dangerous to repeat automatically" real-last-command)) 225 (setq this-command real-last-command 226 repeat-num-input-keys-at-repeat num-input-keys) 227 (setq repeat-previous-repeated-command this-command) 228 (when (null repeat-arg) 229 (setq repeat-arg last-prefix-arg)) 230 ;; Now determine whether to loop on repeated taps of the final character 231 ;; of the key sequence that invoked repeat. The Emacs global 232 ;; last-command-char contains the final character now, but may not still 233 ;; contain it after the previous command is repeated, so the character 234 ;; needs to be saved. 235 (let ((repeat-repeat-char 236 (if (eq repeat-on-final-keystroke t) 237 ;; allow any final input event that was a character 238 (when (eq last-command-char 239 last-command-event) 240 last-command-char) 241 ;; allow only specified final keystrokes 242 (car (memq last-command-char 243 (listify-key-sequence 244 repeat-on-final-keystroke)))))) 245 (if (memq real-last-command '(exit-minibuffer 246 minibuffer-complete-and-exit 247 self-insert-and-exit)) 248 (let ((repeat-command (car command-history))) 249 (repeat-message "Repeating %S" repeat-command) 250 (eval repeat-command)) 251 (if (null repeat-arg) 252 (repeat-message "Repeating command %S" real-last-command) 253 (setq current-prefix-arg repeat-arg) 254 (repeat-message "Repeating command %S %S" repeat-arg real-last-command)) 255 (if (eq real-last-command 'self-insert-command) 256 (let ((insertion 257 (if (<= (- num-input-keys 258 repeat-num-input-keys-at-self-insert) 259 1) 260 repeat-last-self-insert 261 (let ((range (nth 1 buffer-undo-list))) 262 (condition-case nil 263 (setq repeat-last-self-insert 264 (buffer-substring (car range) 265 (cdr range))) 266 (error (error "%s %s %s" ;Danger, Will Robinson! 267 "repeat can't intuit what you" 268 "inserted before auto-fill" 269 "clobbered it, sorry"))))))) 270 (setq repeat-num-input-keys-at-self-insert num-input-keys) 271 ;; If the self-insert had a repeat count, INSERTION 272 ;; includes that many copies of the same character. 273 ;; So use just the first character 274 ;; and repeat it the right number of times. 275 (setq insertion (substring insertion -1)) 276 (let ((count (prefix-numeric-value repeat-arg)) 277 (i 0)) 278 (while (< i count) 279 (repeat-self-insert insertion) 280 (setq i (1+ i))))) 281 (let ((indirect (indirect-function real-last-command))) 282 (if (or (stringp indirect) 283 (vectorp indirect)) 284 ;; Bind real-last-command so that executing the macro 285 ;; does not alter it. 286 (let ((real-last-command real-last-command)) 287 (execute-kbd-macro real-last-command)) 288 (run-hooks 'pre-command-hook) 289 (call-interactively real-last-command) 290 (run-hooks 'post-command-hook))))) 291 (when repeat-repeat-char 292 ;; A simple recursion here gets into trouble with max-lisp-eval-depth 293 ;; on long sequences of repetitions of a command like `forward-word' 294 ;; (only 32 repetitions are possible given the default value of 200 for 295 ;; max-lisp-eval-depth), but if I now locally disable the repeat char I 296 ;; can iterate indefinitely here around a single level of recursion. 297 (let (repeat-on-final-keystroke) 298 (while (eq (read-event) repeat-repeat-char) 299 ;; Make each repetition undo separately. 300 (undo-boundary) 301 (repeat repeat-arg)) 302 (setq unread-command-events (list last-input-event)))))) 303 304(defun repeat-self-insert (string) 305 (let ((i 0)) 306 (while (< i (length string)) 307 (let ((last-command-char (aref string i))) 308 (self-insert-command 1)) 309 (setq i (1+ i))))) 310 311(defun repeat-message (format &rest args) 312 "Like `message' but displays with `repeat-message-function' if non-nil." 313 (let ((message (apply 'format format args))) 314 (if repeat-message-function 315 (funcall repeat-message-function message) 316 (message "%s" message)))) 317 318;; OK, there's one situation left where that doesn't work correctly: when the 319;; most recent self-insertion provoked an auto-fill. The problem is that 320;; unravelling the undo information after an auto-fill is too hard, since all 321;; kinds of stuff can get in there as a result of comment prefixes etc. It'd 322;; be possible to advise do-auto-fill to record the most recent 323;; self-insertion before it does its thing, but that's a performance hit on 324;; auto-fill, which already has performance problems; so it's better to just 325;; leave it like this. If text didn't provoke an auto-fill when the user 326;; typed it, this'll correctly repeat its self-insertion, even if the 327;; repetition does cause auto-fill. 328 329;; If you wanted perfection, probably it'd be necessary to hack do-auto-fill 330;; into 2 functions, maybe-do-auto-fill & really-do-auto-fill, because only 331;; really-do-auto-fill should be advised. As things are, either the undo 332;; information would need to be scanned on every do-auto-fill invocation, or 333;; the code at the top of do-auto-fill deciding whether filling is necessary 334;; would need to be duplicated in the advice, wasting execution time when 335;; filling does turn out to be necessary. 336 337;; I thought maybe this story had a moral, something about functional 338;; decomposition; but now I'm not even sure of that, since a function 339;; call per se is a performance hit, & even the code that would 340;; correspond to really-do-auto-fill has performance problems that 341;; can make it necessary to stop typing while Emacs catches up. 342;; Maybe the real moral is that perfection is a chimera. 343 344;; Ah, hell, it's all going to fall into a black hole someday anyway. 345 346;;;;; ************************* EMACS CONTROL ************************* ;;;;; 347 348(provide 'repeat) 349 350;;; arch-tag: cd569600-a1ad-4fa7-9062-bb91dfeaf1db 351;;; repeat.el ends here 352