;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:46:57 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/isearch.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`isearch.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (custom-declare-group 'isearch nil "Incremental search minor mode." :link '(emacs-commentary-link "isearch") :link '(custom-manual "(emacs)Incremental Search") :prefix "isearch-" :prefix "search-" :group 'matching) #@72 *Non-nil means random control characters terminate incremental search. (custom-declare-variable 'search-exit-option 't '(#$ . -831) :type 'boolean :group 'isearch) #@251 *Number of lines in slow search display windows. These are the short windows used during incremental search on slow terminals. Negative means put the slow search window at the top (normally it's at bottom) and the value is minus the number of lines. (custom-declare-variable 'search-slow-window-lines '1 '(#$ . -1002) :type 'integer :group 'isearch) #@173 *Highest terminal speed at which to use "slow" style incremental search. This is the style where a one-line window is created to show the line that the search has reached. (custom-declare-variable 'search-slow-speed '1200 '(#$ . -1359) :type 'integer :group 'isearch) #@296 *If non-nil, upper case chars disable case fold searching. That is, upper and lower case chars must match exactly. This applies no matter where the chars come from, but does not apply to chars in regexps that are prefixed with `\'. If this value is `not-yanks', yanked text is always downcased. (custom-declare-variable 'search-upper-case ''not-yanks '(#$ . -1634) :type '(choice (const :tag "off" nil) (const not-yanks) (other :tag "on" t)) :group 'isearch) #@212 *If non-nil, do a nonincremental search instead if exiting immediately. Actually, `isearch-edit-string' is called to let you enter the search string, and RET terminates editing and does a nonincremental search. (custom-declare-variable 'search-nonincremental-instead 't '(#$ . -2100) :type 'boolean :group 'isearch) #@309 *If non-nil, regular expression to match a sequence of whitespace chars. This applies to regular expression incremental search. You might want to use something like "[ \t\r\n]+" instead. In the Customization buffer, that is `[' followed by a space, a tab, a carriage return (control-M), a newline, and `]+'. (custom-declare-variable 'search-whitespace-regexp '"\\s-+" '(#$ . -2423) :type 'regexp :group 'isearch) #@65 *Non-nil means incremental search highlights the current match. (custom-declare-variable 'search-highlight 't '(#$ . -2842) :type 'boolean :group 'isearch) #@357 If t incremental search can match hidden text. nil means don't match invisible text. If the value is `open', if the text matched is made invisible by an overlay having an `invisible' property and that overlay has a property `isearch-open-invisible', then incremental search will show the contents. (This applies when using `outline.el' and `hideshow.el'.) (custom-declare-variable 'search-invisible ''open '(#$ . 3005) :type '(choice (const :tag "Match hidden text" t) (const :tag "Open overlays" open) (const :tag "Don't match hidden text" nil)) :group 'isearch) #@333 If non-nil, re-hide an invisible match right away. This variable makes a difference when `search-invisible' is set to `open'. It means that after search makes some invisible text visible to show the match, it makes the text invisible again when the match moves. Ordinarily the text becomes invisible again at the end of the search. (custom-declare-variable 'isearch-hide-immediately 't '(#$ . 3576) :type 'boolean :group 'isearch) #@62 Function(s) to call after starting up an incremental search. (defvar isearch-mode-hook nil (#$ . 4013)) #@62 Function(s) to call after terminating an incremental search. (defvar isearch-mode-end-hook nil (#$ . 4123)) #@34 List of search string sequences. (defvar search-ring nil (#$ . 4237)) #@53 List of regular expression search string sequences. (defvar regexp-search-ring nil (#$ . 4313)) #@72 *Maximum length of search ring before oldest elements are thrown away. (custom-declare-variable 'search-ring-max '16 '(#$ . -4415) :type 'integer :group 'isearch) #@79 *Maximum length of regexp search ring before oldest elements are thrown away. (custom-declare-variable 'regexp-search-ring-max '16 '(#$ . -4584) :type 'integer :group 'isearch) #@64 Index in `search-ring' of last string reused. nil if none yet. (defvar search-ring-yank-pointer nil (#$ . 4767)) #@71 Index in `regexp-search-ring' of last string reused. nil if none yet. (defvar regexp-search-ring-yank-pointer nil (#$ . 4886)) #@128 *Non-nil if advancing or retreating in the search ring should cause search. Default value, nil, means edit the string instead. (custom-declare-variable 'search-ring-update 'nil '(#$ . -5020) :type 'boolean :group 'isearch) #@28 Keymap for `isearch-mode'. (defvar isearch-mode-map (byte-code "\306\307 \310\311 8!\204\312\311 8!\204\313\314!\210\315 A@\211\2032\316\n @\317#\210 A\211\204$*\320 \321\322#\210\323W\203O\320 \324\311\"\322#\210T\211\202:\323\323\325W\203f\320 \326!\317#\210T\211\202R\327 \320 \330 !\f#\210\320 \331\f#\210)\320 \326 \332\"\333#\210\320 \334\335#\210\320 \336\337#\210\320 \340\335#\210\320 \341\337#\210\320 \342\343#\210\320 \344\345#\210\346 U\204\257\313\347!\210\320 \350\351#\210\320 \352\351#\210\320 \353\354#\210\320 \355\356#\210\320 \357\317#\210\320 \360\317#\210\320 \361\362#\210\320 \363\362#\210\320 \364\365#\210\320 \366\367#\210\320 \370\371#\210\320 \372\371#\210\320 \373\374#\210\320 \375\376#\210\320 \377\201@#\210\320 \201A\201B#\210\320 \201C\201D#\210\320 \201E\201F#\210\320 \201G\201F#\210\320 \201H\201F#\210\320 \201I\201F#\210\320 \201J\201F#\210\320 \201K\201L#\210\320 \201M\201N#\210\320 \201O\201P#\210\320 \201Q\201F#\210\320 \201R\201S#\210\320 \201T\201U#\210\320 \201V\201W#\210 *\207" [i map table l meta-map meta-prefix-char 0 make-keymap vectorp 1 char-table-p error "The initialization of isearch-mode-map must be updated" generic-character-list set-char-table-default isearch-printing-char define-key [t] isearch-other-control-char 32 make-string 256 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" " " " " isearch-whitespace-chars [33554464] "" isearch-yank-word "" isearch-yank-line "*" isearch-*-char "?" "|" isearch-|-char "\356" isearch-ring-advance "\360" isearch-ring-retreat "\371" isearch-yank-kill "\211" isearch-complete [switch-frame] nil [delete-frame] [iconify-frame] [make-frame-visible] [mouse-movement] "" 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] 6) (#$ . 5249)) #@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\320#\210)\207" [map minibuffer-local-map make-sparse-keymap set-keymap-parent define-key " " isearch-nonincremental-exit-minibuffer "\356" isearch-ring-advance-edit "\360" isearch-ring-retreat-edit "\211" isearch-complete-edit "" isearch-forward-exit-minibuffer "" isearch-reverse-exit-minibuffer] 4) (#$ . 7461)) (byte-code "\301B\306\301!\204\f\307\302B\306\302!\204\307\303B\306\303!\204$\307\304B\306\304!\2040\307\305B\306\305!\204<\310\311B\306\311!\204I\310 \312B\306\312!\204V\313\n\314B\306\314!\204c\307\f\315B\306\315!\204p\307 \316B\306\316!\204}\307\317B\306\317!\204\212\307\320B\306\320!\204\227\321\322B\306\322!\204\244\307\323B\306\323!\204\261\307\324B\306\324!\204\276\307\325B\306\325!\204\313\307\326B\306\326!\204\330\307\327B\306\327!\204\345\307\330B\306\330!\204\362\321\331B\306\331!\204\377\307\332B\306\332!\204\f\307\333B\306\333!\204\307\334B\306\334!\204&\307\335B\306\335!\2043\307\336B\306\336!\204@\307\337B\306\337!\204M\307\340B\306\340!\204Z\307 \341B\306\341!\204g\307!\342+\236\204t+\343C\244\210\342B\306\342!\204\201\307\"\344\342!\210\345,\346\301#\210\345-\346\347#\210\345,\350\351#\210\345-\350\352#\207" [current-load-list isearch-forward isearch-regexp isearch-word isearch-cmds isearch-string boundp nil "" isearch-message isearch-success t isearch-invalid-regexp isearch-within-brackets isearch-other-end isearch-wrapped isearch-barrier 0 isearch-just-started isearch-case-fold-search isearch-original-minibuffer-message-timeout isearch-adjusted isearch-slow-terminal-mode isearch-small-window isearch-opoint isearch-window-configuration isearch-yank-flag isearch-op-fun isearch-recursive-edit isearch-nonincremental isearch-new-forward isearch-opened-overlays isearch-input-method-function isearch-input-method-local-p isearch-mode (isearch-mode isearch-mode) make-variable-buffer-local define-key "" isearch-forward-regexp "" isearch-backward isearch-backward-regexp minor-mode-alist global-map esc-map] 4) #@2426 Do incremental search forward. With a prefix argument, do an incremental regular expression search instead. \ 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 characters 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] to yank word 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 last killed text onto end of search string and search for 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. Type \[isearch-toggle-case-fold] to toggle search case-sensitivity. Type \[isearch-toggle-regexp] to toggle regular-expression mode. 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. 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 M-x 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 (#$ . 9796) "P\np"]) #@234 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 \[isearch-forward] for more info. (defalias 'isearch-forward-regexp #[(&optional not-regexp no-recursive-edit) "\302\303?\304 ?$\207" [not-regexp no-recursive-edit isearch-mode t nil] 5 (#$ . 12392) "P\np"]) #@142 Do incremental search backward. With a prefix argument, do a regular expression search instead. See \[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 (#$ . 12807) "P\np"]) #@235 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 \[isearch-forward] for more info. (defalias 'isearch-backward-regexp #[(&optional not-regexp no-recursive-edit) "\302\303?\303 ?$\207" [not-regexp no-recursive-edit isearch-mode nil] 5 (#$ . 13119) "P\np"]) (defalias 'isearch-mode-help #[nil "\300\301!\210\302 \207" [describe-function isearch-forward isearch-update] 2 nil nil]) #@83 Start isearch minor mode. Called by `isearch-forward', etc. \{isearch-mode-map} (defalias 'isearch-mode #[(forward &optional regexp op-fun recursive-edit word-p) "\n\f!\"#$\306%\306&\307'\310(\307)`*\307+\307,\307-\307./0X\205;\311 1\312_V2\3073\3074\3105`6\3077\3078\f9\313\314!:\307;<=\307<:\204k\315\314!\210\307\f\316\306!\2102\205y\317 >\320\321 !?\322?!\323>\204\231\324?!\210@\203\231\325?!\210)\326A\327 \210\330 \210BC\331 \210\332\333!\210\334\335\336\"\210\334\337\336\"\210 \203\304\310D\340 \210)(\207" [forward isearch-forward regexp isearch-regexp word-p isearch-word "" nil t window-height 4 local-variable-p input-method-function make-local-variable looking-at current-window-configuration window-frame minibuffer-window frame-live-p (nil t) make-frame-visible raise-frame " Isearch" force-mode-line-update isearch-push-state isearch-update run-hooks isearch-mode-hook add-hook mouse-leave-buffer-hook isearch-done kbd-macro-termination-hook recursive-edit op-fun isearch-op-fun case-fold-search isearch-case-fold-search isearch-string isearch-message isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-invalid-regexp isearch-within-brackets baud-rate search-slow-speed search-slow-window-lines isearch-slow-terminal-mode isearch-other-end isearch-small-window isearch-just-started 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] 3 (#$ . 13656)]) (defalias 'isearch-update #[nil "\204\205\306 \204\f\307 \210 \203c\n\204c\310 \204c`\311\312\313!\210\314\315\316 \313W\2031 [T\2026\317 TZ\"\210) \313W\203[\320\314 Z!\210\321\322 `\"\210\323\322 \324 \"\210\323\325 \313\"\210\202_\326\314!\210 b\210)\203\201`W\203x\327`\"\210\202\205\327`\"\210\202\205\330\316!\210\316\316\331 \210\311\211\207" [unread-command-events isearch-slow-terminal-mode isearch-small-window found-point window-min-height search-slow-window-lines 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 isearch-other-end isearch-adjusted isearch-yank-flag disable-point-adjustment] 4]) (defalias 'isearch-done #[(&optional nopush edit) "\306 \n \f \257#$@#\232\204#$B$)\307\310\311\"\210\307\312\311\"\210\313%\313&'(\314\315!\210\316!\210\317\320 !`)*+\203L\321+!\210,\203X)b\210\202`\322\320 *\315#\210`-U\204\207.\203q/\204\207\323-\315\"\2100\204\207\324 \325V\204\207\326\327!\210*\31312\203\2273\202\233\330\331!\210\332 \210m?\205\247\333`\334\"o?\205\261\333`S\334\"454\203\3325\203\33245=\203\332 \203\324\335`\334\"b\210\202\332\336`\334\"b\210*G\325V\203\3546\204\354\337 \"\210\340\341!\2107?\205\3758\205\375\342 \207" [isearch-string isearch-regexp isearch-word isearch-forward isearch-message isearch-case-fold-search isearch-resume remove-hook mouse-leave-buffer-hook isearch-done kbd-macro-termination-hook nil isearch-dehighlight t isearch-lazy-highlight-cleanup window-start selected-window set-window-configuration set-window-start push-mark minibuffer-depth 0 message "Mark saved where search started" kill-local-variable input-method-function force-mode-line-update get-text-property intangible next-single-property-change previous-single-property-change isearch-update-ring run-hooks isearch-mode-end-hook exit-recursive-edit 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-opoint transient-mark-mode mark-active executing-kbd-macro isearch-mode isearch-input-method-local-p isearch-input-method-function before after nopush edit isearch-recursive-edit] 7]) #@80 Add STRING to the beginning of the search ring. REGEXP says which ring to use. (defalias 'isearch-update-ring #[(string &optional regexp) "\203\" \203\n @\230?\205?\n B\211G V\205!\fS \233\306\241\207 \203.\n @\230?\205?\n B\211G\fV\205?\fS \233\306\241\207" [regexp regexp-search-ring string regexp-search-ring-max search-ring-max search-ring nil] 3 (#$ . 17986)]) #@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 (#$ . 18370) nil]) #@792 Edit the search string in the minibuffer. The following additional command keys are active while editing. \ \[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-ring-advance-edit] to replace the search string with the next item in the search ring. \[isearch-ring-retreat-edit] to replace the search string with the previous item in the search ring. \[isearch-complete-edit] to complete the search string using the search ring. \ If first char entered is \[isearch-yank-word], then do word search instead. (defalias 'isearch-edit-string #[nil "\300\301\302\217\207" [err (byte-code " \n \f  !\"#$%&'()*+\306 ,\211,-.+*)('&%$#\"! /012\307\310\311\217\210\302 \210\312\216\3133\314 )4\3155\3156\316\317\315\211\313#!\210\3207\3214!\"\322=\203\204\313\313/\202\214\323 \210\3244!\210\3153\315\325\317\315\211# 8\315\326%)2\327\3302\331#1, G\332U\203\302 \203\2729\202\274:@\206\301\331.\333 \210\334 \210\335 \210\205\323\336 \207" [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-word isearch-regexp current-window-configuration err (byte-code "\300\301\211\"\207" [isearch-done t] 3) ((exit)) ((byte-code "\306 \n\307 %\210\f \n \307\207" [isearch-forward isearch-regexp isearch-op-fun isearch-word isearch-new-string isearch-string isearch-mode nil isearch-new-message isearch-message isearch-new-forward isearch-new-word] 6)) t read-event nil message isearch-message-prefix lookup-key vector isearch-yank-word cancel-kbd-macro-events isearch-unread read-from-minibuffer junk-ring mapconcat isearch-text-char-description "" 0 isearch-push-state isearch-search isearch-update isearch-done isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-invalid-regexp isearch-within-brackets isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit isearch-original-minibuffer-message-timeout minibuffer-message-timeout isearch-window-configuration isearch-new-word isearch-new-forward isearch-new-message isearch-new-string cursor-in-echo-area e minibuffer-history-symbol message-log-max isearch-mode-map minibuffer-local-isearch-map regexp-search-ring search-ring] 22) ((quit (isearch-abort)))] 3 (#$ . 18818) 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 "b\210\301\302!\210\303 \210\304\305\306\"\207" [isearch-opoint isearch-done t isearch-clean-overlays signal quit nil] 3 (#$ . 21783) 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 "\303 \210\203 b\210\304\305\306!\210\307 \210\310\311\304\"\207\203 \n\203&\312 \210\202\313 \207" [isearch-success isearch-opoint isearch-invalid-regexp discard-input nil isearch-done t isearch-clean-overlays signal quit isearch-pop-state isearch-update] 3 (#$ . 22019) nil]) (defalias 'isearch-repeat #[(direction) " \306==\203>\n\307\232\203( \203\f@\202 @\206\307\310\311\n\307#\202A\204A\2035e\2026db\210\312\202A?`\n\307\232\203P\312\202\213\203\210\313\225\313\224\232\203\210\204\210\203jm\202ko\203w\314\315 \210\202\213\203\316\202\200\317u\210\320 \210\202\213\320 \210\321 \210\322 \207" [isearch-forward direction isearch-string isearch-regexp regexp-search-ring search-ring forward "" mapconcat isearch-text-char-description t 0 nil ding 1 -1 isearch-search isearch-push-state isearch-update isearch-message isearch-success isearch-wrapped isearch-barrier isearch-just-started] 4]) #@37 Repeat incremental search forwards. (defalias 'isearch-repeat-forward #[nil "\300\301!\207" [isearch-repeat forward] 2 (#$ . 23203) nil]) #@38 Repeat incremental search backwards. (defalias 'isearch-repeat-backward #[nil "\300\301!\207" [isearch-repeat backward] 2 (#$ . 23347) nil]) #@36 Toggle regexp searching on or off. (defalias 'isearch-toggle-regexp #[nil "?\211\203 \302\303 \207" [isearch-regexp isearch-word nil isearch-update] 2 (#$ . 23494) nil]) #@45 Toggle case folding in searching on or off. (defalias 'isearch-toggle-case-fold #[nil "?\205\305\306\307\310\311\306\211\n# \203\312\202\313$\210)\314\315\316!\210\317 \207" [isearch-case-fold-search message-log-max isearch-nonincremental isearch-message isearch-adjusted yes nil message "%s%s [case %ssensitive]" isearch-message-prefix "in" "" t sit-for 1 isearch-update] 6 (#$ . 23674) 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 (#$ . 24085) nil]) #@33 Pull STRING into search string. (defalias 'isearch-yank-string #[(string) "\203 \306=\203 \n\227 \203\307\n!\f\nP \310\311\n\312#P\313 \314 \207" [isearch-case-fold-search search-upper-case string isearch-regexp isearch-string isearch-message not-yanks regexp-quote mapconcat isearch-text-char-description "" t isearch-search-and-update isearch-yank-flag] 5 (#$ . 24333)]) #@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 (#$ . 24723) nil]) #@46 Pull current X selection into search string. (defalias 'isearch-yank-x-selection #[nil "\300\301 !\207" [isearch-yank-string x-get-selection] 2 (#$ . 24890) nil]) #@164 Handle mouse-2 in Isearch mode. For a click in the echo area, invoke `isearch-yank-x-selection'. Otherwise invoke whatever mouse-2 is bound to outside of Isearch. (defalias 'isearch-mouse-2 #[(click arg) "\306 8)\307\n8)\310\311\312!!\313 !\314 !\203*\315 !\204*\316 \202K\205K\317!\211A@)\320\232\203G\"\202K!,\207" [click event position w overriding-terminal-local-map key 1 0 nil vector event-basic-type key-binding window-minibuffer-p minibuffer-window-active-p isearch-yank-x-selection interactive-form "e\nP" binding x arg] 4 (#$ . 25060) "e\nP"]) #@48 Pull next word from buffer into search string. (defalias 'isearch-yank-word #[nil "\302\212\204 \203 b\210\303`\304v\210`\")!\207" [isearch-forward isearch-other-end isearch-yank-string buffer-substring-no-properties 1] 4 (#$ . 25649) nil]) #@51 Pull rest of line from buffer into search string. (defalias 'isearch-yank-line #[nil "\302\212\204 \203 b\210\303`\304 \")!\207" [isearch-forward isearch-other-end isearch-yank-string buffer-substring-no-properties line-end-position] 4 (#$ . 25901) nil]) (defalias 'isearch-search-and-update #[nil "\204 \203f\n\204G \204G\306\307\310\217\203G\f\204%\311\225 ^X\203G\312\306\306\311\225\312=\203f\203f\313 \"\202f\203c \204c\n\203Y\202a ^T^b\210\314 \210\315 \210\203r \210\316 \207" [isearch-success isearch-regexp isearch-forward isearch-adjusted isearch-yank-flag isearch-opoint nil (byte-code "\211\305=\203\n\203\306 \f\"\307\f\203 \202\310 !!)\207" [isearch-case-fold-search case-fold-search search-upper-case isearch-string isearch-regexp t isearch-no-upper-case-p looking-at regexp-quote] 4) ((error)) 0 t isearch-no-upper-case-p isearch-search isearch-push-state isearch-update isearch-barrier isearch-invalid-regexp isearch-within-brackets isearch-other-end isearch-case-fold-search search-upper-case isearch-string isearch-op-fun] 3]) #@38 Handle * and ? specially in regexps. (defalias 'isearch-*-char #[nil "\203L G\211\306V\203 \nSH\307=\203\nS\211\202\310 G\nZ\311\"\306U\203K\312\313\fA@8\211\2067 \203D  ]\202H  ^b\210))\314!\207" [isearch-regexp isearch-string idx isearch-adjusted isearch-cmds cs 0 92 mod 2 t 5 isearch-process-search-char isearch-barrier isearch-forward last-command-char] 4 (#$ . 27015) nil]) #@43 If in regexp search, jump to the barrier. (defalias 'isearch-|-char #[nil "\203 \304\nb\210\305 !\207" [isearch-regexp isearch-adjusted isearch-barrier last-command-char t isearch-process-search-char] 2 (#$ . 27425) nil]) (defalias 'isearch-other-control-char 'isearch-other-meta-char) #@263 Exit the search normally and reread this key sequence. But only if `search-exit-option' is non-nil, the default. 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. (defalias 'isearch-other-meta-char #[nil "\306 \211\307H\310!G\311U\203w\312 \"\211?\206$\f\250\206$\313\f!)\204w\314 \210\312 \"\203<\315 \210\316\317\n\"\202o\310\312 \"!\211\205o\n@\211\250\203l\320Y\203l\321U\204l\322W\203l\323!\210\nA\211\202D\316\317\n\"\210\324\211\202D\325 !\" \250\205\243\326\">\205\243\327\">\205\243\312#\330!\211$\307 \331ZI\210$)\324#)\203\267\n \331Z\240\210\314 \210\316\317\n\"\202o%\332=\203\310\316\317\n\"\210\333 \202o%\203k\324&\314 \210\316\317\n\"\210G\311V\203\307H9\203\311H<\203\311H'\311'8)(\311(8:\203 \311(8@\202 \311(8)\247\204)\211A)@\210)@*\204b <\203b '\311'8)(\307(8)\211&\203b\334&!\203b\335 \307V\204R\336&!\204b\212\337&!q\210\315 \210\340 )\202g\315 \210\340 )\202o\341\211\"+\207" [key main-event keylist function-key-map lookup global-map this-command-keys 0 listify-key-sequence 1 lookup-key keymapp cancel-kbd-macro-events isearch-done apply isearch-unread 32 127 256 isearch-process-search-char nil event-modifiers shift control copy-sequence 33554432 edit isearch-edit-string windowp minibuffer-depth window-minibuffer-p window-buffer isearch-clean-overlays isearch-process-search-string mods isearch-mode-map copy search-exit-option window event position unread-command-events isearch-mode] 7 (#$ . 27721) nil]) #@50 Quote special characters for incremental search. (defalias 'isearch-quote-char #[nil "\302\303\304!! \203\305Y\203\306X\203\307!\310!)\207" [char enable-multibyte-characters read-quoted-char isearch-message t 128 255 unibyte-char-to-multibyte isearch-process-search-char] 3 (#$ . 29354) nil]) #@63 Convert return into newline for incremental search. Obsolete. (defalias 'isearch-return-char #[nil "\300\301!\207" [isearch-process-search-char 10] 2 (#$ . 29665) nil]) #@71 Add this ordinary printing character to the search string and search. (defalias 'isearch-printing-char #[nil "\211\304U\203\n\305\n\203- \306Y\203- \307X\203-\310 \203%\311 !\202:\312\313 !!\202: \2037\311 !\202:\312 !)\207" [last-command-char char enable-multibyte-characters current-input-method 33554464 32 128 255 keyboard-coding-system isearch-process-search-multibyte-characters isearch-process-search-char unibyte-char-to-multibyte] 4 (#$ . 29840) nil]) #@115 Match all whitespace chars, if in regexp mode. If you want to search for just a space, type \[quoted-insert] SPC. (defalias 'isearch-whitespace-chars #[nil "\203 \203\n\204 \204\304 \305\"\207\306 \207\306 \207" [isearch-regexp search-whitespace-regexp isearch-within-brackets isearch-invalid-regexp isearch-process-search-string " " isearch-printing-char] 3 (#$ . 30320) nil]) (defalias 'isearch-process-search-char #[(char) "\301\302!\303Y\203\302!\202\304!\"\207" [char 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!?\205L \312\206+\313\2034\314\2025\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\202\305 \210\306 \207" [advance search-ring-update isearch-ring-adjust1 isearch-search isearch-update isearch-edit-string isearch-push-state] 2]) #@48 Advance to the next search string in the ring. (defalias 'isearch-ring-advance #[nil "\300\301!\207" [isearch-ring-adjust advance] 2 (#$ . 31745) nil]) #@52 Retreat to the previous search string in the ring. (defalias 'isearch-ring-retreat #[nil "\300\301!\207" [isearch-ring-adjust nil] 2 (#$ . 31903) nil]) #@111 Insert the next element of the search history into the minibuffer. With prefix arg N, insert the Nth element. (defalias 'isearch-ring-advance-edit #[(n) "\203\306\202 \307\310 !\203 \202\f\211G \311 !?\205? \312\n\206+\313Z \"\211L\210\314 \210\n 8c\210db,\207" [isearch-regexp yank-pointer-name yank-pointer regexp-search-ring search-ring ring regexp-search-ring-yank-pointer search-ring-yank-pointer eval zerop mod 0 delete-field length n] 5 (#$ . 32062) "p"]) #@115 Insert the previous element of the search history into the minibuffer. With prefix arg N, insert the Nth element. (defalias 'isearch-ring-retreat-edit #[(n) "\301[!\207" [n isearch-ring-advance-edit] 2 (#$ . 32552) "p"]) (defalias 'isearch-complete1 #[nil "\203 \202 \n\306\307 \" \310\f\"\211\311=\203#\311\202^\2040G\312U\203Y\232\203L\203H\313\220\314\315\f\"!\221\210\311\202^\205^\211\202^\316\317!\210\320,\207" [isearch-regexp regexp-search-ring search-ring ring alist case-fold-search mapcar #[(string) "C\207" [string] 1] try-completion t 0 "*Isearch completions*" display-completion-list all-completions message "No completion" nil completion-ignore-case isearch-string completion completion-auto-help] 6]) #@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 "\300 \203\301 \207\302\303!\210\304 \207" [isearch-complete1 isearch-edit-string sit-for 1 isearch-update] 2 (#$ . 33317) nil]) #@54 Same as `isearch-complete' except in the minibuffer. (defalias 'isearch-complete-edit #[nil "\301 \302 \205 \303 \210c\207" [isearch-string buffer-string isearch-complete1 delete-field] 1 (#$ . 33676) nil]) (defalias 'isearch-top-state #[nil "@\211@ A@\306 8\307 8\310 8\311 8\312 8\313 8\314 8\315 8\316 8 AA@b)\207" [isearch-cmds cmd isearch-string isearch-message isearch-success isearch-forward 3 4 5 6 7 8 9 10 11 isearch-other-end isearch-word isearch-invalid-regexp isearch-wrapped isearch-barrier isearch-within-brackets isearch-case-fold-search] 3]) (defalias 'isearch-pop-state #[nil "A\301 \207" [isearch-cmds isearch-top-state] 1]) (defalias 'isearch-push-state #[nil " `\n \f  \n\257\f B\211 \207" [isearch-string isearch-message isearch-success isearch-forward isearch-other-end isearch-word isearch-invalid-regexp isearch-wrapped isearch-barrier isearch-within-brackets isearch-case-fold-search isearch-cmds] 12]) (defalias 'isearch-message #[(&optional c-q-hack ellipsis) "\306 \n# \307 \"Q \203\f\202\310 \311\312\f\")*\207" [ellipsis c-q-hack isearch-nonincremental isearch-message m cursor-in-echo-area isearch-message-prefix isearch-message-suffix nil message "%s" message-log-max] 6]) (defalias 'isearch-message-prefix #[(&optional c-q-hack ellipsis nonincremental) "\203 \203 \306\307\310\217\210\n\204\306\n\203\311\202\312 \2051\f\203*` V\202-` W\2051\313 \2056\314\203?\315\202@\311\203I\316\202J\311\203S\317\202T\320\f\203\\\311\202]\321\203j\322\323Q\202k\324\260\211\325\326O\226\326\306OP)\207" [isearch-invalid-regexp ellipsis isearch-success isearch-wrapped isearch-forward isearch-opoint nil (byte-code "\303`\304#\210\305\305\305\207" [isearch-string isearch-invalid-regexp isearch-within-brackets re-search-forward t nil] 4) ((error)) "" "failing " "over" "wrapped " "word " "regexp " "search" "I-search" " backward" " [" "]: " ": " 0 1 isearch-word isearch-regexp nonincremental current-input-method current-input-method-title m] 11]) (defalias 'isearch-message-suffix #[(&optional c-q-hack ellipsis) "\203\302\202 \303 \203\304 \305Q\202\303P\207" [c-q-hack isearch-invalid-regexp "^Q" "" " [" "]"] 4]) (defalias 'isearch-search #[nil "\306\307\310\"\210\310=\203 \203\311\n \"\312\313\314\217\210\f?\205-\315 @8\203(\316 \210\317 @8b\207" [isearch-case-fold-search search-upper-case isearch-string isearch-regexp isearch-success isearch-cmds isearch-message nil t isearch-no-upper-case-p lossage (byte-code "\306 \307\203\306\306\n\203v\203)\203%\310\202E\311\202E\203;\2037\312\202E\313\202E\203D\314\202E\315\306\307#\307=\204p\203po\204pm\204p\316\224\316\225U\204p\317\316\224\316\225\"\204\306\211\204\306\203\214\203\210\316\224\202\212\316\225,\306\207" [search-invisible isearch-case-fold-search retry case-fold-search inhibit-quit inhibit-point-motion-hooks nil t word-search-forward word-search-backward re-search-forward re-search-backward search-forward search-backward 0 isearch-range-invisible isearch-regexp isearch-invalid-regexp isearch-within-brackets isearch-word isearch-forward isearch-string isearch-success isearch-just-started isearch-other-end] 5) ((quit (byte-code "\301\302!\210\303\303\207" [isearch-success isearch-unread 7 nil] 2)) (invalid-regexp (byte-code "A@\303\304 \"\303\305 \"\203\306\303\207" [lossage isearch-invalid-regexp isearch-within-brackets string-match "\\`Unmatched \\[" "\\`Premature \\|\\`Unmatched \\|\\`Invalid " "incomplete input"] 3)) (error (byte-code "\302\303\"\302\207" [lossage isearch-invalid-regexp format "%s"] 3))) 3 ding 2] 3]) (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 (#$ . 38286)]) (defalias 'isearch-close-unnecessary-overlays #[(begin end) "\306 \306\211\203\\ @\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 #1=#:--dolist-temp--97269 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\352\212b\210\n\306=\307\211\203 \203\310 \"\210` W\203\311\311`\312\"\313=\2036\202C>\206C\236)\203\311\314`\312\"\203[\315`\312\307 $b\210\307\202\f\203\301\316`!\307\211\211\211\203\266@\317\312\"\313=\203\211\202\226>\204\231\236\203\255\317\320\"\203\253B\202\255\307A\211\204q\f\203\300\321 \",\322`!b\210\202` Y\205\351\f\203\350 :\203\350\321 \"\323\324 \"\210\307\202\351\313+\207" [beg end search-invisible crt-overlays can-be-opened isearch-hide-immediately open nil isearch-close-unnecessary-overlays get-char-property invisible t get-text-property next-single-property-change overlays-at overlay-get isearch-open-invisible append next-overlay-change mapc isearch-open-overlay-temporary prop buffer-invisibility-spec invis-prop o ov-list overlays isearch-opened-overlays] 6 (#$ . 39079)]) (byte-code "\301B\302\301!\204\f\303\303\207" [current-load-list isearch-overlay boundp nil] 2) (defalias 'isearch-highlight #[(beg end) "\205 \203\305 \n p$\207\306\n \"\307 \310\f#\210\307 \311\312#\207" [search-highlight isearch-overlay beg end isearch move-overlay make-overlay overlay-put face priority 1] 5]) (defalias 'isearch-dehighlight #[(totally) "\205\301!\207" [isearch-overlay delete-overlay] 2]) #@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\n\203( \310=\203(\f?\2025\f\2045 \211\227=\2045\311) T\202 ,?\207" [string found len i quote-flag char nil 0 92 t regexp-flag] 4 (#$ . 40519)]) (defalias 'isearch-text-char-description #[(c) "\301W\203 \302\303\304\\\"\207\305U\203\306\207\307!\207" [c 32 format "^%c" 64 127 "^?" char-to-string] 4]) (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]) (byte-code "\300\301!\210\302\303\304\305\306\307\310\311\312\313& \207" [require timer custom-declare-group isearch-lazy-highlight nil "Lazy highlighting feature for incremental search." :prefix "isearch-lazy-highlight-" :version "21.1" :group isearch] 10) #@240 *Controls the lazy-highlighting during incremental searches. When non-nil, all text in the buffer matching the current search string is highlighted lazily (see `isearch-lazy-highlight-initial-delay' and `isearch-lazy-highlight-interval'). (custom-declare-variable 'isearch-lazy-highlight 't '(#$ . -41539) :type 'boolean :group 'isearch-lazy-highlight) #@165 *Controls whether to remove extra highlighting after a search. If this is nil, extra highlighting can be "manually" removed with \[isearch-lazy-highlight-cleanup]. (custom-declare-variable 'isearch-lazy-highlight-cleanup 't '(#$ . -41899) :type 'boolean :group 'isearch-lazy-highlight) #@68 *Seconds to wait before beginning to lazily highlight all matches. (custom-declare-variable 'isearch-lazy-highlight-initial-delay '0.25 '(#$ . -42191) :type 'number :group 'isearch-lazy-highlight) #@58 *Seconds between lazily highlighting successive matches. (custom-declare-variable 'isearch-lazy-highlight-interval '0 '(#$ . -42394) :type 'number :group 'isearch-lazy-highlight) #@228 *Maximum matches to highlight at a time (for `isearch-lazy-highlight'). Larger values may reduce isearch's responsiveness to user input; smaller values make matches highlight slowly. A value of nil means highlight all matches. (custom-declare-variable 'isearch-lazy-highlight-max-at-a-time '20 '(#$ . -42580) :type '(choice (const :tag "All" nil) (integer :tag "Some")) :group 'isearch-lazy-highlight) (byte-code "\306\307\310\311\312\313\314\301&\210\315\301\316\317\314\307%\210\301B\320\301!\204\301\315\302\321\322\314\307%\210\302B\320\302!\2043\302\303B\320\303!\204?\310\304B\320\304!\204K\310\305B\320\305!\204W\310\323B\320\323!\204d\310\324B\320\324!\204q\310\325B\320\325!\204~\310\326B\320\326!\204\213\310\327B\320\327!\204\230\310\330B\320\330!\204\245\310\331B\320\331!\204\262\310\310\207" [current-load-list isearch isearch-lazy-highlight-face isearch-lazy-highlight-overlays isearch-lazy-highlight-wrapped isearch-lazy-highlight-start custom-declare-group isearch-faces nil "Lazy highlighting feature for incremental search." :version "21.1" :group custom-declare-face ((((type tty pc) (class color)) (:background "magenta4" :foreground "cyan1")) (((class color) (background light)) (:background "magenta4" :foreground "lightskyblue1")) (((class color) (background dark)) (:background "palevioletred2" :foreground "brown4")) (t (:inverse-video t))) "Face for highlighting Isearch matches." boundp ((((type tty pc) (class color)) (:background "turquoise3")) (((class color) (background light)) (:background "paleturquoise")) (((class color) (background dark)) (:background "paleturquoise4")) (t (:underline t))) "Face for lazy highlighting of Isearch matches other than the current one." isearch-lazy-highlight-end isearch-lazy-highlight-timer isearch-lazy-highlight-last-string isearch-lazy-highlight-window isearch-lazy-highlight-window-start isearch-lazy-highlight-case-fold-search isearch-lazy-highlight-regexp] 8) #@265 Stop lazy highlighting and remove extra highlighting from current buffer. FORCE non-nil means do it whether or not `isearch-lazy-highlight-cleanup' is nil. This function is called when exiting an incremental search if `isearch-lazy-highlight-cleanup' is non-nil. (defalias 'isearch-lazy-highlight-cleanup #[(&optional force) "\204 \203\n\203\304\n@!\210\nA\211\204\f \205#\305 !\210\306\211\207" [force isearch-lazy-highlight-cleanup isearch-lazy-highlight-overlays isearch-lazy-highlight-timer delete-overlay cancel-timer nil] 3 (#$ . 44580) '(t)]) #@190 Cleanup any previous `isearch-lazy-highlight' loop and begin a new one. This happens when `isearch-update' is invoked (which can cause the search string to change or the window to scroll). (defalias 'isearch-lazy-highlight-new-loop #[nil "\205Y\306\307!\205Y \n\232\203.\310 =\203.\f =\203.=\203.\311 U?\205Y\312\313!\210?\205Y\310 \311 ``  \314\315\314\316#\211\207" [isearch-lazy-highlight 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 isearch-lazy-highlight-cleanup t nil run-with-idle-timer isearch-lazy-highlight-update isearch-lazy-highlight-regexp isearch-regexp isearch-lazy-highlight-window-start isearch-invalid-regexp isearch-lazy-highlight-start isearch-lazy-highlight-end isearch-lazy-highlight-wrapped isearch-lazy-highlight-initial-delay isearch-lazy-highlight-timer] 4 (#$ . 45149)]) #@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 " \203 \306\202\n\203\307\202\310 \203 @\202 A\f \2034 \203/\202@\311 \202@ \203>\202@\312 \313#*\207" [isearch-case-fold-search isearch-word isearch-regexp choices case-fold-search isearch-forward (word-search-forward . word-search-backward) (re-search-forward . re-search-backward) (search-forward . search-backward) window-end window-start t isearch-string isearch-lazy-highlight-wrapped isearch-lazy-highlight-start isearch-lazy-highlight-end] 4 (#$ . 46131)]) #@58 Update highlighting of other matches for current search. (defalias 'isearch-lazy-highlight-update #[nil "\306\307\212\310 \311\216 \203\202b\210\n\203\254\312  \2030 S\211\313X\2030\307\203\202\313\224\313\225\211U\203J\314u\210\202q\315\"\316\317#\210\316\320\313#\210\316\321\322 #\210B) \203{`\202~`*\202\250\203\216\307\306\202\250\306 \203\240\323 \323 b\210\202\250\324 \324 b\210)\202 ?\205\272\325 \307\326#\211!.\207" [isearch-lazy-highlight-max-at-a-time nomore looping max save-match-data-internal isearch-forward t nil match-data ((set-match-data save-match-data-internal)) isearch-lazy-highlight-search 0 1 make-overlay overlay-put face priority window selected-window window-start window-end run-at-time isearch-lazy-highlight-update isearch-lazy-highlight-end isearch-lazy-highlight-start found me mb ov isearch-lazy-highlight-face isearch-lazy-highlight-overlays isearch-lazy-highlight-wrapped isearch-lazy-highlight-interval isearch-lazy-highlight-timer] 5 (#$ . 46812)]) #@348 Resume an incremental search. SEARCH 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 #[(search regexp word forward message case-fold) "\306 \307\211\n%\210   \n \310 \207" [forward regexp word search isearch-string message isearch-mode nil isearch-search isearch-message case-fold isearch-case-fold-search] 6 (#$ . 47886)])