WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp
Viewing File: /usr/share/emacs/24.3/lisp/kmacro.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:48:27 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/kmacro.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301\302\303\304\305\304\306\307\310\311\312\311\313&
\210\314\315\316\317\320\321\304\301&\210\314\322\323\324\320\325\304\301&\210\314\326\327\330\320\331\304\301&\210\314\332\327\333\320\331\304\301&\210\314\334\327\335\320\336\304\301&\210\314\337\302\340\320\331\304\301&\210\314\341\342\343\320\344\304\301&\207" [custom-declare-group kmacro nil "Simplified keyboard macro user interface." :group keyboard convenience :version "22.1" :link (emacs-commentary-link :tag "Commentary" "kmacro.el") (emacs-library-link :tag "Lisp File" "kmacro.el") custom-declare-variable kmacro-call-mouse-event 'S-mouse-3 "The mouse event used by kmacro to call a macro.\nSet to nil if no mouse binding is desired." :type symbol kmacro-ring-max 8 "Maximum number of keyboard macros to save in macro ring." integer kmacro-execute-before-append t "Controls whether appending to a macro starts by executing the macro.\nIf non-nil, using a single \\[universal-argument] prefix executes the macro\nbefore appending, while more than one \\[universal-argument] prefix does not\nexecute the macro.\nOtherwise, a single \\[universal-argument] prefix does not execute the\nmacro, while more than one \\[universal-argument] prefix causes the\nmacro to be executed before appending to it." boolean kmacro-repeat-no-prefix "Allow repeating certain macro commands without entering the C-x C-k prefix." kmacro-call-repeat-key "Allow repeating macro call using last key or a specific key." (choice (const :tag "Disabled" nil) (const :tag "Last key" t) (character :tag "Character" :value 101) (symbol :tag "Key symbol" :value RET)) kmacro-call-repeat-with-arg "Repeat macro call with original arg when non-nil; repeat once if nil." kmacro-step-edit-mini-window-height 0.75 "Override `max-mini-window-height' when step edit keyboard macro." number] 14)
#@37 Keymap for keyboard macro commands.
(defvar kmacro-keymap (byte-code "\301 \302\303\304#\210\302\305\304#\210\302\306\307#\210\302\310\311#\210\302\312\313#\210\302\314\315#\210\302\316\317#\210\302\320\321#\210\302\322\323#\210\302\324\325#\210\302\326\327#\210\302\330\331#\210\302\332\333#\210\302\334\335#\210\302\336\337#\210\302\340\341#\210\302\342\343#\210\302\344\345#\210\302\346\347#\210\302\350\351#\210\302\352\353#\210\302\354\355#\210)\207" [map make-sparse-keymap define-key "s" kmacro-start-macro "" "" kmacro-end-or-call-macro-repeat "r" apply-macro-to-region-lines "q" kbd-macro-query "" kmacro-cycle-ring-next "" kmacro-cycle-ring-previous "" kmacro-view-macro-repeat "" kmacro-delete-ring-head "" kmacro-swap-ring "\f" kmacro-call-ring-2nd-repeat "" kmacro-set-format "" kmacro-set-counter "	" kmacro-insert-counter "" kmacro-add-counter "" kmacro-edit-macro-repeat "
" kmacro-edit-macro "e" edit-kbd-macro "l" kmacro-edit-lossage " " kmacro-step-edit-macro "b" kmacro-bind-to-key "n" kmacro-name-last-macro] 4) (#$ . 2394))
(byte-code "\302\300\"\210	\203\303\304	!\305\"\210\302\207" [kmacro-keymap kmacro-call-mouse-event defalias global-set-key vector kmacro-end-call-mouse] 3)
(defalias 'kmacro-keyboard-quit #[nil "?\206\301=\206\302 \206\303 \207" [defining-kbd-macro append kmacro-ring-empty-p kmacro-pop-ring] 2])
#@33 Current keyboard macro counter.
(defvar kmacro-counter 0 (#$ . 3790))
(defvar kmacro-default-counter-format "%d")
#@40 Current keyboard macro counter format.
(defvar kmacro-counter-format "%d" (#$ . 3910))
#@43 Macro format at start of macro execution.
(defvar kmacro-counter-format-start kmacro-counter-format (#$ . 4003))
#@44 Macro counter at start of macro execution.
(defvar kmacro-counter-value-start kmacro-counter (#$ . 4122))
#@37 Last counter inserted by key macro.
(defvar kmacro-last-counter 0 (#$ . 4234))
#@66 Initial counter value for the next keyboard macro to be defined.
(defvar kmacro-initial-counter-value nil (#$ . 4319))
#@173 Insert macro counter, then increment it by ARG.
Interactively, ARG defaults to 1.  With \[universal-argument], insert
previous `kmacro-counter', and do not modify counter.
(defalias 'kmacro-insert-counter #[(arg) "\203\305\n\203\n<\203\306\f\"c\207\306	\"c\210\307\310\n!!\207" [kmacro-initial-counter-value kmacro-counter arg kmacro-counter-format kmacro-last-counter nil format kmacro-add-counter prefix-numeric-value] 3 (#$ . 4445) "P"])
#@27 Set macro counter FORMAT.
(defalias 'kmacro-set-format #[(format) "\305\232\203\n\306\202\n\206?\205	\211\207" [format kmacro-counter-format defining-kbd-macro executing-kbd-macro kmacro-default-counter-format "" "%d"] 2 (#$ . 4904) "sMacro Counter Format: "])
#@32 Display current counter value.
(defalias 'kmacro-display-counter #[(&optional value) "\204	\303\304\305\n\"#\207" [value kmacro-counter kmacro-counter-format message "New macro counter value: %s (%d)" format] 5 (#$ . 5183)])
#@151 Set `kmacro-counter' to ARG or prompt if missing.
With \[universal-argument] prefix, reset counter to its value prior to this iteration of the macro.
(defalias 'kmacro-set-counter #[(arg) "\204	\204\306\n\211!\207\f\203 <\203 \202!\n	?\205)\306 \207" [defining-kbd-macro executing-kbd-macro arg kmacro-initial-counter-value kmacro-counter kmacro-last-counter kmacro-display-counter current-prefix-arg kmacro-counter-value-start] 3 (#$ . 5421) "NMacro counter value: "])
#@122 Add numeric prefix arg (prompt if missing) to macro counter.
With \[universal-argument], restore previous counter value.
(defalias 'kmacro-add-counter #[(arg) "\203\306\n	\f\203\f<\203\202	\210	
\\)?\205(\307 \207" [kmacro-initial-counter-value kmacro-counter kmacro-last-counter last current-prefix-arg arg nil kmacro-display-counter executing-kbd-macro] 2 (#$ . 5916) "NAdd to macro counter: "])
#@51 Function called prior to each iteration of macro.
(defalias 'kmacro-loop-setup-function #[nil "\n\304\207" [kmacro-counter-format-start kmacro-counter-format kmacro-counter kmacro-counter-value-start t] 1 (#$ . 6339)])
#@273 The keyboard macro ring.
Each element is a list (MACRO COUNTER FORMAT).  Actually, the head of
the macro ring (when defining or executing) is not stored in the ring;
instead it is available in the variables `last-kbd-macro', `kmacro-counter',
and `kmacro-counter-format'.
(defvar kmacro-ring nil (#$ . 6568))
(defvar kmacro-view-last-item nil)
(defvar kmacro-view-item-no 0)
#@43 Return pseudo head element in macro ring.
(defalias 'kmacro-ring-head #[nil "\205	\nE\207" [last-kbd-macro kmacro-counter kmacro-counter-format-start] 3 (#$ . 6949)])
#@47 Push ELT or current macro onto `kmacro-ring'.
(defalias 'kmacro-push-ring #[(&optional elt) "\206\303 \211\205\304\305\306\n#)\207" [elt history-delete-duplicates kmacro-ring-max kmacro-ring-head nil add-to-history kmacro-ring] 4 (#$ . 7126)])
(defalias 'kmacro-split-ring-element #[(elt) "@A@\3048\211\207" [elt last-kbd-macro kmacro-counter kmacro-counter-format-start 2] 2])
#@98 Pop head element off macro ring (no check).
Non-nil arg RAW means just return raw first element.
(defalias 'kmacro-pop-ring1 #[(&optional raw) "@	\204\302@!\210A\207" [kmacro-ring raw kmacro-split-ring-element] 3 (#$ . 7524)])
#@87 Pop head element off macro ring.
Non-nil arg RAW means just return raw first element.
(defalias 'kmacro-pop-ring #[(&optional raw) "\301 ?\205	\302!\207" [raw kmacro-ring-empty-p kmacro-pop-ring1] 2 (#$ . 7763)])
#@139 Tell user and return t if `last-kbd-macro' is nil or `kmacro-ring' is empty.
Check only `last-kbd-macro' if optional arg NONE is non-nil.
(defalias 'kmacro-ring-empty-p #[(&optional none) "\204	\203\303 \210\202\204\304\305!\210\306\207\n\204&	\204&\304\307!\210\306\207\310\207" [last-kbd-macro kmacro-ring none kmacro-pop-ring1 message "No keyboard macro defined." t "Only one keyboard macro defined." nil] 2 (#$ . 7985)])
#@237 Display a keyboard MACRO.
Optional arg TRUNC non-nil specifies to limit width of macro to 60 chars.
Optional arg DESCR is descriptive text for macro; default is "Macro:".
Optional arg EMPTY is message to print if no macros are defined.
(defalias 'kmacro-display #[(macro &optional trunc descr empty) "\203J\306\307!\211G\f\205	V\310\311\206\312\313U\203(\314\2021\315\316\315\"\"
\203=\n\313	SO\202>\n
\203F\317\202G\314%,\207\310\320\206R\321\"\207" [macro x m l trunc z 60 format-kbd-macro message "%s%s: %s%s" "Macro" 0 "" format " [%s]" "..." "%s" "No keyboard macros defined" descr kmacro-counter kmacro-counter-format-start empty] 9 (#$ . 8429)])
#@66 Process kmacro commands keys immediately after cycling the ring.
(defalias 'kmacro-repeat-on-last-key #[(keys) "\306!\211GS\307\211\211
\203t\n\204t\f\310 I\203t\311\312\"\211\203t\313N\211\203t\314\312!\210	\315=\203Q\203I\307\307!\210)\202n\316
\312\"\210\202n	\317=\203b\307\307!\210)\202n	\320=\203n\307!\210\312\307\202,\205\204\314\312!\210C\211\207" [keys repeat done cmd n last-kbd-macro vconcat nil read-event key-binding t kmacro-repeat clear-this-command-keys ring kmacro-display head stop kmacro-ring kmacro-repeat-no-prefix last-input-event unread-command-events] 5 (#$ . 9117)])
(defalias 'kmacro-get-repeat-prefix #[nil "\302	\205\303 \211\205G\304V\205)\207" [keys kmacro-repeat-no-prefix nil this-single-command-keys 1] 2])
#@40 Execute item ITEM from the macro ring.
(defalias 'kmacro-exec-ring-item #[(item arg) "A@\3048\305@\306#\210A\n\240*\207" [item kmacro-counter-format-start kmacro-counter arg 2 execute-kbd-macro kmacro-loop-setup-function] 4 (#$ . 9918)])
#@46 Execute second keyboard macro in macro ring.
(defalias 'kmacro-call-ring-2nd #[(arg) "\302 ?\205\303@	\"\207" [kmacro-ring arg kmacro-ring-empty-p kmacro-exec-ring-item] 3 (#$ . 10169) "P"])
#@149 Execute second keyboard macro in macro ring.
This is like `kmacro-call-ring-2nd', but allows repeating macro commands
without repeating the prefix.
(defalias 'kmacro-call-ring-2nd-repeat #[(arg) "\303 \304	!\210\n\205\205\305!)\207" [keys arg kmacro-ring kmacro-get-repeat-prefix kmacro-call-ring-2nd kmacro-repeat-on-last-key] 2 (#$ . 10370) "P"])
(put 'kmacro-call-ring-2nd-repeat 'kmacro-repeat 'head)
#@54 Display the current head of the keyboard macro ring.
(defalias 'kmacro-view-ring-2nd #[nil "\301 ?\205\f\302@@\303\"\207" [kmacro-ring kmacro-ring-empty-p kmacro-display "2nd macro"] 3 (#$ . 10788) nil])
#@99 Move to next keyboard macro in keyboard macro ring.
Displays the selected macro in the echo area.
(defalias 'kmacro-cycle-ring-next #[(&optional _arg) "\306 ?\205.\307 \210\310 	G\211\311Z	\233\211A@\312\241\210\313\f!\210\314
\315\"\210\205-\316!,\207" [keys kmacro-ring len tail elt last-kbd-macro kmacro-ring-empty-p kmacro-push-ring kmacro-get-repeat-prefix 2 nil kmacro-split-ring-element kmacro-display t kmacro-repeat-on-last-key] 4 (#$ . 11000) nil])
(put 'kmacro-cycle-ring-next 'kmacro-repeat 'ring)
#@103 Move to previous keyboard macro in keyboard macro ring.
Displays the selected macro in the echo area.
(defalias 'kmacro-cycle-ring-previous #[(&optional _arg) "\304 ?\205+\305 \306 \307 \210\n\203\nC\244\210\202C\310\311\"\210	\205*\312	!*\207" [cur keys kmacro-ring last-kbd-macro kmacro-ring-empty-p kmacro-get-repeat-prefix kmacro-ring-head kmacro-pop-ring1 kmacro-display t kmacro-repeat-on-last-key] 3 (#$ . 11526) nil])
(put 'kmacro-cycle-ring-previous 'kmacro-repeat 'ring)
#@49 Swap first two elements on keyboard macro ring.
(defalias 'kmacro-swap-ring #[nil "\302 ?\205\303 \304 \210\305!\210)\306	\307\"\207" [cur last-kbd-macro kmacro-ring-empty-p kmacro-ring-head kmacro-pop-ring1 kmacro-push-ring kmacro-display t] 3 (#$ . 12025) nil])
#@48 Delete current macro from keyboard macro ring.
(defalias 'kmacro-delete-ring-head #[(&optional _arg) "\302\303!?\205\204\304\202\305 \210\306	\303\304\307$\207" [kmacro-ring last-kbd-macro kmacro-ring-empty-p t nil kmacro-pop-ring kmacro-display "Keyboard macro ring is now empty."] 5 (#$ . 12299) nil])
(put 'kmacro-delete-ring-head 'kmacro-repeat 'head)
#@939 Record subsequent keyboard input, defining a keyboard macro.
The commands are recorded even as they are executed.
Use \[kmacro-end-macro] to finish recording and make the macro available.
Use \[kmacro-end-and-call-macro] to execute the macro.

Non-nil arg (prefix arg) means append to last macro defined.

With \[universal-argument] prefix, append to last keyboard macro
defined.  Depending on `kmacro-execute-before-append', this may begin
by re-executing the last macro as if you typed it again.

Otherwise, it sets `kmacro-counter' to ARG or 0 if missing before
defining the macro.

Use \[kmacro-insert-counter] to insert (and increment) the macro counter.
The counter value can be set or modified via \[kmacro-set-counter] and \[kmacro-add-counter].
The format of the counter can be modified via \[kmacro-set-format].

Use \[kmacro-name-last-macro] to give it a permanent name.
Use \[kmacro-bind-to-key] to bind it to a key sequence.
(defalias 'kmacro-start-macro #[(arg) "\204	\203\f\306\307!\207\n\205\n<\211\204E\f\203#\310\f
E!\210\n\203-\311\n!\2063\2063\312\313

\314\211\205[\203W\n@\315V\202[\n@\315U\"\210\205h\205h\303\211)\207" [defining-kbd-macro executing-kbd-macro arg append last-kbd-macro kmacro-counter message "Already defining keyboard macro." kmacro-push-ring prefix-numeric-value 0 nil start-kbd-macro 4 kmacro-counter-format-start kmacro-initial-counter-value kmacro-counter-value-start kmacro-last-counter kmacro-default-counter-format kmacro-counter-format kmacro-execute-before-append] 5 (#$ . 12670) "P"])
#@403 Finish defining a keyboard macro.
The definition was started by \[kmacro-start-macro].
The macro is now available for use via \[kmacro-call-macro],
or it can be given a name with \[kmacro-name-last-macro] and then invoked
under that name.

With numeric arg, repeat macro now that many times,
counting the definition just completed as the first repetition.
An argument of zero means repeat until error.
(defalias 'kmacro-end-macro #[(arg) "?\205*\304	\305\"\210\n\205*\nG\306U\205*\307\310\311!\210\n?\205*\205*\312 \210\202\207" [executing-kbd-macro arg last-kbd-macro kmacro-ring end-kbd-macro kmacro-loop-setup-function 0 nil message "Ignore empty macro" kmacro-pop-ring1] 3 (#$ . 14255) "P"])
#@517 Call the last keyboard macro that you defined with \[kmacro-start-macro].
A prefix argument serves as a repeat count.  Zero means repeat until error.

When you call the macro, you can call the macro again by repeating
just the last key in the key sequence that you used to call this
command.  See `kmacro-call-repeat-key' and `kmacro-call-repeat-with-arg'
for details on how to adjust or disable this behavior.

To make a macro permanent so you can call it even after defining
others, use \[kmacro-name-last-macro].
(defalias 'kmacro-call-macro #[(arg &optional no-repeat end-macro) "\204\f\306 G\307V\204\310=\205	\203\311\f!\210\202$\312\f\313\"\210\f:\203,\f@\f\2036\f\314V\205\213
\315=\203@\n\202A
\211\205\213\316 \204l\317\320\321\322\n!\323\"\203i\f\203i\f\307V\203i\324\325\f\"\202j\326#\210\327\330 \331\322\n!\332\323\333\334\205\201\f\335BBF#\210)!)\207" [no-repeat last-input-event repeat-key end-macro arg kmacro-call-repeat-key this-single-command-keys 1 repeating kmacro-end-macro call-last-kbd-macro kmacro-loop-setup-function 0 t current-message message "(Type %s to repeat macro%s)" format-kbd-macro vector nil format " %d times" "" set-temporary-overlay-map make-sparse-keymap define-key lambda (interactive) kmacro-call-macro ('repeating) kmacro-call-repeat-with-arg map] 10 (#$ . 14968) "p"])
#@667 Record subsequent keyboard input, defining a keyboard macro.
The commands are recorded even as they are executed.

Sets the `kmacro-counter' to ARG (or 0 if no prefix arg) before defining the
macro.

With \[universal-argument], appends to current keyboard macro (keeping
the current value of `kmacro-counter').

When defining/executing macro, inserts macro counter and increments
the counter with ARG or 1 if missing.  With \[universal-argument],
inserts previous `kmacro-counter' (but do not modify counter).

The macro counter can be modified via \[kmacro-set-counter] and \[kmacro-add-counter].
The format of the counter can be modified via \[kmacro-set-format].
(defalias 'kmacro-start-macro-or-insert-counter #[(arg) "\204	\203\f\303\n!\207\304\n!\207" [defining-kbd-macro executing-kbd-macro arg kmacro-insert-counter kmacro-start-macro] 2 (#$ . 16326) "P"])
#@185 End kbd macro if currently being defined; else call last kbd macro.
With numeric prefix ARG, repeat macro that many times.
With \[universal-argument], call second macro in macro ring.
(defalias 'kmacro-end-or-call-macro #[(arg &optional no-repeat) "\203	\203\306\n\307#\207\310\n!\207\f\311=\203\"
\203\"\312
@\n\"\207\n\203/\n<\203/\313\314!\207\306\n\"\207" [defining-kbd-macro kmacro-call-repeat-key arg no-repeat this-command kmacro-view-last-item kmacro-call-macro t kmacro-end-macro kmacro-view-macro kmacro-exec-ring-item kmacro-call-ring-2nd 1] 4 (#$ . 17202) "P"])
#@75 As `kmacro-end-or-call-macro' but allows repeat without repeating prefix.
(defalias 'kmacro-end-or-call-macro-repeat #[(arg) "\302 \303	\304\"\210\205\305!)\207" [keys arg kmacro-get-repeat-prefix kmacro-end-or-call-macro t kmacro-repeat-on-last-key] 3 (#$ . 17793) "P"])
(put 'kmacro-end-or-call-macro-repeat 'kmacro-repeat 'head)
#@297 Call last keyboard macro, ending it first if currently being defined.
With numeric prefix ARG, repeat macro that many times.
Zero argument means repeat until there is an error.

To give a macro a permanent name, so you can call it
even after defining other macros, use \[kmacro-name-last-macro].
(defalias 'kmacro-end-and-call-macro #[(arg &optional no-repeat) "\203\303\304!\210\305	\n\"\207" [defining-kbd-macro arg no-repeat kmacro-end-macro nil kmacro-call-macro] 3 (#$ . 18137) "P"])
#@142 Move point to the position clicked with the mouse and call last kbd macro.
If kbd macro currently being defined end it before activating it.
(defalias 'kmacro-end-call-mouse #[(event) "\203\302 \210\303	!\210\304\305\306\"\207" [defining-kbd-macro event end-kbd-macro mouse-set-point kmacro-call-macro nil t] 3 (#$ . 18636) "e"])
#@54 Create lambda form for macro bound to symbol or key.
(defalias 'kmacro-lambda-form #[(mac &optional counter format) "\203		\nE\303\304\305\306\307\310	D\311BB\257\207" [counter mac format lambda (&optional arg) "Keyboard macro." (interactive "p") kmacro-exec-ring-item quote (arg)] 7 (#$ . 18975)])
#@43 Extract kmacro from a kmacro lambda form.
(defalias 'kmacro-extract-lambda #[(mac) ":\205H@\301=\205H\302\303\"\211\205HA:\205HA@:\205HA@A:\205HA@A@\211\205H<\205HG\304U\205H\305@!\205H\207" [mac lambda assoc kmacro-exec-ring-item 3 arrayp] 3 (#$ . 19285)])
#@590 When not defining or executing a macro, offer to bind last macro to a key.
The key sequences [C-x C-k 0] through [C-x C-k 9] and [C-x C-k A]
through [C-x C-k Z] are reserved for user bindings, and to bind to
one of these sequences, just enter the digit or letter, rather than
the whole sequence.

You can bind to any valid key sequence, but if you try to bind to
a key with an existing command binding, you will be asked for
confirmation whether to replace that binding.  Note that the
binding is made in the `global-map' keymap, so the macro binding
may be shaded by a local key binding.
(defalias 'kmacro-bind-to-key #[(_arg) "\204	\203\205\217\306\307!\207\n\204\310\311!\210\312\313!\314\211\211G\315U\203T
\316H\211 \250\203S \317Y\203? \320X\204M \321Y\203S \322X\203S\323
P\324)
\325\232?\205\216\f\204~\326
!\211\203~;\204~\327!\204~\330\331\332\333
!#!\205\216\334!
\335\336 !#\210\306\337\333
!\"+\207" [defining-kbd-macro executing-kbd-macro last-kbd-macro cmd ok key-seq message "Cannot save macro while defining it." error "No keyboard macro defined" read-key-sequence "Bind last macro to key: " nil 1 0 48 57 65 90 "" t "" key-binding vectorp yes-or-no-p format "%s runs command %S.  Bind anyway? " format-kbd-macro define-key kmacro-lambda-form kmacro-ring-head "Keyboard macro bound to %s" ch global-map] 6 (#$ . 19573) "p"])
#@238 Assign a name to the last keyboard macro defined.
Argument SYMBOL is the name to define.
The symbol's function definition becomes the keyboard macro string.
Such a "function" cannot be called from Lisp, but it is a valid editor command.
(defalias 'kmacro-name-last-macro #[(symbol) "\204\302\303!\210\304	!\203&	\305N\204&	K;\204&\306	K!\204&\302\307	\"\210	\310\230\2030\302\311!\210	\312\313 !M\210\314	\305\315#\207" [last-kbd-macro symbol error "No keyboard macro defined" fboundp kmacro vectorp "Function %s is already defined and not a keyboard macro" "" "No command name given" kmacro-lambda-form kmacro-ring-head put t] 4 (#$ . 20961) "SName for last kbd macro: "])
#@93 Display the last keyboard macro.
If repeated, it shows previous elements in the macro ring.
(defalias 'kmacro-view-macro #[(&optional _arg) "\306 \204\307=\204\310\202+	\204\n\311\202+	:\203)	AT\202+\310\307\211\312	\203:	@@\202;
\310	\203]\311U\203J\313\202X\314U\203T\315\202X\316\317\"\320P\202^\321#\207" [last-command kmacro-view-last-item kmacro-ring kmacro-view-item-no this-command last-kbd-macro kmacro-ring-empty-p kmacro-view-macro nil 2 kmacro-display "2nd" 3 "3nd" format "%dth" " previous macro" "Last macro"] 7 (#$ . 21649) nil])
#@283 Display the last keyboard macro.
If repeated, it shows previous elements in the macro ring.
To execute the displayed macro ring item without changing the macro ring,
just enter C-k.
This is like `kmacro-view-macro', but allows repeating macro commands
without repeating the prefix.
(defalias 'kmacro-view-macro-repeat #[(&optional arg) "\303 \304	!\210\n\205\205\305!)\207" [keys arg last-kbd-macro kmacro-get-repeat-prefix kmacro-view-macro kmacro-repeat-on-last-key] 2 (#$ . 22232) nil])
(put 'kmacro-view-macro-repeat 'kmacro-repeat 'ring)
#@27 Edit last keyboard macro.
(defalias 'kmacro-edit-macro-repeat #[(&optional arg) "\301\302\"\207" [arg edit-kbd-macro "
"] 3 (#$ . 22788) "P"])
(put 'kmacro-edit-macro-repeat 'kmacro-repeat 'stop)
#@66 As edit last keyboard macro, but without kmacro-repeat property.
(defalias 'kmacro-edit-macro #[(&optional arg) "\301\302\"\207" [arg edit-kbd-macro "
"] 3 (#$ . 22991) "P"])
#@54 Edit most recent 300 keystrokes as a keyboard macro.
(defalias 'kmacro-edit-lossage #[nil "\300 \210\301\302!\207" [kmacro-push-ring edit-kbd-macro "l"] 2 (#$ . 23173) nil])
#@285 Keymap that defines the responses to questions in `kmacro-step-edit-macro'.
This keymap is an extension to the `query-replace-map', allowing the
following additional answers: `insert', `insert-1', `replace', `replace-1',
`append', `append-end', `act-repeat', `skip-end', `skip-keep'.
(defvar kmacro-step-edit-map (byte-code "\302 \303	\"\210\304\305\306#\210\304\307\306#\210\304\310\311#\210\304\312\313#\210\304\314\315#\210\304\316\317#\210\304\320\321#\210\304\322\321#\210\304\323\324#\210\304\325\326#\210\304\327\330#\210\304\331\332#\210\304\333\334#\210\304\335\336#\210)\207" [map query-replace-map make-sparse-keymap set-keymap-parent define-key "	" act-repeat [tab] "" skip-rest "c" automatic "f" skip-keep "q" quit "d" skip "" "i" insert "I" insert-1 "r" replace "R" replace-1 "a" append "A" append-end] 4) (#$ . 23355))
#@63 Commands which build up a prefix arg for the current command.
(defvar kmacro-step-edit-prefix-commands '(universal-argument universal-argument-more universal-argument-minus digit-argument negative-argument) (#$ . 24214))
(defalias 'kmacro-step-edit-prompt #[(macro index) "?\205
	\205
\n	O?\205\n\306O\306\307 $%\310\311\312\313\314&\315\"&\2039&G\316V\2039\317\202:\320\321%\203G\314%!\202P\203O\322\202P\323\324\325#$\203\\\317\202]\320$\203i\314$!\202j\320&\326 \203\312\327\321\330\324\331#ed{#\202\220\f\203\217\312\327\321\332\324\331#\f#\202\220\320%\203\261\312\333\321\334\324\335#'\203\245\336\202\246\320\321\337\324\340#(%\202\316\321\312\341)\247\203\276\320\202\277\342)\247\203\311\320\202\312\343#\324\340#Q\",\207" [kmacro-step-edit-appending index macro executing-kbd-macro-index curmsg message-log-max nil current-message message "%s" format "Macro: %s%s%s%s%s\n" format-kbd-macro 1 0 " " "" propertize "<APPEND>" "<INSERT>" face region minibufferp "%s\n%s\n" "                         minibuffer                             " header-line "                         echo area                              " "%s\n%s%s %S [yn iIaArR C-k kq!] " "--------------Step Edit Keyboard Macro  [?: help]---------------" mode-line " Step: y/SPC: execute next,  d/n/DEL: skip next,  f: skip but keep\n       TAB: execute while same,  ?: toggle help\n Edit: i: insert,  r: replace,  a: append,  A: append at end,\n       I/R: insert/replace with one sequence,\n End:  !/c: execute rest,  C-k: skip rest and save,  q/C-g: quit\n----------------------------------------------------------------\n" "Next command:" bold "Type key sequence%s to insert and execute%s: " "s" " (end with C-j)" future keys kmacro-step-edit-new-macro kmacro-step-edit-help this-command kmacro-step-edit-inserting] 12])
(defalias 'kmacro-step-edit-query #[nil "\306\307\211\211&\310=\2032'\306=\2042(\307)\310\311!\210)\2031()GZ\211()*\307\211+*,'\306=\203\212&\310=\203\202\312 \210\307)\310\313-!!\210\314.\315 \".)\203v.\311)G[O.()GZ()\307\211-/\316\202\204\303\307'\202\232&'=\203\227\303\202\232\307'\203\243\210\202\337&0>\203\2711\204\26421\317\202\337&\320=\203\305\317\202\337\321,1\206\3172\"\210\3223\323rpq\210\324 )!\"+\317=\204$\303=\204\356\325=\203\371&'\202\356\326=\203\3074\3165\202!\327=\203\3071\202!\330=\203 \316&\202\356\331=\203,\3165\202!\332>\203:\3075\306\202\356\333\235\203Y1\206G2(\334=\203S\335\202T\3066\202!\336\235\203\205\337=\203i\335\202j\3066\3071(*GU\203!\314*\340\"*\3067\202!\341=\203\244\3066(*GU\203\356\314*\342\"*\3067\202\356\343=\203\313(*GU\203\303\314*\344\"*\306\21167\202\306\3435\306\202\356\345=\203\3421\206\3302(8?8\202!1\206\3512(\202!(1\206\3672V\203\314.*1\2062\306=?\205(O\".\3071\n\203$\n(\202$\316&	\2112-\207" [kmacro-step-edit-mini-window-height next-index restore-index act max-mini-window-height resize-mini-windows t nil quoted-insert 0 clear-this-command-keys prefix-numeric-value vconcat recent-keys ignore universal-argument universal-argument-other-key kmacro-step-edit-prompt lookup-key vector read-event act-repeat quit skip skip-keep skip-rest (automatic exit) (insert-1 insert) insert-1 1 (replace-1 replace) replace-1 [nil] append [nil] append-end [nil] help this-command kmacro-step-edit-action executing-kbd-macro-index unread-command-events executing-kbd-macro defining-kbd-macro macro current-prefix-arg kmacro-step-edit-new-macro prefix-arg kmacro-step-edit-prefix-commands kmacro-step-edit-prefix-index kmacro-step-edit-key-index kmacro-step-edit-map kmacro-step-edit-replace kmacro-step-edit-active kmacro-step-edit-inserting kmacro-step-edit-appending kmacro-step-edit-help] 7])
(defalias 'kmacro-step-edit-insert #[nil "\306	\307\211\211\211\211\206\307\310\307\"\210\311 \210\312\307\211\211\211\306%\313\306\307#\211\203\320\f\314=\203~\315 \210\314\316!!\210\307\211\317\320 \"\247\203y\307\203y\321G[OGZ\211\307\322\202\326\f >\203\216\321!\311 \210\202\326\f\323=\203\251\306\"\321!\311 \210\247\203\326\307\202\326\247\203\265\307\202\326\324\232\203\326\307\211\"\307\311 \210\307\211#!\322$\202\361\f\211$\325>\203\346\211GSH%\203\361\317&\"&\n\211.\207" [kmacro-step-edit-mini-window-height executing-kbd-macro next-index keys cmd defining-kbd-macro t nil kmacro-step-edit-prompt reset-this-command-lengths read-key-sequence key-binding quoted-insert clear-this-command-keys prefix-numeric-value vconcat recent-keys 0 ignore universal-argument-other-key "\n" (self-insert-command digit-argument) macro max-mini-window-height resize-mini-windows kmacro-step-edit-prefix-index kmacro-step-edit-key-index executing-kbd-macro-index current-prefix-arg prefix-arg kmacro-step-edit-inserting unread-command-events kmacro-step-edit-prefix-commands universal-argument-num-events kmacro-step-edit-action overriding-terminal-local-map this-command last-command-event kmacro-step-edit-new-macro] 9])
(defalias 'kmacro-step-edit-pre-command #[nil "\306\307\310\"\210\203T\311=\203\311\202T\312=\203/\nGU\203T\313\314\"\315\211\315\202TU\204T\f\203A\316 \210\202D\317 \210
\203T\f\204T\320\311\315=\205_\321\307\310\315#\207" [kmacro-step-edit-active this-command executing-kbd-macro-index executing-kbd-macro kmacro-step-edit-inserting kmacro-step-edit-appending remove-hook post-command-hook kmacro-step-edit-post-command ignore append-end vconcat [nil] t kmacro-step-edit-insert kmacro-step-edit-query nil add-hook kmacro-step-edit-num-input-keys num-input-keys] 5])
(defalias 'kmacro-step-edit-minibuf-setup #[nil "\301\302\303\304#\210\205\305\302\303\306\304$\207" [kmacro-step-edit-active remove-hook pre-command-hook kmacro-step-edit-pre-command t add-hook nil] 5])
(defalias 'kmacro-step-edit-post-command #[nil "\303\304\305\"\210\205\306\304\305\307\211$\210	\203	\211\207\n\211\207" [kmacro-step-edit-active kmacro-step-edit-key-index executing-kbd-macro-index remove-hook pre-command-hook kmacro-step-edit-pre-command add-hook nil] 5])
#@127 Step edit and execute last keyboard macro.

To customize possible responses, change the "bindings" in `kmacro-step-edit-map'.
(defalias 'kmacro-step-edit-macro #[nil "\306\307\310\211\306\310\311\310\211	\n\312\301\313\310#\210\312\302\314\306#\210\312\303\315\306#\210\316\310\211\"\210\205T\205T\232?\205T\317 \210\211.
\207" [num-input-keys pre-command-hook post-command-hook minibuffer-setup-hook kmacro-step-edit-num-input-keys kmacro-step-edit-help t "" nil 0 add-hook kmacro-step-edit-pre-command kmacro-step-edit-post-command kmacro-step-edit-minibuf-setup call-last-kbd-macro kmacro-push-ring kmacro-step-edit-action kmacro-step-edit-key-index kmacro-step-edit-prefix-index kmacro-step-edit-replace kmacro-step-edit-appending kmacro-step-edit-inserting kmacro-step-edit-new-macro kmacro-step-edit-active last-kbd-macro] 13 (#$ . 30520) nil])
(provide 'kmacro)
F1l3 Manager
