Current File : //usr/local/share/emacs/27.2/lisp/kmacro.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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!\210\300\302!\210\303\304\305\306\307\310\307\311\312\313\314\315\314\316&
\210\317\320\321\322\323DD\324\325\326%\210\317\327\321\322\330DD\331\325\332%\210\317\333\321\322\334DD\335\325\336%\210\317\337\321\322\340DD\341\325\336%\210\317\342\321\322\343DD\344\325\345%\210\317\346\321\322\347DD\350\325\336%\210\317\351\321\322\352DD\353\325\354%\207" [require replace cl-lib 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 funcall function #[0 "\300\207" [S-mouse-3] 1] "The mouse event used by kmacro to call a macro.\nSet to nil if no mouse binding is desired." :type symbol kmacro-ring-max #[0 "\300\207" [8] 1] "Maximum number of keyboard macros to save in macro ring." integer kmacro-execute-before-append #[0 "\300\207" [t] 1] "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 #[0 "\300\207" [t] 1] "Allow repeating certain macro commands without entering the C-x C-k prefix." kmacro-call-repeat-key #[0 "\300\207" [t] 1] "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 #[0 "\300\207" [nil] 1] "Repeat macro call with original arg when non-nil; repeat once if nil." kmacro-step-edit-mini-window-height #[0 "\300\207" [0.75] 1] "Override `max-mini-window-height' when step edit keyboard macro." number] 14)
#@37 Keymap for keyboard macro commands.
(defvar kmacro-keymap (byte-code "\300 \301\302\303#\210\301\304\303#\210\301\305\306#\210\301\307\310#\210\301\311\312#\210\301\313\314#\210\301\315\316#\210\301\317\320#\210\301\321\322#\210\301\323\324#\210\301\325\326#\210\301\327\330#\210\301\331\332#\210\301\333\334#\210\301\335\336#\210\301\337\340#\210\301\341\342#\210\301\343\344#\210\301\345\346#\210\301\347\350#\210\301\351\352#\210\301\353\354#\210\301\355\356#\210\211\207" [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 "x" kmacro-to-register] 5) (#$ . 2473))
(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 #[0 "?\206 \301=\206 \302 \206 \303 \207" [defining-kbd-macro append kmacro-ring-empty-p kmacro-pop-ring] 2])
#@238 Current keyboard macro counter.
This is normally initialized to zero when the macro is defined,
and incremented each time the value of the counter is inserted
into a buffer. See `kmacro-start-macro-or-insert-counter' for
more details.
(defvar kmacro-counter 0 (#$ . 3906))
(defvar kmacro-default-counter-format "%d")
#@97 Current keyboard macro counter format.
Can be set directly via `kmacro-set-format', which see.
(defvar kmacro-counter-format "%d" (#$ . 4231))
#@43 Macro format at start of macro execution.
(defvar kmacro-counter-format-start kmacro-counter-format (#$ . 4381))
#@44 Macro counter at start of macro execution.
(defvar kmacro-counter-value-start kmacro-counter (#$ . 4500))
#@37 Last counter inserted by key macro.
(defvar kmacro-last-counter 0 (#$ . 4612))
#@66 Initial counter value for the next keyboard macro to be defined.
(defvar kmacro-initial-counter-value nil (#$ . 4697))
#@308 Insert current value of `kmacro-counter', then increment it by ARG.
Interactively, ARG defaults to 1. With \[universal-argument], insert
the previous value of `kmacro-counter', and do not increment the
current value.
The previous value of the counter is the one it had before
the last increment.
(fn ARG)
(defalias 'kmacro-insert-counter #[257 "\203 \304\211:\203 \305\n \"c\207\305\n \"c\210\306\307!!\207" [kmacro-initial-counter-value kmacro-counter kmacro-counter-format kmacro-last-counter nil format kmacro-add-counter prefix-numeric-value] 4 (#$ . 4823) "P"])
#@60 Set the format of `kmacro-counter' to FORMAT.
(fn FORMAT)
(defalias 'kmacro-set-format #[257 "\211\304\232\203\n \305\202 \211 \206 \n?\205 \211\207" [kmacro-counter-format defining-kbd-macro executing-kbd-macro kmacro-default-counter-format "" "%d"] 3 (#$ . 5405) "sMacro Counter Format: "])
#@54 Display current counter value.
(fn &optional VALUE)
(defalias 'kmacro-display-counter #[256 "\211\204 \262\302\303\304 \"#\207" [kmacro-counter kmacro-counter-format message "New macro counter value: %s (%d)" format] 6 (#$ . 5711)])
#@189 Set the value of `kmacro-counter' to ARG, or prompt for value if no argument.
With \[universal-argument] prefix, reset counter to its value prior to this iteration of the macro.
(fn ARG)
(defalias 'kmacro-set-counter #[257 "\204 \204 \306\211!\207
\203
<\203 \202 \211 ?\205' \306 \207" [defining-kbd-macro executing-kbd-macro kmacro-initial-counter-value kmacro-counter kmacro-last-counter current-prefix-arg kmacro-display-counter kmacro-counter-value-start] 4 (#$ . 5957) "NMacro counter value: "])
#@148 Add the value of numeric prefix arg (prompt if missing) to `kmacro-counter'.
With \[universal-argument], restore previous counter value.
(fn ARG)
(defalias 'kmacro-add-counter #[257 "\203 \305\n \203 <\203 \211\202 \210 \\\210\f?\205& \306 \207" [kmacro-initial-counter-value kmacro-counter kmacro-last-counter current-prefix-arg executing-kbd-macro nil kmacro-display-counter] 4 (#$ . 6482) "NAdd to macro counter: "])
#@51 Function called prior to each iteration of macro.
(defalias 'kmacro-loop-setup-function #[0 "\n\304\207" [kmacro-counter-format-start kmacro-counter-format kmacro-counter kmacro-counter-value-start t] 1 (#$ . 6923)])
#@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 (#$ . 7150))
(defvar kmacro-view-last-item nil)
(defvar kmacro-view-item-no 0)
#@43 Return pseudo head element in macro ring.
(defalias 'kmacro-ring-head #[0 "\205 \nE\207" [last-kbd-macro kmacro-counter kmacro-counter-format-start] 3 (#$ . 7531)])
#@67 Push ELT or current macro onto `kmacro-ring'.
(fn &optional ELT)
(defalias 'kmacro-push-ring #[256 "\211\206 \302 \211\262\205 \303\304\305 #)\207" [history-delete-duplicates kmacro-ring-max kmacro-ring-head nil add-to-history kmacro-ring] 5 (#$ . 7706)])
#@12
(fn ELT)
(defalias 'kmacro-split-ring-element #[257 "\211@\211A@\3038\211\207" [last-kbd-macro kmacro-counter kmacro-counter-format-start 2] 3 (#$ . 7974)])
#@118 Pop head element off macro ring (no check).
Non-nil arg RAW means just return raw first element.
(fn &optional RAW)
(defalias 'kmacro-pop-ring1 #[256 "@\204 \301@!\210A\207" [kmacro-ring kmacro-split-ring-element] 4 (#$ . 8144)])
#@107 Pop head element off macro ring.
Non-nil arg RAW means just return raw first element.
(fn &optional RAW)
(defalias 'kmacro-pop-ring #[256 "\300 ?\205 \301!\207" [kmacro-ring-empty-p kmacro-pop-ring1] 3 (#$ . 8388)])
#@160 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.
(fn &optional NONE)
(defalias 'kmacro-ring-empty-p #[256 "\204 \203 \302 \210\202 \204 \303\304!\210\305\207\211\204& \204& \303\306!\210\305\207\307\207" [last-kbd-macro kmacro-ring kmacro-pop-ring1 message "No keyboard macro defined." t "Only one keyboard macro defined." nil] 3 (#$ . 8614)])
#@277 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.
(fn MACRO &optional TRUNC DESCR EMPTY)
(defalias 'kmacro-display #[1025 "\203F \302\303!\211G\205 \211V\304\305\206 \306\307U\203# \310\202* \311\312\311 \"\"\2039 \313\307\nS#\202; \203C \314\202D \310%\207\304\315\206M \316\"\207" [kmacro-counter kmacro-counter-format-start 60 format-kbd-macro message "%s%s: %s%s" "Macro" 0 "" format " [%s]" substring "..." "%s" "No keyboard macros defined"] 16 (#$ . 9063)])
#@77 Process kmacro commands keys immediately after cycling the ring.
(fn KEYS)
(defalias 'kmacro-repeat-on-last-key #[257 "\305!\262\211GS\306\211\211\203d \204d \307 I\203d \310\311\"\211\262\203d \312N\211\262\203d \313\311!\210\211\314\267\202_ \203F \306\306!\210)\202_ \315\311\"\210\202_ \306\306!\210)\202_ \306!\210\311\262\306\202 \266 \205s \313\311!\210 \fB\211\207" [last-kbd-macro kmacro-ring kmacro-repeat-no-prefix last-input-event unread-command-events vconcat nil read-event key-binding t kmacro-repeat clear-this-command-keys #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ring 56 head 78 stop 88)) kmacro-display] 8 (#$ . 9738)])
(defalias 'kmacro-get-repeat-prefix #[0 "\301\205 \302 \211\262\205 \211G\303V\205 \211\207" [kmacro-repeat-no-prefix nil this-single-command-keys 1] 3])
#@103 Execute item ITEM from the macro ring.
ARG is the number of times to execute the item.
(fn ITEM ARG)
(defalias 'kmacro-exec-ring-item #[514 "A@\3028\303@\304#\210A \240*\207" [kmacro-counter-format-start kmacro-counter 2 execute-kbd-macro kmacro-loop-setup-function] 6 (#$ . 10611)])
#@56 Execute second keyboard macro in macro ring.
(fn ARG)
(defalias 'kmacro-call-ring-2nd #[257 "\301 ?\205 \302@\"\207" [kmacro-ring kmacro-ring-empty-p kmacro-exec-ring-item] 4 (#$ . 10909) "P"])
#@159 Execute second keyboard macro in macro ring.
This is like `kmacro-call-ring-2nd', but allows repeating macro commands
without repeating the prefix.
(fn ARG)
(defalias 'kmacro-call-ring-2nd-repeat #[257 "\301 \302!\210\205 \211\205 \303!\207" [kmacro-ring kmacro-get-repeat-prefix kmacro-call-ring-2nd kmacro-repeat-on-last-key] 4 (#$ . 11114) "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 #[0 "\301 ?\205
\302@@\303\304#\207" [kmacro-ring kmacro-ring-empty-p kmacro-display nil "2nd macro"] 4 (#$ . 11531) nil])
#@148 Move to next keyboard macro in keyboard macro ring.
Displays the selected macro in the echo area.
The ARG parameter is unused.
(fn &optional ARG)
(defalias 'kmacro-cycle-ring-next #[256 "\302 ?\205+ \303 \210\304 G\211\305Z\233\211A@\306\241\210\307!\210\310 \311\"\210\205) \312!\266\204\207" [kmacro-ring 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] 8 (#$ . 11748) nil])
(put 'kmacro-cycle-ring-next 'kmacro-repeat 'ring)
#@152 Move to previous keyboard macro in keyboard macro ring.
Displays the selected macro in the echo area.
The ARG parameter is unused.
(fn &optional ARG)
(defalias 'kmacro-cycle-ring-previous #[256 "\302 ?\205* \303 \304 \305 \210\203 C\244\210\202 \211C\306 \307\"\210\205( \310!\266\202\207" [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] 6 (#$ . 12294) nil])
(put 'kmacro-cycle-ring-previous 'kmacro-repeat 'ring)
#@49 Swap first two elements on keyboard macro ring.
(defalias 'kmacro-swap-ring #[0 "\301 ?\205 \302 \303 \210\304!\266\305\306\"\207" [last-kbd-macro kmacro-ring-empty-p kmacro-ring-head kmacro-pop-ring1 kmacro-push-ring kmacro-display t] 3 (#$ . 12826) nil])
#@97 Delete current macro from keyboard macro ring.
The ARG parameter is unused.
(fn &optional ARG)
(defalias 'kmacro-delete-ring-head #[256 "\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."] 6 (#$ . 13093) nil])
(put 'kmacro-delete-ring-head 'kmacro-repeat 'head)
#@998 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 name that will remain valid even
after another macro is defined.
Use \[kmacro-bind-to-key] to bind it to a key sequence.
(fn ARG)
(defalias 'kmacro-start-macro #[257 "\204 \203\f \306\307!\207\211\205 \211<\211\204@ \n\203! \310\n \fE!\210\203+ \311!\2060
\2060 \312\313 \314\211\205V \203R @\315V\202V @\315U\"\210\205c \211\205c \316\211\207" [defining-kbd-macro executing-kbd-macro last-kbd-macro kmacro-counter kmacro-counter-format-start kmacro-initial-counter-value message "Already defining keyboard macro." kmacro-push-ring prefix-numeric-value 0 nil start-kbd-macro 4 append kmacro-counter-value-start kmacro-last-counter kmacro-default-counter-format kmacro-counter-format kmacro-execute-before-append] 6 (#$ . 13500) "P"])
#@413 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.
(fn ARG)
(defalias 'kmacro-end-macro #[257 "?\205* \303\304\"\210 \205* G\305U\205* \306\307\310!\210 ?\205* \n\205* \311 \210\202 \207" [executing-kbd-macro last-kbd-macro kmacro-ring end-kbd-macro kmacro-loop-setup-function 0 nil message "Ignore empty macro" kmacro-pop-ring1] 4 (#$ . 15136) "P"])
#@591 Call the keyboard MACRO that you defined with \[kmacro-start-macro].
A prefix argument serves as a repeat count. Zero means repeat until error.
MACRO defaults to `last-kbd-macro'.
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 give a macro a name so you can call it even after defining others,
use \[kmacro-name-last-macro].
(fn ARG &optional NO-REPEAT END-MACRO MACRO)
(defalias 'kmacro-call-macro #[1025 "\204\f \304 G\305V\204 \306=\205 \203 \307!\210\202* \206# \310\311\"\210):\2033 @\262\203= \312V\205\242 \n\313=\203G \211\202H \n\211\262\205\242 \314 \204v \315\316\317\320!\321\" \203s \203s \305V\203s \322\323 \"\202t \324#\210\325\326 \327\320!\330\321\331\332 \205\210
\333\321\203\223 \202\231
\206\231 \257F#\210\211\262!\207" [last-input-event last-kbd-macro kmacro-call-repeat-key kmacro-call-repeat-with-arg 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-transient-map make-sparse-keymap define-key lambda (interactive) kmacro-call-macro 'repeating] 18 (#$ . 15851) "p"])
#@940 Record subsequent keyboard input, defining a keyboard macro.
The commands are recorded even as they are executed.
Initializes the macro's `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 used during defining/executing a macro, inserts the current value
of `kmacro-counter' and increments the counter value by ARG (or by 1 if no
prefix argument). With just \[universal-argument], inserts the previous
value of `kmacro-counter', and does not modify the counter; this is
different from incrementing the counter by zero. (The previous value
of the counter is the one it had before the last increment.)
The macro counter can be set directly via \[kmacro-set-counter] and \[kmacro-add-counter].
The format of the inserted value of the counter can be controlled
via \[kmacro-set-format].
(fn ARG)
(defalias 'kmacro-start-macro-or-insert-counter #[257 "\204 \203\f \302!\207\303!\207" [defining-kbd-macro executing-kbd-macro kmacro-insert-counter kmacro-start-macro] 3 (#$ . 17271) "P"])
#@215 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.
(fn ARG &optional NO-REPEAT)
(defalias 'kmacro-end-or-call-macro #[513 "\203 \203 \304\305#\207\306!\207\n\307=\203\" \203\" \310 @\"\207\203/ <\203/ \311\312!\207\304\"\207" [defining-kbd-macro kmacro-call-repeat-key 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] 6 (#$ . 18412) "P"])
#@85 As `kmacro-end-or-call-macro' but allows repeat without repeating prefix.
(fn ARG)
(defalias 'kmacro-end-or-call-macro-repeat #[257 "\300 \301\302\"\210\211\205 \303!\207" [kmacro-get-repeat-prefix kmacro-end-or-call-macro t kmacro-repeat-on-last-key] 5 (#$ . 18991) "P"])
(put 'kmacro-end-or-call-macro-repeat 'kmacro-repeat 'head)
#@317 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 name, so you can call it even after defining other
macros, use \[kmacro-name-last-macro].
(fn ARG &optional NO-REPEAT)
(defalias 'kmacro-end-and-call-macro #[513 "\203 \301\302!\210\303\"\207" [defining-kbd-macro kmacro-end-macro nil kmacro-call-macro] 5 (#$ . 19335) "P"])
#@154 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.
(fn EVENT)
(defalias 'kmacro-end-call-mouse #[257 "\203& \303 \210 \203& G\304U\203& \305\306\307!\210 \204& \n\203& \310 \210\202 \311!\210\312\305\313\"\207" [defining-kbd-macro last-kbd-macro kmacro-ring end-kbd-macro 0 nil message "Ignore empty macro" kmacro-pop-ring1 mouse-set-point kmacro-call-macro t] 4 (#$ . 19817) "e"])
#@89 Create lambda form for macro bound to symbol or key.
(fn MAC &optional COUNTER FORMAT)
(defalias 'kmacro-lambda-form #[769 "\203\n E\262\300\301\302\303\304\305D\306BB\257\207" [lambda (&optional arg) "Keyboard macro." (interactive "p") kmacro-exec-ring-item quote (arg)] 10 (#$ . 20301)])
#@53 Extract kmacro from a kmacro lambda form.
(fn MAC)
(defalias 'kmacro-extract-lambda #[257 "\211\242\300=\2050 \301\302\"\211\262\2050 \211\243\242\243\242\211\262\2050 \211<\2050 \211G\303U\2050 \304@!\2050 \211\207" [lambda assoc kmacro-exec-ring-item 3 arrayp] 4 (#$ . 20606)])
(defalias 'kmacro-p 'kmacro-extract-lambda "Return non-nil if MAC is a kmacro keyboard macro.")
#@629 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.
The ARG parameter is unused.
(fn ARG)
(defalias 'kmacro-bind-to-key #[257 "\204 \203 \205\212 \304\305!\207\n\204 \306\307!\210\310\311!\312\211G\313U\203M \314H\211\250\203L \211\315Y\2038 \211\316X\204D \211\317Y\203L \211\320X\203L \321P\262\322\262\210\323\232?\205\210 \204y \324!\211\262\203y \211;\204y \325!\204y \326\327\330\331!#!\205\210 \332 \333\334 !#\210\304\335\331!\"\266\203\207" [defining-kbd-macro executing-kbd-macro last-kbd-macro global-map 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"] 9 (#$ . 20994) "p"])
#@83 Return non-nil if SYMBOL is the name of some sort of keyboard macro.
(fn SYMBOL)
(defalias 'kmacro-keyboard-macro-p #[257 "\211K\211\205 \211;\206 \300!\206 \301!\207" [vectorp kmacro-p] 4 (#$ . 22423)])
#@251 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.
(fn SYMBOL)
(defalias 'kmacro-name-last-macro #[257 "\204 \301\302!\210\303!\203 \304!\204 \301\305\"\210\211\306\230\203# \301\307!\210\211\310\311 !M\210\312\313\314#\207" [last-kbd-macro error "No keyboard macro defined" fboundp kmacro-keyboard-macro-p "Function %s is already defined and not a keyboard macro" "" "No command name given" kmacro-lambda-form kmacro-ring-head put kmacro t] 5 (#$ . 22640) "SName for last kbd macro: "])
#@74 compiler-macro for inlining `kmacro-register-p'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'kmacro-register-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block kmacro-register-p (and (memq (type-of cl-x) cl-struct-kmacro-register-tags) t)) nil] 9 (#$ . 23329)])
(put 'kmacro-register-p 'compiler-macro 'kmacro-register-p--cmacro)
#@13
(fn CL-X)
(defalias 'kmacro-register-p #[257 "\301!>\205 \302\207" [cl-struct-kmacro-register-tags type-of t] 3 (#$ . 23694)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put kmacro-register-p side-effect-free error-free put kmacro-register cl-deftype-satisfies] 5)
#@78 compiler-macro for inlining `kmacro-register-macro'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'kmacro-register-macro--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block kmacro-register-macro (progn (or (kmacro-register-p cl-x) (signal 'wrong-type-argument (list 'kmacro-register cl-x))) (aref cl-x 1))) nil] 9 (#$ . 23989)])
(put 'kmacro-register-macro 'compiler-macro 'kmacro-register-macro--cmacro)
#@66 Access slot "macro" of `kmacro-register' struct CL-X.
(fn CL-X)
(defalias 'kmacro-register-macro #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-kmacro-register-tags type-of signal wrong-type-argument kmacro-register 1] 5 (#$ . 24424)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put kmacro-register-macro side-effect-free t defalias copy-kmacro-register copy-sequence] 4)
#@78 compiler-macro for inlining `kmacro-make-register'.
(fn CL-WHOLE-ARG MACRO)
(defalias 'kmacro-make-register--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (macro) (cl-block kmacro-make-register (record 'kmacro-register macro)) nil] 9 (#$ . 24839)])
(put 'kmacro-make-register 'compiler-macro 'kmacro-make-register--cmacro)
#@64 Constructor for objects of type `kmacro-register'.
(fn MACRO)
(defalias 'kmacro-make-register #[257 "\300\301\"\207" [record kmacro-register] 4 (#$ . 25192)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303& \210\313\314\306\315\306\316%\210\313\317\306\320\306\321%\210\313\322\306\323\306\324%\207" [function-put kmacro-make-register side-effect-free t cl-struct-define kmacro-register nil cl-structure-object record ((cl-tag-slot) (macro)) cl-struct-kmacro-register-tags cl-generic-define-method register-val-jump-to ((data kmacro-register) _arg) #[514 "\302\303\211\304! >\204 \305\306\307D\"\210\310H$\207" [current-prefix-arg cl-struct-kmacro-register-tags kmacro-call-macro nil type-of signal wrong-type-argument kmacro-register 1] 10 "\n\n(fn DATA ARG)"] register-val-describe ((data kmacro-register) _verbose) #[514 "\301\302\303\304\305!>\204 \306\307\310D\"\210\311H!\"!\207" [cl-struct-kmacro-register-tags princ format "a keyboard macro:\n %s" format-kbd-macro type-of signal wrong-type-argument kmacro-register 1] 10 "\n\n(fn DATA VERBOSE)"] register-val-insert ((data kmacro-register)) #[257 "\301\302!>\204 \303\304\305D\"\210\306H!c\207" [cl-struct-kmacro-register-tags format-kbd-macro type-of signal wrong-type-argument kmacro-register 1] 6 "\n\n(fn DATA)"]] 11)
#@125 Store the last keyboard macro in register R.
Interactively, reads the register using `register-read-with-preview'.
(fn R)
(defalias 'kmacro-to-register #[257 "\301\302\303\"\"\207" [last-kbd-macro set-register record kmacro-register] 6 (#$ . 26526) (byte-code "\204 \301\302!\210\303\304!C\207" [last-kbd-macro error "No keyboard macro defined" register-read-with-preview "Save to register: "] 2)])
#@142 Display the last keyboard macro.
If repeated, it shows previous elements in the macro ring.
The ARG parameter is unused.
(fn &optional ARG)
(defalias 'kmacro-view-macro #[256 "\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"] 8 (#$ . 26938) nil])
#@303 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.
(fn &optional ARG)
(defalias 'kmacro-view-macro-repeat #[256 "\301 \302!\210\205 \211\205 \303!\207" [last-kbd-macro kmacro-get-repeat-prefix kmacro-view-macro kmacro-repeat-on-last-key] 4 (#$ . 27557) nil])
(put 'kmacro-view-macro-repeat 'kmacro-repeat 'ring)
#@47 Edit last keyboard macro.
(fn &optional ARG)
(defalias 'kmacro-edit-macro-repeat #[256 "\300\301\"\207" [edit-kbd-macro "
"] 4 (#$ . 28112) "P"])
(put 'kmacro-edit-macro-repeat 'kmacro-repeat 'stop)
#@86 As edit last keyboard macro, but without kmacro-repeat property.
(fn &optional ARG)
(defalias 'kmacro-edit-macro #[256 "\300\301\"\207" [edit-kbd-macro "
"] 4 (#$ . 28319) "P"])
#@54 Edit most recent 300 keystrokes as a keyboard macro.
(defalias 'kmacro-edit-lossage #[0 "\300 \210\301\302!\207" [kmacro-push-ring edit-kbd-macro "l"] 2 (#$ . 28505) nil])
(defvar kmacro-step-edit-active 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 "\301 \302\"\210\303\304\305#\210\303\306\305#\210\303\307\310#\210\303\311\312#\210\303\313\314#\210\303\315\316#\210\303\317\320#\210\303\321\320#\210\303\322\323#\210\303\324\325#\210\303\326\327#\210\303\330\331#\210\303\332\333#\210\303\334\335#\210\211\207" [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] 5) (#$ . 28722))
#@20
(fn MACRO INDEX)
(defalias 'kmacro-step-edit-prompt #[514 "?\205 \211\205 \306 #?\205 \306 \"\307\310 \311\312\313\314\315 \316\" \2033 G\317V\2033 \320\2024 \321\322\n\203A \315 !\202J \203I \323\202J \324\325\326# \203V \320\202W \321\n\203c \315 !\202d \321&\327 \203y \313\330\322\331\325\332#ed{#\202\213 \203\212 \313\330\322\333\325\332##\202\213 \321\203\252 \313\334\322\335\325\336#\f\203\237 \337\202\240 \321\322\340\325\341#
%\202\307 \322\313\342%\247\203\267 \321\202\270 \343%\247\203\302 \321\202\303 \344#\325\341#Q\")\207" [kmacro-step-edit-appending executing-kbd-macro-index message-log-max kmacro-step-edit-new-macro kmacro-step-edit-help this-command substring 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)" kmacro-step-edit-inserting] 18 (#$ . 29578)])
(defalias 'kmacro-step-edit-query #[0 "\306\307\211\211 \310=\203. \f\306=\204.
\262\307 \310\311!\210 \203-
GZ\211\262) \307\211 \f\306=\203\202 \310=\203z \312 \210\307 \310\313 !!\210\314!\315 \"! \203m \316!\311 G[#!
GZ)\307\211 \"\317\262\202} \320\262\307\202\220 \f=\203\216 \320\262\202\220 \307\204\251 \321#\"\210\322$\323rpq\210\324 )!\"\262*\210\325\267\202R\202X \202X\307%\317&\202}\202}\317\202X\317&\202}\307&\306\262\202X#\326=\203\346 \327\202\347 \306'\202}\330=\203\366 \327\202\367 \306'
GU\203}\314 \331\" \306(\202}\306'
GU\203X\314 \332\" \306(\202X
GU\203>\314 \333\" \306\211'(\202A\334&\306\262\202X#)?)\202}#\202}
#V\203t\314!\316 #\306=?\205p
#\"!\203\202\317\211\211#*\207" [kmacro-step-edit-mini-window-height max-mini-window-height resize-mini-windows this-command kmacro-step-edit-action executing-kbd-macro-index t nil quoted-insert 0 clear-this-command-keys prefix-numeric-value vconcat recent-keys substring ignore act kmacro-step-edit-prompt lookup-key vector read-event #s(hash-table size 15 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (act 177 act-repeat 180 quit 185 skip 194 skip-keep 197 skip-rest 202 automatic 208 exit 208 insert-1 217 insert 217 replace-1 236 replace 236 append 270 append-end 294 help 327)) insert-1 1 replace-1 [nil] [nil] [nil] append-end unread-command-events executing-kbd-macro defining-kbd-macro current-prefix-arg kmacro-step-edit-new-macro prefix-arg 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] 13])
(defalias 'kmacro-step-edit-insert #[0 "\306 \307\211\211\211\211
\310\307\"\210\311\307\211\211\211\306%\262\312\306\307#\262\203\223 \313=\203x \314 \210\313\315!!\210\307\211\316\317 \"\262\247\203r \307\203r \320\321G[#\262GZ\211\262\307\322\262\202\231 \247\203\204 \307\202\231 \323\232\203\231 \307\211
\262\322\202\264 \211\324>\203\251 \211GSH \203\264 \316 \" \211\211,\207" [kmacro-step-edit-mini-window-height executing-kbd-macro defining-kbd-macro max-mini-window-height resize-mini-windows kmacro-step-edit-key-index t nil kmacro-step-edit-prompt read-key-sequence key-binding quoted-insert clear-this-command-keys prefix-numeric-value vconcat recent-keys substring 0 ignore "\n" (self-insert-command digit-argument) executing-kbd-macro-index current-prefix-arg prefix-arg kmacro-step-edit-inserting unread-command-events kmacro-step-edit-action this-command last-command-event kmacro-step-edit-new-macro] 15])
(defalias 'kmacro-step-edit-pre-command #[0 "\306\307\310\"\210\203N \311\267\202) \312\202N \n GU\203N \313 \314\"\315\211\315\202N U\204N \f\203; \316 \210\202> \317 \210
\203N \f\204N \320\312\315=\205Y \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 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ignore 15 append-end 20)) ignore 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 #[0 "\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 #[0 "\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 #[0 "\306\307\310\211\306\311\310\211 \n \312\301\313\310#\210\312\302\314\306#\210\312\303\315\306#\210\316\310\211\"\210\205Q \205Q \232?\205Q \317 \210\211.\f\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-replace kmacro-step-edit-appending kmacro-step-edit-inserting kmacro-step-edit-new-macro kmacro-step-edit-active last-kbd-macro] 12 (#$ . 35122) nil])
(provide 'kmacro)
Mini Shell