lisp/kmacro.el

   1 ;;; kmacro.el --- enhanced keyboard macros
   2
   3 ;; Copyright (C) 2002-2013 Free Software Foundation, Inc.
   4
   5 ;; Author: Kim F. Storm <storm@cua.dk>
   6 ;; Keywords: keyboard convenience
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software: you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation, either version 3 of the License, or
  13 ;; (at your option) any later version.
  14
  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.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 ;;; Commentary:
  24
  25 ;; The kmacro package provides the user interface to emacs' basic
  26 ;; keyboard macro functionality.  With kmacro, two function keys are
  27 ;; dedicated to keyboard macros, by default F3 and F4.
  28
  29 ;; Note: The traditional bindings C-x (, C-x ), and C-x e are still
  30 ;; supported, but for some users these bindings are too hard to type
  31 ;; to be really useful for doing small repeated tasks.
  32
  33 ;; To start defining a keyboard macro, use F3.  To end the macro,
  34 ;; use F4, and to call the macro also use F4.  This makes it very
  35 ;; easy to repeat a macro immediately after defining it.
  36 ;;
  37 ;; You can call the macro repeatedly by pressing F4 multiple times, or
  38 ;; you can give a numeric prefix argument specifying the number of
  39 ;; times to repeat the macro.  Macro execution automatically
  40 ;; terminates when point reaches the end of the buffer or if an error
  41 ;; is signaled by ringing the bell.
  42
  43 ;; When you define a macro with F3/F4, it is automatically added to
  44 ;; the head of the "keyboard macro ring", and F4 actually executes the
  45 ;; first element of the macro ring.
  46 ;;
  47 ;; Note: an empty macro is never added to the macro ring.
  48 ;;
  49 ;; You can execute the second element on the macro ring with C-u F4 or
  50 ;; C-x C-k C-l, you can use C-x C-k C-p and C-x C-k C-n to cycle
  51 ;; through the macro ring, and you can swap the first and second
  52 ;; elements with C-x C-k C-t.  To delete the first element in the
  53 ;; macro ring, use C-x C-k C-d.
  54 ;;
  55 ;; You can also use C-x C-k C-s to start a macro, and C-x C-k C-k to
  56 ;; end it; then use C-k to execute it immediately, or C-x C-k C-k to
  57 ;; execute it later.
  58 ;;
  59 ;; In general, immediately after using C-x C-k followed by one of C-k,
  60 ;; C-l, C-p, or C-n, you can further cycle the macro ring using C-p or
  61 ;; C-n, execute the first or second macro using C-k or C-l, delete
  62 ;; the head macro with C-d, or edit the current macro with C-e without
  63 ;; repeating the C-x C-k prefix.
  64
  65 ;; If you enter F3 while defining the macro, the numeric value of
  66 ;; `kmacro-counter' is inserted using the `kmacro-counter-format', and
  67 ;; `kmacro-counter' is incremented by 1 (or the numeric prefix value
  68 ;; of F3).
  69 ;;
  70 ;; The initial value of `kmacro-counter' is 0, or the numeric prefix
  71 ;; value given to F3 when starting the macro.
  72 ;;
  73 ;; Now, each time you call the macro using F4, the current
  74 ;; value of `kmacro-counter' is inserted and incremented, making it
  75 ;; easy to insert incremental numbers in the buffer.
  76 ;;
  77 ;; Example:
  78 ;;
  79 ;; The following sequence: M-5 F3 x M-2 F3 y F4 F4 F4 F4
  80 ;; inserts the following string:  x5yx7yx9yx11y
  81
  82 ;; A macro can also be called using a mouse click, default S-mouse-3.
  83 ;; This calls the macro at the point where you click the mouse.
  84
  85 ;; You can edit the last macro using C-x C-k C-e.
  86
  87 ;; You can append to the last macro using C-u F3.
  88
  89 ;; You can set the macro counter using C-x C-k C-c, add to it using C-x C-k C-a,
  90 ;; and you can set the macro counter format with C-x C-k C-f.
  91
  92 ;; The following key bindings are performed:
  93 ;;
  94 ;;           Normal                         While defining macro
  95 ;;           ---------------------------    ------------------------------
  96 ;;  f3       Define macro                   Insert current counter value
  97 ;;           Prefix arg specifies initial   and increase counter by prefix
  98 ;;           counter value (default 0)      (default increment: 1)
  99 ;;
 100 ;;  C-u f3   APPENDs to last macro
 101 ;;
 102 ;;  f4       Call last macro                End macro
 103 ;;           Prefix arg specifies number
 104 ;;           of times to execute macro.
 105 ;;
 106 ;;  C-u f4   Swap last and head of macro ring.
 107 ;;
 108 ;;  S-mouse-3  Set point at click and       End macro and execute macro at
 109 ;;             execute last macro.          click.
 110
 111 ;;; Code:
 112
 113 ;; Customization:
 114
 115 (defgroup kmacro nil
 116   "Simplified keyboard macro user interface."
 117   :group 'keyboard
 118   :group 'convenience
 119   :version "22.1"
 120   :link '(emacs-commentary-link :tag "Commentary" "kmacro.el")
 121   :link '(emacs-library-link :tag "Lisp File" "kmacro.el"))
 122
 123 (defcustom kmacro-call-mouse-event 'S-mouse-3
 124   "The mouse event used by kmacro to call a macro.
 125 Set to nil if no mouse binding is desired."
 126   :type 'symbol
 127   :group 'kmacro)
 128
 129 (defcustom kmacro-ring-max 8
 130   "Maximum number of keyboard macros to save in macro ring."
 131   :type 'integer
 132   :group 'kmacro)
 133
 134
 135 (defcustom kmacro-execute-before-append t
 136   "Controls whether appending to a macro starts by executing the macro.
 137 If non-nil, using a single \\[universal-argument] prefix executes the macro
 138 before appending, while more than one \\[universal-argument] prefix does not
 139 execute the macro.
 140 Otherwise, a single \\[universal-argument] prefix does not execute the
 141 macro, while more than one \\[universal-argument] prefix causes the
 142 macro to be executed before appending to it."
 143   :type 'boolean
 144   :group 'kmacro)
 145
 146
 147 (defcustom kmacro-repeat-no-prefix t
 148   "Allow repeating certain macro commands without entering the C-x C-k prefix."
 149   :type 'boolean
 150   :group 'kmacro)
 151
 152 (defcustom kmacro-call-repeat-key t
 153   "Allow repeating macro call using last key or a specific key."
 154   :type '(choice (const :tag "Disabled" nil)
 155                  (const :tag "Last key" t)
 156                  (character :tag "Character" :value ?e)
 157                  (symbol :tag "Key symbol" :value RET))
 158   :group 'kmacro)
 159
 160 (defcustom kmacro-call-repeat-with-arg nil
 161   "Repeat macro call with original arg when non-nil; repeat once if nil."
 162   :type 'boolean
 163   :group 'kmacro)
 164
 165 (defcustom kmacro-step-edit-mini-window-height 0.75
 166   "Override `max-mini-window-height' when step edit keyboard macro."
 167   :type 'number
 168   :group 'kmacro)
 169
 170 ;; Keymap
 171
 172 (defvar kmacro-keymap
 173   (let ((map (make-sparse-keymap)))
 174     ;; Start, end, execute macros
 175     (define-key map "s"    'kmacro-start-macro)
 176     (define-key map "\C-s" 'kmacro-start-macro)
 177     (define-key map "\C-k" 'kmacro-end-or-call-macro-repeat)
 178     (define-key map "r"    'apply-macro-to-region-lines)
 179     (define-key map "q"    'kbd-macro-query)  ;; Like C-x q
 180
 181     ;; macro ring
 182     (define-key map "\C-n" 'kmacro-cycle-ring-next)
 183     (define-key map "\C-p" 'kmacro-cycle-ring-previous)
 184     (define-key map "\C-v" 'kmacro-view-macro-repeat)
 185     (define-key map "\C-d" 'kmacro-delete-ring-head)
 186     (define-key map "\C-t" 'kmacro-swap-ring)
 187     (define-key map "\C-l" 'kmacro-call-ring-2nd-repeat)
 188
 189     ;; macro counter
 190     (define-key map "\C-f" 'kmacro-set-format)
 191     (define-key map "\C-c" 'kmacro-set-counter)
 192     (define-key map "\C-i" 'kmacro-insert-counter)
 193     (define-key map "\C-a" 'kmacro-add-counter)
 194
 195     ;; macro editing
 196     (define-key map "\C-e" 'kmacro-edit-macro-repeat)
 197     (define-key map "\r"   'kmacro-edit-macro)
 198     (define-key map "e"    'edit-kbd-macro)
 199     (define-key map "l"    'kmacro-edit-lossage)
 200     (define-key map " "    'kmacro-step-edit-macro)
 201
 202     ;; naming and binding
 203     (define-key map "b"    'kmacro-bind-to-key)
 204     (define-key map "n"    'kmacro-name-last-macro)
 205     map)
 206   "Keymap for keyboard macro commands.")
 207 (defalias 'kmacro-keymap kmacro-keymap)
 208
 209 ;;; Provide some binding for startup:
 210 ;;;###autoload (global-set-key "\C-x(" 'kmacro-start-macro)
 211 ;;;###autoload (global-set-key "\C-x)" 'kmacro-end-macro)
 212 ;;;###autoload (global-set-key "\C-xe" 'kmacro-end-and-call-macro)
 213 ;;;###autoload (global-set-key [f3] 'kmacro-start-macro-or-insert-counter)
 214 ;;;###autoload (global-set-key [f4] 'kmacro-end-or-call-macro)
 215 ;;;###autoload (global-set-key "\C-x\C-k" 'kmacro-keymap)
 216 ;;;###autoload (autoload 'kmacro-keymap "kmacro" "Keymap for keyboard macro commands." t 'keymap)
 217
 218 (if kmacro-call-mouse-event
 219   (global-set-key (vector kmacro-call-mouse-event) 'kmacro-end-call-mouse))
 220
 221
 222 ;;; Called from keyboard-quit
 223
 224 (defun kmacro-keyboard-quit ()
 225   (or (not defining-kbd-macro)
 226       (eq defining-kbd-macro 'append)
 227       (kmacro-ring-empty-p)
 228       (kmacro-pop-ring)))
 229
 230
 231 ;;; Keyboard macro counter
 232
 233 (defvar kmacro-counter 0
 234   "Current keyboard macro counter.")
 235
 236 (defvar kmacro-default-counter-format "%d")
 237
 238 (defvar kmacro-counter-format "%d"
 239   "Current keyboard macro counter format.")
 240
 241 (defvar kmacro-counter-format-start kmacro-counter-format
 242   "Macro format at start of macro execution.")
 243
 244 (defvar kmacro-counter-value-start kmacro-counter
 245   "Macro counter at start of macro execution.")
 246
 247 (defvar kmacro-last-counter 0
 248   "Last counter inserted by key macro.")
 249
 250 (defvar kmacro-initial-counter-value nil
 251   "Initial counter value for the next keyboard macro to be defined.")
 252
 253
 254 (defun kmacro-insert-counter (arg)
 255   "Insert macro counter, then increment it by ARG.
 256 Interactively, ARG defaults to 1.  With \\[universal-argument], insert
 257 previous `kmacro-counter', and do not modify counter."
 258   (interactive "P")
 259   (if kmacro-initial-counter-value
 260       (setq kmacro-counter kmacro-initial-counter-value
 261             kmacro-initial-counter-value nil))
 262   (if (and arg (listp arg))
 263       (insert (format kmacro-counter-format kmacro-last-counter))
 264     (insert (format kmacro-counter-format kmacro-counter))
 265     (kmacro-add-counter (prefix-numeric-value arg))))
 266
 267
 268 (defun kmacro-set-format (format)
 269   "Set macro counter FORMAT."
 270   (interactive "sMacro Counter Format: ")
 271   (setq kmacro-counter-format
 272         (if (equal format "") "%d" format))
 273   ;; redefine initial macro counter if we are not executing a macro.
 274   (if (not (or defining-kbd-macro executing-kbd-macro))
 275       (setq kmacro-default-counter-format kmacro-counter-format)))
 276
 277
 278 (defun kmacro-display-counter (&optional value)
 279   "Display current counter value."
 280   (unless value (setq value kmacro-counter))
 281   (message "New macro counter value: %s (%d)" (format kmacro-counter-format value) value))
 282
 283
 284 (defun kmacro-set-counter (arg)
 285   "Set `kmacro-counter' to ARG or prompt if missing.
 286 With \\[universal-argument] prefix, reset counter to its value prior to this iteration of the macro."
 287   (interactive "NMacro counter value: ")
 288   (if (not (or defining-kbd-macro executing-kbd-macro))
 289       (kmacro-display-counter (setq kmacro-initial-counter-value arg))
 290     (setq kmacro-last-counter kmacro-counter
 291           kmacro-counter (if (and current-prefix-arg (listp current-prefix-arg))
 292                              kmacro-counter-value-start
 293                            arg))
 294     (unless executing-kbd-macro
 295       (kmacro-display-counter))))
 296
 297
 298 (defun kmacro-add-counter (arg)
 299   "Add numeric prefix arg (prompt if missing) to macro counter.
 300 With \\[universal-argument], restore previous counter value."
 301   (interactive "NAdd to macro counter: ")
 302   (if kmacro-initial-counter-value
 303       (setq kmacro-counter kmacro-initial-counter-value
 304             kmacro-initial-counter-value nil))
 305   (let ((last kmacro-last-counter))
 306     (setq kmacro-last-counter kmacro-counter
 307           kmacro-counter (if (and current-prefix-arg (listp current-prefix-arg))
 308                              last
 309                            kmacro-counter (+ kmacro-counter arg))))
 310   (unless executing-kbd-macro
 311     (kmacro-display-counter)))
 312
 313
 314 (defun kmacro-loop-setup-function ()
 315   "Function called prior to each iteration of macro."
 316   ;; Restore macro counter format to initial format, so it is ok to change
 317   ;; counter format in the macro without restoring it.
 318   (setq kmacro-counter-format kmacro-counter-format-start)
 319   ;; Save initial counter value so we can restore it with C-u kmacro-set-counter.
 320   (setq kmacro-counter-value-start kmacro-counter)
 321   ;; Return non-nil to continue execution.
 322   t)
 323
 324
 325 ;;; Keyboard macro ring
 326
 327 (defvar kmacro-ring nil
 328   "The keyboard macro ring.
 329 Each element is a list (MACRO COUNTER FORMAT).  Actually, the head of
 330 the macro ring (when defining or executing) is not stored in the ring;
 331 instead it is available in the variables `last-kbd-macro', `kmacro-counter',
 332 and `kmacro-counter-format'.")
 333
 334 ;; Remember what we are currently looking at with kmacro-view-macro.
 335
 336 (defvar kmacro-view-last-item nil)
 337 (defvar kmacro-view-item-no 0)
 338
 339
 340 (defun kmacro-ring-head ()
 341   "Return pseudo head element in macro ring."
 342   (and last-kbd-macro
 343        (list last-kbd-macro kmacro-counter kmacro-counter-format-start)))
 344
 345
 346 (defun kmacro-push-ring (&optional elt)
 347   "Push ELT or current macro onto `kmacro-ring'."
 348   (when (setq elt (or elt (kmacro-ring-head)))
 349     (let ((history-delete-duplicates nil))
 350       (add-to-history 'kmacro-ring elt kmacro-ring-max))))
 351
 352
 353 (defun kmacro-split-ring-element (elt)
 354   (setq last-kbd-macro (car elt)
 355         kmacro-counter (nth 1 elt)
 356         kmacro-counter-format-start (nth 2 elt)))
 357
 358
 359 (defun kmacro-pop-ring1 (&optional raw)
 360   "Pop head element off macro ring (no check).
 361 Non-nil arg RAW means just return raw first element."
 362   (prog1 (car kmacro-ring)
 363     (unless raw
 364       (kmacro-split-ring-element (car kmacro-ring)))
 365     (setq kmacro-ring (cdr kmacro-ring))))
 366
 367
 368 (defun kmacro-pop-ring (&optional raw)
 369   "Pop head element off macro ring.
 370 Non-nil arg RAW means just return raw first element."
 371   (unless (kmacro-ring-empty-p)
 372     (kmacro-pop-ring1 raw)))
 373
 374
 375 (defun kmacro-ring-empty-p (&optional none)
 376   "Tell user and return t if `last-kbd-macro' is nil or `kmacro-ring' is empty.
 377 Check only `last-kbd-macro' if optional arg NONE is non-nil."
 378   (while (and (null last-kbd-macro) kmacro-ring)
 379     (kmacro-pop-ring1))
 380   (cond
 381    ((null last-kbd-macro)
 382     (message "No keyboard macro defined.")
 383     t)
 384    ((and (null none) (null kmacro-ring))
 385     (message "Only one keyboard macro defined.")
 386     t)
 387    (t nil)))
 388
 389
 390 (defun kmacro-display (macro &optional trunc descr empty)
 391   "Display a keyboard MACRO.
 392 Optional arg TRUNC non-nil specifies to limit width of macro to 60 chars.
 393 Optional arg DESCR is descriptive text for macro; default is \"Macro:\".
 394 Optional arg EMPTY is message to print if no macros are defined."
 395   (if macro
 396       (let* ((x 60)
 397              (m (format-kbd-macro macro))
 398              (l (length m))
 399              (z (and trunc (> l x))))
 400         (message "%s%s: %s%s" (or descr "Macro")
 401                  (if (= kmacro-counter 0) ""
 402                    (format " [%s]"
 403                            (format kmacro-counter-format-start kmacro-counter)))
 404                  (if z (substring m 0 (1- x)) m) (if z "..." "")))
 405     (message "%s" (or empty "No keyboard macros defined"))))
 406
 407
 408 (defun kmacro-repeat-on-last-key (keys)
 409   "Process kmacro commands keys immediately after cycling the ring."
 410   (setq keys (vconcat keys))
 411   (let ((n (1- (length keys)))
 412         cmd done repeat)
 413     (while (and last-kbd-macro
 414                 (not done)
 415                 (aset keys n (read-event))
 416                 (setq cmd (key-binding keys t))
 417                 (setq repeat (get cmd 'kmacro-repeat)))
 418       (clear-this-command-keys t)
 419       (cond
 420        ((eq repeat 'ring)
 421         (if kmacro-ring
 422             (let ((kmacro-repeat-no-prefix nil))
 423               (funcall cmd nil))
 424           (kmacro-display last-kbd-macro t)))
 425        ((eq repeat 'head)
 426         (let ((kmacro-repeat-no-prefix nil))
 427           (funcall cmd nil)))
 428        ((eq repeat 'stop)
 429         (funcall cmd nil)
 430         (setq done t)))
 431       (setq last-input-event nil)))
 432   (when last-input-event
 433     (clear-this-command-keys t)
 434     (setq unread-command-events (list last-input-event))))
 435
 436
 437 (defun kmacro-get-repeat-prefix ()
 438   (let (keys)
 439     (and kmacro-repeat-no-prefix
 440          (setq keys (this-single-command-keys))
 441          (> (length keys) 1)
 442          keys)))
 443
 444
 445 ;;;###autoload
 446 (defun kmacro-exec-ring-item (item arg)
 447   "Execute item ITEM from the macro ring."
 448   ;; Use counter and format specific to the macro on the ring!
 449   (let ((kmacro-counter (nth 1 item))
 450         (kmacro-counter-format-start (nth 2 item)))
 451     (execute-kbd-macro (car item) arg #'kmacro-loop-setup-function)
 452     (setcar (cdr item) kmacro-counter)))
 453
 454
 455 (defun kmacro-call-ring-2nd (arg)
 456   "Execute second keyboard macro in macro ring."
 457   (interactive "P")
 458   (unless (kmacro-ring-empty-p)
 459     (kmacro-exec-ring-item (car kmacro-ring) arg)))
 460
 461
 462 (defun kmacro-call-ring-2nd-repeat (arg)
 463   "Execute second keyboard macro in macro ring.
 464 This is like `kmacro-call-ring-2nd', but allows repeating macro commands
 465 without repeating the prefix."
 466   (interactive "P")
 467   (let ((keys (kmacro-get-repeat-prefix)))
 468     (kmacro-call-ring-2nd arg)
 469     (if (and kmacro-ring keys)
 470         (kmacro-repeat-on-last-key keys))))
 471
 472 (put 'kmacro-call-ring-2nd-repeat 'kmacro-repeat 'head)
 473
 474
 475 (defun kmacro-view-ring-2nd ()
 476   "Display the current head of the keyboard macro ring."
 477   (interactive)
 478   (unless (kmacro-ring-empty-p)
 479     (kmacro-display (car (car kmacro-ring)) "2nd macro")))
 480
 481
 482 (defun kmacro-cycle-ring-next (&optional _arg)
 483   "Move to next keyboard macro in keyboard macro ring.
 484 Displays the selected macro in the echo area."
 485   (interactive)
 486   (unless (kmacro-ring-empty-p)
 487     (kmacro-push-ring)
 488     (let* ((keys (kmacro-get-repeat-prefix))
 489            (len (length kmacro-ring))
 490            (tail (nthcdr (- len 2) kmacro-ring))
 491            (elt (car (cdr tail))))
 492       (setcdr tail nil)
 493       (kmacro-split-ring-element elt)
 494       (kmacro-display last-kbd-macro t)
 495       (if keys
 496           (kmacro-repeat-on-last-key keys)))))
 497
 498 (put 'kmacro-cycle-ring-next 'kmacro-repeat 'ring)
 499
 500
 501 (defun kmacro-cycle-ring-previous (&optional _arg)
 502   "Move to previous keyboard macro in keyboard macro ring.
 503 Displays the selected macro in the echo area."
 504   (interactive)
 505   (unless (kmacro-ring-empty-p)
 506     (let ((keys (kmacro-get-repeat-prefix))
 507           (cur (kmacro-ring-head)))
 508       (kmacro-pop-ring1)
 509       (if kmacro-ring
 510           (nconc kmacro-ring (list cur))
 511         (setq kmacro-ring (list cur)))
 512       (kmacro-display last-kbd-macro t)
 513       (if keys
 514           (kmacro-repeat-on-last-key keys)))))
 515
 516 (put 'kmacro-cycle-ring-previous 'kmacro-repeat 'ring)
 517
 518
 519 (defun kmacro-swap-ring ()
 520   "Swap first two elements on keyboard macro ring."
 521   (interactive)
 522   (unless (kmacro-ring-empty-p)
 523     (let ((cur (kmacro-ring-head)))
 524       (kmacro-pop-ring1)
 525       (kmacro-push-ring cur))
 526     (kmacro-display last-kbd-macro t)))
 527
 528
 529 (defun kmacro-delete-ring-head (&optional _arg)
 530   "Delete current macro from keyboard macro ring."
 531   (interactive)
 532   (unless (kmacro-ring-empty-p t)
 533     (if (null kmacro-ring)
 534         (setq last-kbd-macro nil)
 535       (kmacro-pop-ring))
 536     (kmacro-display last-kbd-macro t nil "Keyboard macro ring is now empty.")))
 537
 538 (put 'kmacro-delete-ring-head 'kmacro-repeat 'head)
 539
 540 ;;; Traditional bindings:
 541
 542
 543 ;;;###autoload
 544 (defun kmacro-start-macro (arg)
 545   "Record subsequent keyboard input, defining a keyboard macro.
 546 The commands are recorded even as they are executed.
 547 Use \\[kmacro-end-macro] to finish recording and make the macro available.
 548 Use \\[kmacro-end-and-call-macro] to execute the macro.
 549
 550 Non-nil arg (prefix arg) means append to last macro defined.
 551
 552 With \\[universal-argument] prefix, append to last keyboard macro
 553 defined.  Depending on `kmacro-execute-before-append', this may begin
 554 by re-executing the last macro as if you typed it again.
 555
 556 Otherwise, it sets `kmacro-counter' to ARG or 0 if missing before
 557 defining the macro.
 558
 559 Use \\[kmacro-insert-counter] to insert (and increment) the macro counter.
 560 The counter value can be set or modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
 561 The format of the counter can be modified via \\[kmacro-set-format].
 562
 563 Use \\[kmacro-name-last-macro] to give it a permanent name.
 564 Use \\[kmacro-bind-to-key] to bind it to a key sequence."
 565   (interactive "P")
 566   (if (or defining-kbd-macro executing-kbd-macro)
 567       (message "Already defining keyboard macro.")
 568     (let ((append (and arg (listp arg))))
 569       (unless append
 570         (if last-kbd-macro
 571             (kmacro-push-ring
 572              (list last-kbd-macro kmacro-counter kmacro-counter-format-start)))
 573         (setq kmacro-counter (or (if arg (prefix-numeric-value arg))
 574                                  kmacro-initial-counter-value
 575                                  0)
 576               kmacro-initial-counter-value nil
 577               kmacro-counter-value-start kmacro-counter
 578               kmacro-last-counter kmacro-counter
 579               kmacro-counter-format kmacro-default-counter-format
 580               kmacro-counter-format-start kmacro-default-counter-format))
 581
 582       (start-kbd-macro append
 583                        (and append
 584                             (if kmacro-execute-before-append
 585                                 (> (car arg) 4)
 586                               (= (car arg) 4))))
 587       (if (and defining-kbd-macro append)
 588           (setq defining-kbd-macro 'append)))))
 589
 590
 591 ;;;###autoload
 592 (defun kmacro-end-macro (arg)
 593   "Finish defining a keyboard macro.
 594 The definition was started by \\[kmacro-start-macro].
 595 The macro is now available for use via \\[kmacro-call-macro],
 596 or it can be given a name with \\[kmacro-name-last-macro] and then invoked
 597 under that name.
 598
 599 With numeric arg, repeat macro now that many times,
 600 counting the definition just completed as the first repetition.
 601 An argument of zero means repeat until error."
 602   (interactive "P")
 603    ;; Isearch may push the kmacro-end-macro key sequence onto the macro.
 604    ;; Just ignore it when executing the macro.
 605   (unless executing-kbd-macro
 606     (end-kbd-macro arg #'kmacro-loop-setup-function)
 607     (when (and last-kbd-macro (= (length last-kbd-macro) 0))
 608       (setq last-kbd-macro nil)
 609       (message "Ignore empty macro")
 610       ;; Don't call `kmacro-ring-empty-p' to avoid its messages.
 611       (while (and (null last-kbd-macro) kmacro-ring)
 612         (kmacro-pop-ring1)))))
 613
 614
 615 ;;;###autoload
 616 (defun kmacro-call-macro (arg &optional no-repeat end-macro)
 617   "Call the last keyboard macro that you defined with \\[kmacro-start-macro].
 618 A prefix argument serves as a repeat count.  Zero means repeat until error.
 619
 620 When you call the macro, you can call the macro again by repeating
 621 just the last key in the key sequence that you used to call this
 622 command.  See `kmacro-call-repeat-key' and `kmacro-call-repeat-with-arg'
 623 for details on how to adjust or disable this behavior.
 624
 625 To make a macro permanent so you can call it even after defining
 626 others, use \\[kmacro-name-last-macro]."
 627   (interactive "p")
 628   (let ((repeat-key (and (or (and (null no-repeat)
 629                                   (> (length (this-single-command-keys)) 1))
 630                              ;; Used when we're in the process of repeating.
 631                              (eq no-repeat 'repeating))
 632                          last-input-event)))
 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       ;; Issue a hint to the user, if the echo area isn't in use.
 644       (unless (current-message)
 645         (message "(Type %s to repeat macro%s)"
 646                  (format-kbd-macro (vector repeat-key) nil)
 647                  (if (and kmacro-call-repeat-with-arg
 648                           arg (> arg 1))
 649                      (format " %d times" arg) "")))
 650       ;; Can't use the `keep-pred' arg because this overlay keymap needs to be
 651       ;; removed during the next run of the kmacro (i.e. we need to add&remove
 652       ;; this overlay-map at each repetition).
 653       (set-temporary-overlay-map
 654        (let ((map (make-sparse-keymap)))
 655          (define-key map (vector repeat-key)
 656            `(lambda () (interactive)
 657               (kmacro-call-macro ,(and kmacro-call-repeat-with-arg arg)
 658                                  'repeating)))
 659          map)))))
 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 keymap 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
 919   (let ((map (make-sparse-keymap)))
 920     ;; query-replace-map answers include: `act', `skip', `act-and-show',
 921     ;; `exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
 922     ;; `automatic', `backup', `exit-prefix', and `help'.")
 923     ;; Also: `quit', `edit-replacement'
 924
 925     (set-keymap-parent map query-replace-map)
 926
 927     (define-key map "\t" 'act-repeat)
 928     (define-key map [tab] 'act-repeat)
 929     (define-key map "\C-k" 'skip-rest)
 930     (define-key map "c" 'automatic)
 931     (define-key map "f" 'skip-keep)
 932     (define-key map "q" 'quit)
 933     (define-key map "d" 'skip)
 934     (define-key map "\C-d" 'skip)
 935     (define-key map "i" 'insert)
 936     (define-key map "I" 'insert-1)
 937     (define-key map "r" 'replace)
 938     (define-key map "R" 'replace-1)
 939     (define-key map "a" 'append)
 940     (define-key map "A" 'append-end)
 941     map)
 942   "Keymap that defines the responses to questions in `kmacro-step-edit-macro'.
 943 This keymap is an extension to the `query-replace-map', allowing the
 944 following additional answers: `insert', `insert-1', `replace', `replace-1',
 945 `append', `append-end', `act-repeat', `skip-end', `skip-keep'.")
 946
 947 (defvar kmacro-step-edit-prefix-commands
 948   '(universal-argument universal-argument-more universal-argument-minus
 949                        digit-argument negative-argument)
 950   "Commands which build up a prefix arg for the current command.")
 951
 952 (defun kmacro-step-edit-prompt (macro index)
 953   ;; Show step-edit prompt
 954   (let ((keys (and (not kmacro-step-edit-appending)
 955                    index (substring macro index executing-kbd-macro-index)))
 956         (future (and (not kmacro-step-edit-appending)
 957                      (substring macro executing-kbd-macro-index)))
 958         (message-log-max nil)
 959         (curmsg (current-message)))
 960
 961     ;; TODO: Scroll macro if max-mini-window-height is too small.
 962     (message "%s"
 963              (concat
 964               (format "Macro: %s%s%s%s%s\n"
 965                       (format-kbd-macro kmacro-step-edit-new-macro 1)
 966                       (if (and kmacro-step-edit-new-macro (> (length kmacro-step-edit-new-macro) 0)) " " "")
 967                       (propertize (if keys (format-kbd-macro keys)
 968                                     (if kmacro-step-edit-appending "<APPEND>" "<INSERT>")) 'face 'region)
 969                       (if future " " "")
 970                       (if future (format-kbd-macro future) ""))
 971               (cond
 972                ((minibufferp)
 973                 (format "%s\n%s\n"
 974                           (propertize "\
 975                          minibuffer                             " 'face 'header-line)
 976                           (buffer-substring (point-min) (point-max))))
 977                (curmsg
 978                 (format "%s\n%s\n"
 979                         (propertize "\
 980                          echo area                              " 'face 'header-line)
 981                         curmsg))
 982                (t ""))
 983               (if keys
 984                   (format "%s\n%s%s %S [yn iIaArR C-k kq!] "
 985                           (propertize "\
 986 --------------Step Edit Keyboard Macro  [?: help]---------------" 'face 'mode-line)
 987                           (if kmacro-step-edit-help "\
 988  Step: y/SPC: execute next,  d/n/DEL: skip next,  f: skip but keep
 989        TAB: execute while same,  ?: toggle help
 990  Edit: i: insert,  r: replace,  a: append,  A: append at end,
 991        I/R: insert/replace with one sequence,
 992  End:  !/c: execute rest,  C-k: skip rest and save,  q/C-g: quit
 993 ----------------------------------------------------------------
 994 " "")
 995                           (propertize "Next command:" 'face 'bold)
 996                           this-command)
 997                 (propertize
 998                  (format "Type key sequence%s to insert and execute%s: "
 999                          (if (numberp kmacro-step-edit-inserting) ""  "s")
1000                          (if (numberp kmacro-step-edit-inserting) ""  " (end with C-j)"))
1001                  'face 'bold))))))
1002
1003 (defun kmacro-step-edit-query ()
1004   ;; Pre-command hook function for step-edit in "command" mode
1005   (let ((resize-mini-windows t)
1006         (max-mini-window-height kmacro-step-edit-mini-window-height)
1007         act restore-index next-index)
1008
1009     ;; Handle commands which reads additional input using read-char.
1010     (cond
1011      ((and (eq this-command 'quoted-insert)
1012            (not (eq kmacro-step-edit-action t)))
1013       ;; Find the actual end of this key sequence.
1014       ;; Must be able to backtrack in case we actually execute it.
1015       (setq restore-index executing-kbd-macro-index)
1016       (let (unread-command-events)
1017         (quoted-insert 0)
1018         (when unread-command-events
1019           (setq executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events))
1020                 next-index executing-kbd-macro-index)))))
1021
1022     ;; Query the user; stop macro execution temporarily.
1023     (let ((macro executing-kbd-macro)
1024           (executing-kbd-macro nil)
1025           (defining-kbd-macro nil))
1026
1027       ;; Any action requested by previous command
1028       (cond
1029        ((eq kmacro-step-edit-action t)  ;; Reentry for actual command @ end of prefix arg.
1030         (cond
1031          ((eq this-command 'quoted-insert)
1032           (clear-this-command-keys) ;; recent-keys actually
1033           (let (unread-command-events)
1034             (quoted-insert (prefix-numeric-value current-prefix-arg))
1035             (setq kmacro-step-edit-new-macro
1036                   (vconcat kmacro-step-edit-new-macro (recent-keys)))
1037             (when unread-command-events
1038               (setq kmacro-step-edit-new-macro
1039                     (substring kmacro-step-edit-new-macro 0 (- (length unread-command-events)))
1040                     executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events)))))
1041           (setq current-prefix-arg nil
1042                 prefix-arg nil)
1043           (setq act 'ignore))
1044          (t
1045           (setq act 'act)))
1046         (setq kmacro-step-edit-action nil))
1047        ((eq this-command kmacro-step-edit-action)  ;; TAB -> activate while same command
1048         (setq act 'act))
1049        (t
1050         (setq kmacro-step-edit-action nil)))
1051
1052       ;; Handle prefix arg, or query user
1053       (cond
1054        (act act) ;; set above
1055        ((memq this-command kmacro-step-edit-prefix-commands)
1056         (unless kmacro-step-edit-prefix-index
1057           (setq kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1058         (setq act 'universal-argument))
1059        ((eq this-command 'universal-argument-other-key)
1060         (setq act 'universal-argument))
1061        (t
1062         (kmacro-step-edit-prompt macro (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1063         (setq act (lookup-key kmacro-step-edit-map
1064                               (vector (with-current-buffer (current-buffer) (read-event))))))))
1065
1066     ;; Resume macro execution and perform the action
1067     (cond
1068      ((eq act 'universal-argument)
1069       nil)
1070      ((cond
1071        ((eq act 'act)
1072         t)
1073        ((eq act 'act-repeat)
1074         (setq kmacro-step-edit-action this-command)
1075         t)
1076        ((eq act 'quit)
1077         (setq kmacro-step-edit-replace nil)
1078         (setq kmacro-step-edit-active 'ignore)
1079         nil)
1080        ((eq act 'skip)
1081         (setq kmacro-step-edit-prefix-index nil)
1082         nil)
1083        ((eq act 'skip-keep)
1084         (setq this-command 'ignore)
1085         t)
1086        ((eq act 'skip-rest)
1087         (setq kmacro-step-edit-active 'ignore)
1088         nil)
1089        ((memq act '(automatic exit))
1090         (setq kmacro-step-edit-active nil)
1091         (setq act t)
1092         t)
1093        ((member act '(insert-1 insert))
1094         (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1095         (setq kmacro-step-edit-inserting (if (eq act 'insert-1) 1 t))
1096         nil)
1097        ((member act '(replace-1 replace))
1098         (setq kmacro-step-edit-inserting (if (eq act 'replace-1) 1 t))
1099         (setq kmacro-step-edit-prefix-index nil)
1100         (if (= executing-kbd-macro-index (length executing-kbd-macro))
1101             (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1102                   kmacro-step-edit-appending t))
1103         nil)
1104        ((eq act 'append)
1105         (setq kmacro-step-edit-inserting t)
1106         (if (= executing-kbd-macro-index (length executing-kbd-macro))
1107             (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1108                   kmacro-step-edit-appending t))
1109         t)
1110        ((eq act 'append-end)
1111         (if (= executing-kbd-macro-index (length executing-kbd-macro))
1112             (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1113                   kmacro-step-edit-inserting t
1114                   kmacro-step-edit-appending t)
1115           (setq kmacro-step-edit-active 'append-end))
1116         (setq act t)
1117         t)
1118        ((eq act 'help)
1119         (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1120         (setq kmacro-step-edit-help (not kmacro-step-edit-help))
1121         nil)
1122        (t ;; Ignore unknown responses
1123         (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1124         nil))
1125       (if (> executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1126           (setq kmacro-step-edit-new-macro
1127                 (vconcat kmacro-step-edit-new-macro
1128                          (substring executing-kbd-macro
1129                                     (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1130                                     (if (eq act t) nil executing-kbd-macro-index)))
1131                 kmacro-step-edit-prefix-index nil))
1132       (if restore-index
1133           (setq executing-kbd-macro-index restore-index)))
1134      (t
1135       (setq this-command 'ignore)))
1136     (setq kmacro-step-edit-key-index next-index)))
1137
1138 (defun kmacro-step-edit-insert ()
1139   ;; Pre-command hook function for step-edit in "insert" mode
1140   (let ((resize-mini-windows t)
1141         (max-mini-window-height kmacro-step-edit-mini-window-height)
1142         (macro executing-kbd-macro)
1143         (executing-kbd-macro nil)
1144         (defining-kbd-macro nil)
1145         cmd keys next-index)
1146     (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1147           kmacro-step-edit-prefix-index nil)
1148     (kmacro-step-edit-prompt macro nil)
1149     ;; Now, we have read a key sequence from the macro, but we don't want
1150     ;; to execute it yet.  So push it back and read another sequence.
1151     (reset-this-command-lengths)
1152     (setq keys (read-key-sequence nil nil nil nil t))
1153     (setq cmd (key-binding keys t nil))
1154     (if (cond
1155          ((null cmd)
1156           t)
1157          ((eq cmd 'quoted-insert)
1158           (clear-this-command-keys) ;; recent-keys actually
1159           (quoted-insert (prefix-numeric-value current-prefix-arg))
1160           (setq current-prefix-arg nil
1161                 prefix-arg nil)
1162           (setq keys (vconcat keys (recent-keys)))
1163           (when (numberp kmacro-step-edit-inserting)
1164             (setq kmacro-step-edit-inserting nil)
1165             (when unread-command-events
1166               (setq keys (substring keys 0 (- (length unread-command-events)))
1167                     executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events))
1168                     next-index executing-kbd-macro-index
1169                     unread-command-events nil)))
1170           (setq cmd 'ignore)
1171           nil)
1172          ((memq cmd kmacro-step-edit-prefix-commands)
1173           (setq universal-argument-num-events 0)
1174           (reset-this-command-lengths)
1175           nil)
1176          ((eq cmd 'universal-argument-other-key)
1177           (setq kmacro-step-edit-action t)
1178           (setq universal-argument-num-events 0)
1179           (reset-this-command-lengths)
1180           (if (numberp kmacro-step-edit-inserting)
1181               (setq kmacro-step-edit-inserting nil))
1182           nil)
1183          ((numberp kmacro-step-edit-inserting)
1184           (setq kmacro-step-edit-inserting nil)
1185           nil)
1186          ((equal keys "\C-j")
1187           (setq kmacro-step-edit-inserting nil)
1188           (setq kmacro-step-edit-action nil)
1189           ;; Forget any (partial) prefix arg from next command
1190           (setq kmacro-step-edit-prefix-index nil)
1191           (reset-this-command-lengths)
1192           (setq overriding-terminal-local-map nil)
1193           (setq universal-argument-num-events nil)
1194           (setq next-index kmacro-step-edit-key-index)
1195           t)
1196          (t nil))
1197         (setq this-command 'ignore)
1198       (setq this-command cmd)
1199       (if (memq this-command '(self-insert-command digit-argument))
1200           (setq last-command-event (aref keys (1- (length keys)))))
1201       (if keys
1202           (setq kmacro-step-edit-new-macro (vconcat kmacro-step-edit-new-macro keys))))
1203     (setq kmacro-step-edit-key-index next-index)))
1204
1205 (defun kmacro-step-edit-pre-command ()
1206   (remove-hook 'post-command-hook 'kmacro-step-edit-post-command)
1207   (when kmacro-step-edit-active
1208     (cond
1209      ((eq kmacro-step-edit-active 'ignore)
1210       (setq this-command 'ignore))
1211      ((eq kmacro-step-edit-active 'append-end)
1212       (if (= executing-kbd-macro-index (length executing-kbd-macro))
1213           (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1214                 kmacro-step-edit-inserting t
1215                 kmacro-step-edit-appending t
1216                 kmacro-step-edit-active t)))
1217      ((/= kmacro-step-edit-num-input-keys num-input-keys)
1218       (if kmacro-step-edit-inserting
1219           (kmacro-step-edit-insert)
1220         (kmacro-step-edit-query))
1221       (setq kmacro-step-edit-num-input-keys num-input-keys)
1222       (if (and kmacro-step-edit-appending (not kmacro-step-edit-inserting))
1223           (setq kmacro-step-edit-appending nil
1224                 kmacro-step-edit-active 'ignore)))))
1225   (when (eq kmacro-step-edit-active t)
1226     (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)))
1227
1228 (defun kmacro-step-edit-minibuf-setup ()
1229   (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command t)
1230   (when kmacro-step-edit-active
1231     (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil t)))
1232
1233 (defun kmacro-step-edit-post-command ()
1234   (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command)
1235   (when kmacro-step-edit-active
1236     (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil nil)
1237     (if kmacro-step-edit-key-index
1238         (setq executing-kbd-macro-index kmacro-step-edit-key-index)
1239       (setq kmacro-step-edit-key-index executing-kbd-macro-index))))
1240
1241
1242 (defun kmacro-step-edit-macro ()
1243   "Step edit and execute last keyboard macro.
1244
1245 To customize possible responses, change the \"bindings\" in `kmacro-step-edit-map'."
1246   (interactive)
1247   (let ((kmacro-step-edit-active t)
1248         (kmacro-step-edit-new-macro "")
1249         (kmacro-step-edit-inserting nil)
1250         (kmacro-step-edit-appending nil)
1251         (kmacro-step-edit-replace t)
1252         (kmacro-step-edit-prefix-index nil)
1253         (kmacro-step-edit-key-index 0)
1254         (kmacro-step-edit-action nil)
1255         (kmacro-step-edit-help nil)
1256         (kmacro-step-edit-num-input-keys num-input-keys)
1257         (pre-command-hook pre-command-hook)
1258         (post-command-hook post-command-hook)
1259         (minibuffer-setup-hook minibuffer-setup-hook))
1260     (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil)
1261     (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)
1262     (add-hook 'minibuffer-setup-hook 'kmacro-step-edit-minibuf-setup t)
1263     (call-last-kbd-macro nil nil)
1264     (when (and kmacro-step-edit-replace
1265                kmacro-step-edit-new-macro
1266                (not (equal last-kbd-macro kmacro-step-edit-new-macro)))
1267       (kmacro-push-ring)
1268       (setq last-kbd-macro kmacro-step-edit-new-macro))))
1269
1270 (provide 'kmacro)
1271
1272 ;;; kmacro.el ends here