001: @c This is part of the Emacs manual.
002: @c Copyright (C) 1985-1987, 1993-1995, 1997, 2000-2018 Free Software
003: @c Foundation, Inc.
004: @c See file emacs.texi for copying conditions.
005: @node Keyboard Macros
006: @chapter Keyboard Macros
007: @cindex defining keyboard macros
008: @cindex keyboard macro
009: 
010:   In this chapter we describe how to record a sequence of editing
011: commands so you can repeat it conveniently later.
012: 
013:   A @dfn{keyboard macro} is a command defined by an Emacs user to stand for
014: another sequence of keys.  For example, if you discover that you are
015: about to type @kbd{C-n M-d C-d} forty times, you can speed your work by
016: defining a keyboard macro to do @kbd{C-n M-d C-d}, and then executing
017: it 39 more times.
018: 
019:   You define a keyboard macro by executing and recording the commands
020: which are its definition.  Put differently, as you define a keyboard
021: macro, the definition is being executed for the first time.  This way,
022: you can see the effects of your commands, so that you don't have to
023: figure them out in your head.  When you close the definition, the
024: keyboard macro is defined and also has been, in effect, executed once.
025: You can then do the whole thing over again by invoking the macro.
026: 
027:   Keyboard macros differ from ordinary Emacs commands in that they are
028: written in the Emacs command language rather than in Lisp.  This makes it
029: easier for the novice to write them, and makes them more convenient as
030: temporary hacks.  However, the Emacs command language is not powerful
031: enough as a programming language to be useful for writing anything
032: intelligent or general.  For such things, Lisp must be used.
033: 
034: @menu
035: * Basic Keyboard Macro::     Defining and running keyboard macros.
036: * Keyboard Macro Ring::      Where previous keyboard macros are saved.
037: * Keyboard Macro Counter::   Inserting incrementing numbers in macros.
038: * Keyboard Macro Query::     Making keyboard macros do different things each
039:                                time.
040: * Save Keyboard Macro::      Giving keyboard macros names; saving them in
041:                                files.
042: * Edit Keyboard Macro::      Editing keyboard macros.
043: * Keyboard Macro Step-Edit:: Interactively executing and editing a keyboard
044:                                macro.
045: @end menu
046: 
047: @node Basic Keyboard Macro
048: @section Basic Use
049: 
050: @table @kbd
051: @item @key{F3}
052: @itemx C-x (
053: Start defining a keyboard macro
054: (@code{kmacro-start-macro-or-insert-counter}).
055: @item @key{F4}
056: @itemx C-x e
057: If a keyboard macro is being defined, end the definition; otherwise,
058: execute the most recent keyboard macro
059: (@code{kmacro-end-or-call-macro}).
060: @item C-u @key{F3}
061: @itemx C-u C-x (
062: Re-execute last keyboard macro, then append keys to its definition.
063: @item C-u C-u @key{F3}
064: @itemx C-u C-u C-x (
065: Append keys to the last keyboard macro without re-executing it.
066: @item C-x C-k r
067: Run the last keyboard macro on each line that begins in the region
068: (@code{apply-macro-to-region-lines}).
069: @end table
070: 
071: @kindex F3
072: @kindex F4
073: @findex kmacro-start-macro-or-insert-counter
074: @findex kmacro-end-or-call-macro
075: @findex kmacro-end-and-call-macro
076:   To start defining a keyboard macro, type @key{F3}.  From then on,
077: your keys continue to be executed, but also become part of the
078: definition of the macro.  @samp{Def} appears in the mode line to
079: remind you of what is going on.  When you are finished, type @key{F4}
080: (@code{kmacro-end-or-call-macro}) to terminate the definition.  For
081: example,
082: 
083: @example
084: @key{F3} M-f foo @key{F4}
085: @end example
086: 
087: @noindent
088: defines a macro to move forward a word and then insert @samp{foo}.
089: Note that @key{F3} and @key{F4} do not become part of the macro.
090: 
091:   After defining the macro, you can call it with @key{F4}.  For the
092: above example, this has the same effect as typing @kbd{M-f foo} again.
093: (Note the two roles of the @key{F4} command: it ends the macro if you
094: are in the process of defining one, or calls the last macro
095: otherwise.)  You can also supply @key{F4} with a numeric prefix
096: argument @samp{n}, which means to invoke the macro @samp{n} times.  An
097: argument of zero repeats the macro indefinitely, until it gets an
098: error or you type @kbd{C-g} (or, on MS-DOS, @kbd{C-@key{BREAK}}).
099: 
100:   The above example demonstrates a handy trick that you can employ
101: with keyboard macros: if you wish to repeat an operation at regularly
102: spaced places in the text, include a motion command as part of the
103: macro.  In this case, repeating the macro inserts the string
104: @samp{foo} after each successive word.
105: 
106:   After terminating the definition of a keyboard macro, you can append
107: more keystrokes to its definition by typing @kbd{C-u @key{F3}}.  This
108: is equivalent to plain @key{F3} followed by retyping the whole
109: definition so far.  As a consequence, it re-executes the macro as
110: previously defined.  If you change the variable
111: @code{kmacro-execute-before-append} to @code{nil}, the existing macro
112: will not be re-executed before appending to it (the default is
113: @code{t}).  You can also add to the end of the definition of the last
114: keyboard macro without re-executing it by typing @kbd{C-u C-u
115: @key{F3}}.
116: 
117:   When a command reads an argument with the minibuffer, your
118: minibuffer input becomes part of the macro along with the command.  So
119: when you replay the macro, the command gets the same argument as when
120: you entered the macro.  For example,
121: 
122: @example
123: @key{F3} C-a C-k C-x b foo @key{RET} C-y C-x b @key{RET} @key{F4}
124: @end example
125: 
126: @noindent
127: defines a macro that kills the current line, yanks it into the buffer
128: @samp{foo}, then returns to the original buffer.
129: 
130:   Most keyboard commands work as usual in a keyboard macro definition,
131: with some exceptions.  Typing @kbd{C-g} (@code{keyboard-quit}) quits
132: the keyboard macro definition.  Typing @kbd{C-M-c}
133: (@code{exit-recursive-edit}) can be unreliable: it works as you'd
134: expect if exiting a recursive edit that started within the macro, but
135: if it exits a recursive edit that started before you invoked the
136: keyboard macro, it also necessarily exits the keyboard macro too.
137: Mouse events are also unreliable, even though you can use them in a
138: keyboard macro: when the macro replays the mouse event, it uses the
139: original mouse position of that event, the position that the mouse had
140: while you were defining the macro.  The effect of this may be hard to
141: predict.
142: 
143: @findex apply-macro-to-region-lines
144: @kindex C-x C-k r
145:   The command @kbd{C-x C-k r} (@code{apply-macro-to-region-lines})
146: repeats the last defined keyboard macro on each line that begins in
147: the region.  It does this line by line, by moving point to the
148: beginning of the line and then executing the macro.
149: 
150: @kindex C-x (
151: @kindex C-x )
152: @kindex C-x e
153: @findex kmacro-start-macro
154: @findex kmacro-end-macro
155:   In addition to the @key{F3} and @key{F4} commands described above,
156: Emacs also supports an older set of key bindings for defining and
157: executing keyboard macros.  To begin a macro definition, type @kbd{C-x
158: (} (@code{kmacro-start-macro}); as with @key{F3}, a prefix argument
159: appends this definition to the last keyboard macro.  To end a macro
160: definition, type @kbd{C-x )} (@code{kmacro-end-macro}).  To execute
161: the most recent macro, type @kbd{C-x e}
162: (@code{kmacro-end-and-call-macro}).  If you enter @kbd{C-x e} while
163: defining a macro, the macro is terminated and executed immediately.
164: Immediately after typing @kbd{C-x e}, you can type @kbd{e} repeatedly
165: to immediately repeat the macro one or more times.  You can also give
166: @kbd{C-x e} a repeat argument, just like @key{F4} (when it is used to
167: execute a macro).
168: 
169:   @kbd{C-x )} can be given a repeat count as an argument.  This means
170: to repeat the macro right after defining it.  The macro definition
171: itself counts as the first repetition, since it is executed as you
172: define it, so @kbd{C-u 4 C-x )} executes the macro immediately 3
173: additional times.
174: 
175: @node Keyboard Macro Ring
176: @section The Keyboard Macro Ring
177: 
178:   All defined keyboard macros are recorded in the @dfn{keyboard macro
179: ring}.  There is only one keyboard macro ring, shared by all buffers.
180: 
181: @table @kbd
182: @item C-x C-k C-k
183: Execute the keyboard macro at the head of the ring (@code{kmacro-end-or-call-macro-repeat}).
184: @item C-x C-k C-n
185: Rotate the keyboard macro ring to the next macro (defined earlier)
186: (@code{kmacro-cycle-ring-next}).
187: @item C-x C-k C-p
188: Rotate the keyboard macro ring to the previous macro (defined later)
189: (@code{kmacro-cycle-ring-previous}).
190: @end table
191: 
192:   All commands which operate on the keyboard macro ring use the
193: same @kbd{C-x C-k} prefix.  Most of these commands can be executed and
194: repeated immediately after each other without repeating the @kbd{C-x
195: C-k} prefix.  For example,
196: 
197: @example
198: 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
199: @end example
200: 
201: @noindent
202: will rotate the keyboard macro ring to the second-previous macro,
203: execute the resulting head macro three times, rotate back to the
204: original head macro, execute that once, rotate to the previous
205: macro, execute that, and finally delete it from the macro ring.
206: 
207: @findex kmacro-end-or-call-macro-repeat
208: @kindex C-x C-k C-k
209:   The command @kbd{C-x C-k C-k} (@code{kmacro-end-or-call-macro-repeat})
210: executes the keyboard macro at the head of the macro ring.  You can
211: repeat the macro immediately by typing another @kbd{C-k}, or you can
212: rotate the macro ring immediately by typing @kbd{C-n} or @kbd{C-p}.
213: 
214:   When a keyboard macro is being defined, @kbd{C-x C-k C-k} behaves
215: like @key{F4} except that, immediately afterward, you can use most key
216: bindings of this section without the @kbd{C-x C-k} prefix.  For
217: instance, another @kbd{C-k} will re-execute the macro.
218: 
219: @findex kmacro-cycle-ring-next
220: @kindex C-x C-k C-n
221: @findex kmacro-cycle-ring-previous
222: @kindex C-x C-k C-p
223:   The commands @kbd{C-x C-k C-n} (@code{kmacro-cycle-ring-next}) and
224: @kbd{C-x C-k C-p} (@code{kmacro-cycle-ring-previous}) rotate the
225: macro ring, bringing the next or previous keyboard macro to the head
226: of the macro ring.  The definition of the new head macro is displayed
227: in the echo area.  You can continue to rotate the macro ring
228: immediately by repeating just @kbd{C-n} and @kbd{C-p} until the
229: desired macro is at the head of the ring.  To execute the new macro
230: ring head immediately, just type @kbd{C-k}.
231: 
232:   Note that Emacs treats the head of the macro ring as the last
233: defined keyboard macro.  For instance, @key{F4} will execute that
234: macro, and @kbd{C-x C-k n} will give it a name.
235: 
236: @vindex kmacro-ring-max
237:   The maximum number of macros stored in the keyboard macro ring is
238: determined by the customizable variable @code{kmacro-ring-max}.
239: 
240: @node Keyboard Macro Counter
241: @section The Keyboard Macro Counter
242: 
243:   Each keyboard macro has an associated counter, which is initialized
244: to 0 when you start defining the macro.  This counter allows you to
245: insert a number into the buffer that depends on the number of times
246: the macro has been called.  The counter is incremented each time its
247: value is inserted into the buffer.
248: 
249: @table @kbd
250: @item @key{F3}
251: In a keyboard macro definition, insert the keyboard macro counter
252: value in the buffer (@code{kmacro-start-macro-or-insert-counter}).
253: @item C-x C-k C-i
254: Insert the keyboard macro counter value in the buffer
255: (@code{kmacro-insert-counter}).
256: @item C-x C-k C-c
257: Set the keyboard macro counter (@code{kmacro-set-counter}).
258: @item C-x C-k C-a
259: Add the prefix arg to the keyboard macro counter (@code{kmacro-add-counter}).
260: @item C-x C-k C-f
261: Specify the format for inserting the keyboard macro counter
262: (@code{kmacro-set-format}).
263: @end table
264: 
265: @findex kmacro-insert-counter
266: @kindex C-x C-k C-i
267:   When you are defining a keyboard macro, the command @key{F3}
268: (@code{kmacro-start-macro-or-insert-counter}) inserts the current
269: value of the keyboard macro's counter into the buffer, and increments
270: the counter by 1.  (If you are not defining a macro, @key{F3} begins a
271: macro definition instead.  @xref{Basic Keyboard Macro}.)  You can use
272: a numeric prefix argument to specify a different increment.  If you
273: just specify a @kbd{C-u} prefix, that is the same as an increment of
274: zero: it inserts the current counter value without changing it.
275: 
276:   As an example, let us show how the keyboard macro counter can be
277: used to build a numbered list.  Consider the following key sequence:
278: 
279: @example
280: @key{F3} C-a @key{F3} . @key{SPC} @key{F4}
281: @end example
282: 
283: @noindent
284: As part of this keyboard macro definition, the string @samp{0. } was
285: inserted into the beginning of the current line.  If you now move
286: somewhere else in the buffer and type @key{F4} to invoke the macro,
287: the string @samp{1. } is inserted at the beginning of that line.
288: Subsequent invocations insert @samp{2. }, @samp{3. }, and so forth.
289: 
290:   The command @kbd{C-x C-k C-i} (@code{kmacro-insert-counter}) does
291: the same thing as @key{F3}, but it can be used outside a keyboard
292: macro definition.  When no keyboard macro is being defined or
293: executed, it inserts and increments the counter of the macro at the
294: head of the keyboard macro ring.
295: 
296: @findex kmacro-set-counter
297: @kindex C-x C-k C-c
298:   The command @kbd{C-x C-k C-c} (@code{kmacro-set-counter}) sets the
299: current macro counter to the value of the numeric argument.  If you use
300: it inside the macro, it operates on each repetition of the macro.  If
301: you specify just @kbd{C-u} as the prefix, while executing the macro,
302: that resets the counter to the value it had at the beginning of the
303: current repetition of the macro (undoing any increments so far in this
304: repetition).
305: 
306: @findex kmacro-add-counter
307: @kindex C-x C-k C-a
308:   The command @kbd{C-x C-k C-a} (@code{kmacro-add-counter}) adds the
309: prefix argument to the current macro counter.  With just @kbd{C-u} as
310: argument, it resets the counter to the last value inserted by any
311: keyboard macro.  (Normally, when you use this, the last insertion
312: will be in the same macro and it will be the same counter.)
313: 
314: @findex kmacro-set-format
315: @kindex C-x C-k C-f
316:   The command @kbd{C-x C-k C-f} (@code{kmacro-set-format}) prompts for
317: the format to use when inserting the macro counter.  The default
318: format is @samp{%d}, which means to insert the number in decimal
319: without any padding.  You can exit with empty minibuffer to reset the
320: format to this default.  You can specify any format string that the
321: @code{format} function accepts and that makes sense with a single
322: integer extra argument (@pxref{Formatting Strings,,, elisp, The Emacs
323: Lisp Reference Manual}).  Do not put the format string inside double
324: quotes when you insert it in the minibuffer.
325: 
326:   If you use this command while no keyboard macro is being defined or
327: executed, the new format affects all subsequent macro definitions.
328: Existing macros continue to use the format in effect when they were
329: defined.  If you set the format while defining a keyboard macro, this
330: affects the macro being defined from that point on, but it does not
331: affect subsequent macros.  Execution of the macro will, at each step,
332: use the format in effect at that step during its definition.  Changes
333: to the macro format during execution of a macro, like the
334: corresponding changes during its definition, have no effect on
335: subsequent macros.
336: 
337:   The format set by @kbd{C-x C-k C-f} does not affect insertion of
338: numbers stored in registers.
339: 
340:   If you use a register as a counter, incrementing it on each
341: repetition of the macro, that accomplishes the same thing as a
342: keyboard macro counter.  @xref{Number Registers}.  For most purposes,
343: it is simpler to use a keyboard macro counter.
344: 
345: @node Keyboard Macro Query
346: @section Executing Macros with Variations
347: 
348:   In a keyboard macro, you can create an effect similar to that of
349: @code{query-replace}, in that the macro asks you each time around
350: whether to make a change.
351: 
352: @table @kbd
353: @item C-x q
354: When this point is reached during macro execution, ask for confirmation
355: (@code{kbd-macro-query}).
356: @end table
357: 
358: @kindex C-x q
359: @findex kbd-macro-query
360:   While defining the macro, type @kbd{C-x q} at the point where you
361: want the query to occur.  During macro definition, the @kbd{C-x q}
362: does nothing, but when you run the macro later, @kbd{C-x q} asks you
363: interactively whether to continue.
364: 
365:   The valid responses when @kbd{C-x q} asks are:
366: 
367: @table @asis
368: @item @key{SPC} (or @kbd{y})
369: Continue executing the keyboard macro.
370: 
371: @item @key{DEL} (or @kbd{n})
372: Skip the remainder of this repetition of the macro, and start right
373: away with the next repetition.
374: 
375: @item @key{RET} (or @kbd{q})
376: Skip the remainder of this repetition and cancel further repetitions.
377: 
378: @item @kbd{C-r}
379: Enter a recursive editing level, in which you can perform editing
380: which is not part of the macro.  When you exit the recursive edit
381: using @kbd{C-M-c}, you are asked again how to continue with the
382: keyboard macro.  If you type a @key{SPC} at this time, the rest of the
383: macro definition is executed.  It is up to you to leave point and the
384: text in a state such that the rest of the macro will do what you want.
385: @end table
386: 
387:   @kbd{C-u C-x q}, which is @kbd{C-x q} with a numeric argument,
388: performs a completely different function.  It enters a recursive edit
389: reading input from the keyboard, both when you type it during the
390: definition of the macro, and when it is executed from the macro.  During
391: definition, the editing you do inside the recursive edit does not become
392: part of the macro.  During macro execution, the recursive edit gives you
393: a chance to do some particularized editing on each repetition.
394: @xref{Recursive Edit}.
395: 
396: @node Save Keyboard Macro
397: @section Naming and Saving Keyboard Macros
398: 
399: @table @kbd
400: @item C-x C-k n
401: Give a command name (for the duration of the Emacs session) to the most
402: recently defined keyboard macro (@code{kmacro-name-last-macro}).
403: @item C-x C-k b
404: Bind the most recently defined keyboard macro to a key sequence (for
405: the duration of the session) (@code{kmacro-bind-to-key}).
406: @item M-x insert-kbd-macro
407: Insert in the buffer a keyboard macro's definition, as Lisp code.
408: @end table
409: 
410: @cindex saving keyboard macros
411: @findex kmacro-name-last-macro
412: @kindex C-x C-k n
413:   If you wish to save a keyboard macro for later use, you can give it
414: a name using @kbd{C-x C-k n} (@code{kmacro-name-last-macro}).
415: This reads a name as an argument using the minibuffer and defines that
416: name to execute the last keyboard macro, in its current form.  (If you
417: later add to the definition of this macro, that does not alter the
418: name's definition as a macro.)  The macro name is a Lisp symbol, and
419: defining it in this way makes it a valid command name for calling with
420: @kbd{M-x} or for binding a key to with @code{global-set-key}
421: (@pxref{Keymaps}).  If you specify a name that has a prior definition
422: other than a keyboard macro, an error message is shown and nothing is
423: changed.
424: 
425: @cindex binding keyboard macros
426: @findex kmacro-bind-to-key
427: @kindex C-x C-k b
428:   You can also bind the last keyboard macro (in its current form) to a
429: key, using @kbd{C-x C-k b} (@code{kmacro-bind-to-key}) followed by the
430: key sequence you want to bind.  You can bind to any key sequence in
431: the global keymap, but since most key sequences already have other
432: bindings, you should select the key sequence carefully.  If you try to
433: bind to a key sequence with an existing binding (in any keymap), this
434: command asks you for confirmation before replacing the existing binding.
435: 
436:   To avoid problems caused by overriding existing bindings, the key
437: sequences @kbd{C-x C-k 0} through @kbd{C-x C-k 9} and @kbd{C-x C-k A}
438: through @kbd{C-x C-k Z} are reserved for your own keyboard macro
439: bindings.  In fact, to bind to one of these key sequences, you only
440: need to type the digit or letter rather than the whole key sequences.
441: For example,
442: 
443: @example
444: C-x C-k b 4
445: @end example
446: 
447: @noindent
448: will bind the last keyboard macro to the key sequence @kbd{C-x C-k 4}.
449: 
450: @findex insert-kbd-macro
451:   Once a macro has a command name, you can save its definition in a file.
452: Then it can be used in another editing session.  First, visit the file
453: you want to save the definition in.  Then use this command:
454: 
455: @example
456: M-x insert-kbd-macro @key{RET} @var{macroname} @key{RET}
457: @end example
458: 
459: @noindent
460: This inserts some Lisp code that, when executed later, will define the
461: same macro with the same definition it has now.  (You don't need to
462: understand Lisp code to do this, because @code{insert-kbd-macro} writes
463: the Lisp code for you.)  Then save the file.  You can load the file
464: later with @code{load-file} (@pxref{Lisp Libraries}).  If the file you
465: save in is your init file @file{~/.emacs} (@pxref{Init File}) then the
466: macro will be defined each time you run Emacs.
467: 
468:   If you give @code{insert-kbd-macro} a numeric argument, it makes
469: additional Lisp code to record the keys (if any) that you have bound
470: to @var{macroname}, so that the macro will be reassigned the same keys
471: when you load the file.
472: 
473: @node Edit Keyboard Macro
474: @section Editing a Keyboard Macro
475: 
476: @table @kbd
477: @item C-x C-k C-e
478: Edit the last defined keyboard macro (@code{kmacro-edit-macro}).
479: @item C-x C-k e @var{name} @key{RET}
480: Edit a previously defined keyboard macro @var{name} (@code{edit-kbd-macro}).
481: @item C-x C-k l
482: Edit the last 300 keystrokes as a keyboard macro
483: (@code{kmacro-edit-lossage}).
484: @end table
485: 
486: @findex kmacro-edit-macro
487: @kindex C-x C-k C-e
488: @kindex C-x C-k RET
489:   You can edit the last keyboard macro by typing @kbd{C-x C-k C-e} or
490: @kbd{C-x C-k @key{RET}} (@code{kmacro-edit-macro}).  This formats the
491: macro definition in a buffer and enters a specialized major mode for
492: editing it.  Type @kbd{C-h m} once in that buffer to display details
493: of how to edit the macro.  When you are finished editing, type
494: @kbd{C-c C-c}.
495: 
496: @findex edit-kbd-macro
497: @kindex C-x C-k e
498:   You can edit a named keyboard macro or a macro bound to a key by typing
499: @kbd{C-x C-k e} (@code{edit-kbd-macro}).  Follow that with the
500: keyboard input that you would use to invoke the macro---@kbd{C-x e} or
501: @kbd{M-x @var{name}} or some other key sequence.
502: 
503: @findex kmacro-edit-lossage
504: @kindex C-x C-k l
505:   You can edit the last 300 keystrokes as a macro by typing
506: @kbd{C-x C-k l} (@code{kmacro-edit-lossage}).
507: 
508: @node Keyboard Macro Step-Edit
509: @section Stepwise Editing a Keyboard Macro
510: 
511: @findex kmacro-step-edit-macro
512: @kindex C-x C-k SPC
513:   You can interactively replay and edit the last keyboard
514: macro, one command at a time, by typing @kbd{C-x C-k @key{SPC}}
515: (@code{kmacro-step-edit-macro}).  Unless you quit the macro using
516: @kbd{q} or @kbd{C-g}, the edited macro replaces the last macro on the
517: macro ring.
518: 
519:   This macro editing feature shows the last macro in the minibuffer
520: together with the first (or next) command to be executed, and prompts
521: you for an action.  You can enter @kbd{?} to get a summary of your
522: options.  These actions are available:
523: 
524: @itemize @bullet{}
525: @item
526: @key{SPC} and @kbd{y} execute the current command, and advance to the
527: next command in the keyboard macro.
528: @item
529: @kbd{n}, @kbd{d}, and @key{DEL} skip and delete the current command.
530: @item
531: @kbd{f} skips the current command in this execution of the keyboard
532: macro, but doesn't delete it from the macro.
533: @item
534: @key{TAB} executes the current command, as well as all similar
535: commands immediately following the current command; for example, @key{TAB}
536: may be used to insert a sequence of characters (corresponding to a
537: sequence of @code{self-insert-command} commands).
538: @item
539: @kbd{c} continues execution (without further editing) until the end of
540: the keyboard macro.  If execution terminates normally, the edited
541: macro replaces the original keyboard macro.
542: @item
543: @kbd{C-k} skips and deletes the rest of the keyboard macro,
544: terminates step-editing, and replaces the original keyboard macro
545: with the edited macro.
546: @item
547: @kbd{q} and @kbd{C-g} cancels the step-editing of the keyboard macro;
548: discarding any changes made to the keyboard macro.
549: @item
550: @kbd{i @var{key}@dots{} C-j} reads and executes a series of key sequences (not
551: including the final @kbd{C-j}), and inserts them before the current
552: command in the keyboard macro, without advancing over the current
553: command.
554: @item
555: @kbd{I @var{key}@dots{}} reads one key sequence, executes it, and inserts it
556: before the current command in the keyboard macro, without advancing
557: over the current command.
558: @item
559: @kbd{r @var{key}@dots{} C-j} reads and executes a series of key sequences (not
560: including the final @kbd{C-j}), and replaces the current command in
561: the keyboard macro with them, advancing over the inserted key
562: sequences.
563: @item
564: @kbd{R @var{key}@dots{}} reads one key sequence, executes it, and replaces the
565: current command in the keyboard macro with that key sequence,
566: advancing over the inserted key sequence.
567: @item
568: @kbd{a @var{key}@dots{} C-j} executes the current command, then reads and
569: executes a series of key sequences (not including the final
570: @kbd{C-j}), and inserts them after the current command in the keyboard
571: macro; it then advances over the current command and the inserted key
572: sequences.
573: @item
574: @kbd{A @var{key}@dots{} C-j} executes the rest of the commands in the keyboard
575: macro, then reads and executes a series of key sequences (not
576: including the final @kbd{C-j}), and appends them at the end of the
577: keyboard macro; it then terminates the step-editing and replaces the
578: original keyboard macro with the edited macro.
579: @end itemize
580: