Commit | Line | Data |
---|---|---|
eef59362 KS |
1 | @c This is part of the Emacs manual. |
2 | @c Copyright (C) 1985,86,87,93,94,95,97,2000,2001,2002,2003 | |
3 | @c Free Software Foundation, Inc. | |
4 | @c See file emacs.texi for copying conditions. | |
5 | @node Keyboard Macros, Files, Fixit, Top | |
6 | @chapter Keyboard Macros | |
eef59362 KS |
7 | @cindex defining keyboard macros |
8 | @cindex keyboard macro | |
9 | ||
10 | In this chapter we describe how a sequence of editing commands can | |
11 | be recorded and repeated multiple times. | |
12 | ||
13 | A @dfn{keyboard macro} is a command defined by the user to stand for | |
14 | another sequence of keys. For example, if you discover that you are | |
15 | about to type @kbd{C-n C-d} forty times, you can speed your work by | |
16 | defining a keyboard macro to do @kbd{C-n C-d} and calling it with a | |
17 | repeat count of forty. | |
18 | ||
19 | You define a keyboard macro while executing the commands which are the | |
20 | definition. Put differently, as you define a keyboard macro, the | |
21 | definition is being executed for the first time. This way, you can see | |
22 | what the effects of your commands are, so that you don't have to figure | |
23 | them out in your head. When you are finished, the keyboard macro is | |
24 | defined and also has been, in effect, executed once. You can then do the | |
25 | whole thing over again by invoking the macro. | |
26 | ||
27 | Keyboard macros differ from ordinary Emacs commands in that they are | |
28 | written in the Emacs command language rather than in Lisp. This makes it | |
29 | easier for the novice to write them, and makes them more convenient as | |
30 | temporary hacks. However, the Emacs command language is not powerful | |
31 | enough as a programming language to be useful for writing anything | |
32 | intelligent or general. For such things, Lisp must be used. | |
33 | ||
34 | @menu | |
35 | * Basic Keyboard Macro:: Defining and running keyboard macros. | |
36 | * Keyboard Macro Ring:: Where previous keyboard macros are saved. | |
37 | * Keyboard Macro Counter:: Inserting incrementing numbers in macros. | |
38 | * Keyboard Macro Query:: Making keyboard macros do different things each time. | |
39 | * Save Keyboard Macro:: Giving keyboard macros names; saving them in files. | |
40 | * Edit Keyboard Macro:: Editing keyboard macros. | |
41 | * Keyboard Macro Step-Edit:: Interactively executing and editing a keyboard macro. | |
42 | @end menu | |
43 | ||
44 | @node Basic Keyboard Macro | |
45 | @section Basic Use | |
46 | ||
47 | @table @kbd | |
48 | @item C-x ( | |
49 | Start defining a keyboard macro (@code{kmacro-start-macro}). | |
50 | @item C-x ) | |
51 | End the definition of a keyboard macro (@code{kmacro-end-macro}). | |
52 | @item C-x e | |
53 | Execute the most recent keyboard macro (@code{kmacro-end-and-call-macro}). | |
54 | First end the definition of the keyboard macro, if currently defining it. | |
55 | To immediately execute the keyboard macro again, just repeat the @kbd{e}. | |
56 | @item C-u C-x ( | |
57 | Re-execute last keyboard macro, then add more keys to its definition. | |
58 | @item C-u C-u C-x ( | |
59 | Add more keys to the last keyboard macro without re-executing it. | |
60 | @item C-x q | |
61 | When this point is reached during macro execution, ask for confirmation | |
62 | (@code{kbd-macro-query}). | |
63 | @item C-x C-k n | |
64 | Give a command name (for the duration of the session) to the most | |
65 | recently defined keyboard macro (@code{name-last-kbd-macro}). | |
66 | @item C-x C-k b | |
67 | Bind the most recently defined keyboard macro to a key sequence (for | |
68 | the duration of the session) (@code{kmacro-bind-to-key}). | |
69 | @item M-x insert-kbd-macro | |
70 | Insert in the buffer a keyboard macro's definition, as Lisp code. | |
71 | @item C-x C-k e | |
72 | Edit a previously defined keyboard macro (@code{edit-kbd-macro}). | |
73 | @item C-x C-k r | |
74 | Run the last keyboard macro on each complete line in the region | |
75 | (@code{apply-macro-to-region-lines}). | |
76 | @end table | |
77 | ||
78 | @kindex C-x ( | |
79 | @kindex C-x ) | |
80 | @kindex C-x e | |
81 | @findex kmacro-start-macro | |
82 | @findex kmacro-end-macro | |
83 | @findex kmacro-end-and-call-macro | |
84 | To start defining a keyboard macro, type the @kbd{C-x (} command | |
85 | (@code{kmacro-start-macro}). From then on, your keys continue to be | |
86 | executed, but also become part of the definition of the macro. @samp{Def} | |
87 | appears in the mode line to remind you of what is going on. When you are | |
88 | finished, the @kbd{C-x )} command (@code{kmacro-end-macro}) terminates the | |
89 | definition (without becoming part of it!). For example, | |
90 | ||
91 | @example | |
92 | C-x ( M-f foo C-x ) | |
93 | @end example | |
94 | ||
95 | @noindent | |
96 | defines a macro to move forward a word and then insert @samp{foo}. | |
97 | ||
98 | The macro thus defined can be invoked again with the @kbd{C-x e} | |
99 | command (@code{kmacro-end-and-call-macro}), which may be given a | |
100 | repeat count as a numeric argument to execute the macro many times. | |
101 | If you enter @kbd{C-x e} while defining a macro, the macro is | |
102 | terminated and executed immediately. | |
103 | ||
104 | After executing the macro with @kbd{C-x e}, you can use @kbd{e} | |
105 | repeatedly to immediately repeat the macro one or more times. For example, | |
106 | ||
107 | @example | |
108 | C-x ( xyz C-x e e e | |
109 | @end example | |
110 | ||
111 | @noindent | |
112 | inserts @samp{xyzxyzxyzxyz} in the current buffer. | |
113 | ||
114 | @kbd{C-x )} can also be given a repeat count as an argument, in | |
115 | which case it repeats the macro that many times right after defining | |
116 | it, but defining the macro counts as the first repetition (since it is | |
117 | executed as you define it). Therefore, giving @kbd{C-x )} an argument | |
118 | of 4 executes the macro immediately 3 additional times. An argument | |
119 | of zero to @kbd{C-x e} or @kbd{C-x )} means repeat the macro | |
120 | indefinitely (until it gets an error or you type @kbd{C-g} or, on | |
121 | MS-DOS, @kbd{C-@key{BREAK}}). | |
122 | ||
123 | @kindex C-x C-k C-s | |
124 | @kindex C-x C-k C-k | |
125 | Alternatively, you can use @kbd{C-x C-k C-s} to start a keyboard macro, | |
126 | and @kbd{C-x C-k C-k...} to end and execute it. | |
127 | ||
128 | If you wish to repeat an operation at regularly spaced places in the | |
129 | text, define a macro and include as part of the macro the commands to move | |
130 | to the next place you want to use it. For example, if you want to change | |
131 | each line, you should position point at the start of a line, and define a | |
132 | macro to change that line and leave point at the start of the next line. | |
133 | Then repeating the macro will operate on successive lines. | |
134 | ||
135 | When a command reads an argument with the minibuffer, your | |
136 | minibuffer input becomes part of the macro along with the command. So | |
137 | when you replay the macro, the command gets the same argument as | |
138 | when you entered the macro. For example, | |
139 | ||
140 | @example | |
141 | C-x ( C-a C-@key{SPC} C-n M-w C-x b f o o @key{RET} C-y C-x b @key{RET} C-x ) | |
142 | @end example | |
143 | ||
144 | @noindent | |
145 | defines a macro that copies the current line into the buffer | |
146 | @samp{foo}, then returns to the original buffer. | |
147 | ||
148 | You can use function keys in a keyboard macro, just like keyboard | |
149 | keys. You can even use mouse events, but be careful about that: when | |
150 | the macro replays the mouse event, it uses the original mouse position | |
151 | of that event, the position that the mouse had while you were defining | |
152 | the macro. The effect of this may be hard to predict. (Using the | |
153 | current mouse position would be even less predictable.) | |
154 | ||
155 | One thing that doesn't always work well in a keyboard macro is the | |
156 | command @kbd{C-M-c} (@code{exit-recursive-edit}). When this command | |
157 | exits a recursive edit that started within the macro, it works as you'd | |
158 | expect. But if it exits a recursive edit that started before you | |
159 | invoked the keyboard macro, it also necessarily exits the keyboard macro | |
160 | as part of the process. | |
161 | ||
162 | After you have terminated the definition of a keyboard macro, you can add | |
163 | to the end of its definition by typing @kbd{C-u C-x (}. This is equivalent | |
164 | to plain @kbd{C-x (} followed by retyping the whole definition so far. As | |
165 | a consequence it re-executes the macro as previously defined. | |
166 | ||
167 | You can also add to the end of the definition of the last keyboard | |
168 | macro without re-execuing it by typing @kbd{C-u C-u C-x (}. | |
169 | ||
170 | The variable @code{kmacro-execute-before-append} specifies whether | |
171 | a single @kbd{C-u} prefix causes the existing macro to be re-executed | |
172 | before appending to it. | |
173 | ||
174 | @findex apply-macro-to-region-lines | |
175 | @kindex C-x C-k r | |
176 | The command @kbd{C-x C-k r} (@code{apply-macro-to-region-lines}) | |
177 | repeats the last defined keyboard macro on each complete line within | |
178 | the current region. It does this line by line, by moving point to the | |
179 | beginning of the line and then executing the macro. | |
180 | ||
181 | @node Keyboard Macro Ring | |
182 | @section Where previous keyboard macros are saved | |
183 | ||
184 | All defined keyboard macros are recorded in the ``keyboard macro ring'', | |
185 | a list of sequences of keys. There is only one keyboard macro ring, | |
186 | shared by all buffers. | |
187 | ||
188 | All commands which operates on the keyboard macro ring use the | |
189 | same @kbd{C-x C-k} prefix. Most of these commands can be executed and | |
190 | repeated immediately after each other without repeating the @kbd{C-x | |
191 | C-k} prefix. For example, | |
192 | ||
193 | @example | |
194 | C-x C-k C-p C-p C-k C-k C-k C-n C-n C-k C-p C-k C-d | |
195 | @end example | |
196 | ||
197 | @noindent | |
198 | will rotate the keyboard macro ring to the ``second previous'' macro, | |
199 | execute the resulting head macro three times, rotate back to the | |
200 | original head macro, execute that once, rotate to the ``previous'' | |
201 | macro, execute that, and finally delete it from the macro ring. | |
202 | ||
203 | @findex kmacro-end-or-call-macro-repeat | |
204 | @kindex C-x C-k C-k | |
205 | The command @kbd{C-x C-k C-k} (@code{kmacro-end-or-call-macro-repeat}) | |
206 | executes the keyboard macro at the head of the macro ring. You can | |
207 | repeat the macro immediately by typing another @kbd{C-k}, or you can | |
208 | rotate the macro ring immediately by typing @kbd{C-n} or @kbd{C-p}. | |
209 | ||
210 | @findex kmacro-cycle-ring-next | |
211 | @kindex C-x C-k C-n | |
212 | @findex kmacro-cycle-ring-previous | |
213 | @kindex C-x C-k C-p | |
214 | The commands @kbd{C-x C-k C-n} (@code{kmacro-cycle-ring-next}) and | |
215 | @kbd{C-x C-k C-p} (@code{kmacro-cycle-ring-previous}) rotates the | |
216 | macro ring, bringing the next or previous keyboard macro to the head | |
217 | of the macro ring. The definition of the new head macro is displayed | |
218 | in the echo area. You can continue to rotate the macro ring | |
219 | immediately by repeating just @kbd{C-n} and @kbd{C-p} until the | |
220 | desired macro is at the head of the ring. To execute the new macro | |
221 | ring head immediately, just type @kbd{C-k}. | |
222 | ||
223 | @findex kmacro-view-macro-repeat | |
224 | @kindex C-x C-k C-v | |
225 | ||
226 | The commands @kbd{C-x C-k C-v} (@code{kmacro-view-macro-repeat}) | |
227 | displays the last keyboard macro, or when repeated (with @kbd{C-v}), | |
228 | it displays the previous macro on the macro ring, just like @kbd{C-x | |
229 | C-k C-p}, but without actually rotating the macro ring. If you enter | |
230 | @kbd{C-k} immediately after displaying a macro from the ring, that | |
231 | macro is executed, but still without altering the macro ring. | |
232 | ||
233 | So while e.g. @kbd{C-x C-k C-p C-p C-k C-k} makes the 3rd previous | |
234 | macro the current macro and executes it twice, @kbd{C-x C-k C-v C-v | |
235 | C-v C-k C-k} will display and execute the 3rd previous macro once and | |
236 | then the current macro once. | |
237 | ||
238 | @findex kmacro-delete-ring-head | |
239 | @kindex C-x C-k C-d | |
240 | ||
241 | The commands @kbd{C-x C-k C-d} (@code{kmacro-delete-ring-head}) | |
242 | removes and deletes the macro currently at the head of the macro | |
243 | ring. You can use this to delete a macro that didn't work as | |
244 | expected, or which you don't need anymore. | |
245 | ||
246 | @findex kmacro-swap-ring | |
247 | @kindex C-x C-k C-t | |
248 | ||
249 | The commands @kbd{C-x C-k C-t} (@code{kmacro-swap-ring}) | |
250 | interchanges the head of the macro ring with the previous element on | |
251 | the macro ring. | |
252 | ||
253 | @findex kmacro-call-ring-2nd-repeat | |
254 | @kindex C-x C-k C-l | |
255 | ||
256 | The commands @kbd{C-x C-k C-l} (@code{kmacro-call-ring-2nd-repeat}) | |
257 | executes the previous (rather than the head) element on the macro ring. | |
258 | ||
259 | @node Keyboard Macro Counter | |
260 | @section Inserting incrementing numbers in macros | |
261 | ||
262 | Each keyboard macro has an associated counter which is automatically | |
263 | incremented on every repetition of the keyboard macro. Normally, the | |
264 | macro counter is initialized to 0 when you start defining the macro, | |
265 | and incremented by 1 after each insertion of the counter value; | |
266 | that is, if you insert the macro counter twice while defining the | |
267 | macro, it will be incremented by 2 time for each repetition of the | |
268 | macro. | |
269 | ||
270 | @findex kmacro-insert-counter | |
271 | @kindex C-x C-k C-i | |
272 | The command @kbd{C-x C-k C-i} (@code{kmacro-insert-counter}) inserts | |
273 | the current value of the keyboard macro counter and increments the | |
274 | counter by 1. You can use a numeric prefix argument to specify a | |
275 | different increment. If you specify a @kbd{C-u} prefix, the last | |
276 | inserted counter value is repeated and the counter is not incremented. | |
277 | For example, if you enter the following sequence while defining a macro | |
278 | ||
279 | @example | |
280 | C-x C-k C-i C-x C-k C-i C-u C-x C-k C-i C-x C-k C-i | |
281 | @end example | |
282 | ||
283 | @noindent | |
284 | the text @samp{0112} is inserted in the buffer, and for the first and | |
285 | second execution of the macro @samp{3445} and @samp{6778} are | |
286 | inserted. | |
287 | ||
288 | @findex kmacro-set-counter | |
289 | @kindex C-x C-k C-c | |
290 | The command @kbd{C-x C-k C-c} (@code{kmacro-set-counter}) prompts | |
291 | for the initial value of the keyboard macro counter if you use it | |
292 | before you define a keyboard macro. If you use it while defining a | |
293 | keyboard macro, you set the macro counter to the same (initial) value | |
294 | on each repetition of the macro. If you specify a @kbd{C-u} prefix, | |
295 | the counter is reset to the value it had prior to the current | |
296 | repetition of the macro (undoing any increments so far in this | |
297 | repetition). | |
298 | ||
299 | @findex kmacro-add-counter | |
300 | @kindex C-x C-k C-a | |
301 | The command @kbd{C-x C-k C-a} (@code{kmacro-add-counter}) prompts | |
302 | for a value to add to the macro counter. | |
303 | ||
304 | @findex kmacro-set-format | |
305 | @kindex C-x C-k C-f | |
306 | The command @kbd{C-x C-k C-f} (@code{kmacro-set-format}) prompts | |
307 | for the format to use when inserting the macro counter. The default | |
308 | format is @samp{%d}. If you set the counter format before you define a | |
309 | macro, that format is restored before each repetition of the macro. | |
310 | Consequently, any changes you make to the macro counter format while | |
311 | defining a macro are only active for the rest of the macro. | |
312 | ||
313 | @node Keyboard Macro Query | |
314 | @section Executing Macros with Variations | |
315 | ||
316 | @kindex C-x q | |
317 | @findex kbd-macro-query | |
318 | Using @kbd{C-x q} (@code{kbd-macro-query}), you can get an effect | |
319 | similar to that of @code{query-replace}, where the macro asks you each | |
320 | time around whether to make a change. While defining the macro, | |
321 | type @kbd{C-x q} at the point where you want the query to occur. During | |
322 | macro definition, the @kbd{C-x q} does nothing, but when you run the | |
323 | macro later, @kbd{C-x q} asks you interactively whether to continue. | |
324 | ||
325 | The valid responses when @kbd{C-x q} asks are @key{SPC} (or @kbd{y}), | |
326 | @key{DEL} (or @kbd{n}), @key{RET} (or @kbd{q}), @kbd{C-l} and @kbd{C-r}. | |
327 | The answers are the same as in @code{query-replace}, though not all of | |
328 | the @code{query-replace} options are meaningful. | |
329 | ||
330 | These responses include @key{SPC} to continue, and @key{DEL} to skip | |
331 | the remainder of this repetition of the macro and start right away with | |
332 | the next repetition. @key{RET} means to skip the remainder of this | |
333 | repetition and cancel further repetitions. @kbd{C-l} redraws the screen | |
334 | and asks you again for a character to say what to do. | |
335 | ||
336 | @kbd{C-r} enters a recursive editing level, in which you can perform | |
337 | editing which is not part of the macro. When you exit the recursive | |
338 | edit using @kbd{C-M-c}, you are asked again how to continue with the | |
339 | keyboard macro. If you type a @key{SPC} at this time, the rest of the | |
340 | macro definition is executed. It is up to you to leave point and the | |
341 | text in a state such that the rest of the macro will do what you | |
342 | want.@refill | |
343 | ||
344 | @kbd{C-u C-x q}, which is @kbd{C-x q} with a numeric argument, | |
345 | performs a completely different function. It enters a recursive edit | |
346 | reading input from the keyboard, both when you type it during the | |
347 | definition of the macro, and when it is executed from the macro. During | |
348 | definition, the editing you do inside the recursive edit does not become | |
349 | part of the macro. During macro execution, the recursive edit gives you | |
350 | a chance to do some particularized editing on each repetition. | |
351 | @xref{Recursive Edit}. | |
352 | ||
353 | Another way to vary the behavior of a keyboard macro is to use a | |
354 | register as a counter, incrementing it on each repetition of the macro. | |
355 | @xref{RegNumbers}. | |
356 | ||
357 | @node Save Keyboard Macro | |
358 | @section Naming and Saving Keyboard Macros | |
359 | ||
360 | @cindex saving keyboard macros | |
361 | @findex name-last-kbd-macro | |
362 | @kindex C-x C-k n | |
363 | If you wish to save a keyboard macro for later use, you can give it | |
364 | a name using @kbd{C-x C-k n} (@code{name-last-kbd-macro}). | |
365 | This reads a name as an argument using the minibuffer and defines that name | |
366 | to execute the macro. The macro name is a Lisp symbol, and defining it in | |
367 | this way makes it a valid command name for calling with @kbd{M-x} or for | |
368 | binding a key to with @code{global-set-key} (@pxref{Keymaps}). If you | |
369 | specify a name that has a prior definition other than another keyboard | |
370 | macro, an error message is shown and nothing is changed. | |
371 | ||
372 | @cindex binding keyboard macros | |
373 | @findex kmacro-bind-to-key | |
374 | @kindex C-x C-k b | |
375 | Rather than giving a keyboard macro a name, you can bind it to a | |
376 | key using @kbd{C-x C-k b} (@code{kmacro-bind-to-key}) followed by the | |
377 | key sequence you want the keyboard macro to be bound to. You can | |
378 | bind to any key sequence in the global keymap, but since most key | |
379 | sequences already have other bindings, you should select the key | |
380 | sequence carefylly. If you try to bind to a key sequence with an | |
381 | existing binding (in any keymap), you will be asked if you really | |
382 | want to replace the existing binding of that key. | |
383 | ||
384 | To avoid problems caused by overriding existing bindings, the key | |
385 | sequences @kbd{C-x C-k 0} through @kbd{C-x C-k 9} and @kbd{C-x C-k A} | |
386 | through @kbd{C-x C-k Z} are reserved for your own keyboard macro | |
387 | bindings. In fact, to bind to one of these key sequences, you only | |
388 | need to type the digit or letter rather than the whole key sequences. | |
389 | For example, | |
390 | ||
391 | @example | |
392 | C-x C-k b 4 | |
393 | @end example | |
394 | ||
395 | @noindent | |
396 | will bind the last keyboard macro to the key sequence @kbd{C-x C-k 4}. | |
397 | ||
398 | @findex insert-kbd-macro | |
399 | Once a macro has a command name, you can save its definition in a file. | |
400 | Then it can be used in another editing session. First, visit the file | |
401 | you want to save the definition in. Then use this command: | |
402 | ||
403 | @example | |
404 | M-x insert-kbd-macro @key{RET} @var{macroname} @key{RET} | |
405 | @end example | |
406 | ||
407 | @noindent | |
408 | This inserts some Lisp code that, when executed later, will define the | |
409 | same macro with the same definition it has now. (You need not | |
410 | understand Lisp code to do this, because @code{insert-kbd-macro} writes | |
411 | the Lisp code for you.) Then save the file. You can load the file | |
412 | later with @code{load-file} (@pxref{Lisp Libraries}). If the file you | |
413 | save in is your init file @file{~/.emacs} (@pxref{Init File}) then the | |
414 | macro will be defined each time you run Emacs. | |
415 | ||
416 | If you give @code{insert-kbd-macro} a numeric argument, it makes | |
417 | additional Lisp code to record the keys (if any) that you have bound to the | |
418 | keyboard macro, so that the macro will be reassigned the same keys when you | |
419 | load the file. | |
420 | ||
421 | @node Edit Keyboard Macro | |
422 | @section Interactively executing and editing a keyboard macro | |
423 | ||
424 | @findex kmacro-edit-macro | |
425 | @kindex C-x C-k C-e | |
426 | @kindex C-x C-k RET | |
427 | You can edit the last keyboard macro by typing @kbd{C-x C-k C-e} or | |
428 | @kbd{C-x C-k RET} (@code{kmacro-edit-macro}). This formats the macro | |
429 | definition in a buffer and enters a specialized major mode for editing | |
430 | it. Type @kbd{C-h m} once in that buffer to display details of how to | |
431 | edit the macro. When you are finished editing, type @kbd{C-c C-c}. | |
432 | ||
433 | @findex edit-kbd-macro | |
434 | @kindex C-x C-k e | |
435 | You can edit a named keyboard macro or a macro bound to a key by typing | |
436 | @kbd{C-x C-k e} (@code{edit-kbd-macro}). Follow that with the | |
437 | keyboard input that you would use to invoke the macro---@kbd{C-x e} or | |
438 | @kbd{M-x @var{name}} or some other key sequence. | |
439 | ||
440 | @findex kmacro-edit-lossage | |
441 | @kindex C-x C-k l | |
442 | You can edit the last 100 keystrokes as a macro by typing | |
443 | @kbd{C-x C-k l} (@code{kmacro-edit-lossage}). | |
444 | ||
445 | @node Keyboard Macro Step-Edit | |
446 | @section Interactively executing and editing a keyboard macro | |
447 | ||
448 | @findex kmacro-step-edit-macro | |
449 | @kindex C-x C-k SPC | |
450 | You can interactively and stepwise replay and edit the last keyboard | |
451 | macro one command at a time by typing @kbd{C-x C-k SPC} | |
452 | (@code{kmacro-step-edit-macro}). Unless you quit the macro using | |
453 | @kbd{q} or @kbd{C-g}, the edited macro replaces the last macro on the | |
454 | macro ring. | |
455 | ||
456 | This shows the last macro in the minibuffer together with the first | |
457 | (or next) command to be executed, and prompts you for an action. | |
458 | You can enter @kbd{?} to get a command summary. | |
459 | ||
460 | The following commands are available in the step-edit mode and relate | |
461 | to the first (or current) command in the keyboard macro: | |
462 | ||
463 | @itemize @bullet{} | |
464 | @item | |
465 | @kbd{SPC} and @kbd{y} execute the current command, and advance to the | |
466 | next command in the keyboard macro. | |
467 | @item | |
468 | @kbd{n}, @kbd{d}, and @kbd{DEL} skip and delete the current command. | |
469 | @item | |
470 | @kbd{f} skips the current command in this execution of the keyboard | |
471 | macro, but doesn't delete it from the macro. | |
472 | @item | |
473 | @kbd{TAB} executes the current command, as well as all similar | |
474 | commands immediately following the current command; for example, TAB | |
475 | may be used to insert a sequence of characters (corresponding to a | |
476 | sequence of @code{self-insert-command} commands). | |
477 | @item | |
478 | @kbd{c} continues execution (without further editing) until the end of | |
479 | the keyboard macro. If execution terminates normally, the edited | |
480 | macro replaces the original keyboard macro. | |
481 | @item | |
482 | @kbd{C-k} skips and deletes the rest of the keyboard macro, | |
483 | terminates step-editing, and replaces the original keyboard macro | |
484 | with the edited macro. | |
485 | @item | |
486 | @kbd{q} and @kbd{C-g} cancels the step-editing of the keyboard macro; | |
487 | discarding any changes made to the keyboard macro. | |
488 | @item | |
489 | @kbd{i KEY... C-j} reads and executes a series of key sequences (not | |
490 | including the final @kbd{C-j}), and inserts them before the current | |
491 | command in the keyboard macro, without advancing over the current | |
492 | command. | |
493 | @item | |
494 | @kbd{I KEY...} reads one key sequence, executes it, and inserts it | |
495 | before the current command in the keyboard macro, without advancing | |
496 | over the current command. | |
497 | @item | |
498 | @kbd{r KEY... C-j} reads and executes a series of key sequences (not | |
499 | including the final @kbd{C-j}), and replaces the current command in | |
500 | the keyboard macro with them, advancing over the inserted key | |
501 | sequences. | |
502 | @item | |
503 | @kbd{R KEY...} reads one key sequence, executes it, and replaces the | |
504 | current command in the keyboard macro with that key sequence, | |
505 | advancing over the inserted key sequence. | |
506 | @item | |
507 | @kbd{a KEY... C-j} executes the current command, then reads and | |
508 | executes a series of key sequences (not including the final | |
509 | @kbd{C-j}), and inserts them after the current command in the keyboard | |
510 | macro; it then advances over the current command and the inserted key | |
511 | sequences. | |
512 | @item | |
513 | @kbd{A KEY... C-j} executes the rest of the commands in the keyboard | |
514 | macro, then reads and executes a series of key sequences (not | |
515 | including the final @kbd{C-j}), and appends them at the end of the | |
516 | keyboard macro; it then terminates the step-editing and replaces the | |
517 | original keyboard macro with the edited macro. | |
518 | @end itemize | |
ab5796a9 MB |
519 | |
520 | @ignore | |
521 | arch-tag: c1b0dd3b-3159-4c08-928f-52e763953e9c | |
522 | @end ignore |