;ELC ;;; Compiled by rms@psilocin.ai.mit.edu on Tue Aug 18 03:45:43 1998 ;;; from file /gd/gnu/emacs/lisp/isearch.el ;;; in Emacs version 20.2.98.3 ;;; with bytecomp version 2.48 ;;; 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." :prefix "isearch-" :prefix "search-" :group 'matching) #@72 *Non-nil means random control characters terminate incremental search. (custom-declare-variable 'search-exit-option 't '(#$ . -725) :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 '(#$ . -896) :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 '(#$ . -1252) :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 '(#$ . -1527) :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 '(#$ . -1993) :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-+" '(#$ . -2316) :type 'regexp :group 'isearch) #@65 *Non-nil means incremental search highlights the current match. (custom-declare-variable 'search-highlight 't '(#$ . -2735) :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 '(#$ . 2898) :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 '(#$ . 3469) :type 'boolean :group 'isearch) #@62 Function(s) to call after starting up an incremental search. (defvar isearch-mode-hook nil (#$ . 3906)) #@62 Function(s) to call after terminating an incremental search. (defvar isearch-mode-end-hook nil (#$ . 4016)) #@34 List of search string sequences. (defvar search-ring nil (#$ . 4130)) #@53 List of regular expression search string sequences. (defvar regexp-search-ring nil (#$ . 4206)) #@72 *Maximum length of search ring before oldest elements are thrown away. (custom-declare-variable 'search-ring-max '16 '(#$ . -4308) :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 '(#$ . -4477) :type 'integer :group 'isearch) #@64 Index in `search-ring' of last string reused. nil if none yet. (defvar search-ring-yank-pointer nil (#$ . 4660)) #@71 Index in `regexp-search-ring' of last string reused. nil if none yet. (defvar regexp-search-ring-yank-pointer nil (#$ . 4779)) #@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 '(#$ . -4913) :type 'boolean :group 'isearch) #@26 Keymap for isearch-mode. (defvar isearch-mode-map nil (#$ . 5142)) (byte-code "\204U\306\307 \310\311\n8!\204\312\311\n8!\204\313\314!\210\315 \nA@\211\2036\316 \f@\317#\210\fA\211\204(*\320\n\321\322#\210 \323W\203S\320\n\324\311 \"\322#\210 T\211\202>\323\323\325W\203j\320\n\326 !\317#\210 T\211\202V\327 \320\n\330@! #\210\320\n\331 #\210)\320\n\326@\332\"\333#\210\320\n\334\335#\210\320\n\336\337#\210\320\n\340\341#\210\320\n\342\343#\210\344@U\204\252\313\345!\210\320\n\346\347#\210\320\n\350\347#\210\320\n\351\352#\210\320\n\353\354#\210\320\n\355\317#\210\320\n\356\317#\210\320\n\357\360#\210\320\n\361\360#\210\320\n\362\363#\210\320\n\364\365#\210\320\n\366\367#\210\320\n\370\367#\210\320\n\371\372#\210\320\n\373\374#\210\320\n\375\376#\210\320\n\377\201A#\210\320\n\201B\201C#\210\320\n\201D\201E#\210\320\n\201F\201E#\210\320\n\201G\201E#\210\320\n\201H\201E#\210\320\n\201I\201J#\210\320\n\201K\201L#\210\n*\201E\207" [isearch-mode-map i map table l meta-map 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 "" 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" meta-prefix-char isearch-yank-kill "\211" isearch-complete [switch-frame] nil [delete-frame] [iconify-frame] [make-frame-visible] "" isearch-toggle-input-method "" isearch-toggle-specified-input-method] 6) #@55 Keymap for editing isearch strings in the minibuffer. (defvar minibuffer-local-isearch-map nil (#$ . 7094)) (byte-code "\204/\306 !\307\n\310\311#\210\307\n\312\313#\210\307\n\314\315#\210\307\n\316\317#\210\307\n\320\321#\210\307\n\322\323#\210\n)\324\303!\2047\325\303\fB\324\305!\204C\325\305\fB\324\326!\204P\325\326\fB\324\327!\204]\325\327\fB\324\330!\204j\331\330\fB\324\332!\204w\331\332\fB\324\333!\204\204\334\333\fB\324\335!\204\221\325\335\fB\324\336!\204\236\325\336\fB\324\337!\204\253\325\337\fB\324\340!\204\270\325 \340\fB\324\341!\204\305\342!\341\fB\324\343!\204\322\325#\343\fB\324\344!\204\337\325$\344\fB\324\345!\204\354\325%\345\fB\324\346!\204\371\325&\346\fB\324\347!\204\325'\347\fB\324\350!\204\342(\350\fB\324\351!\204 \325)\351\fB\324\352!\204-\325*\352\fB\324\353!\204:\325+\353\fB\324\354!\204G\325,\354\fB\324\355!\204T\325-\355\fB\324\356!\204a\325.\356\fB\324\357!\204n\325/\357\fB\324\360!\204{\3250\360\fB\324\361!\204\210\3251\361\fB\3628\236\204\2318\363C\244\210\324\362!\204\242\3252\362\fB\364\362!\210\3079\320\303#\210\307:\320\365#\210\3079\322\366#\210\307:\322\367#\207" [minibuffer-local-isearch-map minibuffer-local-map map isearch-forward current-load-list isearch-regexp copy-keymap 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 boundp nil isearch-word isearch-cmds isearch-string "" 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-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 isearch-forward-regexp isearch-backward isearch-backward-regexp minor-mode-alist global-map esc-map] 4) #@1797 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 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. 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. 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 (#$ . 9359) "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 (#$ . 11326) "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 (#$ . 11741) "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 (#$ . 12053) "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-./X\205;\311 0\312_V1\3072\3073\3104`5\3076\3077\f8\313\314!9\307:9\204d\315\314!\210\307\f\316\306!\2101\205r\317 ;\320\321 !<\322\204\222\324\327 \210\330 \210?@\331 \210\332\333!\210\334\335\336\"\210\203\270\310A\337 \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 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 isearch-window-configuration frame minibuffer-auto-raise isearch-mode isearch-mode-map overriding-terminal-local-map isearch-recursive-edit] 3 (#$ . 12590)]) (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\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-other-end isearch-adjusted isearch-yank-flag] 4]) (defalias 'isearch-done #[(&optional nopush edit) "\306\307\310\"\210\311\312\313!\210\314\315 !` \203\316 !\210\f\203$ b\210\202+\317\315 \n\313#\210` U\204P\203;\204P\320 \313\"\210\204P\321 \322V\204P\323\324!\210*\311 \203`!\202d\325\326!\210\327 \210\"G\322V\203{#\204{\330\"$\"\210\331\332!\210%?\205\214&\205\214\333 \207" [overriding-terminal-local-map found-point found-start isearch-window-configuration isearch-small-window isearch-opoint remove-hook mouse-leave-buffer-hook isearch-done nil isearch-dehighlight t 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 isearch-update-ring run-hooks isearch-mode-end-hook exit-recursive-edit transient-mark-mode mark-active executing-kbd-macro isearch-mode isearch-input-method-local-p isearch-input-method-function isearch-string nopush isearch-regexp edit isearch-recursive-edit] 4]) #@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 (#$ . 16108)]) (defalias 'isearch-switch-frame-handler #[nil "\300 \210\301 \210\302\303 A@!\207" [isearch-done isearch-clean-overlays handle-switch-frame isearch-last-command-char] 2 nil nil]) #@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 (#$ . 16671) 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 ,+*)('&%$#\"! -./0\307\310\311\217\210\302 \210\312\216\3131\314 )2\3153\3154\316\317\315\211\313#!\210\3205\3212!\"\322=\203}\313\313-\202\205\323 \210\3242!\210\3151\315\325\317\315\211# 6\315\326%)0\327\3300\331#/, G\332U\203\273 \203\2637\202\2658@\206\272\331.\333 \210\334 \210\335 \210\205\314\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-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] 20) ((quit (isearch-abort)))] 3 (#$ . 17119) 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 (#$ . 20000) 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 (#$ . 20236) 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 (#$ . 21420) nil]) #@38 Repeat incremental search backwards. (defalias 'isearch-repeat-backward #[nil "\300\301!\207" [isearch-repeat backward] 2 (#$ . 21564) 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 (#$ . 21711) 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 (#$ . 21891) nil]) #@90 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 (#$ . 22302) 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 (#$ . 22552)]) #@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 (#$ . 22942) nil]) #@257 Pull current X selection into search string. Some users like to put this command on Mouse-2. To do that, evaluate these expressions: (define-key isearch-mode-map [down-mouse-2] nil) (define-key isearch-mode-map [mouse-2] 'isearch-yank-x-selection) (defalias 'isearch-yank-x-selection #[nil "\300\301 !\207" [isearch-yank-string x-get-selection] 2 (#$ . 23110) nil]) #@48 Pull next word from buffer into search string. (defalias 'isearch-yank-word #[nil "\302\212\204 \203 b\210`\303v\210`{)!\207" [isearch-forward isearch-other-end isearch-yank-string 1] 3 (#$ . 23490) nil]) #@51 Pull rest of line from buffer into search string. (defalias 'isearch-yank-line #[nil "\302\212\204 \203 b\210`\303 {)!\207" [isearch-forward isearch-other-end isearch-yank-string line-end-position] 3 (#$ . 23706) 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 "\304\n\203 \202\305 !!)\207" [isearch-case-fold-search case-fold-search isearch-regexp isearch-string looking-at regexp-quote] 3) ((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\315 !\207" [isearch-regexp isearch-string idx isearch-adjusted isearch-cmds cs 0 92 mod 2 t 5 isearch-process-search-char isearch-last-command-char isearch-barrier isearch-forward] 4 (#$ . 24707) nil]) #@43 If in regexp search, jump to the barrier. (defalias 'isearch-|-char #[nil "\203 \303\nb\210\304\305 !\207" [isearch-regexp isearch-adjusted isearch-barrier t isearch-process-search-char isearch-last-command-char] 2 (#$ . 25128) 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\203H\312 \"\211?\206$\f\250\206$\313\f!)\204H\314 \210\312 \"\203<\315 \210\316\317\n\"\202.\316\317\310\312 \"!\"\202.\320 ! \250\205t\321 >\205t\322 >\205t\312!\323!\211\"\307 \324ZI\210\")\325#)\203\210\n \324Z\240\210\314 \210\316\317\n\"\202.#\326=\203\231\316\317\n\"\210\327 \202.#\203*\325$\314 \210\316\317\n\"\210G\311V\203\345\307H9\203\345\311H<\203\345\330\331\311H!!\247\204\345%A\211%@\211\211&A@)A \211&A@)A@@\240\210 <\203! \211&A@)\211'@)\211$\203!\332$!\203!\333 \307V\204\334$!\204!\212\335$!q\210\315 \210\336 )\202&\315 \210\336 )\202.\337\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 event-modifiers shift control copy-sequence 33554432 nil edit isearch-edit-string posn-point event-start windowp minibuffer-depth window-minibuffer-p window-buffer isearch-clean-overlays isearch-process-search-string mods isearch-mode-map copy search-exit-option window unread-command-events event position] 7 (#$ . 25436) nil]) #@50 Quote special characters for incremental search. (defalias 'isearch-quote-char #[nil "\303\304\305!! \203\306Y\203\307X\203\n\\\310!)\207" [char enable-multibyte-characters nonascii-insert-offset read-quoted-char isearch-message t 128 255 isearch-process-search-char] 3 (#$ . 26917) nil]) #@63 Convert return into newline for incremental search. Obsolete. (defalias 'isearch-return-char #[nil "\300\301!\207" [isearch-process-search-char 10] 2 (#$ . 27224) nil]) #@71 Add this ordinary printing character to the search string and search. (defalias 'isearch-printing-char #[nil "\304 \211\305U\203 \306 \203#\307Y\203#\310X\203#\311\n\\!\2020 \203-\312!\2020\311!)\207" [char enable-multibyte-characters nonascii-insert-offset current-input-method isearch-last-command-char 33554464 32 128 255 isearch-process-search-char isearch-process-search-multibyte-characters] 4 (#$ . 27399) nil]) #@102 Match all whitespace chars, if in regexp mode. If you want to search for just a space, type C-q 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 (#$ . 27839) nil]) (defalias 'isearch-process-search-char #[(char) "\301\302!\303Y\203\304!\202\305!\"\207" [char isearch-process-search-string isearch-char-to-string 200 char-to-string 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 !\f\311U?\205L \312\206+\311\2034\313\2025\314\\\f\"\211L\210 8\315\316\317#\211,\207" [isearch-regexp regexp-search-ring search-ring ring length yank-pointer-name regexp-search-ring-yank-pointer search-ring-yank-pointer eval 0 mod -1 1 mapconcat isearch-text-char-description "" yank-pointer advance isearch-string isearch-message] 5]) (defalias 'isearch-ring-adjust #[(advance) "\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 (#$ . 29268) nil]) #@52 Retreat to the previous search string in the ring. (defalias 'isearch-ring-retreat #[nil "\300\301!\207" [isearch-ring-adjust nil] 2 (#$ . 29426) nil]) #@68 Insert the next element of the search history into the minibuffer. (defalias 'isearch-ring-advance-edit #[(n) "\203\306\202 \307\310 !\203 \202\f\211G\211\f\311U?\205> \312\n\206*\311 Z\f\"\211L\210\313 \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 0 mod erase-buffer length n] 5 (#$ . 29584) "p"]) #@73 Inserts the previous element of the search history into the minibuffer. (defalias 'isearch-ring-retreat-edit #[(n) "\301[!\207" [n isearch-ring-advance-edit] 2 (#$ . 30028) "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 (#$ . 30751) 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 erase-buffer] 1 (#$ . 31110) 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\325H\226I\210)\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 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 "A@\302\207" [lossage isearch-invalid-regexp nil] 1))) 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 mapcar isearch-open-necessary-overlays nil] 3]) (defalias 'isearch-close-unecessary-overlays #[(begin end) "\306\211\211\306\f\205q\f@\fA \307 !V\203$ \310 !W\2063\307 !V\2053\310 !W\311 \312\"\n\203D B\202\n \203P \313\"\210\202\n\314 \315\311 \316\"#\210\314 \317\311 \320\"#\210\314 \316\306#\210\314 \320\306#\210\202\n,\207" [isearch-opened-overlays fct-temp inside-overlay ov ov-list begin nil overlay-start overlay-end overlay-get isearch-open-invisible-temporary t overlay-put invisible isearch-invisible intangible isearch-intangible end] 6]) #@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-unecessary-overlays get-char-property invisible t get-text-property next-single-property-change overlays-at overlay-get isearch-open-invisible append next-overlay-change mapcar isearch-open-overlay-temporary prop buffer-invisibility-spec invis-prop o ov-list overlays isearch-opened-overlays] 6 (#$ . 36231)]) (byte-code "\302\300!\204\303\300 B\303\207" [isearch-overlay current-load-list boundp nil] 2) (defalias 'isearch-highlight #[(beg end) "?\206 ??\205+\n\204\305 \f\"\306\n \fp$\210\307\n\310\311\312\313\"\203)\312\202*\314#\207" [search-highlight window-system isearch-overlay beg end make-overlay move-overlay overlay-put face internal-find-face isearch nil region] 6]) (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 (#$ . 37731)]) (defalias 'isearch-char-to-string #[(c) "\301!\207" [c char-to-string] 2]) (defalias 'isearch-text-char-description #[(c) "\250\203\301W\204\302U\203\303!\207\304!\207" [c 32 127 text-char-description isearch-char-to-string] 2]) (defalias 'isearch-unread #[(&rest char-or-events) "\302\303\"\210\304 \"\211\207" [char-or-events unread-command-events mapcar store-kbd-macro-event append] 3]) (defalias 'isearch-last-command-char #[nil "\207" [last-command-char] 1])