lisp/kmacro.el

   1 ;;; kmacro.el --- enhanced keyboard macros
   2
   3 ;; Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4 ;;   Free Software Foundation, Inc.
   5
   6 ;; Author: Kim F. Storm <storm@cua.dk>
   7 ;; Keywords: keyboard convenience
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;; The kmacro package provides the user interface to emacs' basic
  27 ;; keyboard macro functionality.  With kmacro, two function keys are
  28 ;; dedicated to keyboard macros, by default F3 and F4.
  29
  30 ;; Note: The traditional bindings C-x (, C-x ), and C-x e are still
  31 ;; supported, but for some users these bindings are too hard to type
  32 ;; to be really useful for doing small repeated tasks.
  33
  34 ;; To start defining a keyboard macro, use F3.  To end the macro,
  35 ;; use F4, and to call the macro also use F4.  This makes it very
  36 ;; easy to repeat a macro immediately after defining it.
  37 ;;
  38 ;; You can call the macro repeatedly by pressing F4 multiple times, or
  39 ;; you can give a numeric prefix argument specifying the number of
  40 ;; times to repeat the macro.  Macro execution automatically
  41 ;; terminates when point reaches the end of the buffer or if an error
  42 ;; is signaled by ringing the bell.
  43
  44 ;; When you define a macro with F3/F4, it is automatically added to
  45 ;; the head of the "keyboard macro ring", and F4 actually executes the
  46 ;; first element of the macro ring.
  47 ;;
  48 ;; Note: an empty macro is never added to the macro ring.
  49 ;;
  50 ;; You can execute the second element on the macro ring with C-u F4 or
  51 ;; C-x C-k C-l, you can use C-x C-k C-p and C-x C-k C-n to cycle
  52 ;; through the macro ring, and you can swap the first and second
  53 ;; elements with C-x C-k C-t.  To delete the first element in the
  54 ;; macro ring, use C-x C-k C-d.
  55 ;;
  56 ;; You can also use C-x C-k C-s to start a macro, and C-x C-k C-k to
  57 ;; end it; then use C-k to execute it immediately, or C-x C-k C-k to
  58 ;; execute it later.
  59 ;;
  60 ;; In general, immediately after using C-x C-k followed by one of C-k,
  61 ;; C-l, C-p, or C-n, you can further cycle the macro ring using C-p or
  62 ;; C-n, execute the first or second macro using C-k or C-l, delete
  63 ;; the head macro with C-d, or edit the current macro with C-e without
  64 ;; repeating the C-x C-k prefix.
  65
  66 ;; If you enter F3 while defining the macro, the numeric value of
  67 ;; `kmacro-counter' is inserted using the `kmacro-counter-format', and
  68 ;; `kmacro-counter' is incremented by 1 (or the numeric prefix value
  69 ;; of F3).
  70 ;;
  71 ;; The initial value of `kmacro-counter' is 0, or the numeric prefix
  72 ;; value given to F3 when starting the macro.
  73 ;;
  74 ;; Now, each time you call the macro using F4, the current
  75 ;; value of `kmacro-counter' is inserted and incremented, making it
  76 ;; easy to insert incremental numbers in the buffer.
  77 ;;
  78 ;; Example:
  79 ;;
  80 ;; The following sequence: M-5 F3 x M-2 F3 y F4 F4 F4 F4
  81 ;; inserts the following string:  x5yx7yx9yx11y
  82
  83 ;; A macro can also be called using a mouse click, default S-mouse-3.
  84 ;; This calls the macro at the point where you click the mouse.
  85
  86 ;; You can edit the last macro using C-x C-k C-e.
  87
  88 ;; You can append to the last macro using C-u F3.
  89
  90 ;; You can set the macro counter using C-x C-k C-c, add to it using C-x C-k C-a,
  91 ;; and you can set the macro counter format with C-x C-k C-f.
  92
  93 ;; The following key bindings are performed:
  94 ;;
  95 ;;           Normal                         While defining macro
  96 ;;           ---------------------------    ------------------------------
  97 ;;  f3       Define macro                   Insert current counter value
  98 ;;           Prefix arg specifies initial   and increase counter by prefix
  99 ;;           counter value (default 0)      (default increment: 1)
 100 ;;
 101 ;;  C-u f3   APPENDs to last macro
 102 ;;
 103 ;;  f4       Call last macro                End macro
 104 ;;           Prefix arg specifies number
 105 ;;           of times to execute macro.
 106 ;;
 107 ;;  C-u f4   Swap last and head of macro ring.
 108 ;;
 109 ;;  S-mouse-3  Set point at click and       End macro and execute macro at
 110 ;;             execute last macro.          click.
 111
 112 ;;; Code:
 113
 114 ;; Customization:
 115
 116 (defgroup kmacro nil
 117   "Simplified keyboard macro user interface."
 118   :group 'keyboard
 119   :group 'convenience
 120   :version "22.1"
 121   :link '(emacs-commentary-link :tag "Commentary" "kmacro.el")
 122   :link '(emacs-library-link :tag "Lisp File" "kmacro.el"))
 123
 124 (defcustom kmacro-call-mouse-event 'S-mouse-3
 125   "The mouse event used by kmacro to call a macro.
 126 Set to nil if no mouse binding is desired."
 127   :type 'symbol
 128   :group 'kmacro)
 129
 130 (defcustom kmacro-ring-max 8
 131   "Maximum number of keyboard macros to save in macro ring."
 132   :type 'integer
 133   :group 'kmacro)
 134
 135
 136 (defcustom kmacro-execute-before-append t
 137   "Controls whether appending to a macro starts by executing the macro.
 138 If non-nil, using a single \\[universal-argument] prefix executes the macro
 139 before appending, while more than one \\[universal-argument] prefix does not
 140 execute the macro.
 141 Otherwise, a single \\[universal-argument] prefix does not execute the
 142 macro, while more than one \\[universal-argument] prefix causes the
 143 macro to be executed before appending to it."
 144   :type 'boolean
 145   :group 'kmacro)
 146
 147
 148 (defcustom kmacro-repeat-no-prefix t
 149   "Allow repeating certain macro commands without entering the C-x C-k prefix."
 150   :type 'boolean
 151   :group 'kmacro)
 152
 153 (defcustom kmacro-call-repeat-key t
 154   "Allow repeating macro call using last key or a specific key."
 155   :type '(choice (const :tag "Disabled" nil)
 156                  (const :tag "Last key" t)
 157                  (character :tag "Character" :value ?e)
 158                  (symbol :tag "Key symbol" :value RET))
 159   :group 'kmacro)
 160
 161 (defcustom kmacro-call-repeat-with-arg nil
 162   "Repeat macro call with original arg when non-nil; repeat once if nil."
 163   :type 'boolean
 164   :group 'kmacro)
 165
 166 (defcustom kmacro-step-edit-mini-window-height 0.75
 167   "Override `max-mini-window-height' when step edit keyboard macro."
 168   :type 'number
 169   :group 'kmacro)
 170
 171 ;; Keymap
 172
 173 (defvar kmacro-keymap
 174   (let ((map (make-sparse-keymap)))
 175     ;; Start, end, execute macros
 176     (define-key map "s"    'kmacro-start-macro)
 177     (define-key map "\C-s" 'kmacro-start-macro)
 178     (define-key map "\C-k" 'kmacro-end-or-call-macro-repeat)
 179     (define-key map "r"    'apply-macro-to-region-lines)
 180     (define-key map "q"    'kbd-macro-query)  ;; Like C-x q
 181
 182     ;; macro ring
 183     (define-key map "\C-n" 'kmacro-cycle-ring-next)
 184     (define-key map "\C-p" 'kmacro-cycle-ring-previous)
 185     (define-key map "\C-v" 'kmacro-view-macro-repeat)
 186     (define-key map "\C-d" 'kmacro-delete-ring-head)
 187     (define-key map "\C-t" 'kmacro-swap-ring)
 188     (define-key map "\C-l" 'kmacro-call-ring-2nd-repeat)
 189
 190     ;; macro counter
 191     (define-key map "\C-f" 'kmacro-set-format)
 192     (define-key map "\C-c" 'kmacro-set-counter)
 193     (define-key map "\C-i" 'kmacro-insert-counter)
 194     (define-key map "\C-a" 'kmacro-add-counter)
 195
 196     ;; macro editing
 197     (define-key map "\C-e" 'kmacro-edit-macro-repeat)
 198     (define-key map "\r"   'kmacro-edit-macro)
 199     (define-key map "e"    'edit-kbd-macro)
 200     (define-key map "l"    'kmacro-edit-lossage)
 201     (define-key map " "    'kmacro-step-edit-macro)
 202
 203     ;; naming and binding
 204     (define-key map "b"    'kmacro-bind-to-key)
 205     (define-key map "n"    'kmacro-name-last-macro)
 206     map)
 207   "Keymap for keyboard macro commands.")
 208 (defalias 'kmacro-keymap kmacro-keymap)
 209
 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)
 218
 219 (if kmacro-call-mouse-event
 220   (global-set-key (vector kmacro-call-mouse-event) 'kmacro-end-call-mouse))
 221
 222
 223 ;;; Called from keyboard-quit
 224
 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)))
 230
 231
 232 ;;; Keyboard macro counter
 233
 234 (defvar kmacro-counter 0
 235   "*Current keyboard macro counter.")
 236
 237 (defvar kmacro-default-counter-format "%d")
 238
 239 (defvar kmacro-counter-format "%d"
 240   "*Current keyboard macro counter format.")
 241
 242 (defvar kmacro-counter-format-start kmacro-counter-format
 243   "Macro format at start of macro execution.")
 244
 245 (defvar kmacro-counter-value-start kmacro-counter
 246   "Macro counter at start of macro execution.")
 247
 248 (defvar kmacro-last-counter 0
 249   "Last counter inserted by key macro.")
 250
 251 (defvar kmacro-initial-counter-value nil
 252   "Initial counter value for the next keyboard macro to be defined.")
 253
 254
 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))))
 267
 268
 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)))
 277
 278
 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))
 283
 284
 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))))
 297
 298
 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)))
 313
 314
 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.
 323   t)
 324
 325
 326 ;;; Keyboard macro ring
 327
 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'.")
 334
 335 ;; Remember what we are currently looking at with kmacro-view-macro.
 336
 337 (defvar kmacro-view-last-item nil)
 338 (defvar kmacro-view-item-no 0)
 339
 340
 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)))
 345
 346
 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))))
 352
 353
 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)))
 358
 359
 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))))
 367
 368
 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)))
 374
 375
 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.")
 384     t)
 385    ((and (null none) (null kmacro-ring))
 386     (message "Only one keyboard macro defined.")
 387     t)
 388    (t nil)))
 389
 390
 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"))))
 407
 408
 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))))
 436
 437
 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)))
 444
 445
 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)))
 454
 455
 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)))
 461
 462
 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))))
 472
 473 (put 'kmacro-call-ring-2nd-repeat 'kmacro-repeat 'head)
 474
 475
 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")))
 481
 482
 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)))))
 498
 499 (put 'kmacro-cycle-ring-next 'kmacro-repeat 'ring)
 500
 501
 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)))))
 516
 517 (put 'kmacro-cycle-ring-previous 'kmacro-repeat 'ring)
 518
 519
 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)))
 528
 529
 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.")))
 538
 539 (put 'kmacro-delete-ring-head 'kmacro-repeat 'head)
 540
 541 ;;; Traditional bindings:
 542
 543
 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.
 550
 551 Non-nil arg (prefix arg) means append to last macro defined.
 552
 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.
 556
 557 Otherwise, it sets `kmacro-counter' to ARG or 0 if missing before
 558 defining the macro.
 559
 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].
 563
 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
 576                                  0)
 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))
 582
 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)))))
 590
 591
 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.
 599
 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)))))
 614
 615
 616 ;;;###autoload
 617 (defun kmacro-call-macro (arg &optional no-repeat end-macro)
 618   "Call the last keyboard macro that you defined with \\[kmacro-start-macro].
 619 A prefix argument serves as a repeat count.  Zero means repeat until error.
 620
 621 When you call the macro, you can call the macro again by repeating
 622 just the last key in the key sequence that you used to call this
 623 command.  See `kmacro-call-repeat-key' and `kmacro-call-repeat-with-arg'
 624 for details on how to adjust or disable this behavior.
 625
 626 To make a macro permanent so you can call it even after defining
 627 others, use \\[kmacro-name-last-macro]."
 628   (interactive "p")
 629   (let ((repeat-key (and (null no-repeat)
 630                          (> (length (this-single-command-keys)) 1)
 631                          last-input-event))
 632         repeat-key-str)
 633     (if end-macro
 634         (kmacro-end-macro arg)
 635       (call-last-kbd-macro arg #'kmacro-loop-setup-function))
 636     (when (consp arg)
 637       (setq arg (car arg)))
 638     (when (and (or (null arg) (> arg 0))
 639                (setq repeat-key
 640                      (if (eq kmacro-call-repeat-key t)
 641                          repeat-key
 642                        kmacro-call-repeat-key)))
 643       (setq repeat-key-str (format-kbd-macro (vector repeat-key) nil))
 644       (while repeat-key
 645         (message "(Type %s to repeat macro%s)"
 646                  repeat-key-str
 647                  (if (and kmacro-call-repeat-with-arg
 648                           arg (> arg 1))
 649                      (format " %d times" arg) ""))
 650         (if (equal repeat-key (read-event))
 651             (progn
 652               (clear-this-command-keys t)
 653               (call-last-kbd-macro (and kmacro-call-repeat-with-arg arg)
 654                                    #'kmacro-loop-setup-function)
 655               (setq last-input-event nil))
 656           (setq repeat-key nil)))
 657       (when last-input-event
 658         (clear-this-command-keys t)
 659         (setq unread-command-events (list last-input-event))))))
 660
 661
 662 ;;; Combined function key bindings:
 663
 664 ;;;###autoload
 665 (defun kmacro-start-macro-or-insert-counter (arg)
 666   "Record subsequent keyboard input, defining a keyboard macro.
 667 The commands are recorded even as they are executed.
 668
 669 Sets the `kmacro-counter' to ARG (or 0 if no prefix arg) before defining the
 670 macro.
 671
 672 With \\[universal-argument], appends to current keyboard macro (keeping
 673 the current value of `kmacro-counter').
 674
 675 When defining/executing macro, inserts macro counter and increments
 676 the counter with ARG or 1 if missing.  With \\[universal-argument],
 677 inserts previous `kmacro-counter' (but do not modify counter).
 678
 679 The macro counter can be modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
 680 The format of the counter can be modified via \\[kmacro-set-format]."
 681   (interactive "P")
 682   (if (or defining-kbd-macro executing-kbd-macro)
 683       (kmacro-insert-counter arg)
 684     (kmacro-start-macro arg)))
 685
 686
 687 ;;;###autoload
 688 (defun kmacro-end-or-call-macro (arg &optional no-repeat)
 689   "End kbd macro if currently being defined; else call last kbd macro.
 690 With numeric prefix ARG, repeat macro that many times.
 691 With \\[universal-argument], call second macro in macro ring."
 692   (interactive "P")
 693   (cond
 694    (defining-kbd-macro
 695      (if kmacro-call-repeat-key
 696          (kmacro-call-macro arg no-repeat t)
 697        (kmacro-end-macro arg)))
 698    ((and (eq this-command 'kmacro-view-macro)  ;; We are in repeat mode!
 699          kmacro-view-last-item)
 700     (kmacro-exec-ring-item (car kmacro-view-last-item) arg))
 701    ((and arg (listp arg))
 702     (kmacro-call-ring-2nd 1))
 703    (t
 704     (kmacro-call-macro arg no-repeat))))
 705
 706
 707 (defun kmacro-end-or-call-macro-repeat (arg)
 708   "As `kmacro-end-or-call-macro' but allows repeat without repeating prefix."
 709   (interactive "P")
 710   (let ((keys (kmacro-get-repeat-prefix)))
 711     (kmacro-end-or-call-macro arg t)
 712     (if keys
 713         (kmacro-repeat-on-last-key keys))))
 714
 715 (put 'kmacro-end-or-call-macro-repeat 'kmacro-repeat 'head)
 716
 717
 718 ;;;###autoload
 719 (defun kmacro-end-and-call-macro (arg &optional no-repeat)
 720   "Call last keyboard macro, ending it first if currently being defined.
 721 With numeric prefix ARG, repeat macro that many times.
 722 Zero argument means repeat until there is an error.
 723
 724 To give a macro a permanent name, so you can call it
 725 even after defining other macros, use \\[kmacro-name-last-macro]."
 726   (interactive "P")
 727   (if defining-kbd-macro
 728       (kmacro-end-macro nil))
 729   (kmacro-call-macro arg no-repeat))
 730
 731
 732 ;;;###autoload
 733 (defun kmacro-end-call-mouse (event)
 734   "Move point to the position clicked with the mouse and call last kbd macro.
 735 If kbd macro currently being defined end it before activating it."
 736   (interactive "e")
 737   (when defining-kbd-macro
 738     (end-kbd-macro))
 739   (mouse-set-point event)
 740   (kmacro-call-macro nil t))
 741
 742
 743 ;;; Misc. commands
 744
 745 ;; An idea for macro bindings:
 746 ;; Create a separate keymap installed as a minor-mode keymap (e.g. in
 747 ;; the emulation-mode-map-alists) in which macro bindings are made
 748 ;; independent of any other bindings.  When first binding is made,
 749 ;; the kemap is created, installed, and enabled.  Key seq. C-x C-k +
 750 ;; can then be used to toggle the use of this keymap on and off.
 751 ;; This means that it would be safe(r) to bind ordinary keys like
 752 ;; letters and digits, provided that we inhibit the keymap while
 753 ;; executing the macro later on (but that's controversial...)
 754
 755 (defun kmacro-lambda-form (mac &optional counter format)
 756   "Create lambda form for macro bound to symbol or key."
 757   (if counter
 758       (setq mac (list mac counter format)))
 759   `(lambda (&optional arg)
 760      "Keyboard macro."
 761      (interactive "p")
 762      (kmacro-exec-ring-item ',mac arg)))
 763
 764 (defun kmacro-extract-lambda (mac)
 765   "Extract kmacro from a kmacro lambda form."
 766   (and (consp mac)
 767        (eq (car mac) 'lambda)
 768        (setq mac (assoc 'kmacro-exec-ring-item mac))
 769        (consp (cdr mac))
 770        (consp (car (cdr mac)))
 771        (consp (cdr (car (cdr mac))))
 772        (setq mac (car (cdr (car (cdr mac)))))
 773        (listp mac)
 774        (= (length mac) 3)
 775        (arrayp (car mac))
 776        mac))
 777
 778
 779 (defun kmacro-bind-to-key (arg)
 780   "When not defining or executing a macro, offer to bind last macro to a key.
 781 The key sequences [C-x C-k 0] through [C-x C-k 9] and [C-x C-k A]
 782 through [C-x C-k Z] are reserved for user bindings, and to bind to
 783 one of these sequences, just enter the digit or letter, rather than
 784 the whole sequence.
 785
 786 You can bind to any valid key sequence, but if you try to bind to
 787 a key with an existing command binding, you will be asked for
 788 confirmation whether to replace that binding.  Note that the
 789 binding is made in the `global-map' keymap, so the macro binding
 790 may be shaded by a local key binding."
 791   (interactive "p")
 792   (if (or defining-kbd-macro executing-kbd-macro)
 793       (if defining-kbd-macro
 794           (message "Cannot save macro while defining it."))
 795     (unless last-kbd-macro
 796       (error "No keyboard macro defined"))
 797     (let ((key-seq (read-key-sequence "Bind last macro to key: "))
 798           ok cmd)
 799       (when (= (length key-seq) 1)
 800         (let ((ch (aref key-seq 0)))
 801           (if (and (integerp ch)
 802                    (or (and (>= ch ?0) (<= ch ?9))
 803                        (and (>= ch ?A) (<= ch ?Z))))
 804               (setq key-seq (concat "\C-x\C-k" key-seq)
 805                     ok t))))
 806       (when (and (not (equal key-seq "\a"))
 807                  (or ok
 808                      (not (setq cmd (key-binding key-seq)))
 809                      (stringp cmd)
 810                      (vectorp cmd)
 811                      (yes-or-no-p (format "%s runs command %S.  Bind anyway? "
 812                                           (format-kbd-macro key-seq)
 813                                           cmd))))
 814         (define-key global-map key-seq
 815           (kmacro-lambda-form (kmacro-ring-head)))
 816         (message "Keyboard macro bound to %s" (format-kbd-macro key-seq))))))
 817
 818
 819 (defun kmacro-name-last-macro (symbol)
 820   "Assign a name to the last keyboard macro defined.
 821 Argument SYMBOL is the name to define.
 822 The symbol's function definition becomes the keyboard macro string.
 823 Such a \"function\" cannot be called from Lisp, but it is a valid editor command."
 824   (interactive "SName for last kbd macro: ")
 825   (or last-kbd-macro
 826       (error "No keyboard macro defined"))
 827   (and (fboundp symbol)
 828        (not (get symbol 'kmacro))
 829        (not (stringp (symbol-function symbol)))
 830        (not (vectorp (symbol-function symbol)))
 831        (error "Function %s is already defined and not a keyboard macro"
 832               symbol))
 833   (if (string-equal symbol "")
 834       (error "No command name given"))
 835   (fset symbol (kmacro-lambda-form (kmacro-ring-head)))
 836   (put symbol 'kmacro t))
 837
 838
 839 (defun kmacro-view-macro (&optional arg)
 840   "Display the last keyboard macro.
 841 If repeated, it shows previous elements in the macro ring."
 842   (interactive)
 843   (cond
 844    ((or (kmacro-ring-empty-p)
 845         (not (eq last-command 'kmacro-view-macro)))
 846     (setq kmacro-view-last-item nil))
 847    ((null kmacro-view-last-item)
 848     (setq kmacro-view-last-item kmacro-ring
 849           kmacro-view-item-no 2))
 850    ((consp kmacro-view-last-item)
 851     (setq kmacro-view-last-item (cdr kmacro-view-last-item)
 852           kmacro-view-item-no (1+ kmacro-view-item-no)))
 853    (t
 854     (setq kmacro-view-last-item nil)))
 855   (setq this-command 'kmacro-view-macro
 856         last-command this-command) ;; in case we repeat
 857   (kmacro-display (if kmacro-view-last-item
 858                       (car (car kmacro-view-last-item))
 859                     last-kbd-macro)
 860                   nil
 861                   (if kmacro-view-last-item
 862                       (concat (cond ((= kmacro-view-item-no 2) "2nd")
 863                                     ((= kmacro-view-item-no 3) "3nd")
 864                                     (t (format "%dth" kmacro-view-item-no)))
 865                               " previous macro")
 866                     "Last macro")))
 867
 868 (defun kmacro-view-macro-repeat (&optional arg)
 869   "Display the last keyboard macro.
 870 If repeated, it shows previous elements in the macro ring.
 871 To execute the displayed macro ring item without changing the macro ring,
 872 just enter C-k.
 873 This is like `kmacro-view-macro', but allows repeating macro commands
 874 without repeating the prefix."
 875   (interactive)
 876   (let ((keys (kmacro-get-repeat-prefix)))
 877     (kmacro-view-macro arg)
 878     (if (and last-kbd-macro keys)
 879         (kmacro-repeat-on-last-key keys))))
 880
 881 (put 'kmacro-view-macro-repeat 'kmacro-repeat 'ring)
 882
 883
 884 (defun kmacro-edit-macro-repeat (&optional arg)
 885   "Edit last keyboard macro."
 886   (interactive "P")
 887   (edit-kbd-macro "\r" arg))
 888
 889 (put 'kmacro-edit-macro-repeat 'kmacro-repeat 'stop)
 890
 891
 892 (defun kmacro-edit-macro (&optional arg)
 893   "As edit last keyboard macro, but without kmacro-repeat property."
 894   (interactive "P")
 895   (edit-kbd-macro "\r" arg))
 896
 897
 898 (defun kmacro-edit-lossage ()
 899   "Edit most recent 300 keystrokes as a keyboard macro."
 900   (interactive)
 901   (kmacro-push-ring)
 902   (edit-kbd-macro "\C-hl"))
 903
 904
 905 ;;; Single-step editing of keyboard macros
 906
 907 (defvar kmacro-step-edit-active)         ;; step-editing active
 908 (defvar kmacro-step-edit-new-macro)      ;; storage for new macro
 909 (defvar kmacro-step-edit-inserting)      ;; inserting into macro
 910 (defvar kmacro-step-edit-appending)      ;; append to end of macro
 911 (defvar kmacro-step-edit-replace)        ;; replace orig macro when done
 912 (defvar kmacro-step-edit-prefix-index)   ;; index of first prefix arg key
 913 (defvar kmacro-step-edit-key-index)      ;; index of current key
 914 (defvar kmacro-step-edit-action)         ;; automatic action on next pre-command hook
 915 (defvar kmacro-step-edit-help)           ;; kmacro step edit help enabled
 916 (defvar kmacro-step-edit-num-input-keys) ;; to ignore duplicate pre-command hook
 917
 918 (defvar kmacro-step-edit-map (make-sparse-keymap)
 919   "Keymap that defines the responses to questions in `kmacro-step-edit-macro'.
 920 This keymap is an extension to the `query-replace-map', allowing the
 921 following additional answers: `insert', `insert-1', `replace', `replace-1',
 922 `append', `append-end', `act-repeat', `skip-end', `skip-keep'.")
 923
 924 ;; query-replace-map answers include: `act', `skip', `act-and-show',
 925 ;; `exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
 926 ;; `automatic', `backup', `exit-prefix', and `help'.")
 927 ;; Also: `quit', `edit-replacement'
 928
 929 (set-keymap-parent kmacro-step-edit-map query-replace-map)
 930
 931 (define-key kmacro-step-edit-map "\t" 'act-repeat)
 932 (define-key kmacro-step-edit-map [tab] 'act-repeat)
 933 (define-key kmacro-step-edit-map "\C-k" 'skip-rest)
 934 (define-key kmacro-step-edit-map "c" 'automatic)
 935 (define-key kmacro-step-edit-map "f" 'skip-keep)
 936 (define-key kmacro-step-edit-map "q" 'quit)
 937 (define-key kmacro-step-edit-map "d" 'skip)
 938 (define-key kmacro-step-edit-map "\C-d" 'skip)
 939 (define-key kmacro-step-edit-map "i" 'insert)
 940 (define-key kmacro-step-edit-map "I" 'insert-1)
 941 (define-key kmacro-step-edit-map "r" 'replace)
 942 (define-key kmacro-step-edit-map "R" 'replace-1)
 943 (define-key kmacro-step-edit-map "a" 'append)
 944 (define-key kmacro-step-edit-map "A" 'append-end)
 945
 946 (defvar kmacro-step-edit-prefix-commands
 947   '(universal-argument universal-argument-more universal-argument-minus
 948                        digit-argument negative-argument)
 949   "Commands which build up a prefix arg for the current command.")
 950
 951 (defun kmacro-step-edit-prompt (macro index)
 952   ;; Show step-edit prompt
 953   (let ((keys (and (not kmacro-step-edit-appending)
 954                    index (substring macro index executing-kbd-macro-index)))
 955         (future (and (not kmacro-step-edit-appending)
 956                      (substring macro executing-kbd-macro-index)))
 957         (message-log-max nil)
 958         (curmsg (current-message)))
 959
 960     ;; TODO: Scroll macro if max-mini-window-height is too small.
 961     (message "%s"
 962              (concat
 963               (format "Macro: %s%s%s%s%s\n"
 964                       (format-kbd-macro kmacro-step-edit-new-macro 1)
 965                       (if (and kmacro-step-edit-new-macro (> (length kmacro-step-edit-new-macro) 0)) " " "")
 966                       (propertize (if keys (format-kbd-macro keys)
 967                                     (if kmacro-step-edit-appending "<APPEND>" "<INSERT>")) 'face 'region)
 968                       (if future " " "")
 969                       (if future (format-kbd-macro future) ""))
 970               (cond
 971                ((minibufferp)
 972                 (format "%s\n%s\n"
 973                           (propertize "\
 974                          minibuffer                             " 'face 'header-line)
 975                           (buffer-substring (point-min) (point-max))))
 976                (curmsg
 977                 (format "%s\n%s\n"
 978                         (propertize "\
 979                          echo area                              " 'face 'header-line)
 980                         curmsg))
 981                (t ""))
 982               (if keys
 983                   (format "%s\n%s%s %S [yn iIaArR C-k kq!] "
 984                           (propertize "\
 985 --------------Step Edit Keyboard Macro  [?: help]---------------" 'face 'mode-line)
 986                           (if kmacro-step-edit-help "\
 987  Step: y/SPC: execute next,  d/n/DEL: skip next,  f: skip but keep
 988        TAB: execute while same,  ?: toggle help
 989  Edit: i: insert,  r: replace,  a: append,  A: append at end,
 990        I/R: insert/replace with one sequence,
 991  End:  !/c: execute rest,  C-k: skip rest and save,  q/C-g: quit
 992 ----------------------------------------------------------------
 993 " "")
 994                           (propertize "Next command:" 'face 'bold)
 995                           this-command)
 996                 (propertize
 997                  (format "Type key sequence%s to insert and execute%s: "
 998                          (if (numberp kmacro-step-edit-inserting) ""  "s")
 999                          (if (numberp kmacro-step-edit-inserting) ""  " (end with C-j)"))
1000                  'face 'bold))))))
1001
1002 (defun kmacro-step-edit-query ()
1003   ;; Pre-command hook function for step-edit in "command" mode
1004   (let ((resize-mini-windows t)
1005         (max-mini-window-height kmacro-step-edit-mini-window-height)
1006         act restore-index next-index)
1007
1008     ;; Handle commands which reads additional input using read-char.
1009     (cond
1010      ((and (eq this-command 'quoted-insert)
1011            (not (eq kmacro-step-edit-action t)))
1012       ;; Find the actual end of this key sequence.
1013       ;; Must be able to backtrack in case we actually execute it.
1014       (setq restore-index executing-kbd-macro-index)
1015       (let (unread-command-events)
1016         (quoted-insert 0)
1017         (when unread-command-events
1018           (setq executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events))
1019                 next-index executing-kbd-macro-index)))))
1020
1021     ;; Query the user; stop macro exection temporarily
1022     (let ((macro executing-kbd-macro)
1023           (executing-kbd-macro nil)
1024           (defining-kbd-macro nil))
1025
1026       ;; Any action requested by previous command
1027       (cond
1028        ((eq kmacro-step-edit-action t)  ;; Reentry for actual command @ end of prefix arg.
1029         (cond
1030          ((eq this-command 'quoted-insert)
1031           (clear-this-command-keys) ;; recent-keys actually
1032           (let (unread-command-events)
1033             (quoted-insert (prefix-numeric-value current-prefix-arg))
1034             (setq kmacro-step-edit-new-macro
1035                   (vconcat kmacro-step-edit-new-macro (recent-keys)))
1036             (when unread-command-events
1037               (setq kmacro-step-edit-new-macro
1038                     (substring kmacro-step-edit-new-macro 0 (- (length unread-command-events)))
1039                     executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events)))))
1040           (setq current-prefix-arg nil
1041                 prefix-arg nil)
1042           (setq act 'ignore))
1043          (t
1044           (setq act 'act)))
1045         (setq kmacro-step-edit-action nil))
1046        ((eq this-command kmacro-step-edit-action)  ;; TAB -> activate while same command
1047         (setq act 'act))
1048        (t
1049         (setq kmacro-step-edit-action nil)))
1050
1051       ;; Handle prefix arg, or query user
1052       (cond
1053        (act act) ;; set above
1054        ((memq this-command kmacro-step-edit-prefix-commands)
1055         (unless kmacro-step-edit-prefix-index
1056           (setq kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1057         (setq act 'universal-argument))
1058        ((eq this-command 'universal-argument-other-key)
1059         (setq act 'universal-argument))
1060        (t
1061         (kmacro-step-edit-prompt macro (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1062         (setq act (lookup-key kmacro-step-edit-map
1063                               (vector (with-current-buffer (current-buffer) (read-event))))))))
1064
1065     ;; Resume macro execution and perform the action
1066     (cond
1067      ((eq act 'universal-argument)
1068       nil)
1069      ((cond
1070        ((eq act 'act)
1071         t)
1072        ((eq act 'act-repeat)
1073         (setq kmacro-step-edit-action this-command)
1074         t)
1075        ((eq act 'quit)
1076         (setq kmacro-step-edit-replace nil)
1077         (setq kmacro-step-edit-active 'ignore)
1078         nil)
1079        ((eq act 'skip)
1080         (setq kmacro-step-edit-prefix-index nil)
1081         nil)
1082        ((eq act 'skip-keep)
1083         (setq this-command 'ignore)
1084         t)
1085        ((eq act 'skip-rest)
1086         (setq kmacro-step-edit-active 'ignore)
1087         nil)
1088        ((memq act '(automatic exit))
1089         (setq kmacro-step-edit-active nil)
1090         (setq act t)
1091         t)
1092        ((member act '(insert-1 insert))
1093         (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1094         (setq kmacro-step-edit-inserting (if (eq act 'insert-1) 1 t))
1095         nil)
1096        ((member act '(replace-1 replace))
1097         (setq kmacro-step-edit-inserting (if (eq act 'replace-1) 1 t))
1098         (setq kmacro-step-edit-prefix-index nil)
1099         (if (= executing-kbd-macro-index (length executing-kbd-macro))
1100             (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1101                   kmacro-step-edit-appending t))
1102         nil)
1103        ((eq act 'append)
1104         (setq kmacro-step-edit-inserting t)
1105         (if (= executing-kbd-macro-index (length executing-kbd-macro))
1106             (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1107                   kmacro-step-edit-appending t))
1108         t)
1109        ((eq act 'append-end)
1110         (if (= executing-kbd-macro-index (length executing-kbd-macro))
1111             (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1112                   kmacro-step-edit-inserting t
1113                   kmacro-step-edit-appending t)
1114           (setq kmacro-step-edit-active 'append-end))
1115         (setq act t)
1116         t)
1117        ((eq act 'help)
1118         (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1119         (setq kmacro-step-edit-help (not kmacro-step-edit-help))
1120         nil)
1121        (t ;; Ignore unknown responses
1122         (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1123         nil))
1124       (if (> executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1125           (setq kmacro-step-edit-new-macro
1126                 (vconcat kmacro-step-edit-new-macro
1127                          (substring executing-kbd-macro
1128                                     (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1129                                     (if (eq act t) nil executing-kbd-macro-index)))
1130                 kmacro-step-edit-prefix-index nil))
1131       (if restore-index
1132           (setq executing-kbd-macro-index restore-index)))
1133      (t
1134       (setq this-command 'ignore)))
1135     (setq kmacro-step-edit-key-index next-index)))
1136
1137 (defun kmacro-step-edit-insert ()
1138   ;; Pre-command hook function for step-edit in "insert" mode
1139   (let ((resize-mini-windows t)
1140         (max-mini-window-height kmacro-step-edit-mini-window-height)
1141         (macro executing-kbd-macro)
1142         (executing-kbd-macro nil)
1143         (defining-kbd-macro nil)
1144         cmd keys next-index)
1145     (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1146           kmacro-step-edit-prefix-index nil)
1147     (kmacro-step-edit-prompt macro nil)
1148     ;; Now, we have read a key sequence from the macro, but we don't want
1149     ;; to execute it yet.  So push it back and read another sequence.
1150     (reset-this-command-lengths)
1151     (setq keys (read-key-sequence nil nil nil nil t))
1152     (setq cmd (key-binding keys t nil))
1153     (if (cond
1154          ((null cmd)
1155           t)
1156          ((eq cmd 'quoted-insert)
1157           (clear-this-command-keys) ;; recent-keys actually
1158           (quoted-insert (prefix-numeric-value current-prefix-arg))
1159           (setq current-prefix-arg nil
1160                 prefix-arg nil)
1161           (setq keys (vconcat keys (recent-keys)))
1162           (when (numberp kmacro-step-edit-inserting)
1163             (setq kmacro-step-edit-inserting nil)
1164             (when unread-command-events
1165               (setq keys (substring keys 0 (- (length unread-command-events)))
1166                     executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events))
1167                     next-index executing-kbd-macro-index
1168                     unread-command-events nil)))
1169           (setq cmd 'ignore)
1170           nil)
1171          ((memq cmd kmacro-step-edit-prefix-commands)
1172           (setq universal-argument-num-events 0)
1173           (reset-this-command-lengths)
1174           nil)
1175          ((eq cmd 'universal-argument-other-key)
1176           (setq kmacro-step-edit-action t)
1177           (setq universal-argument-num-events 0)
1178           (reset-this-command-lengths)
1179           (if (numberp kmacro-step-edit-inserting)
1180               (setq kmacro-step-edit-inserting nil))
1181           nil)
1182          ((numberp kmacro-step-edit-inserting)
1183           (setq kmacro-step-edit-inserting nil)
1184           nil)
1185          ((equal keys "\C-j")
1186           (setq kmacro-step-edit-inserting nil)
1187           (setq kmacro-step-edit-action nil)
1188           ;; Forget any (partial) prefix arg from next command
1189           (setq kmacro-step-edit-prefix-index nil)
1190           (reset-this-command-lengths)
1191           (setq overriding-terminal-local-map nil)
1192           (setq universal-argument-num-events nil)
1193           (setq next-index kmacro-step-edit-key-index)
1194           t)
1195          (t nil))
1196         (setq this-command 'ignore)
1197       (setq this-command cmd)
1198       (if (memq this-command '(self-insert-command digit-argument))
1199           (setq last-command-event (aref keys (1- (length keys)))))
1200       (if keys
1201           (setq kmacro-step-edit-new-macro (vconcat kmacro-step-edit-new-macro keys))))
1202     (setq kmacro-step-edit-key-index next-index)))
1203
1204 (defun kmacro-step-edit-pre-command ()
1205   (remove-hook 'post-command-hook 'kmacro-step-edit-post-command)
1206   (when kmacro-step-edit-active
1207     (cond
1208      ((eq kmacro-step-edit-active 'ignore)
1209       (setq this-command 'ignore))
1210      ((eq kmacro-step-edit-active 'append-end)
1211       (if (= executing-kbd-macro-index (length executing-kbd-macro))
1212           (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1213                 kmacro-step-edit-inserting t
1214                 kmacro-step-edit-appending t
1215                 kmacro-step-edit-active t)))
1216      ((/= kmacro-step-edit-num-input-keys num-input-keys)
1217       (if kmacro-step-edit-inserting
1218           (kmacro-step-edit-insert)
1219         (kmacro-step-edit-query))
1220       (setq kmacro-step-edit-num-input-keys num-input-keys)
1221       (if (and kmacro-step-edit-appending (not kmacro-step-edit-inserting))
1222           (setq kmacro-step-edit-appending nil
1223                 kmacro-step-edit-active 'ignore)))))
1224   (when (eq kmacro-step-edit-active t)
1225     (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)))
1226
1227 (defun kmacro-step-edit-minibuf-setup ()
1228   (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command t)
1229   (when kmacro-step-edit-active
1230     (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil t)))
1231
1232 (defun kmacro-step-edit-post-command ()
1233   (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command)
1234   (when kmacro-step-edit-active
1235     (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil nil)
1236     (if kmacro-step-edit-key-index
1237         (setq executing-kbd-macro-index kmacro-step-edit-key-index)
1238       (setq kmacro-step-edit-key-index executing-kbd-macro-index))))
1239
1240
1241 (defun kmacro-step-edit-macro ()
1242   "Step edit and execute last keyboard macro.
1243
1244 To customize possible responses, change the \"bindings\" in `kmacro-step-edit-map'."
1245   (interactive)
1246   (let ((kmacro-step-edit-active t)
1247         (kmacro-step-edit-new-macro "")
1248         (kmacro-step-edit-inserting nil)
1249         (kmacro-step-edit-appending nil)
1250         (kmacro-step-edit-replace t)
1251         (kmacro-step-edit-prefix-index nil)
1252         (kmacro-step-edit-key-index 0)
1253         (kmacro-step-edit-action nil)
1254         (kmacro-step-edit-help nil)
1255         (kmacro-step-edit-num-input-keys num-input-keys)
1256         (pre-command-hook pre-command-hook)
1257         (post-command-hook post-command-hook)
1258         (minibuffer-setup-hook minibuffer-setup-hook))
1259     (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil)
1260     (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)
1261     (add-hook 'minibuffer-setup-hook 'kmacro-step-edit-minibuf-setup t)
1262     (call-last-kbd-macro nil nil)
1263     (when (and kmacro-step-edit-replace
1264                kmacro-step-edit-new-macro
1265                (not (equal last-kbd-macro kmacro-step-edit-new-macro)))
1266       (kmacro-push-ring)
1267       (setq last-kbd-macro kmacro-step-edit-new-macro))))
1268
1269 (provide 'kmacro)
1270
1271 ;; arch-tag: d3fe0b24-ae41-47de-a4d6-41a77d5559f0
1272 ;;; kmacro.el ends here