lisp/kmacro.el

   1 ;;; kmacro.el --- enhanced keyboard macros
   2
   3 ;; Copyright (C) 2002, 2003, 2004, 2005, 2006,
   4 ;;   2007, 2008 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 and increment with ARG or 1 if missing.
 257 With \\[universal-argument], insert previous `kmacro-counter' (but 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 (null no-repeat)
 629                          (> (length (this-single-command-keys)) 1)
 630                          last-input-event))
 631         repeat-key-str)
 632     (if end-macro
 633         (kmacro-end-macro arg)
 634       (call-last-kbd-macro arg #'kmacro-loop-setup-function))
 635     (when (consp arg)
 636       (setq arg (car arg)))
 637     (when (and (or (null arg) (> arg 0))
 638                (setq repeat-key
 639                      (if (eq kmacro-call-repeat-key t)
 640                          repeat-key
 641                        kmacro-call-repeat-key)))
 642       (setq repeat-key-str (format-kbd-macro (vector repeat-key) nil))
 643       (while repeat-key
 644         (message "(Type %s to repeat macro%s)"
 645                  repeat-key-str
 646                  (if (and kmacro-call-repeat-with-arg
 647                           arg (> arg 1))
 648                      (format " %d times" arg) ""))
 649         (if (equal repeat-key (read-event))
 650             (progn
 651               (clear-this-command-keys t)
 652               (call-last-kbd-macro (and kmacro-call-repeat-with-arg arg)
 653                                    #'kmacro-loop-setup-function)
 654               (setq last-input-event nil))
 655           (setq repeat-key nil)))
 656       (when last-input-event
 657         (clear-this-command-keys t)
 658         (setq unread-command-events (list last-input-event))))))
 659
 660
 661 ;;; Combined function key bindings:
 662
 663 ;;;###autoload
 664 (defun kmacro-start-macro-or-insert-counter (arg)
 665   "Record subsequent keyboard input, defining a keyboard macro.
 666 The commands are recorded even as they are executed.
 667
 668 Sets the `kmacro-counter' to ARG (or 0 if no prefix arg) before defining the
 669 macro.
 670
 671 With \\[universal-argument], appends to current keyboard macro (keeping
 672 the current value of `kmacro-counter').
 673
 674 When defining/executing macro, inserts macro counter and increments
 675 the counter with ARG or 1 if missing.  With \\[universal-argument],
 676 inserts previous `kmacro-counter' (but do not modify counter).
 677
 678 The macro counter can be modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
 679 The format of the counter can be modified via \\[kmacro-set-format]."
 680   (interactive "P")
 681   (if (or defining-kbd-macro executing-kbd-macro)
 682       (kmacro-insert-counter arg)
 683     (kmacro-start-macro arg)))
 684
 685
 686 ;;;###autoload
 687 (defun kmacro-end-or-call-macro (arg &optional no-repeat)
 688   "End kbd macro if currently being defined; else call last kbd macro.
 689 With numeric prefix ARG, repeat macro that many times.
 690 With \\[universal-argument], call second macro in macro ring."
 691   (interactive "P")
 692   (cond
 693    (defining-kbd-macro
 694      (if kmacro-call-repeat-key
 695          (kmacro-call-macro arg no-repeat t)
 696        (kmacro-end-macro arg)))
 697    ((and (eq this-command 'kmacro-view-macro)  ;; We are in repeat mode!
 698          kmacro-view-last-item)
 699     (kmacro-exec-ring-item (car kmacro-view-last-item) arg))
 700    ((and arg (listp arg))
 701     (kmacro-call-ring-2nd 1))
 702    (t
 703     (kmacro-call-macro arg no-repeat))))
 704
 705
 706 (defun kmacro-end-or-call-macro-repeat (arg)
 707   "As `kmacro-end-or-call-macro' but allows repeat without repeating prefix."
 708   (interactive "P")
 709   (let ((keys (kmacro-get-repeat-prefix)))
 710     (kmacro-end-or-call-macro arg t)
 711     (if keys
 712         (kmacro-repeat-on-last-key keys))))
 713
 714 (put 'kmacro-end-or-call-macro-repeat 'kmacro-repeat 'head)
 715
 716
 717 ;;;###autoload
 718 (defun kmacro-end-and-call-macro (arg &optional no-repeat)
 719   "Call last keyboard macro, ending it first if currently being defined.
 720 With numeric prefix ARG, repeat macro that many times.
 721 Zero argument means repeat until there is an error.
 722
 723 To give a macro a permanent name, so you can call it
 724 even after defining other macros, use \\[kmacro-name-last-macro]."
 725   (interactive "P")
 726   (if defining-kbd-macro
 727       (kmacro-end-macro nil))
 728   (kmacro-call-macro arg no-repeat))
 729
 730
 731 ;;;###autoload
 732 (defun kmacro-end-call-mouse (event)
 733   "Move point to the position clicked with the mouse and call last kbd macro.
 734 If kbd macro currently being defined end it before activating it."
 735   (interactive "e")
 736   (when defining-kbd-macro
 737     (end-kbd-macro))
 738   (mouse-set-point event)
 739   (kmacro-call-macro nil t))
 740
 741
 742 ;;; Misc. commands
 743
 744 ;; An idea for macro bindings:
 745 ;; Create a separate keymap installed as a minor-mode keymap (e.g. in
 746 ;; the emulation-mode-map-alists) in which macro bindings are made
 747 ;; independent of any other bindings.  When first binding is made,
 748 ;; the kemap is created, installed, and enabled.  Key seq. C-x C-k +
 749 ;; can then be used to toggle the use of this keymap on and off.
 750 ;; This means that it would be safe(r) to bind ordinary keys like
 751 ;; letters and digits, provided that we inhibit the keymap while
 752 ;; executing the macro later on (but that's controversial...)
 753
 754 (defun kmacro-lambda-form (mac &optional counter format)
 755   "Create lambda form for macro bound to symbol or key."
 756   (if counter
 757       (setq mac (list mac counter format)))
 758   `(lambda (&optional arg)
 759      "Keyboard macro."
 760      (interactive "p")
 761      (kmacro-exec-ring-item ',mac arg)))
 762
 763 (defun kmacro-extract-lambda (mac)
 764   "Extract kmacro from a kmacro lambda form."
 765   (and (consp mac)
 766        (eq (car mac) 'lambda)
 767        (setq mac (assoc 'kmacro-exec-ring-item mac))
 768        (consp (cdr mac))
 769        (consp (car (cdr mac)))
 770        (consp (cdr (car (cdr mac))))
 771        (setq mac (car (cdr (car (cdr mac)))))
 772        (listp mac)
 773        (= (length mac) 3)
 774        (arrayp (car mac))
 775        mac))
 776
 777
 778 (defun kmacro-bind-to-key (arg)
 779   "When not defining or executing a macro, offer to bind last macro to a key.
 780 The key sequences [C-x C-k 0] through [C-x C-k 9] and [C-x C-k A]
 781 through [C-x C-k Z] are reserved for user bindings, and to bind to
 782 one of these sequences, just enter the digit or letter, rather than
 783 the whole sequence.
 784
 785 You can bind to any valid key sequence, but if you try to bind to
 786 a key with an existing command binding, you will be asked for
 787 confirmation whether to replace that binding.  Note that the
 788 binding is made in the `global-map' keymap, so the macro binding
 789 may be shaded by a local key binding."
 790   (interactive "p")
 791   (if (or defining-kbd-macro executing-kbd-macro)
 792       (if defining-kbd-macro
 793           (message "Cannot save macro while defining it."))
 794     (unless last-kbd-macro
 795       (error "No keyboard macro defined"))
 796     (let ((key-seq (read-key-sequence "Bind last macro to key: "))
 797           ok cmd)
 798       (when (= (length key-seq) 1)
 799         (let ((ch (aref key-seq 0)))
 800           (if (and (integerp ch)
 801                    (or (and (>= ch ?0) (<= ch ?9))
 802                        (and (>= ch ?A) (<= ch ?Z))))
 803               (setq key-seq (concat "\C-x\C-k" key-seq)
 804                     ok t))))
 805       (when (and (not (equal key-seq "\a"))
 806                  (or ok
 807                      (not (setq cmd (key-binding key-seq)))
 808                      (stringp cmd)
 809                      (vectorp cmd)
 810                      (yes-or-no-p (format "%s runs command %S.  Bind anyway? "
 811                                           (format-kbd-macro key-seq)
 812                                           cmd))))
 813         (define-key global-map key-seq
 814           (kmacro-lambda-form (kmacro-ring-head)))
 815         (message "Keyboard macro bound to %s" (format-kbd-macro key-seq))))))
 816
 817
 818 (defun kmacro-name-last-macro (symbol)
 819   "Assign a name to the last keyboard macro defined.
 820 Argument SYMBOL is the name to define.
 821 The symbol's function definition becomes the keyboard macro string.
 822 Such a \"function\" cannot be called from Lisp, but it is a valid editor command."
 823   (interactive "SName for last kbd macro: ")
 824   (or last-kbd-macro
 825       (error "No keyboard macro defined"))
 826   (and (fboundp symbol)
 827        (not (get symbol 'kmacro))
 828        (not (stringp (symbol-function symbol)))
 829        (not (vectorp (symbol-function symbol)))
 830        (error "Function %s is already defined and not a keyboard macro"
 831               symbol))
 832   (if (string-equal symbol "")
 833       (error "No command name given"))
 834   (fset symbol (kmacro-lambda-form (kmacro-ring-head)))
 835   (put symbol 'kmacro t))
 836
 837
 838 (defun kmacro-view-macro (&optional arg)
 839   "Display the last keyboard macro.
 840 If repeated, it shows previous elements in the macro ring."
 841   (interactive)
 842   (cond
 843    ((or (kmacro-ring-empty-p)
 844         (not (eq last-command 'kmacro-view-macro)))
 845     (setq kmacro-view-last-item nil))
 846    ((null kmacro-view-last-item)
 847     (setq kmacro-view-last-item kmacro-ring
 848           kmacro-view-item-no 2))
 849    ((consp kmacro-view-last-item)
 850     (setq kmacro-view-last-item (cdr kmacro-view-last-item)
 851           kmacro-view-item-no (1+ kmacro-view-item-no)))
 852    (t
 853     (setq kmacro-view-last-item nil)))
 854   (setq this-command 'kmacro-view-macro
 855         last-command this-command) ;; in case we repeat
 856   (kmacro-display (if kmacro-view-last-item
 857                       (car (car kmacro-view-last-item))
 858                     last-kbd-macro)
 859                   nil
 860                   (if kmacro-view-last-item
 861                       (concat (cond ((= kmacro-view-item-no 2) "2nd")
 862                                     ((= kmacro-view-item-no 3) "3nd")
 863                                     (t (format "%dth" kmacro-view-item-no)))
 864                               " previous macro")
 865                     "Last macro")))
 866
 867 (defun kmacro-view-macro-repeat (&optional arg)
 868   "Display the last keyboard macro.
 869 If repeated, it shows previous elements in the macro ring.
 870 To execute the displayed macro ring item without changing the macro ring,
 871 just enter C-k.
 872 This is like `kmacro-view-macro', but allows repeating macro commands
 873 without repeating the prefix."
 874   (interactive)
 875   (let ((keys (kmacro-get-repeat-prefix)))
 876     (kmacro-view-macro arg)
 877     (if (and last-kbd-macro keys)
 878         (kmacro-repeat-on-last-key keys))))
 879
 880 (put 'kmacro-view-macro-repeat 'kmacro-repeat 'ring)
 881
 882
 883 (defun kmacro-edit-macro-repeat (&optional arg)
 884   "Edit last keyboard macro."
 885   (interactive "P")
 886   (edit-kbd-macro "\r" arg))
 887
 888 (put 'kmacro-edit-macro-repeat 'kmacro-repeat 'stop)
 889
 890
 891 (defun kmacro-edit-macro (&optional arg)
 892   "As edit last keyboard macro, but without kmacro-repeat property."
 893   (interactive "P")
 894   (edit-kbd-macro "\r" arg))
 895
 896
 897 (defun kmacro-edit-lossage ()
 898   "Edit most recent 100 keystrokes as a keyboard macro."
 899   (interactive)
 900   (kmacro-push-ring)
 901   (edit-kbd-macro "\C-hl"))
 902
 903
 904 ;;; Single-step editing of keyboard macros
 905
 906 (defvar kmacro-step-edit-active)         ;; step-editing active
 907 (defvar kmacro-step-edit-new-macro)      ;; storage for new macro
 908 (defvar kmacro-step-edit-inserting)      ;; inserting into macro
 909 (defvar kmacro-step-edit-appending)      ;; append to end of macro
 910 (defvar kmacro-step-edit-replace)        ;; replace orig macro when done
 911 (defvar kmacro-step-edit-prefix-index)   ;; index of first prefix arg key
 912 (defvar kmacro-step-edit-key-index)      ;; index of current key
 913 (defvar kmacro-step-edit-action)         ;; automatic action on next pre-command hook
 914 (defvar kmacro-step-edit-help)           ;; kmacro step edit help enabled
 915 (defvar kmacro-step-edit-num-input-keys) ;; to ignore duplicate pre-command hook
 916
 917 (defvar kmacro-step-edit-map (make-sparse-keymap)
 918   "Keymap that defines the responses to questions in `kmacro-step-edit-macro'.
 919 This keymap is an extension to the `query-replace-map', allowing the
 920 following additional answers: `insert', `insert-1', `replace', `replace-1',
 921 `append', `append-end', `act-repeat', `skip-end', `skip-keep'.")
 922
 923 ;; query-replace-map answers include: `act', `skip', `act-and-show',
 924 ;; `exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
 925 ;; `automatic', `backup', `exit-prefix', and `help'.")
 926 ;; Also: `quit', `edit-replacement'
 927
 928 (set-keymap-parent kmacro-step-edit-map query-replace-map)
 929
 930 (define-key kmacro-step-edit-map "\t" 'act-repeat)
 931 (define-key kmacro-step-edit-map [tab] 'act-repeat)
 932 (define-key kmacro-step-edit-map "\C-k" 'skip-rest)
 933 (define-key kmacro-step-edit-map "c" 'automatic)
 934 (define-key kmacro-step-edit-map "f" 'skip-keep)
 935 (define-key kmacro-step-edit-map "q" 'quit)
 936 (define-key kmacro-step-edit-map "d" 'skip)
 937 (define-key kmacro-step-edit-map "\C-d" 'skip)
 938 (define-key kmacro-step-edit-map "i" 'insert)
 939 (define-key kmacro-step-edit-map "I" 'insert-1)
 940 (define-key kmacro-step-edit-map "r" 'replace)
 941 (define-key kmacro-step-edit-map "R" 'replace-1)
 942 (define-key kmacro-step-edit-map "a" 'append)
 943 (define-key kmacro-step-edit-map "A" 'append-end)
 944
 945 (defvar kmacro-step-edit-prefix-commands
 946   '(universal-argument universal-argument-more universal-argument-minus
 947                        digit-argument negative-argument)
 948   "Commands which build up a prefix arg for the current command.")
 949
 950 (defun kmacro-step-edit-prompt (macro index)
 951   ;; Show step-edit prompt
 952   (let ((keys (and (not kmacro-step-edit-appending)
 953                    index (substring macro index executing-kbd-macro-index)))
 954         (future (and (not kmacro-step-edit-appending)
 955                      (substring macro executing-kbd-macro-index)))
 956         (message-log-max nil)
 957         (curmsg (current-message)))
 958
 959     ;; TODO: Scroll macro if max-mini-window-height is too small.
 960     (message "%s"
 961              (concat
 962               (format "Macro: %s%s%s%s%s\n"
 963                       (format-kbd-macro kmacro-step-edit-new-macro 1)
 964                       (if (and kmacro-step-edit-new-macro (> (length kmacro-step-edit-new-macro) 0)) " " "")
 965                       (propertize (if keys (format-kbd-macro keys)
 966                                     (if kmacro-step-edit-appending "<APPEND>" "<INSERT>")) 'face 'region)
 967                       (if future " " "")
 968                       (if future (format-kbd-macro future) ""))
 969               (cond
 970                ((minibufferp)
 971                 (format "%s\n%s\n"
 972                           (propertize "\
 973                          minibuffer                             " 'face 'header-line)
 974                           (buffer-substring (point-min) (point-max))))
 975                (curmsg
 976                 (format "%s\n%s\n"
 977                         (propertize "\
 978                          echo area                              " 'face 'header-line)
 979                         curmsg))
 980                (t ""))
 981               (if keys
 982                   (format "%s\n%s%s %S [yn iIaArR C-k kq!] "
 983                           (propertize "\
 984 --------------Step Edit Keyboard Macro  [?: help]---------------" 'face 'mode-line)
 985                           (if kmacro-step-edit-help "\
 986  Step: y/SPC: execute next,  d/n/DEL: skip next,  f: skip but keep
 987        TAB: execute while same,  ?: toggle help
 988  Edit: i: insert,  r: replace,  a: append,  A: append at end,
 989        I/R: insert/replace with one sequence,
 990  End:  !/c: execute rest,  C-k: skip rest and save,  q/C-g: quit
 991 ----------------------------------------------------------------
 992 " "")
 993                           (propertize "Next command:" 'face 'bold)
 994                           this-command)
 995                 (propertize
 996                  (format "Type key sequence%s to insert and execute%s: "
 997                          (if (numberp kmacro-step-edit-inserting) ""  "s")
 998                          (if (numberp kmacro-step-edit-inserting) ""  " (end with C-j)"))
 999                  'face 'bold))))))
1000
1001 (defun kmacro-step-edit-query ()
1002   ;; Pre-command hook function for step-edit in "command" mode
1003   (let ((resize-mini-windows t)
1004         (max-mini-window-height kmacro-step-edit-mini-window-height)
1005         act restore-index next-index)
1006
1007     ;; Handle commands which reads additional input using read-char.
1008     (cond
1009      ((and (eq this-command 'quoted-insert)
1010            (not (eq kmacro-step-edit-action t)))
1011       ;; Find the actual end of this key sequence.
1012       ;; Must be able to backtrack in case we actually execute it.
1013       (setq restore-index executing-kbd-macro-index)
1014       (let (unread-command-events)
1015         (quoted-insert 0)
1016         (when unread-command-events
1017           (setq executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events))
1018                 next-index executing-kbd-macro-index)))))
1019
1020     ;; Query the user; stop macro exection temporarily
1021     (let ((macro executing-kbd-macro)
1022           (executing-kbd-macro nil)
1023           (defining-kbd-macro nil))
1024
1025       ;; Any action requested by previous command
1026       (cond
1027        ((eq kmacro-step-edit-action t)  ;; Reentry for actual command @ end of prefix arg.
1028         (cond
1029          ((eq this-command 'quoted-insert)
1030           (clear-this-command-keys) ;; recent-keys actually
1031           (let (unread-command-events)
1032             (quoted-insert (prefix-numeric-value current-prefix-arg))
1033             (setq kmacro-step-edit-new-macro
1034                   (vconcat kmacro-step-edit-new-macro (recent-keys)))
1035             (when unread-command-events
1036               (setq kmacro-step-edit-new-macro
1037                     (substring kmacro-step-edit-new-macro 0 (- (length unread-command-events)))
1038                     executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events)))))
1039           (setq current-prefix-arg nil
1040                 prefix-arg nil)
1041           (setq act 'ignore))
1042          (t
1043           (setq act 'act)))
1044         (setq kmacro-step-edit-action nil))
1045        ((eq this-command kmacro-step-edit-action)  ;; TAB -> activate while same command
1046         (setq act 'act))
1047        (t
1048         (setq kmacro-step-edit-action nil)))
1049
1050       ;; Handle prefix arg, or query user
1051       (cond
1052        (act act) ;; set above
1053        ((memq this-command kmacro-step-edit-prefix-commands)
1054         (unless kmacro-step-edit-prefix-index
1055           (setq kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1056         (setq act 'universal-argument))
1057        ((eq this-command 'universal-argument-other-key)
1058         (setq act 'universal-argument))
1059        (t
1060         (kmacro-step-edit-prompt macro (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1061         (setq act (lookup-key kmacro-step-edit-map
1062                               (vector (with-current-buffer (current-buffer) (read-event))))))))
1063
1064     ;; Resume macro execution and perform the action
1065     (cond
1066      ((eq act 'universal-argument)
1067       nil)
1068      ((cond
1069        ((eq act 'act)
1070         t)
1071        ((eq act 'act-repeat)
1072         (setq kmacro-step-edit-action this-command)
1073         t)
1074        ((eq act 'quit)
1075         (setq kmacro-step-edit-replace nil)
1076         (setq kmacro-step-edit-active 'ignore)
1077         nil)
1078        ((eq act 'skip)
1079         (setq kmacro-step-edit-prefix-index nil)
1080         nil)
1081        ((eq act 'skip-keep)
1082         (setq this-command 'ignore)
1083         t)
1084        ((eq act 'skip-rest)
1085         (setq kmacro-step-edit-active 'ignore)
1086         nil)
1087        ((memq act '(automatic exit))
1088         (setq kmacro-step-edit-active nil)
1089         (setq act t)
1090         t)
1091        ((member act '(insert-1 insert))
1092         (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1093         (setq kmacro-step-edit-inserting (if (eq act 'insert-1) 1 t))
1094         nil)
1095        ((member act '(replace-1 replace))
1096         (setq kmacro-step-edit-inserting (if (eq act 'replace-1) 1 t))
1097         (setq kmacro-step-edit-prefix-index nil)
1098         (if (= executing-kbd-macro-index (length executing-kbd-macro))
1099             (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1100                   kmacro-step-edit-appending t))
1101         nil)
1102        ((eq act 'append)
1103         (setq kmacro-step-edit-inserting t)
1104         (if (= executing-kbd-macro-index (length executing-kbd-macro))
1105             (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1106                   kmacro-step-edit-appending t))
1107         t)
1108        ((eq act 'append-end)
1109         (if (= executing-kbd-macro-index (length executing-kbd-macro))
1110             (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1111                   kmacro-step-edit-inserting t
1112                   kmacro-step-edit-appending t)
1113           (setq kmacro-step-edit-active 'append-end))
1114         (setq act t)
1115         t)
1116        ((eq act 'help)
1117         (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1118         (setq kmacro-step-edit-help (not kmacro-step-edit-help))
1119         nil)
1120        (t ;; Ignore unknown responses
1121         (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1122         nil))
1123       (if (> executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
1124           (setq kmacro-step-edit-new-macro
1125                 (vconcat kmacro-step-edit-new-macro
1126                          (substring executing-kbd-macro
1127                                     (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1128                                     (if (eq act t) nil executing-kbd-macro-index)))
1129                 kmacro-step-edit-prefix-index nil))
1130       (if restore-index
1131           (setq executing-kbd-macro-index restore-index)))
1132      (t
1133       (setq this-command 'ignore)))
1134     (setq kmacro-step-edit-key-index next-index)))
1135
1136 (defun kmacro-step-edit-insert ()
1137   ;; Pre-command hook function for step-edit in "insert" mode
1138   (let ((resize-mini-windows t)
1139         (max-mini-window-height kmacro-step-edit-mini-window-height)
1140         (macro executing-kbd-macro)
1141         (executing-kbd-macro nil)
1142         (defining-kbd-macro nil)
1143         cmd keys next-index)
1144     (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
1145           kmacro-step-edit-prefix-index nil)
1146     (kmacro-step-edit-prompt macro nil)
1147     ;; Now, we have read a key sequence from the macro, but we don't want
1148     ;; to execute it yet.  So push it back and read another sequence.
1149     (reset-this-command-lengths)
1150     (setq keys (read-key-sequence nil nil nil nil t))
1151     (setq cmd (key-binding keys t nil))
1152     (if (cond
1153          ((null cmd)
1154           t)
1155          ((eq cmd 'quoted-insert)
1156           (clear-this-command-keys) ;; recent-keys actually
1157           (quoted-insert (prefix-numeric-value current-prefix-arg))
1158           (setq current-prefix-arg nil
1159                 prefix-arg nil)
1160           (setq keys (vconcat keys (recent-keys)))
1161           (when (numberp kmacro-step-edit-inserting)
1162             (setq kmacro-step-edit-inserting nil)
1163             (when unread-command-events
1164               (setq keys (substring keys 0 (- (length unread-command-events)))
1165                     executing-kbd-macro-index (- executing-kbd-macro-index (length unread-command-events))
1166                     next-index executing-kbd-macro-index
1167                     unread-command-events nil)))
1168           (setq cmd 'ignore)
1169           nil)
1170          ((memq cmd kmacro-step-edit-prefix-commands)
1171           (setq universal-argument-num-events 0)
1172           (reset-this-command-lengths)
1173           nil)
1174          ((eq cmd 'universal-argument-other-key)
1175           (setq kmacro-step-edit-action t)
1176           (setq universal-argument-num-events 0)
1177           (reset-this-command-lengths)
1178           (if (numberp kmacro-step-edit-inserting)
1179               (setq kmacro-step-edit-inserting nil))
1180           nil)
1181          ((numberp kmacro-step-edit-inserting)
1182           (setq kmacro-step-edit-inserting nil)
1183           nil)
1184          ((equal keys "\C-j")
1185           (setq kmacro-step-edit-inserting nil)
1186           (setq kmacro-step-edit-action nil)
1187           ;; Forget any (partial) prefix arg from next command
1188           (setq kmacro-step-edit-prefix-index nil)
1189           (reset-this-command-lengths)
1190           (setq overriding-terminal-local-map nil)
1191           (setq universal-argument-num-events nil)
1192           (setq next-index kmacro-step-edit-key-index)
1193           t)
1194          (t nil))
1195         (setq this-command 'ignore)
1196       (setq this-command cmd)
1197       (if (memq this-command '(self-insert-command digit-argument))
1198           (setq last-command-char (aref keys (1- (length keys)))))
1199       (if keys
1200           (setq kmacro-step-edit-new-macro (vconcat kmacro-step-edit-new-macro keys))))
1201     (setq kmacro-step-edit-key-index next-index)))
1202
1203 (defun kmacro-step-edit-pre-command ()
1204   (remove-hook 'post-command-hook 'kmacro-step-edit-post-command)
1205   (when kmacro-step-edit-active
1206     (cond
1207      ((eq kmacro-step-edit-active 'ignore)
1208       (setq this-command 'ignore))
1209      ((eq kmacro-step-edit-active 'append-end)
1210       (if (= executing-kbd-macro-index (length executing-kbd-macro))
1211           (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
1212                 kmacro-step-edit-inserting t
1213                 kmacro-step-edit-appending t
1214                 kmacro-step-edit-active t)))
1215      ((/= kmacro-step-edit-num-input-keys num-input-keys)
1216       (if kmacro-step-edit-inserting
1217           (kmacro-step-edit-insert)
1218         (kmacro-step-edit-query))
1219       (setq kmacro-step-edit-num-input-keys num-input-keys)
1220       (if (and kmacro-step-edit-appending (not kmacro-step-edit-inserting))
1221           (setq kmacro-step-edit-appending nil
1222                 kmacro-step-edit-active 'ignore)))))
1223   (when (eq kmacro-step-edit-active t)
1224     (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)))
1225
1226 (defun kmacro-step-edit-minibuf-setup ()
1227   (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command t)
1228   (when kmacro-step-edit-active
1229     (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil t)))
1230
1231 (defun kmacro-step-edit-post-command ()
1232   (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command)
1233   (when kmacro-step-edit-active
1234     (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil nil)
1235     (if kmacro-step-edit-key-index
1236         (setq executing-kbd-macro-index kmacro-step-edit-key-index)
1237       (setq kmacro-step-edit-key-index executing-kbd-macro-index))))
1238
1239
1240 (defun kmacro-step-edit-macro ()
1241   "Step edit and execute last keyboard macro.
1242
1243 To customize possible responses, change the \"bindings\" in `kmacro-step-edit-map'."
1244   (interactive)
1245   (let ((kmacro-step-edit-active t)
1246         (kmacro-step-edit-new-macro "")
1247         (kmacro-step-edit-inserting nil)
1248         (kmacro-step-edit-appending nil)
1249         (kmacro-step-edit-replace t)
1250         (kmacro-step-edit-prefix-index nil)
1251         (kmacro-step-edit-key-index 0)
1252         (kmacro-step-edit-action nil)
1253         (kmacro-step-edit-help nil)
1254         (kmacro-step-edit-num-input-keys num-input-keys)
1255         (pre-command-hook pre-command-hook)
1256         (post-command-hook post-command-hook)
1257         (minibuffer-setup-hook minibuffer-setup-hook))
1258     (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil)
1259     (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)
1260     (add-hook 'minibuffer-setup-hook 'kmacro-step-edit-minibuf-setup t)
1261     (call-last-kbd-macro nil nil)
1262     (when (and kmacro-step-edit-replace
1263                kmacro-step-edit-new-macro
1264                (not (equal last-kbd-macro kmacro-step-edit-new-macro)))
1265       (kmacro-push-ring)
1266       (setq last-kbd-macro kmacro-step-edit-new-macro))))
1267
1268 (provide 'kmacro)
1269
1270 ;; arch-tag: d3fe0b24-ae41-47de-a4d6-41a77d5559f0
1271 ;;; kmacro.el ends here