1 ;;; kmacro.el --- enhanced keyboard macros
3 ;; Copyright (C) 2002 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 2, or (at your option)
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; see the file COPYING. If not, write to the
22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 ;; Boston, MA 02111-1307, USA.
27 ;; The kmacro package is an alternative user interface to emacs'
28 ;; keyboard macro functionality. This functionality is normally bound
29 ;; to C-x (, C-x ), and C-x e, but these bindings are too hard to
30 ;; type to be really useful for doing small repeated tasks.
32 ;; With kmacro, two function keys are dedicated to keyboard macros,
33 ;; by default F3 and F4. Personally, I prefer F1 and F2, but those
34 ;; keys already have default bindings.
36 ;; To start defining a keyboard macro, use F3. To end the macro,
37 ;; use F4, and to call the macro also use F4. This makes it very
38 ;; easy to repeat a macro immediately after defining it.
40 ;; You can call the macro repeatedly by pressing F4 multiple times, or
41 ;; you can give a numeric prefix argument specifying the number of
42 ;; times to repeat the macro. Macro execution automatically
43 ;; terminates when point reaches the end of the buffer or if an error
44 ;; is signalled by ringing the bell.
46 ;; When you define a macro with F3/F4, it is automatically added to
47 ;; the head of the "keyboard macro ring", and F4 actually executes the
48 ;; first element of the macro ring.
50 ;; Note: an empty macro is never added to the macro ring.
52 ;; You can execute the second element on the macro ring with C-u F4 or
53 ;; C-x C-k C-l, you can use C-x C-k C-p and C-x C-k C-n to cycle
54 ;; through the macro ring, and you can swap the first and second
55 ;; elements with C-x C-k C-t. To delete the first element in the
56 ;; macro ring, use C-x C-k C-d.
59 ;; You can also use C-x C-k C-s to start a macro, and C-x C-k C-k to
60 ;; end it; then use C-k to execute it immediately, or C-x C-k C-k to
63 ;; In general, immediately after using C-x C-k followed by one of C-k,
64 ;; C-l, C-p, or C-n, you can further cycle the macro ring using C-p or
65 ;; C-n, execute the first or second macro using C-k or C-l, delete
66 ;; the head macro with C-d, or edit the current macro with C-e without
67 ;; repeating the C-x C-k prefix.
69 ;; If you enter F3 while defining the macro, the numeric value of
70 ;; `kmacro-counter' is inserted using the `kmacro-counter-format', and
71 ;; `kmacro-counter' is incremented by 1 (or the numeric prefix value
74 ;; The initial value of `kmacro-counter' is 0, or the numeric prefix
75 ;; value given to F3 when starting the macro.
77 ;; Now, each time you call the macro using F4, the current
78 ;; value of `kmacro-counter' is inserted and incremented, making it
79 ;; easy to insert incremental numbers in the buffer.
83 ;; The following sequence: M-5 F3 x M-2 F3 y F4 F4 F4 F4
84 ;; inserts the following string: x5yx7yx9yx11y
86 ;; A macro can also be called using a mouse click, default S-mouse-3.
87 ;; This calls the macro at the point where you click the mouse.
89 ;; You can edit the last macro using C-x C-k C-e.
91 ;; You can append to the last macro using C-u F3.
93 ;; You can set the macro counter using C-x C-k C-c, add to it using C-x C-k C-a,
94 ;; and you can set the macro counter format with C-x C-k C-f.
96 ;; The following key bindings are performed:
98 ;; Normal While defining macro
99 ;; --------------------------- ------------------------------
100 ;; f3 Define macro Insert current counter value
101 ;; Prefix arg specifies initial and increase counter by prefix
102 ;; counter value (default 0) (default increment: 1)
104 ;; C-u f3 APPENDs to last macro
106 ;; f4 Call last macro End macro
107 ;; Prefix arg specifies number
108 ;; of times to execute macro.
110 ;; C-u f4 Swap last and head of macro ring.
112 ;; S-mouse-3 Set point at click and End macro and execute macro at
113 ;; execute last macro. click.
120 "Simplified keyboard macro user interface."
123 :link
'(emacs-commentary-link :tag
"Commentary" "kmacro.el")
124 :link
'(emacs-library-link :tag
"Lisp File" "kmacro.el"))
126 (defcustom kmacro-call-mouse-event
'S-mouse-3
127 "The mouse event used by kmacro to call a macro.
128 Set to nil if no mouse binding is desired."
132 (defcustom kmacro-ring-max
8
133 "Maximum number of keyboard macros to save in macro ring."
138 (defcustom kmacro-execute-before-append t
139 "Controls whether appending to a macro starts by executing the macro.
140 If non-nil, using a single \\[universal-argument] prefix executes the macro
141 before appending, while more than one \\[universal-argument] prefix does not
143 Otherwise, a single \\[universal-argument] prefix does not execute the
144 macro, while more than one \\[universal-argument] prefix causes the
145 macro to be executed before appending to it."
150 (defcustom kmacro-repeat-no-prefix t
151 "Allow repeating certain macro commands without entering the C-x C-k prefix."
155 (defcustom kmacro-call-repeat-key t
156 "Allow repeating macro call using last key or a specific key."
157 :type
'(choice (const :tag
"Disabled" nil
)
158 (const :tag
"Last key" t
)
159 (character :tag
"Character" :value ?e
)
160 (symbol :tag
"Key symbol" :value RET
))
163 (defcustom kmacro-call-repeat-with-arg nil
164 "Repeat macro call with original arg when non-nil; repeat once if nil."
168 (defcustom kmacro-step-edit-mini-window-height
0.75
169 "Override `max-mini-window-height' when step edit keyboard macro."
175 (defvar kmacro-keymap
176 (let ((map (make-sparse-keymap)))
177 ;; Start, end, execute macros
178 (define-key map
"s" 'kmacro-start-macro
)
179 (define-key map
"\C-s" 'kmacro-start-macro
)
180 (define-key map
"\C-k" 'kmacro-end-or-call-macro-repeat
)
181 (define-key map
"r" 'apply-macro-to-region-lines
)
182 (define-key map
"q" 'kbd-macro-query
) ;; Like C-x q
185 (define-key map
"\C-n" 'kmacro-cycle-ring-next
)
186 (define-key map
"\C-p" 'kmacro-cycle-ring-previous
)
187 (define-key map
"\C-v" 'kmacro-view-macro-repeat
)
188 (define-key map
"\C-d" 'kmacro-delete-ring-head
)
189 (define-key map
"\C-t" 'kmacro-swap-ring
)
190 (define-key map
"\C-l" 'kmacro-call-ring-2nd-repeat
)
193 (define-key map
"\C-f" 'kmacro-set-format
)
194 (define-key map
"\C-c" 'kmacro-set-counter
)
195 (define-key map
"\C-i" 'kmacro-insert-counter
)
196 (define-key map
"\C-a" 'kmacro-add-counter
)
199 (define-key map
"\C-e" 'kmacro-edit-macro-repeat
)
200 (define-key map
"\r" 'kmacro-edit-macro
)
201 (define-key map
"e" 'edit-kbd-macro
)
202 (define-key map
"l" 'kmacro-edit-lossage
)
203 (define-key map
" " 'kmacro-step-edit-macro
)
205 ;; naming and binding
206 (define-key map
"b" 'kmacro-bind-to-key
)
207 (define-key map
"n" 'kmacro-name-last-macro
)
209 "Keymap for keyboard macro commands.")
210 (defalias 'kmacro-keymap kmacro-keymap
)
212 ;;; Provide some binding for startup:
213 ;;;###autoload (global-set-key "\C-x(" 'kmacro-start-macro)
214 ;;;###autoload (global-set-key "\C-x)" 'kmacro-end-macro)
215 ;;;###autoload (global-set-key "\C-xe" 'kmacro-end-and-call-macro)
216 ;;;###autoload (global-set-key [f3] 'kmacro-start-macro-or-insert-counter)
217 ;;;###autoload (global-set-key [f4] 'kmacro-end-or-call-macro)
218 ;;;###autoload (global-set-key "\C-x\C-k" 'kmacro-keymap)
219 ;;;###autoload (autoload 'kmacro-keymap "kmacro" "Keymap for keyboard macro commands." t 'keymap)
221 (if kmacro-call-mouse-event
222 (global-set-key (vector kmacro-call-mouse-event
) 'kmacro-end-call-mouse
))
226 ;;; Keyboard macro counter
228 (defvar kmacro-counter
0
229 "*Current keyboard macro counter.")
231 (defvar kmacro-counter-format
"%d"
232 "*Current keyboard macro counter format.")
234 (defvar kmacro-counter-format-start kmacro-counter-format
235 "Macro format at start of macro execution.")
237 (defvar kmacro-counter-value-start kmacro-counter
238 "Macro counter at start of macro execution.")
240 (defvar kmacro-last-counter
0
241 "Last counter inserted by key macro.")
243 (defvar kmacro-initial-counter-value nil
244 "Initial counter value for the next keyboard macro to be defined.")
247 (defun kmacro-insert-counter (arg)
248 "Insert macro counter and increment with ARG or 1 if missing.
249 With \\[universal-argument], insert previous kmacro-counter (but do not modify counter)."
251 (setq kmacro-initial-counter-value nil
)
252 (if (and arg
(listp arg
))
253 (insert (format kmacro-counter-format kmacro-last-counter
))
254 (insert (format kmacro-counter-format kmacro-counter
))
255 (kmacro-add-counter (prefix-numeric-value arg
))))
258 (defun kmacro-set-format (format)
259 "Set macro counter FORMAT."
260 (interactive "sMacro Counter Format (printf format): ")
261 (setq kmacro-counter-format
262 (if (equal format
"") "%d" format
))
263 ;; redefine initial macro counter if we are not executing a macro.
264 (if (not (or defining-kbd-macro executing-kbd-macro
))
265 (setq kmacro-counter-format-start kmacro-counter-format
)))
268 (defun kmacro-display-counter (&optional value
)
269 "Display current counter value."
270 (unless value
(setq value kmacro-counter
))
271 (message "New macro counter value: %s (%d)" (format kmacro-counter-format value
) value
))
274 (defun kmacro-set-counter (arg)
275 "Set kmacro-counter to ARG or prompt if missing.
276 With \\[universal-argument] prefix, reset counter to its value prior to this iteration of the macro."
277 (interactive "NMacro counter value: ")
278 (setq kmacro-last-counter kmacro-counter
279 kmacro-counter
(if (and current-prefix-arg
(listp current-prefix-arg
))
280 kmacro-counter-value-start
282 ;; setup initial macro counter value if we are not executing a macro.
283 (setq kmacro-initial-counter-value
284 (and (not (or defining-kbd-macro executing-kbd-macro
))
286 (unless executing-kbd-macro
287 (kmacro-display-counter)))
290 (defun kmacro-add-counter (arg)
291 "Add numeric prefix arg (prompt if missing) to macro counter.
292 With \\[universal-argument], restore previous counter value."
293 (interactive "NAdd to macro counter: ")
294 (setq kmacro-initial-counter-value nil
)
295 (let ((last kmacro-last-counter
))
296 (setq kmacro-last-counter kmacro-counter
297 kmacro-counter
(if (and current-prefix-arg
(listp current-prefix-arg
))
299 kmacro-counter
(+ kmacro-counter arg
))))
300 (unless executing-kbd-macro
301 (kmacro-display-counter)))
304 (defun kmacro-loop-setup-function ()
305 "Function called prior to each iteration of macro."
306 ;; Restore macro counter format to initial format, so it is ok to change
307 ;; counter format in the macro without restoring it.
308 (setq kmacro-counter-format kmacro-counter-format-start
)
309 ;; Save initial counter value so we can restore it with C-u kmacro-set-counter.
310 (setq kmacro-counter-value-start kmacro-counter
)
311 ;; Return non-nil to continue execution.
315 ;;; Keyboard macro ring
317 (defvar kmacro-ring nil
318 "The keyboard macro ring.
319 Each element is a list (MACRO COUNTER FORMAT). Actually, the head of
320 the macro ring (when defining or executing) is not stored in the ring;
321 instead it is available in the variables `last-kbd-macro', `kmacro-counter',
322 and `kmacro-counter-format'.")
324 ;; Remember what we are currently looking at with kmacro-view-macro.
326 (defvar kmacro-view-last-item nil
)
327 (defvar kmacro-view-item-no
0)
330 (defun kmacro-ring-head ()
331 "Return pseudo head element in macro ring."
333 (list last-kbd-macro kmacro-counter kmacro-counter-format-start
)))
336 (defun kmacro-push-ring (&optional elt
)
337 "Push ELT or current macro onto `kmacro-ring'."
338 (when (setq elt
(or elt
(kmacro-ring-head)))
339 (let ((len (length kmacro-ring
)))
340 (setq kmacro-ring
(cons elt kmacro-ring
))
341 (if (>= len kmacro-ring-max
)
342 (setcdr (nthcdr len kmacro-ring
) nil
)))))
345 (defun kmacro-split-ring-element (elt)
346 (setq last-kbd-macro
(car elt
)
347 kmacro-counter
(nth 1 elt
)
348 kmacro-counter-format-start
(nth 2 elt
)))
351 (defun kmacro-pop-ring1 (&optional raw
)
352 "Pop head element off macro ring (no check).
353 Non-nil arg RAW means just return raw first element."
354 (prog1 (car kmacro-ring
)
356 (kmacro-split-ring-element (car kmacro-ring
)))
357 (setq kmacro-ring
(cdr kmacro-ring
))))
360 (defun kmacro-pop-ring (&optional raw
)
361 "Pop head element off macro ring.
362 Non-nil arg RAW means just return raw first element."
363 (unless (kmacro-ring-empty-p)
364 (kmacro-pop-ring1 raw
)))
367 (defun kmacro-ring-length ()
368 "Return length of macro ring, including pseudo head."
369 (+ (if last-kbd-macro
1 0) (length kmacro-ring
)))
372 (defun kmacro-ring-empty-p (&optional none
)
373 "Tell user and return t if `last-kbd-macro' is nil or `kmacro-ring' is empty.
374 Check only `last-kbd-macro' if optional arg NONE is non-nil."
375 (while (and (null last-kbd-macro
) kmacro-ring
)
378 ((null last-kbd-macro
)
379 (message "No keyboard macro defined.")
381 ((and (null none
) (null kmacro-ring
))
382 (message "Only one keyboard macro defined.")
387 (defun kmacro-display (macro &optional trunc descr empty
)
388 "Display a keyboard MACRO.
389 Optional arg TRUNC non-nil specifies to limit width of macro to 60 chars.
390 Optional arg DESCR is descriptive text for macro; default is \"Macro:\".
391 Optional arg EMPTY is message to print if no macros are defined."
394 (m (format-kbd-macro macro
))
396 (z (and nil trunc
(> l x
))))
397 (message (format "%s: %s%s" (or descr
"Macro")
398 (if z
(substring m
0 (1- x
)) m
) (if z
"..." ""))))
399 (message (or empty
"No keyboard macros defined"))))
402 (defun kmacro-repeat-on-last-key (keys)
403 "Process kmacro commands keys immidiately after cycling the ring."
404 (setq keys
(vconcat keys
))
405 (let ((n (1- (length keys
)))
407 (while (and last-kbd-macro
409 (aset keys n
(read-event))
410 (setq cmd
(key-binding keys t
))
411 (setq repeat
(get cmd
'kmacro-repeat
)))
412 (clear-this-command-keys t
)
416 (let ((kmacro-repeat-no-prefix nil
))
418 (kmacro-display last-kbd-macro t
)))
420 (let ((kmacro-repeat-no-prefix nil
))
425 (setq last-input-event nil
)))
426 (when last-input-event
427 (clear-this-command-keys t
)
428 (setq unread-command-events
(list last-input-event
))))
431 (defun kmacro-get-repeat-prefix ()
433 (and kmacro-repeat-no-prefix
434 (setq keys
(this-single-command-keys))
439 (defun kmacro-exec-ring-item (item arg
)
440 "Execute item ITEM from the macro ring."
441 ;; Use counter and format specific to the macro on the ring!
442 (let ((kmacro-counter (nth 1 item
))
443 (kmacro-counter-format-start (nth 2 item
)))
444 (execute-kbd-macro (car item
) arg
#'kmacro-loop-setup-function
)
445 (setcar (cdr item
) kmacro-counter
)))
448 (defun kmacro-call-ring-2nd (arg)
449 "Execute second keyboard macro at in macro ring."
451 (unless (kmacro-ring-empty-p)
452 (kmacro-exec-ring-item (car kmacro-ring
) arg
)))
455 (defun kmacro-call-ring-2nd-repeat (arg)
456 "Execute second keyboard macro at in macro ring.
457 This is like `kmacro-call-ring-2nd', but allows repeating macro commands
458 without repeating the prefix."
460 (let ((keys (kmacro-get-repeat-prefix)))
461 (kmacro-call-ring-2nd arg
)
462 (if (and kmacro-ring keys
)
463 (kmacro-repeat-on-last-key keys
))))
465 (put 'kmacro-call-ring-2nd-repeat
'kmacro-repeat
'head
)
468 (defun kmacro-view-ring-2nd ()
469 "Display the current head of the keyboard macro ring."
471 (unless (kmacro-ring-empty-p)
472 (kmacro-display (car (car kmacro-ring
)) "2nd macro")))
475 (defun kmacro-cycle-ring-next (&optional arg
)
476 "Move to next keyboard macro in keyboard macro ring.
477 Displays the selected macro in the echo area."
479 (unless (kmacro-ring-empty-p)
481 (let* ((keys (kmacro-get-repeat-prefix))
482 (len (length kmacro-ring
))
483 (tail (nthcdr (- len
2) kmacro-ring
))
484 (elt (car (cdr tail
))))
486 (kmacro-split-ring-element elt
)
487 (kmacro-display last-kbd-macro t
)
489 (kmacro-repeat-on-last-key keys
)))))
491 (put 'kmacro-cycle-ring-next
'kmacro-repeat
'ring
)
494 (defun kmacro-cycle-ring-previous (&optional arg
)
495 "Move to previous keyboard macro in keyboard macro ring.
496 Displays the selected macro in the echo area."
498 (unless (kmacro-ring-empty-p)
499 (let ((keys (kmacro-get-repeat-prefix))
500 (cur (kmacro-ring-head)))
503 (nconc kmacro-ring
(list cur
))
504 (setq kmacro-ring
(list cur
)))
505 (kmacro-display last-kbd-macro t
)
507 (kmacro-repeat-on-last-key keys
)))))
509 (put 'kmacro-cycle-ring-previous
'kmacro-repeat
'ring
)
512 (defun kmacro-swap-ring ()
513 "Swap first two elements on keyboard macro ring."
515 (unless (kmacro-ring-empty-p)
516 (let ((cur (kmacro-ring-head)))
518 (kmacro-push-ring cur
))
519 (kmacro-display last-kbd-macro t
)))
522 (defun kmacro-delete-ring-head (&optional arg
)
523 "Delete current macro from keyboard macro ring."
525 (unless (kmacro-ring-empty-p t
)
526 (if (null kmacro-ring
)
527 (setq last-kbd-macro nil
)
529 (kmacro-display last-kbd-macro t nil
"Keyboard macro ring is now empty.")))
531 (put 'kmacro-delete-ring-head
'kmacro-repeat
'head
)
533 ;;; Traditional bindings:
537 (defun kmacro-start-macro (arg)
538 "Record subsequent keyboard input, defining a keyboard macro.
539 The commands are recorded even as they are executed.
540 Use \\[kmacro-end-macro] to finish recording and make the macro available.
541 Use \\[kmacro-end-and-call-macro] to execute the macro.
543 Non-nil arg (prefix arg) means append to last macro defined.
545 With \\[universal-argument] prefix, append to last keyboard macro
546 defined. Depending on `kmacro-execute-before-append', this may begin
547 by re-executing the last macro as if you typed it again.
549 Otherwise, it sets `kmacro-counter' to ARG or 0 if missing before
552 Use \\[kmacro-insert-counter] to insert (and increment) the macro counter.
553 The counter value can be set or modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
554 The format of the counter can be modified via \\[kmacro-set-format].
556 Use \\[kmacro-name-last-macro] to give it a permanent name.
557 Use \\[kmacro-bind-to-key] to bind it to a key sequence."
559 (if (or defining-kbd-macro executing-kbd-macro
)
560 (message "Already defining keyboard macro.")
561 (let ((append (and arg
(listp arg
))))
564 (let ((len (length kmacro-ring
)))
567 (list last-kbd-macro kmacro-counter kmacro-counter-format-start
)
569 (if (>= len kmacro-ring-max
)
570 (setcdr (nthcdr len kmacro-ring
) nil
))))
571 (setq kmacro-counter
(or (if arg
(prefix-numeric-value arg
))
572 kmacro-initial-counter-value
574 kmacro-initial-counter-value nil
575 kmacro-counter-value-start kmacro-counter
576 kmacro-last-counter kmacro-counter
577 kmacro-counter-format-start kmacro-counter-format
))
579 (start-kbd-macro append
581 (if kmacro-execute-before-append
583 (= (car arg
) 4)))))))
587 (defun kmacro-end-macro (arg)
588 "Finish defining a keyboard macro.
589 The definition was started by \\[kmacro-start-macro].
590 The macro is now available for use via \\[kmacro-call-macro],
591 or it can be given a name with \\[kmacro-name-last-macro] and then invoked
594 With numeric arg, repeat macro now that many times,
595 counting the definition just completed as the first repetition.
596 An argument of zero means repeat until error."
598 (end-kbd-macro arg
#'kmacro-loop-setup-function
)
599 (when (and last-kbd-macro
(= (length last-kbd-macro
) 0))
600 (message "Ignore empty macro")
605 (defun kmacro-call-macro (arg &optional no-repeat end-macro
)
606 "Call the last keyboard macro that you defined with \\[kmacro-start-macro].
607 A prefix argument serves as a repeat count. Zero means repeat until error.
609 When you call the macro, you can call the macro again by repeating
610 just the last key in the key sequence that you used to call this
611 command. See `kmacro-call-repeat-key' and `kmacro-call-repeat-with-arg'
612 for details on how to adjust or disable this behaviour.
614 To make a macro permanent so you can call it even after defining
615 others, use \\[kmacro-name-last-macro]."
617 (let ((repeat-key (and (null no-repeat
)
618 (> (length (this-single-command-keys)) 1)
622 (kmacro-end-macro arg
)
623 (call-last-kbd-macro arg
#'kmacro-loop-setup-function
))
625 (setq arg
(car arg
)))
626 (when (and (or (null arg
) (> arg
0))
628 (if (eq kmacro-call-repeat-key t
)
630 kmacro-call-repeat-key
)))
631 (setq repeat-key-str
(format-kbd-macro (vector repeat-key
) nil
))
633 (message "(Type %s to repeat macro%s)"
635 (if (and kmacro-call-repeat-with-arg
637 (format " %d times" arg
) ""))
638 (if (equal repeat-key
(read-event))
640 (clear-this-command-keys t
)
641 (call-last-kbd-macro (and kmacro-call-repeat-with-arg arg
)
642 #'kmacro-loop-setup-function
)
643 (setq last-input-event nil
))
644 (setq repeat-key nil
)))
645 (when last-input-event
646 (clear-this-command-keys t
)
647 (setq unread-command-events
(list last-input-event
))))))
650 ;;; Combined function key bindings:
653 (defun kmacro-start-macro-or-insert-counter (arg)
654 "Record subsequent keyboard input, defining a keyboard macro.
655 The commands are recorded even as they are executed.
657 Sets the `kmacro-counter' to ARG (or 0 if no prefix arg) before defining the
660 With \\[universal-argument], appends to current keyboard macro (keeping
661 the current value of `kmacro-counter').
663 When defining/executing macro, inserts macro counter and increments
664 the counter with ARG or 1 if missing. With \\[universal-argument],
665 inserts previous kmacro-counter (but do not modify counter).
667 The macro counter can be modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
668 The format of the counter can be modified via \\[kmacro-set-format]."
670 (if (or defining-kbd-macro executing-kbd-macro
)
671 (kmacro-insert-counter arg
)
672 (kmacro-start-macro arg
)))
676 (defun kmacro-end-or-call-macro (arg &optional no-repeat
)
677 "End kbd macro if currently being defined; else call last kbd macro.
678 With numeric prefix ARG, repeat macro that many times.
679 With \\[universal-argument], call second macro in macro ring."
683 (if kmacro-call-repeat-key
684 (kmacro-call-macro arg no-repeat t
)
685 (kmacro-end-macro arg
)))
686 ((and (eq this-command
'kmacro-view-macro
) ;; We are in repeat mode!
687 kmacro-view-last-item
)
688 (kmacro-exec-ring-item (car kmacro-view-last-item
) arg
))
689 ((and arg
(listp arg
))
690 (kmacro-call-ring-2nd 1))
692 (kmacro-call-macro arg no-repeat
))))
695 (defun kmacro-end-or-call-macro-repeat (arg)
696 "As `kmacro-end-or-call-macro' but allows repeat without repeating prefix."
698 (let ((keys (kmacro-get-repeat-prefix)))
699 (kmacro-end-or-call-macro arg t
)
701 (kmacro-repeat-on-last-key keys
))))
703 (put 'kmacro-end-or-call-macro-repeat
'kmacro-repeat
'head
)
707 (defun kmacro-end-and-call-macro (arg &optional no-repeat
)
708 "Call last keyboard macro, ending it first if currently being defined.
709 With numeric prefix ARG, repeat macro that many times.
710 Zero argument means repeat until there is an error.
712 To give a macro a permanent name, so you can call it
713 even after defining other macros, use \\[kmacro-name-last-macro]."
715 (if defining-kbd-macro
716 (kmacro-end-macro nil
))
717 (kmacro-call-macro arg no-repeat
))
721 (defun kmacro-end-call-mouse (event)
722 "Move point to the position clicked with the mouse and call last kbd macro.
723 If kbd macro currently being defined end it before activating it."
725 (when defining-kbd-macro
727 (mouse-set-point event
)
728 (kmacro-call-macro nil t
))
733 ;; An idea for macro bindings:
734 ;; Create a separate keymap installed as a minor-mode keymap (e.g. in
735 ;; the emulation-mode-map-alists) in which macro bindings are made
736 ;; independent of any other bindings. When first binding is made,
737 ;; the kemap is created, installed, and enabled. Key seq. C-x C-k +
738 ;; can then be used to toggle the use of this keymap on and off.
739 ;; This means that it would be safe(r) to bind ordinary keys like
740 ;; letters and digits, provided that we inhibit the keymap while
741 ;; executing the macro later on (but that's controversial...)
743 (defun kmacro-lambda-form (mac &optional counter format
)
744 "Create lambda form for macro bound to symbol or key."
746 (setq mac
(list mac counter format
)))
747 `(lambda (&optional arg
)
750 (kmacro-exec-ring-item ',mac arg
)))
752 (defun kmacro-extract-lambda (mac)
753 "Extract kmacro from a kmacro lambda form."
755 (eq (car mac
) 'lambda
)
756 (setq mac
(assoc 'kmacro-exec-ring-item mac
))
758 (consp (car (cdr mac
)))
759 (consp (cdr (car (cdr mac
))))
760 (setq mac
(car (cdr (car (cdr mac
)))))
767 (defun kmacro-bind-to-key (arg)
768 "When not defining or executing a macro, offer to bind last macro to a key.
769 The key sequences [C-x C-k 0] through [C-x C-k 9] and [C-x C-k A]
770 through [C-x C-k Z] are reserved for user bindings, and to bind to
771 one of these sequences, just enter the digit or letter, rather than
774 You can bind to any valid key sequence, but if you try to bind to
775 a key with an existing command binding, you will be asked for
776 confirmation whether to replace that binding. Note that the
777 binding is made in the `global-map' keymap, so the macro binding
778 may be shaded by a local key binding."
780 (if (or defining-kbd-macro executing-kbd-macro
)
781 (if defining-kbd-macro
782 (message "Cannot save macro while defining it."))
783 (unless last-kbd-macro
784 (error "No keyboard macro defined"))
785 (let ((key-seq (read-key-sequence "Bind last macro to key: "))
787 (when (= (length key-seq
) 1)
788 (let ((ch (aref key-seq
0)))
789 (if (or (and (>= ch ?
0) (<= ch ?
9))
790 (and (>= ch ?A
) (<= ch ?Z
)))
791 (setq key-seq
(concat "\C-x\C-k" key-seq
)
793 (when (and (not (equal key-seq
"\a"))
795 (not (setq cmd
(key-binding key-seq
)))
798 (yes-or-no-p (format "%s runs command %S. Bind anyway? "
799 (format-kbd-macro key-seq
)
801 (define-key global-map key-seq
802 (kmacro-lambda-form (kmacro-ring-head)))
803 (message "Keyboard macro bound to %s" (format-kbd-macro key-seq
))))))
806 (defun kmacro-name-last-macro (symbol)
807 "Assign a name to the last keyboard macro defined.
808 Argument SYMBOL is the name to define.
809 The symbol's function definition becomes the keyboard macro string.
810 Such a \"function\" cannot be called from Lisp, but it is a valid editor command."
811 (interactive "SName for last kbd macro: ")
813 (error "No keyboard macro defined"))
814 (and (fboundp symbol
)
815 (not (get symbol
'kmacro
))
816 (not (stringp (symbol-function symbol
)))
817 (not (vectorp (symbol-function symbol
)))
818 (error "Function %s is already defined and not a keyboard macro"
820 (if (string-equal symbol
"")
821 (error "No command name given"))
822 (fset symbol
(kmacro-lambda-form (kmacro-ring-head)))
823 (put symbol
'kmacro t
))
826 (defun kmacro-view-macro (&optional arg
)
827 "Display the last keyboard macro.
828 If repeated, it shows previous elements in the macro ring."
831 ((or (kmacro-ring-empty-p)
832 (not (eq last-command
'kmacro-view-macro
)))
833 (setq kmacro-view-last-item nil
))
834 ((null kmacro-view-last-item
)
835 (setq kmacro-view-last-item kmacro-ring
836 kmacro-view-item-no
2))
837 ((consp kmacro-view-last-item
)
838 (setq kmacro-view-last-item
(cdr kmacro-view-last-item
)
839 kmacro-view-item-no
(1+ kmacro-view-item-no
)))
841 (setq kmacro-view-last-item nil
)))
842 (setq this-command
'kmacro-view-macro
843 last-command this-command
) ;; in case we repeat
844 (kmacro-display (if kmacro-view-last-item
845 (car (car kmacro-view-last-item
))
848 (if kmacro-view-last-item
849 (concat (cond ((= kmacro-view-item-no
2) "2nd")
850 ((= kmacro-view-item-no
3) "3nd")
851 (t (format "%dth" kmacro-view-item-no
)))
855 (defun kmacro-view-macro-repeat (&optional arg
)
856 "Display the last keyboard macro.
857 If repeated, it shows previous elements in the macro ring.
858 To execute the displayed macro ring item without changing the macro ring,
860 This is like `kmacro-view-macro', but allows repeating macro commands
861 without repeating the prefix."
863 (let ((keys (kmacro-get-repeat-prefix)))
864 (kmacro-view-macro arg
)
865 (if (and last-kbd-macro keys
)
866 (kmacro-repeat-on-last-key keys
))))
868 (put 'kmacro-view-macro-repeat
'kmacro-repeat
'ring
)
871 (defun kmacro-edit-macro-repeat (&optional arg
)
872 "Edit last keyboard macro."
874 (edit-kbd-macro "\r" arg
))
876 (put 'kmacro-edit-macro-repeat
'kmacro-repeat
'stop
)
879 (defun kmacro-edit-macro (&optional arg
)
880 "As edit last keyboard macro, but without kmacro-repeat property."
882 (edit-kbd-macro "\r" arg
))
885 (defun kmacro-edit-lossage ()
886 "Edit most recent 100 keystrokes as a keyboard macro."
889 (edit-kbd-macro "\C-hl"))
892 ;;; Single-step editing of keyboard macros
894 (defvar kmacro-step-edit-active
) ;; step-editing active
895 (defvar kmacro-step-edit-new-macro
) ;; storage for new macro
896 (defvar kmacro-step-edit-inserting
) ;; inserting into macro
897 (defvar kmacro-step-edit-appending
) ;; append to end of macro
898 (defvar kmacro-step-edit-replace
) ;; replace orig macro when done
899 (defvar kmacro-step-edit-prefix-index
) ;; index of first prefix arg key
900 (defvar kmacro-step-edit-key-index
) ;; index of current key
901 (defvar kmacro-step-edit-action
) ;; automatic action on next pre-command hook
902 (defvar kmacro-step-edit-help
) ;; kmacro step edit help enabled
903 (defvar kmacro-step-edit-num-input-keys
) ;; to ignore duplicate pre-command hook
905 (defvar kmacro-step-edit-map
(make-sparse-keymap)
906 "Keymap that defines the responses to questions in `kmacro-step-edit-macro'.
907 This keymap is an extension to the `query-replace-map', allowing the
908 following additional answers: `insert', `insert-1', `replace', `replace-1',
909 `append', `append-end', `act-repeat', `skip-end', `skip-keep'.")
911 ;; query-replace-map answers include: `act', `skip', `act-and-show',
912 ;; `exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
913 ;; `automatic', `backup', `exit-prefix', and `help'.")
914 ;; Also: `quit', `edit-replacement'
916 (set-keymap-parent kmacro-step-edit-map query-replace-map
)
918 (define-key kmacro-step-edit-map
"\t" 'act-repeat
)
919 (define-key kmacro-step-edit-map
[tab] 'act-repeat)
920 (define-key kmacro-step-edit-map "\C-k" 'skip-rest)
921 (define-key kmacro-step-edit-map "c" 'automatic)
922 (define-key kmacro-step-edit-map "f" 'skip-keep)
923 (define-key kmacro-step-edit-map "q" 'quit)
924 (define-key kmacro-step-edit-map "d" 'skip)
925 (define-key kmacro-step-edit-map "\C-d" 'skip)
926 (define-key kmacro-step-edit-map "i" 'insert)
927 (define-key kmacro-step-edit-map "I" 'insert-1)
928 (define-key kmacro-step-edit-map "r" 'replace)
929 (define-key kmacro-step-edit-map "R" 'replace-1)
930 (define-key kmacro-step-edit-map "a" 'append)
931 (define-key kmacro-step-edit-map "A" 'append-end)
933 (defvar kmacro-step-edit-prefix-commands
934 '(universal-argument universal-argument-more universal-argument-minus
935 digit-argument negative-argument)
936 "Commands which builds up a prefix arg for the current command")
938 (defun kmacro-step-edit-prompt (macro index)
939 ;; Show step-edit prompt
940 (let ((keys (and (not kmacro-step-edit-appending)
941 index (substring macro index executing-macro-index)))
942 (future (and (not kmacro-step-edit-appending)
943 (substring macro executing-macro-index)))
944 (message-log-max nil)
945 (curmsg (current-message)))
947 ;; TODO: Scroll macro if max-mini-window-height is too small.
950 (format "Macro: %s%s%s%s%s\n"
951 (format-kbd-macro kmacro-step-edit-new-macro 1)
952 (if (and kmacro-step-edit-new-macro (> (length kmacro-step-edit-new-macro) 0)) " " "")
953 (propertize (if keys (format-kbd-macro keys)
954 (if kmacro-step-edit-appending "<APPEND>" "<INSERT>")) 'face 'region)
956 (if future (format-kbd-macro future) ""))
961 minibuffer " 'face 'header-line)
962 (buffer-substring (point-min) (point-max))))
966 echo area " 'face 'header-line)
970 (format "%s\n%s%s %S [yn iIaArR C-k kq!] "
972 --------------Step Edit Keyboard Macro [?: help]---------------" 'face 'mode-line)
973 (if kmacro-step-edit-help "\
974 Step: y/SPC: execute next, d/n/DEL: skip next, f: skip but keep
975 TAB: execute while same, ?: toggle help
976 Edit: i: insert, r: replace, a: append, A: append at end,
977 I/R: insert/replace with one sequence,
978 End: !/c: execute rest, C-k: skip rest and save, q/C-g: quit
979 ----------------------------------------------------------------
981 (propertize "Next command:" 'face 'bold)
984 (format "Type key sequence%s to insert and execute%s: "
985 (if (numberp kmacro-step-edit-inserting) "" "s")
986 (if (numberp kmacro-step-edit-inserting) "" " (end with C-j)"))
989 (defun kmacro-step-edit-query ()
990 ;; Pre-command hook function for step-edit in "command" mode
991 (let ((resize-mini-windows t)
992 (max-mini-window-height kmacro-step-edit-mini-window-height)
993 act restore-index next-index)
995 ;; Handle commands which reads additional input using read-char.
997 ((and (eq this-command 'quoted-insert)
998 (not (eq kmacro-step-edit-action t)))
999 ;; Find the actual end of this key sequence.
1000 ;; Must be able to backtrack in case we actually execute it.
1001 (setq restore-index executing-macro-index)
1002 (let (unread-command-events)
1004 (when unread-command-events
1005 (setq executing-macro-index (- executing-macro-index (length unread-command-events))
1006 next-index executing-macro-index)))))
1008 ;; Query the user; stop macro exection temporarily
1009 (let ((macro executing-kbd-macro)
1010 (executing-kbd-macro nil)
1011 (defining-kbd-macro nil))
1013 ;; Any action requested by previous command
1015 ((eq kmacro-step-edit-action t) ;; Reentry for actual command @ end of prefix arg.
1017 ((eq this-command 'quoted-insert)
1018 (clear-this-command-keys) ;; recent-keys actually
1019 (let (unread-command-events)
1020 (quoted-insert (prefix-numeric-value current-prefix-arg))
1021 (setq kmacro-step-edit-new-macro
1022 (vconcat kmacro-step-edit-new-macro (recent-keys)))
1023 (when unread-command-events
1024 (setq kmacro-step-edit-new-macro
1025 (substring kmacro-step-edit-new-macro 0 (- (length unread-command-events)))
1026 executing-macro-index (- executing-macro-index (length unread-command-events)))))
1027 (setq current-prefix-arg nil
1032 (setq kmacro-step-edit-action nil))
1033 ((eq this-command kmacro-step-edit-action) ;; TAB -> activate while same command
1036 (setq kmacro-step-edit-action nil)))
1038 ;; Handle prefix arg, or query user
1040 (act act) ;; set above
1041 ((memq this-command kmacro-step-edit-prefix-commands)
1042 (unless kmacro-step-edit-prefix-index
1043 (setq kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1044 (setq act 'universal-argument))
1045 ((eq this-command 'universal-argument-other-key)
1046 (setq act 'universal-argument))
1048 (kmacro-step-edit-prompt macro (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1049 (setq act (lookup-key kmacro-step-edit-map
1050 (vector (with-current-buffer (current-buffer) (read-event))))))))
1052 ;; Resume macro execution and perform the action
1054 ((eq act 'universal-argument)
1059 ((eq act 'act-repeat)
1060 (setq kmacro-step-edit-action this-command)
1063 (setq kmacro-step-edit-replace nil)
1064 (setq kmacro-step-edit-active 'ignore)
1067 (setq kmacro-step-edit-prefix-index nil)
1069 ((eq act 'skip-keep)
1070 (setq this-command 'ignore)
1072 ((eq act 'skip-rest)
1073 (setq kmacro-step-edit-active 'ignore)
1075 ((memq act '(automatic exit))
1076 (setq kmacro-step-edit-active nil)
1079 ((member act '(insert-1 insert))
1080 (setq executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1081 (setq kmacro-step-edit-inserting (if (eq act 'insert-1) 1 t))
1083 ((member act '(replace-1 replace))
1084 (setq kmacro-step-edit-inserting (if (eq act 'replace-1) 1 t))
1085 (setq kmacro-step-edit-prefix-index nil)
1086 (if (= executing-macro-index (length executing-kbd-macro))
1087 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1088 kmacro-step-edit-appending t))
1091 (setq kmacro-step-edit-inserting t)
1092 (if (= executing-macro-index (length executing-kbd-macro))
1093 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1094 kmacro-step-edit-appending t))
1096 ((eq act 'append-end)
1097 (if (= executing-macro-index (length executing-kbd-macro))
1098 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1099 kmacro-step-edit-inserting t
1100 kmacro-step-edit-appending t)
1101 (setq kmacro-step-edit-active 'append-end))
1105 (setq executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1106 (setq kmacro-step-edit-help (not kmacro-step-edit-help))
1108 (t ;; Ignore unknown responses
1109 (setq executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1111 (if (> executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1112 (setq kmacro-step-edit-new-macro
1113 (vconcat kmacro-step-edit-new-macro
1114 (substring executing-kbd-macro
1115 (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1116 (if (eq act t) nil executing-macro-index)))
1117 kmacro-step-edit-prefix-index nil))
1119 (setq executing-macro-index restore-index)))
1121 (setq this-command 'ignore)))
1122 (setq kmacro-step-edit-key-index next-index)))
1124 (defun kmacro-step-edit-insert ()
1125 ;; Pre-command hook function for step-edit in "insert" mode
1126 (let ((resize-mini-windows t)
1127 (max-mini-window-height kmacro-step-edit-mini-window-height)
1128 (macro executing-kbd-macro)
1129 (executing-kbd-macro nil)
1130 (defining-kbd-macro nil)
1131 cmd keys next-index)
1132 (setq executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1133 kmacro-step-edit-prefix-index nil)
1134 (kmacro-step-edit-prompt macro nil)
1135 ;; Now, we have read a key sequence from the macro, but we don't want
1136 ;; to execute it yet. So push it back and read another sequence.
1137 (reset-this-command-lengths)
1138 (setq keys (read-key-sequence nil nil nil nil t))
1139 (setq cmd (key-binding keys t nil))
1143 ((eq cmd 'quoted-insert)
1144 (clear-this-command-keys) ;; recent-keys actually
1145 (quoted-insert (prefix-numeric-value current-prefix-arg))
1146 (setq current-prefix-arg nil
1148 (setq keys (vconcat keys (recent-keys)))
1149 (when (numberp kmacro-step-edit-inserting)
1150 (setq kmacro-step-edit-inserting nil)
1151 (when unread-command-events
1152 (setq keys (substring keys 0 (- (length unread-command-events)))
1153 executing-macro-index (- executing-macro-index (length unread-command-events))
1154 next-index executing-macro-index
1155 unread-command-events nil)))
1158 ((memq cmd kmacro-step-edit-prefix-commands)
1159 (setq universal-argument-num-events 0)
1160 (reset-this-command-lengths)
1162 ((eq cmd 'universal-argument-other-key)
1163 (setq kmacro-step-edit-action t)
1164 (setq universal-argument-num-events 0)
1165 (reset-this-command-lengths)
1166 (if (numberp kmacro-step-edit-inserting)
1167 (setq kmacro-step-edit-inserting nil))
1169 ((numberp kmacro-step-edit-inserting)
1170 (setq kmacro-step-edit-inserting nil)
1172 ((equal keys "\C-j")
1173 (setq kmacro-step-edit-inserting nil)
1174 (setq kmacro-step-edit-action nil)
1175 ;; Forget any (partial) prefix arg from next command
1176 (setq kmacro-step-edit-prefix-index nil)
1177 (reset-this-command-lengths)
1178 (setq overriding-terminal-local-map nil)
1179 (setq universal-argument-num-events nil)
1180 (setq next-index kmacro-step-edit-key-index)
1183 (setq this-command 'ignore)
1184 (setq this-command cmd)
1185 (if (memq this-command '(self-insert-command digit-argument))
1186 (setq last-command-char (aref keys (1- (length keys)))))
1188 (setq kmacro-step-edit-new-macro (vconcat kmacro-step-edit-new-macro keys))))
1189 (setq kmacro-step-edit-key-index next-index)))
1191 (defun kmacro-step-edit-pre-command ()
1192 (remove-hook 'post-command-hook 'kmacro-step-edit-post-command)
1193 (when kmacro-step-edit-active
1195 ((eq kmacro-step-edit-active 'ignore)
1196 (setq this-command 'ignore))
1197 ((eq kmacro-step-edit-active 'append-end)
1198 (if (= executing-macro-index (length executing-kbd-macro))
1199 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1200 kmacro-step-edit-inserting t
1201 kmacro-step-edit-appending t
1202 kmacro-step-edit-active t)))
1203 ((/= kmacro-step-edit-num-input-keys num-input-keys)
1204 (if kmacro-step-edit-inserting
1205 (kmacro-step-edit-insert)
1206 (kmacro-step-edit-query))
1207 (setq kmacro-step-edit-num-input-keys num-input-keys)
1208 (if (and kmacro-step-edit-appending (not kmacro-step-edit-inserting))
1209 (setq kmacro-step-edit-appending nil
1210 kmacro-step-edit-active 'ignore)))))
1211 (when (eq kmacro-step-edit-active t)
1212 (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)))
1214 (defun kmacro-step-edit-minibuf-setup ()
1215 (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command t)
1216 (when kmacro-step-edit-active
1217 (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil t)))
1219 (defun kmacro-step-edit-post-command ()
1220 (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command)
1221 (when kmacro-step-edit-active
1222 (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil nil)
1223 (if kmacro-step-edit-key-index
1224 (setq executing-macro-index kmacro-step-edit-key-index)
1225 (setq kmacro-step-edit-key-index executing-macro-index))))
1228 (defun kmacro-step-edit-macro ()
1229 "Step edit and execute last keyboard macro.
1231 To customize possible responses, change the \"bindings\" in `kmacro-step-edit-map'."
1233 (let ((kmacro-step-edit-active t)
1234 (kmacro-step-edit-new-macro "")
1235 (kmacro-step-edit-inserting nil)
1236 (kmacro-step-edit-appending nil)
1237 (kmacro-step-edit-replace t)
1238 (kmacro-step-edit-prefix-index nil)
1239 (kmacro-step-edit-key-index 0)
1240 (kmacro-step-edit-action nil)
1241 (kmacro-step-edit-help nil)
1242 (kmacro-step-edit-num-input-keys num-input-keys)
1243 (pre-command-hook pre-command-hook)
1244 (post-command-hook post-command-hook)
1245 (minibuffer-setup-hook minibuffer-setup-hook))
1246 (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil)
1247 (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)
1248 (add-hook 'minibuffer-setup-hook 'kmacro-step-edit-minibuf-setup t)
1249 (call-last-kbd-macro nil nil)
1250 (when (and kmacro-step-edit-replace
1251 kmacro-step-edit-new-macro
1252 (not (equal last-kbd-macro kmacro-step-edit-new-macro)))
1254 (setq last-kbd-macro kmacro-step-edit-new-macro))))
1258 ;;; arch-tag: d3fe0b24-ae41-47de-a4d6-41a77d5559f0
1259 ;;; kmacro.el ends here