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