Current File : //usr/local/share/emacs/27.2/lisp/isearch.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301\302\303\304\305\304\306\307\310\307\311\312\313&
\210\314\315\316\317\320DD\321\322\323\324\325&\210\314\326\316\317\327DD\330\322\331%\210\314\332\316\317\333DD\334\322\331%\210\314\335\316\317\336DD\337\322\340%\210\314\341\316\317\342DD\343\322\344%\210\314\345\316\317\346DD\347\322\350\324\351&\210\314\352\316\317\353DD\354\322\355%\210\314\356\316\317\357DD\360\322\344%\210\314\361\316\317\362DD\363\322\344%\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 funcall function #[0 "\300\207" [t] 1] "Defines what control characters do in incremental search.\nIf t, random control and meta characters terminate the search\nand are then executed normally.\nIf `edit', edit the search string instead of exiting.\nIf `append', the characters which you type that are not interpreted by\nthe incremental search are simply appended to the search string.\nIf nil, run the command without exiting Isearch." :type (choice (const :tag "Terminate incremental search" t) (const :tag "Edit the search string" edit) (const :tag "Append control characters to the search string" append) (const :tag "Don't terminate incremental search" nil)) :version "27.1" search-slow-window-lines #[0 "\300\207" [1] 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 #[0 "\300\207" [1200] 1] "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 #[0 "\300\207" [not-yanks] 1] "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 #[0 "\300\207" [t] 1] "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.)" boolean search-whitespace-regexp #[0 "\300\301!\207" [purecopy "\\s-+"] 2] "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, a\ntab, a carriage return (control-M), a newline, and `]+'. Don't\nadd any capturing groups into this value; that can change the\nnumbering of existing capture groups in unexpected ways." (choice (const :tag "Match Spaces Literally" nil) regexp) "24.3" search-invisible #[0 "\300\207" [open] 1] "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 a non-nil `invisible' property, and that overlay\nhas a non-nil property `isearch-open-invisible', then incremental\nsearch will show the hidden text. (This applies when using `outline.el'\nand `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 #[0 "\300\207" [t] 1] "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 #[0 "\300\207" [nil] 1] "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 (#$ . 5987))
#@68 Function(s) to call after isearch has found matches in the buffer.
(defvar isearch-update-post-hook nil (#$ . 6097))
#@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 (#$ . 6221))
#@77 Non-nil while running `isearch-mode-end-hook' if the user quits the search.
(defvar isearch-mode-end-hook-quit nil (#$ . 6438))
#@88 Function to call to display the search prompt.
If nil, use function `isearch-message'.
(defvar isearch-message-function nil (#$ . 6572))
#@259 Function to call to wrap the search when search is failed.
The function is called with no parameters, and would typically
move point.
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 (#$ . 6716))
#@99 Function to save a function restoring the mode-specific Isearch state
to the search status stack.
(defvar isearch-push-state-function nil (#$ . 7027))
#@589 Predicate to filter hits of Isearch and replace commands.
Isearch hits that don't satisfy the predicate will be skipped.
The value should be a function of two arguments; it will be
called with the positions of the start and the end of the text
matched by Isearch and replace commands. If this function
returns nil, Isearch and replace commands will continue searching
without stopping at resp. replacing 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 (#$ . 7185))
#@34 List of search string sequences.
(defvar search-ring nil (#$ . 7849))
#@53 List of regular expression search string sequences.
(defvar regexp-search-ring nil (#$ . 7925))
(byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\306\307%\207" [custom-declare-variable search-ring-max funcall function #[0 "\300\207" [16] 1] "Maximum length of search ring before oldest elements are thrown away." :type integer regexp-search-ring-max #[0 "\300\207" [16] 1] "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 (#$ . 8415))
#@77 Index in `regexp-search-ring' of last string reused.
It is nil if none yet.
(defvar regexp-search-ring-yank-pointer nil (#$ . 8540))
(byte-code "\300\301\302\303\304DD\305\306\307%\210\310\311\312\"\210\300\313\302\303\314DD\315\306\316\317\320&\210\300\321\302\303\322DD\323\306\307%\210\324\325\326\327\330\325\330\331&\207" [custom-declare-variable search-ring-update funcall function #[0 "\300\207" [nil] 1] "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 #[0 "\300\207" [nil] 1] "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 #[0 "\300\207" [t] 1] "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 "\300\301\302\303\304\305%\210\306\307\310\311\312DD\313\314\315\316\317\316\320& \210\306\321\310\311\322DD\323\314\324\316\325\316\320\304\326& \210\327\317\330\331\332\333\304\334\316\320\316\335& \210\306\336\310\311\337DD\340\314\324\316\317&\210\306\341\310\311\342DD\343\314\344\316\317&\210\306\345\310\311\346DD\347\314\344\316\317&\210\306\350\310\311\351DD\352\314\353\316\317&\210\306\354\310\311\355DD\356\314\357\316\317\304\326& \210\306\360\310\311\361DD\362\314\324\316\317\304\326& \210\300\317\363\364\316\317\316\365&\210\327\325\330\366\332\367\304\326\316\320\316\335& \210\306\370\310\311\371DD\372\314\373\316\325\304\326& \210\306\374\310\311\375DD\376\314\377\316\325\304\326& \207" [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 funcall function #[0 "\300\207" [t] 1] "Controls the lazy-highlighting during incremental search.\nWhen non-nil, all text currently visible on the screen\nmatching the current search string is highlighted lazily\n(see `lazy-highlight-initial-delay' and `lazy-highlight-interval').\n\nWhen multiple windows display the current buffer, the\nhighlighting is displayed only on the selected window, unless\nthis variable is set to the symbol `all-windows'." :type (choice (const :tag "Off" nil) (const :tag "On, and applied to current window" t) (const :tag "On, and applied to all windows" all-windows)) :group lazy-highlight isearch isearch-lazy-count #[0 "\300\207" [nil] 1] "Show match numbers in the search prompt.\nWhen both this option and `isearch-lazy-highlight' are non-nil,\nshow the current match number and the total number of matches\nin the buffer (or its restriction), including all hidden matches." boolean lazy-count "27.1" custom-declare-group nil "Lazy highlighting feature for matching strings." :prefix "lazy-highlight-" "21.1" matching lazy-highlight-cleanup #[0 "\300\207" [t] 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]." lazy-highlight-initial-delay #[0 "\300\207" [0.25] 1] "Seconds to wait before beginning to lazily highlight all matches." number lazy-highlight-interval #[0 "\300\207" [0] 1] "Seconds between lazily highlighting successive matches." lazy-highlight-max-at-a-time #[0 "\300\207" [nil] 1] "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 shown on the screen." (choice (const :tag "All" nil) (integer :tag "Some")) lazy-highlight-buffer-max-at-a-time #[0 "\300\207" [20] 1] "Maximum matches to highlight at a time (for `lazy-highlight-buffer').\nLarger values may reduce Isearch's responsiveness to user input;\nsmaller values make matches highlight slowly.\nA value of nil means highlight all matches in the buffer." (choice (const :tag "All" nil) (integer :tag "Some")) lazy-highlight-buffer #[0 "\300\207" [nil] 1] "Controls the lazy-highlighting of the full buffer.\nWhen non-nil, all text in the buffer matching the current search\nstring is highlighted lazily (see `lazy-highlight-initial-delay',\n`lazy-highlight-interval' and `lazy-highlight-buffer-max-at-a-time').\nThis is useful when `lazy-highlight-cleanup' is customized to nil\nand doesn't remove full-buffer highlighting after a search." ((((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 "Lazy counting feature for reporting the number of matches." "lazy-count-" lazy-count-prefix-format #[0 "\300\207" [#1="%s/%s "] 1 #1#] "Format of the current/total number of matches for the prompt prefix." (choice (const :tag "No prefix" nil) (string :tag "Prefix format string" "%s/%s ")) lazy-count-suffix-format #[0 "\300\207" [nil] 1] "Format of the current/total number of matches for the prompt suffix." (choice (const :tag "No suffix" nil) (string :tag "Suffix format string" " [%s of %s]"))] 12)
#@64 Keymap for characters following the Help key for Isearch mode.
(defvar isearch-help-map (byte-code "\301 \302\303!\304#\210\302\305\304#\210\302\306\304#\210\302\307\304#\210\302\310\311#\210\302\312\313#\210\302\314\315#\210\302\316\317#\210\211\207" [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] 5) (#$ . 15284))
#@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 #[0 "\300\207" [nil] 1 (#$ . 15759)])
#@15 Help command.
(defalias 'isearch-help-for-help-internal #[0 "\306\307\310!!\203 \311\312\"\210\313\314!\315 C\316 \317C\317C\317\211\320\321 \"\2035 \322\323\324\325 \326\327#!\330\211 $\262\331\326\332\333\334\n #\335\"\336$\216\317\n\241\210\337\340\341#\210\337\342\343 \344\"#\210\203\200 \345\317!)\262\343
\"\203x \343
\"\262\326H\262\202\203 \346\262\211\346=\204\227 \211@=\204\227 \211A>\203R\347 \240\210\350\351\317\330#\210\352\353!\203\270 \354 =\204\270 \354 \240\210\317\240\210\317B\330 C\355 \210c\210)\242\356 \210 \240\210)eb\210\211\357A@\360B\">\204\356 \211\242\361=\204\356 \362\232\203R\3631 \211\242\361=\203\377 \364!\202\211\365>\203\n\366 \202\211\367>\204\362\232\205\370 0\202 \210\202!\210\330 D\345\371\372\373d!\2034\374\2025\375\"!\262\326H\262*\211\376=\203\324 \377\343\"\317#\210\202\324 \311\374!\210\211<\203g\211EBE\317\240\202\253\343\"\211\203\245\242\203\200\201F \242!\210\317\240\210\242\201G !\210)\242\205\251\242\316 =\204\237\201H \242!\210\317\240\202\251\201I \262*\266\210\207" [three-step-help minor-mode-map-alist isearch-help-map global-map overriding-local-map function-key-map 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 substring this-command-keys 0 -1 t make-byte-code "\301\242\203\n \304\301\242!\210\302\242\203 \305\302\242!\210\300\242\211\207" vconcat vector [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 help-char help-event-list buffer-read-only inhibit-read-only cursor-in-echo-area unread-command-events set-window-configuration call-interactively iconify-frame ding] 17 (#$ . 16329) nil])
(defvar isearch--display-help-action '(nil (inhibit-same-window . t)))
#@28 Display Isearch help menu.
(defalias 'isearch-help-for-help #[0 "\302 \210)\303 \207" [isearch--display-help-action display-buffer-overriding-action isearch-help-for-help-internal isearch-update] 1 (#$ . 18791) 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 #[0 "\n\306\211\223\210\307 B\310\fB \311 \312\313!\211 \306\211rq\210\314\315!\210\314\316\317!!)\262rq\210\320\306\"\262)\321\322!\203C \322\"\202D \211)\266\203+\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 standard-output] 6 (#$ . 19017) nil])
#@63 Display documentation of the function invoked by isearch key.
(defalias 'isearch-describe-key #[0 "\302\303!\210)\304 \207" [isearch--display-help-action display-buffer-overriding-action call-interactively describe-key isearch-update] 2 (#$ . 19806) nil])
#@40 Display documentation of Isearch mode.
(defalias 'isearch-describe-mode #[0 "\302\303!\210)\304 \207" [isearch--display-help-action display-buffer-overriding-action describe-function isearch-forward isearch-update] 2 (#$ . 20070) nil])
(defalias 'isearch-mode-help 'isearch-describe-mode)
#@52 Run `tmm-menubar' while `isearch-mode' is enabled.
(defalias 'isearch-tmm-menubar #[0 "\306\307!\210\310\311!\210\312\313 \3141% \n \f
$%&'()*+,-./01234\315 5\211\312C\312C 5 6 7 4 3 2 1\n 8
, + * ) ( ' & % $ 9 : ;\316<\3171\233 \320\316\211\"0\202\237 \210\202\240 \210`\240\210\211=\240\210\321\322\323\324\325 \f\f&\326\"\327$\216\316 >\330 \312\211\316$)\262 ) G\322U\203\366 $\203\344 ?\202\346 @@\206\353 \331\332\333 \331#\334\312!\210.\266 \335 \210&\203 &@\336 \232\204\337 \210\340 \210\205!\320 \210 \331\232\205!\341\331!0\202+\210\312<\342 \266\343!\207" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-regexp-function isearch-case-fold-search require tmm run-hooks menu-bar-update-hook nil tmm-menubar-keymap (quit) current-window-configuration t (exit) isearch-done make-byte-code 0 "\310
\311\310%\210\300\301 \302\305\303\304\312!\210\2068 \313\310\314\"\210\307\242\205S \306\242`=\205S =\205S \307\242b\207" vconcat vector [nil isearch-mode isearch-update-from-string-properties isearch-message t isearch-suspended isearch-forward isearch-regexp isearch-op-fun isearch-regexp-function isearch-string isearch-new-forward isearch-new-nonincremental isearch-nonincremental isearch-new-regexp-function isearch-case-fold-search multi-isearch-current-buffer multi-isearch-file-list multi-isearch-buffer-list isearch-message-function] 6 tmm-prompt "" mapconcat isearch-text-char-description isearch-ring-adjust1 isearch-search isearch--get-state isearch-push-state isearch-update message isearch-abort call-interactively isearch-regexp isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error multi-isearch-file-list multi-isearch-buffer-list multi-isearch-next-buffer-current-function multi-isearch-current-buffer isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-window-configuration multi-isearch-next-buffer-function isearch-new-regexp-function isearch-new-forward isearch-new-nonincremental isearch-suspended isearch-other-end isearch-mode regexp-search-ring search-ring] 43 (#$ . 20367) nil])
#@55 List of commands that can open a menu during Isearch.
(defvar isearch-menu-bar-commands '(isearch-tmm-menubar menu-bar-open mouse-minor-mode-menu) (#$ . 22729))
(defvar isearch-menu-bar-yank-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\317#\210\211\207" [make-sparse-keymap define-key [isearch-yank-pop] (menu-item "Previous kill" isearch-yank-pop :help "Replace previous yanked kill on search string") [isearch-yank-kill] (menu-item "Current kill" isearch-yank-kill :help "Append current kill to search string") [isearch-yank-until-char] (menu-item "Until char..." isearch-yank-until-char :help "Yank from point to specified character into search string") [isearch-yank-line] (menu-item "Rest of line" isearch-yank-line :help "Yank the rest of the current line on search string") [isearch-yank-symbol-or-char] (menu-item "Symbol/char" isearch-yank-symbol-or-char :help "Yank next symbol or char on search string") [isearch-yank-word-or-char] (menu-item "Word/char" isearch-yank-word-or-char :help "Yank next word or char on search string") [isearch-yank-char] (menu-item "Char" isearch-yank-char :help "Yank char at point on search string")] 5))
(defvar isearch-menu-bar-map (byte-code "\301\302!\303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\303\316\317#\210\303\320\321#\210\303\322\323#\210\303\324\325#\210\303\326\327#\210\303\330\331#\210\303\332\333#\210\303\334\335#\210\303\336\337#\210\303\340\341#\210\303\342\343#\210\303\344\345#\210\303\346\347#\210\303\350\351#\210\303\352\353#\210\303\354\355#\210\303\356\357\360E#\210\303\361\362#\210\303\363\364#\210\303\365\366#\210\303\367\370#\210\303\371\372#\210\303\373\374#\210\303\375\376#\210\303\377\201@ #\210\303\201A \201B #\210\303\201C \201D #\210\303\201E \201F #\210\303\201G \201H #\210\303\201I \357\201J \201K \201L \201M \201N \201O \257#\210\211\207" [isearch-menu-bar-yank-map make-sparse-keymap "Isearch" define-key [isearch-complete] (menu-item "Complete current search string" isearch-complete :help "Complete current search string over search history") [isearch-complete-separator] (menu-item "--") [isearch-query-replace-regexp] (menu-item "Replace search string as regexp" isearch-query-replace-regexp :help "Replace matches for current search string as regexp") [isearch-query-replace] (menu-item "Replace search string" isearch-query-replace :help "Replace matches for current search string") [isearch-occur] (menu-item "Show all matches for search string" isearch-occur :help "Show all matches for current search string") [isearch-highlight-regexp] (menu-item "Highlight all matches for search string" isearch-highlight-regexp :help "Highlight all matches for current search string") [isearch-search-replace-separator] (menu-item "--") [isearch-toggle-specified-input-method] (menu-item "Turn on specific input method" isearch-toggle-specified-input-method :help "Turn on specific input method for search") [isearch-toggle-input-method] (menu-item "Toggle input method" isearch-toggle-input-method :help "Toggle input method for search") [isearch-input-method-separator] (menu-item "--") [isearch-char-by-name] (menu-item "Search for char by name" isearch-char-by-name :help "Search for character by name") [isearch-quote-char] (menu-item "Search for literal char" isearch-quote-char :help "Search for literal char") [isearch-special-char-separator] (menu-item "--") [isearch-toggle-word] (menu-item "Word matching" isearch-toggle-word :help "Word matching" :button (:toggle eq isearch-regexp-function 'word-search-regexp)) [isearch-toggle-symbol] (menu-item "Symbol matching" isearch-toggle-symbol :help "Symbol matching" :button (:toggle eq isearch-regexp-function 'isearch-symbol-regexp)) [isearch-toggle-regexp] (menu-item "Regexp matching" isearch-toggle-regexp :help "Regexp matching" :button (:toggle . isearch-regexp)) [isearch-toggle-invisible] (menu-item "Invisible text matching" isearch-toggle-invisible :help "Invisible text matching" :button (:toggle . isearch-invisible)) [isearch-toggle-char-fold] (menu-item "Character folding matching" isearch-toggle-char-fold :help "Character folding matching" :button (:toggle eq isearch-regexp-function 'char-fold-to-regexp)) [isearch-toggle-case-fold] (menu-item "Case folding matching" isearch-toggle-case-fold :help "Case folding matching" :button (:toggle . isearch-case-fold-search)) [isearch-toggle-lax-whitespace] (menu-item "Lax whitespace matching" isearch-toggle-lax-whitespace :help "Lax whitespace matching" :button (:toggle . isearch-lax-whitespace)) [isearch-toggle-separator] (menu-item "--") [isearch-yank-menu] menu-item "Yank on search string" [isearch-edit-string] (menu-item "Edit current search string" isearch-edit-string :help "Edit current search string") [isearch-ring-retreat] (menu-item "Edit previous search string" isearch-ring-retreat :help "Edit previous search string in Isearch history") [isearch-ring-advance] (menu-item "Edit next search string" isearch-ring-advance :help "Edit next search string in Isearch history") [isearch-del-char] (menu-item "Delete last char from search string" isearch-del-char :help "Delete last character from search string") [isearch-delete-char] (menu-item "Undo last input item" isearch-delete-char :help "Undo the effect of the last Isearch command") [isearch-end-of-buffer] (menu-item "Go to last match" isearch-end-of-buffer :help "Go to last occurrence of current search string") [isearch-beginning-of-buffer] (menu-item "Go to first match" isearch-beginning-of-buffer :help "Go to first occurrence of current search string") [isearch-repeat-backward] (menu-item "Repeat search backward" isearch-repeat-backward :help "Repeat current search backward") [isearch-repeat-forward] (menu-item "Repeat search forward" isearch-repeat-forward :help "Repeat current search forward") [isearch-nonincremental] (menu-item "Nonincremental search" isearch-exit :help "Start nonincremental search" :visible (string-equal isearch-string #1="")) [isearch-exit] (menu-item "Finish search" isearch-exit :help "Finish search leaving point where it is" :visible (not (string-equal isearch-string #1#))) [isearch-abort] (menu-item "Remove characters not found" isearch-abort :help "Quit current search" :visible (not isearch-success)) [isearch-cancel] "Cancel search" isearch-cancel :help "Cancel current search and return to starting point" :filter #[257 "\203 \301\207\207" [isearch-success isearch-abort] 2 "\n\n(fn BINDING)"]] 11))
#@28 Keymap for `isearch-mode'.
(defvar isearch-mode-map (byte-code "\304\305 \306A@!\204 \307\310!\210\311A@\312\313 B\314#\210\315\262\312W\2032 \316\317!\314#\210T\262\202 \320 \316\321!#\266\316\322\323#\210\316\324\325#\210\316\326\323#\210\316\327\325#\210\316\330\331#\210\316\332\333#\210\316\334\335#\210\336U\204q \307\337!\210\316\340\341#\210\316\342\343#\210\316\344\345#\210\316\346\345#\210\316\347\314#\210\316\350\314#\210\316\351\314#\210\316\352\353#\210\316\354\355#\210\316\356\357#\210\316\360\361#\210\316\362\363#\210\316\364\365#\210\316\366\367#\210\316\370\371#\210\316\372\373#\210\316\321 !\n#\210\316\374\n#\210\316\375\n#\210\316\376\377#\210\316\201@ \201A #\210\316\201B \201C #\210\316\201D \201E #\210\316\201F \201G #\210\316\201H \201G #\210\316\201I \201G #\210\316\201J \201G #\210\316\201K \201G #\210\316\201L \201G #\210\316\201M \201N #\210\316\201O \201P #\210\316\201Q \201R #\210\316\201S \201G #\210\316\201T \201U #\210\316\201V \201W #\210\316\201X \201Y #\210\316\201Z \201[ #\210\201\\ \201W \201] \201^ #\210\201\\ \201Y \201] \201_ #\210\201\\ \201[ \201] \201` #\210\316\201` \201[ #\210\316\201a \201b #\210\316\201c \201d #\210\316\201e \201f #\210\316\201g \201h #\210\316\201i \201j #\210\316\201k \201l #\210\316\201m \201n \201o E#\210\316\201p \201q #\210\207" [meta-prefix-char help-char isearch-help-map isearch-menu-bar-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-yank-symbol-or-char "\204" isearch-del-char "\231" isearch-yank-char "" isearch-yank-kill "\232" isearch-yank-until-char "\363" isearch-yank-line "\363\274" isearch-beginning-of-buffer "\363\276" isearch-end-of-buffer [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 "\363c" "\363r" "\363e" [134217765] isearch-query-replace [201326629] isearch-query-replace-regexp "\363o" isearch-occur "\363hr" isearch-highlight-regexp "\363hl" isearch-highlight-lines-matching-regexp "8
" isearch-char-by-name [menu-bar search-menu] menu-item "Isearch" [remap tmm-menubar] isearch-tmm-menubar] 8) (#$ . 29333))
#@65 Variable holding the old local value of `tool-bar-map', if any.
(defvar isearch-tool-bar-old-map nil (#$ . 32328))
#@64 Return an image specification for IMAGE-NAME.
(fn IMAGE-NAME)
(defalias 'isearch-tool-bar-image #[257 "\300\301!!\207" [eval tool-bar--image-expression] 4 (#$ . 32449)])
(defvar isearch-tool-bar-map (byte-code "\300 \301\302\303\304\305\306\307\310\311\257#\210\301\312\303\313\314\306\315\310\316\257#\210\301\317\303\320\321\306\322\310\323\257#\210\301\324\303\325\326\306\327\310\330\257#\210\301\331\303\332\333\306\334\310\335\336\337\257 #\210\301\340\303\341\342\306\343\310\344\345\346\257 #\210\301\347\303\350\351\306\352\310\353\257#\210\301\354\303\355\356\306\357\310\360\257#\210\211\207" [make-sparse-keymap define-key [isearch-describe-mode] menu-item "Help" isearch-describe-mode :help "Get help for Isearch" :image (isearch-tool-bar-image "help") [isearch-occur] "Show hits" isearch-occur "Show each search hit" (isearch-tool-bar-image "index") [isearch-query-replace] "Replace" isearch-query-replace "Replace search string" (isearch-tool-bar-image "search-replace") [isearch-delete-char] "Undo" isearch-delete-char "Undo last input item" (isearch-tool-bar-image "undo") [isearch-exit] "Finish" isearch-exit "Finish search leaving point where it is" (isearch-tool-bar-image "exit") :visible (not (string-equal isearch-string "")) [isearch-cancel] "Abort" isearch-cancel "Abort search" (isearch-tool-bar-image "close") :filter #[257 "\203 \301\207\207" [isearch-success isearch-abort] 2 "\n\n(fn BINDING)"] [isearch-repeat-forward] "Repeat forward" isearch-repeat-forward "Repeat search forward" (isearch-tool-bar-image "right-arrow") [isearch-repeat-backward] "Repeat backward" isearch-repeat-backward "Repeat search backward" (isearch-tool-bar-image "left-arrow")] 13))
#@55 Keymap for editing Isearch strings in the minibuffer.
(defvar minibuffer-local-isearch-map (byte-code "\301 \302\"\210\303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\303\316\315#\210\211\207" [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]] 5) (#$ . 34163))
(defvar isearch-forward nil)
(defvar isearch-regexp nil)
(byte-code "\300\301\302\303#\210\304\211\203( \211@\301N\203! \302N\204! \305\302\301N#\210A\266\202\202 \210\306\301\302\307#\207" [defvaralias isearch-word isearch-regexp-function nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1"] 7)
#@765 Regexp-based search mode for words/symbols.
If non-nil, a function to convert a search string to a regexp
used by regexp search functions.
The function should accept 1 or 2 arguments: the original string
to convert, and a flag, whose non-nil value means the match
doesn't have to start or end on a word boundary. The function
should return the corresponding regexp, a string.
The symbol property `isearch-message-prefix' put on this function
specifies the prefix string displayed in the search message.
Existing functions you could use as values are `word-search-regexp',
`isearch-symbol-regexp', and `char-fold-to-regexp'.
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 (#$ . 34986))
#@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 (#$ . 35807))
#@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 (#$ . 36261))
#@217 Stack of search status elements.
Each element is an `isearch--state' struct where the slots are
[STRING MESSAGE POINT SUCCESS FORWARD OTHER-END WORD/REGEXP-FUNCTION
ERROR WRAPPED BARRIER CASE-FOLD-SEARCH POP-FUN]
(defvar isearch-cmds nil (#$ . 36722))
(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 (#$ . 37232))
(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-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 "\303\236\204 \304C\244\210\303 \236\204 \303\nBC\244\210\303\207" [minor-mode-alist minor-mode-map-alist isearch-mode-map isearch-mode (isearch-mode isearch-mode)] 3)
(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)
#@4518 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-beginning-of-buffer] to go to the first match, \[isearch-end-of-buffer] to go to the last match.
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-until-char] to yank from point until the next instance of a
specified character 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-highlight-lines-matching-regexp] to run `highlight-lines-matching-regexp' that highlights lines
matching 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.
(fn &optional REGEXP-P NO-RECURSIVE-EDIT)
(defalias 'isearch-forward #[512 "\300\301??\302?$\207" [isearch-mode t nil] 7 (#$ . 38791) "P\np"])
#@605 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.
(fn &optional NOT-REGEXP NO-RECURSIVE-EDIT)
(defalias 'isearch-forward-regexp #[512 "\300\301?\302?$\207" [isearch-mode t nil] 7 (#$ . 43418) "P\np"])
#@445 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.
(fn &optional NOT-WORD NO-RECURSIVE-EDIT)
(defalias 'isearch-forward-word #[512 "\300\301\302\211??%\207" [isearch-mode t nil] 8 (#$ . 44138) "P\np"])
#@413 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.
(fn &optional NOT-SYMBOL NO-RECURSIVE-EDIT)
(defalias 'isearch-forward-symbol #[512 "\300\301\302\211?\303%\207" [isearch-mode t nil isearch-symbol-regexp] 8 (#$ . 44701) "P\np"])
#@196 Do incremental search backward.
With a prefix argument, do a regular expression search instead.
See the command `isearch-forward' for more information.
(fn &optional REGEXP-P NO-RECURSIVE-EDIT)
(defalias 'isearch-backward #[512 "\300\301??\301?$\207" [isearch-mode nil] 7 (#$ . 45257) "P\np"])
#@305 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.
(fn &optional NOT-REGEXP NO-RECURSIVE-EDIT)
(defalias 'isearch-backward-regexp #[512 "\300\301?\301?$\207" [isearch-mode nil] 7 (#$ . 45561) "P\np"])
#@454 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.
With a prefix argument, search for ARGth symbol forward if ARG is
positive, or search for ARGth symbol backward if ARG is negative.
(fn &optional ARG)
(defalias 'isearch-forward-symbol-at-point #[256 "\301\302\303\"\210\304 \205 \305!\2030 @`W\203 @b\210\306\307@A\"!\210\211\2057 \310!\2027 \311\312 \210\313 \207" [isearch-error isearch-forward-symbol nil 1 find-tag-default-bounds prefix-numeric-value isearch-yank-string buffer-substring-no-properties isearch-repeat-forward "No symbol at point" isearch-push-state isearch-update] 7 (#$ . 45980) "P"])
#@799 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'.
(fn FORWARD &optional REGEXP OP-FUN RECURSIVE-EDIT REGEXP-FUNCTION)
(defalias 'isearch-mode #[1281 "\206 \211?\205 \306=\211\206 \307 !\205 ?\205
+,-.\310\211/0\3111\3062\3113`4\311\21156\311789X\205X \312 \313\314:!_V;\311\211<=\306>\315 ?`@\311\211ABC\316\317!D\311\211EF\311\211GH\311IJK\311J\316\320!\203\231 L\321\320!\210MD\204\252 \321\317!\210\311\322\310!\210;\205\270 \323 N\324\325 !\326!\327>\204\331 \330!\204\320 \331!\210O\203\331 \332!\210\210\333P\334 \210QR\335\336!\210RS\337 \210\340 \210\341\342\343\"\210\341\344\345\"\210\341\346\347\"\210\341\350\351\"\210\203\306 T\352 \210)2\207" [isearch-forward search-default-mode isearch-regexp isearch-regexp-function isearch-op-fun isearch-case-fold-search t functionp "" nil window-height 4 abs window-hscroll local-variable-p input-method-function tool-bar-map 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-mouse-leave-buffer kbd-macro-termination-hook isearch-done recursive-edit 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 isearch-pre-scroll-point isearch-pre-move-point isearch-lazy-count-current isearch-lazy-count-total minibuffer-message-timeout isearch-original-minibuffer-message-timeout isearch-tool-bar-old-map isearch-tool-bar-map isearch-window-configuration minibuffer-auto-raise isearch-mode isearch-mode-map overriding-terminal-local-map isearch--saved-overriding-local-map isearch-recursive-edit] 10 (#$ . 46856)])
(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 #[0 "p=\204 \306!\203 rq\210\307\310 \")p\311\301!\210\310 B\n\204\336 \204\336 \312 \2044 \f\2062 \313 \210
\203\225 \"\204\225 \314 \204\225 `\315\"\316\317!\210\320 #\321\322$\317W\203] $[T\202c \323 $TZ\"\210)$\317W\203\212 \324\320$Z!\210\325\326 `\"\210\327\326 \330 \"\210\327\331 \317\"\210\202\216 \332\320!\210\211b\266\202\275 \330 \322\327\331 %\"\210\314\322\211\315#\262\211\203\265 \211@\333 \334 _Y\203\273 \327\331 \"\210\266&\203\333 &`W\203\322 \335&`\"\210\202\336 \335`&\"\210\202\336 \336 \210\322\211'(\315)\337\340!\210*\205\362 \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 window-min-height search-slow-window-lines isearch-start-hscroll isearch-other-end isearch-adjusted isearch-yank-flag disable-point-adjustment isearch-lazy-highlight] 7 (#$ . 49939)])
#@202 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.
(fn &optional NOPUSH EDIT)
(defalias 'isearch-done #[512 "\203 \306\307\310 \n \f
\3110D\257\"\210\312\313\314\"\210\312\315\316\"\210\312\317\320\"\210\312\321\322\"\210\3231!\203? r1q\210\3241\325\3262\"2)\324345\327 \210\330!\210\3246\331 `7\203p \3327!\2108\203i \211b\210\202p \333\334 \335#\210\266\3249:\203\201 ; \202\205 \336\337!\210<\203\230 \340\341!\210<!\324<\202\234 \336\341!\210\342 \210m?\205\250 \343`\344\"o?\205\262 \343`S\344\"\211\203\321 \203\321 \211=\203\321 \f\203\313 \345`\344\"\202\317 \346`\344\"b\210\266 G\347V\203\343 \204\343 \350 \n\"\210\205\351 \211? =\351\352!\210)`>U\204?\203@\204\353>\335\"\210A\204\354 \347V\204\211\204\355\356!\210\211?\205'B\205'\357 \207" [isearch-resume-in-command-history isearch-string isearch-regexp isearch-regexp-function isearch-forward isearch-message add-to-history command-history isearch-resume quote remove-hook pre-command-hook isearch-pre-command-hook post-command-hook isearch-post-command-hook mouse-leave-buffer-hook isearch-mouse-leave-buffer kbd-macro-termination-hook isearch-done buffer-live-p nil 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 make-local-variable tool-bar-map 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 isearch--current-buffer cursor-sensor-inhibit overriding-terminal-local-map isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-lazy-highlight-last-string isearch-window-configuration isearch-small-window isearch-mode isearch-input-method-local-p isearch-input-method-function isearch-tool-bar-old-map isearch-mode-end-hook-quit isearch-opoint transient-mark-mode mark-active executing-kbd-macro isearch-recursive-edit] 12 (#$ . 51530)])
#@57 List of mouse commands that are allowed during Isearch.
(defvar isearch-mouse-commands '(mouse-minor-mode-menu) (#$ . 53807))
#@201 Exit Isearch unless the mouse command is allowed in Isearch.
Mouse commands are allowed in Isearch if they have a non-nil
`isearch-scroll' property or if they are listed in
`isearch-mouse-commands'.
(defalias 'isearch-mouse-leave-buffer #[0 " >\206 \302N\303=?\205 \304 \207" [this-command isearch-mouse-commands isearch-scroll t isearch-done] 2 (#$ . 53940)])
#@130 Add STRING to the beginning of the search ring.
REGEXP if non-nil says use the regexp search ring.
(fn STRING &optional REGEXP)
(defalias 'isearch-update-ring #[513 "\303\304\203 \305\202\f \306\307!\203 \202 \n\303$)\207" [history-delete-duplicates regexp-search-ring-max search-ring-max t add-to-history regexp-search-ring search-ring isearch-string-propertize] 7 (#$ . 54313)])
#@81 Add isearch properties to the isearch string.
(fn STRING &optional PROPERTIES)
(defalias 'isearch-string-propertize #[513 "\211\204 \300D\262 \204 \303\302\nD\"\262\304\305#\207" [isearch-case-fold-search isearch-regexp isearch-regexp-function append apply propertize] 6 (#$ . 54709)])
#@64 Update isearch properties from the isearch string
(fn STRING)
(defalias 'isearch-update-from-string-properties #[257 "\302\303\304\"\300\"\203 \305\304\300#\302\303\304\"\301\"\205! \305\304\301#\211\207" [isearch-case-fold-search isearch-regexp-function plist-member text-properties-at 0 get-text-property] 5 (#$ . 55010)])
#@73 compiler-macro for inlining `isearch--state-p'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-p (and (memq (type-of cl-x) cl-struct-isearch--state-tags) t)) nil] 9 (#$ . 55349)])
(put 'isearch--state-p 'compiler-macro 'isearch--state-p--cmacro)
#@13
(fn CL-X)
(defalias 'isearch--state-p #[257 "\301!>\205 \302\207" [cl-struct-isearch--state-tags type-of t] 3 (#$ . 55708)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put isearch--state-p side-effect-free error-free put isearch--state cl-deftype-satisfies] 5)
#@78 compiler-macro for inlining `isearch--state-string'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-string--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-string (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 1))) nil] 9 (#$ . 55999)])
(put 'isearch--state-string 'compiler-macro 'isearch--state-string--cmacro)
#@66 Access slot "string" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-string #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 1] 5 (#$ . 56432)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-string side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-string] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-message'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-message--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-message (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 2))) nil] 9 (#$ . 56927)])
(put 'isearch--state-message 'compiler-macro 'isearch--state-message--cmacro)
#@67 Access slot "message" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-message #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 2] 5 (#$ . 57365)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-message side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-message] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@77 compiler-macro for inlining `isearch--state-point'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-point--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-point (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 3))) nil] 9 (#$ . 57864)])
(put 'isearch--state-point 'compiler-macro 'isearch--state-point--cmacro)
#@65 Access slot "point" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-point #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 3] 5 (#$ . 58292)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-point side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-point] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-success'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-success--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-success (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 4))) nil] 9 (#$ . 58783)])
(put 'isearch--state-success 'compiler-macro 'isearch--state-success--cmacro)
#@67 Access slot "success" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-success #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 4] 5 (#$ . 59221)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-success side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-success] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-forward'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-forward--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-forward (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 5))) nil] 9 (#$ . 59720)])
(put 'isearch--state-forward 'compiler-macro 'isearch--state-forward--cmacro)
#@67 Access slot "forward" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-forward #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 5] 5 (#$ . 60158)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-forward side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-forward] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@81 compiler-macro for inlining `isearch--state-other-end'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-other-end--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-other-end (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 6))) nil] 9 (#$ . 60657)])
(put 'isearch--state-other-end 'compiler-macro 'isearch--state-other-end--cmacro)
#@69 Access slot "other-end" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-other-end #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 6] 5 (#$ . 61105)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-other-end side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-other-end] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@76 compiler-macro for inlining `isearch--state-word'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-word--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-word (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 7))) nil] 9 (#$ . 61612)])
(put 'isearch--state-word 'compiler-macro 'isearch--state-word--cmacro)
#@64 Access slot "word" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-word #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 7] 5 (#$ . 62035)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-word side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-word] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@77 compiler-macro for inlining `isearch--state-error'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-error--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-error (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 8))) nil] 9 (#$ . 62522)])
(put 'isearch--state-error 'compiler-macro 'isearch--state-error--cmacro)
#@65 Access slot "error" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-error #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 8] 5 (#$ . 62950)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-error side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-error] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-wrapped'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-wrapped--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-wrapped (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 9))) nil] 9 (#$ . 63441)])
(put 'isearch--state-wrapped 'compiler-macro 'isearch--state-wrapped--cmacro)
#@67 Access slot "wrapped" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-wrapped #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 9] 5 (#$ . 63879)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-wrapped side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-wrapped] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-barrier'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-barrier--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-barrier (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 10))) nil] 9 (#$ . 64378)])
(put 'isearch--state-barrier 'compiler-macro 'isearch--state-barrier--cmacro)
#@67 Access slot "barrier" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-barrier #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 10] 5 (#$ . 64817)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-barrier side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-barrier] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@88 compiler-macro for inlining `isearch--state-case-fold-search'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-case-fold-search--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-case-fold-search (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 11))) nil] 9 (#$ . 65317)])
(put 'isearch--state-case-fold-search 'compiler-macro 'isearch--state-case-fold-search--cmacro)
#@76 Access slot "case-fold-search" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-case-fold-search #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 11] 5 (#$ . 65801)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-case-fold-search side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-case-fold-search] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `isearch--state-pop-fun'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'isearch--state-pop-fun--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block isearch--state-pop-fun (progn (or (isearch--state-p cl-x) (signal 'wrong-type-argument (list 'isearch--state cl-x))) (aref cl-x 12))) nil] 9 (#$ . 66337)])
(put 'isearch--state-pop-fun 'compiler-macro 'isearch--state-pop-fun--cmacro)
#@67 Access slot "pop-fun" of `isearch--state' struct CL-X.
(fn CL-X)
(defalias 'isearch--state-pop-fun #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-isearch--state-tags type-of signal wrong-type-argument isearch--state 12] 5 (#$ . 66776)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put isearch--state-pop-fun side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" isearch--state-pop-fun] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@51 Constructor for objects of type `isearch--state'.
(defalias 'isearch--get-state #[0 " `\n \f
\n \f
\205
\306\307\f\f\f\f\f\f\f\f\f\f\f
&
)\207" [isearch-string isearch-message isearch-success isearch-forward isearch-other-end isearch-regexp-function record isearch--state isearch-error isearch-wrapped isearch-barrier isearch-case-fold-search case-fold-search isearch-push-state-function] 25 (#$ . 67276)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303& \207" [function-put isearch--get-state side-effect-free t cl-struct-define isearch--state nil cl-structure-object record ((cl-tag-slot) (string nil :read-only t) (message nil :read-only t) (point nil :read-only t) (success nil :read-only t) (forward nil :read-only t) (other-end nil :read-only t) (word nil :read-only t) (error nil :read-only t) (wrapped nil :read-only t) (barrier nil :read-only t) (case-fold-search nil :read-only t) (pop-fun nil :read-only t)) cl-struct-isearch--state-tags] 11)
#@12
(fn CMD)
(defalias 'isearch--set-state #[257 "\306!>\204 \307\310\311D\"\210\211\312H\306!>\204\" \307\310\311D\"\210\211\313H\306!>\2045 \307\310\311D\"\210\211\314H\306!>\204H \307\310\311D\"\210\211\315H\306!>\204[ \307\310\311D\"\210\211\316H\306!>\204n \307\310\311D\"\210\211\317H\306!>\204\202 \307\310\311D\"\210\211\320H\306!>\204\226 \307\310\311D\"\210\211\321H\306!>\204\252 \307\310\311D\"\210\211\322H\306!>\204\276 \307\310\311D\"\210\211\323H\324\306!>\204\323 \307\310\311D\"\210\325H!\203\357 \306!>\204\351 \307\310\311D\"\210\211\325H!\210\306!>\204\376 \307\310\311D\"\210\211\326Hb\207" [cl-struct-isearch--state-tags isearch-string isearch-message isearch-success isearch-forward isearch-other-end type-of signal wrong-type-argument isearch--state 1 2 4 5 6 7 8 9 10 11 functionp 12 3 isearch-regexp-function isearch-error isearch-wrapped isearch-barrier isearch-case-fold-search] 6 (#$ . 68284)])
(defalias 'isearch-pop-state #[0 "A\301@!\207" [isearch-cmds isearch--set-state] 2])
(defalias 'isearch-push-state #[0 "\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 #[0 "\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 (#$ . 69450) nil])
#@168 Return position of first mismatch in search string, or nil if none.
If MSG is non-nil, use variable `isearch-message', otherwise `isearch-string'.
(fn &optional MSG)
(defalias 'isearch-fail-pos #[256 "\203 \202\n \n\306 \203 \f\205\245 \203P \307@!
>\204( \310\311\312@D\"\210@\313H\203G \307@!
>\204@ \310\311\312@D\"\210@\314H\203P \211A\262\210\202 \205\205 \203p \307@!
>\204i \310\311\312@D\"\210@\315H\202\205 \307@!
>\204\201 \310\311\312@D\"\210@\316H\262\211;\203\244 \211GGW\203\244 \211\317\320G#\232\203\244 \211G\202\245 \320\207" [isearch-cmds isearch-message isearch-string isearch-success isearch-error cl-struct-isearch--state-tags nil type-of signal wrong-type-argument isearch--state 4 8 2 1 substring 0] 9 (#$ . 69902)])
(byte-code "\300\301\302\303#\210\304\211\203( \211@\301N\203! \302N\204! \305\302\301N#\210A\266\202\202 \210\306\301\302\307#\207" [defvaralias isearch-new-word isearch-new-regexp-function nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1"] 7)
#@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 (#$ . 70954))
(defvar isearch-suspended nil)
#@303 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', `isearch-new-nonincremental'.
(fn &rest BODY)
(defalias 'with-isearch-suspended '(macro . #[128 "\300\301\302\303\304\305\306\307\310\302\nB\311BB\312BBBBBB\313BB\314BBB\207" [condition-case nil progn let ((isearch-new-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) (multi-isearch-file-list-new multi-isearch-file-list) (multi-isearch-buffer-list-new multi-isearch-buffer-list) (multi-isearch-next-buffer-function multi-isearch-next-buffer-current-function) (multi-isearch-current-buffer-new multi-isearch-current-buffer) (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) (setq isearch-suspended t) (condition-case nil (isearch-done t t) (exit nil)) (setq old-point (point) old-other-end isearch-other-end) unwind-protect ((setq isearch-suspended nil) (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-nonincremental isearch-new-nonincremental isearch-regexp-function isearch-new-regexp-function isearch-case-fold-search isearch-new-case-fold multi-isearch-current-buffer multi-isearch-current-buffer-new multi-isearch-file-list multi-isearch-file-list-new multi-isearch-buffer-list multi-isearch-buffer-list-new) (isearch-update-from-string-properties isearch-string) (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) (unless (and isearch-cmds (equal (car isearch-cmds) (isearch--get-state))) (isearch-push-state)) (isearch-update) (if isearch-nonincremental (progn (isearch-done) (if (equal isearch-string #1#) (message #1#))))) ((quit (setq isearch-suspended nil) (isearch-abort)))] 12 (#$ . 71281)]))
#@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 #[0 "\3061X C\nC \f
#$%&'()*+,-./0123\307 4\211\310C\310C 4 5 6 3 2 1 0\n 7
+ * ) ( ' & % $ # 8 9 :\311;\3121\222 \313\311\211\"0\202\226 \210\202\227 \210`\240\210\211<\240\210\314\315\316\317\320 \f\f&\321\"\322$\216\310\211 = >\310 ?\311 @\323\324\310\" \325 \206\327 GTBA\310#\203\355 \326B\206\350 \327TB\202\366 \330C\206\364 \327TB\310\311&\240\210\331\332 \242\333#\240\210- G\315U\203+#\203\202@\206 \333\331\332 \333#\334\310!\210.\266 \335 \210%\203@%@\336 \232\204C\337 \210\340 \210\205V\313 \210 \333\232\205V\341\333!0\207\210\310;\342 \207" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-regexp-function isearch-case-fold-search (quit) current-window-configuration nil t (exit) isearch-done make-byte-code 0 "\310
\311\310%\210\300\242\301\242 \302\305\303\304\312!\210\206: \313\310\314\"\210\307\242\205U \306\242`=\205U =\205U \307\242b\207" vconcat vector [nil isearch-mode isearch-update-from-string-properties isearch-message t isearch-suspended isearch-forward isearch-regexp isearch-op-fun isearch-regexp-function isearch-string isearch-new-forward isearch-new-nonincremental isearch-nonincremental isearch-new-regexp-function isearch-case-fold-search multi-isearch-current-buffer multi-isearch-file-list multi-isearch-buffer-list isearch-message-function] 6 read-from-minibuffer isearch-message-prefix isearch-fail-pos regexp-search-ring -1 search-ring mapconcat isearch-text-char-description "" isearch-ring-adjust1 isearch-search isearch--get-state 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 multi-isearch-file-list multi-isearch-buffer-list multi-isearch-next-buffer-current-function multi-isearch-current-buffer isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-window-configuration multi-isearch-next-buffer-function isearch-new-regexp-function isearch-new-forward isearch-new-nonincremental isearch-suspended isearch-other-end message-log-max history-add-new-input minibuffer-history-symbol minibuffer-allow-text-properties minibuffer-local-isearch-map regexp-search-ring-yank-pointer search-ring-yank-pointer] 42 (#$ . 74476) nil])
(defalias 'isearch-nonincremental-exit-minibuffer #[0 "\301\302 \207" [isearch-new-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 #[0 "\302\303\304 \207" [isearch-new-forward isearch-new-nonincremental t nil exit-minibuffer] 1 (#$ . 77655) nil])
#@78 Resume isearching backward from the minibuffer that edits the search string.
(defalias 'isearch-reverse-exit-minibuffer #[0 "\302\211\303 \207" [isearch-new-forward isearch-new-nonincremental nil exit-minibuffer] 2 (#$ . 77898) nil])
#@57 Terminate the search and go back to the starting point.
(defalias 'isearch-cancel #[0 "\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 (#$ . 78140) 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 #[0 "\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 (#$ . 78479) nil])
#@34
(fn DIRECTION &optional COUNT)
(defalias 'isearch-repeat #[513 "\306==\203^ \307\232\203< \n\203 \202 \f\204 \310\202d \n\203' \202( \f@\311\312 \307#\313\314!\210\202d \204d \315\203P \210\202d \203X e\202Y db\210\202d ?\315` \307\232\203s \315\202\330 \316\206} \317S\211\262X\203\327 \203\274 ` \232\203\274 \204\274 \203\236 m\202\237 o\203\253 \314\320 \210\202\277 \203\263 \317\202\264 \321u\210\322 \210\202\277 \322 \210\211\316V\203\310 \323 \210\203\321
\203w \316\262\202w )\323 \210\324 \207" [isearch-forward isearch-string isearch-regexp regexp-search-ring search-ring isearch-error forward "" "No previous search string" mapconcat isearch-text-char-description isearch-ring-adjust1 nil t 0 1 ding -1 isearch-search isearch-push-state isearch-update isearch-message isearch-last-case-fold-search isearch-case-fold-search isearch-success isearch-wrapped isearch-wrap-function isearch-barrier isearch-cmds isearch-other-end isearch-just-started] 6 (#$ . 78903)])
#@377 Repeat incremental search forwards.
With a numeric argument, repeat the search ARG times.
A negative argument searches backwards.
\<isearch-mode-map>
This command finds the next relative occurrence of the current
search string. To find the absolute occurrence from the beginning
of the buffer, type \[isearch-beginning-of-buffer] with a numeric argument.
(fn &optional ARG)
(defalias 'isearch-repeat-forward #[256 "\211\203& \301!\211\302W\203 \303\304!!\210\305\306!\202% \204! \211T\262\305\306\"\207\305\306!\207" [isearch-forward prefix-numeric-value 0 isearch-repeat-backward abs isearch-repeat forward] 5 (#$ . 79941) "P"])
#@365 Repeat incremental search backwards.
With a numeric argument, repeat the search ARG times.
A negative argument searches forwards.
\<isearch-mode-map>
This command finds the next relative occurrence of the current
search string. To find the absolute occurrence from the end
of the buffer, type \[isearch-end-of-buffer] with a numeric argument.
(fn &optional ARG)
(defalias 'isearch-repeat-backward #[256 "\211\203& \301!\211\302W\203 \303\304!!\210\305\306!\202% \203! \211T\262\305\306\"\207\305\306!\207" [isearch-forward prefix-numeric-value 0 isearch-repeat-forward abs isearch-repeat backward] 5 (#$ . 80586) "P"])
#@382 Go to the first occurrence of the current search string.
Move point to the beginning of the buffer and search forwards from the top.
\<isearch-mode-map>
With a numeric argument, go to the ARGth absolute occurrence counting from
the beginning of the buffer. To find the next relative occurrence forwards,
type \[isearch-repeat-forward] with a numeric argument.
(fn &optional ARG)
(defalias 'isearch-beginning-of-buffer #[256 "\211\203 \211\301W\203 \302\303!!\207\304eb\210\305\306\"\207" [isearch-just-started 0 isearch-end-of-buffer abs t isearch-repeat forward] 4 (#$ . 81220) "p"])
#@375 Go to the last occurrence of the current search string.
Move point to the end of the buffer and search backwards from the bottom.
\<isearch-mode-map>
With a numeric argument, go to the ARGth absolute occurrence counting from
the end of the buffer. To find the next relative occurrence backwards,
type \[isearch-repeat-backward] with a numeric argument.
(fn &optional ARG)
(defalias 'isearch-end-of-buffer #[256 "\211\203 \211\301W\203 \302\303!!\207\304db\210\305\306\"\207" [isearch-just-started 0 isearch-beginning-of-buffer abs t isearch-repeat backward] 4 (#$ . 81819) "p"])
#@474 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.
(fn MODE KEY FUNCTION &optional DOCSTRING &rest BODY)
(defalias 'isearch-define-mode-toggle '(macro . #[1155 "\300\301\302\"!\303P\304\305\306\301\307\f\n\203 \310 P\202 \311#\312\313\314\f\205: \315\316\317\320\316\321DE\321DEE\322B \323#BBBBBB\324\325\321DF\205\211 9\205\211 \326\327 D\330\301\331\"F\326\327\nD\332F\333\334\335\336\337\336\327\340\341\342\301\343\"!FD\344BBEE\345BBEBBB\207" [intern format "isearch-toggle-%s" "\363" progn defun nil "Toggle %s searching on or off.%s" "\n" "" (interactive) (unless isearch-mode (isearch-mode t)) append setq isearch-regexp-function unless eq function ((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))] 25 (#$ . 82412)]))
(byte-code "\300\301\302\303#\300\207" [function-put isearch-define-mode-toggle lisp-indent-function defun] 4)
#@80 Toggle word searching on or off.
Turning on word search turns off regexp mode.
(defalias 'isearch-toggle-word #[0 "\204 \300\305!\210 \306=?\205 \306\307\305\211\310 \207" [isearch-mode isearch-regexp-function isearch-regexp isearch-success isearch-adjusted t word-search-regexp nil isearch-update] 3 (#$ . 83911) nil])
(byte-code "\301\302\303#\210\304\305\306\307#\210\304\305\310\302#\210\304\311\312\311\312N\313\314ABB\262#\207" [isearch-mode-map 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)] 7)
#@84 Toggle symbol searching on or off.
Turning on symbol search turns off regexp mode.
(defalias 'isearch-toggle-symbol #[0 "\204 \300\305!\210 \306=?\205 \306\307\305\211\310 \207" [isearch-mode isearch-regexp-function isearch-regexp isearch-success isearch-adjusted t isearch-symbol-regexp nil isearch-update] 3 (#$ . 84581) nil])
(byte-code "\301\302\303#\210\304\305\306\307#\210\304\305\310\302#\210\304\311\312\311\312N\313\314ABB\262#\207" [isearch-mode-map 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)] 7)
#@91 Toggle char-fold searching on or off.
Turning on character-folding turns off regexp mode.
(defalias 'isearch-toggle-char-fold #[0 "\204 \300\305!\210 \306=?\205 \306\307\305\211\310 \207" [isearch-mode isearch-regexp-function isearch-regexp isearch-success isearch-adjusted t char-fold-to-regexp nil isearch-update] 3 (#$ . 85272) nil])
(byte-code "\301\302\303#\210\304\305\306\307#\210\304\305\310\302#\210\304\311\312\311\312N\313\314ABB\262#\207" [isearch-mode-map 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)] 7)
#@36 Toggle regexp searching on or off.
(defalias 'isearch-toggle-regexp #[0 "\204 \300\305!\210 ?\211\203 \306\305\211\307 \207" [isearch-mode isearch-regexp isearch-regexp-function isearch-success isearch-adjusted t nil isearch-update] 3 (#$ . 85976) nil])
(define-key isearch-mode-map "\363r" 'isearch-toggle-regexp)
#@55 Text properties that are added to the isearch prompt.
(defvar isearch-message-properties minibuffer-prompt-properties (#$ . 86304))
#@74 Print STRING at the end of the isearch prompt for 1 second.
(fn STRING)
(defalias 'isearch--momentary-message #[257 "\304\305\306\307\304 \"\n\310\311\312\313\" #$\210)\314\315!\207" [message-log-max isearch-nonincremental isearch-message isearch-message-properties nil message "%s%s%s" isearch-message-prefix apply propertize format " [%s]" sit-for 1] 10 (#$ . 86442)])
#@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 #[0 "\204 \300\306!\210\307 \203 \n?\211\202 ?\211\203 \310\202 \311!\210\306\211\312 \207" [isearch-mode isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace isearch-success isearch-adjusted t isearch--momentary-message "match spaces loosely" "match spaces literally" isearch-update] 4 (#$ . 86824) 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 #[0 "\204 \300\304!\210\305 ?\205 \306\211\203 \307\202 \310!\210\304\211\311 \207" [isearch-mode isearch-case-fold-search isearch-success isearch-adjusted t isearch--momentary-message yes "case insensitive" "case sensitive" isearch-update] 4 (#$ . 87482) 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 #[0 "\204 \300\305!\210\306 ?\205 \n\206 \307\211\203 \310\202 \311!\210\305\211\312 \207" [isearch-mode isearch-invisible search-invisible isearch-success isearch-adjusted t isearch--momentary-message open "match invisible text" "match visible text" isearch-update] 4 (#$ . 87959) nil])
(define-key isearch-mode-map "\363i" 'isearch-toggle-invisible)
#@558 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'.
(fn STRING &optional LAX)
(defalias 'word-search-regexp #[513 "\301\232\203 \301\207\302\303\304\305#)\266\203\203 \306\207\307\303\304\305#)\266\203\203. \306\202/ \310\311\312\313\306\304#\306#\314\303\304\305#)\266\203\203L \306\202R ?\205R \315Q\207" [inhibit-changing-match-data "" "\\`\\W+\\'" nil t string-match "\\W+" "\\`\\W" "\\<" mapconcat regexp-quote split-string "\\W\\'" "\\>"] 11 (#$ . 88620)])
#@1222 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.
(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'word-search-backward #[1025 "\300\301\302\"$\207" [re-search-backward word-search-regexp nil] 9 (#$ . 89590) "sWord search backward: "])
#@1194 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.
(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'word-search-forward #[1025 "\300\301\302\"$\207" [re-search-forward word-search-regexp nil] 9 (#$ . 90971) "sWord search: "])
#@1339 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.
(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'word-search-backward-lax #[1025 "\300\301\302\"$\207" [re-search-backward word-search-regexp t] 9 (#$ . 92313) "sWord search backward: "])
#@1310 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.
(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'word-search-forward-lax #[1025 "\300\301\302\"$\207" [re-search-forward word-search-regexp t] 9 (#$ . 93813) "sWord search: "])
#@510 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.
(fn STRING &optional LAX)
(defalias 'isearch-symbol-regexp #[513 "\301\302\232\203 \302\202b \303\304\"\305\306\307#)\266\203\203\" \211\202b \303\310\"\305\306\307#)\266\203\2039 \211\202: \311\312\313\314\306##\303\315\"\305\306\307#)\266\203\203[ \202a ?\205a \316Q\207" [inhibit-changing-match-data "\\(?:\\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\\'" "\\_>"] 12 (#$ . 95272)])
#@112 Search forward for STRING, matching a sequence of whitespace chars.
(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'search-forward-lax-whitespace #[1025 "\302\303!$)\207" [search-whitespace-regexp search-spaces-regexp re-search-forward regexp-quote] 9 (#$ . 96318)])
#@113 Search backward for STRING, matching a sequence of whitespace chars.
(fn STRING &optional BOUND NOERROR COUNT)
(defalias 'search-backward-lax-whitespace #[1025 "\302\303!$)\207" [search-whitespace-regexp search-spaces-regexp re-search-backward regexp-quote] 9 (#$ . 96604)])
#@112 Search forward for REGEXP, matching a sequence of whitespace chars.
(fn REGEXP &optional BOUND NOERROR COUNT)
(defalias 're-search-forward-lax-whitespace #[1025 "\302$)\207" [search-whitespace-regexp search-spaces-regexp re-search-forward] 9 (#$ . 96893)])
#@113 Search backward for REGEXP, matching a sequence of whitespace chars.
(fn REGEXP &optional BOUND NOERROR COUNT)
(defalias 're-search-backward-lax-whitespace #[1025 "\302$)\207" [search-whitespace-regexp search-spaces-regexp re-search-backward] 9 (#$ . 97164)])
(byte-code "\300\211\203 \211@\301\302\303#\210A\266\202\202 \207" [(re-search-forward-lax-whitespace search-backward-lax-whitespace search-forward-lax-whitespace re-search-backward-lax-whitespace) make-obsolete "instead, use (let ((search-spaces-regexp search-whitespace-regexp))\n (re-search-... ...))" "25.1"] 6)
#@533 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-%'.
(fn &optional ARG REGEXP-FLAG)
(defalias 'isearch-query-replace #[512 "\306 \210\211\203 \307 \310\n \f\205 \311=?\205! \311=\310\312
! \313\310\307\"\210\314 \210 \203y \203R `V\202V `W\203y \203u !\203u \203n \315 `V\202r \315 `W\204y b\210\"\"JBL\210\316\317\320\321 \206\217 #\307\"\203\232 \322\202\233 \323\324 \203\244 \325\202\245 \323R#\307\206\261 #\310\211\324 \205\272 \326 \324 \205\301 \327 \f&\n\210.\266 \205\321 \330 \207" [isearch-regexp isearch-case-fold-search isearch-invisible isearch-lax-whitespace isearch-regexp-lax-whitespace isearch-string barf-if-buffer-read-only t nil - isearch-string-propertize isearch-done isearch-clean-overlays mark perform-replace query-replace-read-to "Query replace" isearch--describe-regexp-mode " backward" "" use-region-p " in region" region-beginning region-end exit-recursive-edit isearch-recursive-edit 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-regexp-function] 22 (#$ . 97772) (list current-prefix-arg)])
#@148 Start `query-replace-regexp' with string to replace from last search string.
See `isearch-query-replace' for more information.
(fn &optional ARG)
(defalias 'isearch-query-replace-regexp #[256 "\300\301\"\207" [isearch-query-replace t] 4 (#$ . 99464) (list current-prefix-arg)])
#@583 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.
(fn REGEXP &optional NLINES)
(defalias 'isearch-occur #[513 "\306 \203\n \n\202 \205 \f \307\203( \310\311 \312\313!%\202) \314 \2051 \315 #+\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 use-region-p region-bounds search-upper-case case-fold-search isearch-regexp-function] 10 (#$ . 99751) (byte-code ":\306 !\203 \n!\202# \203 \307\n!\202# \203 \n\202# \310\n!\211\203]\311!\312U\2034 \313\202d\f@\314\3151Q
\n&' ( )*+,-./012345678\316 9\211\314C\314C 9 : ; 8 7 6 5\n <
0 / . - , + * ) = > ?\317@\3201\310 \321\317\211\"0\202\314 \210\202\315 \210`\240\210\211A\240\210\322\312\323\324\325 \f\f&\326\"\327$\216\330\331\332 \" \304#\262 )\nG\312U\203\" \203B\202C@\206\333\334\335\n\333#&\336\314!\210.\266 \337 \210*\2037*@\340 \232\204:\341 \210\342 \210
\205M\321 \210\n\333\232\205M\343\333!0\202W\210\314@\344 \210\262\202d\205d\345!D\207" [current-prefix-arg isearch-regexp-function isearch-string isearch-regexp occur-collect-regexp-history isearch-nonincremental functionp word-search-regexp regexp-quote regexp-opt-depth 0 "\\&" nil (quit) current-window-configuration t (exit) isearch-done make-byte-code "\310
\311\310%\210\300\301 \302\305\303\304\312!\210\2068 \313\310\314\"\210\307\242\205S \306\242`=\205S =\205S \307\242b\207" vconcat vector [nil isearch-mode isearch-update-from-string-properties isearch-message t isearch-suspended isearch-forward isearch-regexp isearch-op-fun isearch-regexp-function isearch-string isearch-new-forward isearch-new-nonincremental isearch-nonincremental isearch-new-regexp-function isearch-case-fold-search multi-isearch-current-buffer multi-isearch-file-list multi-isearch-buffer-list isearch-message-function] 6 read-regexp format "Regexp to collect (default %s): " "" mapconcat isearch-text-char-description isearch-ring-adjust1 isearch-search isearch--get-state isearch-push-state isearch-update message isearch-abort prefix-numeric-value isearch-message isearch-forward isearch-case-fold-search isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error multi-isearch-file-list multi-isearch-buffer-list multi-isearch-next-buffer-current-function multi-isearch-current-buffer isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-window-configuration multi-isearch-next-buffer-function isearch-new-regexp-function isearch-new-forward isearch-new-nonincremental isearch-suspended isearch-other-end regexp-search-ring search-ring] 46)])
#@301 Run HI-LOCK-FUNC to exit isearch, leaving the matches highlighted.
This is the internal function used by `isearch-highlight-regexp'
and `isearch-highlight-lines-matching-regexp' to invoke
HI-LOCK-FUNC (either `highlight-regexp' or `highlight-lines-matching-regexp',
respectively).
(fn HI-LOCK-FUNC)
(defalias 'isearch--highlight-regexp-or-lines #[257 "\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 \"\266\205\\ \324 \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 #[257 "\300!\301\302\"\203 \303\304\226\227#\202 \305!\207" [string string-match "[[:alpha:]]" format "[%s%s]" regexp-quote] 6 "\n\n(fn C)"] "" regexp-quote hi-lock-read-face-name exit-recursive-edit] 5 (#$ . 103244)])
#@171 Exit Isearch mode and call `highlight-regexp'.
The arguments passed to `highlight-regexp' are the regexp from
the last search and the face from `hi-lock-read-face-name'.
(defalias 'isearch-highlight-regexp #[0 "\300\301!\207" [isearch--highlight-regexp-or-lines highlight-regexp] 2 (#$ . 104287) nil])
#@201 Exit Isearch mode and call `highlight-lines-matching-regexp'.
The arguments passed to `highlight-lines-matching-regexp' are the
regexp from the last search and the face from `hi-lock-read-face-name'.
(defalias 'isearch-highlight-lines-matching-regexp #[0 "\300\301!\207" [isearch--highlight-regexp-or-lines highlight-lines-matching-regexp] 2 (#$ . 104596) nil])
#@316 Undo last input item during a search.
An input item is the result of a command that pushes a new state
of isearch (as recorded by the `isearch--state' structure) to
`isearch-cmds'. Info node `(emacs)Basic Isearch' explains when
Emacs records a new input item.
If no input items have been entered yet, just beep.
(defalias 'isearch-delete-char #[0 "A\204 \301 \210\202 \302 \210\303 \207" [isearch-cmds ding isearch-pop-state isearch-update] 1 (#$ . 104965) nil])
#@242 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.
(fn &optional ARG)
(defalias 'isearch-del-char #[256 "G\304U\203
\305 \210\202! \306\304\206 \307G^[#\310\311\312#\n\206& \301\313\314\"\210 \2031 b\210\315 \210\316 \210\317 \207" [isearch-string isearch-message isearch-message-function isearch-other-end 0 ding substring 1 mapconcat isearch-text-char-description "" nil t isearch-search isearch-push-state isearch-update] 6 (#$ . 105441) "p"])
#@46 Pull STRING into search string.
(fn STRING)
(defalias 'isearch-yank-string #[257 "\203 \304=\203 \211\227\262\n\203 \305!\262\306\307\310\311\312#\"\207" [isearch-case-fold-search search-upper-case isearch-regexp isearch-yank-flag not-yanks regexp-quote t isearch-process-search-string mapconcat isearch-text-char-description ""] 7 (#$ . 106075)])
#@48 Pull string from kill ring into search string.
(defalias 'isearch-yank-kill #[0 "\204 \300\301!\210\302\303\304!!\207" [isearch-mode t isearch-yank-string current-kill 0] 3 (#$ . 106441) nil])
#@66 Replace just-yanked search string with previously killed string.
(defalias 'isearch-yank-pop #[0 "\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 (#$ . 106642) nil])
#@46 Pull current X selection into search string.
(defalias 'isearch-yank-x-selection #[0 "\301\302 !\210\205 \303 \207" [select-active-regions isearch-yank-string gui-get-selection deactivate-mark] 2 (#$ . 106941) nil])
#@205 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.
(fn CLICK)
(defalias 'isearch-mouse-2 #[257 "\301!\211@\262\302\303\304 \305\")\306!\203 \307!\204 \310 \202) \311!\205) \312!\207" [overriding-terminal-local-map event-start nil key-binding this-command-keys-vector t window-minibuffer-p minibuffer-window-active-p isearch-yank-x-selection functionp call-interactively] 5 (#$ . 107166) "e"])
#@53 Pull terminal paste into search string.
(fn EVENT)
(defalias 'isearch-xterm-paste #[257 "\211\242\300=\205 \211A@\301!\262\207" [xterm-paste isearch-yank-string] 4 (#$ . 107716) "e"])
#@333 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.
(fn JUMPFORM)
(defalias 'isearch-yank-internal #[257 "\302\212\204
\203
b\210\303` \")!\207" [isearch-forward isearch-other-end isearch-yank-string buffer-substring-no-properties] 5 (#$ . 107911)])
#@94 Pull next character from buffer into end of search string in minibuffer.
(fn &optional ARG)
(defalias 'isearch-yank-char-in-minibuffer #[256 "m\203 r\300 A@q\210\301`u\210`\")c\207\211u\207" [buffer-list buffer-substring-no-properties] 4 (#$ . 108439) "p"])
#@134 Pull next character from buffer into search string.
If optional ARG is non-nil, pull in the next ARG characters.
(fn &optional ARG)
(defalias 'isearch-yank-char #[256 "\300\301\302\303\304\305!\306\"\307$!\207" [isearch-yank-internal make-byte-code 0 "\300u\210`\207" vconcat vector [] 1] 8 (#$ . 108707) "p"])
#@37
(fn SYNTAX-LIST FN &optional ARG)
(defalias 'isearch--yank-char-or-syntax #[770 "\300\301\302\303\304\305#\306\"\307$!\207" [isearch-yank-internal make-byte-code 0 "\302\303\211W\2034 \211\304f\206 \303z\300>\204\" `Tf\206 \303z\300>\203) \301\305!\210\202, \305u\210\210\211T\262\202 \266`\207" vconcat vector [0 nil 1] 5] 12 (#$ . 109027)])
#@148 Pull next character or word from buffer into search string.
If optional ARG is non-nil, pull in the next ARG characters/words.
(fn &optional ARG)
(defalias 'isearch-yank-word-or-char #[256 "\300\301\302#\207" [isearch--yank-char-or-syntax (119) forward-word] 5 (#$ . 109391) "p"])
#@152 Pull next character or symbol from buffer into search string.
If optional ARG is non-nil, pull in the next ARG characters/symbols.
(fn &optional ARG)
(defalias 'isearch-yank-symbol-or-char #[256 "\300\301\302#\207" [isearch--yank-char-or-syntax (119 95) forward-symbol] 5 (#$ . 109681) "p"])
#@124 Pull next word from buffer into search string.
If optional ARG is non-nil, pull in the next ARG words.
(fn &optional ARG)
(defalias 'isearch-yank-word #[256 "\300\301\302\303\304\305!\306\"\307$!\207" [isearch-yank-internal make-byte-code 0 "\300v\210`\207" vconcat vector [] 1] 8 (#$ . 109982) "p"])
#@339 Pull everything until next instance of CHAR from buffer into search string.
Interactively, prompt for CHAR.
If optional ARG is non-nil, pull until next ARGth instance of CHAR.
This is often useful for keyboard macros, for example in programming
languages or markup languages in which CHAR marks a token boundary.
(fn CHAR &optional ARG)
(defalias 'isearch-yank-until-char #[513 "\300\301\302\303\304\305\"\306\"\307$!\207" [isearch-yank-internal make-byte-code 0 "\303\3041 \305\306\300!\307\211\301$\210\310u0\202 \210\311\312\300\"\210\313\314!\210`)\207" vconcat vector [inhibit-field-text-motion t (search-failed) search-forward char-to-string nil -1 message "`%c' not found" sit-for 2] 5] 10 (#$ . 110293) "cYank until character: \np"])
#@124 Pull rest of line from buffer into search string.
If optional ARG is non-nil, yank the next ARG lines.
(fn &optional ARG)
(defalias 'isearch-yank-line #[256 "\300\301\302\303\304\305!\306\"\307$!\207" [isearch-yank-internal make-byte-code 0 "\302\303l\203\f \300T\202
\300!)\207" vconcat vector [inhibit-field-text-motion t line-end-position] 2] 8 (#$ . 111050) "p"])
#@218 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.
(fn &optional COUNT)
(defalias 'isearch-char-by-name #[256 "\3061@ C\nC \f
\"#$%&'()*+,-./012\307 3\211\310C\310C 3 4 5 2 1 0 /\n 6
* ) ( ' & % $ # \" 7 8 9\311:\3121\222 \313\311\211\"0\202\226 \210\202\227 \210`\240\210\211;\240\210\314\315\316\317\320 \f\f&\321\"\322$\216\323\324!\211\203\356 \250\203\330 \325V\203\330 \326 \"\202\333 \327! P\240\210\n\330\331\332#P\240\266\210) G\315U\203\"\203<\202=@\206\332\330\331 \332#\333\310!\210.\266 \334 \210$\203($@\335 \232\204+\336 \210\337 \210\205>\313 \210 \332\232\205>\340\332!0\207\210\310:\341 \207" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-regexp-function isearch-case-fold-search (quit) current-window-configuration nil t (exit) isearch-done make-byte-code 0 "\310
\311\310%\210\300\242\301\242 \302\305\303\304\312!\210\206: \313\310\314\"\210\307\242\205U \306\242`=\205U =\205U \307\242b\207" vconcat vector [nil isearch-mode isearch-update-from-string-properties isearch-message t isearch-suspended isearch-forward isearch-regexp isearch-op-fun isearch-regexp-function isearch-string isearch-new-forward isearch-new-nonincremental isearch-nonincremental isearch-new-regexp-function isearch-case-fold-search multi-isearch-current-buffer multi-isearch-file-list multi-isearch-buffer-list isearch-message-function] 6 read-char-by-name "Add character to search (Unicode name or hex): " 1 make-string char-to-string mapconcat isearch-text-char-description "" isearch-ring-adjust1 isearch-search isearch--get-state 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 multi-isearch-file-list multi-isearch-buffer-list multi-isearch-next-buffer-current-function multi-isearch-current-buffer isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-window-configuration multi-isearch-next-buffer-function isearch-new-regexp-function isearch-new-forward isearch-new-nonincremental isearch-suspended isearch-other-end regexp-search-ring search-ring] 42 (#$ . 111430) "p"])
(defalias 'isearch-search-and-update #[0 "\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])
#@65 Return t if STR ends in an odd number of backslashes.
(fn STR)
(defalias 'isearch-backslash #[257 "\300G\301\302\"Z\303\"\304U\207" [mod string-match "\\\\*\\'" 2 1] 6 (#$ . 114940)])
#@571 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.
(fn WANT-BACKSLASH &optional ALLOW-INVALID TO-BARRIER)
(defalias 'isearch-fallback #[769 "\205\342 \306 !??=\205\342 \n\2030 A@\307!\f>\204$ \310\311\312D\"\210\211\313H\262\2030 \205\342 \211\203<
b\210\314\211\207 \211A@\203\250 \307!\f>\204T \310\311\312D\"\210\211\313H\204\232 \307!\f>\204i \310\311\312D\"\210\211\315H\211GSH\306\307@!\f>\204\204 \310\311\312@D\"\210@\315H!\203\222 \211\316=\202\225 \211\317>\266\202\203\250 \262A\262@\262\202A \205\340 @\203\311 \307@!\f>\204\302 \310\311\312@D\"\210@\320H\206\312
\203\325 \211
]\202\330 \211
^b\210\314\211\262\266\203\207" [isearch-regexp isearch-string isearch-error isearch-cmds cl-struct-isearch--state-tags isearch-barrier isearch-backslash type-of signal wrong-type-argument isearch--state 8 t 1 125 (42 63 43) 6 isearch-adjusted isearch-forward] 13 (#$ . 115134)])
(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\302\330\303\304#\210\302\331\303\304#\210\302\332\303\304#\210\302\333\303\304#\210\302\334\303\304#\210\302\335\303\304#\210\336\337\340\341\342DD\343\344\345\346\347&\210\336\350\340\341\351DD\352\353\354\344\355\346\347& \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 enlarge-window-horizontally shrink-window-horizontally shrink-window mouse-drag-mode-line mouse-drag-vertical-line split-window-vertically split-window-horizontally universal-argument universal-argument-more negative-argument digit-argument custom-declare-variable isearch-allow-scroll funcall function #[0 "\300\207" [nil] 1] "Whether scrolling is allowed during incremental search.\nIf non-nil, scrolling commands can be used in Isearch mode.\nHowever, you cannot scroll far enough that the current match is\nno longer visible (is off screen). But if the value is `unlimited'\nthat limitation is removed and you can scroll any distance off screen.\nIf nil, scrolling commands exit Isearch mode." :type (choice (const :tag "Scrolling exits Isearch" nil) (const :tag "Scrolling with current match on screen" t) (const :tag "Scrolling with current match off screen" unlimited)) :group isearch isearch-allow-prefix #[0 "\300\207" [t] 1] "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" boolean] 10)
#@299 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.
(fn ISEARCH-POINT)
(defalias 'isearch-string-out-of-window #[257 "\302 \303\304\305\"\212\306 r\307\310\311\312\313!\314\"\315$\216\316\317!\210`*\262)\212\306 r\307\310\311\312\313!\320\"\315$\216\316\321!\210`*\262)\304\211\203M \262 \206H \262\202Y \262 \206W \262Y\203f \211X\204\207 \203x Y\203\213 W\202\204 Y\203\213 W\203\213 \304\202\236 W\203\235 W\203\235 \322\202\236 \323\207" [isearch-forward isearch-other-end window-group-start window-group-end nil t internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 move-to-window-group-line 1 [internal--after-save-selected-window] -1 above below] 11 (#$ . 118739)])
#@237 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.
(fn ABOVE ISEARCH-POINT)
(defalias 'isearch-back-into-window #[514 "\302\211\203 \262 \206 \262\202 \262 \206 \262\203; b\210\303\304!\210\305\302\306\"Y\203P b\210\303\307!\210\202P \211b\210\303\307!\210\310 W\203P b\210\303\304!\210\266\211b\207" [isearch-forward isearch-other-end nil recenter-window-group 0 window-group-end t -1 window-group-start] 8 (#$ . 119762)])
(defvar isearch-pre-scroll-point nil)
(defvar isearch-pre-move-point nil)
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \207" [custom-declare-variable isearch-yank-on-move funcall function #[0 "\300\207" [nil] 1] "Motion keys yank text to the search string while you move the cursor.\nIf `shift', extend the search string by motion commands while holding down\nthe shift key. The search string is extended by yanking text that\nends at the new position after moving point in the current buffer.\nIf t, extend the search string without the shift key pressed.\nTo enable motion commands, put the `isearch-move' property on their\nsymbols to `enabled', or to disable an automatically detected\nshift-translated command, use the property value `disabled'." :type (choice (const :tag "Motion keys exit Isearch" nil) (const :tag "Motion keys extend the search string" t) (const :tag "Shifted motion keys extend the search string" shift)) :group isearch :version "27.1"] 10)
#@500 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 t)
before the command is executed globally with terminated Isearch.
See more for options in `search-exit-option'.
(defalias 'isearch-pre-command-hook #[0 "\306 \211\307H =?\206\310\311\n\312#!\206\310\311\313\314\315\312 FD\"!\206\f
>\206'\316=\2038 \317\211\202(\203C \f\320>\204] )\203q \f9\203q \f\321N\322=\204] \f\323N\322=\203q )\205)\324=?\205`\211*\202\211\242\325=\203\215 \326\327!\211@\262!\203\215 \330 \210\317\211\202+\203\342 \f9\203\342 \f\331N\332=\204\342 \f\331N\333=\204\330 +\322=\203\314 \334\f!A@;\203\314 \335\334\f!A@\312\322 ,\336#)\266\203\204\330 +\337=\203\342 -\203\342 \312-`\211.\202'\340=\203\375 \312\341\342\">\204\367 \343\211\"\210\344\211\202'\205\345 \210\346 \207" [overriding-terminal-local-map isearch--saved-overriding-local-map isearch-mode-map isearch-tool-bar-map this-command isearch-menu-bar-commands this-single-command-keys 0 commandp lookup-key nil keymap tool-bar menu-item edit isearch-edit-string (universal-argument universal-argument-more digit-argument negative-argument) isearch-scroll t scroll-command unlimited down-mouse-1 window-minibuffer-p event-start read-event isearch-move disabled enabled interactive-form "^\\^" string-match shift append mapcar #[257 "\300!\207" [characterp] 3 "\n\n(fn K)"] isearch-process-search-string ignore isearch-done isearch-clean-overlays search-exit-option isearch-allow-prefix isearch-allow-scroll isearch-pre-scroll-point isearch-yank-on-move inhibit-changing-match-data this-command-keys-shift-translated isearch-pre-move-point] 9 (#$ . 121360)])
(defalias 'isearch-post-command-hook #[0 "\203 \306!\211\203 \307\310=\"\210\202 b\210\210\311\312 \210 \313=\203+ \n\203+ \314 \210 \203j `=\204h \315\f\206;
`\"\203G \316!\262\211\317\320\321#\322\f\206Y
`X\211\203d b\210\323 \266\311\324 \207" [isearch-pre-scroll-point isearch-allow-scroll isearch-lazy-highlight isearch-pre-move-point isearch-other-end isearch-opoint isearch-string-out-of-window isearch-back-into-window above nil isearch-update unlimited isearch-lazy-highlight-new-loop buffer-substring-no-properties regexp-quote mapconcat isearch-text-char-description "" t isearch-search-and-update force-mode-line-update isearch-regexp isearch-string isearch-message isearch-yank-flag isearch-forward] 6])
#@122 Quote special characters for incremental search.
With argument, add COUNT copies of the character.
(fn &optional COUNT)
(defalias 'isearch-quote-char #[256 "\303\304\305!!\306!\204 \307\310\311\312!!\"\210\2038 \2038 \211\313U\2038 \314\n\211G\"\2031 \315\316\317\"\202< \320\"\202< \320\"\207" [isearch-regexp isearch-regexp-lax-whitespace isearch-string 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] 7 (#$ . 124095) "p"])
#@143 Add this ordinary printing CHAR to the search string and search.
With argument, add COUNT copies of the character.
(fn &optional CHAR COUNT)
(defalias 'isearch-printing-char #[512 "\206 \211\302U\203 \303\262 \203 \304\"\202 \305\"\207" [last-command-event current-input-method 33554464 32 isearch-process-search-multibyte-characters isearch-process-search-char] 6 (#$ . 124692) (byte-code "\302 !D\207" [last-command-event current-prefix-arg prefix-numeric-value] 3)])
#@103 Add CHAR to the search string, COUNT times.
Search is updated accordingly.
(fn CHAR &optional COUNT)
(defalias 'isearch-process-search-char #[513 "\300\267\202 \301\302!\210\202 \301\303\211\"\210\202 \301\303\302\303#\210\211\250\203- \211\304V\203- \305\"\2020 \306!\307Y\203: \211\202? \310\311\312#\313\"\207" [#s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (42 6 63 6 125 13 124 21)) isearch-fallback nil t 1 make-string char-to-string 128 mapconcat isearch-text-char-description "" isearch-process-search-string] 7 (#$ . 125182)])
#@23
(fn STRING MESSAGE)
(defalias 'isearch-process-search-string #[514 "P P\302 \207" [isearch-string isearch-message isearch-search-and-update] 4 (#$ . 125775)])
#@16
(fn ADVANCE)
(defalias 'isearch-ring-adjust1 #[257 "\203 \202 \n\211G\203 \305\202 \306\307!\310U?\205M \311\206. \203- \310\202. \312\2037 \312\2028 \313\\\"\211\262L\210\2118\314\315 \316#\317 !\207" [isearch-regexp regexp-search-ring search-ring isearch-string isearch-message regexp-search-ring-yank-pointer search-ring-yank-pointer eval 0 mod -1 1 mapconcat isearch-text-char-description "" isearch-update-from-string-properties] 9 (#$ . 125947)])
#@16
(fn ADVANCE)
(defalias 'isearch-ring-adjust #[257 "\302!\210\203 \206
\303\304\305\"\210\306 \210\307 \210\310 \207\311 \207" [search-ring-update isearch-message-function isearch-ring-adjust1 isearch-message nil t isearch-search isearch-push-state isearch-update isearch-edit-string] 4 (#$ . 126428)])
#@48 Advance to the next search string in the ring.
(defalias 'isearch-ring-advance #[0 "\300\301!\207" [isearch-ring-adjust advance] 2 (#$ . 126743) nil])
#@52 Retreat to the previous search string in the ring.
(defalias 'isearch-ring-retreat #[0 "\300\301!\207" [isearch-ring-adjust nil] 2 (#$ . 126900) nil])
(defalias 'isearch-complete1 #[0 "\203 \202 \n \306
\"\211\307=\203 \307\202z \211\204$
G\310U\203u \211
\232\203k \203g r\311\312!q\210p\313 \210\314\211\307\211\307 \315 \210\316\317!\210+\211 \320\321
\"!\210\322!\210)\266\307\202z \211\205z \211\211\202z \323\324!\210\314)\207" [isearch-regexp regexp-search-ring search-ring case-fold-search completion-ignore-case isearch-string 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" completion-auto-help default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only standard-output] 9])
#@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 #[0 "\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 (#$ . 127862) nil])
#@54 Same as `isearch-complete' except in the minibuffer.
(defalias 'isearch-complete-edit #[0 "\301 \302 \205
\303 \210c\207" [isearch-string field-string isearch-complete1 delete-field] 1 (#$ . 128309) nil])
#@36
(fn &optional C-Q-HACK ELLIPSIS)
(defalias 'isearch-message #[512 "\211\304\305!\211\203( \306!\262\307G\310$\210\311\312\"\203( \307\313\224\313\225\314$\210\315\n\"\316!Q\262\203< \202C \317\320\321\"))\207" [isearch-message cursor-in-echo-area isearch-nonincremental message-log-max 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"] 10 (#$ . 128523)])
#@173 Make a string for describing REGEXP-FUNCTION.
If SPACE-BEFORE is non-nil, put a space before, instead of after,
the word mode.
(fn REGEXP-FUNCTION &optional SPACE-BEFORE)
(defalias 'isearch--describe-regexp-mode #[513 "\303=\203 \304\262\203 \232\204 \303=\203/ =\203/ \n\204+ \204/ \204/ \305\202U \203B 9\205U \306N\206U \305\202U \203J \307\202U \310!\203T \311\202U \305\203a \312\313\314#\202b \211\207" [search-default-mode isearch-regexp isearch-success t word-search-regexp "" isearch-message-prefix "regexp " functionp "literal " replace-regexp-in-string "\\(.*\\) \\'" " \\1"] 7 (#$ . 129041)])
(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)
#@42
(fn &optional ELLIPSIS NONINCREMENTAL)
(defalias 'isearch-message-prefix #[512 "\203 \203 \3061 \307 `\310#\210\311\2110\202 \210\202 \210\n\204% \311\262\n\203- \312\202. \313 \2036 \314\2027 \312\f\205T
?\205T )\203L `*V\202P `*W\205T \315\f\205Y \316\n?\205e +?\205e \317\312C\320\321\322\323\324\325!\326\"\327\330%,\"\210\211\242\262\331-!.\203\212 \332\202\224 /\203\223 \333\202\224 \3120\206\232 \312 \203\243 \334\202\244 \335)\203\255 \312\202\256 \3361\203\275 \337\3402\341Q!\202\276 \342\260\f\343\344\345 \346\347\350#\226\346\350\"Q3#\207" [isearch-error isearch-string isearch-success isearch-adjusted isearch-wrapped isearch-wrap-function (error) re-search-forward t nil "" "failing " "pending " "over" "wrapped " "case-sensitive " advice-function-mapc make-byte-code 514 "\301\236A\211\205 \300\300\242P\240\207" vconcat vector [isearch-message-prefix] 6 "\n\n(fn _ PROPS)" isearch--describe-regexp-mode "multi-file " "multi-buffer " "search" "I-search" " backward" bidi-string-mark-left-to-right " [" "]: " ": " apply propertize isearch-lazy-count-format substring 0 1 isearch-forward isearch-opoint isearch-case-fold-search isearch-filter-predicate isearch-regexp-function multi-isearch-file-list multi-isearch-buffer-list isearch-message-prefix-add current-input-method current-input-method-title isearch-message-properties] 17 (#$ . 129826)])
#@27
(fn &optional C-Q-HACK)
(defalias 'isearch-message-suffix #[256 "\303\304\203\n \305\202 \306\307\310!\203 \311\312Q\202 \306 \206 \306R\n#\207" [isearch-error isearch-message-suffix-add isearch-message-properties apply propertize "^Q" "" isearch-lazy-count-format suffix " [" "]"] 8 (#$ . 131231)])
#@224 Format the current match number and the total number of matches.
When SUFFIX-P is non-nil, the returned string is indended for
isearch-message-suffix prompt. Otherwise, for isearch-message-prefix.
(fn &optional SUFFIX-P)
(defalias 'isearch-lazy-count-format #[256 "\211\203 \202 \211\203B \n\203B \203B \f\204B
\204B \306\f\203( \2028 \307=\2032 \307\2028 \310
\311#
\206> \312#\202C \313\207" [lazy-count-suffix-format lazy-count-prefix-format isearch-lazy-count isearch-lazy-count-current isearch-error isearch-suspended format 0 - -1 "?" "" isearch-forward isearch-lazy-count-total] 8 (#$ . 131547)])
#@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 (#$ . 132173))
#@112 Return the function to use for the search.
Can be changed via `isearch-search-fun-function' for special needs.
(defalias 'isearch-search-fun #[0 "\206 \301 \207" [isearch-search-fun-function isearch-search-fun-default] 1 (#$ . 132727)])
#@53 Non-nil if next regexp-function call should be lax.
(defalias 'isearch--lax-regexp-function-p #[0 "\302>\206 \207" [this-command isearch-yank-flag (isearch-printing-char isearch-del-char)] 2 (#$ . 132972)])
#@49 Return default functions to use for the search.
(defalias 'isearch-search-fun-default #[0 "\300\207" [#[1025 "\203' ?\205 \306 \211\203 \307\310!\203 \"\202\" \311\"\262\2022 \n\203/ \2022 \312!\n\203: \202; \f\205?
\203J \313\202K \314$)\207" [isearch-regexp-function isearch-adjusted isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace search-whitespace-regexp isearch--lax-regexp-function-p t functionp word-search-regexp regexp-quote re-search-forward re-search-backward search-spaces-regexp isearch-forward] 10 "\n\n(fn STRING &optional BOUND NOERROR COUNT)"]] 1 (#$ . 133188)])
#@535 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.
(fn STRING BOUND NOERROR)
(defalias 'isearch-search-string #[771 "\305 \212\211#)\306\307!\203y \310!\203y \311\306\312\313#)\266\203\203y \314\315\316\317 \"\"\306\203w \320 \321\322\323\324\325!\326\"\327$\216\212 #\211\262\203V \320\312!\262*\210\203w \203p \n\203j W\202m V\203w \262\330!\210\266\205\217 \203\213 \331\f!\203\213 \332\f!\210b\210\207" [translation-table-for-input inhibit-changing-match-data isearch-forward multi-isearch-next-buffer-current-function multi-isearch-current-buffer isearch-search-fun nil char-table-p multibyte-string-p "[^[:ascii:]]" t string-match apply string mapcar #[257 "H\206 \211\207" [translation-table-for-input] 3 "\n\n(fn C)"] match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 set-match-data buffer-live-p switch-to-buffer] 15 (#$ . 133820)])
(defalias 'isearch-search #[0 "\306=\203 \203 \307\n \"\3101\343 \3111\324 \3121\222 \3131\202 \f\314\f\306 # $ %\314&\211\203a \315\n\314\306#\211'\203[ o\204[ m\204[ \316\224\316\225U\204[ (\316\224\316\225\"\2032 \314\262\2022 \314)'\205x *\203s \316\224\202u \316\225\211+,\266\2050000\202\354 000\317\320!\210\314\211'\262\202\354 00\211A@&\321\322&\"\203\250 \323\211&\202\317 ?\205\317 \321\324&\"\205\317 ,\203\301 \325\211&\202\317 -\205\317 .\205\317 \326\211&\262\202\354 0\314'\3278\211&\262\202\354 \330\331\"\211&\262\210'?\205h\332/@!0>\204\333\334\335/@D\"\210/@\336H\203\337 \210\340\332/@!0>\204'\333\334\335/@D\"\210/@\341H!\203N\332/@!0>\204D\333\334\335/@D\"\210/@\341H/@!\210\332/@!0>\204b\333\334\335/@D\"\210/@\342Hb\207" [isearch-case-fold-search search-upper-case isearch-string isearch-regexp isearch-invisible search-invisible t isearch-no-upper-case-p (error) (search-failed) (invalid-regexp) (quit) nil isearch-search-string 0 isearch-unread 7 string-match "\\`Premature \\|\\`Unmatched " "incomplete input" "\\`Regular expression too big" "Too many words" "Too many spaces for whitespace matching" 2 format "%s" type-of signal wrong-type-argument isearch--state 4 ding functionp 12 3 case-fold-search inhibit-quit inhibit-point-motion-hooks isearch-error isearch-success isearch-filter-predicate isearch-just-started isearch-forward isearch-other-end isearch-regexp-function isearch-lax-whitespace search-whitespace-regexp isearch-cmds cl-struct-isearch--state-tags] 10])
#@11
(fn OV)
(defalias 'isearch-open-overlay-temporary #[257 "\300\301\"\203 \300\301\"\302\"\207\303\304\300\305\"#\210\303\305\302#\207" [overlay-get isearch-open-invisible-temporary nil overlay-put isearch-invisible invisible] 7 (#$ . 136776)])
#@11
(fn OV)
(defalias 'isearch-open-necessary-overlays #[257 "`\300!V\205
`\301!X\302\303\"\204 \211\204) \304\305\302\306\"#\210\304\306\307#\210\2036 \302\310\"!\202> \211\205> \211\311\"\207" [overlay-start overlay-end overlay-get isearch-open-invisible-temporary overlay-put invisible isearch-invisible nil isearch-open-invisible t] 9 (#$ . 137034)])
(defalias 'isearch-clean-overlays #[0 "\205\f \301\302\"\210\303\211\207" [isearch-opened-overlays mapc isearch-open-necessary-overlays nil] 3])
#@92 Return t if regions START0..END0 and START1..END1 intersect.
(fn START0 END0 START1 END1)
(defalias 'isearch-intersects-p #[1028 "Y\203\f W\206- V\203 X\206- Y\203$ W\206- \211V\205- \211X\207" [] 6 (#$ . 137555)])
#@18
(fn BEGIN END)
(defalias 'isearch-close-unnecessary-overlays #[514 "\301\211\211\205E \211@\302\303!\304!$\203 \211B\202> \305\306\"\211\203. \211\307\"\210\202= \310\311\305\312\"#\210\310\312\301#\210\210A\266\202\202 \262\207" [isearch-opened-overlays nil isearch-intersects-p overlay-start overlay-end overlay-get isearch-open-invisible-temporary t overlay-put invisible isearch-invisible] 12 (#$ . 137792)])
#@70 Return t if all the text from BEG to END is invisible.
(fn BEG END)
(defalias 'isearch-range-invisible #[514 "U?\205\257 \212b\210\304=\305\203 \203 \306\"\210`W\203\214 \307`!\203\214 \307\310`\311\"!\203@ \312`\311\305$b\210\305\262\202 \203\204 \313`!\305\211\211\203w @\262\314\311\"\262\307!\203p \314\315\"\203m B\262\202p \305\262A\262\202J \203\202 \316\"\262\266\317`!b\210\202 `Y\205\254 \203\251 \211:\203\251 \316\n\"\320\321\"\210\305\202\254 \322\211\266\202)\207" [search-invisible isearch-hide-immediately isearch-opened-overlays isearch-hidden 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] 11 (#$ . 138230)])
#@467 Return non-nil if text between BEG and END is deemed visible by Isearch.
This function is intended to be used as `isearch-filter-predicate'.
It returns non-nil if the text between BEG and END is visible to
Isearch, at least partially, as determined by `isearch-range-invisible'.
If `search-invisible' is t, which allows Isearch matches inside
invisible text, this function will always return non-nil, regardless
of what `isearch-range-invisible' says.
(fn BEG END)
(defalias 'isearch-filter-visible #[514 "\301=\206 \302\"?\207" [search-invisible t isearch-range-invisible] 5 (#$ . 139085)])
#@200 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.
(fn STRING REGEXP-FLAG)
(defalias 'isearch-no-upper-case-p #[514 "\300\301G\300\211\204< W\203< H\203# \211\302=\203# ?\262\2024 \2041 \211\227=\2041 \303\262\300\262\210T\262\202 \211\206g \205g \304\305\"\205g \3061` \304\307\301\211\224#\310\"\210\3000\202g \211A@\311\232\262?\207" [nil 0 92 t string-match "\\[:\\(upp\\|low\\)er:]" (invalid-regexp) substring "" "Unmatched [ or [^"] 11 (#$ . 139689)])
#@10
(fn C)
(defalias 'isearch-text-char-description #[257 "\211\300W\203 \301\302!\303\301\304\305\306\\\"\307\310##\207\211\311U\203* \301\302!\303\301\312\307\310##\207\302!\207" [32 propertize char-to-string display format "^%c" 64 face escape-glyph 127 "^?"] 9 (#$ . 140298)])
#@29
(fn &rest CHAR-OR-EVENTS)
(defalias 'isearch-unread #[128 "\301\302\"\210\303\"\211\207" [unread-command-events mapc store-kbd-macro-event append] 4 (#$ . 140589)])
(defvar isearch-overlay nil)
#@16
(fn BEG END)
(defalias 'isearch-highlight #[514 "\205 \203 \303 p$\207\304\"\305 \306\307#\210\305 \310\n#\207" [search-highlight isearch-overlay isearch-face move-overlay make-overlay overlay-put priority 1001 face] 7 (#$ . 140795)])
(defalias 'isearch-dehighlight #[0 "\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-window-start-changed nil)
(defvar isearch-lazy-highlight-window-end-changed nil)
(defvar isearch-lazy-highlight-point-min nil)
(defvar isearch-lazy-highlight-point-max nil)
(defvar isearch-lazy-highlight-buffer 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)
(byte-code "\300\301\302\303#\210\304\211\203( \211@\301N\203! \302N\204! \305\302\301N#\210A\266\202\202 \210\306\301\302\307#\207" [defvaralias isearch-lazy-highlight-word isearch-lazy-highlight-regexp-function nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1"] 7)
(defvar isearch-lazy-highlight-regexp-function nil)
(defvar isearch-lazy-highlight-forward nil)
(defvar isearch-lazy-highlight-error nil)
(defvar isearch-lazy-count-current nil)
(defvar isearch-lazy-count-total nil)
(defvar isearch-lazy-count-hash (make-hash-table))
#@346 Stop lazy highlighting and remove extra highlighting from current buffer.
FORCE non-nil means do it whether or not `lazy-highlight-cleanup' is nil.
PROCRASTINATE non-nil means postpone cleanup to a later time.
This function is called when exiting an incremental search if
`lazy-highlight-cleanup' is non-nil.
(fn &optional FORCE PROCRASTINATE)
(defalias 'lazy-highlight-cleanup #[512 "\204 \203 \211\204 \203 \303 @!\210 A\211\204 \n\205' \304\n!\210\305\211\207" [lazy-highlight-cleanup isearch-lazy-highlight-overlays isearch-lazy-highlight-timer delete-overlay cancel-timer nil] 5 (#$ . 142700) '(t)])
#@321 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.
(fn &optional BEG END)
(defalias 'isearch-lazy-highlight-new-loop #[512 "\204?\306\307!\203? \n\232\203 \310 >\203 \f
=\203 =\203 =\203 =\203 =\203 =\203 \232\203 !\203Z e\"U?\202c \311 #U?\211$\204 !\203s d%U?\202| \312 &U?\211'\203?\313\314 \315\232?\"\210(\203\302 )\203\302 *\204\302 \315\232\204\264 $\204\246 '\203\264 e\"U\203\264 d%U\204\302 \316+!\210\317\211,-\320 \210\317\211$' .\211/\310 0\321 \311 #\312 &e\"d%!12\206\361 `2\206\371 `3\3174
\211 \203'\nGS\\d^\20213\nGSZe]3 \315\232\204?\3225\317\323#6(\205^)\205^*?\205^,\205^\324`+\307#,\320 \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 "" clrhash nil isearch-message selected-window-group run-with-idle-timer isearch-lazy-highlight-start gethash 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-forward isearch-lazy-highlight-forward isearch-error isearch-lazy-highlight-error lazy-highlight-buffer isearch-lazy-highlight-point-min isearch-lazy-highlight-window-start isearch-lazy-highlight-window-start-changed isearch-lazy-highlight-point-max isearch-lazy-highlight-window-end isearch-lazy-highlight-window-end-changed isearch-lazy-count isearch-mode isearch-message-function isearch-lazy-count-hash isearch-lazy-count-current isearch-lazy-count-total isearch-lazy-highlight-start-limit isearch-lazy-highlight-end-limit isearch-lazy-highlight-window isearch-lazy-highlight-buffer isearch-other-end isearch-lazy-highlight-end isearch-lazy-highlight-wrapped lazy-highlight-initial-delay isearch-lazy-highlight-timer] 7 (#$ . 143323)])
#@156 Search ahead for the next or previous match, for lazy highlighting.
Attempt to do the search exactly the way the pending Isearch would.
(fn STRING BOUND)
(defalias 'isearch-lazy-highlight-search #[514 "\3061e \n \f
\205 \f\205 \307\307\310 \f
\203_ \311 \307#\262\211\203Y `\nU\204Y \312\224\312\225U\204Y \312\224\312\225\"\203/ \310\262\202/ .\266\2100\207\210\310\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) t nil isearch-search-string 0 isearch-lazy-count search-invisible isearch-forward isearch-regexp-lax-whitespace isearch-lax-whitespace isearch-regexp-function isearch-regexp case-fold-search isearch-filter-predicate] 15 (#$ . 145675)])
#@14
(fn MB ME)
(defalias 'isearch-lazy-highlight-match #[514 "\303\"\211B\304\305\306#\210\304\307\310#\210 \311=\206 \n?\205% \304\312\313 #\207" [isearch-lazy-highlight-overlays isearch-lazy-highlight isearch-lazy-highlight-buffer make-overlay overlay-put priority 1000 face lazy-highlight all-windows window selected-window] 7 (#$ . 146560)])
#@43 Start a new lazy-highlight updating loop.
(defalias 'isearch-lazy-highlight-start #[0 "\300\301!\210\302 \207" [lazy-highlight-cleanup t isearch-lazy-highlight-update] 2 (#$ . 146918)])
#@58 Update highlighting of other matches for current search.
(defalias 'isearch-lazy-highlight-update #[0 "\306\307\211\211\3101n\307\311 r\312\313\314\315\316!\317\"\320$\216\321\n!\203+ \322 >\204+ \323\n!\210\324 \262\325 \262\212\326 \312\313\327\315\316!\330\"\331$\216\f\203J
\202L #b\210\203.\f\203k $\206\\ d%\203f #\202g ^\202| &\206q e%\203z
\202{ ]\332'\"\203\225 S\262 \313X\203\225 \307\262\211\203\363 \313\224\313\225U\203\340 \f\203\304 %\203\262 #\202\264 U\203\276 \307\262\202\345 \333u\210\202\345 %\203\316
\202\320 U\203\332 \307\262\202\345 \334u\210\202\345 \335\"\210\f\203\356 `\202\361 `#\266\211\204)%\203\307\262\306\262\202)\306%\f\203 &\206e]b\210\202)#$\206%d^b\210\266\202N \203Z(\204B)\205c*?\205c\f\203Ke\202Nd#\336+\307\337#\211,\202c\336+\307\340#\211,)\262+\262)0\202u\210\306-\341\342!\207" [lazy-highlight-max-at-a-time inhibit-quit isearch-lazy-highlight-window isearch-lazy-highlight-window-group isearch-lazy-highlight-forward isearch-lazy-highlight-end t nil (quit) internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 window-live-p selected-window select-window window-group-start window-group-end match-data "\301\300\302\"\207" [set-match-data evaporate] 3 isearch-lazy-highlight-search 1 -1 isearch-lazy-highlight-match run-at-time isearch-lazy-highlight-buffer-update isearch-lazy-highlight-update eval (ignore nil) isearch-lazy-highlight-start isearch-lazy-highlight-end-limit isearch-lazy-highlight-wrapped isearch-lazy-highlight-start-limit isearch-lazy-highlight-last-string isearch-lazy-highlight-buffer isearch-lazy-count isearch-lazy-count-current lazy-highlight-interval isearch-lazy-highlight-timer quit-flag] 14 (#$ . 147110)])
#@58 Update highlighting of other matches in the full buffer.
(defalias 'isearch-lazy-highlight-buffer-update #[0 "\306\307\211\211`\3101F\307\311 r\312\313\314\315\316!\317\"\320$\216\321\n!\203, \322 >\204, \323\n!\210\324 \262\325 \262\212\326 \312\313\327\315\316!\330\"\331$\216\f\203K
\202M %b\210\203 \f\203a &\206g d\202g '\206g e\332(\" \203\200 S\262\n \313X\203\200 \307\262 \211\203\372 \313\224\313\225U\203\266 \f\203\244 dU\203\236 \307\262\202\354 \333u\210\202\354 eU\203\260 \307\262\202\354 \334u\210\202\354 )\203\324 *\206\301 \313T*\335\f\203\315 \202\316 *+#\210,\203\354 Y\203\347 \211X\204\354 \336\"\210\f\203\365 `\202\370 `%\266\211\204\307\262 \306\262\266\202O \2032)\205;-\205;.?\205;*\204%\313*\337+\313#/\340 \202;\3410\307\342#\2111)\262+\262)0\202M\210\3062\343\344!\207" [lazy-highlight-buffer-max-at-a-time inhibit-quit isearch-lazy-highlight-window isearch-lazy-highlight-window-group isearch-lazy-highlight-forward isearch-lazy-highlight-end t nil (quit) internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 window-live-p selected-window select-window window-group-start window-group-end match-data "\301\300\302\"\207" [set-match-data evaporate] 3 isearch-lazy-highlight-search 1 -1 puthash isearch-lazy-highlight-match gethash isearch-message run-at-time isearch-lazy-highlight-buffer-update eval (ignore nil) isearch-lazy-highlight-start isearch-lazy-highlight-end-limit isearch-lazy-highlight-start-limit isearch-lazy-highlight-last-string isearch-lazy-count isearch-lazy-count-total isearch-lazy-count-hash isearch-lazy-highlight-buffer isearch-mode isearch-message-function isearch-lazy-count-current lazy-highlight-interval isearch-lazy-highlight-timer quit-flag] 16 (#$ . 148965)])
#@399 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.
(fn STRING REGEXP WORD FORWARD MESSAGE CASE-FOLD)
(defalias 'isearch-resume #[1542 "\303\304\211%\210\211\305 \210\306 \207" [isearch-string isearch-message isearch-case-fold-search isearch-mode nil isearch-search isearch-update] 12 (#$ . 150840)])
(provide 'isearch)
Mini Shell