| Current Path : /usr/share/emacs/24.3/lisp/ |
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 |
| Current File : //usr/share/emacs/24.3/lisp/isearch.elc |
;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:12:50 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/isearch.el
;;; in Emacs version 24.3
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301\302\303\304\305\304\306\307\310\307\311\312\313&
\210\314\315\316\317\320\321\312\301&\210\314\322\323\324\320\325\312\301&\210\314\326\327\330\320\325\312\301&\210\314\331\332\333\320\334\312\301&\210\314\335\316\336\320\321\312\301&\210\314\337\340\341\320\342\312\301\343\344& \210\314\345\346\347\320\350\312\301&\210\314\351\316\352\320\321\312\301&\210\314\353\302\354\320\321\312\301&\207" [custom-declare-group isearch nil "Incremental search minor mode." :link (emacs-commentary-link "isearch") (custom-manual "(emacs)Incremental Search") :prefix "isearch-" "search-" :group matching custom-declare-variable search-exit-option t "Non-nil means random control characters terminate incremental search." :type boolean search-slow-window-lines 1 "Number of lines in slow search display windows.\nThese are the short windows used during incremental search on slow terminals.\nNegative means put the slow search window at the top (normally it's at bottom)\nand the value is minus the number of lines." integer search-slow-speed 1200 "Highest terminal speed at which to use \"slow\" style incremental search.\nThis is the style where a one-line window is created to show the line\nthat the search has reached." search-upper-case 'not-yanks "If non-nil, upper case chars disable case fold searching.\nThat is, upper and lower case chars must match exactly.\nThis applies no matter where the chars come from, but does not\napply to chars in regexps that are prefixed with `\\'.\nIf this value is `not-yanks', text yanked into the search string\nin Isearch mode is always downcased." (choice (const :tag "off" nil) (const not-yanks) (other :tag "on" t)) search-nonincremental-instead "If non-nil, do a nonincremental search instead of exiting immediately.\nActually, `isearch-edit-string' is called to let you enter the search\nstring, and RET terminates editing and does a nonincremental search." search-whitespace-regexp (purecopy "\\s-+") "If non-nil, regular expression to match a sequence of whitespace chars.\nWhen you enter a space or spaces in the incremental search, it\nwill match any sequence matched by this regexp. As an exception,\nspaces are treated normally in regexp incremental search if they\noccur in a regexp construct like [...] or *, + or ?.\n\nIf the value is a string, it applies to both ordinary and\nregexp incremental search. If the value is nil, or\n`isearch-lax-whitespace' is nil for ordinary incremental search, or\n`isearch-regexp-lax-whitespace' is nil for regexp incremental search,\nthen each space you type matches literally, against one space.\n\nYou might want to use something like \"[ \\t\\r\\n]+\" instead.\nIn the Customization buffer, that is `[' followed by a space,\na tab, a carriage return (control-M), a newline, and `]+'." (choice (const :tag "Match Spaces Literally" nil) regexp) :version "24.3" search-invisible 'open "If t incremental search can match hidden text.\nA nil value means don't match invisible text.\nWhen the value is `open', if the text matched is made invisible by\nan overlay having an `invisible' property and that overlay has a property\n`isearch-open-invisible', then incremental search will show the contents.\n(This applies when using `outline.el' and `hideshow.el'.)\nSee also `reveal-mode' if you want overlays to automatically be opened\nwhenever point is in one of them." (choice (const :tag "Match hidden text" t) (const :tag "Open overlays" open) (const :tag "Don't match hidden text" nil)) isearch-hide-immediately "If non-nil, re-hide an invisible match right away.\nThis variable makes a difference when `search-invisible' is set to `open'.\nIt means that after search makes some invisible text visible\nto show the match, it makes the text invisible again when the match moves.\nOrdinarily the text becomes invisible again at the end of the search." isearch-resume-in-command-history "If non-nil, `isearch-resume' commands are added to the command history.\nThis allows you to resume earlier Isearch sessions through the\ncommand history."] 14)
#@62 Function(s) to call after starting up an incremental search.
(defvar isearch-mode-hook nil (#$ . 4607))
#@68 Function(s) to call after isearch has found matches in the buffer.
(defvar isearch-update-post-hook nil (#$ . 4717))
#@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 (#$ . 4841))
#@77 Non-nil while running `isearch-mode-end-hook' if the user quits the search.
(defvar isearch-mode-end-hook-quit nil (#$ . 5058))
#@79 Function to call to display the search prompt.
If nil, use `isearch-message'.
(defvar isearch-message-function nil (#$ . 5192))
#@183 Function to call to wrap the search when search is failed.
If nil, move point to the beginning of the buffer for a forward search,
or to the end of the buffer for a backward search.
(defvar isearch-wrap-function nil (#$ . 5327))
#@99 Function to save a function restoring the mode-specific Isearch state
to the search status stack.
(defvar isearch-push-state-function nil (#$ . 5562))
#@306 Predicate that filters the search hits that would normally be available.
Search hits that dissatisfy the predicate are skipped. The function
has two arguments: the positions of start and end of text matched by
the search. If this function returns nil, continue searching without
stopping at this match.
(defvar isearch-filter-predicate 'isearch-filter-visible (#$ . 5720))
#@34 List of search string sequences.
(defvar search-ring nil (#$ . 6101))
#@53 List of regular expression search string sequences.
(defvar regexp-search-ring nil (#$ . 6177))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\302\311\304\305\306\307&\207" [custom-declare-variable search-ring-max 16 "Maximum length of search ring before oldest elements are thrown away." :type integer :group isearch regexp-search-ring-max "Maximum length of regexp search ring before oldest elements are thrown away."] 8)
#@70 Index in `search-ring' of last string reused.
It is nil if none yet.
(defvar search-ring-yank-pointer nil (#$ . 6620))
#@77 Index in `regexp-search-ring' of last string reused.
It is nil if none yet.
(defvar regexp-search-ring-yank-pointer nil (#$ . 6745))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\307&\210\313\307\314\315\306\307\306\316&\207" [custom-declare-variable search-ring-update nil "Non-nil if advancing or retreating in the search ring should cause search.\nDefault value, nil, means edit the string instead." :type boolean :group isearch search-highlight t "Non-nil means incremental search highlights the current match." custom-declare-face ((((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." basic-faces] 8)
(defvar isearch-face 'isearch)
(byte-code "\302\303\304\305\306\307\310\311&\210\312\313\314\315\316\317\310\320\310\311& \210\321\320\322\323\324\325\306\326\310\311\310\327& \210\330\331\332\322#\210\333\322\211\203S @\331N\203L \332N\204L \334\332\331N#\210 A\211\2045 *\335\331\332\336#\210\312\332\314\337\316\317\310\320&\210\330\340\341\322#\210\333\322\211\203\221 @\340N\203\212 \341N\204\212 \334\341\340N#\210 A\211\204s *\335\340\341\336#\210\312\341\342\343\316\344\310\320&\210\330\345\346\322#\210\333\322\211\203\317 @\345N\203\310 \346N\204\310 \334\346\345N#\210 A\211\204\261 *\335\345\346\336#\210\312\346\347\350\316\344\310\320&\210\330\351\352\322#\210\333\322\211\203
@\351N\203\352N\204\334\352\351N#\210 A\211\204\357 *\335\351\352\336#\210\312\352\353\354\316\355\310\320&\210\302\320\356\357\310\320\310\360&\210\334\361\362\320#\210\334\361\363\364\336!\206:\314#\210\330\361\365\322#\210\333\322\211\203h @\361N\203a\365N\204a\334\365\361N#\210 A\211\204J*\335\361\365\336#\207" [prop --dolist-tail-- custom-declare-face isearch-fail ((((class color) (min-colors 88) (background light)) (:background "RosyBrown1")) (((class color) (min-colors 88) (background dark)) (:background "red4")) (((class color) (min-colors 16)) (:background "red")) (((class color) (min-colors 8)) (:background "red")) (((class color grayscale)) :foreground "grey") (t (:inverse-video t))) "Face for highlighting failed part in Isearch echo-area message." :version "23.1" :group isearch custom-declare-variable isearch-lazy-highlight t "Controls the lazy-highlighting during incremental search.\nWhen non-nil, all text in the buffer matching the current search\nstring is highlighted lazily (see `lazy-highlight-initial-delay'\nand `lazy-highlight-interval')." :type boolean lazy-highlight custom-declare-group nil "Lazy highlighting feature for matching strings." :prefix "lazy-highlight-" "21.1" matching defvaralias isearch-lazy-highlight-cleanup lazy-highlight-cleanup (saved-value saved-variable-comment) put make-obsolete-variable "22.1" "Controls whether to remove extra highlighting after a search.\nIf this is nil, extra highlighting can be \"manually\" removed with\n\\[lazy-highlight-cleanup]." isearch-lazy-highlight-initial-delay lazy-highlight-initial-delay 0.25 "Seconds to wait before beginning to lazily highlight all matches." number isearch-lazy-highlight-interval lazy-highlight-interval 0 "Seconds between lazily highlighting successive matches." isearch-lazy-highlight-max-at-a-time lazy-highlight-max-at-a-time 20 "Maximum matches to highlight at a time (for `lazy-highlight').\nLarger values may reduce Isearch's responsiveness to user input;\nsmaller values make matches highlight slowly.\nA value of nil means highlight all matches." (choice (const :tag "All" nil) (integer :tag "Some")) ((((class color) (min-colors 88) (background light)) (:background "paleturquoise")) (((class color) (min-colors 88) (background dark)) (:background "paleturquoise4")) (((class color) (min-colors 16)) (:background "turquoise3")) (((class color) (min-colors 8)) (:background "turquoise3")) (t (:underline t))) "Face for lazy highlighting of matches other than the current one." basic-faces isearch-lazy-highlight-face face-alias obsolete-face purecopy lazy-highlight-face] 13)
(defvar lazy-highlight-face 'lazy-highlight)
#@64 Keymap for characters following the Help key for Isearch mode.
(defvar isearch-help-map (byte-code "\302 \303\304\305#\210\303\306 !\307#\210\303\310\307#\210\303\311\307#\210\303\312\307#\210\303\313\314#\210\303\315\316#\210\303\317\320#\210\303\321\322#\210)\207" [map help-char make-sparse-keymap define-key [t] isearch-other-control-char char-to-string isearch-help-for-help [help] [f1] "?" "b" isearch-describe-bindings "k" isearch-describe-key "m" isearch-describe-mode "q" help-quit] 4) (#$ . 11171))
#@481 You have typed %THIS-KEY%, the help character. Type a Help option:
(Type \<help-map>\[help-quit] to exit the Help command.)
b Display all Isearch key bindings.
k KEYS Display full documentation of Isearch key sequence.
m Display documentation of Isearch mode.
You can't type here other help keys available in the global help map,
but outside of this help window when you type them in Isearch mode,
they exit Isearch mode before displaying global help.
(defalias 'isearch-help-for-help-internal-doc #[nil "\300\207" [nil] 1 (#$ . 11698)])
#@15 Help command.
(defalias 'isearch-help-for-help-internal #[nil "\306\307\310!! \203 \311\312\"\210\313\314!\315 \f \316 ;\317\211 < =\317\211 > ?\320\321\n\"\203< \322\323\324 \325\326O!\327\211\n$\330\216\317 @\241\210\331 \332\333#\210\331 \334\335A\336\"#\210 \203| B\337\317!)>\335C>\"\203s \335C>\">>\325H?\202 \340??\340=\204\226 ?D=\204\226 ?E>\203$\341 <\342\343!\210\344\345!\203\267 \346\347 !;=\204\267 \346\347 !=\317<\317F\327 G\350 \210\nc\210)
\351 \210\f)eb\210?\352ED\353B\">\204\354 ?\242\354=\204\354 >\355\232\203$\317\356\357\217\210\327 B H\337\360\361\362d!\203\363\202\364\"!\211>\325H?*?\365=\203\317 \366\335 >\"\317>#\210\202\317 \311\363!\210?<\203<?IBI\317\211<\202x\335 >\"\211 J\203u<\203T\367<!\210\317<
\370J!\210)=\205w=\316 =\204n\371=!\210\317\211=\202w\372 ). \207" [line-prompt three-step-help help-screen local-map minor-mode-map-alist new-minor-mode-map-alist substitute-command-keys purecopy "Type a help option: [bkm] or ?" message "%s" documentation isearch-help-for-help-internal-doc make-sparse-keymap selected-frame nil string-match "%THIS-KEY%" replace-match key-description this-command-keys 0 -1 t ((byte-code "\203 \304!\210 \203 \305 !\210\n\304\207" [config new-frame new-minor-mode-map-alist minor-mode-map-alist set-window-configuration iconify-frame] 2)) define-key [t] undefined [vertical-scroll-bar] lookup-key [vertical-scroll-bar] read-key-sequence 63 current-window-configuration switch-to-buffer-other-window "*Help*" fboundp make-frame window-frame selected-window erase-buffer help-mode append (63 22 32 127 delete backspace vertical-scroll-bar 134217846) switch-frame "\366" (byte-code "\242\302=\203 \303!\210\202) \304>\203 \305 \210\202) \306>\204& \307\232\203) \310 \210\302\207" [char key switch-frame handle-switch-frame (22 32) scroll-up (127 134217846 delete backspace) "\366" scroll-down] 2) ((error)) format "Type one of the options listed%s: " pos-visible-in-window-p "" ", or SPACE or DEL to scroll" vertical-scroll-bar command-execute set-window-configuration call-interactively iconify-frame ding prev-frame config new-frame key char isearch-help-map global-map overriding-local-map function-key-map help-char help-event-list buffer-read-only inhibit-read-only cursor-in-echo-area unread-command-events defn] 7 (#$ . 12270) nil])
#@28 Display Isearch help menu.
(defalias 'isearch-help-for-help #[nil "\302\211\303 \210*\304 \207" [same-window-regexps same-window-buffer-names nil isearch-help-for-help-internal isearch-update] 2 (#$ . 14669) nil])
#@139 Show a list of all keys defined in Isearch mode, and their definitions.
This is like `describe-bindings', but displays only Isearch keys.
(defalias 'isearch-describe-bindings #[nil "\306\211\n\306\211\223\210\306\307\fB
r\310\311!q\210p\312 \210\306\211\313\211\313 \314 \210\315\316!\210+\211 r q\210\317\320!\210\317\321\322!!)\323!\210+\324 !\210,\207" [same-window-regexps same-window-buffer-names help-window-point-marker help-window temp-buffer-show-hook default-directory nil #[nil "\301 \211\207" [help-window selected-window] 2] get-buffer-create "*Help*" kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook princ "Isearch Mode Bindings:\n" substitute-command-keys "\\{isearch-mode-map}" internal-temp-output-buffer-show help-window-setup #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output] 4 (#$ . 14892) nil])
#@63 Display documentation of the function invoked by isearch key.
(defalias 'isearch-describe-key #[nil "\302\211\303\304!\210*\305 \207" [same-window-regexps same-window-buffer-names nil call-interactively describe-key isearch-update] 2 (#$ . 15848) nil])
#@40 Display documentation of Isearch mode.
(defalias 'isearch-describe-mode #[nil "\302\211\303\304!\210*\305 \207" [same-window-regexps same-window-buffer-names nil describe-function isearch-forward isearch-update] 2 (#$ . 16109) nil])
(defalias 'isearch-mode-help 'isearch-describe-mode)
#@28 Keymap for `isearch-mode'.
(defvar isearch-mode-map (byte-code "\306\307 \310A@!\204 \311\312!\210\313A@\314\315 B\316#\210\317\320\321#\210\322\211\314W\2039 \317\323 !\316#\210 T\211\202% \324 \317\325 !\n#\210\317\326\n#\210\317\n\327\330#\210)\317\331\332#\210\317\333\334#\210\317\335\332#\210\317\336\334#\210\317\337\340#\210\317\341\342#\210 \343U\204 \311\344!\210\317\345\346#\210\317\347\346#\210\317\350\351#\210\317\352\353#\210\317\354\316#\210\317\355\316#\210\317\356\316#\210\317\357\360#\210\317\361\362#\210\317\363\364#\210\317\365\366#\210\317\367\370#\210\317\325\f!
#\210\317\371
#\210\317\372
#\210\317\373\374#\210\317\375\376#\210\317\377\201@ #\210\317\201A \201B #\210\317\201C \201D #\210\317\201E \201D #\210\317\201F \201D #\210\317\201G \201D #\210\317\201H \201D #\210\317\201I \201D #\210\317\201J \201K #\210\317\201L \201M #\210\317\201N \201O #\210\317\201P \201D #\210\317\201Q \201R #\210\317\201S \201T #\210\317\201U \201V #\210\317\201W \201R #\210\317\201X \201T #\210\317\201Y \201Z #\210\317\201[ \201\\ #\210\317\201] \201^ #\210\317\201_ \201` #\210\317\201a \201b #\210\317\201c \201d #\210\317\201e \201f #\210\317\201g \201D #\210\317\201h \321#\210\317\201i \201D #\210\317\201j \321#\210*\207" [map i meta-map meta-prefix-char help-char isearch-help-map 0 make-keymap char-table-p error "The initialization of isearch-mode-map must be updated" set-char-table-range 256 max-char isearch-printing-char define-key [t] isearch-other-control-char 32 vector make-sparse-keymap char-to-string [escape] [t] isearch-other-meta-char "" isearch-repeat-forward "" isearch-repeat-backward "\223" "\222" "" isearch-delete-char "" isearch-abort 27 "Inconsistency in isearch.el" "" isearch-cancel [escape escape escape] "" isearch-quote-char "
" isearch-exit "\n" " " [33554464] "" isearch-yank-word-or-char "\227" isearch-del-char "\231" isearch-yank-char "" isearch-yank-kill "\363" isearch-yank-line [help] [f1] "\356" isearch-ring-advance "\360" isearch-ring-retreat "\371" isearch-yank-pop "\211" isearch-complete [switch-frame] nil [delete-frame] [iconify-frame] [make-frame-visible] [mouse-movement] [language-change] " " isearch-toggle-input-method " " isearch-toggle-specified-input-method [mouse-2] isearch-mouse-2 [down-mouse-2] "\343" isearch-toggle-case-fold "\362" isearch-toggle-regexp "\345" isearch-edit-string "\363c" "\363r" "\363w" isearch-toggle-word "\363_" isearch-toggle-symbol "\363 " isearch-toggle-lax-whitespace [134217765] isearch-query-replace [201326629] isearch-query-replace-regexp "\363o" isearch-occur "\363hr" isearch-highlight-regexp "" [24 t] "8" "8
"] 5) (#$ . 16403))
#@55 Keymap for editing Isearch strings in the minibuffer.
(defvar minibuffer-local-isearch-map (byte-code "\302 \303 \"\210\304\305\306#\210\304\307\310#\210\304\311\312#\210\304\313\314#\210\304\315\316#\210\304\317\316#\210)\207" [map minibuffer-local-map make-sparse-keymap set-keymap-parent define-key "
" isearch-nonincremental-exit-minibuffer "\211" isearch-complete-edit "" isearch-forward-exit-minibuffer "" isearch-reverse-exit-minibuffer "" isearch-yank-char-in-minibuffer [right]] 4) (#$ . 19132))
(defvar isearch-forward nil)
(defvar isearch-regexp nil)
#@386 Regexp-based search mode for words/symbols.
If t, do incremental search for a sequence of words, ignoring punctuation.
If the value is a function (e.g. `isearch-symbol-regexp'), it is called to
convert the search string to a regexp used by regexp search functions.
The property `isearch-message-prefix' put on this function specifies the
prefix string displayed in the search message.
(defvar isearch-word nil (#$ . 19713))
#@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 (#$ . 20144))
#@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 (#$ . 20598))
#@185 Stack of search status sets.
Each set is a vector of the form:
[STRING MESSAGE POINT SUCCESS FORWARD OTHER-END WORD
INVALID-REGEXP WRAPPED BARRIER WITHIN-BRACKETS CASE-FOLD-SEARCH]
(defvar isearch-cmds nil (#$ . 21059))
(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 (#$ . 21537))
(defvar isearch-just-started nil)
(defvar isearch-start-hscroll 0)
(defvar isearch-case-fold-search nil)
(defvar isearch-last-case-fold-search nil)
(defvar isearch-original-minibuffer-message-timeout nil)
(defvar isearch-adjusted nil)
(defvar isearch-slow-terminal-mode nil)
(defvar isearch-small-window nil)
(defvar isearch-opoint 0)
(defvar isearch-window-configuration nil)
(defvar isearch-yank-flag nil)
(defvar isearch-op-fun nil)
(defvar isearch-recursive-edit nil)
(defvar isearch-nonincremental nil)
(defvar isearch-new-forward nil)
(defvar isearch-opened-overlays nil)
(defvar isearch-hidden nil)
(defvar isearch-input-method-function nil)
(defvar isearch-input-method-local-p nil)
(byte-code "\301\236\204 \302C\244\210\301\207" [minor-mode-alist isearch-mode (isearch-mode isearch-mode)] 2)
(defvar isearch-mode 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#\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] 4)
#@3766 Do incremental search forward.
With a prefix argument, do an incremental regular expression search instead.
\<isearch-mode-map>
As you type characters, they add to the search string and are found.
The following non-printing keys are bound in `isearch-mode-map'.
Type \[isearch-delete-char] to cancel last input item from end of search string.
Type \[isearch-exit] to exit, leaving point at location found.
Type LFD (C-j) to match end of line.
Type \[isearch-repeat-forward] to search again forward, \[isearch-repeat-backward] to search again backward.
Type \[isearch-yank-word-or-char] to yank next word or character in buffer
onto the end of the search string, and search for it.
Type \[isearch-del-char] to delete character from end of search string.
Type \[isearch-yank-char] to yank char from buffer onto end of search string and search for it.
Type \[isearch-yank-line] to yank rest of line onto end of search string and search for it.
Type \[isearch-yank-kill] to yank the last string of killed text.
Type \[isearch-yank-pop] to replace string just yanked into search prompt
with string killed before it.
Type \[isearch-quote-char] to quote control character to search for it.
\[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-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-lax-whitespace] to toggle whitespace matching.
In incremental searches, a space or spaces normally matches any whitespace
defined by the variable `search-whitespace-regexp'; see also the variables
`isearch-lax-whitespace' and `isearch-regexp-lax-whitespace'.
Type \[isearch-edit-string] to edit the search string in the minibuffer.
Also supported is a search ring of the previous 16 search strings.
Type \[isearch-ring-advance] to search for the next item in the search ring.
Type \[isearch-ring-retreat] to search for the previous item in the search ring.
Type \[isearch-complete] to complete the search string using the search ring.
Type \[isearch-query-replace] to run `query-replace' with string to replace from last search string.
Type \[isearch-query-replace-regexp] to run `query-replace-regexp' with the last search string.
Type \[isearch-occur] to run `occur' that shows the last search string.
Type \[isearch-highlight-regexp] to run `highlight-regexp' that highlights the last search string.
Type \[isearch-describe-bindings] to display all Isearch key bindings.
Type \[isearch-describe-key] to display documentation of Isearch key.
Type \[isearch-describe-mode] to display documentation of Isearch mode.
If an input method is turned on in the current buffer, that input
method is also active while you are typing characters to search.
To toggle the input method, type \[isearch-toggle-input-method]. It also toggles the input
method in the current buffer.
To use a different input method for searching, type \[isearch-toggle-specified-input-method],
and specify an input method you want to use.
The above keys, bound in `isearch-mode-map', are often controlled by
options; do \[apropos] on search-.* to find them.
Other control and meta characters terminate the search
and are then executed normally (depending on `search-exit-option').
Likewise for function keys and mouse button events.
If this function is called non-interactively, it does not return to
the calling function until the search is done.
(defalias 'isearch-forward #[(&optional regexp-p no-recursive-edit) "\302\303??\304 ?$\207" [regexp-p no-recursive-edit isearch-mode t nil] 5 (#$ . 22834) "P\np"])
#@511 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'.
(defalias 'isearch-forward-regexp #[(&optional not-regexp no-recursive-edit) "\302\303?\304 ?$\207" [not-regexp no-recursive-edit isearch-mode t nil] 5 (#$ . 26771) "P\np"])
#@309 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.
(defalias 'isearch-forward-word #[(&optional not-word no-recursive-edit) "\302\303\304\211? ?%\207" [no-recursive-edit not-word isearch-mode t nil] 6 (#$ . 27463) "P\np"])
#@275 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.
(defalias 'isearch-forward-symbol #[(&optional not-symbol no-recursive-edit) "\301\302\303\211?\304%\207" [no-recursive-edit isearch-mode t nil isearch-symbol-regexp] 6 (#$ . 27951) "P\np"])
#@153 Do incremental search backward.
With a prefix argument, do a regular expression search instead.
See the command `isearch-forward' for more information.
(defalias 'isearch-backward #[(&optional regexp-p no-recursive-edit) "\302\303??\303 ?$\207" [regexp-p no-recursive-edit isearch-mode nil] 5 (#$ . 28424) "P\np"])
#@253 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' for more information.
(defalias 'isearch-backward-regexp #[(&optional not-regexp no-recursive-edit) "\302\303?\303 ?$\207" [not-regexp no-recursive-edit isearch-mode nil] 5 (#$ . 28747) "P\np"])
#@103 Start Isearch minor mode.
It is called by the function `isearch-forward' and other related functions.
(defalias 'isearch-mode #[(forward &optional regexp op-fun recursive-edit word) "\n\f$%&'(&\306\211)*\307+\310,\307-`.\307\211/0\307123X\205> \311 \3124!\313_V5\307\21167\3108\314 9`:\307\211;<=\315\316!>\307?@A\307@>\204r \317\316!\210\307\320\306!\2105\205\200 \321 B\322\323 ! C\324C!\325>\204\247 \326C!\204\235 \327C!\210D\203\247 \330C!\210)\331E\332 \210FG\333\334!\210\335 \210\336 \210\337\340\341\"\210\337\342\341\"\210#\203\322 \310 H\343 \210),\207" [forward isearch-forward regexp isearch-regexp word isearch-word "" nil t window-height abs 4 window-hscroll local-variable-p input-method-function make-local-variable looking-at current-window-configuration window-frame minibuffer-window frame-live-p (nil t) frame-visible-p make-frame-visible raise-frame " Isearch" force-mode-line-update run-hooks isearch-mode-hook isearch-push-state isearch-update add-hook mouse-leave-buffer-hook isearch-done kbd-macro-termination-hook recursive-edit op-fun isearch-op-fun isearch-case-fold-search isearch-last-case-fold-search case-fold-search isearch-string isearch-message isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error baud-rate search-slow-speed search-slow-window-lines isearch-slow-terminal-mode isearch-other-end isearch-small-window isearch-just-started isearch-start-hscroll isearch-opoint search-ring-yank-pointer isearch-opened-overlays isearch-input-method-function isearch-input-method-local-p regexp-search-ring-yank-pointer minibuffer-message-timeout isearch-original-minibuffer-message-timeout isearch-window-configuration frame minibuffer-auto-raise isearch-mode isearch-mode-map overriding-terminal-local-map isearch-recursive-edit] 4 (#$ . 29180)])
#@128 This is called after every isearch command to update the display.
The last thing it does is to run `isearch-update-post-hook'.
(defalias 'isearch-update #[nil "\204\263 \204\263 \306 \204 \n\203 \n \210\202 \307 \210 \203z \f\204z \310 \204z ` \311\312\313!\210\314 \315\316 \313W\203B [T\202H \317 TZ\"\210) \313W\203o \320\314 Z!\210\321\322 `\"\210\323\322 \324 \"\210\323\325 \313\"\210\202s \326\314!\210
b\210)\202\222 \324 \323\325 \"\210\310 \204\221 \323\325 \"\210) \203\260 `W\203\247 \327 `\"\210\202\263 \327` \"\210\202\263 \330 \210\316\211!\"#\203\301 \331 \210\311$\332\333!\207" [unread-command-events executing-kbd-macro isearch-message-function isearch-slow-terminal-mode isearch-small-window found-point input-pending-p isearch-message pos-visible-in-window-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 isearch-highlight isearch-dehighlight isearch-lazy-highlight-new-loop run-hooks isearch-update-post-hook window-min-height search-slow-window-lines current-scroll isearch-start-hscroll isearch-other-end isearch-adjusted isearch-yank-flag isearch-lazy-highlight disable-point-adjustment] 5 (#$ . 31077)])
#@174 Exit Isearch mode.
For successful search, pass no args.
For a failing search, NOPUSH is t.
For going to the minibuffer to edit the search string,
NOPUSH is t and EDIT is t.
(defalias 'isearch-done #[(&optional nopush edit) "\203# \306 \n \f
\307$D\257 %&@%\232\204\" %&B&)\310\311\312\"\210\310\313\312\"\210\314\211'()*\315 \210\316!\210\317\320 !` + ,-\203f \321-!\210.\203^ +b\210\202f \322\320 ,\323#\210*\314/0\203v 1\202z \324\325!\210\326 \210m?\205\206 \327`\330\"o?\205\220 \327`S\330\" 2 32\203\267 3\203\267 23=\203\267 \f\203\261 \331`\330\"\202\265 \332`\330\"b\210* G\333V\203\311 4\204\311 \334 \n\"\2104\205\321 5? 6\335\336!\210)`7U\2048\203\351 9\204\3377\323\"\210:\204\340 \333V\2045\204\341\342!\2105?\205;\205\343 \207" [isearch-resume-in-command-history isearch-string isearch-regexp isearch-word isearch-forward isearch-message isearch-resume quote remove-hook mouse-leave-buffer-hook isearch-done kbd-macro-termination-hook nil isearch-dehighlight lazy-highlight-cleanup window-start selected-window set-window-configuration set-window-start t kill-local-variable input-method-function force-mode-line-update get-text-property intangible next-single-property-change previous-single-property-change 0 isearch-update-ring run-hooks isearch-mode-end-hook push-mark minibuffer-depth message "Mark saved where search started" exit-recursive-edit isearch-case-fold-search command command-history isearch-lazy-highlight-start overriding-terminal-local-map isearch-original-minibuffer-message-timeout minibuffer-message-timeout found-point found-start isearch-window-configuration isearch-small-window isearch-mode isearch-input-method-local-p isearch-input-method-function before after nopush edit isearch-mode-end-hook-quit isearch-opoint transient-mark-mode mark-active executing-kbd-macro isearch-recursive-edit] 9 (#$ . 32363)])
#@100 Add STRING to the beginning of the search ring.
REGEXP if non-nil says use the regexp search ring.
(defalias 'isearch-update-ring #[(string &optional regexp) "\304\203 \305\202\n \306 \203 \n\202 #\207" [regexp string regexp-search-ring-max search-ring-max add-to-history regexp-search-ring search-ring] 4 (#$ . 34274)])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-string compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-string (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-string 'isearch--state)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-string #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-string isearch--state 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-message compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-message (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-message 'isearch--state)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-message #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-message isearch--state 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-point compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-point (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-point 'isearch--state)) (aref cl-x 3)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-point #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-point isearch--state 3] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-success compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-success (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-success 'isearch--state)) (aref cl-x 4)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-success #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-success isearch--state 4] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-forward compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-forward (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-forward 'isearch--state)) (aref cl-x 5)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-forward #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-forward isearch--state 5] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-other-end compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-other-end (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-other-end 'isearch--state)) (aref cl-x 6)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-other-end #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-other-end isearch--state 6] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-word compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-word (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-word 'isearch--state)) (aref cl-x 7)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-word #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-word isearch--state 7] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-error compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-error (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-error 'isearch--state)) (aref cl-x 8)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-error #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-error isearch--state 8] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-wrapped compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-wrapped (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-wrapped 'isearch--state)) (aref cl-x 9)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-wrapped #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-wrapped isearch--state 9] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-barrier compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-barrier (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-barrier 'isearch--state)) (aref cl-x 10)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-barrier #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-barrier isearch--state 10] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-case-fold-search compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-case-fold-search (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-case-fold-search 'isearch--state)) (aref cl-x 11)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-case-fold-search #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-case-fold-search isearch--state 11] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-pop-fun compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-pop-fun (or (and (memq (aref cl-x 0) cl-struct-isearch--state-tags)) (error "%s accessing a non-%s" 'isearch--state-pop-fun 'isearch--state)) (aref cl-x 12)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-pop-fun #[(cl-x) "\302H >\204 \303\304\305\306#\210\307H\207" [cl-x cl-struct-isearch--state-tags 0 error "%s accessing a non-%s" isearch--state-pop-fun isearch--state 12] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put isearch--state-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block isearch--state-p (and (vectorp cl-x) (>= (length cl-x) 13) (memq (aref cl-x 0) cl-struct-isearch--state-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/isearch.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'isearch--state-p #[(cl-x) "\302!\205 G\303Y\205 \304H >\205 \305\207" [cl-x cl-struct-isearch--state-tags vectorp 13 0 t] 2])
#@380
(fn &aux (STRING isearch-string) (MESSAGE isearch-message) (POINT (point)) (SUCCESS isearch-success) (FORWARD isearch-forward) (OTHER-END isearch-other-end) (WORD isearch-word) (ERROR isearch-error) (WRAPPED isearch-wrapped) (BARRIER isearch-barrier) (CASE-FOLD-SEARCH isearch-case-fold-search) (POP-FUN (if isearch-push-state-function (funcall isearch-push-state-function))))
(defalias 'isearch--get-state #[(&rest #1=#:--cl-rest--) "\n`
\f
\205- \203? \306\307\310 G\311\\D\"\210\312\313 \f\f &
.\f\207" [isearch-string string isearch-message message point isearch-success signal wrong-number-of-arguments isearch--get-state 0 vector cl-struct-isearch--state success isearch-forward forward isearch-other-end other-end isearch-word word isearch-error error isearch-wrapped wrapped isearch-barrier barrier isearch-case-fold-search case-fold-search isearch-push-state-function pop-fun #1#] 14 (#$ . 43812)])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\313#\210\302\314\315\313#\210\302\316\315\317#\210\302\320\315\313#\210\302\321\315\313#\210\302\322\315\313#\210\302\323\315\313#\210\302\324\315\313#\210\302\325\315\313#\210\302\326\315\313#\210\302\327\315\313#\210\302\330\315\313#\210\302\331\315\313#\210\302\332\315\313#\210\302\333\315\313#\207" [cl-struct-isearch--state-tags cl-struct-isearch--state put isearch--state cl-struct-slots ((cl-tag-slot) (string :read-only t) (message :read-only t) (point :read-only t) (success :read-only t) (forward :read-only t) (other-end :read-only t) (word :read-only t) (error :read-only t) (wrapped :read-only t) (barrier :read-only t) (case-fold-search :read-only t) (pop-fun :read-only t)) cl-struct-type (vector nil) cl-struct-include nil cl-struct-print t isearch--get-state side-effect-free isearch--state-p error-free isearch--state-pop-fun isearch--state-case-fold-search isearch--state-barrier isearch--state-wrapped isearch--state-error isearch--state-word isearch--state-other-end isearch--state-forward isearch--state-success isearch--state-point isearch--state-message isearch--state-string] 4)
(defalias 'isearch--set-state #[(cmd) "\306H >\204 \307\310\311\312#\210\313H\306H >\204 \307\310\314\312#\210\315H\306H >\2042 \307\310\316\312#\210\317H\306H >\204D \307\310\320\312#\210\321H\306H >\204V \307\310\322\312#\210\323H#\306H >\204i \307\310\324\312#\210\325H$\306H >\204| \307\310\326\312#\210\327H%\306H >\204\217 \307\310\330\312#\210\331H&\306H >\204\242 \307\310\332\312#\210\333H'\306H >\204\265 \307\310\334\312#\210\335H(\336\306H >\204\311 \307\310\337\312#\210\340H!\203\344 \306H >\204\336 \307\310\337\312#\210\340H!\210\306H >\204\362 \307\310\341\312#\210\342Hb\207" [cmd cl-struct-isearch--state-tags isearch-string isearch-message isearch-success isearch-forward 0 error "%s accessing a non-%s" isearch--state-string isearch--state 1 isearch--state-message 2 isearch--state-success 4 isearch--state-forward 5 isearch--state-other-end 6 isearch--state-word 7 isearch--state-error 8 isearch--state-wrapped 9 isearch--state-barrier 10 isearch--state-case-fold-search 11 functionp isearch--state-pop-fun 12 isearch--state-point 3 isearch-other-end isearch-word isearch-error isearch-wrapped isearch-barrier isearch-case-fold-search] 5])
(defalias 'isearch-pop-state #[nil "A\301@!\207" [isearch-cmds isearch--set-state] 2])
(defalias 'isearch-push-state #[nil "\301 B\211\207" [isearch-cmds isearch--get-state] 2])
#@205 Exit search normally.
However, if this is the first command after starting incremental
search and `search-nonincremental-instead' is non-nil, do a
nonincremental search instead via `isearch-edit-string'.
(defalias 'isearch-exit #[nil "\203 G\303U\203 \304\305 \210)\306 \210\307 \207" [search-nonincremental-instead isearch-string isearch-nonincremental 0 t isearch-edit-string isearch-done isearch-clean-overlays] 2 (#$ . 47371) nil])
#@139 Return position of first mismatch in search string, or nil if none.
If MSG is non-nil, use `isearch-message', otherwise `isearch-string'.
(defalias 'isearch-fail-pos #[(&optional msg) " \203 \n\202\n \306 \203 \205\254 @\307H>\204* \310\311\312\313#\210@\314H\203K @\307H>\204C \310\311\315\313#\210@\316H\203V \211A@\210\202 \205\216 \203x @\307H>\204p \310\311\317\313#\210@\320H\202\216 @\307H>\204\211 \310\311\321\313#\210@\322H\211;\203\253 \fG
GW\203\253 \f
\307\fGO\232\203\253 \fG\202\254 \307+\207" [isearch-cmds msg isearch-message isearch-string succ-msg curr-msg nil 0 error "%s accessing a non-%s" isearch--state-success isearch--state 4 isearch--state-error 8 isearch--state-message 2 isearch--state-string 1 cmds isearch-success isearch-error cl-struct-isearch--state-tags] 5 (#$ . 47819)])
#@498 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-nonincremental-exit-minibuffer] to do one nonincremental search.
\[isearch-forward-exit-minibuffer] to resume isearching forward.
\[isearch-reverse-exit-minibuffer] to resume isearching backward.
\[isearch-complete-edit] to complete the search string using the search ring.
(defalias 'isearch-edit-string #[nil "\300\301\302\217\207" [nil (byte-code " \n \f
!\"#$%&'(\306 )\211\307\211 * + ) , - ( ' & % $ # \" ! . / 0 1 2\307\310\311\217\210`+3*\312\216\307\211 4 5\307 6\313\314\307\" \315 \206z GTB7\307 \203\220 \3168\206\213 \317TB\202\231 \3209\206\227 \317TB\307\321&2\322\3232\324#1, G\325U\203\313 \203\271 \202\273 @\206\300 \324\322\323 \324#\326\307!\210.\327 \210\330 \210\331 \210\205\346 \332 \210 \324\232\205\346 \333\324!\207" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-word isearch-case-fold-search current-window-configuration nil (byte-code "\300\301\211\"\207" [isearch-done t] 3) ((exit)) ((byte-code "\203 `=\203 \n =\203 b\210\306\n\f
\307%\210 \n \f
\307\207" [old-other-end old-point isearch-forward isearch-new-forward isearch-regexp isearch-op-fun isearch-mode nil isearch-word isearch-new-string isearch-string isearch-new-message isearch-message isearch-new-word isearch-new-case-fold isearch-case-fold-search] 6)) read-from-minibuffer isearch-message-prefix isearch-fail-pos regexp-search-ring -1 search-ring t mapconcat isearch-text-char-description "" 0 isearch-ring-adjust1 isearch-search isearch-push-state isearch-update isearch-done message isearch-regexp isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-error isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout old-other-end old-point minibuffer-message-timeout isearch-window-configuration isearch-new-case-fold isearch-new-word isearch-new-forward isearch-new-message isearch-new-string isearch-other-end message-log-max history-add-new-input minibuffer-history-symbol minibuffer-local-isearch-map regexp-search-ring-yank-pointer search-ring-yank-pointer] 25) ((quit (isearch-abort)))] 3 (#$ . 48677) nil])
(defalias 'isearch-nonincremental-exit-minibuffer #[nil "\301\302 \207" [isearch-nonincremental t exit-minibuffer] 1 nil nil])
(defalias 'isearch-forward-exit-minibuffer #[nil "\301\302 \207" [isearch-new-forward t exit-minibuffer] 1 nil nil])
(defalias 'isearch-reverse-exit-minibuffer #[nil "\301\302 \207" [isearch-new-forward nil exit-minibuffer] 1 nil nil])
#@57 Terminate the search and go back to the starting point.
(defalias 'isearch-cancel #[nil "\203 \203 \303 !\304 @!\210)\202 \nb\210\305\306!\210\307 \210\310\311\312\"\207" [isearch-push-state-function isearch-cmds isearch-opoint last isearch--set-state isearch-done t isearch-clean-overlays signal quit nil] 3 (#$ . 51530) nil])
#@193 Abort incremental search mode if searching is successful, signaling quit.
Otherwise, revert to previous successful search and continue searching.
Use `isearch-exit' to quit without signaling.
(defalias 'isearch-abort #[nil "\302 \210\203 \204 \303\304 \207\203 \203 \305 \210\202 \306 \207" [isearch-success isearch-error discard-input nil isearch-cancel isearch-pop-state isearch-update] 1 (#$ . 51871) nil])
(defalias 'isearch-repeat #[(direction) " \306==\203_ \n\307\232\203= \203 \f\202
\204 \310\202e \203( \f\202)
@\311\312\n\307#\313\314!\210\202e \204e \315\203Q \210\202e \203Y e\202Z db\210\202e ?\315`\n\307\232\203t \315\202\256 \203\253 ` \232\203\253 \204\253 \203\215 m\202\216 o\203\232 \314\316 \210\202\256 \203\242 \317\202\243 \320u\210\321 \210\202\256 \321 \210\322 \210\323 \207" [isearch-forward direction isearch-string isearch-regexp regexp-search-ring search-ring forward "" "No previous search string" mapconcat isearch-text-char-description isearch-ring-adjust1 nil t ding 1 -1 isearch-search isearch-push-state isearch-update isearch-error isearch-message isearch-last-case-fold-search isearch-case-fold-search isearch-success isearch-wrapped isearch-wrap-function isearch-barrier isearch-other-end isearch-just-started] 4])
#@37 Repeat incremental search forwards.
(defalias 'isearch-repeat-forward #[nil "\300\301!\207" [isearch-repeat forward] 2 (#$ . 53187) nil])
#@38 Repeat incremental search backwards.
(defalias 'isearch-repeat-backward #[nil "\300\301!\207" [isearch-repeat backward] 2 (#$ . 53331) nil])
#@36 Toggle regexp searching on or off.
(defalias 'isearch-toggle-regexp #[nil "?\211\203 \304\305\211\306 \207" [isearch-regexp isearch-word isearch-success isearch-adjusted nil t isearch-update] 2 (#$ . 53478) nil])
#@34 Toggle word searching on or off.
(defalias 'isearch-toggle-word #[nil "?\211\203 \304\305\211\306 \207" [isearch-word isearch-regexp isearch-success isearch-adjusted nil t isearch-update] 2 (#$ . 53703) nil])
#@36 Toggle symbol searching on or off.
(defalias 'isearch-toggle-symbol #[nil "\304=?\205 \304\211\203 \305\306\211\307 \207" [isearch-word isearch-regexp isearch-success isearch-adjusted isearch-symbol-regexp nil t isearch-update] 3 (#$ . 53924) nil])
#@218 Toggle whitespace matching in searching on or off.
In ordinary search, toggles the value of the variable
`isearch-lax-whitespace'. In regexp search, toggles the
value of the variable `isearch-regexp-lax-whitespace'.
(defalias 'isearch-toggle-lax-whitespace #[nil "\203\n ?\202
\n?\306\307\310\311\306\f\"
\203 \202 \n\203& \312\202' \313$\210)\314\211\315\316!\210\317 \207" [isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace message-log-max isearch-nonincremental isearch-message nil message "%s%s [%s]" isearch-message-prefix "match spaces loosely" "match spaces literally" t sit-for 1 isearch-update isearch-success isearch-adjusted] 6 (#$ . 54187) nil])
#@45 Toggle case folding in searching on or off.
(defalias 'isearch-toggle-case-fold #[nil "?\205 \306\307\310\311\312\307\n\" \203 \313\202 \314$\210)\315\211\316\317!\210\320 \207" [isearch-case-fold-search message-log-max isearch-nonincremental isearch-message isearch-success isearch-adjusted yes nil message "%s%s [case %ssensitive]" isearch-message-prefix "in" "" t sit-for 1 isearch-update] 6 (#$ . 54884) nil])
#@420 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 LAX is non-nil, the end of the string
need not match a word boundary unless it ends in whitespace.
Used in `word-search-forward', `word-search-backward',
`word-search-forward-lax', `word-search-backward-lax'.
(defalias 'word-search-regexp #[(string &optional lax) "\305\306\307\310\n #,\203 \311\207\312\313\314\315\316\307#\316#\f\2032 \317\306\307\310\n #,\2053 \312Q\207" [string start regexp inhibit-changing-match-data lax "^\\W*$" nil t string-match "" "\\b" mapconcat identity split-string "\\W+" "\\W$"] 7 (#$ . 55314)])
#@637 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 extend before 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.
Optional fourth argument is repeat count--search for successive occurrences.
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.
(defalias 'word-search-backward #[(string &optional bound noerror count) "\304\305\306\" \n $\207" [string bound noerror count re-search-backward word-search-regexp nil] 5 (#$ . 56074) "sWord search backward: "])
#@629 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 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.
Optional fourth argument is repeat count--search for successive occurrences.
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.
(defalias 'word-search-forward #[(string &optional bound noerror count) "\304\305\306\" \n $\207" [string bound noerror count re-search-forward word-search-regexp nil] 5 (#$ . 56931) "sWord search: "])
#@754 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 extend before 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.
Optional fourth argument is repeat count--search for successive occurrences.
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.
(defalias 'word-search-backward-lax #[(string &optional bound noerror count) "\304\305\306\" \n $\207" [string bound noerror count re-search-backward word-search-regexp t] 5 (#$ . 57769) "sWord search backward: "])
#@745 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 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.
Optional fourth argument is repeat count--search for successive occurrences.
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.
(defalias 'word-search-forward-lax #[(string &optional bound noerror count) "\304\305\306\" \n $\207" [string bound noerror count re-search-forward word-search-regexp t] 5 (#$ . 58745) "sWord search: "])
#@204 Return a regexp which matches STRING as a symbol.
Creates a regexp where STRING is surrounded by symbol delimiters \_< and \_>.
If LAX is non-nil, the end of the string need not match a symbol boundary.
(defalias 'isearch-symbol-regexp #[(string &optional lax) "\302\303! ?\205\n \304Q\207" [string lax "\\_<" regexp-quote "\\_>"] 3 (#$ . 59701)])
(put 'isearch-symbol-regexp 'isearch-message-prefix "symbol ")
#@69 Search forward for STRING, matching a sequence of whitespace chars.
(defalias 'search-forward-lax-whitespace #[(string &optional bound noerror count) "\306\307\n! \f
$)\207" [search-whitespace-regexp search-spaces-regexp string bound noerror count re-search-forward regexp-quote] 5 (#$ . 60119)])
#@70 Search backward for STRING, matching a sequence of whitespace chars.
(defalias 'search-backward-lax-whitespace #[(string &optional bound noerror count) "\306\307\n! \f
$)\207" [search-whitespace-regexp search-spaces-regexp string bound noerror count re-search-backward regexp-quote] 5 (#$ . 60424)])
#@69 Search forward for REGEXP, matching a sequence of whitespace chars.
(defalias 're-search-forward-lax-whitespace #[(regexp &optional bound noerror count) "\306\n \f
$)\207" [search-whitespace-regexp search-spaces-regexp regexp bound noerror count re-search-forward] 5 (#$ . 60732)])
#@70 Search backward for REGEXP, matching a sequence of whitespace chars.
(defalias 're-search-backward-lax-whitespace #[(regexp &optional bound noerror count) "\306\n \f
$)\207" [search-whitespace-regexp search-spaces-regexp regexp bound noerror count re-search-backward] 5 (#$ . 61022)])
#@427 Start `query-replace' with string to replace from last search string.
The arg DELIMITED (prefix arg if interactive), if non-nil, means replace
only matches surrounded by word boundaries. Note that using the prefix arg
is possible only when `isearch-allow-scroll' is non-nil, and it doesn't
always provide the correct matches for `query-replace', so the preferred
way to run word replacements from Isearch is `M-s w ... M-%'.
(defalias 'isearch-query-replace #[(&optional delimited regexp-flag) "\306 \210\203 \307\n\310 \f\310 \311\310\307\"\210\312 \210\203@ `W\203@ \203< \203< \313 `W\204@ b\210 JBL\210\314 \315 \316 \204[ \203_ \317\202` \320 \203h \321\202i \320\203w \203w \322\202x \320R #\307 \206\204 \310\211\205\222 \205\222 \323 \205\236 \205\236 \324 & \210-
\205\250 \325 \207" [regexp-flag isearch-regexp isearch-case-fold-search isearch-lax-whitespace isearch-regexp-lax-whitespace isearch-recursive-edit barf-if-buffer-read-only t nil isearch-done isearch-clean-overlays mark perform-replace query-replace-read-to "Query replace" " word" "" " regexp" " in region" region-beginning region-end exit-recursive-edit replace-regexp-lax-whitespace replace-lax-whitespace search-upper-case case-fold-search isearch-other-end transient-mark-mode mark-active query-replace-from-history-variable isearch-string delimited isearch-word] 10 (#$ . 61316) (list current-prefix-arg)])
#@128 Start `query-replace-regexp' with string to replace from last search string.
See `isearch-query-replace' for more information.
(defalias 'isearch-query-replace-regexp #[(&optional delimited) "\301\302\"\207" [delimited isearch-query-replace t] 3 (#$ . 62758) (list current-prefix-arg)])
#@553 Run `occur' using the last search string as the regexp.
Interactively, REGEXP is constructed using the search string from the
last search command. NLINES has the same meaning as in `occur'.
If the last search command was a word search, REGEXP is computed from
the search words, ignoring punctuation. If the last search
command was a regular expression search, REGEXP is the regular
expression used in that search. If the last search command searched
for a literal string, REGEXP is constructed by quoting all the special
characters in that string.
(defalias 'isearch-occur #[(regexp &optional nlines) "\306 \203\n \n\202 \205 \f \307\n \"+\207" [isearch-case-fold-search isearch-regexp isearch-regexp-lax-whitespace isearch-lax-whitespace search-whitespace-regexp search-spaces-regexp nil occur search-upper-case case-fold-search regexp nlines] 3 (#$ . 63053) (let* ((perform-collect (consp current-prefix-arg)) (regexp (cond ((functionp isearch-word) (funcall isearch-word isearch-string)) (isearch-word (word-search-regexp isearch-string)) (isearch-regexp isearch-string) (t (regexp-quote isearch-string))))) (list regexp (if perform-collect (if (zerop (regexp-opt-depth regexp)) "\\&" (isearch-done nil t) (isearch-clean-overlays) (let ((default (car occur-collect-regexp-history))) (read-regexp (format "Regexp to collect (default %s): " default) default 'occur-collect-regexp-history))) (if current-prefix-arg (progn (prefix-numeric-value current-prefix-arg))))))])
#@262 Run `highlight-regexp' with regexp from the current search string.
It exits Isearch mode and calls `hi-lock-face-buffer' with its regexp
argument from the last search regexp or a quoted search string,
and reads its face argument using `hi-lock-read-face-name'.
(defalias 'isearch-highlight-regexp #[nil "\306\307\306\310\"\210\311 \210)\312\313\306\310#\210 \203 \n\2029 \310=\203* \f\203* \314\n \"\202+ \2036 \315\316\n\317#\2029 \320\n! \321
\322 \"\210)\205G \323 \207" [isearch-recursive-edit isearch-regexp isearch-string isearch-case-fold-search search-upper-case string nil isearch-done t isearch-clean-overlays require hi-lock isearch-no-upper-case-p mapconcat #[(c) "\302!\303\304 \"\203 \305\306 \226 \227#\202 \307 !)\207" [c s string string-match "[[:alpha:]]" format "[%s%s]" regexp-quote] 4] "" regexp-quote hi-lock-face-buffer hi-lock-read-face-name exit-recursive-edit] 4 (#$ . 64545) nil])
#@88 Discard last input item and move point back.
If no previous match was done, just beep.
(defalias 'isearch-delete-char #[nil "A\204 \301 \210\202 \302 \210\303 \207" [isearch-cmds ding isearch-pop-state isearch-update] 1 (#$ . 65468) nil])
#@100 Delete character from end of search string and search again.
If search string is empty, just beep.
(defalias 'isearch-del-char #[(&optional arg) "G\304U\203
\305 \210\202 \304 \206 \306[O\307\310\311# \203$ b\210\312 \210\313 \210\314 \207" [isearch-string arg isearch-message isearch-other-end 0 ding 1 mapconcat isearch-text-char-description "" isearch-search isearch-push-state isearch-update] 4 (#$ . 65717) "p"])
#@33 Pull STRING into search string.
(defalias 'isearch-yank-string #[(string) "\203
\305=\203
\n\227 \203 \306\n!\307\310\n\311\312\n\313#\"\207" [isearch-case-fold-search search-upper-case string isearch-regexp isearch-yank-flag not-yanks regexp-quote t isearch-process-search-string mapconcat isearch-text-char-description ""] 6 (#$ . 66150)])
#@48 Pull string from kill ring into search string.
(defalias 'isearch-yank-kill #[nil "\300\301\302!!\207" [isearch-yank-string current-kill 0] 3 (#$ . 66506) nil])
#@66 Replace just-yanked search string with previously killed string.
(defalias 'isearch-yank-pop #[nil "\301>\204 \302 \207\303 \210\304\305\306!!\207" [last-command (isearch-yank-kill isearch-yank-pop) isearch-yank-kill isearch-pop-state isearch-yank-string current-kill 1] 3 (#$ . 66673) nil])
#@46 Pull current X selection into search string.
(defalias 'isearch-yank-x-selection #[nil "\305\306 !\210\205\205 \307\n\204 \205\204 \310=\203 \n\242\310=\202! \203Y \311 \203Y \312 \203Y \203< \313\314 \"\210\307\202Y \315 \316 U\204Y \317\314!\204P \320\314!\204Y \313\314\315 \316 {\"\210 \204u \n\321=\204o \n\242\310=\203u \nA\204u \307\211\202\204 \n\242\310=\203 \nA\307\322\323!)\207" [select-active-regions force transient-mark-mode saved-region-selection mark-active isearch-yank-string x-get-selection nil only region-active-p display-selections-p x-set-selection PRIMARY region-beginning region-end x-selection-owner-p x-selection-exists-p lambda run-hooks deactivate-mark-hook] 4 (#$ . 66973) nil])
#@193 Handle mouse-2 in Isearch mode.
For a click in the echo area, invoke `isearch-yank-x-selection'.
Otherwise invoke whatever the calling mouse-2 command sequence
is bound to outside of Isearch.
(defalias 'isearch-mouse-2 #[(click) "\305!\211@)\306\307\310 \311\" \312\n!\203! \313\n!\204! \314 \202* \315\f!\205* \316\f!+\207" [click position w overriding-terminal-local-map binding event-start nil key-binding this-command-keys-vector t window-minibuffer-p minibuffer-window-active-p isearch-yank-x-selection functionp call-interactively] 4 (#$ . 67703) "e"])
#@318 Pull the text from point to the point reached by JUMPFORM.
JUMPFORM is a lambda expression that takes no arguments and returns
a buffer position, possibly having moved point to that position.
For example, it might move point forward by a word and return point,
or it might return the position of the end of the line.
(defalias 'isearch-yank-internal #[(jumpform) "\303\212\204
\203
b\210\304`\n \")!\207" [isearch-forward isearch-other-end jumpform isearch-yank-string buffer-substring-no-properties] 4 (#$ . 68273)])
#@74 Pull next character from buffer into end of search string in minibuffer.
(defalias 'isearch-yank-char-in-minibuffer #[(&optional arg) "m\203 r\302 \211A@)q\210\303` u\210`\")c\207 u\207" [x arg buffer-list buffer-substring-no-properties] 4 (#$ . 68802) "p"])
#@53 Pull next character from buffer into search string.
(defalias 'isearch-yank-char #[(&optional arg) "\300\301!\207" [isearch-yank-internal #[nil "u\210`\207" [arg] 1]] 2 (#$ . 69069) "p"])
#@121 Pull next character, subword or word from buffer into search string.
Subword is used when `subword-mode' is activated.
(defalias 'isearch-yank-word-or-char #[nil "\300\301!\207" [isearch-yank-internal #[nil "\301f\206 \302z\303U\204 `Tf\206 \302z\303U\2030 \304\300!\203* \203* \305\306!\210\2023 \306v\210\2023 \306u\210`\207" [subword-mode nil 0 119 boundp subword-forward 1] 2]] 2 (#$ . 69265) nil])
#@48 Pull next word from buffer into search string.
(defalias 'isearch-yank-word #[nil "\300\301!\207" [isearch-yank-internal #[nil "\300v\210`\207" [1] 1]] 2 (#$ . 69679) nil])
#@51 Pull rest of line from buffer into search string.
(defalias 'isearch-yank-line #[nil "\300\301!\207" [isearch-yank-internal #[nil "\301\302l\203 \303\202\f \304!)\207" [inhibit-field-text-motion t line-end-position 2 1] 2]] 2 (#$ . 69858) nil])
(defalias 'isearch-search-and-update #[nil "\204 \204 \n\306\203k \204K \f\204K \306\307\310\217\203K
\204, \311\225^X\203K \312\306\311\225\312=\203k \203k \313 \"\202k \203h \f\204h \203] \202f ^T^b\210\314 \210\315 \210\203w \210\316 \207" [isearch-success isearch-regexp isearch-hidden isearch-forward isearch-adjusted isearch-yank-flag nil (byte-code "\211\306=\203 \n\203 \307 \f\"\310\311
!\203
\306\"\2025
\203* \312 \306\"\2025 \f\2032 \2025 \313 !!)\207" [isearch-case-fold-search case-fold-search search-upper-case isearch-string isearch-regexp isearch-word t isearch-no-upper-case-p looking-at functionp word-search-regexp regexp-quote] 5) ((error)) 0 t isearch-no-upper-case-p isearch-search isearch-push-state isearch-update isearch-opoint isearch-barrier isearch-error isearch-other-end isearch-case-fold-search search-upper-case isearch-string isearch-op-fun] 3])
#@55 Return t if STR ends in an odd number of backslashes.
(defalias 'isearch-backslash #[(str) "\301G\302\303\"Z\304\"\305U\207" [str mod string-match "\\\\*\\'" 2 1] 5 (#$ . 71041)])
#@515 Return point to previous successful match to allow regexp liberalization.
\<isearch-mode-map>
Respects \[isearch-repeat-forward] and \[isearch-repeat-backward] by stopping at `isearch-barrier' as needed.
Do nothing if a backslash is escaping the liberalizing character.
If WANT-BACKSLASH is non-nil, invert this behavior (for \} and \|).
Do nothing if regexp has recently been invalid unless optional
ALLOW-INVALID non-nil.
If optional TO-BARRIER non-nil, ignore previous matches and go exactly
to the barrier.
(defalias 'isearch-fallback #[(want-backslash &optional allow-invalid to-barrier) "\205\306 !?\n?=\205 \2036 \f\211 A@)\211 \307H>\204) \310\311\312\313#\210\314H)\2036 \205\203D b\210\315\211\207\f\211 A @ \203\304 \307H>\204e \310\311\312\313#\210 \314H\204\263 \307H>\204| \310\311\316\313#\210 \317H\211 \211GSH \306@\307H>\204\233 \310\311\316\313#\210@\317H!\203\253 \320=\202\257 \321>*\203\304 A@ \202P \205@\203\350 @\307H>\204\340 \310\311\322\313#\210@\323H\206\352 \203\371 ]\202\376 ^b\210\315\211)+\207" [isearch-regexp isearch-string want-backslash isearch-error isearch-cmds x isearch-backslash 0 error "%s accessing a non-%s" isearch--state-error isearch--state 8 t isearch--state-string 1 125 (42 63 43) isearch--state-other-end 6 cl-x cl-struct-isearch--state-tags allow-invalid to-barrier isearch-barrier isearch-adjusted stack previous frame string lchar last-other-end isearch-forward] 6 (#$ . 71230)])
#@100 Unread the given key-sequence KEYLIST.
Scroll-bar or mode-line events are processed appropriately.
(defalias 'isearch-unread-key-sequence #[(keylist) "\304 \210\305\306\"\210G\307V\205J @9\205J \211A@)<\205J \310\211A@)!\311\n8\206? \nA@:\203< \nA@@\202? \nA@)\247?\205J \211A@\207" [keylist x position unread-command-events cancel-kbd-macro-events apply isearch-unread 1 event-start 5] 4 (#$ . 72764)])
(byte-code "\300\301!\203\f \302\301\303\304#\210\300\305!\203 \302\305\303\304#\210\302\306\303\304#\210\302\307\303\304#\210\302\310\303\304#\210\302\311\303\304#\210\302\312\303\304#\210\302\313\303\304#\210\302\314\303\304#\210\302\315\303\304#\210\302\316\303\304#\210\302\317\303\304#\210\302\320\303\304#\210\302\321\303\304#\210\302\322\303\304#\210\302\323\303\304#\210\302\324\303\304#\210\302\325\303\304#\210\302\326\303\304#\210\302\327\303\304#\210\330\331\332\333\334\335\336\337&\207" [fboundp scroll-bar-toolkit-scroll put isearch-scroll t w32-handle-scroll-bar-event recenter recenter-top-bottom reposition-window list-buffers scroll-other-window scroll-other-window-down beginning-of-buffer-other-window end-of-buffer-other-window delete-other-windows balance-windows split-window-right split-window-below enlarge-window split-window-vertically split-window-horizontally universal-argument negative-argument digit-argument custom-declare-variable isearch-allow-scroll nil "Whether scrolling is allowed during incremental search.\nIf non-nil, scrolling commands can be used in Isearch mode.\nHowever, the current match will never scroll offscreen.\nIf nil, scrolling commands will first cancel Isearch mode." :type boolean :group isearch] 8)
#@279 Test whether the search string is currently outside of the window.
Return nil if it's completely visible, or if point is visible,
together with as much of the search string as will fit; the symbol
`above' if we need to scroll the text downwards; the symbol `below',
if upwards.
(defalias 'isearch-string-out-of-window #[(isearch-point) "\306 \307\310\311\"\212\312\313!\210`)\212\312\314!\210`)\310\211 \203/ \206+ \202: \2069
Y\203F \fX\204g \203Y \nY\203k \fW\202d
Y\203k W\203k \310\202}
W\203| \nW\203| \315\202} \316.\207" [end start w-L-1 w-L1 w-end w-start window-start window-end nil t move-to-window-line 1 -1 above below isearch-forward isearch-point isearch-other-end] 6 (#$ . 74447)])
#@211 Scroll the window to bring the search string back into view.
Restore point to ISEARCH-POINT in the process. ABOVE is t when the
search string is above the top of the window, nil when it is beneath
the bottom.
(defalias 'isearch-back-into-window #[(above isearch-point) "\306\211\n\203 \f\206 \202 \f\206
\2039 b\210\307\310!\210 \311\306\312\"Y\203N b\210\307\313!\210\202N b\210\307\313!\210 \314 W\203N b\210\307\310!\210* b\207" [end start isearch-forward isearch-point isearch-other-end above nil recenter 0 window-end t -1 window-start] 4 (#$ . 75194)])
#@111 Reread key sequence KEYLIST with an inactive Isearch-mode keymap.
Return the key sequence as a string/vector.
(defalias 'isearch-reread-key-sequence-naturally #[(keylist) "\302!\210\303\304\303!)\207" [keylist overriding-terminal-local-map isearch-unread-key-sequence nil read-key-sequence] 2 (#$ . 75780)])
#@90 If KEY-SEQ is bound to a scrolling command, return it as a symbol.
Otherwise return nil.
(defalias 'isearch-lookup-scroll-key #[(key-seq) "\303\304 !\211\205& \n9\205& \305\n!\205& \n\306N\307=\204% \n\310N\307=\205& \n*\207" [overriding-terminal-local-map key-seq binding nil key-binding commandp isearch-scroll t scroll-command] 3 (#$ . 76096)])
(defalias 'isearch-other-control-char 'isearch-other-meta-char)
#@797 Process a miscellaneous key sequence in Isearch mode.
Try to convert the current key-sequence to something usable in Isearch
mode, either by converting it with `function-key-map', downcasing a
key with C-<upper case>, or finding a "scrolling command" bound to
it. (In the last case, we may have to read more events.) If so,
either unread the converted sequence or execute the command.
Otherwise, if `search-exit-option' is non-nil (the default) unread the
key-sequence and exit the search normally. If it is the symbol
`edit', the search string is edited in the minibuffer and the meta
character is unread so that it applies to editing the string.
ARG is the prefix argument. It will be transmitted through to the
scrolling command or to the command whose key-sequence exits
Isearch mode.
(defalias 'isearch-other-meta-char #[(&optional arg) "\203\f \306 \307O\202 \306 \211\310H\311\n! \307\211 /\nG\312U\203\232 \3130\n\"\211 1?\2069 1\250\2069 \3141!)\204\232 \315 \210\3132\n\"\203V \316 \21034\317\320\f\"\202\272\311\3130\n\"!\211\205\272\f@\211\250\203\213 \n\321Y\203\213 \n\322U\204\213 \n\323W\203\213 \324\n!\210\325\n!\210\fA\211\202_ 34\317\320\f\"\210\307\211\202_ \326 ! 5 \250\205\311 \3275>\205\311 \3305>\205\311 \3136\331\n!\211 7\310 \332ZI\2107)\307#\333>?)\203\341 \f \332Z\240\210\315 \21034\317\320\f\"\202\2728\334=\203\366 34\317\320\f\"\210\335 \202\2729\203:\336\f!\311\n!\n\310H\337\n!\211\203:`/34\340
!\210\341/!\211 :\2030\342:\343=/\"\210\2024/b\210)\344 \202\272 \242\345=\203V\346\347 !\211 ;@)!\203V\350 \210\335 \202\2728\203\266\307 <34\351\f!\210=@>\204\247 <\203\247\347 !\211 ;@)\211<\203\247\352<!\203\247\353 \310V\204\227\346<!\204\247r\354<!q\210\316 \210\355 )\202\262\316 \210\355 \2103\2114)\202\272\356\n\211\"-\207" [current-prefix-arg universal-argument-num-events key main-event keylist scroll-command this-command-keys nil 0 listify-key-sequence 1 lookup-key keymapp cancel-kbd-macro-events isearch-done apply isearch-unread 32 127 256 store-kbd-macro-event isearch-process-search-char event-modifiers shift control copy-sequence 33554432 (nil isearch-other-control-char) edit isearch-edit-string isearch-reread-key-sequence-naturally isearch-lookup-scroll-key command-execute isearch-string-out-of-window isearch-back-into-window above isearch-update down-mouse-1 window-minibuffer-p event-start read-event isearch-unread-key-sequence windowp minibuffer-depth window-buffer isearch-clean-overlays isearch-process-search-string isearch-point local-function-key-map lookup global-map arg prefix-arg mods isearch-mode-map copy search-exit-option isearch-allow-scroll ab-bel position window unread-command-events isearch-mode] 7 (#$ . 76517) "P"])
#@50 Quote special characters for incremental search.
(defalias 'isearch-quote-char #[nil "\305\306\307!! \203) \n\203) \310U\203) \311 \211G\"\203# \312\313\314\"\202@ \315!\202@ \f\203= \316Y\203= \317X\203= \320!\315!)\207" [char isearch-regexp isearch-regexp-lax-whitespace isearch-string enable-multibyte-characters read-quoted-char isearch-message t 32 subregexp-context-p isearch-process-search-string "[ ]" " " isearch-process-search-char 128 255 unibyte-char-to-multibyte] 3 (#$ . 79301) nil])
#@71 Add this ordinary printing character to the search string and search.
(defalias 'isearch-printing-char #[nil "\211\303U\203\n \304\n\203 \305 !\202 \306 !)\207" [last-command-event char current-input-method 33554464 32 isearch-process-search-multibyte-characters isearch-process-search-char] 3 (#$ . 79813) nil])
(defalias 'isearch-process-search-char #[(char) "\301>\203
\302\303!\210\202' \304=\203 \302\305\211\"\210\202' \306=\203' \302\305\303\305#\210\307\310!\311Y\2037 \310!\202: \312!\"\207" [char (42 63) isearch-fallback nil 125 t 124 isearch-process-search-string char-to-string 128 isearch-text-char-description] 4])
(defalias 'isearch-process-search-string #[(string message) " P\n P\304 \207" [isearch-string string isearch-message message isearch-search-and-update] 2])
(defalias 'isearch-ring-adjust1 #[(advance) "\203 \202 \n\211G \203 \306\202 \307 \310
! \311\f!?\205U
\312\2064 \2033 \313\2024 \314\203= \314\202> \315\\\f\"\211L\210 8\316\317\320#\211,\207" [isearch-regexp regexp-search-ring search-ring ring length yank-pointer-name regexp-search-ring-yank-pointer search-ring-yank-pointer eval zerop mod 0 -1 1 mapconcat isearch-text-char-description "" yank-pointer advance isearch-string isearch-message] 5])
(defalias 'isearch-ring-adjust #[(advance) "\302!\210 \203 \303 \210\304 \210\305 \207\306 \207" [advance search-ring-update isearch-ring-adjust1 isearch-search isearch-push-state isearch-update isearch-edit-string] 2])
#@48 Advance to the next search string in the ring.
(defalias 'isearch-ring-advance #[nil "\300\301!\207" [isearch-ring-adjust advance] 2 (#$ . 81320) nil])
#@52 Retreat to the previous search string in the ring.
(defalias 'isearch-ring-retreat #[nil "\300\301!\207" [isearch-ring-adjust nil] 2 (#$ . 81478) nil])
(defalias 'isearch-complete1 #[nil "\203 \202 \n\f \306 \"\211 \307=\203 \307\202\211 \204* G\310U\203\204 \232\203w \203s r\311\312!q\210p\313 \210\314\211\307\211 \307 \315 \210\316\317!\210+\211 \320\321 \"!\210\322 !\210+\307\202\211 \205\211 \211\202\211 \323\324!\210\314+\207" [isearch-regexp regexp-search-ring search-ring ring case-fold-search completion-ignore-case try-completion t 0 get-buffer-create "*Isearch completions*" kill-all-local-variables nil erase-buffer run-hooks temp-buffer-setup-hook display-completion-list all-completions internal-temp-output-buffer-show message "No completion" isearch-string completion completion-auto-help default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output] 5])
#@189 Complete the search string from the strings on the search ring.
The completed string is then editable in the minibuffer.
If there is no completion possible, say so and continue searching.
(defalias 'isearch-complete #[nil "\302 \203 \303\304\305#\306 \207\307\310!\210\311 \207" [isearch-string isearch-message isearch-complete1 mapconcat isearch-text-char-description "" isearch-edit-string sit-for 1 isearch-update] 4 (#$ . 82497) nil])
#@54 Same as `isearch-complete' except in the minibuffer.
(defalias 'isearch-complete-edit #[nil "\301 \302 \205
\303 \210c\207" [isearch-string field-string isearch-complete1 delete-field] 1 (#$ . 82945) nil])
(defalias 'isearch-message #[(&optional c-q-hack ellipsis) " \306\307! \n\203( \310 !\311\n G\312 $\210\313\314 \"\203( \311\315\224\315\225\316 $\210\317
\" \320!Q\203< \202D \321 \322\323 \")+\207" [ellipsis isearch-message fail-pos m cursor-in-echo-area isearch-nonincremental isearch-fail-pos t copy-sequence add-text-properties (face isearch-fail) string-match " +$" 0 (face trailing-whitespace) isearch-message-prefix isearch-message-suffix nil message "%s" c-q-hack message-log-max] 5])
(defalias 'isearch-message-prefix #[(&optional ellipsis nonincremental) "\203
\203
\306\307\310\217\210\n\204 \306\n\203 \311\202 \312 \203$ \313\202% \311\f\205B
?\205B \203: ` V\202> ` W\205B \314\f\205G \315 \203] 9\203Y \316N\206^ \317\202^ \311!\203g \320\202h \311\"\203q \321\202r \311#\206x \311$\203\201 \322\202\202 \323 \203\213 \311\202\214 \324%\203\233 \325\326&\327Q!\202\234 \330\260 '\331'\332\333O\226'\333\306OP\334\335#)\207" [isearch-error ellipsis isearch-success isearch-adjusted isearch-wrapped isearch-wrap-function nil (byte-code "\302`\303#\210\304\211\207" [isearch-string isearch-error re-search-forward t nil] 5) ((error)) "" "failing " "pending " "over" "wrapped " isearch-message-prefix "word " "regexp " "multi " "search" "I-search" " backward" bidi-string-mark-left-to-right " [" "]: " ": " propertize 0 1 face minibuffer-prompt isearch-forward isearch-opoint isearch-word isearch-regexp multi-isearch-next-buffer-current-function isearch-message-prefix-add nonincremental current-input-method current-input-method-title m] 14])
(defalias 'isearch-message-suffix #[(&optional c-q-hack) "\203 \303\202 \304 \203 \305 \306Q\202 \304\n\206 \304Q\207" [c-q-hack isearch-error isearch-message-suffix-add "^Q" "" " [" "]"] 4])
#@373 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.
This returned function will be used by `isearch-search-string' to
search for the first occurrence of STRING or its translation.
(defvar isearch-search-fun-function 'isearch-search-fun-default (#$ . 84958))
#@112 Return the function to use for the search.
Can be changed via `isearch-search-fun-function' for special needs.
(defalias 'isearch-search-fun #[nil "\206 \301 \207" [isearch-search-fun-function isearch-search-fun-default] 1 (#$ . 85415)])
#@49 Return default functions to use for the search.
(defalias 'isearch-search-fun-default #[nil "\203 \306\207 \203 \n\203 \203 \f\203 \307\207\310\207 \203& \f\203$ \311\207\312\207
\2036 \2036 \f\2034 \313\207\314\207\f\203< \315\207\316\207" [isearch-word isearch-regexp isearch-regexp-lax-whitespace search-whitespace-regexp isearch-forward isearch-lax-whitespace #[(string &optional bound noerror count) "\206! @?\206! \nG @\306H >\204 \307\310\311\312#\210 @\313HG=?
\203+ \314\202, \315\316!\203< \f\"\202A \317\f\"$)\207" [isearch-nonincremental isearch-cmds isearch-string cl-struct-isearch--state-tags lax isearch-forward 0 error "%s accessing a non-%s" isearch--state-string isearch--state 1 re-search-forward re-search-backward functionp word-search-regexp isearch-word string bound noerror count] 5] re-search-forward-lax-whitespace re-search-backward-lax-whitespace re-search-forward re-search-backward search-forward-lax-whitespace search-backward-lax-whitespace search-forward search-backward] 1 (#$ . 85661)])
#@155 Search for the first occurrence of STRING or its translation.
If found, move point to the end of the occurrence,
update the match data, and return point.
(defalias 'isearch-search-string #[(string bound noerror) "\306 \212 \n #) \307 \310!\203y \311 !\203y \312 \307 \313 \314 #,\203y \315\301\316\317 \"\"\307 \211 \203x \320 \321\216\212\n #\211\203W \320\313!+
\203x \f\203q \203k
\fW\202n
\fV\203x
\322!\210*\f\205\222 \203\216 \323 !\203\216 \324 !\210\fb\210\f+\207" [func string bound noerror pos1 pos2 isearch-search-fun nil char-table-p multibyte-string-p "[^[:ascii:]]" t string-match apply mapcar #[(c) " H\206 \207" [translation-table-for-input c] 2] match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) set-match-data buffer-live-p switch-to-buffer translation-table-for-input start regexp inhibit-changing-match-data translated save-match-data-internal isearch-forward multi-isearch-next-buffer-current-function multi-isearch-current-buffer] 6 (#$ . 86717)])
(defalias 'isearch-search #[nil "\203\f \306\307\"\210\202 \310\306\307\"\210 \307=\203 \n\203 \311 \f\"\312\313\314\217\210
?\205\223 @\315H>\204; \316\317\320\321#\210@\322H\203F \323 \210\324@\315H>\204X \316\317\325\321#\210@\326H!\203| @\315H>\204r \316\317\325\321#\210@\326H@!\210@\315H>\204\215 \316\317\327\321#\210@\330Hb\207" [isearch-message-function isearch-case-fold-search search-upper-case isearch-string isearch-regexp isearch-success nil t isearch-message isearch-no-upper-case-p lossage (byte-code "\306=\205 \307\n\310 \307\f \203A \311
\307\310#\211\203; o\204; m\204; \312\224\312\225U\204; \312\224\312\225\"\203 \307\211\204 \307\203W \203S \312\224\202U \312\225,\307\207" [isearch-filter-predicate search-invisible isearch-case-fold-search retry case-fold-search inhibit-quit isearch-filter-visible nil t isearch-search-string 0 inhibit-point-motion-hooks isearch-error isearch-string isearch-success isearch-just-started isearch-forward isearch-other-end] 5) ((quit (byte-code "\301\302!\210\303\211\207" [isearch-success isearch-unread 7 nil] 3)) (invalid-regexp (byte-code "A@\302\303 \"\203
\304\302\207" [lossage isearch-error string-match "\\`Premature \\|\\`Unmatched \\|\\`Invalid " "incomplete input"] 3)) (search-failed (byte-code "\303\304 8\303\207" [isearch-success lossage isearch-error nil 2] 2)) (error (byte-code "\302\303\"\302\207" [lossage isearch-error format "%s"] 3))) 0 error "%s accessing a non-%s" isearch--state-success isearch--state 4 ding functionp isearch--state-pop-fun 12 isearch--state-point 3 isearch-cmds cl-struct-isearch--state-tags] 5])
(defalias 'isearch-open-overlay-temporary #[(ov) "\301\302\"\203 \301\302\"\303\"\207\304\305\301\306\"#\210\304\307\301\310\"#\210\304\306\303#\210\304\310\303#\207" [ov overlay-get isearch-open-invisible-temporary nil overlay-put isearch-invisible invisible isearch-intangible intangible] 6])
(defalias 'isearch-open-necessary-overlays #[(ov) "`\303!V\205
`\304!W\305\306\"\211\204 \2049 \307\310\305\311\"#\210\307\312\305\313\"#\210\307\311\314#\210\307\313\314#\210\n\203F \305\315\"!\202N \205N \316\"*\207" [ov fct-temp inside-overlay overlay-start overlay-end overlay-get isearch-open-invisible-temporary overlay-put invisible isearch-invisible intangible isearch-intangible nil isearch-open-invisible t] 7])
(defalias 'isearch-clean-overlays #[nil "\205\f \301\302\"\210\303\211\207" [isearch-opened-overlays mapc isearch-open-necessary-overlays nil] 3])
#@62 Return t if regions START0..END0 and START1..END1 intersect.
(defalias 'isearch-intersects-p #[(start0 end0 start1 end1) " Y\203\f \nW\206- V\203 \nX\206- Y\203$ W\206- \nV\205- \n X\207" [start0 start1 end1 end0] 2 (#$ . 90340)])
(defalias 'isearch-close-unnecessary-overlays #[(begin end) "\306 \306\211\205] @\307\f
\310\n!\311\n!$\203# \nB\202U \312\n\313\"\211 \2036 \n\314\"\210\202T \315\n\316\312\n\317\"#\210\315\n\320\312\n\321\"#\210\315\n\317\306#\210\315\n\321\306#\210) A\211\204\f \306+\207" [isearch-opened-overlays overlays ov --dolist-tail-- begin end nil isearch-intersects-p overlay-start overlay-end overlay-get isearch-open-invisible-temporary t overlay-put invisible isearch-invisible intangible isearch-intangible fct-temp] 7])
#@56 Return t if all the text from BEG to END is invisible.
(defalias 'isearch-range-invisible #[(beg end) " U?\205\275 \212b\210\n\306=\307\211 \203
\203 \310 \"\210` W\203\231 \311`!\203\231 \311\312`\313\"!\203@ \314`\313\307 $b\210\307\202 \f\203\221 \315`!\307\211\211 \211 \203\206 @\316\313\"\311!\203} \316\317\"\203{ B\202} \307A\211\204V \f\203\220 \320 \",\321`!b\210\202 ` Y\205\274 \f\203\270 :\203\270 \320 \"\322\323 \"\210\307\202\274 \324\211+\207" [beg end search-invisible crt-overlays can-be-opened isearch-hide-immediately open nil isearch-close-unnecessary-overlays invisible-p get-text-property invisible next-single-property-change overlays-at overlay-get isearch-open-invisible append next-overlay-change mapc isearch-open-overlay-temporary t invis-prop o ov-list overlays isearch-opened-overlays isearch-hidden] 6 (#$ . 91122)])
#@248 Test whether the current search hit is visible at least partially.
Return non-nil if the text from BEG to END is visible to Isearch as
determined by `isearch-range-invisible' unless invisible text can be
searched too when `search-invisible' is t.
(defalias 'isearch-filter-visible #[(beg end) "\303=\206 \304 \n\"?\207" [search-invisible beg end t isearch-range-invisible] 3 (#$ . 92028)])
#@175 Return t if there are no upper case chars in STRING.
If REGEXP-FLAG is non-nil, disregard letters preceded by `\' (but not `\\')
since they have special meaning in a regexp.
(defalias 'isearch-no-upper-case-p #[(string regexp-flag) "\306\307G\306 \204> \nW\203> H \203(
\310=\203( \f?\2027 \f\2045
\211\227=\2045 \311\306) T\202 \206R \205R \312\313\"\205R \314\315\316\217,?\207" [string found len i quote-flag char nil 0 92 t string-match "\\[:\\(upp\\|low\\)er:]" err (byte-code "\301\302\211\224O\303\"\210\304\207" [string string-match 0 "" nil] 4) ((invalid-regexp (byte-code "\211A@)\302\232\207" [err x "Unmatched [ or [^"] 3))) regexp-flag] 4 (#$ . 92427)])
(defalias 'isearch-text-char-description #[(c) "\301W\203 \302\303\304\305\\\"\306\307#\207\310U\203 \302\311\306\307#\207\312!\207" [c 32 propertize format "^%c" 64 face escape-glyph 127 "^?" char-to-string] 5])
(defalias 'isearch-unread #[(&rest char-or-events) "\302\303\"\210\304 \"\211\207" [char-or-events unread-command-events mapc store-kbd-macro-event append] 3])
(defvar isearch-overlay nil)
(defalias 'isearch-highlight #[(beg end) "\205 \203 \305 \n p$\207\306\n \"\307 \310\311#\210\307 \312\f#\207" [search-highlight isearch-overlay beg end isearch-face move-overlay make-overlay overlay-put priority 1001 face] 5])
(defalias 'isearch-dehighlight #[nil "\205 \301!\207" [isearch-overlay delete-overlay] 2])
(defvar isearch-lazy-highlight-overlays nil)
(defvar isearch-lazy-highlight-wrapped nil)
(defvar isearch-lazy-highlight-start-limit nil)
(defvar isearch-lazy-highlight-end-limit nil)
(defvar isearch-lazy-highlight-start nil)
(defvar isearch-lazy-highlight-end nil)
(defvar isearch-lazy-highlight-timer nil)
(defvar isearch-lazy-highlight-last-string nil)
(defvar isearch-lazy-highlight-window nil)
(defvar isearch-lazy-highlight-window-start nil)
(defvar isearch-lazy-highlight-window-end nil)
(defvar isearch-lazy-highlight-case-fold-search nil)
(defvar isearch-lazy-highlight-regexp nil)
(defvar isearch-lazy-highlight-lax-whitespace nil)
(defvar isearch-lazy-highlight-regexp-lax-whitespace nil)
(defvar isearch-lazy-highlight-word nil)
(defvar isearch-lazy-highlight-forward nil)
(defvar isearch-lazy-highlight-error nil)
#@249 Stop lazy highlighting and remove extra highlighting from current buffer.
FORCE non-nil means do it whether or not `lazy-highlight-cleanup'
is nil. This function is called when exiting an incremental search if
`lazy-highlight-cleanup' is non-nil.
(defalias 'lazy-highlight-cleanup #[(&optional force) "\204 \203 \n\203 \304\n@!\210\nA\211\204\f \205# \305 !\210\306\211\207" [force lazy-highlight-cleanup isearch-lazy-highlight-overlays isearch-lazy-highlight-timer delete-overlay cancel-timer nil] 3 (#$ . 94689) '(t)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias isearch-lazy-highlight-cleanup lazy-highlight-cleanup nil make-obsolete "22.1"] 4)
#@297 Cleanup any previous `lazy-highlight' loop and begin a new one.
BEG and END specify the bounds within which highlighting should occur.
This is called when `isearch-update' is invoked (which can cause the
search string to change or the window to scroll). It is also used
by other Emacs features.
(defalias 'isearch-lazy-highlight-new-loop #[(&optional beg end) "?\205\265 \306\307!\205\265 \n\232\203_ \310 =\203_ \f
=\203_ =\203_ =\203_ =\203_ =\203_ \311 U\203_ \312 U\203_ =\203_ \232?\205\265 \313\314!\210 !\"\310 \311 \312 #\206\200 `$#\206\210 `%\315&
\316\232?\205\265 \317'\315\320#\211(\207" [executing-kbd-macro isearch-string isearch-lazy-highlight-last-string isearch-lazy-highlight-window isearch-lazy-highlight-case-fold-search isearch-case-fold-search sit-for 0 selected-window window-start window-end lazy-highlight-cleanup t nil "" run-with-idle-timer isearch-lazy-highlight-update isearch-lazy-highlight-regexp isearch-regexp isearch-lazy-highlight-word isearch-word isearch-lazy-highlight-lax-whitespace isearch-lax-whitespace isearch-lazy-highlight-regexp-lax-whitespace isearch-regexp-lax-whitespace isearch-lazy-highlight-window-start isearch-lazy-highlight-window-end isearch-forward isearch-lazy-highlight-forward isearch-error isearch-lazy-highlight-error beg isearch-lazy-highlight-start-limit end isearch-lazy-highlight-end-limit isearch-other-end isearch-lazy-highlight-start isearch-lazy-highlight-end isearch-lazy-highlight-wrapped lazy-highlight-initial-delay isearch-lazy-highlight-timer] 4 (#$ . 95375)])
#@137 Search ahead for the next or previous match, for lazy highlighting.
Attempt to do the search exactly the way the pending Isearch would.
(defalias 'isearch-lazy-highlight-search #[nil "\300\301\302\217\207" [nil (byte-code " \n \f
\306\307\306
\203# \f\206 d
\203 \202 \310 ^\2026 \206) e
\2033 \2025 \311 ] \203| \312\307#\211\203u `U\204u \313\224\313\225U\204u \313\224\313\225\"\203J \306\211\204O .\n\207" [isearch-lazy-highlight-case-fold-search isearch-lazy-highlight-regexp isearch-lazy-highlight-word isearch-lazy-highlight-lax-whitespace isearch-lazy-highlight-regexp-lax-whitespace isearch-lazy-highlight-forward nil t window-end window-start isearch-search-string 0 isearch-lazy-highlight-end-limit isearch-lazy-highlight-wrapped isearch-lazy-highlight-start isearch-lazy-highlight-start-limit isearch-lazy-highlight-end bound success retry search-invisible isearch-forward isearch-regexp-lax-whitespace isearch-lax-whitespace isearch-word isearch-regexp case-fold-search isearch-lazy-highlight-last-string isearch-filter-predicate] 12) ((error))] 3 (#$ . 96997)])
#@58 Update highlighting of other matches for current search.
(defalias 'isearch-lazy-highlight-update #[nil "\304\305\305\306\307\217+\207" [lazy-highlight-max-at-a-time nomore looping max t nil (byte-code "\306\307 r\310\216\311\n!\203 \312 \n=\204 \313\n!\210\212\314 \315\216\f\203'
\202) b\210 \203 \316 \203G S\211 \317X\203G \306 \203\315 \317\224\317\225 !\211 \"!U\203\232 \f\203} \"#\203k \202m \320 U\203w \306 \202\300 \321u\210\202\300 \"#\203\210
\202\212 \322 U\203\224 \306 \202\300 \323u\210\202\300 \324\"!\"\211 $%B%\325$\326\327#\210\325$\330&#\210\325$\331\312 #\210)\f\203\311 `\202\314 ` * \204#\203\340 \306 \332'\202\332#\f\203\370 \322 (\206\360 e\322 ]b\210\202\320 )\206d\320 ^b\210)\202+ '?\205\333*\306\334#\211+.\207" [inhibit-quit save-selected-window--state isearch-lazy-highlight-window save-match-data-internal isearch-lazy-highlight-forward isearch-lazy-highlight-end nil internal--before-save-selected-window ((internal--after-save-selected-window save-selected-window--state)) window-live-p selected-window select-window match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) isearch-lazy-highlight-search 0 window-end 1 window-start -1 make-overlay overlay-put priority 1000 face window t run-at-time isearch-lazy-highlight-update isearch-lazy-highlight-start looping found max me mb isearch-lazy-highlight-wrapped ov isearch-lazy-highlight-overlays lazy-highlight-face nomore isearch-lazy-highlight-start-limit isearch-lazy-highlight-end-limit lazy-highlight-interval isearch-lazy-highlight-timer] 5) ((quit (byte-code "\301\302\303!\207" [quit-flag t eval (ignore nil)] 2)))] 3 (#$ . 98127)])
#@348 Resume an incremental search.
STRING is the string or regexp searched for.
REGEXP non-nil means the resumed search was a regexp search.
WORD non-nil means resume a word search.
FORWARD non-nil means resume a forward search.
MESSAGE is the echo-area message recorded for the search resumed.
CASE-FOLD non-nil means the search was case-insensitive.
(defalias 'isearch-resume #[(string regexp word forward message case-fold) "\306 \307\211\n%\210
\n \f\310 \210\311 \207" [forward regexp word string isearch-string message isearch-mode nil isearch-search isearch-update isearch-message case-fold isearch-case-fold-search] 6 (#$ . 99874)])