Fix bug #14306 with whitespace mode together with linum-mode.
[emacs.git] / lisp / kmacro.el
blobd6de2feb3fcfacb448ba8528df0c447033fd1b38
1 ;;; kmacro.el --- enhanced keyboard macros
3 ;; Copyright (C) 2002-2013 Free Software Foundation, Inc.
5 ;; Author: Kim F. Storm <storm@cua.dk>
6 ;; Keywords: keyboard convenience
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software: you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation, either version 3 of the License, or
13 ;; (at your option) any later version.
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
23 ;;; Commentary:
25 ;; The kmacro package provides the user interface to emacs' basic
26 ;; keyboard macro functionality. With kmacro, two function keys are
27 ;; dedicated to keyboard macros, by default F3 and F4.
29 ;; Note: The traditional bindings C-x (, C-x ), and C-x e are still
30 ;; supported, but for some users these bindings are too hard to type
31 ;; to be really useful for doing small repeated tasks.
33 ;; To start defining a keyboard macro, use F3. To end the macro,
34 ;; use F4, and to call the macro also use F4. This makes it very
35 ;; easy to repeat a macro immediately after defining it.
37 ;; You can call the macro repeatedly by pressing F4 multiple times, or
38 ;; you can give a numeric prefix argument specifying the number of
39 ;; times to repeat the macro. Macro execution automatically
40 ;; terminates when point reaches the end of the buffer or if an error
41 ;; is signaled by ringing the bell.
43 ;; When you define a macro with F3/F4, it is automatically added to
44 ;; the head of the "keyboard macro ring", and F4 actually executes the
45 ;; first element of the macro ring.
47 ;; Note: an empty macro is never added to the macro ring.
49 ;; You can execute the second element on the macro ring with C-u F4 or
50 ;; C-x C-k C-l, you can use C-x C-k C-p and C-x C-k C-n to cycle
51 ;; through the macro ring, and you can swap the first and second
52 ;; elements with C-x C-k C-t. To delete the first element in the
53 ;; macro ring, use C-x C-k C-d.
55 ;; You can also use C-x C-k C-s to start a macro, and C-x C-k C-k to
56 ;; end it; then use C-k to execute it immediately, or C-x C-k C-k to
57 ;; execute it later.
59 ;; In general, immediately after using C-x C-k followed by one of C-k,
60 ;; C-l, C-p, or C-n, you can further cycle the macro ring using C-p or
61 ;; C-n, execute the first or second macro using C-k or C-l, delete
62 ;; the head macro with C-d, or edit the current macro with C-e without
63 ;; repeating the C-x C-k prefix.
65 ;; If you enter F3 while defining the macro, the numeric value of
66 ;; `kmacro-counter' is inserted using the `kmacro-counter-format', and
67 ;; `kmacro-counter' is incremented by 1 (or the numeric prefix value
68 ;; of F3).
70 ;; The initial value of `kmacro-counter' is 0, or the numeric prefix
71 ;; value given to F3 when starting the macro.
73 ;; Now, each time you call the macro using F4, the current
74 ;; value of `kmacro-counter' is inserted and incremented, making it
75 ;; easy to insert incremental numbers in the buffer.
77 ;; Example:
79 ;; The following sequence: M-5 F3 x M-2 F3 y F4 F4 F4 F4
80 ;; inserts the following string: x5yx7yx9yx11y
82 ;; A macro can also be called using a mouse click, default S-mouse-3.
83 ;; This calls the macro at the point where you click the mouse.
85 ;; You can edit the last macro using C-x C-k C-e.
87 ;; You can append to the last macro using C-u F3.
89 ;; You can set the macro counter using C-x C-k C-c, add to it using C-x C-k C-a,
90 ;; and you can set the macro counter format with C-x C-k C-f.
92 ;; The following key bindings are performed:
94 ;; Normal While defining macro
95 ;; --------------------------- ------------------------------
96 ;; f3 Define macro Insert current counter value
97 ;; Prefix arg specifies initial and increase counter by prefix
98 ;; counter value (default 0) (default increment: 1)
100 ;; C-u f3 APPENDs to last macro
102 ;; f4 Call last macro End macro
103 ;; Prefix arg specifies number
104 ;; of times to execute macro.
106 ;; C-u f4 Swap last and head of macro ring.
108 ;; S-mouse-3 Set point at click and End macro and execute macro at
109 ;; execute last macro. click.
111 ;;; Code:
113 ;; Customization:
115 (defgroup kmacro nil
116 "Simplified keyboard macro user interface."
117 :group 'keyboard
118 :group 'convenience
119 :version "22.1"
120 :link '(emacs-commentary-link :tag "Commentary" "kmacro.el")
121 :link '(emacs-library-link :tag "Lisp File" "kmacro.el"))
123 (defcustom kmacro-call-mouse-event 'S-mouse-3
124 "The mouse event used by kmacro to call a macro.
125 Set to nil if no mouse binding is desired."
126 :type 'symbol
127 :group 'kmacro)
129 (defcustom kmacro-ring-max 8
130 "Maximum number of keyboard macros to save in macro ring."
131 :type 'integer
132 :group 'kmacro)
135 (defcustom kmacro-execute-before-append t
136 "Controls whether appending to a macro starts by executing the macro.
137 If non-nil, using a single \\[universal-argument] prefix executes the macro
138 before appending, while more than one \\[universal-argument] prefix does not
139 execute the macro.
140 Otherwise, a single \\[universal-argument] prefix does not execute the
141 macro, while more than one \\[universal-argument] prefix causes the
142 macro to be executed before appending to it."
143 :type 'boolean
144 :group 'kmacro)
147 (defcustom kmacro-repeat-no-prefix t
148 "Allow repeating certain macro commands without entering the C-x C-k prefix."
149 :type 'boolean
150 :group 'kmacro)
152 (defcustom kmacro-call-repeat-key t
153 "Allow repeating macro call using last key or a specific key."
154 :type '(choice (const :tag "Disabled" nil)
155 (const :tag "Last key" t)
156 (character :tag "Character" :value ?e)
157 (symbol :tag "Key symbol" :value RET))
158 :group 'kmacro)
160 (defcustom kmacro-call-repeat-with-arg nil
161 "Repeat macro call with original arg when non-nil; repeat once if nil."
162 :type 'boolean
163 :group 'kmacro)
165 (defcustom kmacro-step-edit-mini-window-height 0.75
166 "Override `max-mini-window-height' when step edit keyboard macro."
167 :type 'number
168 :group 'kmacro)
170 ;; Keymap
172 (defvar kmacro-keymap
173 (let ((map (make-sparse-keymap)))
174 ;; Start, end, execute macros
175 (define-key map "s" 'kmacro-start-macro)
176 (define-key map "\C-s" 'kmacro-start-macro)
177 (define-key map "\C-k" 'kmacro-end-or-call-macro-repeat)
178 (define-key map "r" 'apply-macro-to-region-lines)
179 (define-key map "q" 'kbd-macro-query) ;; Like C-x q
181 ;; macro ring
182 (define-key map "\C-n" 'kmacro-cycle-ring-next)
183 (define-key map "\C-p" 'kmacro-cycle-ring-previous)
184 (define-key map "\C-v" 'kmacro-view-macro-repeat)
185 (define-key map "\C-d" 'kmacro-delete-ring-head)
186 (define-key map "\C-t" 'kmacro-swap-ring)
187 (define-key map "\C-l" 'kmacro-call-ring-2nd-repeat)
189 ;; macro counter
190 (define-key map "\C-f" 'kmacro-set-format)
191 (define-key map "\C-c" 'kmacro-set-counter)
192 (define-key map "\C-i" 'kmacro-insert-counter)
193 (define-key map "\C-a" 'kmacro-add-counter)
195 ;; macro editing
196 (define-key map "\C-e" 'kmacro-edit-macro-repeat)
197 (define-key map "\r" 'kmacro-edit-macro)
198 (define-key map "e" 'edit-kbd-macro)
199 (define-key map "l" 'kmacro-edit-lossage)
200 (define-key map " " 'kmacro-step-edit-macro)
202 ;; naming and binding
203 (define-key map "b" 'kmacro-bind-to-key)
204 (define-key map "n" 'kmacro-name-last-macro)
205 (define-key map "x" 'kmacro-to-register)
206 map)
207 "Keymap for keyboard macro commands.")
208 (defalias 'kmacro-keymap kmacro-keymap)
210 ;;; Provide some binding for startup:
211 ;;;###autoload (global-set-key "\C-x(" 'kmacro-start-macro)
212 ;;;###autoload (global-set-key "\C-x)" 'kmacro-end-macro)
213 ;;;###autoload (global-set-key "\C-xe" 'kmacro-end-and-call-macro)
214 ;;;###autoload (global-set-key [f3] 'kmacro-start-macro-or-insert-counter)
215 ;;;###autoload (global-set-key [f4] 'kmacro-end-or-call-macro)
216 ;;;###autoload (global-set-key "\C-x\C-k" 'kmacro-keymap)
217 ;;;###autoload (autoload 'kmacro-keymap "kmacro" "Keymap for keyboard macro commands." t 'keymap)
219 (if kmacro-call-mouse-event
220 (global-set-key (vector kmacro-call-mouse-event) 'kmacro-end-call-mouse))
223 ;;; Called from keyboard-quit
225 (defun kmacro-keyboard-quit ()
226 (or (not defining-kbd-macro)
227 (eq defining-kbd-macro 'append)
228 (kmacro-ring-empty-p)
229 (kmacro-pop-ring)))
232 ;;; Keyboard macro counter
234 (defvar kmacro-counter 0
235 "Current keyboard macro counter.")
237 (defvar kmacro-default-counter-format "%d")
239 (defvar kmacro-counter-format "%d"
240 "Current keyboard macro counter format.")
242 (defvar kmacro-counter-format-start kmacro-counter-format
243 "Macro format at start of macro execution.")
245 (defvar kmacro-counter-value-start kmacro-counter
246 "Macro counter at start of macro execution.")
248 (defvar kmacro-last-counter 0
249 "Last counter inserted by key macro.")
251 (defvar kmacro-initial-counter-value nil
252 "Initial counter value for the next keyboard macro to be defined.")
255 (defun kmacro-insert-counter (arg)
256 "Insert macro counter, then increment it by ARG.
257 Interactively, ARG defaults to 1. With \\[universal-argument], insert
258 previous `kmacro-counter', and do not modify counter."
259 (interactive "P")
260 (if kmacro-initial-counter-value
261 (setq kmacro-counter kmacro-initial-counter-value
262 kmacro-initial-counter-value nil))
263 (if (and arg (listp arg))
264 (insert (format kmacro-counter-format kmacro-last-counter))
265 (insert (format kmacro-counter-format kmacro-counter))
266 (kmacro-add-counter (prefix-numeric-value arg))))
269 (defun kmacro-set-format (format)
270 "Set macro counter FORMAT."
271 (interactive "sMacro Counter Format: ")
272 (setq kmacro-counter-format
273 (if (equal format "") "%d" format))
274 ;; redefine initial macro counter if we are not executing a macro.
275 (if (not (or defining-kbd-macro executing-kbd-macro))
276 (setq kmacro-default-counter-format kmacro-counter-format)))
279 (defun kmacro-display-counter (&optional value)
280 "Display current counter value."
281 (unless value (setq value kmacro-counter))
282 (message "New macro counter value: %s (%d)" (format kmacro-counter-format value) value))
285 (defun kmacro-set-counter (arg)
286 "Set `kmacro-counter' to ARG or prompt if missing.
287 With \\[universal-argument] prefix, reset counter to its value prior to this iteration of the macro."
288 (interactive "NMacro counter value: ")
289 (if (not (or defining-kbd-macro executing-kbd-macro))
290 (kmacro-display-counter (setq kmacro-initial-counter-value arg))
291 (setq kmacro-last-counter kmacro-counter
292 kmacro-counter (if (and current-prefix-arg (listp current-prefix-arg))
293 kmacro-counter-value-start
294 arg))
295 (unless executing-kbd-macro
296 (kmacro-display-counter))))
299 (defun kmacro-add-counter (arg)
300 "Add numeric prefix arg (prompt if missing) to macro counter.
301 With \\[universal-argument], restore previous counter value."
302 (interactive "NAdd to macro counter: ")
303 (if kmacro-initial-counter-value
304 (setq kmacro-counter kmacro-initial-counter-value
305 kmacro-initial-counter-value nil))
306 (let ((last kmacro-last-counter))
307 (setq kmacro-last-counter kmacro-counter
308 kmacro-counter (if (and current-prefix-arg (listp current-prefix-arg))
309 last
310 kmacro-counter (+ kmacro-counter arg))))
311 (unless executing-kbd-macro
312 (kmacro-display-counter)))
315 (defun kmacro-loop-setup-function ()
316 "Function called prior to each iteration of macro."
317 ;; Restore macro counter format to initial format, so it is ok to change
318 ;; counter format in the macro without restoring it.
319 (setq kmacro-counter-format kmacro-counter-format-start)
320 ;; Save initial counter value so we can restore it with C-u kmacro-set-counter.
321 (setq kmacro-counter-value-start kmacro-counter)
322 ;; Return non-nil to continue execution.
326 ;;; Keyboard macro ring
328 (defvar kmacro-ring nil
329 "The keyboard macro ring.
330 Each element is a list (MACRO COUNTER FORMAT). Actually, the head of
331 the macro ring (when defining or executing) is not stored in the ring;
332 instead it is available in the variables `last-kbd-macro', `kmacro-counter',
333 and `kmacro-counter-format'.")
335 ;; Remember what we are currently looking at with kmacro-view-macro.
337 (defvar kmacro-view-last-item nil)
338 (defvar kmacro-view-item-no 0)
341 (defun kmacro-ring-head ()
342 "Return pseudo head element in macro ring."
343 (and last-kbd-macro
344 (list last-kbd-macro kmacro-counter kmacro-counter-format-start)))
347 (defun kmacro-push-ring (&optional elt)
348 "Push ELT or current macro onto `kmacro-ring'."
349 (when (setq elt (or elt (kmacro-ring-head)))
350 (let ((history-delete-duplicates nil))
351 (add-to-history 'kmacro-ring elt kmacro-ring-max))))
354 (defun kmacro-split-ring-element (elt)
355 (setq last-kbd-macro (car elt)
356 kmacro-counter (nth 1 elt)
357 kmacro-counter-format-start (nth 2 elt)))
360 (defun kmacro-pop-ring1 (&optional raw)
361 "Pop head element off macro ring (no check).
362 Non-nil arg RAW means just return raw first element."
363 (prog1 (car kmacro-ring)
364 (unless raw
365 (kmacro-split-ring-element (car kmacro-ring)))
366 (setq kmacro-ring (cdr kmacro-ring))))
369 (defun kmacro-pop-ring (&optional raw)
370 "Pop head element off macro ring.
371 Non-nil arg RAW means just return raw first element."
372 (unless (kmacro-ring-empty-p)
373 (kmacro-pop-ring1 raw)))
376 (defun kmacro-ring-empty-p (&optional none)
377 "Tell user and return t if `last-kbd-macro' is nil or `kmacro-ring' is empty.
378 Check only `last-kbd-macro' if optional arg NONE is non-nil."
379 (while (and (null last-kbd-macro) kmacro-ring)
380 (kmacro-pop-ring1))
381 (cond
382 ((null last-kbd-macro)
383 (message "No keyboard macro defined.")
385 ((and (null none) (null kmacro-ring))
386 (message "Only one keyboard macro defined.")
388 (t nil)))
391 (defun kmacro-display (macro &optional trunc descr empty)
392 "Display a keyboard MACRO.
393 Optional arg TRUNC non-nil specifies to limit width of macro to 60 chars.
394 Optional arg DESCR is descriptive text for macro; default is \"Macro:\".
395 Optional arg EMPTY is message to print if no macros are defined."
396 (if macro
397 (let* ((x 60)
398 (m (format-kbd-macro macro))
399 (l (length m))
400 (z (and trunc (> l x))))
401 (message "%s%s: %s%s" (or descr "Macro")
402 (if (= kmacro-counter 0) ""
403 (format " [%s]"
404 (format kmacro-counter-format-start kmacro-counter)))
405 (if z (substring m 0 (1- x)) m) (if z "..." "")))
406 (message "%s" (or empty "No keyboard macros defined"))))
409 (defun kmacro-repeat-on-last-key (keys)
410 "Process kmacro commands keys immediately after cycling the ring."
411 (setq keys (vconcat keys))
412 (let ((n (1- (length keys)))
413 cmd done repeat)
414 (while (and last-kbd-macro
415 (not done)
416 (aset keys n (read-event))
417 (setq cmd (key-binding keys t))
418 (setq repeat (get cmd 'kmacro-repeat)))
419 (clear-this-command-keys t)
420 (cond
421 ((eq repeat 'ring)
422 (if kmacro-ring
423 (let ((kmacro-repeat-no-prefix nil))
424 (funcall cmd nil))
425 (kmacro-display last-kbd-macro t)))
426 ((eq repeat 'head)
427 (let ((kmacro-repeat-no-prefix nil))
428 (funcall cmd nil)))
429 ((eq repeat 'stop)
430 (funcall cmd nil)
431 (setq done t)))
432 (setq last-input-event nil)))
433 (when last-input-event
434 (clear-this-command-keys t)
435 (setq unread-command-events (list last-input-event))))
438 (defun kmacro-get-repeat-prefix ()
439 (let (keys)
440 (and kmacro-repeat-no-prefix
441 (setq keys (this-single-command-keys))
442 (> (length keys) 1)
443 keys)))
446 ;;;###autoload
447 (defun kmacro-exec-ring-item (item arg)
448 "Execute item ITEM from the macro ring."
449 ;; Use counter and format specific to the macro on the ring!
450 (let ((kmacro-counter (nth 1 item))
451 (kmacro-counter-format-start (nth 2 item)))
452 (execute-kbd-macro (car item) arg #'kmacro-loop-setup-function)
453 (setcar (cdr item) kmacro-counter)))
456 (defun kmacro-call-ring-2nd (arg)
457 "Execute second keyboard macro in macro ring."
458 (interactive "P")
459 (unless (kmacro-ring-empty-p)
460 (kmacro-exec-ring-item (car kmacro-ring) arg)))
463 (defun kmacro-call-ring-2nd-repeat (arg)
464 "Execute second keyboard macro in macro ring.
465 This is like `kmacro-call-ring-2nd', but allows repeating macro commands
466 without repeating the prefix."
467 (interactive "P")
468 (let ((keys (kmacro-get-repeat-prefix)))
469 (kmacro-call-ring-2nd arg)
470 (if (and kmacro-ring keys)
471 (kmacro-repeat-on-last-key keys))))
473 (put 'kmacro-call-ring-2nd-repeat 'kmacro-repeat 'head)
476 (defun kmacro-view-ring-2nd ()
477 "Display the current head of the keyboard macro ring."
478 (interactive)
479 (unless (kmacro-ring-empty-p)
480 (kmacro-display (car (car kmacro-ring)) "2nd macro")))
483 (defun kmacro-cycle-ring-next (&optional _arg)
484 "Move to next keyboard macro in keyboard macro ring.
485 Displays the selected macro in the echo area."
486 (interactive)
487 (unless (kmacro-ring-empty-p)
488 (kmacro-push-ring)
489 (let* ((keys (kmacro-get-repeat-prefix))
490 (len (length kmacro-ring))
491 (tail (nthcdr (- len 2) kmacro-ring))
492 (elt (car (cdr tail))))
493 (setcdr tail nil)
494 (kmacro-split-ring-element elt)
495 (kmacro-display last-kbd-macro t)
496 (if keys
497 (kmacro-repeat-on-last-key keys)))))
499 (put 'kmacro-cycle-ring-next 'kmacro-repeat 'ring)
502 (defun kmacro-cycle-ring-previous (&optional _arg)
503 "Move to previous keyboard macro in keyboard macro ring.
504 Displays the selected macro in the echo area."
505 (interactive)
506 (unless (kmacro-ring-empty-p)
507 (let ((keys (kmacro-get-repeat-prefix))
508 (cur (kmacro-ring-head)))
509 (kmacro-pop-ring1)
510 (if kmacro-ring
511 (nconc kmacro-ring (list cur))
512 (setq kmacro-ring (list cur)))
513 (kmacro-display last-kbd-macro t)
514 (if keys
515 (kmacro-repeat-on-last-key keys)))))
517 (put 'kmacro-cycle-ring-previous 'kmacro-repeat 'ring)
520 (defun kmacro-swap-ring ()
521 "Swap first two elements on keyboard macro ring."
522 (interactive)
523 (unless (kmacro-ring-empty-p)
524 (let ((cur (kmacro-ring-head)))
525 (kmacro-pop-ring1)
526 (kmacro-push-ring cur))
527 (kmacro-display last-kbd-macro t)))
530 (defun kmacro-delete-ring-head (&optional _arg)
531 "Delete current macro from keyboard macro ring."
532 (interactive)
533 (unless (kmacro-ring-empty-p t)
534 (if (null kmacro-ring)
535 (setq last-kbd-macro nil)
536 (kmacro-pop-ring))
537 (kmacro-display last-kbd-macro t nil "Keyboard macro ring is now empty.")))
539 (put 'kmacro-delete-ring-head 'kmacro-repeat 'head)
541 ;;; Traditional bindings:
544 ;;;###autoload
545 (defun kmacro-start-macro (arg)
546 "Record subsequent keyboard input, defining a keyboard macro.
547 The commands are recorded even as they are executed.
548 Use \\[kmacro-end-macro] to finish recording and make the macro available.
549 Use \\[kmacro-end-and-call-macro] to execute the macro.
551 Non-nil arg (prefix arg) means append to last macro defined.
553 With \\[universal-argument] prefix, append to last keyboard macro
554 defined. Depending on `kmacro-execute-before-append', this may begin
555 by re-executing the last macro as if you typed it again.
557 Otherwise, it sets `kmacro-counter' to ARG or 0 if missing before
558 defining the macro.
560 Use \\[kmacro-insert-counter] to insert (and increment) the macro counter.
561 The counter value can be set or modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
562 The format of the counter can be modified via \\[kmacro-set-format].
564 Use \\[kmacro-name-last-macro] to give it a permanent name.
565 Use \\[kmacro-bind-to-key] to bind it to a key sequence."
566 (interactive "P")
567 (if (or defining-kbd-macro executing-kbd-macro)
568 (message "Already defining keyboard macro.")
569 (let ((append (and arg (listp arg))))
570 (unless append
571 (if last-kbd-macro
572 (kmacro-push-ring
573 (list last-kbd-macro kmacro-counter kmacro-counter-format-start)))
574 (setq kmacro-counter (or (if arg (prefix-numeric-value arg))
575 kmacro-initial-counter-value
577 kmacro-initial-counter-value nil
578 kmacro-counter-value-start kmacro-counter
579 kmacro-last-counter kmacro-counter
580 kmacro-counter-format kmacro-default-counter-format
581 kmacro-counter-format-start kmacro-default-counter-format))
583 (start-kbd-macro append
584 (and append
585 (if kmacro-execute-before-append
586 (> (car arg) 4)
587 (= (car arg) 4))))
588 (if (and defining-kbd-macro append)
589 (setq defining-kbd-macro 'append)))))
592 ;;;###autoload
593 (defun kmacro-end-macro (arg)
594 "Finish defining a keyboard macro.
595 The definition was started by \\[kmacro-start-macro].
596 The macro is now available for use via \\[kmacro-call-macro],
597 or it can be given a name with \\[kmacro-name-last-macro] and then invoked
598 under that name.
600 With numeric arg, repeat macro now that many times,
601 counting the definition just completed as the first repetition.
602 An argument of zero means repeat until error."
603 (interactive "P")
604 ;; Isearch may push the kmacro-end-macro key sequence onto the macro.
605 ;; Just ignore it when executing the macro.
606 (unless executing-kbd-macro
607 (end-kbd-macro arg #'kmacro-loop-setup-function)
608 (when (and last-kbd-macro (= (length last-kbd-macro) 0))
609 (setq last-kbd-macro nil)
610 (message "Ignore empty macro")
611 ;; Don't call `kmacro-ring-empty-p' to avoid its messages.
612 (while (and (null last-kbd-macro) kmacro-ring)
613 (kmacro-pop-ring1)))))
616 ;;;###autoload
617 (defun kmacro-call-macro (arg &optional no-repeat end-macro macro)
618 "Call the keyboard MACRO that you defined with \\[kmacro-start-macro].
619 A prefix argument serves as a repeat count. Zero means repeat until error.
620 MACRO defaults to `last-kbd-macro'.
622 When you call the macro, you can call the macro again by repeating
623 just the last key in the key sequence that you used to call this
624 command. See `kmacro-call-repeat-key' and `kmacro-call-repeat-with-arg'
625 for details on how to adjust or disable this behavior.
627 To make a macro permanent so you can call it even after defining
628 others, use \\[kmacro-name-last-macro]."
629 (interactive "p")
630 (let ((repeat-key (and (or (and (null no-repeat)
631 (> (length (this-single-command-keys)) 1))
632 ;; Used when we're in the process of repeating.
633 (eq no-repeat 'repeating))
634 last-input-event)))
635 (if end-macro
636 (kmacro-end-macro arg) ; modifies last-kbd-macro
637 (let ((last-kbd-macro (or macro last-kbd-macro)))
638 (call-last-kbd-macro arg #'kmacro-loop-setup-function)))
639 (when (consp arg)
640 (setq arg (car arg)))
641 (when (and (or (null arg) (> arg 0))
642 (setq repeat-key
643 (if (eq kmacro-call-repeat-key t)
644 repeat-key
645 kmacro-call-repeat-key)))
646 ;; Issue a hint to the user, if the echo area isn't in use.
647 (unless (current-message)
648 (message "(Type %s to repeat macro%s)"
649 (format-kbd-macro (vector repeat-key) nil)
650 (if (and kmacro-call-repeat-with-arg
651 arg (> arg 1))
652 (format " %d times" arg) "")))
653 ;; Can't use the `keep-pred' arg because this overlay keymap needs to be
654 ;; removed during the next run of the kmacro (i.e. we need to add&remove
655 ;; this overlay-map at each repetition).
656 (set-temporary-overlay-map
657 (let ((map (make-sparse-keymap)))
658 (define-key map (vector repeat-key)
659 `(lambda () (interactive)
660 (kmacro-call-macro ,(and kmacro-call-repeat-with-arg arg)
661 'repeating nil ,(if end-macro
662 last-kbd-macro
663 (or macro last-kbd-macro)))))
664 map)))))
667 ;;; Combined function key bindings:
669 ;;;###autoload
670 (defun kmacro-start-macro-or-insert-counter (arg)
671 "Record subsequent keyboard input, defining a keyboard macro.
672 The commands are recorded even as they are executed.
674 Sets the `kmacro-counter' to ARG (or 0 if no prefix arg) before defining the
675 macro.
677 With \\[universal-argument], appends to current keyboard macro (keeping
678 the current value of `kmacro-counter').
680 When defining/executing macro, inserts macro counter and increments
681 the counter with ARG or 1 if missing. With \\[universal-argument],
682 inserts previous `kmacro-counter' (but do not modify counter).
684 The macro counter can be modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
685 The format of the counter can be modified via \\[kmacro-set-format]."
686 (interactive "P")
687 (if (or defining-kbd-macro executing-kbd-macro)
688 (kmacro-insert-counter arg)
689 (kmacro-start-macro arg)))
692 ;;;###autoload
693 (defun kmacro-end-or-call-macro (arg &optional no-repeat)
694 "End kbd macro if currently being defined; else call last kbd macro.
695 With numeric prefix ARG, repeat macro that many times.
696 With \\[universal-argument], call second macro in macro ring."
697 (interactive "P")
698 (cond
699 (defining-kbd-macro
700 (if kmacro-call-repeat-key
701 (kmacro-call-macro arg no-repeat t)
702 (kmacro-end-macro arg)))
703 ((and (eq this-command 'kmacro-view-macro) ;; We are in repeat mode!
704 kmacro-view-last-item)
705 (kmacro-exec-ring-item (car kmacro-view-last-item) arg))
706 ((and arg (listp arg))
707 (kmacro-call-ring-2nd 1))
709 (kmacro-call-macro arg no-repeat))))
712 (defun kmacro-end-or-call-macro-repeat (arg)
713 "As `kmacro-end-or-call-macro' but allows repeat without repeating prefix."
714 (interactive "P")
715 (let ((keys (kmacro-get-repeat-prefix)))
716 (kmacro-end-or-call-macro arg t)
717 (if keys
718 (kmacro-repeat-on-last-key keys))))
720 (put 'kmacro-end-or-call-macro-repeat 'kmacro-repeat 'head)
723 ;;;###autoload
724 (defun kmacro-end-and-call-macro (arg &optional no-repeat)
725 "Call last keyboard macro, ending it first if currently being defined.
726 With numeric prefix ARG, repeat macro that many times.
727 Zero argument means repeat until there is an error.
729 To give a macro a permanent name, so you can call it
730 even after defining other macros, use \\[kmacro-name-last-macro]."
731 (interactive "P")
732 (if defining-kbd-macro
733 (kmacro-end-macro nil))
734 (kmacro-call-macro arg no-repeat))
737 ;;;###autoload
738 (defun kmacro-end-call-mouse (event)
739 "Move point to the position clicked with the mouse and call last kbd macro.
740 If kbd macro currently being defined end it before activating it."
741 (interactive "e")
742 (when defining-kbd-macro
743 (end-kbd-macro))
744 (mouse-set-point event)
745 (kmacro-call-macro nil t))
748 ;;; Misc. commands
750 ;; An idea for macro bindings:
751 ;; Create a separate keymap installed as a minor-mode keymap (e.g. in
752 ;; the emulation-mode-map-alists) in which macro bindings are made
753 ;; independent of any other bindings. When first binding is made,
754 ;; the keymap is created, installed, and enabled. Key seq. C-x C-k +
755 ;; can then be used to toggle the use of this keymap on and off.
756 ;; This means that it would be safe(r) to bind ordinary keys like
757 ;; letters and digits, provided that we inhibit the keymap while
758 ;; executing the macro later on (but that's controversial...)
760 (defun kmacro-lambda-form (mac &optional counter format)
761 "Create lambda form for macro bound to symbol or key."
762 (if counter
763 (setq mac (list mac counter format)))
764 `(lambda (&optional arg)
765 "Keyboard macro."
766 (interactive "p")
767 (kmacro-exec-ring-item ',mac arg)))
769 (defun kmacro-extract-lambda (mac)
770 "Extract kmacro from a kmacro lambda form."
771 (and (consp mac)
772 (eq (car mac) 'lambda)
773 (setq mac (assoc 'kmacro-exec-ring-item mac))
774 (consp (cdr mac))
775 (consp (car (cdr mac)))
776 (consp (cdr (car (cdr mac))))
777 (setq mac (car (cdr (car (cdr mac)))))
778 (listp mac)
779 (= (length mac) 3)
780 (arrayp (car mac))
781 mac))
784 (defun kmacro-bind-to-key (_arg)
785 "When not defining or executing a macro, offer to bind last macro to a key.
786 The key sequences [C-x C-k 0] through [C-x C-k 9] and [C-x C-k A]
787 through [C-x C-k Z] are reserved for user bindings, and to bind to
788 one of these sequences, just enter the digit or letter, rather than
789 the whole sequence.
791 You can bind to any valid key sequence, but if you try to bind to
792 a key with an existing command binding, you will be asked for
793 confirmation whether to replace that binding. Note that the
794 binding is made in the `global-map' keymap, so the macro binding
795 may be shaded by a local key binding."
796 (interactive "p")
797 (if (or defining-kbd-macro executing-kbd-macro)
798 (if defining-kbd-macro
799 (message "Cannot save macro while defining it."))
800 (unless last-kbd-macro
801 (error "No keyboard macro defined"))
802 (let ((key-seq (read-key-sequence "Bind last macro to key: "))
803 ok cmd)
804 (when (= (length key-seq) 1)
805 (let ((ch (aref key-seq 0)))
806 (if (and (integerp ch)
807 (or (and (>= ch ?0) (<= ch ?9))
808 (and (>= ch ?A) (<= ch ?Z))))
809 (setq key-seq (concat "\C-x\C-k" key-seq)
810 ok t))))
811 (when (and (not (equal key-seq "\a"))
812 (or ok
813 (not (setq cmd (key-binding key-seq)))
814 (stringp cmd)
815 (vectorp cmd)
816 (yes-or-no-p (format "%s runs command %S. Bind anyway? "
817 (format-kbd-macro key-seq)
818 cmd))))
819 (define-key global-map key-seq
820 (kmacro-lambda-form (kmacro-ring-head)))
821 (message "Keyboard macro bound to %s" (format-kbd-macro key-seq))))))
824 (defun kmacro-name-last-macro (symbol)
825 "Assign a name to the last keyboard macro defined.
826 Argument SYMBOL is the name to define.
827 The symbol's function definition becomes the keyboard macro string.
828 Such a \"function\" cannot be called from Lisp, but it is a valid editor command."
829 (interactive "SName for last kbd macro: ")
830 (or last-kbd-macro
831 (error "No keyboard macro defined"))
832 (and (fboundp symbol)
833 (not (get symbol 'kmacro))
834 (not (stringp (symbol-function symbol)))
835 (not (vectorp (symbol-function symbol)))
836 (error "Function %s is already defined and not a keyboard macro"
837 symbol))
838 (if (string-equal symbol "")
839 (error "No command name given"))
840 (fset symbol (kmacro-lambda-form (kmacro-ring-head)))
841 (put symbol 'kmacro t))
844 (defun kmacro-execute-from-register (k)
845 (kmacro-call-macro current-prefix-arg nil nil k))
847 (defun kmacro-to-register (r)
848 "Store the last keyboard macro in register R."
849 (interactive
850 (progn
851 (or last-kbd-macro (error "No keyboard macro defined"))
852 (list (read-char "Save to register: "))))
853 (set-register r (registerv-make
854 last-kbd-macro
855 :jump-func 'kmacro-execute-from-register
856 :print-func (lambda (k)
857 (princ (format "a keyboard macro:\n %s"
858 (format-kbd-macro k))))
859 :insert-func (lambda (k)
860 (insert (format-kbd-macro k))))))
863 (defun kmacro-view-macro (&optional _arg)
864 "Display the last keyboard macro.
865 If repeated, it shows previous elements in the macro ring."
866 (interactive)
867 (cond
868 ((or (kmacro-ring-empty-p)
869 (not (eq last-command 'kmacro-view-macro)))
870 (setq kmacro-view-last-item nil))
871 ((null kmacro-view-last-item)
872 (setq kmacro-view-last-item kmacro-ring
873 kmacro-view-item-no 2))
874 ((consp kmacro-view-last-item)
875 (setq kmacro-view-last-item (cdr kmacro-view-last-item)
876 kmacro-view-item-no (1+ kmacro-view-item-no)))
878 (setq kmacro-view-last-item nil)))
879 (setq this-command 'kmacro-view-macro
880 last-command this-command) ;; in case we repeat
881 (kmacro-display (if kmacro-view-last-item
882 (car (car kmacro-view-last-item))
883 last-kbd-macro)
885 (if kmacro-view-last-item
886 (concat (cond ((= kmacro-view-item-no 2) "2nd")
887 ((= kmacro-view-item-no 3) "3nd")
888 (t (format "%dth" kmacro-view-item-no)))
889 " previous macro")
890 "Last macro")))
892 (defun kmacro-view-macro-repeat (&optional arg)
893 "Display the last keyboard macro.
894 If repeated, it shows previous elements in the macro ring.
895 To execute the displayed macro ring item without changing the macro ring,
896 just enter C-k.
897 This is like `kmacro-view-macro', but allows repeating macro commands
898 without repeating the prefix."
899 (interactive)
900 (let ((keys (kmacro-get-repeat-prefix)))
901 (kmacro-view-macro arg)
902 (if (and last-kbd-macro keys)
903 (kmacro-repeat-on-last-key keys))))
905 (put 'kmacro-view-macro-repeat 'kmacro-repeat 'ring)
908 (defun kmacro-edit-macro-repeat (&optional arg)
909 "Edit last keyboard macro."
910 (interactive "P")
911 (edit-kbd-macro "\r" arg))
913 (put 'kmacro-edit-macro-repeat 'kmacro-repeat 'stop)
916 (defun kmacro-edit-macro (&optional arg)
917 "As edit last keyboard macro, but without kmacro-repeat property."
918 (interactive "P")
919 (edit-kbd-macro "\r" arg))
922 (defun kmacro-edit-lossage ()
923 "Edit most recent 300 keystrokes as a keyboard macro."
924 (interactive)
925 (kmacro-push-ring)
926 (edit-kbd-macro "\C-hl"))
929 ;;; Single-step editing of keyboard macros
931 (defvar kmacro-step-edit-active) ;; step-editing active
932 (defvar kmacro-step-edit-new-macro) ;; storage for new macro
933 (defvar kmacro-step-edit-inserting) ;; inserting into macro
934 (defvar kmacro-step-edit-appending) ;; append to end of macro
935 (defvar kmacro-step-edit-replace) ;; replace orig macro when done
936 (defvar kmacro-step-edit-prefix-index) ;; index of first prefix arg key
937 (defvar kmacro-step-edit-key-index) ;; index of current key
938 (defvar kmacro-step-edit-action) ;; automatic action on next pre-command hook
939 (defvar kmacro-step-edit-help) ;; kmacro step edit help enabled
940 (defvar kmacro-step-edit-num-input-keys) ;; to ignore duplicate pre-command hook
942 (defvar kmacro-step-edit-map
943 (let ((map (make-sparse-keymap)))
944 ;; query-replace-map answers include: `act', `skip', `act-and-show',
945 ;; `exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
946 ;; `automatic', `backup', `exit-prefix', and `help'.")
947 ;; Also: `quit', `edit-replacement'
949 (set-keymap-parent map query-replace-map)
951 (define-key map "\t" 'act-repeat)
952 (define-key map [tab] 'act-repeat)
953 (define-key map "\C-k" 'skip-rest)
954 (define-key map "c" 'automatic)
955 (define-key map "f" 'skip-keep)
956 (define-key map "q" 'quit)
957 (define-key map "d" 'skip)
958 (define-key map "\C-d" 'skip)
959 (define-key map "i" 'insert)
960 (define-key map "I" 'insert-1)
961 (define-key map "r" 'replace)
962 (define-key map "R" 'replace-1)
963 (define-key map "a" 'append)
964 (define-key map "A" 'append-end)
965 map)
966 "Keymap that defines the responses to questions in `kmacro-step-edit-macro'.
967 This keymap is an extension to the `query-replace-map', allowing the
968 following additional answers: `insert', `insert-1', `replace', `replace-1',
969 `append', `append-end', `act-repeat', `skip-end', `skip-keep'.")
971 (defvar kmacro-step-edit-prefix-commands
972 '(universal-argument universal-argument-more universal-argument-minus
973 digit-argument negative-argument)
974 "Commands which build up a prefix arg for the current command.")
976 (defun kmacro-step-edit-prompt (macro index)
977 ;; Show step-edit prompt
978 (let ((keys (and (not kmacro-step-edit-appending)
979 index (substring macro index executing-kbd-macro-index)))
980 (future (and (not kmacro-step-edit-appending)
981 (substring macro executing-kbd-macro-index)))
982 (message-log-max nil)
983 (curmsg (current-message)))
985 ;; TODO: Scroll macro if max-mini-window-height is too small.
986 (message "%s"
987 (concat
988 (format "Macro: %s%s%s%s%s\n"
989 (format-kbd-macro kmacro-step-edit-new-macro 1)
990 (if (and kmacro-step-edit-new-macro (> (length kmacro-step-edit-new-macro) 0)) " " "")
991 (propertize (if keys (format-kbd-macro keys)
992 (if kmacro-step-edit-appending "<APPEND>" "<INSERT>")) 'face 'region)
993 (if future " " "")
994 (if future (format-kbd-macro future) ""))
995 (cond
996 ((minibufferp)
997 (format "%s\n%s\n"
998 (propertize "\
999 minibuffer " 'face 'header-line)
1000 (buffer-substring (point-min) (point-max))))
1001 (curmsg
1002 (format "%s\n%s\n"
1003 (propertize "\
1004 echo area " 'face 'header-line)
1005 curmsg))
1006 (t ""))
1007 (if keys
1008 (format "%s\n%s%s %S [yn iIaArR C-k kq!] "
1009 (propertize "\
1010 --------------Step Edit Keyboard Macro [?: help]---------------" 'face 'mode-line)
1011 (if kmacro-step-edit-help "\
1012 Step: y/SPC: execute next, d/n/DEL: skip next, f: skip but keep
1013 TAB: execute while same, ?: toggle help
1014 Edit: i: insert, r: replace, a: append, A: append at end,
1015 I/R: insert/replace with one sequence,
1016 End: !/c: execute rest, C-k: skip rest and save, q/C-g: quit
1017 ----------------------------------------------------------------
1018 " "")
1019 (propertize "Next command:" 'face 'bold)
1020 this-command)
1021 (propertize
1022 (format "Type key sequence%s to insert and execute%s: "
1023 (if (numberp kmacro-step-edit-inserting) "" "s")
1024 (if (numberp kmacro-step-edit-inserting) "" " (end with C-j)"))
1025 'face 'bold))))))
1027 (defun kmacro-step-edit-query ()
1028 ;; Pre-command hook function for step-edit in "command" mode
1029 (let ((resize-mini-windows t)
1030 (max-mini-window-height kmacro-step-edit-mini-window-height)
1031 act restore-index next-index)
1033 ;; Handle commands which reads additional input using read-char.
1034 (cond
1035 ((and (eq this-command 'quoted-insert)
1036 (not (eq kmacro-step-edit-action t)))
1037 ;; Find the actual end of this key sequence.
1038 ;; Must be able to backtrack in case we actually execute it.
1039 (setq restore-index executing-kbd-macro-index)
1040 (let (unread-command-events)
1041 (quoted-insert 0)
1042 (when unread-command-events
1043 (setq executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events))
1044 next-index executing-kbd-macro-index)))))
1046 ;; Query the user; stop macro execution temporarily.
1047 (let ((macro executing-kbd-macro)
1048 (executing-kbd-macro nil)
1049 (defining-kbd-macro nil))
1051 ;; Any action requested by previous command
1052 (cond
1053 ((eq kmacro-step-edit-action t) ;; Reentry for actual command @ end of prefix arg.
1054 (cond
1055 ((eq this-command 'quoted-insert)
1056 (clear-this-command-keys) ;; recent-keys actually
1057 (let (unread-command-events)
1058 (quoted-insert (prefix-numeric-value current-prefix-arg))
1059 (setq kmacro-step-edit-new-macro
1060 (vconcat kmacro-step-edit-new-macro (recent-keys)))
1061 (when unread-command-events
1062 (setq kmacro-step-edit-new-macro
1063 (substring kmacro-step-edit-new-macro 0 (- (length unread-command-events)))
1064 executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events)))))
1065 (setq current-prefix-arg nil
1066 prefix-arg nil)
1067 (setq act 'ignore))
1069 (setq act 'act)))
1070 (setq kmacro-step-edit-action nil))
1071 ((eq this-command kmacro-step-edit-action) ;; TAB -> activate while same command
1072 (setq act 'act))
1074 (setq kmacro-step-edit-action nil)))
1076 ;; Handle prefix arg, or query user
1077 (cond
1078 (act act) ;; set above
1079 ((memq this-command kmacro-step-edit-prefix-commands)
1080 (unless kmacro-step-edit-prefix-index
1081 (setq kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1082 (setq act 'universal-argument))
1083 ((eq this-command 'universal-argument-other-key)
1084 (setq act 'universal-argument))
1086 (kmacro-step-edit-prompt macro (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1087 (setq act (lookup-key kmacro-step-edit-map
1088 (vector (with-current-buffer (current-buffer) (read-event))))))))
1090 ;; Resume macro execution and perform the action
1091 (cond
1092 ((eq act 'universal-argument)
1093 nil)
1094 ((cond
1095 ((eq act 'act)
1097 ((eq act 'act-repeat)
1098 (setq kmacro-step-edit-action this-command)
1100 ((eq act 'quit)
1101 (setq kmacro-step-edit-replace nil)
1102 (setq kmacro-step-edit-active 'ignore)
1103 nil)
1104 ((eq act 'skip)
1105 (setq kmacro-step-edit-prefix-index nil)
1106 nil)
1107 ((eq act 'skip-keep)
1108 (setq this-command 'ignore)
1110 ((eq act 'skip-rest)
1111 (setq kmacro-step-edit-active 'ignore)
1112 nil)
1113 ((memq act '(automatic exit))
1114 (setq kmacro-step-edit-active nil)
1115 (setq act t)
1117 ((member act '(insert-1 insert))
1118 (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1119 (setq kmacro-step-edit-inserting (if (eq act 'insert-1) 1 t))
1120 nil)
1121 ((member act '(replace-1 replace))
1122 (setq kmacro-step-edit-inserting (if (eq act 'replace-1) 1 t))
1123 (setq kmacro-step-edit-prefix-index nil)
1124 (if (= executing-kbd-macro-index (length executing-kbd-macro))
1125 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1126 kmacro-step-edit-appending t))
1127 nil)
1128 ((eq act 'append)
1129 (setq kmacro-step-edit-inserting t)
1130 (if (= executing-kbd-macro-index (length executing-kbd-macro))
1131 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1132 kmacro-step-edit-appending t))
1134 ((eq act 'append-end)
1135 (if (= executing-kbd-macro-index (length executing-kbd-macro))
1136 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1137 kmacro-step-edit-inserting t
1138 kmacro-step-edit-appending t)
1139 (setq kmacro-step-edit-active 'append-end))
1140 (setq act t)
1142 ((eq act 'help)
1143 (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1144 (setq kmacro-step-edit-help (not kmacro-step-edit-help))
1145 nil)
1146 (t ;; Ignore unknown responses
1147 (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1148 nil))
1149 (if (> executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1150 (setq kmacro-step-edit-new-macro
1151 (vconcat kmacro-step-edit-new-macro
1152 (substring executing-kbd-macro
1153 (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1154 (if (eq act t) nil executing-kbd-macro-index)))
1155 kmacro-step-edit-prefix-index nil))
1156 (if restore-index
1157 (setq executing-kbd-macro-index restore-index)))
1159 (setq this-command 'ignore)))
1160 (setq kmacro-step-edit-key-index next-index)))
1162 (defun kmacro-step-edit-insert ()
1163 ;; Pre-command hook function for step-edit in "insert" mode
1164 (let ((resize-mini-windows t)
1165 (max-mini-window-height kmacro-step-edit-mini-window-height)
1166 (macro executing-kbd-macro)
1167 (executing-kbd-macro nil)
1168 (defining-kbd-macro nil)
1169 cmd keys next-index)
1170 (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1171 kmacro-step-edit-prefix-index nil)
1172 (kmacro-step-edit-prompt macro nil)
1173 ;; Now, we have read a key sequence from the macro, but we don't want
1174 ;; to execute it yet. So push it back and read another sequence.
1175 (reset-this-command-lengths)
1176 (setq keys (read-key-sequence nil nil nil nil t))
1177 (setq cmd (key-binding keys t nil))
1178 (if (cond
1179 ((null cmd)
1181 ((eq cmd 'quoted-insert)
1182 (clear-this-command-keys) ;; recent-keys actually
1183 (quoted-insert (prefix-numeric-value current-prefix-arg))
1184 (setq current-prefix-arg nil
1185 prefix-arg nil)
1186 (setq keys (vconcat keys (recent-keys)))
1187 (when (numberp kmacro-step-edit-inserting)
1188 (setq kmacro-step-edit-inserting nil)
1189 (when unread-command-events
1190 (setq keys (substring keys 0 (- (length unread-command-events)))
1191 executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events))
1192 next-index executing-kbd-macro-index
1193 unread-command-events nil)))
1194 (setq cmd 'ignore)
1195 nil)
1196 ((memq cmd kmacro-step-edit-prefix-commands)
1197 (setq universal-argument-num-events 0)
1198 (reset-this-command-lengths)
1199 nil)
1200 ((eq cmd 'universal-argument-other-key)
1201 (setq kmacro-step-edit-action t)
1202 (setq universal-argument-num-events 0)
1203 (reset-this-command-lengths)
1204 (if (numberp kmacro-step-edit-inserting)
1205 (setq kmacro-step-edit-inserting nil))
1206 nil)
1207 ((numberp kmacro-step-edit-inserting)
1208 (setq kmacro-step-edit-inserting nil)
1209 nil)
1210 ((equal keys "\C-j")
1211 (setq kmacro-step-edit-inserting nil)
1212 (setq kmacro-step-edit-action nil)
1213 ;; Forget any (partial) prefix arg from next command
1214 (setq kmacro-step-edit-prefix-index nil)
1215 (reset-this-command-lengths)
1216 (setq overriding-terminal-local-map nil)
1217 (setq universal-argument-num-events nil)
1218 (setq next-index kmacro-step-edit-key-index)
1220 (t nil))
1221 (setq this-command 'ignore)
1222 (setq this-command cmd)
1223 (if (memq this-command '(self-insert-command digit-argument))
1224 (setq last-command-event (aref keys (1- (length keys)))))
1225 (if keys
1226 (setq kmacro-step-edit-new-macro (vconcat kmacro-step-edit-new-macro keys))))
1227 (setq kmacro-step-edit-key-index next-index)))
1229 (defun kmacro-step-edit-pre-command ()
1230 (remove-hook 'post-command-hook 'kmacro-step-edit-post-command)
1231 (when kmacro-step-edit-active
1232 (cond
1233 ((eq kmacro-step-edit-active 'ignore)
1234 (setq this-command 'ignore))
1235 ((eq kmacro-step-edit-active 'append-end)
1236 (if (= executing-kbd-macro-index (length executing-kbd-macro))
1237 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1238 kmacro-step-edit-inserting t
1239 kmacro-step-edit-appending t
1240 kmacro-step-edit-active t)))
1241 ((/= kmacro-step-edit-num-input-keys num-input-keys)
1242 (if kmacro-step-edit-inserting
1243 (kmacro-step-edit-insert)
1244 (kmacro-step-edit-query))
1245 (setq kmacro-step-edit-num-input-keys num-input-keys)
1246 (if (and kmacro-step-edit-appending (not kmacro-step-edit-inserting))
1247 (setq kmacro-step-edit-appending nil
1248 kmacro-step-edit-active 'ignore)))))
1249 (when (eq kmacro-step-edit-active t)
1250 (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)))
1252 (defun kmacro-step-edit-minibuf-setup ()
1253 (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command t)
1254 (when kmacro-step-edit-active
1255 (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil t)))
1257 (defun kmacro-step-edit-post-command ()
1258 (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command)
1259 (when kmacro-step-edit-active
1260 (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil nil)
1261 (if kmacro-step-edit-key-index
1262 (setq executing-kbd-macro-index kmacro-step-edit-key-index)
1263 (setq kmacro-step-edit-key-index executing-kbd-macro-index))))
1266 (defun kmacro-step-edit-macro ()
1267 "Step edit and execute last keyboard macro.
1269 To customize possible responses, change the \"bindings\" in `kmacro-step-edit-map'."
1270 (interactive)
1271 (let ((kmacro-step-edit-active t)
1272 (kmacro-step-edit-new-macro "")
1273 (kmacro-step-edit-inserting nil)
1274 (kmacro-step-edit-appending nil)
1275 (kmacro-step-edit-replace t)
1276 (kmacro-step-edit-prefix-index nil)
1277 (kmacro-step-edit-key-index 0)
1278 (kmacro-step-edit-action nil)
1279 (kmacro-step-edit-help nil)
1280 (kmacro-step-edit-num-input-keys num-input-keys)
1281 (pre-command-hook pre-command-hook)
1282 (post-command-hook post-command-hook)
1283 (minibuffer-setup-hook minibuffer-setup-hook))
1284 (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil)
1285 (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)
1286 (add-hook 'minibuffer-setup-hook 'kmacro-step-edit-minibuf-setup t)
1287 (call-last-kbd-macro nil nil)
1288 (when (and kmacro-step-edit-replace
1289 kmacro-step-edit-new-macro
1290 (not (equal last-kbd-macro kmacro-step-edit-new-macro)))
1291 (kmacro-push-ring)
1292 (setq last-kbd-macro kmacro-step-edit-new-macro))))
1294 (provide 'kmacro)
1296 ;;; kmacro.el ends here