Deprecated: The each() function is deprecated. This message will be suppressed on further calls in /home/zhenxiangba/zhenxiangba.com/public_html/phproxy-improved-master/index.php on line 456
;ELC ;;; compiled by rms@psilocin.gnu.ai.mit.edu on Sun Aug 11 03:37:42 1996 ;;; from file /home/fsf/rms/e19/lisp/isearch.el ;;; emacs version 19.32.3. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`isearch.el' was compiled for Emacs 19.29 or later")) #@72 *Non-nil means random control characters terminate incremental search. (defconst search-exit-option t (#$ . -473)) #@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. (defvar search-slow-window-lines 1 (#$ . -595)) #@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. (defvar search-slow-speed 1200 (#$ . -900)) #@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. (defvar search-upper-case (quote not-yanks) (#$ . -1123)) #@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. (defvar search-nonincremental-instead t (#$ . -1483)) #@133 *If non-nil, regular expression to match a sequence of whitespace chars. You might want to use something like "[ \t\r\n]+" instead. (defconst search-whitespace-regexp "\\s-+" (#$ . -1755)) #@65 *Non-nil means incremental search highlights the current match. (defvar search-highlight nil (#$ . -1950)) #@62 Function(s) to call after starting up an incremental search. (defvar isearch-mode-hook nil (#$ . 2063)) #@62 Function(s) to call after terminating an incremental search. (defvar isearch-mode-end-hook nil (#$ . 2173)) #@34 List of search string sequences. (defvar search-ring nil (#$ . 2287)) #@53 List of regular expression search string sequences. (defvar regexp-search-ring nil (#$ . 2363)) #@72 *Maximum length of search ring before oldest elements are thrown away. (defconst search-ring-max 16 (#$ . -2465)) #@79 *Maximum length of regexp search ring before oldest elements are thrown away. (defconst regexp-search-ring-max 16 (#$ . -2585)) #@64 Index in `search-ring' of last string reused. nil if none yet. (defvar search-ring-yank-pointer nil (#$ . 2719)) #@71 Index in `regexp-search-ring' of last string reused. nil if none yet. (defvar regexp-search-ring-yank-pointer nil (#$ . 2838)) #@128 *Non-nil if advancing or retreating in the search ring should cause search. Default value, nil, means edit the string instead. (defvar search-ring-update nil (#$ . -2972)) #@26 Keymap for isearch-mode. (defvar isearch-mode-map nil (#$ . 3150)) (byte-code " \f8!!\fA\"\f#\nW9\f\n\"#\nT$\fA@GWS\f\n!#\nT< \f!#\f#)\f\"#\f#\f#\f#\f#U!\f#\f#\f#\f#\f#\f#\f#\f#\f#\f#\f#\f#\f#\f#\f#\f#\f@#\fA#\fB#\fC#\f*ˇ" [isearch-mode-map 0 i make-keymap map vectorp 1 error "The initialization of isearch-mode-map must be updated" make-vector 256 nil define-key [t] isearch-other-control-char 32 make-string vector isearch-printing-char make-sparse-keymap meta-map char-to-string meta-prefix-char [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 "" isearch-yank-word "" isearch-yank-line "*" isearch-*-char "?" "|" isearch-|-char "" isearch-ring-advance "" isearch-ring-retreat "" isearch-yank-kill "" isearch-complete [switch-frame] [delete-frame] [iconify-frame] [make-frame-visible]] 6) #@55 Keymap for editing isearch strings in the minibuffer. (defvar minibuffer-local-isearch-map nil (#$ . 4376)) (byte-code "/\n! # # # # # # )!8B!GB!VB!eB!tB!B!B!B!B!B! B!!B!#B!$B!\n%B!&B!('B!7(B!F)B!U*B!d+B!s,B!-B!.B00C!/B!3#4#3#4#" [minibuffer-local-isearch-map copy-keymap minibuffer-local-map map define-key " " isearch-nonincremental-exit-minibuffer "" isearch-ring-advance-edit "" isearch-ring-retreat-edit "" isearch-complete-edit "" isearch-forward-exit-minibuffer "" isearch-reverse-exit-minibuffer boundp isearch-forward nil current-load-list isearch-regexp 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-mode minor-mode-alist (isearch-mode isearch-mode) make-variable-buffer-local global-map esc-map isearch-forward-regexp isearch-backward isearch-backward-regexp] 4) #@1731 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-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) "\n??\f?$" [isearch-mode t regexp-p nil no-recursive-edit] 5 (#$ . 5917) "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) "\n?\f?$" [isearch-mode t not-regexp nil no-recursive-edit] 5 (#$ . 7808) "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) "\n?? ?$" [isearch-mode nil regexp-p no-recursive-edit] 5 (#$ . 8212) "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) "\n? ?$" [isearch-mode nil not-regexp no-recursive-edit] 5 (#$ . 8512) "P\np"]) (defalias 'isearch-mode-help #[nil "! " [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  \f`X; _V` !\"!Z %' *+ !\"23 )" [forward isearch-forward regexp isearch-regexp word-p isearch-word op-fun isearch-op-fun case-fold-search isearch-case-fold-search "" isearch-string isearch-message nil isearch-cmds t isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-invalid-regexp isearch-within-brackets baud-rate search-slow-speed window-height search-slow-window-lines 4 isearch-slow-terminal-mode isearch-other-end isearch-small-window isearch-just-started isearch-opoint search-ring-yank-pointer regexp-search-ring-yank-pointer looking-at current-window-configuration isearch-window-configuration " Isearch" isearch-mode force-mode-line-update isearch-push-state isearch-mode-map overriding-terminal-local-map isearch-update run-hooks isearch-mode-hook add-hook mouse-leave-buffer-hook isearch-done recursive-edit isearch-recursive-edit] 3 (#$ . 9022)]) (defalias 'isearch-update #[nil " \f k\fk k`! W5[T; TZ\")WbZ! `\" \" \"f!b)`W`\"`\"!͉" [unread-command-events input-pending-p isearch-message isearch-slow-terminal-mode isearch-small-window pos-visible-in-window-p found-point t move-to-window-line 0 1 window-min-height split-window nil search-slow-window-lines window-height vertical-motion set-window-start next-window set-window-hscroll window-hscroll selected-window other-window isearch-other-end isearch-highlight isearch-dehighlight isearch-adjusted isearch-yank-flag] 4]) (defalias 'isearch-done #[(&optional nopush edit) "\"! !` \n  ! * b2 \n#`UYCY\"Y VY!* GVtt\"! ?! " [remove-hook mouse-leave-buffer-hook isearch-done nil overriding-terminal-local-map isearch-dehighlight t window-start selected-window found-point found-start isearch-window-configuration set-window-configuration isearch-small-window set-window-start isearch-opoint transient-mark-mode mark-active push-mark executing-kbd-macro minibuffer-depth 0 message "Mark saved where search started" isearch-mode force-mode-line-update isearch-string nopush isearch-update-ring isearch-regexp run-hooks isearch-mode-end-hook edit isearch-recursive-edit exit-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) "\" \n @?D\n BG V!\fS š0\n@?D\nBG\fVD\fSš" [regexp regexp-search-ring string regexp-search-ring-max search-ring-max nil search-ring] 3 (#$ . 11594)]) (defalias 'isearch-switch-frame-handler #[nil " A@!" [isearch-done 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 " GU ) " [search-nonincremental-instead isearch-string 0 t isearch-nonincremental isearch-edit-string isearch-done] 2 (#$ . 12058) 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 "" [err (byte-code " \n \f  \n \f   \f \n ۏ ܎ ) \"##!' !\"=} !+# -%)#, GU 23@  ." [isearch-nonincremental isearch-string isearch-message isearch-forward isearch-word isearch-regexp 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 current-window-configuration isearch-window-configuration isearch-new-word isearch-new-forward isearch-new-message isearch-new-string err (byte-code "\"" [isearch-done t] 3) ((exit)) ((byte-code " \n % \n ć" [isearch-mode isearch-forward isearch-regexp isearch-op-fun nil isearch-word isearch-new-string isearch-string isearch-new-message isearch-message isearch-new-forward isearch-new-word] 6)) t cursor-in-echo-area read-event e nil minibuffer-history-symbol message-log-max message isearch-message-prefix lookup-key isearch-mode-map vector isearch-yank-word isearch-unread junk-ring read-from-minibuffer minibuffer-local-isearch-map mapconcat isearch-text-char-description "" 0 regexp-search-ring search-ring isearch-push-state isearch-search isearch-update isearch-done] 20) ((quit (isearch-abort)))] 3 (#$ . 12450) nil]) (defalias 'isearch-nonincremental-exit-minibuffer #[nil " " [t isearch-nonincremental exit-minibuffer] 1 nil nil]) (defalias 'isearch-forward-exit-minibuffer #[nil " " [t isearch-new-forward exit-minibuffer] 1 nil nil]) (defalias 'isearch-reverse-exit-minibuffer #[nil " " [nil isearch-new-forward exit-minibuffer] 1 nil nil]) #@57 Terminate the search and go back to the starting point. (defalias 'isearch-cancel #[nil "b!\"" [isearch-opoint isearch-done t signal quit nil] 3 (#$ . 15050) 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 " \nb!\" $  " [discard-input isearch-success isearch-opoint nil isearch-done t signal quit isearch-invalid-regexp isearch-pop-state isearch-update] 3 (#$ . 15230) nil]) (defalias 'isearch-repeat #[(direction) " ==@ Ě* @@ #\nC C7e8db C?` ĚR  ϕϔlmmoy ӂu " [isearch-forward direction forward isearch-string "" isearch-regexp regexp-search-ring search-ring mapconcat isearch-text-char-description isearch-message isearch-success t isearch-wrapped isearch-barrier 0 isearch-just-started nil ding 1 -1 isearch-search isearch-push-state isearch-update] 4]) #@37 Repeat incremental search forwards. (defalias 'isearch-repeat-forward #[nil "!" [isearch-repeat forward] 2 (#$ . 16145) nil]) #@38 Repeat incremental search backwards. (defalias 'isearch-repeat-backward #[nil "!" [isearch-repeat backward] 2 (#$ . 16280) nil]) #@36 Toggle regexp searching on or off. (defalias 'isearch-toggle-regexp #[nil "?  " [isearch-regexp nil isearch-word isearch-update] 2 (#$ . 16418) nil]) #@45 Toggle case folding in searching on or off. (defalias 'isearch-toggle-case-fold #[nil "?‰#ɂ$)\f! " [isearch-case-fold-search yes nil message-log-max message "%s%s [case %ssensitive]" isearch-message-prefix isearch-nonincremental isearch-message "in" "" t isearch-adjusted sit-for 1 isearch-update] 6 (#$ . 16583) nil]) #@90 Discard last input item and move point back. If no previous match was done, just beep. (defalias 'isearch-delete-char #[nil "A  " [isearch-cmds ding isearch-pop-state isearch-update] 1 (#$ . 16940) nil]) (defalias 'isearch-yank #[(chunk) "=\f!3\f  b`=&v/=/`){)\n F\f=F\n\nQ\n!\n\nP\n#P) " [chunk kill current-kill 0 isearch-forward isearch-other-end word 1 line nil string isearch-case-fold-search search-upper-case not-yanks isearch-regexp regexp-quote isearch-string isearch-message mapconcat isearch-text-char-description "" t isearch-yank-flag isearch-search-and-update] 5]) #@48 Pull string from kill ring into search string. (defalias 'isearch-yank-kill #[nil "!" [isearch-yank kill] 2 (#$ . 17609) nil]) #@48 Pull next word from buffer into search string. (defalias 'isearch-yank-word #[nil "!" [isearch-yank word] 2 (#$ . 17745) nil]) #@51 Pull rest of line from buffer into search string. (defalias 'isearch-yank-line #[nil "!" [isearch-yank line] 2 (#$ . 17881) nil]) (defalias 'isearch-search-and-update #[nil " V\n6 6Ə6'ȕ \n^X6\f ȕVS S\nHQ \n^T^b b " [isearch-success isearch-regexp isearch-forward isearch-adjusted nil (byte-code " \f\f!!)" [isearch-case-fold-search case-fold-search looking-at isearch-regexp isearch-string regexp-quote] 3) ((error)) isearch-yank-flag 0 isearch-opoint isearch-barrier t isearch-invalid-regexp isearch-within-brackets isearch-other-end isearch-search isearch-push-state isearch-op-fun isearch-update] 3]) #@38 Handle * and ? specially in regexps. (defalias 'isearch-*-char #[nil "2 ĂA@8 *]/^b) !" [isearch-regexp t isearch-adjusted isearch-forward 5 2 isearch-cmds cs isearch-barrier isearch-process-search-char isearch-last-command-char] 3 (#$ . 18572) nil]) #@43 If in regexp search, jump to the barrier. (defalias 'isearch-|-char #[nil "  b !" [isearch-regexp t isearch-adjusted isearch-barrier isearch-process-search-char isearch-last-command-char] 2 (#$ . 18868) nil]) (defalias (quote isearch-other-control-char) (quote 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 " H ! GUN \" ?( ( !)N \f \"A \"  \"!\"  ! z>z>z ! ZI)#) Z \" = \"  \" GV H9 H< H!!A@ A@)A  A@)A@@ <  A@)!@)!!q ) )  \"+" [this-command-keys key 0 main-event listify-key-sequence keylist 1 lookup-key function-key-map lookup keymapp cancel-kbd-macro-events global-map isearch-done apply isearch-unread event-modifiers mods shift control isearch-mode-map copy-sequence copy 33554432 nil search-exit-option edit isearch-edit-string window posn-point event-start unread-command-events event position windowp window-buffer isearch-process-search-string] 7 (#$ . 19171) nil]) #@50 Quote special characters for incremental search. (defalias 'isearch-quote-char #[nil "!!!" [isearch-process-search-char read-quoted-char isearch-message t] 4 (#$ . 20231) nil]) #@63 Convert return into newline for incremental search. Obsolete. (defalias 'isearch-return-char #[nil "!" [isearch-process-search-char 10] 2 (#$ . 20419) nil]) #@71 Add this ordinary printing character to the search string and search. (defalias 'isearch-printing-char #[nil " !" [isearch-process-search-char isearch-last-command-char] 2 (#$ . 20585) 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 " \n  \" " [isearch-regexp search-whitespace-regexp isearch-within-brackets isearch-invalid-regexp isearch-process-search-string " " isearch-printing-char] 3 (#$ . 20786) nil]) (defalias 'isearch-process-search-char #[(char) "\n!\n!\"" [isearch-process-search-string isearch-char-to-string char isearch-text-char-description] 4]) (defalias 'isearch-process-search-string #[(string message) " P\n P " [isearch-string string isearch-message message isearch-search-and-update] 2]) (defalias 'isearch-ring-adjust1 #[(advance) " \nGł! \fU?O .\f7͂8\\\f\" L 8#," [isearch-regexp regexp-search-ring search-ring ring length regexp-search-ring-yank-pointer search-ring-yank-pointer yank-pointer-name eval yank-pointer 0 mod advance -1 1 isearch-string mapconcat isearch-text-char-description "" isearch-message] 5]) (defalias 'isearch-ring-adjust #[(advance) "A !  " [isearch-cmds isearch-pop-state isearch-ring-adjust1 advance isearch-push-state search-ring-update isearch-search isearch-update isearch-edit-string] 2]) #@48 Advance to the next search string in the ring. (defalias 'isearch-ring-advance #[nil "!" [isearch-ring-adjust advance] 2 (#$ . 22055) nil]) #@52 Retreat to the previous search string in the ring. (defalias 'isearch-ring-retreat #[nil "!" [isearch-ring-adjust nil] 2 (#$ . 22204) nil]) #@68 Insert the next element of the search history into the minibuffer. (defalias 'isearch-ring-advance-edit #[(n) "  !G U?B -\fZ \"L 8cdb," [isearch-regexp regexp-search-ring-yank-pointer search-ring-yank-pointer yank-pointer-name eval yank-pointer regexp-search-ring search-ring ring length 0 mod n erase-buffer] 5 (#$ . 22353) "p"]) #@73 Inserts the previous element of the search history into the minibuffer. (defalias 'isearch-ring-retreat-edit #[(n) " [!" [isearch-ring-advance-edit n] 2 (#$ . 22737) "p"]) (defalias 'isearch-complete1 #[nil " \n \"\n\" =&̂\\ 3\nGUW \nOSϐ\n\"!S \n̂\\!," [isearch-regexp regexp-search-ring search-ring ring mapcar #[(string) "C" [string] 1] alist case-fold-search completion-ignore-case try-completion isearch-string completion t 0 completion-auto-help "*Isearch completions*" display-completion-list all-completions message "No completion" nil] 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 "  ! " [isearch-complete1 isearch-edit-string sit-for 1 isearch-update] 2 (#$ . 23358) nil]) #@54 Same as `isearch-complete' except in the minibuffer. (defalias 'isearch-complete-edit #[nil "  c" [buffer-string isearch-string isearch-complete1 erase-buffer] 1 (#$ . 23690) nil]) (defalias 'isearch-top-state #[nil "@@ A@ 8 8 8 8 8 8 8 8 8 AA@b)" [isearch-cmds cmd isearch-string isearch-message 3 isearch-success 4 isearch-forward 5 isearch-other-end 6 isearch-word 7 isearch-invalid-regexp 8 isearch-wrapped 9 isearch-barrier 10 isearch-within-brackets 11 isearch-case-fold-search] 3]) (defalias 'isearch-pop-state #[nil "A " [isearch-cmds isearch-top-state] 1]) (defalias 'isearch-push-state #[nil " `\n \f  \n\f B " [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) "\n #\f\n\"Q\n\" \")*" [ellipsis isearch-message-prefix c-q-hack isearch-nonincremental isearch-message isearch-message-suffix m cursor-in-echo-area nil message-log-max message "%s"] 6]) (defalias 'isearch-message-prefix #[(&optional c-q-hack ellipsis nonincremental) " ď  Ƃ5 -`\nV1`\nW5; D΂ENЂOX҂Y bԂcհHI)" [isearch-invalid-regexp ellipsis nil (byte-code " `#Ç" [re-search-forward isearch-string t nil isearch-invalid-regexp isearch-within-brackets] 4) ((error)) isearch-success "" "failing " isearch-wrapped isearch-forward isearch-opoint "over" "wrapped " isearch-word "word " isearch-regexp "regexp " nonincremental "search" "I-search" ": " " backward: " m 0] 8]) (defalias 'isearch-message-suffix #[(&optional c-q-hack ellipsis) "  QP" [c-q-hack "^Q" "" isearch-invalid-regexp " [" "]"] 4]) (defalias 'isearch-search #[nil "\" =\f\"ʏ ?2 @8,  @8b" [isearch-message nil t isearch-case-fold-search search-upper-case isearch-no-upper-case-p isearch-string isearch-regexp lossage (byte-code " \f\nɂ:ʂ:\f0,˂:̂:9͂:#WSӔUӕ*" [nil isearch-case-fold-search case-fold-search inhibit-quit isearch-regexp isearch-invalid-regexp isearch-within-brackets isearch-word isearch-forward word-search-forward word-search-backward re-search-forward re-search-backward search-forward search-backward isearch-string t isearch-success isearch-just-started 0 isearch-other-end] 4) ((quit (byte-code "!‡" [isearch-unread 7 nil isearch-success] 2)) (invalid-regexp (byte-code "A@ \" \"‡" [lossage isearch-invalid-regexp string-match "\\`Unmatched \\[" isearch-within-brackets "\\`Premature \\|\\`Unmatched \\|\\`Invalid " "incomplete input"] 3)) (error (byte-code "A@‡" [lossage isearch-invalid-regexp nil] 1))) isearch-success 3 isearch-cmds ding 2] 3]) (byte-code "! B‡" [boundp isearch-overlay nil current-load-list] 2) (defalias 'isearch-highlight #[(beg end) "? ??+\n\f \"\n\f p$\n\")ʂ*#" [search-highlight window-system isearch-overlay make-overlay beg end move-overlay overlay-put face internal-find-face isearch nil region] 6]) (defalias 'isearch-dehighlight #[(totally) "!" [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) " Ă\f\")?" [nil case-fold-search string-match regexp-flag "\\(^\\|\\\\\\\\\\|[^\\]\\)[A-Z]" "[A-Z]" string] 3 (#$ . 27045)]) (byte-code " B B B" [unread-command-event current-load-list unread-command-events last-command-event] 2) (defalias 'isearch-char-to-string #[(c) "\n\"" [make-string 1 c] 3]) (defalias 'isearch-text-char-description #[(c) "WU!!" [c 32 127 text-char-description isearch-char-to-string] 2]) (defalias 'isearch-unread #[(&rest char-or-events) "\n\"\n\f\"" [mapcar store-kbd-macro-event char-or-events append unread-command-events] 3]) (defalias 'isearch-last-command-char #[nil "" [last-command-char] 1])