;ELC ;;; Compiled by cyd@localhost on Mon Apr 23 22:20:55 2007 ;;; from file /home/cyd/emacs/lisp/isearch.el ;;; in Emacs version 22.0.99 ;;; 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 '(#$ . -776) :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 '(#$ . -947) :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 '(#$ . -1303) :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 '(#$ . -1578) :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 '(#$ . -2044) :type 'boolean :group 'isearch) #@534 *If non-nil, regular expression to match a sequence of whitespace chars. This applies to regular expression incremental search. When you put a space or spaces in the incremental regexp, it stands for this, unless it is inside of a regexp construct such as [...] or *, + or ?. 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 `]+'. When this is nil, each space you type matches literally, against one space. (custom-declare-variable 'search-whitespace-regexp '"\\s-+" '(#$ . -2367) :type '(choice (const :tag "Find Spaces Literally" nil) regexp) :group 'isearch) #@472 If t incremental search can match hidden text. A nil value means don't match invisible text. When 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'.) See also `reveal-mode' if you want overlays to automatically be opened whenever point is in one of them. (custom-declare-variable 'search-invisible ''open '(#$ . 3062) :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 '(#$ . 3748) :type 'boolean :group 'isearch) #@154 *If non-nil, `isearch-resume' commands are added to the command history. This allows you to resume earlier isearch sessions through the command history. (custom-declare-variable 'isearch-resume-in-command-history 'nil '(#$ . -4186) :type 'boolean :group 'isearch) #@62 Function(s) to call after starting up an incremental search. (defvar isearch-mode-hook nil (#$ . 4456)) #@164 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 quit the search. (defvar isearch-mode-end-hook nil (#$ . 4567)) #@72 Non-nil while running `isearch-mode-end-hook' if user quit the search. (defvar isearch-mode-end-hook-quit nil (#$ . 4783)) #@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 (#$ . 4913)) #@99 Function to save a function restoring the mode-specific isearch state to the search status stack. (defvar isearch-push-state-function nil (#$ . 5148)) #@34 List of search string sequences. (defvar search-ring nil (#$ . 5305)) #@53 List of regular expression search string sequences. (defvar regexp-search-ring nil (#$ . 5381)) #@72 *Maximum length of search ring before oldest elements are thrown away. (custom-declare-variable 'search-ring-max '16 '(#$ . -5483) :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 '(#$ . -5652) :type 'integer :group 'isearch) #@70 Index in `search-ring' of last string reused. It is nil if none yet. (defvar search-ring-yank-pointer nil (#$ . 5835)) #@77 Index in `regexp-search-ring' of last string reused. It is nil if none yet. (defvar regexp-search-ring-yank-pointer nil (#$ . 5960)) #@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 '(#$ . -6100) :type 'boolean :group 'isearch) #@65 *Non-nil means incremental search highlights the current match. (custom-declare-variable 'search-highlight 't '(#$ . -6329) :type 'boolean :group 'isearch) (byte-code "\301\302\303\304\305\302\305\306&\210\302B\307\302!\204\310\302\211\"\210\301\207" [current-load-list custom-declare-face isearch ((((class color) (min-colors 88) (background light)) (:background "magenta3" :foreground "lightskyblue1")) (((class color) (min-colors 88) (background dark)) (:background "palevioletred2" :foreground "brown4")) (((class color) (min-colors 16)) (:background "magenta4" :foreground "cyan1")) (((class color) (min-colors 8)) (:background "magenta4" :foreground "cyan1")) (t (:inverse-video t))) "Face for highlighting Isearch matches." :group basic-faces default-boundp set-default] 8) #@222 *Controls the lazy-highlighting during incremental search. When non-nil, all text in the buffer matching the current search string is highlighted lazily (see `lazy-highlight-initial-delay' and `lazy-highlight-interval'). (custom-declare-variable 'isearch-lazy-highlight 't '(#$ . -7122) :type 'boolean :group 'lazy-highlight :group 'isearch) (custom-declare-group 'lazy-highlight nil "Lazy highlighting feature for matching strings." :prefix "lazy-highlight-" :version "21.1" :group 'isearch :group 'matching) #@157 *Controls whether to remove extra highlighting after a search. If this is nil, extra highlighting can be "manually" removed with \[lazy-highlight-cleanup]. (custom-declare-variable 'lazy-highlight-cleanup 't '(#$ . -7639) :type 'boolean :group 'lazy-highlight) (byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defvaralias isearch-lazy-highlight-cleanup lazy-highlight-cleanup nil make-obsolete-variable "22.1"] 4) #@68 *Seconds to wait before beginning to lazily highlight all matches. (custom-declare-variable 'lazy-highlight-initial-delay '0.25 '(#$ . -8067) :type 'number :group 'lazy-highlight) (byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defvaralias isearch-lazy-highlight-initial-delay lazy-highlight-initial-delay nil make-obsolete-variable "22.1"] 4) #@58 *Seconds between lazily highlighting successive matches. (custom-declare-variable 'lazy-highlight-interval '0 '(#$ . -8426) :type 'number :group 'lazy-highlight) (byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defvaralias isearch-lazy-highlight-interval lazy-highlight-interval nil make-obsolete-variable "22.1"] 4) #@220 *Maximum matches to highlight at a time (for `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 'lazy-highlight-max-at-a-time '20 '(#$ . -8758) :type '(choice (const :tag "All" nil) (integer :tag "Some")) :group 'lazy-highlight) (byte-code "\301\302\303\304#\210\305\302\303\306#\210\307\310\311\312\313\310\313\314&\210\315\316\317\310#\210\320B\321\320!\204,\322\320\310\"\210\301\316\320\304#\210\305\316\320\306#\207" [current-load-list defvaralias isearch-lazy-highlight-max-at-a-time lazy-highlight-max-at-a-time nil make-obsolete-variable "22.1" custom-declare-face lazy-highlight ((((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." :group basic-faces put isearch-lazy-highlight-face face-alias lazy-highlight-face default-boundp set-default] 8) #@28 Keymap for `isearch-mode'. (defvar isearch-mode-map (byte-code "\306\307 \310 A@!\204\311 A@!\204\312\313!\210\314 A@\211\2032\315\n @\316#\210 A\211\204$*\317 \320\321#\210\322W\203O\317 \323\324\"\321#\210T\211\202:\322\211\325W\203f\317 \326!\316#\210T\211\202R\327 \317 \330 !\f#\210\317 \331\f#\210)\317 \326 \332\"\333#\210\317 \334\335#\210\317 \336\337#\210\317 \340\335#\210\317 \341\337#\210\317 \342\343#\210\317 \344\345#\210 \346U\204\257\312\347!\210\317 \350\351#\210\317 \352\351#\210\317 \353\354#\210\317 \355\356#\210\317 \357\316#\210\317 \360\316#\210\317 \361\316#\210\317 \362\363#\210\317 \364\365#\210\317 \366\367#\210\317 \370\371#\210\317 \372\373#\210\317 \374\375#\210\317 \376\377#\210\317 \201@\201A#\210\317 \201B\201C#\210\317 \201D\201C#\210\317 \201E\201C#\210\317 \201F\201C#\210\317 \201G\201C#\210\317 \201H\201C#\210\317 \201I\201J#\210\317 \201K\201L#\210\317 \201M\201N#\210\317 \201O\201C#\210\317 \201P\201Q#\210\317 \201R\201S#\210\317 \201T\201U#\210\317 \201V\201W#\210\317 \201X\201Y#\210 *\207" [i map table l meta-map meta-prefix-char 0 make-keymap vectorp 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 1 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" " " [33554464] "" isearch-yank-word-or-char "\227" isearch-del-char "\231" isearch-yank-char "" isearch-yank-line "\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] [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 [134217765] isearch-query-replace [201326629] isearch-query-replace-regexp] 6) (#$ . 9993)) #@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) (#$ . 12302)) (byte-code "\301B\302\301!\204\303\301\304\"\210\305B\302\305!\204\303\305\304\"\210\306B\302\306!\204-\303\306\304\"\210\307B\302\307!\204<\303\307\304\"\210\304\207" [current-load-list isearch-forward default-boundp set-default nil isearch-regexp isearch-word isearch-hidden] 3) #@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 (#$ . 13121)) (byte-code "\304B\305\304!\204\306\304\307\"\210\310B\305\310!\204\306\310\307\"\210\311B\305\311!\204-\306\311\312\"\210\313B\305\313!\204<\306\313\314\"\210\315B\305\315!\204K\306\315\314\"\210\316B\305\316!\204Z\306\316\314\"\210\317B\305\317!\204i\306\317\320\"\210\321B\305\321!\204x\306\321\314\"\210\322B\305\322!\204\207\306\322\320\"\210\323B\305\323!\204\226\306\323\314\"\210\324B\305\324!\204\245\306\324\314\"\210\325B\305\325!\204\264\306\325\314\"\210\326B\305\326!\204\303\306\326\314\"\210\327B\305\327!\204\322\306\327\314\"\210\330B\305\330!\204\341\306\330\314\"\210\331B\305\331!\204\360\306\331\320\"\210\332B\305\332!\204\377\306\332\314\"\210\333B\305\333!\204\306\333\314\"\210\334B\305\334!\204\306\334\314\"\210\335B\305\335!\204,\306\335\314\"\210\336B\305\336!\204;\306\336\314\"\210\337B\305\337!\204J\306\337\314\"\210\340B\305\340!\204Y\306\340\314\"\210\341B\305\341!\204h\306\341\314\"\210\342B\305\342!\204w\306\342\314\"\210\343 \236\204\202 \344C\244\210\343B\305\343!\204\221\306\343\314\"\210\345\343!\210\346\n\347\350#\210\346 \347\351#\210\346\n\352\353#\210\346 \352\354#\207" [current-load-list minor-mode-alist global-map esc-map isearch-string default-boundp set-default "" isearch-message isearch-success t isearch-error nil isearch-other-end isearch-wrapped isearch-barrier 0 isearch-just-started isearch-start-hscroll isearch-case-fold-search isearch-last-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 isearch-forward-regexp "" isearch-backward isearch-backward-regexp] 4) #@2915 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 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-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-query-replace] to start `query-replace' with string to replace from last search string. Type \[isearch-query-replace-regexp] to start `query-replace-regexp' with string to replace from last search string. 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 \[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 (#$ . 15363) "P\np"]) #@471 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. In regexp incremental searches, a space or spaces normally matches any whitespace (the variable `search-whitespace-regexp' controls precisely what that means). If you want to search for a literal space and nothing else, enter C-q SPC. (defalias 'isearch-forward-regexp #[(&optional not-regexp no-recursive-edit) "\302\303?\304 ?$\207" [not-regexp no-recursive-edit isearch-mode t nil] 5 (#$ . 18449) "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 (#$ . 19101) "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 (#$ . 19413) "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\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 \210\333 \210FG\334 \210\335\336!\210\337\340\341\"\210\337\342\341\"\210#\203\322\310H\343 \210),\207" [forward isearch-forward regexp isearch-regexp word-p 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 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 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 (#$ . 19950)]) (defalias 'isearch-update #[nil "\204\250 \204\250\306 \204\307 \210\n\203o \204o\310 \204o`\311\312\313!\210\314\315\316\313W\2037[T\202=\317 TZ\"\210)\313W\203d\320\314Z!\210\321\322 `\"\210\323\322 \324 \"\210\323\325 \313\"\210\202h\326\314!\210\fb\210)\202\207\324 \323\325 \"\210\310 \204\206\323\325 \"\210)\203\245`W\203\234\327`\"\210\202\250\327`\"\210\202\250\330 \210\316\211 \203\266\331 \210\311\211!\207" [unread-command-events executing-kbd-macro isearch-slow-terminal-mode isearch-small-window found-point window-min-height 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 search-slow-window-lines current-scroll isearch-start-hscroll isearch-other-end isearch-adjusted isearch-yank-flag isearch-lazy-highlight disable-point-adjustment] 5]) #@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\203v1\202z\324\325!\210\326 \210m?\205\206\327`\330\"o?\205\220\327`S\330\"232\203\2713\203\27123=\203\271\f\203\263\331`\330\"b\210\202\271\332`\330\"b\210* G\333V\203\3134\204\313\334 \n\"\2104\205\3235?6\335\336!\210)`7U\2048\203\3539\204\3377\323\"\210:\204\340 \333V\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 (#$ . 22883)]) #@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 (#$ . 24791)]) #@36 Return the search string in FRAME. (defalias 'isearch-string-state #[(frame) "\301H\207" [frame 0] 2 (#$ . 25124)]) (put 'isearch-string-state 'byte-optimizer 'byte-compile-inline-expand) #@59 Return the search string to display to the user in FRAME. (defalias 'isearch-message-state #[(frame) "\301H\207" [frame 1] 2 (#$ . 25319)]) (put 'isearch-message-state 'byte-optimizer 'byte-compile-inline-expand) #@28 Return the point in FRAME. (defalias 'isearch-point-state #[(frame) "\301H\207" [frame 2] 2 (#$ . 25539)]) (put 'isearch-point-state 'byte-optimizer 'byte-compile-inline-expand) #@35 Return the success flag in FRAME. (defalias 'isearch-success-state #[(frame) "\301H\207" [frame 3] 2 (#$ . 25724)]) (put 'isearch-success-state 'byte-optimizer 'byte-compile-inline-expand) #@45 Return the searching-forward flag in FRAME. (defalias 'isearch-forward-state #[(frame) "\301H\207" [frame 4] 2 (#$ . 25920)]) (put 'isearch-forward-state 'byte-optimizer 'byte-compile-inline-expand) #@45 Return the other end of the match in FRAME. (defalias 'isearch-other-end-state #[(frame) "\301H\207" [frame 5] 2 (#$ . 26126)]) (put 'isearch-other-end-state 'byte-optimizer 'byte-compile-inline-expand) #@42 Return the search-by-word flag in FRAME. (defalias 'isearch-word-state #[(frame) "\301H\207" [frame 6] 2 (#$ . 26336)]) (put 'isearch-word-state 'byte-optimizer 'byte-compile-inline-expand) #@74 Return the regexp error message in FRAME, or nil if its regexp is valid. (defalias 'isearch-error-state #[(frame) "\301H\207" [frame 7] 2 (#$ . 26533)]) (put 'isearch-error-state 'byte-optimizer 'byte-compile-inline-expand) #@42 Return the search-wrapped flag in FRAME. (defalias 'isearch-wrapped-state #[(frame) "\301H\207" [frame 8] 2 (#$ . 26764)]) (put 'isearch-wrapped-state 'byte-optimizer 'byte-compile-inline-expand) #@36 Return the barrier value in FRAME. (defalias 'isearch-barrier-state #[(frame) "\301H\207" [frame 9] 2 (#$ . 26967)]) (put 'isearch-barrier-state 'byte-optimizer 'byte-compile-inline-expand) #@40 Return the case-folding flag in FRAME. (defalias 'isearch-case-fold-search-state #[(frame) "\301H\207" [frame 10] 2 (#$ . 27164)]) (put 'isearch-case-fold-search-state 'byte-optimizer 'byte-compile-inline-expand) #@73 Return the function restoring the mode-specific isearch state in FRAME. (defalias 'isearch-pop-fun-state #[(frame) "\301H\207" [frame 11] 2 (#$ . 27384)]) (put 'isearch-pop-fun-state 'byte-optimizer 'byte-compile-inline-expand) (defalias 'isearch-top-state #[nil "@\211\211\306H) \211\307H) \211\310H) \211\311H) \211\312H) \211\313H) \211\314H) \211\315H) \211\316H) \211\317H)\320 \211\321H)!\203d \211\321H) !\210 \211\322H)b)\207" [isearch-cmds cmd frame isearch-string isearch-message isearch-success 0 1 3 4 5 6 7 8 9 10 functionp 11 2 isearch-forward isearch-other-end isearch-word isearch-error isearch-wrapped isearch-barrier isearch-case-fold-search] 4]) (defalias 'isearch-pop-state #[nil "A\301 \207" [isearch-cmds isearch-top-state] 1]) (defalias 'isearch-push-state #[nil "\306 `\n \f  \n \205 &\f\fB\211\f\207" [isearch-string isearch-message isearch-success isearch-forward isearch-other-end isearch-word vector isearch-error isearch-wrapped isearch-barrier isearch-case-fold-search isearch-push-state-function isearch-cmds] 13]) #@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 (#$ . 28487) nil]) #@602 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-complete-edit] to complete the search string using the search ring. \ If first char entered is \[isearch-yank-word-or-char], then do word search instead. (defalias 'isearch-edit-string #[nil "\300\301\302\217\207" [err (byte-code " \n \f !\"#$%&'()*+,\306 -\211-./,+*)('&%$#\"!0123\307\310\311\217\210\302 \210\312\216\3134\314 )5\315\21167\316\317\320\315\211\313#\"\210\3218\3225!\"\323>\203\201\313\2110\202\211\324 \210\3255!\210\3154\326\320\315\211# 9\315 \203\236\327\202\237\330\315\313&3\331\3323\333#2, G\334U\203\314 \203\276\202\300@\206\305\333\331\332 \333#.\335 \210\336 \210\337 \210\205\347\340 \210 \333\232\205\347\316\333!\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 "%s" isearch-message-prefix lookup-key vector (isearch-yank-word isearch-yank-word-or-char) cancel-kbd-macro-events isearch-unread read-from-minibuffer regexp-search-ring search-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-error 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] 22) ((quit (isearch-abort)))] 3 (#$ . 28935) 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 "\303\304!@\211\305H)!\203\304!@\211\305H)\304!@!\210\nb\210\306\307!\210\310 \210\311\312\313\"\207" [isearch-cmds frame isearch-opoint functionp last 11 isearch-done t isearch-clean-overlays signal quit nil] 4 (#$ . 31772) 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\f\303\304 \207\203 \203\305 \210\202\f\306 \207" [isearch-success isearch-error discard-input nil isearch-cancel isearch-pop-state isearch-update] 1 (#$ . 32105) nil]) (defalias 'isearch-repeat #[(direction) " \306==\203\\\n\307\232\203: \203\f\202 \204 \310\202b \203)\f@\202+ @\311\312\n\307#\202b\204b\313\203N \210\202b\203Ve\202Wdb\210\202b?\313`\n\307\232\203q\313\202\253\203\250`\232\203\250\204\250\203\212m\202\213o\203\227\314\315 \210\202\253\203\237\316\202\240\317u\210\320 \210\202\253\320 \210\321 \210\322 \207" [isearch-forward direction isearch-string isearch-regexp regexp-search-ring search-ring forward "" "No previous search string" mapconcat isearch-text-char-description t nil 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 (#$ . 33384) nil]) #@38 Repeat incremental search backwards. (defalias 'isearch-repeat-backward #[nil "\300\301!\207" [isearch-repeat backward] 2 (#$ . 33528) 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 (#$ . 33675) nil]) #@45 Toggle case folding in searching on or off. (defalias 'isearch-toggle-case-fold #[nil "?\205\306\307\310\311\312\307\211\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] 7 (#$ . 33900) nil]) #@69 Start query-replace with string to replace from last search string. (defalias 'isearch-query-replace #[(&optional regexp-flag) "\306 \210\203 \307\n\310 \210\311 \210\f\203.\f`W\203. \203+\203+\312 `W\204.\fb\210JBL\210\313\314 \203F\315\202G\316 #\307 \317\211 \205Z\205Z\320 \205e\205e\321 & )\207" [regexp-flag isearch-regexp isearch-case-fold-search case-fold-search isearch-other-end transient-mark-mode barf-if-buffer-read-only t isearch-done isearch-clean-overlays mark perform-replace query-replace-read-to "Query replace regexp" "Query replace" nil region-beginning region-end mark-active query-replace-from-history-variable isearch-string isearch-word] 10 (#$ . 34332) nil]) #@76 Start query-replace-regexp with string to replace from last search string. (defalias 'isearch-query-replace-regexp #[nil "\300\301!\207" [isearch-query-replace t] 2 (#$ . 35057) 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 (#$ . 35247) 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#\312\313 \207" [isearch-string arg isearch-message isearch-yank-flag 0 ding 1 mapconcat isearch-text-char-description "" t isearch-search-and-update] 4 (#$ . 35496) "p"]) #@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 (#$ . 35882)]) #@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 (#$ . 36272) 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 (#$ . 36439) 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) "\211:\203 \306 8\202\307 `\310\311F)\311\n8)\312\313\314 \315\"\316 !\2033\317 !\2043\320 \202<\321 !\205<\322 !+\207" [click event position w overriding-terminal-local-map binding 1 selected-window (0 . 0) 0 nil key-binding this-command-keys-vector t window-minibuffer-p minibuffer-window-active-p isearch-yank-x-selection functionp call-interactively] 5 (#$ . 36609) "e"]) #@319 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 (#$ . 37234)]) #@74 Pull next character from buffer into end of search string in minibuffer. (defalias 'isearch-yank-char-in-minibuffer #[(&optional arg) "m\203\212\302 \211A@)q\210\303` u\210`\")c\207 u\207" [x arg buffer-list buffer-substring-no-properties] 4 (#$ . 37764) "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 (#$ . 38034) "p"]) #@61 Pull next character or word from buffer into search string. (defalias 'isearch-yank-word-or-char #[nil "\300\301!\207" [isearch-yank-internal #[nil "\300f\206\301z\302U\204`Tf\206\301z\302U\203\303v\210\202\"\303u\210`\207" [nil 0 119 1] 2]] 2 (#$ . 38229) 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 (#$ . 38507) 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 (#$ . 38686) 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\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-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 (#$ . 39777)]) #@515 Return point to previous successful match to allow regexp liberalization. \ 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\304\306 !?\n?=\205\304 \203&\f\211A@)\211 \307H)\203&\205\304\2034b\210\310\211\207\f\211A@ \203\217 \211 \307H)\204~ \211 \311H)\211\211GSH\306@\211 \311H)!\203v\312=\202z\313>*\203\217A@ \202@\205\303@\203\246@\211 \314H)\206\250\203\267]\202\274^b\210\310\211)+\207" [isearch-regexp isearch-string want-backslash isearch-error isearch-cmds x isearch-backslash 7 t 0 125 (42 63 43) 5 frame allow-invalid to-barrier isearch-barrier isearch-adjusted stack previous string lchar last-other-end isearch-forward] 4 (#$ . 39966)]) #@100 Unread the given key-sequence KEYLIST. Scroll-bar or mode-line events are processed appropriately. (defalias 'isearch-unread-key-sequence #[(keylist) "\305 \210\306\307\"\210G\310V\205[@9\205[\211A@)<\205[\211A@)\211:\2031\310\n8\2027\311 `\312\313F)\314 8\206P\310 8:\203M\310 8@\202P\310 8)\247?\205[\f\211A@\207" [keylist x event position unread-command-events cancel-kbd-macro-events apply isearch-unread 1 selected-window (0 . 0) 0 5] 5 (#$ . 41188)]) (byte-code "\300\301!\203\f\302\301\303\304#\210\300\305!\203\302\305\303\304#\210\300\306!\203$\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#\207" [fboundp scroll-bar-toolkit-scroll put isearch-scroll t mac-handle-scroll-bar-event w32-handle-scroll-bar-event recenter reposition-window scroll-up scroll-down 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-vertically split-window-horizontally enlarge-window universal-argument negative-argument digit-argument] 4) #@71 If non-nil, scrolling commands are allowed during incremental search. (custom-declare-variable 'isearch-allow-scroll 'nil '(#$ . 42587) :type 'boolean :group 'isearch) #@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 (#$ . 42762)]) #@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\202Nb\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 (#$ . 43509)]) #@113 Reread key sequence KEYLIST with Isearch mode's keymap deactivated. 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 (#$ . 44095)]) #@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=\205\n*\207" [overriding-terminal-local-map key-seq binding nil key-binding commandp isearch-scroll t] 3 (#$ . 44413)]) (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-, 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\216\313.\n\"\211/?\2069/\250\2069\314/!)\204\216\315 \210\3130\n\"\203R\316 \210\317\320\f\"\202\233\311\313.\n\"!\211\205\233\f@\211\250\203\203\n\321Y\203\203\n\322U\204\203\n\323W\203\203\324\n!\210\fA\211\202[\317\320\f\"\210\307\211\202[\325 !1 \250\205\275\3261>\205\275\3271>\205\275\3132\330\n!\2113\310 \331ZI\2103)\307#\332>?)\203\321\f \331Z\240\210\315 \210\317\320\f\"\202\2334\333=\203\342\317\320\f\"\210\334 \202\2335\203&\335\f!\311\n!\n\310H\336\n!\211\203&`-67\337 !\210\340-!\2118\203\3418\342=-\"\210\202 -b\210)\343 \202\2334\203\227\3079\344\f!\210:@;\204\210 <\203\210 \211<:\203O\312<8\202U\345 `\346\310F)=\310=8)\2119\203\210\3479!\203\210\350 \310V\204x\3519!\204\210\212\3529!q\210\316 \210\353 )\202\223\316 \210\353 \2106\2117)\202\233\354\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 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 isearch-unread-key-sequence selected-window (0 . 0) windowp minibuffer-depth window-minibuffer-p window-buffer isearch-clean-overlays isearch-process-search-string isearch-point function-key-map lookup global-map mods isearch-mode-map copy search-exit-option isearch-allow-scroll arg prefix-arg ab-bel window unread-command-events isearch-mode event position] 7 (#$ . 44801) "P"]) #@50 Quote special characters for incremental search. (defalias 'isearch-quote-char #[nil "\304\305\306!! \203%\307U\203%\310\n\211G\"\203\311\312\313\"\202<\314!\202< \2039\315Y\2039\316X\2039\317!\314!)\207" [char isearch-regexp 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 (#$ . 47495) nil]) #@53 Convert return into newline for incremental search. (defalias 'isearch-return-char #[nil "\300\301!\207" [isearch-process-search-char 10] 2 (#$ . 47969) nil]) (make-obsolete 'isearch-return-char 'isearch-printing-char) #@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 (#$ . 48194) 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!?\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 (#$ . 49844) nil]) #@52 Retreat to the previous search string in the ring. (defalias 'isearch-ring-retreat #[nil "\300\301!\207" [isearch-ring-adjust nil] 2 (#$ . 50002) nil]) (defalias 'isearch-complete1 #[nil "\203 \202 \n\f\306 \"\211\307=\203\307\202X\204*G\310U\203S\232\203F\203B\311\220\312\313 \"!\221\210\307\202X\205X\211\202X\314\315!\210\316+\207" [isearch-regexp regexp-search-ring search-ring ring case-fold-search completion-ignore-case try-completion t 0 "*Isearch completions*" display-completion-list all-completions message "No completion" nil 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 "\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 (#$ . 50638) 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 (#$ . 51086) nil]) (defalias 'isearch-message #[(&optional c-q-hack ellipsis) "\306 \n# \204#\307\310\f\"\203#\f\311\211\224O\312\f\311\224\313O\314\315#P\202$\f\316 \"Q \2034 \202<\313\317\320 \")*\207" [ellipsis c-q-hack isearch-nonincremental isearch-success isearch-message m isearch-message-prefix string-match " +$" 0 propertize nil face trailing-whitespace isearch-message-suffix message "%s" cursor-in-echo-area message-log-max] 7]) (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 \203$\313\202%\311\f\205B ?\205B\203:`V\202>`W\205B\314\f\205G\315\203P\316\202Q\311\203Z\317\202[\311\203d\320\202e\321\203n\311\202o\322 \203|\323!\324Q\202}\325\260 \"\326\"\327\330O\226\"\330\306OP\331\332#)\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 " "word " "regexp " "search" "I-search" " backward" " [" "]: " ": " propertize 0 1 face minibuffer-prompt isearch-forward isearch-opoint 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-error "^Q" "" " [" "]"] 4]) #@180 Override `isearch-search-fun'. This function should return the search function for isearch to use. It will call this function with three arguments as if it were `search-forward'. (defvar isearch-search-fun-function nil (#$ . 52797)) #@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 "\203 \207 \203\n\203\304\207\305\207 \203\n\203\306\207\307\207\n\203%\310\207\311\207" [isearch-search-fun-function isearch-word isearch-forward isearch-regexp word-search-forward word-search-backward re-search-forward re-search-backward search-forward search-backward] 1 (#$ . 53037)]) (defalias 'isearch-search-string #[(string bound noerror) "\306 G\307\211\212\f #)\310!\203\237\311! V\203\237\307\211\f \312W\203_HH\211\203U\204M\313!I\210)T\211\2020*\203\236\314 \315\216\212\f #\211\203}\314\316!\f+ \203\236\n\203\227\203\221 \nW\202\224 \nV\203\236 \317\f!\210*\n\203\246\nb\210\n,\207" [string pos2 pos1 len func bound isearch-search-fun nil char-table-p string-bytes 0 copy-sequence match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) t set-match-data noerror translation-table-for-input translated i #1=#:--cl-dotimes-temp-- x save-match-data-internal isearch-forward] 4]) (defalias 'isearch-search #[nil "\306\307\310\"\210\310=\203 \203\311\n \"\312\313\314\217\210\f?\205N @\211\315H)\203,\316 \210\317 @\211\320H)!\203E @\211\320H) @!\210 @\211\321H)b\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 \n\307 \f\306 \203E\310\306\307#\307=\204?\203?o\204?m\204?\311\224\311\225U\204?\312\311\224\311\225\"\204\306\211\204\306\203[\203W\311\224\202Y\311\225-\306\207" [search-invisible isearch-case-fold-search search-whitespace-regexp retry search-spaces-regexp case-fold-search nil t isearch-search-string 0 isearch-range-invisible inhibit-quit inhibit-point-motion-hooks isearch-error isearch-string isearch-success isearch-just-started isearch-forward isearch-other-end] 6) ((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))) 3 ding functionp 11 2 frame] 4]) (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 (#$ . 56469)]) (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=#:--cl-dolist-temp-- 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\355\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\354\f\203\350 :\203\350\321 \"\323\324 \"\210\307\202\354\313\211+\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 isearch-hidden] 6 (#$ . 57260)]) #@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 (#$ . 58296)]) (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 "\301B\302\301!\204\303\301\304\"\210\304\207" [current-load-list isearch-overlay default-boundp set-default nil] 3) (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 move-overlay make-overlay overlay-put priority 1001 face] 5]) (defalias 'isearch-dehighlight #[nil "\205\301!\207" [isearch-overlay delete-overlay] 2]) (byte-code "\301B\302\301!\204\303\301\304\"\210\305B\302\305!\204\303\305\304\"\210\306B\302\306!\204-\303\306\304\"\210\307B\302\307!\204<\303\307\304\"\210\310B\302\310!\204K\303\310\304\"\210\311B\302\311!\204Z\303\311\304\"\210\312B\302\312!\204i\303\312\304\"\210\313B\302\313!\204x\303\313\304\"\210\314B\302\314!\204\207\303\314\304\"\210\315B\302\315!\204\226\303\315\304\"\210\316B\302\316!\204\245\303\316\304\"\210\317B\302\317!\204\264\303\317\304\"\210\320B\302\320!\204\303\303\320\304\"\210\321B\302\321!\204\322\303\321\304\"\210\304\207" [current-load-list isearch-lazy-highlight-overlays default-boundp set-default nil isearch-lazy-highlight-wrapped isearch-lazy-highlight-start-limit isearch-lazy-highlight-end-limit isearch-lazy-highlight-start 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-window-end isearch-lazy-highlight-case-fold-search isearch-lazy-highlight-regexp isearch-lazy-highlight-space-regexp] 3) #@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 (#$ . 60886) '(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) "?\205y\306\307!\205y \n\232\2037\310 =\2037\f =\2037=\2037\311 U\2037\312 U?\205y\313\314!\210?\205y\310 \311 \312 ``  \315 \316\232?\205y\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-window-start isearch-lazy-highlight-window-end isearch-error beg isearch-lazy-highlight-start-limit end isearch-lazy-highlight-end-limit isearch-lazy-highlight-start isearch-lazy-highlight-end isearch-lazy-highlight-wrapped search-whitespace-regexp isearch-lazy-highlight-space-regexp lazy-highlight-initial-delay isearch-lazy-highlight-timer] 4 (#$ . 61572)]) #@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 " \n\306\307\310\217+\207" [isearch-lazy-highlight-case-fold-search isearch-lazy-highlight-regexp isearch-lazy-highlight-space-regexp search-spaces-regexp isearch-regexp case-fold-search nil (byte-code "\306 \203\n\206 d \203\f\202\307 ^\202* \206e \203'\n\202)\310 ]\311#\207" [isearch-lazy-highlight-last-string isearch-forward isearch-lazy-highlight-end-limit isearch-lazy-highlight-wrapped isearch-lazy-highlight-start isearch-lazy-highlight-start-limit isearch-search-string window-end window-start t isearch-lazy-highlight-end] 4) ((error))] 3 (#$ . 62884)]) #@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 \310\311\312 \"r\313\216\314 !\203\307 =\204\315 !\210\212\316 \317\216 \203.\2020 b\210!\203\320 \"#\203N#S\211#\321X\203N\306!\"\203\326\321\224\321\225$\211%$U\203\242 \203\204%&\203r \202t\322 U\203~\306\"\202\310\323u\210\202\310%&\203\220\202\222\324 U\203\234\306\"\202\310\325u\210\202\310\326%$\"\211'(B(\327'\330\331#\210\327'\332)#\210\327'\333\307 #\210) \203\322`\202\325` *\"\204&\203\351\306!\334*\202\334& \203\324 +\206\372e\324 ]b\210\202\322  ,\206\fd\322 ^b\210)\2022*?\205$\335-\306\336#\211..\207" [inhibit-quit save-selected-window-alist save-selected-window-window isearch-lazy-highlight-window save-match-data-internal isearch-forward nil selected-window mapcar #[(frame) "\301!D\207" [frame frame-selected-window] 3] frame-list ((byte-code "\305\211\203/\n@\306 @!\203(\307 \211A@)!\203(\310 @ \211A@)\"\210\nA\211\204*\307\f!\203:\311\f!\210\305\207" [save-selected-window-alist elt #1=#:--cl-dolist-temp-- x save-selected-window-window nil frame-live-p window-live-p set-frame-selected-window select-window] 4)) window-live-p 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-end 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 (#$ . 63656)]) #@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 (#$ . 65698)])