ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/isearch.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.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\302\303\304\305\304\306\307\310\307\311\312\313&
\210\314\315\316\317\320\321%\210\314\322\323\324\320\325%\210\314\326\327\330\320\325%\210\314\331\332\333\320\334%\210\314\335\316\336\320\321%\210\314\337\340\341\320\342\343\344&\210\314\345\346\347\320\350%\210\314\351\316\352\320\321%\210\314\353\302\354\320\321%\207" [custom-declare-group isearch nil "Incremental search minor mode." :link (emacs-commentary-link "isearch") (custom-manual "(emacs)Incremental Search") :prefix "isearch-" "search-" :group matching custom-declare-variable search-exit-option t "Non-nil means random control characters terminate incremental search." :type boolean search-slow-window-lines 1 "Number of lines in slow search display windows.\nThese are the short windows used during incremental search on slow terminals.\nNegative means put the slow search window at the top (normally it's at bottom)\nand the value is minus the number of lines." integer search-slow-speed 1200 "Highest terminal speed at which to use \"slow\" style incremental search.\nThis is the style where a one-line window is created to show the line\nthat the search has reached." search-upper-case 'not-yanks "If non-nil, upper case chars disable case fold searching.\nThat is, upper and lower case chars must match exactly.\nThis applies no matter where the chars come from, but does not\napply to chars in regexps that are prefixed with `\\'.\nIf this value is `not-yanks', text yanked into the search string\nin Isearch mode is always downcased." (choice (const :tag "off" nil) (const not-yanks) (other :tag "on" t)) search-nonincremental-instead "If non-nil, do a nonincremental search instead of exiting immediately.\nThis affects the behavior of `isearch-exit' and any key bound to that\ncommand: if this variable is nil, `isearch-exit' always exits the search;\nif the value is non-nil, and the search string is empty, `isearch-exit'\nstarts a nonincremental search instead. (Actually, `isearch-edit-string'\nis called to let you enter the search string, and RET terminates editing\nand does a nonincremental search.)" search-whitespace-regexp (purecopy "\\s-+") "If non-nil, regular expression to match a sequence of whitespace chars.\nWhen you enter a space or spaces in the incremental search, it\nwill match any sequence matched by this regexp. As an exception,\nspaces are treated normally in regexp incremental search if they\noccur in a regexp construct like [...] or *, + or ?.\n\nIf the value is a string, it applies to both ordinary and\nregexp incremental search. If the value is nil, or\n`isearch-lax-whitespace' is nil for ordinary incremental search, or\n`isearch-regexp-lax-whitespace' is nil for regexp incremental search,\nthen each space you type matches literally, against one space.\n\nYou might want to use something like \"[ \\t\\r\\n]+\" instead.\nIn the Customization buffer, that is `[' followed by a space,\na tab, a carriage return (control-M), a newline, and `]+'." (choice (const :tag "Match Spaces Literally" nil) regexp) :version "24.3" search-invisible 'open "If t incremental search/query-replace can match hidden text.\nA nil value means don't match invisible text.\nWhen the value is `open', if the text matched is made invisible by\nan overlay having an `invisible' property and that overlay has a property\n`isearch-open-invisible', then incremental search will show the contents.\n(This applies when using `outline.el' and `hideshow.el'.)\n\nTo temporarily change the value for an active incremental search,\nuse \\<isearch-mode-map>\\[isearch-toggle-invisible].\n\nSee also the related option `isearch-hide-immediately'.\n\nSee also `reveal-mode' if you want overlays to automatically be opened\nwhenever point is in one of them." (choice (const :tag "Match hidden text" t) (const :tag "Open overlays" open) (const :tag "Don't match hidden text" nil)) isearch-hide-immediately "If non-nil, re-hide an invisible match right away.\nThis variable makes a difference when `search-invisible' is set to `open'.\nIf non-nil, invisible matches are re-hidden as soon as the match moves\noff the invisible text surrounding the match.\nIf nil then do not re-hide opened invisible text when the match moves.\nWhatever the value, all opened invisible text is hidden again after exiting\nthe search, with the exception of the last successful match, if any." isearch-resume-in-command-history "If non-nil, `isearch-resume' commands are added to the command history.\nThis allows you to resume earlier Isearch sessions through the\ncommand history."] 14)
#@62 Function(s) to call after starting up an incremental search.
(defvar isearch-mode-hook nil (#$ . 4978))
#@68 Function(s) to call after isearch has found matches in the buffer.
(defvar isearch-update-post-hook nil (#$ . 5088))
#@165 Function(s) to call after terminating an incremental search.
When these functions are called, `isearch-mode-end-hook-quit'
is non-nil if the user quits the search.
(defvar isearch-mode-end-hook nil (#$ . 5212))
#@77 Non-nil while running `isearch-mode-end-hook' if the user quits the search.
(defvar isearch-mode-end-hook-quit nil (#$ . 5429))
#@88 Function to call to display the search prompt.
If nil, use function `isearch-message'.
(defvar isearch-message-function nil (#$ . 5563))
#@183 Function to call to wrap the search when search is failed.
If nil, move point to the beginning of the buffer for a forward search,
or to the end of the buffer for a backward search.
(defvar isearch-wrap-function nil (#$ . 5707))
#@99 Function to save a function restoring the mode-specific Isearch state
to the search status stack.
(defvar isearch-push-state-function nil (#$ . 5942))
#@476 Predicate that filters the search hits that would normally be available.
Search hits that dissatisfy the predicate are skipped. The function
has two arguments: the positions of start and end of text matched by
the search. If this function returns nil, continue searching without
stopping at this match.
If you use `add-function' to modify this variable, you can use the
`isearch-message-prefix' advice property to specify the prefix string
displayed in the search message.
(defvar isearch-filter-predicate 'isearch-filter-visible (#$ . 6100))
#@34 List of search string sequences.
(defvar search-ring nil (#$ . 6651))
#@53 List of regular expression search string sequences.
(defvar regexp-search-ring nil (#$ . 6727))
(byte-code "\300\301\302\303\304\305%\210\300\306\302\307\304\305%\207" [custom-declare-variable search-ring-max 16 "Maximum length of search ring before oldest elements are thrown away." :type integer regexp-search-ring-max "Maximum length of regexp search ring before oldest elements are thrown away."] 6)
#@70 Index in `search-ring' of last string reused.
It is nil if none yet.
(defvar search-ring-yank-pointer nil (#$ . 7137))
#@77 Index in `regexp-search-ring' of last string reused.
It is nil if none yet.
(defvar regexp-search-ring-yank-pointer nil (#$ . 7262))
(byte-code "\300\301\302\303\304\305%\210\306\307\310\"\210\300\311\302\312\304\313\314\315&\210\300\316\317\320\304\305%\210\321\322\323\324\325\322\325\326&\207" [custom-declare-variable search-ring-update nil "Non-nil if advancing or retreating in the search ring should cause search.\nDefault value, nil, means edit the string instead." :type boolean autoload char-fold-to-regexp "char-fold" search-default-mode "Default mode to use when starting isearch.\nValue is nil, t, or a function.\n\nIf nil, default to literal searches (note that `case-fold-search'\nand `isearch-lax-whitespace' may still be applied).\\<isearch-mode-map>\nIf t, default to regexp searches (as if typing `\\[isearch-toggle-regexp]' during\nisearch).\n\nIf a function, use that function as an `isearch-regexp-function'.\nExample functions (and the keys to toggle them during isearch)\nare `word-search-regexp' (`\\[isearch-toggle-word]'), `isearch-symbol-regexp'\n(`\\[isearch-toggle-symbol]'), and `char-fold-to-regexp' (`\\[isearch-toggle-char-fold]')." (choice (const :tag "Literal search" nil) (const :tag "Regexp search" t) (function :tag "Other")) :version "25.1" search-highlight t "Non-nil means incremental search highlights the current match." custom-declare-face isearch ((((class color) (min-colors 88) (background light)) (:background "magenta3" :foreground "lightskyblue1")) (((class color) (min-colors 88) (background dark)) (:background "palevioletred2" :foreground "brown4")) (((class color) (min-colors 16)) (:background "magenta4" :foreground "cyan1")) (((class color) (min-colors 8)) (:background "magenta4" :foreground "cyan1")) (t (:inverse-video t))) "Face for highlighting Isearch matches." :group basic-faces] 8)
(defvar isearch-face 'isearch)
(byte-code "\302\303\304\305\306\307%\210\310\311\312\313\314\315\316\317\316\320& \210\321\317\322\323\324\325\306\326\316\320\316\327& \210\330\331\332\322#\210\333\322\211\203P @\331N\203I \332N\204I \334\332\331N#\210 A\211\2042 *\335\331\332\336#\210\310\332\312\337\314\315\316\317&\210\330\340\341\322#\210\342\322\211\203\216 @\340N\203\207 \341N\204\207 \334\341\340N#\210 A\211\204p *\335\340\341\336#\210\310\341\343\344\314\345\316\317&\210\330\346\347\322#\210\350\322\211\203\314 @\346N\203\305 \347N\204\305 \334\347\346N#\210 A\211\204\256 *\335\346\347\336#\210\310\347\351\352\314\345\316\317&\210\330\353\354\322#\210\355\322\211\203\n @\353N\203\354N\204\334\354\353N#\210 A\211\204\354 *\335\353\354\336#\210\310\354\356\357\314\360\316\317&\210\302\317\361\362\316\317\316\363&\210\334\364\365\317#\210\334\364\366\367\336!\2067\312#\210\330\364\370\322#\210\371\322\211\203e @\364N\203^\370N\204^\334\370\364N#\210 A\211\204G*\335\364\370\336#\207" [prop --dolist-tail-- custom-declare-face isearch-fail ((((class color) (min-colors 88) (background light)) (:background "RosyBrown1")) (((class color) (min-colors 88) (background dark)) (:background "red4")) (((class color) (min-colors 16)) (:background "red")) (((class color) (min-colors 8)) (:background "red")) (((class color grayscale)) :foreground "grey") (t (:inverse-video t))) "Face for highlighting failed part in Isearch echo-area message." :version "23.1" custom-declare-variable isearch-lazy-highlight t "Controls the lazy-highlighting during incremental search.\nWhen non-nil, all text in the buffer matching the current search\nstring is highlighted lazily (see `lazy-highlight-initial-delay'\nand `lazy-highlight-interval')." :type boolean :group lazy-highlight isearch custom-declare-group nil "Lazy highlighting feature for matching strings." :prefix "lazy-highlight-" "21.1" matching defvaralias isearch-lazy-highlight-cleanup lazy-highlight-cleanup (saved-value saved-variable-comment) put make-obsolete-variable "22.1" "Controls whether to remove extra highlighting after a search.\nIf this is nil, extra highlighting can be \"manually\" removed with\n\\[lazy-highlight-cleanup]." isearch-lazy-highlight-initial-delay lazy-highlight-initial-delay (saved-value saved-variable-comment) 0.25 "Seconds to wait before beginning to lazily highlight all matches." number isearch-lazy-highlight-interval lazy-highlight-interval (saved-value saved-variable-comment) 0 "Seconds between lazily highlighting successive matches." isearch-lazy-highlight-max-at-a-time lazy-highlight-max-at-a-time (saved-value saved-variable-comment) 20 "Maximum matches to highlight at a time (for `lazy-highlight').\nLarger values may reduce Isearch's responsiveness to user input;\nsmaller values make matches highlight slowly.\nA value of nil means highlight all matches." (choice (const :tag "All" nil) (integer :tag "Some")) ((((class color) (min-colors 88) (background light)) (:background "paleturquoise")) (((class color) (min-colors 88) (background dark)) (:background "paleturquoise4")) (((class color) (min-colors 16)) (:background "turquoise3")) (((class color) (min-colors 8)) (:background "turquoise3")) (t (:underline t))) "Face for lazy highlighting of matches other than the current one." basic-faces isearch-lazy-highlight-face face-alias obsolete-face purecopy lazy-highlight-face (saved-value saved-variable-comment)] 13)
(defvar lazy-highlight-face 'lazy-highlight)
#@64 Keymap for characters following the Help key for Isearch mode.
(defvar isearch-help-map (byte-code "\302 \303\304 !\305#\210\303\306\305#\210\303\307\305#\210\303\310\305#\210\303\311\312#\210\303\313\314#\210\303\315\316#\210\303\317\320#\210)\207" [map help-char make-sparse-keymap define-key char-to-string isearch-help-for-help [help] [f1] "?" "b" isearch-describe-bindings "k" isearch-describe-key "m" isearch-describe-mode "q" help-quit] 4) (#$ . 12659))
#@481 You have typed %THIS-KEY%, the help character. Type a Help option:
(Type \<help-map>\[help-quit] to exit the Help command.)
b Display all Isearch key bindings.
k KEYS Display full documentation of Isearch key sequence.
m Display documentation of Isearch mode.
You can't type here other help keys available in the global help map,
but outside of this help window when you type them in Isearch mode,
they exit Isearch mode before displaying global help.
(defalias 'isearch-help-for-help-internal-doc #[nil "\300\207" [nil] 1 (#$ . 13137)])
#@15 Help command.
(defalias 'isearch-help-for-help-internal #[nil "\306\307\310!! \203 \311\312\"\210\313\314!\315 \f \316 >\317\211 ? @\317\211 A B\320\321\n\"\203< \322\323\324 \325\326O!\327\211\n$\330\216\317 C\241\210\331 \332\333#\210\331 \334\335D\336\"#\210 \203| E\337\317!)A\335FA\"\203s \335FA\"AA\325HB\202 \340BB\340=\204\226 BG=\204\226 BH>\203U\341 ?\342\343\317\327#\210\344\345!\203\265 \346 >=\204\265 \346 @\317?\317I\327 J\347 \210\nc\210)
\350 \210\f)eb\210B\351HG\352B\">\204\352 B\242\353=\204\352 A\354\232\203U\3551 B\242\353=\203\375 \356B!\202B\357>\203 \360 \202B\361>\204A\354\232\205\362 0\202!\210\202\"\210\327 E K\337\363\364\365d!\2035\366\2026\367\"!\211A\325HB*B\370=\203\315 \371\335 A\"\317A#\210\202\315 \311\366!\210B<\203mBLBL\317\211?\202\251\335 A\"\211 M\203\246?\203\205\372?!\210\317?
\373M!\210)@\205\250@\316 =\204\237\374@!\210\317\211@\202\250\375 ). \207" [line-prompt three-step-help help-screen local-map minor-mode-map-alist new-minor-mode-map-alist substitute-command-keys purecopy "Type a help option: [bkm] or ?" message "%s" documentation isearch-help-for-help-internal-doc make-sparse-keymap selected-frame nil string-match "%THIS-KEY%" replace-match key-description this-command-keys 0 -1 t #[nil "\203 \304!\210 \203 \305 !\210\n\211\207" [config new-frame new-minor-mode-map-alist minor-mode-map-alist set-window-configuration iconify-frame] 2] define-key [t] undefined [vertical-scroll-bar] lookup-key [vertical-scroll-bar] read-key-sequence 63 current-window-configuration pop-to-buffer " *Metahelp*" fboundp make-frame window-frame erase-buffer help-mode append (63 22 32 127 delete backspace vertical-scroll-bar 134217846) switch-frame "\366" (error) handle-switch-frame (22 32) scroll-up (127 134217846 delete backspace) scroll-down format "Type one of the options listed%s: " pos-visible-in-window-p "" ", or SPACE or DEL to scroll" vertical-scroll-bar command-execute set-window-configuration call-interactively iconify-frame ding prev-frame config new-frame key char isearch-help-map global-map overriding-local-map function-key-map help-char help-event-list buffer-read-only inhibit-read-only cursor-in-echo-area unread-command-events defn] 7 (#$ . 13709) nil])
(defvar isearch--display-help-action '(nil (inhibit-same-window . t)))
#@28 Display Isearch help menu.
(defalias 'isearch-help-for-help #[nil "\302 \210)\303 \207" [isearch--display-help-action display-buffer-overriding-action isearch-help-for-help-internal isearch-update] 1 (#$ . 16108) nil])
#@139 Show a list of all keys defined in Isearch mode, and their definitions.
This is like `describe-bindings', but displays only Isearch keys.
(defalias 'isearch-describe-bindings #[nil "\n\306\211\223\210\307 B\310\fB \311 \312\313!\211 \306\211 rq\210\314\315!\210\314\316\317!!)rq\210\320\306\")\321\322!\203M \322\"\202O .\207" [isearch--display-help-action display-buffer-overriding-action help-window-point-marker temp-buffer-window-setup-hook temp-buffer-window-show-hook help-window-old-frame nil help-mode-setup help-mode-finish selected-frame temp-buffer-window-setup "*Help*" princ "Isearch Mode Bindings:\n" substitute-command-keys "\\{isearch-mode-map}" temp-buffer-window-show functionp help-window-setup #1=#:buffer standard-output #2=#:window #3=#:value] 4 (#$ . 16336) nil])
#@63 Display documentation of the function invoked by isearch key.
(defalias 'isearch-describe-key #[nil "\302\303!\210)\304 \207" [isearch--display-help-action display-buffer-overriding-action call-interactively describe-key isearch-update] 2 (#$ . 17156) nil])
#@40 Display documentation of Isearch mode.
(defalias 'isearch-describe-mode #[nil "\302\303!\210)\304 \207" [isearch--display-help-action display-buffer-overriding-action describe-function isearch-forward isearch-update] 2 (#$ . 17422) nil])
(defalias 'isearch-mode-help 'isearch-describe-mode)
#@28 Keymap for `isearch-mode'.
(defvar isearch-mode-map (byte-code "\306\307 \310A@!\204 \311\312!\210\313A@\314\315 B\316#\210\317\211\314W\2033 \320\321 !\316#\210 T\211\202 \322 \320\323 !\n#\210)\320\324\325#\210\320\326\327#\210\320\330\325#\210\320\331\327#\210\320\332\333#\210\320\334\335#\210\320\336\337#\210 \340U\204s \311\341!\210\320\342\343#\210\320\344\345#\210\320\346\347#\210\320\350\347#\210\320\351\316#\210\320\352\316#\210\320\353\316#\210\320\354\355#\210\320\356\357#\210\320\360\361#\210\320\362\363#\210\320\364\365#\210\320\323\f!
#\210\320\366
#\210\320\367
#\210\320\370\371#\210\320\372\373#\210\320\374\375#\210\320\376\377#\210\320\201@ \201A #\210\320\201B \201A #\210\320\201C \201A #\210\320\201D \201A #\210\320\201E \201A #\210\320\201F \201A #\210\320\201G \201H #\210\320\201I \201J #\210\320\201K \201L #\210\320\201M \201A #\210\320\201N \201O #\210\320\201P \201Q #\210\320\201R \201S #\210\320\201T \201U #\210\201V \201U \201W \201X #\210\320\201X \201U #\210\320\201Y \201Z #\210\320\201[ \201\\ #\210\320\201] \201^ #\210\320\201_ \201` #\210\320\201a \201b #\210*\207" [map i meta-map meta-prefix-char help-char isearch-help-map 0 make-keymap char-table-p error "The initialization of isearch-mode-map must be updated" set-char-table-range 256 max-char isearch-printing-char 32 define-key vector make-sparse-keymap char-to-string "" isearch-repeat-forward "" isearch-repeat-backward "\223" "\222" "" isearch-delete-char [backspace] undefined "" isearch-abort 27 "Inconsistency in isearch.el" "" isearch-cancel "" isearch-quote-char "
" isearch-exit [return] "\n" " " [33554464] "" isearch-yank-word-or-char "\227" isearch-del-char "\231" isearch-yank-char "" isearch-yank-kill "\363" isearch-yank-line [help] [f1] "\356" isearch-ring-advance "\360" isearch-ring-retreat "\371" isearch-yank-pop "\211" isearch-complete [switch-frame] nil [delete-frame] [iconify-frame] [make-frame-visible] [mouse-movement] [language-change] " " isearch-toggle-input-method " " isearch-toggle-specified-input-method [mouse-2] isearch-mouse-2 [down-mouse-2] [xterm-paste] isearch-xterm-paste "\343" isearch-toggle-case-fold "\362" isearch-toggle-regexp "\345" isearch-edit-string put :advertised-binding "\363e" [134217765] isearch-query-replace [201326629] isearch-query-replace-regexp "\363o" isearch-occur "\363hr" isearch-highlight-regexp "8
" isearch-char-by-name] 5) (#$ . 17721))
#@55 Keymap for editing Isearch strings in the minibuffer.
(defvar minibuffer-local-isearch-map (byte-code "\302 \303 \"\210\304\305\306#\210\304\307\310#\210\304\311\312#\210\304\313\314#\210\304\315\316#\210\304\317\316#\210)\207" [map minibuffer-local-map make-sparse-keymap set-keymap-parent define-key "
" exit-minibuffer "\211" isearch-complete-edit "" isearch-forward-exit-minibuffer "" isearch-reverse-exit-minibuffer "" isearch-yank-char-in-minibuffer [right]] 4) (#$ . 20209))
(defvar isearch-forward nil)
(defvar isearch-regexp nil)
#@458 Regexp-based search mode for words/symbols.
If the value is a function (e.g. `isearch-symbol-regexp'), it is
called to convert a plain search string to a regexp used by
regexp search functions.
The symbol property `isearch-message-prefix' put on this function
specifies the prefix string displayed in the search message.
This variable is set and changed during isearch. To change the
default behavior used for searches, see `search-default-mode'
instead.
(defvar isearch-regexp-function nil (#$ . 20767))
(byte-code "\302\303\304\305#\210\306\305\211\203, @\303N\203% \304N\204% \307\304\303N#\210 A\211\204 *\310\303\304\311#\207" [prop --dolist-tail-- defvaralias isearch-word isearch-regexp-function nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1"] 6)
#@401 If non-nil, a space will match a sequence of whitespace chars.
When you enter a space or spaces in ordinary incremental search, it
will match any sequence matched by the regexp defined by the variable
`search-whitespace-regexp'. If the value is nil, each space you type
matches literally, against one space. You can toggle the value of this
variable by the command `isearch-toggle-lax-whitespace'.
(defvar isearch-lax-whitespace t (#$ . 21568))
#@399 If non-nil, a space will match a sequence of whitespace chars.
When you enter a space or spaces in regexp incremental search, it
will match any sequence matched by the regexp defined by the variable
`search-whitespace-regexp'. If the value is nil, each space you type
matches literally, against one space. You can toggle the value of this
variable by the command `isearch-toggle-lax-whitespace'.
(defvar isearch-regexp-lax-whitespace nil (#$ . 22022))
#@193 Stack of search status elements.
Each element is an `isearch--state' struct where the slots are
[STRING MESSAGE POINT SUCCESS FORWARD OTHER-END WORD
ERROR WRAPPED BARRIER CASE-FOLD-SEARCH]
(defvar isearch-cmds nil (#$ . 22483))
(defvar isearch-string "")
(defvar isearch-message "")
(defvar isearch-message-prefix-add nil)
(defvar isearch-message-suffix-add nil)
(defvar isearch-success t)
(defvar isearch-error nil)
(defvar isearch-other-end nil)
(defvar isearch-wrapped nil)
#@56 Recorded minimum/maximal point for the current search.
(defvar isearch-barrier 0 (#$ . 22969))
(defvar isearch-just-started nil)
(defvar isearch-start-hscroll 0)
(defvar isearch-case-fold-search nil)
(defvar isearch-invisible search-invisible)
(defvar isearch-last-case-fold-search nil)
(defvar isearch-original-minibuffer-message-timeout nil)
(defvar isearch-adjusted nil)
(defvar isearch-slow-terminal-mode nil)
(defvar isearch-small-window nil)
(defvar isearch-opoint 0)
(defvar isearch-window-configuration nil)
(defvar isearch-yank-flag nil)
(defvar isearch-op-fun nil)
(defvar isearch-recursive-edit nil)
(defvar isearch-nonincremental nil)
(defvar isearch-new-forward nil)
(defvar isearch-opened-overlays nil)
(defvar isearch-hidden nil)
(defvar isearch-input-method-function nil)
(defvar isearch-input-method-local-p nil)
(defvar isearch--saved-overriding-local-map nil)
(byte-code "\301\236\204 \302C\244\210\301\207" [minor-mode-alist isearch-mode (isearch-mode isearch-mode)] 2)
(defvar isearch-mode nil nil)
(byte-code "\303\304!\210\305\306\307#\210\305 \306\310#\210\305\311\312#\210\305 \311\313#\210\305\n\314\315#\210\305\n\316\317#\210\305\n\320\321#\207" [global-map esc-map search-map make-variable-buffer-local isearch-mode define-key "" isearch-forward isearch-forward-regexp "" isearch-backward isearch-backward-regexp "w" isearch-forward-word "_" isearch-forward-symbol "." isearch-forward-symbol-at-point] 4)
#@4072 Do incremental search forward.
With a prefix argument, do an incremental regular expression search instead.
\<isearch-mode-map>
As you type characters, they add to the search string and are found.
The following non-printing keys are bound in `isearch-mode-map'.
Type \[isearch-delete-char] to cancel last input item from end of search string.
Type \[isearch-exit] to exit, leaving point at location found.
Type LFD (C-j) to match end of line.
Type \[isearch-repeat-forward] to search again forward, \[isearch-repeat-backward] to search again backward.
Type \[isearch-yank-word-or-char] to yank next word or character in buffer
onto the end of the search string, and search for it.
Type \[isearch-del-char] to delete character from end of search string.
Type \[isearch-yank-char] to yank char from buffer onto end of search string and search for it.
Type \[isearch-yank-line] to yank rest of line onto end of search string and search for it.
Type \[isearch-yank-kill] to yank the last string of killed text.
Type \[isearch-yank-pop] to replace string just yanked into search prompt
with string killed before it.
Type \[isearch-quote-char] to quote control character to search for it.
Type \[isearch-char-by-name] to add a character to search by Unicode name, with completion.
\[isearch-abort] while searching or when search has failed cancels input back to what has
been found successfully.
\[isearch-abort] when search is successful aborts and moves point to starting point.
If you try to exit with the search string still empty, it invokes
nonincremental search.
Type \[isearch-toggle-case-fold] to toggle search case-sensitivity.
Type \[isearch-toggle-invisible] to toggle search in invisible text.
Type \[isearch-toggle-regexp] to toggle regular-expression mode.
Type \[isearch-toggle-word] to toggle word mode.
Type \[isearch-toggle-symbol] to toggle symbol mode.
Type \[isearch-toggle-char-fold] to toggle character folding.
Type \[isearch-toggle-lax-whitespace] to toggle whitespace matching.
In incremental searches, a space or spaces normally matches any whitespace
defined by the variable `search-whitespace-regexp'; see also the variables
`isearch-lax-whitespace' and `isearch-regexp-lax-whitespace'.
Type \[isearch-edit-string] to edit the search string in the minibuffer.
Also supported is a search ring of the previous 16 search strings.
Type \[isearch-ring-advance] to search for the next item in the search ring.
Type \[isearch-ring-retreat] to search for the previous item in the search ring.
Type \[isearch-complete] to complete the search string using the search ring.
Type \[isearch-query-replace] to run `query-replace' with string to replace from last search string.
Type \[isearch-query-replace-regexp] to run `query-replace-regexp' with the last search string.
Type \[isearch-occur] to run `occur' that shows the last search string.
Type \[isearch-highlight-regexp] to run `highlight-regexp' that highlights the last search string.
Type \[isearch-describe-bindings] to display all Isearch key bindings.
Type \[isearch-describe-key] to display documentation of Isearch key.
Type \[isearch-describe-mode] to display documentation of Isearch mode.
If an input method is turned on in the current buffer, that input
method is also active while you are typing characters to search.
To toggle the input method, type \[isearch-toggle-input-method]. It also toggles the input
method in the current buffer.
To use a different input method for searching, type \[isearch-toggle-specified-input-method],
and specify an input method you want to use.
The above keys, bound in `isearch-mode-map', are often controlled by
options; do \[apropos] on search-.* to find them.
Other control and meta characters terminate the search
and are then executed normally (depending on `search-exit-option').
Likewise for function keys and mouse button events.
If this function is called non-interactively with a nil NO-RECURSIVE-EDIT,
it does not return to the calling function until the search is done.
See the function `isearch-mode' for more information.
(defalias 'isearch-forward #[(&optional regexp-p no-recursive-edit) "\302\303??\304 ?$\207" [regexp-p no-recursive-edit isearch-mode t nil] 5 (#$ . 24418) "P\np"])
#@560 Do incremental search forward for regular expression.
With a prefix argument, do a regular string search instead.
Like ordinary incremental search except that your input is treated
as a regexp. See the command `isearch-forward' for more information.
In incremental searches, a space or spaces normally matches any
whitespace defined by the variable `search-whitespace-regexp'.
To search for a literal space and nothing else, enter C-q SPC.
To toggle whitespace matching, use `isearch-toggle-lax-whitespace'.
This command does not support character folding.
(defalias 'isearch-forward-regexp #[(&optional not-regexp no-recursive-edit) "\302\303?\304 ?$\207" [not-regexp no-recursive-edit isearch-mode t nil] 5 (#$ . 28661) "P\np"])
#@402 Do incremental search forward for a sequence of words.
With a prefix argument, do a regular string search instead.
Like ordinary incremental search except that your input is treated
as a sequence of words without regard to how the words are separated.
See the command `isearch-forward' for more information.
This command does not support character folding, and lax space matching
has no effect on it.
(defalias 'isearch-forward-word #[(&optional not-word no-recursive-edit) "\302\303\304\211? ?%\207" [no-recursive-edit not-word isearch-mode t nil] 6 (#$ . 29402) "P\np"])
#@368 Do incremental search forward for a symbol.
The prefix argument is currently unused.
Like ordinary incremental search except that your input is treated
as a symbol surrounded by symbol boundary constructs \_< and \_>.
See the command `isearch-forward' for more information.
This command does not support character folding, and lax space matching
has no effect on it.
(defalias 'isearch-forward-symbol #[(&optional _not-symbol no-recursive-edit) "\301\302\303\211?\304%\207" [no-recursive-edit isearch-mode t nil isearch-symbol-regexp] 6 (#$ . 29983) "P\np"])
#@153 Do incremental search backward.
With a prefix argument, do a regular expression search instead.
See the command `isearch-forward' for more information.
(defalias 'isearch-backward #[(&optional regexp-p no-recursive-edit) "\302\303??\303 ?$\207" [regexp-p no-recursive-edit isearch-mode nil] 5 (#$ . 30550) "P\np"])
#@260 Do incremental search backward for regular expression.
With a prefix argument, do a regular string search instead.
Like ordinary incremental search except that your input is treated
as a regexp. See the command `isearch-forward-regexp' for more information.
(defalias 'isearch-backward-regexp #[(&optional not-regexp no-recursive-edit) "\302\303?\303 ?$\207" [not-regexp no-recursive-edit isearch-mode nil] 5 (#$ . 30873) "P\np"])
#@302 Do incremental search forward for a symbol found near point.
Like ordinary incremental search except that the symbol found at point
is added to the search string initially as a regexp surrounded
by symbol boundary constructs \_< and \_>.
See the command `isearch-forward-symbol' for more information.
(defalias 'isearch-forward-symbol-at-point #[nil "\302\303\304\"\210\305 \211\203\" @`W\203 @b\210\306\307@A\"!\202) \310\311 \210\312 )\207" [bounds isearch-error isearch-forward-symbol nil 1 find-tag-default-bounds isearch-yank-string buffer-substring-no-properties "No symbol at point" isearch-push-state isearch-update] 5 (#$ . 31313) nil])
#@730 Start Isearch minor mode.
It is called by the function `isearch-forward' and other related functions.
The non-nil arg FORWARD means searching in the forward direction.
The non-nil arg REGEXP does an incremental regular expression search.
The arg OP-FUN is a function to be called after each input character
is processed. (It is not called after characters that exit the search.)
When the arg RECURSIVE-EDIT is non-nil, this function behaves modally and
does not return to the calling function until the search is completed.
To behave this way it enters a recursive-edit and exits it when done
isearching.
The arg REGEXP-FUNCTION, if non-nil, should be a function. It is
used to set the value of `isearch-regexp-function'.
(defalias 'isearch-mode #[(forward &optional regexp op-fun recursive-edit regexp-function) "\n\206 ?\205 \f\306= \206 \307\f!\205 \n?\205 \f)*+,-.,/0\310\21112\3113\3064\3115`6\311\21178\3119:;X\205] \312 \313<!\314_V=\311\211>?\306@\315 A`B\311\211CDE\316\317!F\311GHI\311HF\204\221 \320\317!\210\311\321\310!\210=\205\237 \322 J\323\324 ! K\325K!\326>\204\306 \327K!\204\274 \330K!\210L\203\306 \331K!\210)\332M\333 \210NO\334\335!\210OP\336 \210\337 \210\340\341\342\"\210\340\343\344\"\210\340\345\346\"\210\340\347\346\"\210(\203\377 \306 Q\350 \210)4\207" [forward isearch-forward regexp regexp-function search-default-mode isearch-regexp t functionp "" nil window-height abs 4 window-hscroll local-variable-p input-method-function make-local-variable looking-at current-window-configuration window-frame minibuffer-window frame-live-p (nil t) frame-visible-p make-frame-visible raise-frame " Isearch" force-mode-line-update run-hooks isearch-mode-hook isearch-push-state isearch-update add-hook pre-command-hook isearch-pre-command-hook post-command-hook isearch-post-command-hook mouse-leave-buffer-hook isearch-done kbd-macro-termination-hook recursive-edit isearch-regexp-function op-fun isearch-op-fun isearch-case-fold-search isearch-last-case-fold-search case-fold-search search-invisible isearch-invisible isearch-string isearch-message isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error baud-rate search-slow-speed search-slow-window-lines isearch-slow-terminal-mode isearch-other-end isearch-small-window isearch-just-started isearch-start-hscroll isearch-opoint search-ring-yank-pointer isearch-opened-overlays isearch-input-method-function isearch-input-method-local-p regexp-search-ring-yank-pointer minibuffer-message-timeout isearch-original-minibuffer-message-timeout isearch-window-configuration frame minibuffer-auto-raise isearch-mode isearch-mode-map overriding-terminal-local-map isearch--saved-overriding-local-map isearch-recursive-edit] 4 (#$ . 31973)])
(defvar isearch--current-buffer nil)
#@198 This is called after every isearch command to update the display.
The second last thing it does is to run `isearch-update-post-hook'.
The last thing is to trigger a new round of lazy highlighting.
(defalias 'isearch-update #[nil "p=\204 \306!\203 rq\210\307\310 \")p\311\301!\210\310 B\n\204\346 \204\346 \312 \2044 \f\2062 \313 \210
\203\230 \"\204\230 \314 \204\230 ` #\315\"\316\317!\210\320 $\321\322%\317W\203_ %[T\202e \323 %TZ\"\210)%\317W\203\214 \324\320%Z!\210\325\326 `\"\210\327\326 \330 \"\210\327\331 \317\"\210\202\220 \332\320!\210#b\210)\202\305 \330 \322 & '\327\331 (\"\210\314\322\211\315#\211&\203\275 &@\333 \334 _Y\203\304 \327\331 '\"\210*)\203\343 )`W\203\332 \335)`\"\210\202\346 \335`)\"\210\202\346 \336 \210\322\211*+\315,\337\340!\210-\205\372 \341 \207" [isearch--current-buffer cursor-sensor-inhibit unread-command-events executing-kbd-macro isearch-message-function isearch-slow-terminal-mode buffer-live-p delq isearch make-local-variable input-pending-p isearch-message pos-visible-in-window-group-p t move-to-window-line 0 1 split-window nil window-height vertical-motion set-window-start next-window set-window-hscroll window-hscroll selected-window other-window window-max-chars-per-line frame-char-width isearch-highlight isearch-dehighlight run-hooks isearch-update-post-hook isearch-lazy-highlight-new-loop isearch-small-window found-point window-min-height search-slow-window-lines visible-p current-scroll isearch-start-hscroll isearch-other-end isearch-adjusted isearch-yank-flag disable-point-adjustment isearch-lazy-highlight] 5 (#$ . 34852)])
#@174 Exit Isearch mode.
For successful search, pass no args.
For a failing search, NOPUSH is t.
For going to the minibuffer to edit the search string,
NOPUSH is t and EDIT is t.
(defalias 'isearch-done #[(&optional nopush edit) "\203# \306 \n \f
\307+D\257 ,-@,\232\204\" ,-B-)\310\311\312\"\210\310\313\314\"\210\310\315\316\"\210\310\317\316\"\210\320.\321/!\203Q r/q\210\320/\322\3230\"0)\320123\324 \210\325!\210\326 ` 4 56\203\205 \3276!\2107\203} 4b\210\202\205 \330\331 5\332#\210*\32089\203\225 : \202\231 \333\334!\210\335 \210m?\205\245 \336`\337\"o?\205\257 \336`S\337\" ; <;\203\326 <\203\326 ;<=\203\326 \f\203\320 \340`\337\"\202\324 \341`\337\"b\210* G\342V\203\350 =\204\350 \343 \n\"\210=\205\360 >? ?\344\345!\210)`@U\204#A\203B\204#\346@\332\"\210C\204#\347 \342V\204#>\204#\350\351!\210>?\2050D\2050\352 \207" [isearch-resume-in-command-history isearch-string isearch-regexp isearch-regexp-function isearch-forward isearch-message isearch-resume quote remove-hook pre-command-hook isearch-pre-command-hook post-command-hook isearch-post-command-hook mouse-leave-buffer-hook isearch-done kbd-macro-termination-hook nil buffer-live-p delq isearch isearch-dehighlight lazy-highlight-cleanup window-group-start set-window-configuration set-window-group-start selected-window t kill-local-variable input-method-function force-mode-line-update get-text-property intangible next-single-property-change previous-single-property-change 0 isearch-update-ring run-hooks isearch-mode-end-hook push-mark minibuffer-depth message "Mark saved where search started" exit-recursive-edit isearch-case-fold-search command command-history isearch-lazy-highlight-start isearch--current-buffer cursor-sensor-inhibit overriding-terminal-local-map isearch-original-minibuffer-message-timeout minibuffer-message-timeout found-point found-start isearch-window-configuration isearch-small-window isearch-mode isearch-input-method-local-p isearch-input-method-function before after nopush edit isearch-mode-end-hook-quit isearch-opoint transient-mark-mode mark-active executing-kbd-macro isearch-recursive-edit] 8 (#$ . 36478)])
#@100 Add STRING to the beginning of the search ring.
REGEXP if non-nil says use the regexp search ring.
(defalias 'isearch-update-ring #[(string &optional regexp) "\304\203 \305\202\n \306 \203 \n\202 #\207" [regexp string regexp-search-ring-max search-ring-max add-to-history regexp-search-ring search-ring] 4 (#$ . 38653)])
(defalias 'isearch--state-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-p (declare (side-effect-free error-free)) (and (vectorp cl-x) (>= (length cl-x) 13) (memq (aref cl-x 0) cl-struct-isearch--state-tags) t)) nil] 7])
(put 'isearch--state-p 'compiler-macro 'isearch--state-p--cmacro)
(defalias 'isearch--state-p #[(cl-x) "\302!\205 G\303Y\205 \304H >\205 \305\207" [cl-x cl-struct-isearch--state-tags vectorp 13 0 t] 2])
(byte-code "\300\301\302\303#\210\304\305\306\301#\207" [function-put isearch--state-p side-effect-free error-free put isearch--state cl-deftype-satisfies] 4)
(defalias 'isearch--state-string--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-string (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 1)) nil] 7])
(put 'isearch--state-string 'compiler-macro 'isearch--state-string--cmacro)
(defalias 'isearch--state-string #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 1] 4])
(function-put 'isearch--state-string 'side-effect-free t)
(defalias 'isearch--state-message--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-message (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 2)) nil] 7])
(put 'isearch--state-message 'compiler-macro 'isearch--state-message--cmacro)
(defalias 'isearch--state-message #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 2] 4])
(function-put 'isearch--state-message 'side-effect-free t)
(defalias 'isearch--state-point--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-point (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 3)) nil] 7])
(put 'isearch--state-point 'compiler-macro 'isearch--state-point--cmacro)
(defalias 'isearch--state-point #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 3] 4])
(function-put 'isearch--state-point 'side-effect-free t)
(defalias 'isearch--state-success--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-success (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 4)) nil] 7])
(put 'isearch--state-success 'compiler-macro 'isearch--state-success--cmacro)
(defalias 'isearch--state-success #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 4] 4])
(function-put 'isearch--state-success 'side-effect-free t)
(defalias 'isearch--state-forward--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-forward (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 5)) nil] 7])
(put 'isearch--state-forward 'compiler-macro 'isearch--state-forward--cmacro)
(defalias 'isearch--state-forward #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 5] 4])
(function-put 'isearch--state-forward 'side-effect-free t)
(defalias 'isearch--state-other-end--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-other-end (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 6)) nil] 7])
(put 'isearch--state-other-end 'compiler-macro 'isearch--state-other-end--cmacro)
(defalias 'isearch--state-other-end #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 6] 4])
(function-put 'isearch--state-other-end 'side-effect-free t)
(defalias 'isearch--state-word--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-word (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 7)) nil] 7])
(put 'isearch--state-word 'compiler-macro 'isearch--state-word--cmacro)
(defalias 'isearch--state-word #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 7] 4])
(function-put 'isearch--state-word 'side-effect-free t)
(defalias 'isearch--state-error--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-error (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 8)) nil] 7])
(put 'isearch--state-error 'compiler-macro 'isearch--state-error--cmacro)
(defalias 'isearch--state-error #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 8] 4])
(function-put 'isearch--state-error 'side-effect-free t)
(defalias 'isearch--state-wrapped--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-wrapped (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 9)) nil] 7])
(put 'isearch--state-wrapped 'compiler-macro 'isearch--state-wrapped--cmacro)
(defalias 'isearch--state-wrapped #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 9] 4])
(function-put 'isearch--state-wrapped 'side-effect-free t)
(defalias 'isearch--state-barrier--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-barrier (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 10)) nil] 7])
(put 'isearch--state-barrier 'compiler-macro 'isearch--state-barrier--cmacro)
(defalias 'isearch--state-barrier #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 10] 4])
(function-put 'isearch--state-barrier 'side-effect-free t)
(defalias 'isearch--state-case-fold-search--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-case-fold-search (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 11)) nil] 7])
(put 'isearch--state-case-fold-search 'compiler-macro 'isearch--state-case-fold-search--cmacro)
(defalias 'isearch--state-case-fold-search #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 11] 4])
(function-put 'isearch--state-case-fold-search 'side-effect-free t)
(defalias 'isearch--state-pop-fun--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-pop-fun (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 12)) nil] 7])
(put 'isearch--state-pop-fun 'compiler-macro 'isearch--state-pop-fun--cmacro)
(defalias 'isearch--state-pop-fun #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 12] 4])
(function-put 'isearch--state-pop-fun 'side-effect-free t)
#@51 Constructor for objects of type `isearch--state'.
(defalias 'isearch--get-state #[nil "\n`
\n \f
\205- \306\307 \f\n\f&
.\f\207" [isearch-string string isearch-message message point isearch-success vector cl-struct-isearch--state success isearch-forward forward isearch-other-end other-end isearch-regexp-function word isearch-error error isearch-wrapped wrapped isearch-barrier barrier isearch-case-fold-search case-fold-search isearch-push-state-function pop-fun] 14 (#$ . 47525)])
(byte-code "\300\301\302\303#\210\304\305\306\307\306\211\310\311\312\303& \207" [function-put isearch--get-state side-effect-free t cl-struct-define isearch--state nil cl-structure-object ((cl-tag-slot) (string :read-only t) (message :read-only t) (point :read-only t) (success :read-only t) (forward :read-only t) (other-end :read-only t) (word :read-only t) (error :read-only t) (wrapped :read-only t) (barrier :read-only t) (case-fold-search :read-only t) (pop-fun :read-only t)) cl-struct-isearch--state-tags cl-struct-isearch--state] 10)
(defalias 'isearch--set-state #[(cmd) "\306H >\204 \307\310\311D\"\210\312H\306H >\204\" \307\310\311D\"\210\313H\306H >\2045 \307\310\311D\"\210\314H\306H >\204H \307\310\311D\"\210\315H\306H >\204[ \307\310\311D\"\210\316H\306H >\204o \307\310\311D\"\210\317H\306H >\204\203 \307\310\311D\"\210\320H\306H >\204\227 \307\310\311D\"\210\321H\306H >\204\253 \307\310\311D\"\210\322H\306H >\204\277 \307\310\311D\"\210\323H \324\306H >\204\324 \307\310\311D\"\210\325H!\203\360 \306H >\204\352 \307\310\311D\"\210\325H!\210\306H >\204\377 \307\310\311D\"\210\326Hb\207" [cmd cl-struct-isearch--state-tags isearch-string isearch-message isearch-success isearch-forward 0 signal wrong-type-argument isearch--state 1 2 4 5 6 7 8 9 10 11 functionp 12 3 isearch-other-end isearch-regexp-function isearch-error isearch-wrapped isearch-barrier isearch-case-fold-search] 5])
(defalias 'isearch-pop-state #[nil "A\301@!\207" [isearch-cmds isearch--set-state] 2])
(defalias 'isearch-push-state #[nil "\301 B\211\207" [isearch-cmds isearch--get-state] 2])
#@205 Exit search normally.
However, if this is the first command after starting incremental
search and `search-nonincremental-instead' is non-nil, do a
nonincremental search instead via `isearch-edit-string'.
(defalias 'isearch-exit #[nil "\203 G\303U\203 \304\305 \210)\202 \306 \210\307 \207" [search-nonincremental-instead isearch-string isearch-nonincremental 0 t isearch-edit-string isearch-done isearch-clean-overlays] 2 (#$ . 49718) nil])
#@148 Return position of first mismatch in search string, or nil if none.
If MSG is non-nil, use variable `isearch-message', otherwise `isearch-string'.
(defalias 'isearch-fail-pos #[(&optional msg) " \203 \n\202\n \306 \203 \205\274 \203` @\307H>\2042 \310\311\312@D\"\210@\313H\203V @\307H>\204N \310\311\312@D\"\210@\314H\203` \211A\210\202 \205\236 \203\205 @\307H>\204} \310\311\312@D\"\210@\315H\202\236 @\307H>\204\231 \310\311\312@D\"\210@\316H\211;\203\273 \fG
GW\203\273 \f
\307\fGO\232\203\273 \fG\202\274 \307+\207" [isearch-cmds msg isearch-message isearch-string succ-msg curr-msg nil 0 signal wrong-type-argument isearch--state 4 8 2 1 cmds isearch-success isearch-error cl-struct-isearch--state-tags] 5 (#$ . 50172)])
#@236 Holds the next `isearch-regexp-function' inside `with-isearch-suspended'.
If this is set inside code wrapped by the macro
`with-isearch-suspended', then the value set will be used as the
`isearch-regexp-function' once isearch resumes.
(defvar isearch-new-regexp-function nil (#$ . 50961))
(byte-code "\302\303\304\305#\210\306\305\211\203, @\303N\203% \304N\204% \307\304\303N#\210 A\211\204 *\310\303\304\311#\207" [prop --dolist-tail-- defvaralias isearch-new-word isearch-new-regexp-function nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1"] 6)
#@256 Exit Isearch mode, run BODY, and reinvoke the pending search.
You can update the global isearch variables by setting new values to
`isearch-new-string', `isearch-new-message', `isearch-new-forward',
`isearch-new-regexp-function', `isearch-new-case-fold'.
(defalias 'with-isearch-suspended '(macro . #[(&rest body) "\301\302\303\304\305\306\307\310\303B\311BB\312BBBBB\313BB\314BBB\207" [body condition-case nil progn let ((isearch-nonincremental isearch-nonincremental) (isearch-new-string isearch-string) (isearch-new-message isearch-message) (isearch-new-forward isearch-forward) (isearch-new-regexp-function isearch-regexp-function) (isearch-new-case-fold isearch-case-fold-search) (isearch-regexp isearch-regexp) (isearch-op-fun isearch-op-fun) (isearch-cmds isearch-cmds) (isearch-success isearch-success) (isearch-wrapped isearch-wrapped) (isearch-barrier isearch-barrier) (isearch-adjusted isearch-adjusted) (isearch-yank-flag isearch-yank-flag) (isearch-error isearch-error) (isearch-opoint isearch-opoint) (isearch-slow-terminal-mode isearch-slow-terminal-mode) (isearch-small-window isearch-small-window) (isearch-recursive-edit isearch-recursive-edit) (isearch-window-configuration (current-window-configuration)) (minibuffer-message-timeout isearch-original-minibuffer-message-timeout) (isearch-original-minibuffer-message-timeout isearch-original-minibuffer-message-timeout) old-point old-other-end) (condition-case nil (isearch-done t t) (exit nil)) (setq old-point (point) old-other-end isearch-other-end) unwind-protect ((isearch-mode isearch-forward isearch-regexp isearch-op-fun nil isearch-regexp-function) (setq isearch-string isearch-new-string isearch-message isearch-new-message isearch-forward isearch-new-forward isearch-regexp-function isearch-new-regexp-function isearch-case-fold-search isearch-new-case-fold) (funcall (or isearch-message-function #'isearch-message) nil t) (if (and old-other-end (eq old-point (point)) (eq isearch-forward isearch-new-forward)) (goto-char old-other-end))) ((when (= 0 (length isearch-string)) (setq isearch-string (or (car (if isearch-regexp regexp-search-ring search-ring)) #1="") isearch-message (mapconcat 'isearch-text-char-description isearch-string #1#)) (isearch-ring-adjust1 nil))) ((isearch-search) (isearch-push-state) (isearch-update) (if isearch-nonincremental (progn (isearch-done) (if (equal isearch-string #1#) (message #1#))))) ((quit (isearch-abort)))] 10 (#$ . 51552)]))
#@423 Edit the search string in the minibuffer.
The following additional command keys are active while editing.
\<minibuffer-local-isearch-map>
\[exit-minibuffer] to resume incremental searching with the edited string.
\[isearch-forward-exit-minibuffer] to resume isearching forward.
\[isearch-reverse-exit-minibuffer] to resume isearching backward.
\[isearch-complete-edit] to complete the search string using the search ring.
(defalias 'isearch-edit-string #[nil "\3061\370 \n \f
!\"#$%&'()\307 *\211\310\211 + , * - . ) ( ' & % $ # \" ! / 0 1 2 3\3111f \312\313\211\"0\202j \210\202k \210`,4+\314\216\310\211 5 6\310 7\315\316\310\" \317 \206\212 GTB8\310 \203\240 \3209\206\233 \321TB\202\251 \322:\206\247 \321TB\310\313&3\323\3243\325#2, G\326U\203\333 \203\311 \202\313 @\206\320 \325\323\324 \325#\327\310!\210.\330 \210\331 \210\332 \210\205\366 \312 \210 \325\232\205\366 \333\325!0\207\210\334 \207" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-regexp-function isearch-case-fold-search (quit) current-window-configuration nil (exit) isearch-done t #[nil "\306 \n\307 %\210\f\n \f
\206 \310\307\311\"\210\2058 `=\2058 =\2058 b\207" [isearch-forward isearch-regexp isearch-op-fun isearch-regexp-function isearch-new-string isearch-string isearch-mode nil isearch-message t isearch-new-message isearch-new-forward isearch-new-regexp-function isearch-new-case-fold isearch-case-fold-search isearch-message-function old-other-end old-point] 6] read-from-minibuffer isearch-message-prefix isearch-fail-pos regexp-search-ring -1 search-ring mapconcat isearch-text-char-description "" 0 isearch-ring-adjust1 isearch-search isearch-push-state isearch-update message isearch-abort isearch-regexp isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout old-other-end old-point minibuffer-message-timeout isearch-window-configuration isearch-new-case-fold isearch-new-regexp-function isearch-new-forward isearch-new-message isearch-new-string isearch-other-end message-log-max history-add-new-input minibuffer-history-symbol minibuffer-local-isearch-map regexp-search-ring-yank-pointer search-ring-yank-pointer] 25 (#$ . 54011) nil])
(defalias 'isearch-nonincremental-exit-minibuffer #[nil "\301\302 \207" [isearch-nonincremental t exit-minibuffer] 1 nil nil])
(make-obsolete 'isearch-nonincremental-exit-minibuffer 'exit-minibuffer "24.4")
#@77 Resume isearching forward from the minibuffer that edits the search string.
(defalias 'isearch-forward-exit-minibuffer #[nil "\301\302 \207" [isearch-new-forward t exit-minibuffer] 1 (#$ . 56661) nil])
#@78 Resume isearching backward from the minibuffer that edits the search string.
(defalias 'isearch-reverse-exit-minibuffer #[nil "\301\302 \207" [isearch-new-forward nil exit-minibuffer] 1 (#$ . 56870) nil])
#@57 Terminate the search and go back to the starting point.
(defalias 'isearch-cancel #[nil "\203 \203 \303 !\304 @!\210)\202 \nb\210\305\306!\210\307 \210\310\311\312\"\207" [isearch-push-state-function isearch-cmds isearch-opoint last isearch--set-state isearch-done t isearch-clean-overlays signal quit nil] 3 (#$ . 57082) nil])
#@193 Abort incremental search mode if searching is successful, signaling quit.
Otherwise, revert to previous successful search and continue searching.
Use `isearch-exit' to quit without signaling.
(defalias 'isearch-abort #[nil "\302 \210\203 \204 \303\304 \207\203 \203 \305 \210\202 \306 \207" [isearch-success isearch-error discard-input nil isearch-cancel isearch-pop-state isearch-update] 1 (#$ . 57423) nil])
(defalias 'isearch-repeat #[(direction) " \306==\203_ \n\307\232\203= \203 \f\202
\204 \310\202e \203( \f\202)
@\311\312\n\307#\313\314!\210\202e \204e \315\203Q \210\202e \203Y e\202Z db\210\202e ?\315`\n\307\232\203t \315\202\256 \203\253 ` \232\203\253 \204\253 \203\215 m\202\216 o\203\232 \314\316 \210\202\256 \203\242 \317\202\243 \320u\210\321 \210\202\256 \321 \210\322 \210\323 \207" [isearch-forward direction isearch-string isearch-regexp regexp-search-ring search-ring forward "" "No previous search string" mapconcat isearch-text-char-description isearch-ring-adjust1 nil t ding 1 -1 isearch-search isearch-push-state isearch-update isearch-error isearch-message isearch-last-case-fold-search isearch-case-fold-search isearch-success isearch-wrapped isearch-wrap-function isearch-barrier isearch-other-end isearch-just-started] 4])
#@37 Repeat incremental search forwards.
(defalias 'isearch-repeat-forward #[nil "\300\301!\207" [isearch-repeat forward] 2 (#$ . 58739) nil])
#@38 Repeat incremental search backwards.
(defalias 'isearch-repeat-backward #[nil "\300\301!\207" [isearch-repeat backward] 2 (#$ . 58883) nil])
#@419 Define a command called `isearch-toggle-MODE' and bind it to `M-s KEY'.
The first line of the command's docstring is auto-generated, the
remainder may be provided in DOCSTRING.
If FUNCTION is a symbol, this command first toggles the value of
`isearch-regexp-function' between nil and FUNCTION. Also set the
`isearch-message-prefix' property of FUNCTION.
The command then executes BODY and updates the isearch prompt.
(defalias 'isearch-define-mode-toggle '(macro . #[(mode key function &optional docstring &rest body) "\306\307\310\"!\311 P\312\313\n\314\307\315 \203 \316 P\202 \317#\320\321\f\2054 \322\323\324\325\323\304\fDE\304\fDEE\326B
\327#BBBBB\330\331 \304\nDF\f\205x \f9\205x \332\333\fD\334\307\335\"F\332\333\fD\336 F\337\340\341\342\343\342\333\344\345\346\307\347\"!\fFD\350BBEE\351BBE*BBB\207" [mode key command-name docstring function body intern format "isearch-toggle-%s" "\363" progn defun nil "Toggle %s searching on or off.%s" "\n" "" (interactive) append setq isearch-regexp-function unless eq ((setq isearch-regexp nil)) ((setq isearch-success t isearch-adjusted t) (isearch-update)) define-key isearch-mode-map put quote 'isearch-message-prefix "%s " :advertised-binding cl-callf lambda (types) cons 'choice const :tag capitalize "%s search" ((cdr types)) ((get 'search-default-mode 'custom-type))] 18 (#$ . 59031)]))
(function-put 'isearch-define-mode-toggle 'lisp-indent-function 'defun)
#@80 Toggle word searching on or off.
Turning on word search turns off regexp mode.
(defalias 'isearch-toggle-word #[nil "\304=?\205 \304\305\306\211\307 \207" [isearch-regexp-function isearch-regexp isearch-success isearch-adjusted word-search-regexp nil t isearch-update] 3 (#$ . 60461) nil])
(byte-code "\302\303\304#\210\305\306\307\310#\210\305\306\311\303#\210\305\312\313\312\313N\314\315 A)BB#\207" [isearch-mode-map types define-key "\363w" isearch-toggle-word put word-search-regexp isearch-message-prefix "word " :advertised-binding search-default-mode custom-type choice (const :tag "Word Search" word-search-regexp)] 6)
#@84 Toggle symbol searching on or off.
Turning on symbol search turns off regexp mode.
(defalias 'isearch-toggle-symbol #[nil "\304=?\205 \304\305\306\211\307 \207" [isearch-regexp-function isearch-regexp isearch-success isearch-adjusted isearch-symbol-regexp nil t isearch-update] 3 (#$ . 61103) nil])
(byte-code "\302\303\304#\210\305\306\307\310#\210\305\306\311\303#\210\305\312\313\312\313N\314\315 A)BB#\207" [isearch-mode-map types define-key "\363_" isearch-toggle-symbol put isearch-symbol-regexp isearch-message-prefix "symbol " :advertised-binding search-default-mode custom-type choice (const :tag "Symbol Search" isearch-symbol-regexp)] 6)
#@91 Toggle char-fold searching on or off.
Turning on character-folding turns off regexp mode.
(defalias 'isearch-toggle-char-fold #[nil "\304=?\205 \304\305\306\211\307 \207" [isearch-regexp-function isearch-regexp isearch-success isearch-adjusted char-fold-to-regexp nil t isearch-update] 3 (#$ . 61766) nil])
(byte-code "\302\303\304#\210\305\306\307\310#\210\305\306\311\303#\210\305\312\313\312\313N\314\315 A)BB#\210\305\306\307\310#\207" [isearch-mode-map types define-key "\363'" isearch-toggle-char-fold put char-fold-to-regexp isearch-message-prefix "char-fold " :advertised-binding search-default-mode custom-type choice (const :tag "Char-Fold Search" char-fold-to-regexp)] 6)
#@36 Toggle regexp searching on or off.
(defalias 'isearch-toggle-regexp #[nil "?\211\203 \304\305\211\306 \207" [isearch-regexp isearch-regexp-function isearch-success isearch-adjusted nil t isearch-update] 2 (#$ . 62463) nil])
(define-key isearch-mode-map "\363r" 'isearch-toggle-regexp)
#@60 Print STRING at the end of the isearch prompt for 1 second
(defalias 'isearch--momentary-message #[(string) "\304\305\306\307\304 \"\n $\210)\310\311!\207" [message-log-max isearch-nonincremental isearch-message string nil message "%s%s [%s]" isearch-message-prefix sit-for 1] 5 (#$ . 62760)])
#@210 Toggle lax-whitespace searching on or off.
In ordinary search, toggles the value of the variable
`isearch-lax-whitespace'. In regexp search, toggles the
value of the variable `isearch-regexp-lax-whitespace'.
(defalias 'isearch-toggle-lax-whitespace #[nil "\305\203\f ?\211\202 \n?\211\203 \306\202 \307!\210\310\211\311 \207" [isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace isearch-success isearch-adjusted isearch--momentary-message "match spaces loosely" "match spaces literally" t isearch-update] 4 (#$ . 63062) nil])
(define-key isearch-mode-map "\363 " 'isearch-toggle-lax-whitespace)
#@101 Toggle case-fold searching on or off.
Toggles the value of the variable `isearch-case-fold-search'.
(defalias 'isearch-toggle-case-fold #[nil "\303?\205 \304\211\203 \305\202 \306!\210\307\211\310 \207" [isearch-case-fold-search isearch-success isearch-adjusted isearch--momentary-message yes "case insensitive" "case sensitive" t isearch-update] 4 (#$ . 63690) nil])
(define-key isearch-mode-map "\363c" 'isearch-toggle-case-fold)
#@258 Toggle invisible searching on or off.
This determines whether to search inside invisible text or not.
Toggles the variable `isearch-invisible' between values
nil and a non-nil value of the option `search-invisible'
(or `open' if `search-invisible' is nil).
(defalias 'isearch-toggle-invisible #[nil "\304?\205 \206 \305\211\203 \306\202 \307!\210\310\211\311 \207" [isearch-invisible search-invisible isearch-success isearch-adjusted isearch--momentary-message open "match invisible text" "match visible text" t isearch-update] 4 (#$ . 64136) nil])
(define-key isearch-mode-map "\363i" 'isearch-toggle-invisible)
#@531 Return a regexp which matches words, ignoring punctuation.
Given STRING, a string of words separated by word delimiters,
compute a regexp that matches those exact words separated by
arbitrary punctuation. If the string begins or ends in whitespace,
the beginning or the end of the string matches arbitrary whitespace.
Otherwise if LAX is non-nil, the beginning or the end of the string
need not match a word boundary.
Used in `word-search-forward', `word-search-backward',
`word-search-forward-lax', `word-search-backward-lax'.
(defalias 'word-search-regexp #[(string &optional lax) "\303\232\203 \303\207\304\305\306\307#)\266\203\203 \310\207\311\305\306\307#)\266\203\203. \310\2024 \n?\2054 \312\313\314\315\310\306#\310#\316\305\306\307#)\266\203\203Q \310\202W \n?\205W \317Q\207" [string inhibit-changing-match-data lax "" "\\`\\W+\\'" nil t string-match "\\W+" "\\`\\W" "\\<" mapconcat regexp-quote split-string "\\W\\'" "\\>"] 9 (#$ . 64765)])
#@1179 Search backward from point for STRING, ignoring differences in punctuation.
Set point to the beginning of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not begin before that position. A value of nil
means search to the beginning of the accessible portion of the buffer.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, position at limit of search and return nil.
Optional fourth argument COUNT, if a positive number, means to search
for COUNT successive occurrences. If COUNT is negative, search
forward, instead of backward, for -COUNT occurrences. A value of
nil means the same as 1.
With COUNT positive, the match found is the COUNTth to last one (or
last, if COUNT is 1 or nil) in the buffer located entirely before
the origin of the search; correspondingly with COUNT negative.
Relies on the function `word-search-regexp' to convert a sequence
of words in STRING to a regexp used to search words without regard
to punctuation.
This command does not support character folding, and lax space matching
has no effect on it.
(defalias 'word-search-backward #[(string &optional bound noerror count) "\304\305\306\" \n $\207" [string bound noerror count re-search-backward word-search-regexp nil] 5 (#$ . 65747) "sWord search backward: "])
#@1151 Search forward from point for STRING, ignoring differences in punctuation.
Set point to the end of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not end after that position. A value of nil
means search to the end of the accessible portion of the buffer.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil.
Optional fourth argument COUNT, if a positive number, means to search
for COUNT successive occurrences. If COUNT is negative, search
backward, instead of forward, for -COUNT occurrences. A value of
nil means the same as 1.
With COUNT positive, the match found is the COUNTth one (or first,
if COUNT is 1 or nil) in the buffer located entirely after the
origin of the search; correspondingly with COUNT negative.
Relies on the function `word-search-regexp' to convert a sequence
of words in STRING to a regexp used to search words without regard
to punctuation.
This command does not support character folding, and lax space matching
has no effect on it.
(defalias 'word-search-forward #[(string &optional bound noerror count) "\304\305\306\" \n $\207" [string bound noerror count re-search-forward word-search-regexp nil] 5 (#$ . 67147) "sWord search: "])
#@1296 Search backward from point for STRING, ignoring differences in punctuation.
Set point to the beginning of the occurrence found, and return point.
Unlike `word-search-backward', the end of STRING need not match a word
boundary, unless STRING ends in whitespace.
An optional second argument bounds the search; it is a buffer position.
The match found must not begin before that position. A value of nil
means search to the beginning of the accessible portion of the buffer.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, position at limit of search and return nil.
Optional fourth argument COUNT, if a positive number, means to search
for COUNT successive occurrences. If COUNT is negative, search
forward, instead of backward, for -COUNT occurrences. A value of
nil means the same as 1.
With COUNT positive, the match found is the COUNTth to last one (or
last, if COUNT is 1 or nil) in the buffer located entirely before
the origin of the search; correspondingly with COUNT negative.
Relies on the function `word-search-regexp' to convert a sequence
of words in STRING to a regexp used to search words without regard
to punctuation.
This command does not support character folding, and lax space matching
has no effect on it.
(defalias 'word-search-backward-lax #[(string &optional bound noerror count) "\304\305\306\" \n $\207" [string bound noerror count re-search-backward word-search-regexp t] 5 (#$ . 68508) "sWord search backward: "])
#@1267 Search forward from point for STRING, ignoring differences in punctuation.
Set point to the end of the occurrence found, and return point.
Unlike `word-search-forward', the end of STRING need not match a word
boundary, unless STRING ends in whitespace.
An optional second argument bounds the search; it is a buffer position.
The match found must not end after that position. A value of nil
means search to the end of the accessible portion of the buffer.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil.
Optional fourth argument COUNT, if a positive number, means to search
for COUNT successive occurrences. If COUNT is negative, search
backward, instead of forward, for -COUNT occurrences. A value of
nil means the same as 1.
With COUNT positive, the match found is the COUNTth one (or first,
if COUNT is 1 or nil) in the buffer located entirely after the
origin of the search; correspondingly with COUNT negative.
Relies on the function `word-search-regexp' to convert a sequence
of words in STRING to a regexp used to search words without regard
to punctuation.
This command does not support character folding, and lax space matching
has no effect on it.
(defalias 'word-search-forward-lax #[(string &optional bound noerror count) "\304\305\306\" \n $\207" [string bound noerror count re-search-forward word-search-regexp t] 5 (#$ . 70027) "sWord search: "])
#@483 Return a regexp which matches STRING as a symbol.
Creates a regexp where STRING is surrounded by symbol delimiters \_< and \_>.
If there are more than one symbol, then compute a regexp that matches
those exact symbols separated by non-symbol characters. If the string
begins or ends in whitespace, the beginning or the end of the string
matches arbitrary non-symbol whitespace. Otherwise if LAX is non-nil,
the beginning or the end of the string need not match a symbol boundary.
(defalias 'isearch-symbol-regexp #[(string &optional lax) "\304 \305\232\203\f \305\202g \306\307\" \310\311\312#)\266\203\203# \202g \306\313\" \310\311\312#)\266\203\203: \202@ ?\205@ \314\315\316\317 \311##\306\320\" \310\311\312#)\266\203\203` \202f ?\205f \321Q)\207" [not-word-symbol-re string inhibit-changing-match-data lax "\\(?:\\s-\\|\\s.\\|\\s(\\|\\s)\\|\\s\"\\|\\s\\\\|\\s/\\|\\s$\\|\\s'\\|\\s<\\|\\s>\\|\\s@\\|\\s!\\|\\s|\\)+" "" format "\\`%s\\'" nil t string-match "\\`%s" "\\_<" mapconcat regexp-quote split-string "%s\\'" "\\_>"] 9 (#$ . 71505)])
(put 'isearch-symbol-regexp 'isearch-message-prefix "symbol ")
#@69 Search forward for STRING, matching a sequence of whitespace chars.
(defalias 'search-forward-lax-whitespace #[(string &optional bound noerror count) "\306\307\n! \f
$)\207" [search-whitespace-regexp search-spaces-regexp string bound noerror count re-search-forward regexp-quote] 5 (#$ . 72644)])
#@70 Search backward for STRING, matching a sequence of whitespace chars.
(defalias 'search-backward-lax-whitespace #[(string &optional bound noerror count) "\306\307\n! \f
$)\207" [search-whitespace-regexp search-spaces-regexp string bound noerror count re-search-backward regexp-quote] 5 (#$ . 72949)])
#@69 Search forward for REGEXP, matching a sequence of whitespace chars.
(defalias 're-search-forward-lax-whitespace #[(regexp &optional bound noerror count) "\306\n \f
$)\207" [search-whitespace-regexp search-spaces-regexp regexp bound noerror count re-search-forward] 5 (#$ . 73257)])
#@70 Search backward for REGEXP, matching a sequence of whitespace chars.
(defalias 're-search-backward-lax-whitespace #[(regexp &optional bound noerror count) "\306\n \f
$)\207" [search-whitespace-regexp search-spaces-regexp regexp bound noerror count re-search-backward] 5 (#$ . 73547)])
(byte-code "\302\303\211\203 @\304\305\306#\210 A\211\204 *\303\207" [old --dolist-tail-- (re-search-forward-lax-whitespace search-backward-lax-whitespace search-forward-lax-whitespace re-search-backward-lax-whitespace) nil make-obsolete "instead, use (let ((search-spaces-regexp search-whitespace-regexp))\n (re-search-... ...))" "25.1"] 5)
#@501 Start `query-replace' with string to replace from last search string.
The ARG (prefix arg if interactive), if non-nil, means replace
only matches surrounded by word boundaries. A negative prefix
arg means replace backward. Note that using the prefix arg
is possible only when `isearch-allow-scroll' is non-nil or
`isearch-allow-prefix' is non-nil, and it doesn't always provide the
correct matches for `query-replace', so the preferred way to run word
replacements from Isearch is `M-s w ... M-%'.
(defalias 'isearch-query-replace #[(&optional arg regexp-flag) "\306 \210\203 \307\n\310 \f
\205 \311=?\205! \311=\310 \312\310\307\"\210\313 \210 \203s \203K `V\202O `W\203s !\203o \"\203o \203h \314 `V\202l \314 `W\204s b\210#$#JBL\210\315$\316$\317\320\206\214 %\307\"\203\227 \321\202\230 \322!\203\246 \"\203\246 \323\202\247 \322R #\307 \206\263 %\310\211!\205\301 \"\205\301 \324 !\205\315 \"\205\315 \325 &\n\210.\205\333 \326 \207" [regexp-flag isearch-regexp isearch-case-fold-search isearch-invisible isearch-lax-whitespace isearch-regexp-lax-whitespace barf-if-buffer-read-only t nil - isearch-done isearch-clean-overlays mark perform-replace query-replace-read-to "Query replace" isearch--describe-regexp-mode " backward" "" " in region" region-beginning region-end exit-recursive-edit arg isearch-recursive-edit backward delimited replace-regexp-lax-whitespace replace-lax-whitespace search-invisible search-upper-case case-fold-search isearch-other-end transient-mark-mode mark-active query-replace-from-history-variable isearch-string isearch-regexp-function] 11 (#$ . 74205) (list current-prefix-arg)])
#@128 Start `query-replace-regexp' with string to replace from last search string.
See `isearch-query-replace' for more information.
(defalias 'isearch-query-replace-regexp #[(&optional arg) "\301\302\"\207" [arg isearch-query-replace t] 3 (#$ . 75896) (list current-prefix-arg)])
#@553 Run `occur' using the last search string as the regexp.
Interactively, REGEXP is constructed using the search string from the
last search command. NLINES has the same meaning as in `occur'.
If the last search command was a word search, REGEXP is computed from
the search words, ignoring punctuation. If the last search
command was a regular expression search, REGEXP is the regular
expression used in that search. If the last search command searched
for a literal string, REGEXP is constructed by quoting all the special
characters in that string.
(defalias 'isearch-occur #[(regexp &optional nlines) "\306 \203\n \n\202 \205 \f \f
\307\203) \310\311 \312\313!%\202+ \"+\207" [isearch-case-fold-search isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace search-whitespace-regexp search-spaces-regexp nil occur propertize isearch-string isearch-regexp-function-descr isearch--describe-regexp-mode search-upper-case case-fold-search isearch-regexp-function regexp nlines] 8 (#$ . 76179) (let* ((perform-collect (consp current-prefix-arg)) (regexp (cond ((functionp isearch-regexp-function) (funcall isearch-regexp-function isearch-string)) (isearch-regexp-function (word-search-regexp isearch-string)) (isearch-regexp isearch-string) (t (regexp-quote isearch-string))))) (list regexp (if perform-collect (if (= 0 (regexp-opt-depth regexp)) "\\&" (let ((default (car occur-collect-regexp-history)) regexp-collect) (condition-case nil (progn (let ((isearch-nonincremental isearch-nonincremental) (isearch-new-string isearch-string) (isearch-new-message isearch-message) (isearch-new-forward isearch-forward) (isearch-new-regexp-function isearch-regexp-function) (isearch-new-case-fold isearch-case-fold-search) (isearch-regexp isearch-regexp) (isearch-op-fun isearch-op-fun) (isearch-cmds isearch-cmds) (isearch-success isearch-success) (isearch-wrapped isearch-wrapped) (isearch-barrier isearch-barrier) (isearch-adjusted isearch-adjusted) (isearch-yank-flag isearch-yank-flag) (isearch-error isearch-error) (isearch-opoint isearch-opoint) (isearch-slow-terminal-mode isearch-slow-terminal-mode) (isearch-small-window isearch-small-window) (isearch-recursive-edit isearch-recursive-edit) (isearch-window-configuration (current-window-configuration)) (minibuffer-message-timeout isearch-original-minibuffer-message-timeout) (isearch-original-minibuffer-message-timeout isearch-original-minibuffer-message-timeout) old-point old-other-end) (condition-case nil (isearch-done t t) (exit nil)) (setq old-point (point) old-other-end isearch-other-end) (unwind-protect (progn (setq regexp-collect (read-regexp (format "Regexp to collect (default %s): " default) default 'occur-collect-regexp-history))) (isearch-mode isearch-forward isearch-regexp isearch-op-fun nil isearch-regexp-function) (setq isearch-string isearch-new-string isearch-message isearch-new-message isearch-forward isearch-new-forward isearch-regexp-function isearch-new-regexp-function isearch-case-fold-search isearch-new-case-fold) (funcall (or isearch-message-function #'isearch-message) nil t) (if (and old-other-end (eq old-point (point)) (eq isearch-forward isearch-new-forward)) (goto-char old-other-end))) (if (= 0 (length isearch-string)) (progn (setq isearch-string (or (car (if isearch-regexp regexp-search-ring search-ring)) #1="") isearch-message (mapconcat 'isearch-text-char-description isearch-string #1#)) (isearch-ring-adjust1 nil)))) (isearch-search) (isearch-push-state) (isearch-update) (if isearch-nonincremental (progn (isearch-done) (if (equal isearch-string #1#) (message #1#))))) (quit (isearch-abort))) regexp-collect)) (if current-prefix-arg (progn (prefix-numeric-value current-prefix-arg))))))])
#@262 Run `highlight-regexp' with regexp from the current search string.
It exits Isearch mode and calls `hi-lock-face-buffer' with its regexp
argument from the last search regexp or a quoted search string,
and reads its face argument using `hi-lock-read-face-name'.
(defalias 'isearch-highlight-regexp #[nil "\306\307\306\310\"\210\311 \210)\312\313\306\310#\210\314 !\203 \n!\202O \203' \315\n!\202O \203/ \n\202O \f\310=\203@
\203@ \316\n \"\202A \f\203L \317\320\n\321#\202O \322\n! \323\324 \"\210)\205_ \325 \207" [isearch-recursive-edit isearch-regexp-function isearch-string isearch-regexp isearch-case-fold-search search-upper-case nil isearch-done t isearch-clean-overlays require hi-lock functionp word-search-regexp isearch-no-upper-case-p mapconcat #[(c) "\302!\303\304 \"\203 \305\306 \226 \227#\202 \307 !)\207" [c s string string-match "[[:alpha:]]" format "[%s%s]" regexp-quote] 4] "" regexp-quote hi-lock-face-buffer hi-lock-read-face-name exit-recursive-edit regexp] 4 (#$ . 79909) nil])
#@268 Discard last input item and move point back.
Last input means the last character or the last isearch command
that added or deleted characters from the search string,
moved point, toggled regexp mode or case-sensitivity, etc.
If no previous match was done, just beep.
(defalias 'isearch-delete-char #[nil "A\204 \301 \210\202 \302 \210\303 \207" [isearch-cmds ding isearch-pop-state isearch-update] 1 (#$ . 80931) nil])
#@222 Delete character from end of search string and search again.
Unlike `isearch-delete-char', it only deletes the last character,
but doesn't cancel the effect of other isearch command.
If search string is empty, just beep.
(defalias 'isearch-del-char #[(&optional arg) "G\305U\203
\306 \210\202 \305 \206 \307G^[O\310\311\312# \206% \302\313\314\"\210\f\2030 \fb\210\315 \210\316 \210\317 \207" [isearch-string arg isearch-message isearch-message-function isearch-other-end 0 ding 1 mapconcat isearch-text-char-description "" nil t isearch-search isearch-push-state isearch-update] 4 (#$ . 81360) "p"])
#@33 Pull STRING into search string.
(defalias 'isearch-yank-string #[(string) "\203
\305=\203
\n\227 \203 \306\n!\307\310\n\311\312\n\313#\"\207" [isearch-case-fold-search search-upper-case string isearch-regexp isearch-yank-flag not-yanks regexp-quote t isearch-process-search-string mapconcat isearch-text-char-description ""] 6 (#$ . 81976)])
#@48 Pull string from kill ring into search string.
(defalias 'isearch-yank-kill #[nil "\300\301\302!!\207" [isearch-yank-string current-kill 0] 3 (#$ . 82332) nil])
#@66 Replace just-yanked search string with previously killed string.
(defalias 'isearch-yank-pop #[nil "\301>\204 \302 \207\303 \210\304\305\306!!\207" [last-command (isearch-yank-kill isearch-yank-pop) isearch-yank-kill isearch-pop-state isearch-yank-string current-kill 1] 3 (#$ . 82499) nil])
#@46 Pull current X selection into search string.
(defalias 'isearch-yank-x-selection #[nil "\301\302 !\210\205 \303 \207" [select-active-regions isearch-yank-string gui-get-selection deactivate-mark] 2 (#$ . 82799) nil])
#@193 Handle mouse-2 in Isearch mode.
For a click in the echo area, invoke `isearch-yank-x-selection'.
Otherwise invoke whatever the calling mouse-2 command sequence
is bound to outside of Isearch.
(defalias 'isearch-mouse-2 #[(click) "\304!\211@\262\305\306\307 \310\"\311 !\203! \312 !\204! \313 \202* \314 !\205* \315 !+\207" [click w overriding-terminal-local-map binding event-start nil key-binding this-command-keys-vector t window-minibuffer-p minibuffer-window-active-p isearch-yank-x-selection functionp call-interactively] 3 (#$ . 83025) "e"])
#@41 Pull terminal paste into search string.
(defalias 'isearch-xterm-paste #[nil "\300\301 !\207" [isearch-yank-string xterm--pasted-text] 2 (#$ . 83584) nil])
#@318 Pull the text from point to the point reached by JUMPFORM.
JUMPFORM is a lambda expression that takes no arguments and returns
a buffer position, possibly having moved point to that position.
For example, it might move point forward by a word and return point,
or it might return the position of the end of the line.
(defalias 'isearch-yank-internal #[(jumpform) "\303\212\204
\203
b\210\304`\n \")!\207" [isearch-forward isearch-other-end jumpform isearch-yank-string buffer-substring-no-properties] 4 (#$ . 83747)])
#@74 Pull next character from buffer into end of search string in minibuffer.
(defalias 'isearch-yank-char-in-minibuffer #[(&optional arg) "m\203 r\301 A@q\210\302`u\210`\")c\207u\207" [arg buffer-list buffer-substring-no-properties] 3 (#$ . 84276) "p"])
#@114 Pull next character from buffer into search string.
If optional ARG is non-nil, pull in the next ARG characters.
(defalias 'isearch-yank-char #[(&optional arg) "\300\301!\207" [isearch-yank-internal #[nil "u\210`\207" [arg] 1]] 2 (#$ . 84536) "p"])
#@121 Pull next character, subword or word from buffer into search string.
Subword is used when `subword-mode' is activated.
(defalias 'isearch-yank-word-or-char #[nil "\300\301!\207" [isearch-yank-internal #[nil "\302f\206 \303z\304U\204 `Tf\206 \303z\304U\203: \305\300!\203# \204- \305\301!\2034 \2034 \306\307!\210\202= \307v\210\202= \307u\210`\207" [subword-mode superword-mode nil 0 119 boundp subword-forward 1] 2]] 2 (#$ . 84793) nil])
#@104 Pull next word from buffer into search string.
If optional ARG is non-nil, pull in the next ARG words.
(defalias 'isearch-yank-word #[(&optional arg) "\300\301!\207" [isearch-yank-internal #[nil "v\210`\207" [arg] 1]] 2 (#$ . 85245) "p"])
#@104 Pull rest of line from buffer into search string.
If optional ARG is non-nil, yank the next ARG lines.
(defalias 'isearch-yank-line #[(&optional arg) "\300\301!\207" [isearch-yank-internal #[nil "\302\303l\203\f T\202
!)\207" [inhibit-field-text-motion arg t line-end-position] 2]] 2 (#$ . 85492) "p"])
#@196 Read a character by its Unicode name and add it to the search string.
Completion is available like in `read-char-by-name' used by `insert-char'.
With argument, add COUNT copies of the character.
(defalias 'isearch-char-by-name #[(&optional count) "\3061\353 \n \f
!\"#$%&'(\307 )\211\310\211 * + ) , - ( ' & % $ # \" ! . / 0 1 2\3111f \312\313\211\"0\202j \210\202k \210`+3*\314\216\315\316!\211 4\203\252 5\250\203\223 5\317V\203\223 \32054\"\202\227 \3214! 6 6P2\n\322\3236\324#P1)* G\325U\203\316 \203\274 7\202\276 8@\206\303 \324\322\323 \324#\326\310!\210.\327 \210\330 \210\331 \210\205\351 \312 \210 \324\232\205\351 \332\324!0\207\210\333 \207" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-regexp-function isearch-case-fold-search (quit) current-window-configuration nil (exit) isearch-done t #[nil "\306 \n\307 %\210\f\n \f
\206 \310\307\311\"\210\2058 `=\2058 =\2058 b\207" [isearch-forward isearch-regexp isearch-op-fun isearch-regexp-function isearch-new-string isearch-string isearch-mode nil isearch-message t isearch-new-message isearch-new-forward isearch-new-regexp-function isearch-new-case-fold isearch-case-fold-search isearch-message-function old-other-end old-point] 6] read-char-by-name "Add character to search (Unicode name or hex): " 1 make-string char-to-string mapconcat isearch-text-char-description "" 0 isearch-ring-adjust1 isearch-search isearch-push-state isearch-update message isearch-abort isearch-regexp isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout old-other-end old-point minibuffer-message-timeout isearch-window-configuration isearch-new-case-fold isearch-new-regexp-function isearch-new-forward isearch-new-message isearch-new-string isearch-other-end char count string regexp-search-ring search-ring] 25 (#$ . 85806) "p"])
(defalias 'isearch-search-and-update #[nil "\204 \204 \n\306\203\276 \204\224 \f\204\224 \3071`
\211 \310=\203/ \203/ \311 \"\312\313!\203@ \310\"\202Z \203M \314\310\"\202Z \203V \202Z \315!!)0\202d \210\202\224 \203\224 \204w \316\225^X\203\224 \310\306\316\225
\310=\203\276 \203\276 \311 \"\202\276 \206\232 \317\306\310\"\210\203\273 \f\204\273 \203\260 \202\271 ^T^b\210\320 \210\321 \210 \203\312 \210\322 \207" [isearch-success isearch-regexp isearch-hidden isearch-forward isearch-adjusted isearch-case-fold-search nil (error) t isearch-no-upper-case-p looking-at functionp word-search-regexp regexp-quote 0 isearch-message isearch-search isearch-push-state isearch-update case-fold-search search-upper-case isearch-string isearch-regexp-function isearch-yank-flag isearch-opoint isearch-barrier isearch-error isearch-other-end isearch-message-function isearch-op-fun] 5])
#@55 Return t if STR ends in an odd number of backslashes.
(defalias 'isearch-backslash #[(str) "\301G\302\303\"Z\304\"\305U\207" [str mod string-match "\\\\*\\'" 2 1] 5 (#$ . 88842)])
#@515 Return point to previous successful match to allow regexp liberalization.
\<isearch-mode-map>
Respects \[isearch-repeat-forward] and \[isearch-repeat-backward] by stopping at `isearch-barrier' as needed.
Do nothing if a backslash is escaping the liberalizing character.
If WANT-BACKSLASH is non-nil, invert this behavior (for \} and \|).
Do nothing if regexp has recently been invalid unless optional
ALLOW-INVALID non-nil.
If optional TO-BARRIER non-nil, ignore previous matches and go exactly
to the barrier.
(defalias 'isearch-fallback #[(want-backslash &optional allow-invalid to-barrier) "\205\f\306 !?\n?=\205\f \2032 \fA@\211 \307H>\204& \310\311\312
D\"\210
\313H)\2032 \205\f\203@ b\210\314\211\207\f\211 A @ \203\307 \307H>\204c \310\311\312D\"\210\313H\204\266 \307H>\204| \310\311\312D\"\210\315H\211 \211GSH \306@\307H>\204\236 \310\311\312@D\"\210@\315H!\203\256 \316=\202\262 \317>*\203\307 A@\202L \205 @\203\356 @\307H>\204\346 \310\311\312@D\"\210@\320H\206\360 \203\377 ]\202^b\210\314\211)+\207" [isearch-regexp isearch-string want-backslash isearch-error isearch-cmds cl-x isearch-backslash 0 signal wrong-type-argument isearch--state 8 t 1 125 (42 63 43) 6 cl-struct-isearch--state-tags allow-invalid to-barrier isearch-barrier isearch-adjusted stack previous frame string lchar last-other-end isearch-forward] 6 (#$ . 89031)])
(byte-code "\300\301!\203\f \302\301\303\304#\210\300\305!\203 \302\305\303\304#\210\302\306\303\304#\210\302\307\303\304#\210\302\310\303\304#\210\302\311\303\304#\210\302\312\303\304#\210\302\313\303\304#\210\302\314\303\304#\210\302\315\303\304#\210\302\316\303\304#\210\302\317\303\304#\210\302\320\303\304#\210\302\321\303\304#\210\302\322\303\304#\210\302\323\303\304#\210\302\324\303\304#\210\302\325\303\304#\210\302\326\303\304#\210\302\327\303\304#\210\330\331\332\333\334\335\336\337&\210\330\340\304\341\342\343\334\335\336\337& \207" [fboundp scroll-bar-toolkit-scroll put isearch-scroll t w32-handle-scroll-bar-event recenter recenter-top-bottom reposition-window list-buffers scroll-other-window scroll-other-window-down beginning-of-buffer-other-window end-of-buffer-other-window delete-other-windows balance-windows split-window-right split-window-below enlarge-window split-window-vertically split-window-horizontally universal-argument negative-argument digit-argument custom-declare-variable isearch-allow-scroll nil "Whether scrolling is allowed during incremental search.\nIf non-nil, scrolling commands can be used in Isearch mode.\nHowever, the current match will never scroll offscreen.\nIf nil, scrolling commands will first cancel Isearch mode." :type boolean :group isearch isearch-allow-prefix "Whether prefix arguments are allowed during incremental search.\nIf non-nil, entering a prefix argument will not terminate the\nsearch. This option is ignored (presumed t) when\n`isearch-allow-scroll' is set." :version "24.4"] 10)
#@279 Test whether the search string is currently outside of the window.
Return nil if it's completely visible, or if point is visible,
together with as much of the search string as will fit; the symbol
`above' if we need to scroll the text downwards; the symbol `below',
if upwards.
(defalias 'isearch-string-out-of-window #[(isearch-point) "\306 \307\310\311\"\212\312 r\313\216\314\315!\210`,\212\312 r\316\216\314\317!\210`,\310\211 \203< \2068 \202G \206F \nY\203T
X\204v \203g Y\203z
W\202s Y\203z \fW\203z \310\202\215 \nW\203\214 W\203\214 \320\202\215 \321.\207" [save-selected-window--state end start w-L-1 w-L1 w-end window-group-start window-group-end nil t internal--before-save-selected-window #[nil "\301!\207" [save-selected-window--state internal--after-save-selected-window] 2] move-to-window-group-line 1 #[nil "\301!\207" [save-selected-window--state internal--after-save-selected-window] 2] -1 above below w-start isearch-forward isearch-point isearch-other-end] 6 (#$ . 92043)])
#@211 Scroll the window to bring the search string back into view.
Restore point to ISEARCH-POINT in the process. ABOVE is t when the
search string is above the top of the window, nil when it is beneath
the bottom.
(defalias 'isearch-back-into-window #[(above isearch-point) "\306\211\n\203 \f\206 \202 \f\206
\2039 b\210\307\310!\210 \311\306\312\"Y\203N b\210\307\313!\210\202N b\210\307\313!\210 \314 W\203N b\210\307\310!\210* b\207" [end start isearch-forward isearch-point isearch-other-end above nil recenter-window-group 0 window-group-end t -1 window-group-start] 4 (#$ . 93097)])
(defvar isearch-pre-scroll-point nil)
#@460 Decide whether to exit Isearch mode before executing the command.
Don't exit Isearch if the key sequence that invoked this command
is bound in `isearch-mode-map', or if the invoked command is
a prefix argument command (when `isearch-allow-prefix' is non-nil),
or it is a scrolling command (when `isearch-allow-scroll' is non-nil).
Otherwise, exit Isearch (when `search-exit-option' is non-nil)
before the command is executed globally with terminated Isearch.
(defalias 'isearch-pre-command-hook #[nil "\306 \211\307H\n =?\206\207 \310\311\f\312#!\206\207
\313=\203% \314\211\202\207 \2031 \315>\204N \203Z 9\203Z \316N\317=\204N \320N\317=\203Z \205\207 `\211\202\207 \242\321=\203w \322\323 !\211@\262!\203w \324 \210\314\211\202\207
\203\203 \325 \210\326 \202\207 \327\211\"*\207" [key main-event overriding-terminal-local-map isearch--saved-overriding-local-map isearch-mode-map search-exit-option this-single-command-keys 0 commandp lookup-key nil edit isearch-edit-string (universal-argument digit-argument negative-argument) isearch-scroll t scroll-command down-mouse-1 window-minibuffer-p event-start read-event isearch-done isearch-clean-overlays isearch-process-search-string this-command isearch-allow-prefix isearch-allow-scroll isearch-pre-scroll-point] 6 (#$ . 93746)])
(defalias 'isearch-post-command-hook #[nil "\205 \302!\211\203 \303 \304=\"\210\202 b\210)\305\306 \207" [isearch-pre-scroll-point ab-bel isearch-string-out-of-window isearch-back-into-window above nil isearch-update] 4])
#@100 Quote special characters for incremental search.
With argument, add COUNT copies of the character.
(defalias 'isearch-quote-char #[(&optional count) "\305\306\307!!\310!\204 \311\312\313\314!!\"\210 \2039 \n\2039 \315U\2039 \316 \211G\"\2032 \317\320\321\"\202= \322\f\"\202= \322\f\")\207" [char isearch-regexp isearch-regexp-lax-whitespace isearch-string count read-quoted-char isearch-message t characterp user-error "%s is not a valid character" key-description vector 32 subregexp-context-p isearch-process-search-string "[ ]" " " isearch-process-search-char] 5 (#$ . 95296) "p"])
#@116 Add this ordinary printing CHAR to the search string and search.
With argument, add COUNT copies of the character.
(defalias 'isearch-printing-char #[(&optional char count) "\206 \211\304U\203 \305\n\203 \306 \"\202 \307 \")\207" [char last-command-event current-input-method count 33554464 32 isearch-process-search-multibyte-characters isearch-process-search-char] 4 (#$ . 95896) (list last-command-event (prefix-numeric-value current-prefix-arg))])
#@76 Add CHAR to the search string, COUNT times.
Search is updated accordingly.
(defalias 'isearch-process-search-char #[(char &optional count) "\304>\203
\305\306!\210\202' \307=\203 \305\310\211\"\210\202' \311=\203' \305\310\306\310#\210 \250\2039 \312V\2039 \313 \"\202< \314!\315Y\203G \n\202L \316\317\n\320#\321\n \"*\207" [char count string message (42 63) isearch-fallback nil 125 t 124 1 make-string char-to-string 128 mapconcat isearch-text-char-description "" isearch-process-search-string] 4 (#$ . 96364)])
(defalias 'isearch-process-search-string #[(string message) " P\n P\304 \207" [isearch-string string isearch-message message isearch-search-and-update] 2])
(defalias 'isearch-ring-adjust1 #[(advance) "\203 \202 \n\211G \203 \306\202 \307 \310
! \f\311U?\205U
\312\2064 \2033 \311\2024 \313\203= \313\202> \314\\\f\"\211L\210 8\315\316\317#\211,\207" [isearch-regexp regexp-search-ring search-ring ring length yank-pointer-name regexp-search-ring-yank-pointer search-ring-yank-pointer eval 0 mod -1 1 mapconcat isearch-text-char-description "" yank-pointer advance isearch-string isearch-message] 5])
(defalias 'isearch-ring-adjust #[(advance) "\303!\210 \203 \n\206
\304\305\306\"\210\307 \210\310 \210\311 \207\312 \207" [advance search-ring-update isearch-message-function isearch-ring-adjust1 isearch-message nil t isearch-search isearch-push-state isearch-update isearch-edit-string] 3])
#@48 Advance to the next search string in the ring.
(defalias 'isearch-ring-advance #[nil "\300\301!\207" [isearch-ring-adjust advance] 2 (#$ . 97820) nil])
#@52 Retreat to the previous search string in the ring.
(defalias 'isearch-ring-retreat #[nil "\300\301!\207" [isearch-ring-adjust nil] 2 (#$ . 97978) nil])
(defalias 'isearch-complete1 #[nil "\203 \202 \n\f \306 \"\211 \307=\203 \307\202\211 \204* G\310U\203\204 \232\203w \203s r\311\312!q\210p\313 \210\314\211\307\211 \307 \315 \210\316\317!\210+\211 \320\321 \"!\210\322 !\210+\307\202\211 \205\211 \211\202\211 \323\324!\210\314+\207" [isearch-regexp regexp-search-ring search-ring ring case-fold-search completion-ignore-case try-completion t 0 get-buffer-create "*Isearch completions*" kill-all-local-variables nil erase-buffer run-hooks temp-buffer-setup-hook display-completion-list all-completions internal-temp-output-buffer-show message "No completion" isearch-string completion completion-auto-help default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output] 5])
#@189 Complete the search string from the strings on the search ring.
The completed string is then editable in the minibuffer.
If there is no completion possible, say so and continue searching.
(defalias 'isearch-complete #[nil "\302 \203 \303\304\305#\306 \207\307\310!\210\311 \207" [isearch-string isearch-message isearch-complete1 mapconcat isearch-text-char-description "" isearch-edit-string sit-for 1 isearch-update] 4 (#$ . 98997) nil])
#@54 Same as `isearch-complete' except in the minibuffer.
(defalias 'isearch-complete-edit #[nil "\301 \302 \205
\303 \210c\207" [isearch-string field-string isearch-complete1 delete-field] 1 (#$ . 99445) nil])
(defalias 'isearch-message #[(&optional c-q-hack ellipsis) " \306\307! \n\203( \310 !\311\n G\312 $\210\313\314 \"\203( \311\315\224\315\225\316 $\210\317
\" \320!Q\203< \202D \321 \322\323 \")+\207" [ellipsis isearch-message fail-pos m cursor-in-echo-area isearch-nonincremental isearch-fail-pos t copy-sequence add-text-properties (face isearch-fail) string-match " +$" 0 (face trailing-whitespace) isearch-message-prefix isearch-message-suffix nil message "%s" c-q-hack message-log-max] 5])
#@128 Make a string for describing REGEXP-FUNCTION.
If SPACE-BEFORE is non-nil, put a space before, instead of after,
the word mode.
(defalias 'isearch--describe-regexp-mode #[(regexp-function &optional space-before) "\305=\203 \306 \203 \232\204 \305=\203\" \n=\203\" \307\202H \2035 9\205H \310N\206H \307\202H \n\203= \311\202H \312 !\203G \313\202H \307\f\203U \314\315\316 #\202V )\207" [regexp-function search-default-mode isearch-regexp description space-before t word-search-regexp "" isearch-message-prefix "regexp " functionp "literal " replace-regexp-in-string "\\(.*\\) \\'" " \\1"] 4 (#$ . 100167)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias isearch--describe-word-mode isearch--describe-regexp-mode nil make-obsolete "25.1"] 4)
(defalias 'isearch-message-prefix #[(&optional ellipsis nonincremental) "\203 \203 \3061 \307\n`\310#\210\311\2110\202 \210\202 \210 \204$ \311 \203, \312\202- \313\f\2035 \314\2026 \312
\205T ?\205T !\203L `\"V\202P `\"W\205T \315
\205Y \316\312 #\317\320$\"\210#)\321%!&\203r \322\202| '\203{ \323\202| \312(\206\202 \312)\203\213 \324\202\214 \325!\203\225 \312\202\226 \326*\203\245 \327\330+\331Q!\202\246 \332\260 ,\333,\334\335O\226,\335\311OP\336\337#)\207" [isearch-error ellipsis isearch-string isearch-success isearch-adjusted isearch-wrapped (error) re-search-forward t nil "" "failing " "pending " "over" "wrapped " advice-function-mapc #[(_ props) "\303\236A\211\205 \nP\211)\207" [props np prefix isearch-message-prefix] 3] isearch--describe-regexp-mode "multi-file " "multi-buffer " "search" "I-search" " backward" bidi-string-mark-left-to-right " [" "]: " ": " propertize 0 1 face minibuffer-prompt isearch-wrap-function isearch-forward isearch-opoint prefix isearch-filter-predicate isearch-regexp-function multi-isearch-file-list multi-isearch-buffer-list isearch-message-prefix-add nonincremental current-input-method current-input-method-title m] 14])
(defalias 'isearch-message-suffix #[(&optional c-q-hack) "\203 \303\202 \304 \203 \305 \306Q\202 \304\n\206 \304Q\207" [c-q-hack isearch-error isearch-message-suffix-add "^Q" "" " [" "]"] 4])
#@469 Non-default value overrides the behavior of `isearch-search-fun-default'.
This variable's value should be a function, which will be called
with no arguments, and should return a function that takes three
arguments: STRING, BOUND, and NOERROR. STRING is the string to
be searched for. See `re-search-forward' for the meaning of
BOUND and NOERROR arguments.
This returned function will be used by `isearch-search-string' to
search for the first occurrence of STRING.
(defvar isearch-search-fun-function 'isearch-search-fun-default (#$ . 102351))
#@112 Return the function to use for the search.
Can be changed via `isearch-search-fun-function' for special needs.
(defalias 'isearch-search-fun #[nil "\206 \301 \207" [isearch-search-fun-function isearch-search-fun-default] 1 (#$ . 102905)])
#@53 Non-nil if next regexp-function call should be lax.
(defalias 'isearch--lax-regexp-function-p #[nil "\206# @?\206# \nG @\304H >\204 \305\306\307 @D\"\210 @\310HG=?\207" [isearch-nonincremental isearch-cmds isearch-string cl-struct-isearch--state-tags 0 signal wrong-type-argument isearch--state 1] 5 (#$ . 103152)])
#@49 Return default functions to use for the search.
(defalias 'isearch-search-fun-default #[nil "\300\207" [#[(string &optional bound noerror count) "\203 \202 \n\205
\3061W
\203 \307\202 \310\203? \311 \312!\2035 \"\202; \313\")\202L \203H \202L \314!$0\202 \315@\316N \203y ;\203y \317\320#C\202| A)\"))\207" [isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace search-whitespace-regexp search-spaces-regexp isearch-forward (search-failed) re-search-forward re-search-backward isearch--lax-regexp-function-p functionp word-search-regexp regexp-quote signal isearch-message-prefix format "%s [using %ssearch]" isearch-regexp-function lax string bound noerror count er prefix] 6]] 1 (#$ . 103477)])
#@508 Search for the first occurrence of STRING or its translation.
STRING's characters are translated using `translation-table-for-input'
if that is non-nil.
If found, move point to the end of the occurrence,
update the match data, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil.
(defalias 'isearch-search-string #[(string bound noerror) "\306 \212 \n #) \307 \310!\203t \311 !\203t \312 \307\313 \314#)\266\203\203t \315\301\316\317 \"\"\307 \211 \203s \320 \321\216\212\n #\211\203R \320\313!+
\203s \f\203l \203f
\fW\202i
\fV\203s
\322!\210*\f\205\215 \203\211 \323!\203\211 \324!\210\fb\210\f+\207" [func string bound noerror pos1 pos2 isearch-search-fun nil char-table-p multibyte-string-p "[^[:ascii:]]" t string-match apply mapcar #[(c) " H\206 \207" [translation-table-for-input c] 2] match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] set-match-data buffer-live-p switch-to-buffer translation-table-for-input inhibit-changing-match-data translated save-match-data-internal isearch-forward multi-isearch-next-buffer-current-function multi-isearch-current-buffer] 8 (#$ . 104252)])
(defalias 'isearch-search #[nil "\306=\203 \203 \307\n \"\3101\343 \3111\322 \3121\217 \3131~ \f\314\f\306 \" # $ %\314&
\203_ \315\n\314\306#\211'\203Y o\204Y m\204Y \316\224\316\225U\204Y (\316\224\316\225\"\2030 \314\211\2044 \314)'\205v *\203q \316\224\202s \316\225\211+-0000\202\356 000 ,\317\320!\210\314\211')\202\356 00\211 ,A@&\321\322&\"\203\247 \323\211&\202\316 ?\205\316 \321\324&\"\205\316 -\203\300 \325\211&\202\316 .\205\316 /\205\316 \326\211&)\202\356 0 ,\314'\327,8\211&)\202\356 ,\330\331,\"\211&)\210'?\205j0@\316H1>\204 \332\333\3340@D\"\2100@\335H\203\336 \210\3370@\316H1>\204)\332\333\3340@D\"\2100@\340H!\203P0@\316H1>\204F\332\333\3340@D\"\2100@\340H0@!\2100@\316H1>\204d\332\333\3340@D\"\2100@\341Hb\207" [isearch-case-fold-search search-upper-case isearch-string isearch-regexp isearch-invisible retry t isearch-no-upper-case-p (error) (search-failed) (invalid-regexp) (quit) nil isearch-search-string 0 isearch-unread 7 string-match "\\`Premature \\|\\`Unmatched \\|\\`Invalid " "incomplete input" "\\`Regular expression too big" "Too many words" "Too many spaces for whitespace matching" 2 format "%s" signal wrong-type-argument isearch--state 4 ding functionp 12 3 search-invisible case-fold-search inhibit-quit inhibit-point-motion-hooks isearch-error isearch-success isearch-filter-predicate isearch-just-started isearch-forward isearch-other-end lossage isearch-regexp-function isearch-lax-whitespace search-whitespace-regexp isearch-cmds cl-struct-isearch--state-tags] 6])
(defalias 'isearch-open-overlay-temporary #[(ov) "\301\302\"\203 \301\302\"\303\"\207\304\305\301\306\"#\210\304\306\303#\207" [ov overlay-get isearch-open-invisible-temporary nil overlay-put isearch-invisible invisible] 6])
(defalias 'isearch-open-necessary-overlays #[(ov) "`\303!V\205
`\304!X\305\306\"\211\204 \204* \307\310\305\311\"#\210\307\311\312#\210\n\2037 \305\313\"!\202? \205? \314\"*\207" [ov fct-temp inside-overlay overlay-start overlay-end overlay-get isearch-open-invisible-temporary overlay-put invisible isearch-invisible nil isearch-open-invisible t] 7])
(defalias 'isearch-clean-overlays #[nil "\205\f \301\302\"\210\303\211\207" [isearch-opened-overlays mapc isearch-open-necessary-overlays nil] 3])
#@62 Return t if regions START0..END0 and START1..END1 intersect.
(defalias 'isearch-intersects-p #[(start0 end0 start1 end1) " Y\203\f \nW\206- V\203 \nX\206- Y\203$ W\206- \nV\205- \n X\207" [start0 start1 end1 end0] 2 (#$ . 107967)])
(defalias 'isearch-close-unnecessary-overlays #[(begin end) "\306 \306\211\205N @\307\f
\310\n!\311\n!$\203# \nB\202F \312\n\313\"\211 \2036 \n\314\"\210\202E \315\n\316\312\n\317\"#\210\315\n\317\306#\210) A\211\204\f \306+\207" [isearch-opened-overlays overlays ov --dolist-tail-- begin end nil isearch-intersects-p overlay-start overlay-end overlay-get isearch-open-invisible-temporary t overlay-put invisible isearch-invisible fct-temp] 7])
#@56 Return t if all the text from BEG to END is invisible.
(defalias 'isearch-range-invisible #[(beg end) " U?\205\275 \212b\210\n\306=\307\211 \203
\203 \310 \"\210` W\203\231 \311`!\203\231 \311\312`\313\"!\203@ \314`\313\307 $b\210\307\202 \f\203\221 \315`!\307\211\211 \211 \203\206 @\316\313\"\311!\203} \316\317\"\203{ B\202} \307A\211\204V \f\203\220 \320 \",\321`!b\210\202 ` Y\205\274 \f\203\270 :\203\270 \320 \"\322\323 \"\210\307\202\274 \324\211+\207" [beg end search-invisible crt-overlays can-be-opened isearch-hide-immediately open nil isearch-close-unnecessary-overlays invisible-p get-text-property invisible next-single-property-change overlays-at overlay-get isearch-open-invisible append next-overlay-change mapc isearch-open-overlay-temporary t invis-prop o ov-list overlays isearch-opened-overlays isearch-hidden] 6 (#$ . 108674)])
#@248 Test whether the current search hit is visible at least partially.
Return non-nil if the text from BEG to END is visible to Isearch as
determined by `isearch-range-invisible' unless invisible text can be
searched too when `search-invisible' is t.
(defalias 'isearch-filter-visible #[(beg end) "\303=\206 \304 \n\"?\207" [search-invisible beg end t isearch-range-invisible] 3 (#$ . 109581)])
#@175 Return t if there are no upper case chars in STRING.
If REGEXP-FLAG is non-nil, disregard letters preceded by `\' (but not `\\')
since they have special meaning in a regexp.
(defalias 'isearch-no-upper-case-p #[(string regexp-flag) "\306\307G\306 \204> \nW\203> H \203(
\310=\203( \f?\2027 \f\2045
\211\227=\2045 \311\306) T\202 \206h \205h \312\313\"\205h \3141` \312\307\211\224O\315\"\210\3060\202h \211 A@\316\232),?\207" [string found len i quote-flag char nil 0 92 t string-match "\\[:\\(upp\\|low\\)er:]" (invalid-regexp) "" "Unmatched [ or [^" regexp-flag err] 5 (#$ . 109981)])
(defalias 'isearch-text-char-description #[(c) "\301W\203 \302\303!\304\302\305\306\307\\\"\310\311##\207\312U\203) \302\303!\304\302\313\310\311##\207\303!\207" [c 32 propertize char-to-string display format "^%c" 64 face escape-glyph 127 "^?"] 8])
(defalias 'isearch-unread #[(&rest char-or-events) "\302\303\"\210\304 \"\211\207" [char-or-events unread-command-events mapc store-kbd-macro-event append] 3])
(defvar isearch-overlay nil)
(defalias 'isearch-highlight #[(beg end) "\205 \203 \305 \n p$\207\306\n \"\307 \310\311#\210\307 \312\f#\207" [search-highlight isearch-overlay beg end isearch-face move-overlay make-overlay overlay-put priority 1001 face] 5])
(defalias 'isearch-dehighlight #[nil "\205 \301!\207" [isearch-overlay delete-overlay] 2])
(defvar isearch-lazy-highlight-overlays nil)
(defvar isearch-lazy-highlight-wrapped nil)
(defvar isearch-lazy-highlight-start-limit nil)
(defvar isearch-lazy-highlight-end-limit nil)
(defvar isearch-lazy-highlight-start nil)
(defvar isearch-lazy-highlight-end nil)
(defvar isearch-lazy-highlight-timer nil)
(defvar isearch-lazy-highlight-last-string nil)
(defvar isearch-lazy-highlight-window nil)
(defvar isearch-lazy-highlight-window-group nil)
(defvar isearch-lazy-highlight-window-start nil)
(defvar isearch-lazy-highlight-window-end nil)
(defvar isearch-lazy-highlight-case-fold-search nil)
(defvar isearch-lazy-highlight-regexp nil)
(defvar isearch-lazy-highlight-lax-whitespace nil)
(defvar isearch-lazy-highlight-regexp-lax-whitespace nil)
(defvar isearch-lazy-highlight-regexp-function nil)
(byte-code "\302\303\304\305#\210\306\305\211\203, @\303N\203% \304N\204% \307\304\303N#\210 A\211\204 *\310\303\304\311#\207" [prop --dolist-tail-- defvaralias isearch-lazy-highlight-word isearch-lazy-highlight-regexp-function nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1"] 6)
(defvar isearch-lazy-highlight-forward nil)
(defvar isearch-lazy-highlight-error nil)
#@249 Stop lazy highlighting and remove extra highlighting from current buffer.
FORCE non-nil means do it whether or not `lazy-highlight-cleanup'
is nil. This function is called when exiting an incremental search if
`lazy-highlight-cleanup' is non-nil.
(defalias 'lazy-highlight-cleanup #[(&optional force) "\204 \203 \n\203 \304\n@!\210\nA\211\204\f \205# \305 !\210\306\211\207" [force lazy-highlight-cleanup isearch-lazy-highlight-overlays isearch-lazy-highlight-timer delete-overlay cancel-timer nil] 3 (#$ . 112577) '(t)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias isearch-lazy-highlight-cleanup lazy-highlight-cleanup nil make-obsolete "22.1"] 4)
#@297 Cleanup any previous `lazy-highlight' loop and begin a new one.
BEG and END specify the bounds within which highlighting should occur.
This is called when `isearch-update' is invoked (which can cause the
search string to change or the window to scroll). It is also used
by other Emacs features.
(defalias 'isearch-lazy-highlight-new-loop #[(&optional beg end) "?\205\271 \306\307!\205\271 \n\232\203_ \310 >\203_ \f
=\203_ =\203_ =\203_ =\203_ =\203_ \311 U\203_ \312 U\203_ =\203_ \232?\205\271 \313\314!\210 !\"#\310 $\315 \311 \312 %\206\204 `&%\206\214 `'\316(
\317\232?\205\271 \320)\316\321#\211*\207" [executing-kbd-macro isearch-string isearch-lazy-highlight-last-string isearch-lazy-highlight-window-group isearch-lazy-highlight-case-fold-search isearch-case-fold-search sit-for 0 selected-window window-group-start window-group-end lazy-highlight-cleanup t selected-window-group nil "" run-with-idle-timer isearch-lazy-highlight-update isearch-lazy-highlight-regexp isearch-regexp isearch-lazy-highlight-regexp-function isearch-regexp-function isearch-lazy-highlight-lax-whitespace isearch-lax-whitespace isearch-lazy-highlight-regexp-lax-whitespace isearch-regexp-lax-whitespace isearch-lazy-highlight-window-start isearch-lazy-highlight-window-end isearch-forward isearch-lazy-highlight-forward isearch-error isearch-lazy-highlight-error beg isearch-lazy-highlight-start-limit end isearch-lazy-highlight-end-limit isearch-lazy-highlight-window isearch-other-end isearch-lazy-highlight-start isearch-lazy-highlight-end isearch-lazy-highlight-wrapped lazy-highlight-initial-delay isearch-lazy-highlight-timer] 4 (#$ . 113264)])
#@137 Search ahead for the next or previous match, for lazy highlighting.
Attempt to do the search exactly the way the pending Isearch would.
(defalias 'isearch-lazy-highlight-search #[nil "\3061\220 \n \f
\307\310\307
\203,
\206 d\203& GS\\\202( \311 ^\202D \2062 e\203A GSZ\202C \312 ] \203\212 \313\310#\211\203\203 `U\204\203 \314\224\314\225U\204\203 \314\224\314\225\"\203X \307\211\204] .\n0\207\210\307\207" [isearch-lazy-highlight-case-fold-search isearch-lazy-highlight-regexp isearch-lazy-highlight-regexp-function isearch-lazy-highlight-lax-whitespace isearch-lazy-highlight-regexp-lax-whitespace isearch-lazy-highlight-forward (error) nil t window-group-end window-group-start isearch-search-string 0 isearch-lazy-highlight-end-limit isearch-lazy-highlight-wrapped isearch-lazy-highlight-start isearch-lazy-highlight-last-string isearch-lazy-highlight-start-limit isearch-lazy-highlight-end bound success retry search-invisible isearch-forward isearch-regexp-lax-whitespace isearch-lax-whitespace isearch-regexp-function isearch-regexp case-fold-search isearch-filter-predicate] 13 (#$ . 114986)])
#@58 Update highlighting of other matches for current search.
(defalias 'isearch-lazy-highlight-update #[nil "\306\307\3101&\307 \311 r\312\216\313 !\203& \314 >\204& \315 !\210\212\316 !\317\216\"\2037 #\2029 $b\210\n\203\320 % \203R S\211\321X\203R \307%\203\324 \321\224\321\225 &\211 '&U\203\247 \"\203\211 '(\203w $\202y \322 U\203\203 \307%\202\305 \323u\210\202\305 '(\203\225 #\202\227 \324 U\203\241 \307%\202\305 \325u\210\202\305 \326'&\"\211 )*B*\327)\330\331#\210\327)\332+#\210)\"\203\320 `#\202\323 `$*%\204(\203\345 \307\306\202\306(\"\203\377 \324 #,\206\367 e\324 ]b\210\202\322 $-\206 d\322 ^b\210)\202; ?\205 \333.\307\334#\211/.0\202-\210\3060\335\336!+\207" [lazy-highlight-max-at-a-time nomore looping max inhibit-quit save-selected-window--state t nil (quit) internal--before-save-selected-window #[nil "\301!\207" [save-selected-window--state internal--after-save-selected-window] 2] window-live-p selected-window select-window match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] isearch-lazy-highlight-search 0 window-group-end 1 window-group-start -1 make-overlay overlay-put priority 1000 face run-at-time isearch-lazy-highlight-update eval (ignore nil) isearch-lazy-highlight-window isearch-lazy-highlight-window-group save-match-data-internal isearch-lazy-highlight-forward isearch-lazy-highlight-end isearch-lazy-highlight-start found me mb isearch-lazy-highlight-wrapped ov isearch-lazy-highlight-overlays lazy-highlight-face isearch-lazy-highlight-start-limit isearch-lazy-highlight-end-limit lazy-highlight-interval isearch-lazy-highlight-timer quit-flag] 5 (#$ . 116151)])
#@348 Resume an incremental search.
STRING is the string or regexp searched for.
REGEXP non-nil means the resumed search was a regexp search.
WORD non-nil means resume a word search.
FORWARD non-nil means resume a forward search.
MESSAGE is the echo-area message recorded for the search resumed.
CASE-FOLD non-nil means the search was case-insensitive.
(defalias 'isearch-resume #[(string regexp word forward message case-fold) "\306 \307\211\n%\210
\n \f\310 \210\311 \207" [forward regexp word string isearch-string message isearch-mode nil isearch-search isearch-update isearch-message case-fold isearch-case-fold-search] 6 (#$ . 117865)])
Kontol Shell Bypass