;ELC ;;; compiled by jwz@thalidomide on Thu Feb 24 17:35:29 1994 ;;; from file /th/jwz/emacs19/lisp/prim/isearch-mode.el ;;; emacs version 19.10 Lucid (beta4). ;;; bytecomp version 2.22; 22-dec-93. ;;; 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"))) (error "This file was compiled for Emacs 19.")) (byte-code "M\"" [isearch-char-to-string #[(c) "\"ĉ$\"" [c make-string 1 event-to-character nil t] 7] define-function isearch-text-char-description text-char-description] 3) (defvar search-last-string "" "\ Last string search for by a search command. This does not include direct calls to the primitive search functions, and does not include searches that are aborted.") (defvar search-last-regexp "" "\ Last string searched for by a regexp search command. This does not include direct calls to the primitive search functions, and does not include searches that are aborted.") (defconst search-exit-option t "\ Non-nil means random control characters terminate incremental search.") (defvar search-slow-window-lines 1 "\ *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.") (defconst search-slow-speed 1200 "\ *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-caps-disable-folding t "\ *If non-nil, upper case chars disable case fold searching. This does not apply to \"yanked\" strings.") (defvar search-nonincremental-instead t "\ *If non-nil, do a nonincremental search instead if exiting immediately.") (defconst search-whitespace-regexp "\\(\\s \\|[\n ]\\)+" "\ *If non-nil, regular expression to match a sequence of whitespace chars.") (defvar search-ring nil "\ List of search string sequences.") (defvar regexp-search-ring nil "\ List of regular expression search string sequences.") (defconst search-ring-max 16 "\ *Maximum length of search ring before oldest elements are thrown away.") (defconst regexp-search-ring-max 16 "\ *Maximum length of regexp search ring before oldest elements are thrown away.") (defvar search-ring-yank-pointer nil "\ The tail of the search ring whose car is the last thing searched for.") (defvar regexp-search-ring-yank-pointer nil "\ The tail of the regular expression search ring whose car is the last thing searched for.") (defvar isearch-mode-map nil "\ Keymap for isearch-mode.") (byte-code " \n\"\" W I\n# T f*\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n#\n)" [isearch-mode-map make-keymap map set-keymap-name 32 make-string 1 0 str i 127 define-key isearch-printing-char " " "" isearch-repeat-forward "" isearch-repeat-backward "" isearch-delete-char "" isearch-abort "" isearch-quote-char " " isearch-exit "\n" "" isearch-yank-word "" isearch-yank-line "*" isearch-*-char "?" "|" isearch-|-char backspace (control h) isearch-mode-help "" isearch-ring-advance "" isearch-ring-retreat "" isearch-whitespace-chars "" isearch-complete button2 isearch-yank-x-selection] 5) (defvar minibuffer-local-isearch-map nil "\ Keymap for editing isearch strings in the minibuffer.") (byte-code " \n \"\n\"\n#\n#\n#\n#\n#\n#\n)!!!!!!!!!! !!!#!$!%!&!'!(!)!*!+!,!-!.!/Շ" [minibuffer-local-isearch-map make-sparse-keymap map set-keymap-parent minibuffer-local-map set-keymap-name 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 isearch-regexp isearch-word isearch-cmds isearch-string "" isearch-message isearch-success t isearch-invalid-regexp isearch-other-end isearch-wrapped isearch-barrier 0 isearch-buffer isearch-case-fold-search isearch-adjusted isearch-slow-terminal-mode isearch-small-window isearch-opoint isearch-window-configuration isearch-old-local-map isearch-yank-flag isearch-op-fun isearch-recursive-edit isearch-nonincremental isearch-new-forward] 4) (defvar isearch-mode-hook nil "\ Function(s) to call after starting up an incremental search.") (defvar isearch-mode-end-hook nil "\ Function(s) to call after terminating an incremental search.") (byte-code " \"!!!" [isearch-mode minor-mode-alist purecopy append ((isearch-mode isearch-mode)) boundp nil make-variable-buffer-local] 4) (fset 'isearch-forward #[(&optional regexp-p) "\n??t?$" [isearch-mode t regexp-p nil] 5 "\ 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. Type \\[isearch-whitespace-chars] to match all whitespace chars in regexp. \\[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 are bound in the isearch-mode-map. To change the keys which are special to isearch-mode, simply change the bindings in that map. Other control and meta characters terminate the search and are then executed normally (depending on `search-exit-option'). If this function is called non-interactively, it does not return to the calling function until the search is done. The bindings, more precisely: \\{isearch-mode-map}" "P"]) (fset 'isearch-forward-regexp #[nil "t?$" [isearch-mode t nil] 5 "\ Do incremental search forward for regular expression. Like ordinary incremental search except that your input is treated as a regexp. See \\[isearch-forward] for more info." nil]) (fset 'isearch-backward #[(&optional regexp-p) "\n??t?$" [isearch-mode nil regexp-p] 5 "\ Do incremental search backward. With a prefix argument, do an incremental regular expression search instead. See \\[isearch-forward] for more information." "P"]) (fset 'isearch-backward-regexp #[nil "t?$" [isearch-mode nil t] 5 "\ Do incremental search backward for regular expression. Like ordinary incremental search except that your input is treated as a regexp. See \\[isearch-forward] for more info." nil]) (fset 'isearch-mode-help #[nil "! " [describe-function isearch-forward isearch-update] 2 nil nil]) (fset 'isearch-mode #[(forward &optional regexp op-fun recursive-edit word-p) "p \n   `X _V !`\" $ &'(!+!\" ! 3!3&\") !\n8 )" [executing-macro nil recursive-edit t inhibit-quit isearch-buffer 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 isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-invalid-regexp baud-rate search-slow-speed window-height search-slow-window-lines 4 isearch-slow-terminal-mode isearch-other-end isearch-small-window isearch-opoint current-window-configuration isearch-window-configuration current-local-map isearch-old-local-map pre-command-hook isearch-old-pre-command-hook gettext " Isearch" isearch-mode store-match-data add-hook isearch-pre-command-hook set-buffer-modified-p buffer-modified-p isearch-push-state use-local-map isearch-mode-map set-keymap-parent isearch-update run-hooks isearch-mode-hook isearch-recursive-edit] 3 "\ Start isearch minor mode. Called by isearch-forward, etc."]) (byte-code "MM" [isearch-update #[nil " `! W[T TZ\")WZ! `\" \" \"!b)`W`\"`\"!!͉" [unread-command-event 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 extentp isearch-extent isearch-dehighlight isearch-adjusted isearch-yank-flag] 4] isearch-done #[nil "\n\nq !\" \"  !!) !`!`U!!b #+GVBG V!Sʡ\"#\"B\"#\"G!V!S\"ʡ!& " [t inhibit-quit isearch-buffer use-local-map isearch-old-local-map remove-hook pre-command-hook isearch-pre-command-hook set-keymap-parent isearch-mode-map nil isearch-mode set-buffer-modified-p buffer-modified-p isearch-dehighlight window-start selected-window found-point found-start set-window-configuration isearch-window-configuration isearch-opoint push-mark message "" isearch-small-window set-window-start isearch-string 0 isearch-regexp regexp-search-ring regexp-search-ring-yank-pointer regexp-search-ring-max search-ring-max search-ring search-ring-yank-pointer run-hooks isearch-mode-end-hook isearch-recursive-edit exit-recursive-edit] 5]] 2) (fset 'isearch-exit #[nil " GU ) " [search-nonincremental-instead isearch-string 0 t isearch-nonincremental isearch-edit-string isearch-done] 2 "\ Exit search normally. However, if this is the first command after starting incremental search and `search-nonincremental-instead' is non-nil, do an incremental search via `isearch-edit-string'." nil]) (fset 'isearch-edit-string #[nil "" [nil (byte-code "\n \n  \n       \n  ܎\" ! \" &!\"=)) ##+ GU /0/ / 0  ." [minibuffer-local-isearch-map nil isearch-forward isearch-string isearch-message isearch-regexp isearch-word isearch-op-fun isearch-cmds isearch-success isearch-wrapped isearch-barrier isearch-adjusted isearch-yank-flag isearch-invalid-regexp isearch-other-end isearch-opoint isearch-slow-terminal-mode isearch-small-window isearch-recursive-edit current-window-configuration isearch-window-configuration isearch-new-forward isearch-new-message isearch-new-string isearch-nonincremental minibuffer-local-map isearch-done ((isearch-mode isearch-forward isearch-regexp isearch-op-fun isearch-recursive-edit isearch-word)) isearch-message-prefix t event prompt cursor-in-echo-area message "%s" next-command-event lookup-key isearch-mode-map vector isearch-yank-word unread-command-event read-string mapconcat isearch-text-char-description "" 0 search-last-regexp search-last-string isearch-push-state isearch-search isearch-update] 25) ((quit (isearch-abort)))] 3 "\ Edit the search string in the minibuffer. The following additional command keys are active while editing. \\ \\[exit-minibuffer] to exit editing and resume incremental searching. \\[isearch-forward-exit-minibuffer] to resume isearching forward. \\[isearch-backward-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 next item in the search ring. \\[isearch-complete-edit] to complete the search string from the search ring." nil]) (byte-code "MMM" [isearch-nonincremental-exit-minibuffer #[nil " " [t isearch-nonincremental exit-minibuffer] 1 nil nil] isearch-forward-exit-minibuffer #[nil " " [t isearch-new-forward exit-minibuffer] 1 nil nil] isearch-reverse-exit-minibuffer #[nil " " [nil isearch-new-forward exit-minibuffer] 1 nil nil]] 2) (fset 'isearch-abort #[nil " \nb \" x " [discard-input isearch-success isearch-opoint isearch-done signal quit (isearch) isearch-pop-state isearch-update] 3 "\ Quit incremental search mode if searching is successful, signalling quit. Otherwise, revert to previous successful search and continue searching. Use `isearch-exit' to quit without signalling." nil]) (fset 'isearch-repeat #[(direction) " == Ě @@@ @ #  edb?` ĚѕєҪu " [isearch-forward direction forward isearch-string "" isearch-regexp regexp-search-ring-yank-pointer regexp-search-ring search-ring-yank-pointer search-ring mapconcat isearch-text-char-description isearch-message isearch-success t isearch-wrapped isearch-barrier 0 1 -1 isearch-search isearch-push-state isearch-update] 4]) (fset 'isearch-repeat-forward #[nil "!" [isearch-repeat forward] 2 "\ Repeat incremental search forwards." nil]) (fset 'isearch-repeat-backward #[nil "!" [isearch-repeat backward] 2 "\ Repeat incremental search backwards." nil]) (fset 'isearch-toggle-regexp #[nil "? " [isearch-regexp nil isearch-word isearch-update] 2 "\ Toggle regexp searching on or off." nil]) (fset 'isearch-delete-char #[nil "A\" " [isearch-cmds ding nil isearch-quit isearch-pop-state isearch-update] 3 "\ Discard last input item and move point back. If no previous match was done, just beep." nil]) (fset 'isearch-yank #[(chunk) "; \n\nb` `){)  ! P #P ) " [chunk isearch-forward isearch-other-end word search-caps-disable-folding isearch-case-fold-search isearch-regexp regexp-quote isearch-string isearch-message mapconcat isearch-text-char-description "" t isearch-yank-flag isearch-search-and-update] 5]) (fset 'isearch-yank-word #[nil "!" [isearch-yank #[nil "v" [1] 1]] 2 "\ Pull next word from buffer into search string." nil]) (fset 'isearch-yank-line #[nil "!" [isearch-yank end-of-line] 2 "\ Pull rest of line from buffer into search string." nil]) (fset 'isearch-yank-sexp #[nil "!" [isearch-yank forward-sexp] 2 "\ Pull next expression from buffer into search string." nil]) (fset 'isearch-yank-x-selection #[nil " !" [isearch-yank x-get-selection] 2 "\ Pull the current X selection into the search string." nil]) (fset 'isearch-yank-x-clipboard #[nil " !" [isearch-yank x-get-clipboard] 2 "\ Pull the current X clipboard selection into the search string." nil]) (fset 'isearch-search-and-update #[nil " \n Əȕ \n^X ȕ  \n  \n T^^b  " [isearch-success isearch-regexp isearch-forward isearch-adjusted nil (byte-code " \n\n!!" [looking-at isearch-regexp isearch-string regexp-quote] 3) ((error)) isearch-yank-flag 0 isearch-opoint isearch-barrier t isearch-invalid-regexp isearch-other-end isearch-search isearch-push-state isearch-op-fun isearch-update] 3]) (fset 'isearch-*-char #[nil " ĪA@8 ]^b)\n!" [isearch-regexp t isearch-adjusted isearch-forward 5 2 isearch-cmds cs isearch-barrier isearch-process-search-char last-command-event] 3 "\ Handle * and ? specially in regexps." nil]) (fset 'isearch-|-char #[nil " b !" [isearch-regexp t isearch-adjusted isearch-barrier isearch-process-search-char last-command-event] 2 "\ If in regexp search, jump to the barrier." nil]) (fset 'isearch-quote-char #[nil "!!!" [isearch-process-search-char read-quoted-char isearch-message t] 4 "\ Quote special characters for incremental search." nil]) (fset 'isearch-return-char #[nil "!" [isearch-process-search-char 10] 2 "\ Convert return into newline for incremental search. Obsolete." nil]) (fset 'isearch-printing-char #[nil " !" [isearch-process-search-char last-command-event] 2 "\ Any other printing character => add it to the search string and search." nil]) (fset 'isearch-whitespace-chars #[nil " \" !" [isearch-regexp search-whitespace-regexp isearch-process-search-string " " beep isearch-process-search-char 32] 3 "\ Match all whitespace chars, if in regexp mode." nil]) (byte-code "MM" [isearch-process-search-char #[(char) "\n!\n!\"" [isearch-process-search-string isearch-char-to-string char isearch-text-char-description] 4] isearch-process-search-string #[(string message) " P\n P " [isearch-string string isearch-message message isearch-search-and-update] 2]] 2) (defvar search-ring-update nil "\ *Non-nil if advancing or retreating in the search ring should cause search. Default nil means edit the string from the search ring first.") (byte-code "MM" [isearch-ring-adjust1 #[(advance) " \nGŪ! U?  GZ S\\  L @  #," [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 advance 1 isearch-string mapconcat isearch-text-char-description "" isearch-message] 5] 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]] 2) (fset 'isearch-ring-advance #[nil "!" [isearch-ring-adjust advance] 2 "\ Advance to the next search string in the ring." nil]) (fset 'isearch-ring-retreat #[nil "!" [isearch-ring-adjust nil] 2 "\ Retreat to the previous search string in the ring." nil]) (fset 'isearch-ring-adjust-edit #[(advance) " ! c" [isearch-ring-adjust1 advance erase-buffer isearch-string] 2 "\ Use the next or previous search string in the ring while in minibuffer."]) (fset 'isearch-ring-advance-edit #[nil "!" [isearch-ring-adjust-edit advance] 2 nil nil]) (fset 'isearch-ring-retreat-edit #[nil "!" [isearch-ring-adjust-edit nil] 2 "\ Retreat to the previous search string in the ring while in the minibuffer." nil]) (fset 'isearch-complete1 #[nil " \n \"\n\" =̪ \nGU \n!\n\"! \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 gettext "*Isearch completions*" display-completion-list all-completions temp-minibuffer-message "No completion" nil] 6]) (fset 'isearch-complete #[nil " ! " [isearch-complete1 isearch-edit-string sit-for 1 isearch-update] 2 "\ 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." nil]) (fset 'isearch-complete-edit #[nil "  c" [buffer-string isearch-string isearch-complete1 erase-buffer] 1 "\ Same as `isearch-complete' except in the minibuffer." nil]) (byte-code "MMMMMM#################################MM" [isearch-top-state #[nil "@@ A@ 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-invalid-regexp 7 isearch-wrapped 8 isearch-barrier] 3] isearch-pop-state #[nil "A " [isearch-cmds isearch-top-state] 1] isearch-push-state #[nil " `\n  B" [isearch-string isearch-message isearch-success isearch-forward isearch-other-end isearch-invalid-regexp isearch-wrapped isearch-barrier isearch-cmds] 9] isearch-message #[(&optional c-q-hack ellipsis) "\n! \n!Q\n \"*" [ellipsis isearch-message-prefix c-q-hack isearch-message isearch-message-suffix m cursor-in-echo-area message "%s"] 5] isearch-message-prefix #[(&optional c-q-hack nonincremental) "Ï ƪɪ\n˪ ͪϪѪ&U!U!U!U!U!U!U!U!U!U!U!U!U!U!U!U!U!U!U!U!U!U!@UԁA!BUԁC!DUԁE!FUԁG!HUԁI!JUԁK!LUԁM!NUԁO!PUԁQ!UԁR!SUԁT!UUԁV!WUԁX!YUԁZ![Uԁ\\!]Uԁ^!_Uԁ`!aUԁb!cUԁd!eUԁf!gUԁh!iUԁj!kUԁl!mUԁn!oUԁp!Uԁq!rUԁs!tUԁu!vUԁw!xUԁy!zUԁ{!|Uԁ}!~Uԁ!Uԁ!Uԁ!Uԁ!Uԁ!Uԁ!Uԁ!Uԁ!Uԁ!Uԁ!!)" [isearch-invalid-regexp nil (byte-code " `#Ç" [re-search-forward isearch-string t nil isearch-invalid-regexp] 4) ((error)) logior isearch-success 32 0 isearch-wrapped 16 isearch-word 8 isearch-regexp 4 nonincremental 2 isearch-forward 1 i 63 gettext "Wrapped word regexp search: " 62 "Wrapped word regexp search backward: " 61 "Wrapped word regexp I-search: " 60 "Wrapped word regexp I-search backward: " 59 "Wrapped word search: " 58 "Wrapped word search backward: " 57 "Wrapped word I-search: " 56 "Wrapped word I-search backward: " 55 "Wrapped regexp search: " 54 "Wrapped regexp search backward: " 53 "Wrapped regexp I-search: " 52 "Wrapped regexp I-search backward: " 51 "Wrapped search: " 50 "Wrapped search backward: " 49 "Wrapped I-search: " 48 "Wrapped I-search backward: " 47 "Word regexp search: " 46 "Word regexp search backward: " 45 "Word regexp I-search: " 44 "Word regexp I-search backward: " 43 "Word search: " 42 "Word search backward: " 41 "Word I-search: " 40 "Word I-search backward: " 39 "Regexp search: " 38 "Regexp search backward: " 37 "Regexp I-search: " 36 "Regexp I-search backward: " 35 "Search: " 34 "Search backward: " 33 "I-search: " "I-search backward: " 31 "Failing wrapped word regexp search: " 30 "Failing wrapped word regexp search backward: " 29 "Failing wrapped word regexp I-search: " 28 "Failing wrapped word regexp I-search backward: " 27 "Failing wrapped word search: " 26 "Failing wrapped word search backward: " 25 "Failing wrapped word I-search: " 24 "Failing wrapped word I-search backward: " 23 "Failing wrapped regexp search: " 22 "Failing wrapped regexp search backward: " 21 "Failing wrapped regexp I-search: " 20 "Failing wrapped regexp I-search backward: " 19 "Failing wrapped search: " 18 "Failing wrapped search backward: " 17 "Failing wrapped I-search: " "Failing wrapped I-search backward: " 15 "Failing word regexp search: " 14 "Failing word regexp search backward: " 13 "Failing word regexp I-search: " 12 "Failing word regexp I-search backward: " 11 "Failing word search: " 10 "Failing word search backward: " 9 "Failing word I-search: " "Failing word I-search backward: " 7 "Failing regexp search: " 6 "Failing regexp search backward: " 5 "Failing regexp I-search: " "Failing regexp I-search backward: " 3 "Failing search: " "Failing search backward: " "Failing I-search: " "Failing I-search backward: " error "Something's rotten"] 8] isearch-message-suffix #[(&optional c-q-hack) " QP" [c-q-hack "^Q" "" isearch-invalid-regexp " [" "]"] 4] put isearch-printing-char isearch-command t isearch-return-char isearch-repeat-forward isearch-repeat-backward isearch-delete-char isearch-abort isearch-quote-char isearch-exit isearch-yank-word isearch-yank-line isearch-yank-sexp isearch-*-char isearch-|-char isearch-toggle-regexp isearch-edit-string isearch-mode-help isearch-ring-advance isearch-ring-retreat isearch-ring-advance-edit isearch-ring-retreat-edit isearch-whitespace-chars isearch-complete isearch-complete-edit isearch-forward-exit-minibuffer isearch-reverse-exit-minibuffer isearch-nonincremental-exit-minibuffer isearch-yank-x-selection isearch-yank-x-clipboard isearch-pre-command-hook #[nil "p= 9 N? " [isearch-buffer isearch-done isearch-maybe-frob-keyboard-macros this-command isearch-command] 2] isearch-maybe-frob-keyboard-macros #[nil "=‰;!!=H!;H‰" [this-command self-insert-command isearch-printing-char vectorp key-binding character-to-event 0 last-command-event last-command-char] 3]] 4) (defvar isearch-highlight t "\ *Whether isearch and query-replace should highlight the text which currently matches the search-string.") (byte-code "!!MMMM" [boundp isearch-extent nil make-face isearch isearch-make-extent #[(begin end) " \np# T\" \" )" [make-extent begin end x set-extent-priority mouse-highlight-priority set-extent-face isearch isearch-extent] 4] isearch-highlight #[(begin end) "??\n! \"\n!p=\n! \"\n #" [isearch-highlight extentp isearch-extent isearch-make-extent begin end extent-buffer delete-extent set-extent-endpoints] 4] isearch-dehighlight #[(totally) " \n ! !lj) ! !lj" [isearch-highlight isearch-extent totally t inhibit-quit extentp delete-extent nil detach-extent] 2] isearch-search #[nil "\" ! Ȫɪ Ώ? \"@8\"@8b" [isearch-message nil t case-fold-search search-caps-disable-folding isearch-no-upper-case-p isearch-string isearch-case-fold-search " Isearch" " ISeARch" "Isearch" isearch-mode lossage (byte-code "  Ȫɪ ʪ˪̪#єѕ*" [nil isearch-case-fold-search case-fold-search inhibit-quit isearch-regexp isearch-invalid-regexp 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 0 isearch-other-end] 5) ((quit (byte-code " !Ç" [character-to-event interrupt-char unread-command-event nil isearch-success] 2)) (invalid-regexp (byte-code "A@ \"!‡" [lossage isearch-invalid-regexp string-match "\\`Premature \\|\\`Unmatched \\|\\`Invalid " gettext "incomplete input"] 3))) isearch-success executing-macro defining-kbd-macro isearch-done ding isearch-failed 3 isearch-cmds 2] 3]] 2) (fset 'isearch-no-upper-case-p #[(string) " \")?" [nil case-fold-search string-match "\\(^\\|[^\\]\\)[A-Z]" string] 3 "\ Return t if there are no upper case chars in string. But upper case chars preceeded by \\ do not count since they have special meaning in a regexp."])