2233
|
1 ;;; isearch.el --- incremental search minor mode.
|
2230
|
2
|
11235
|
3 ;; Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
|
846
|
4
|
2230
|
5 ;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
|
11969
|
6 ;; Maintainer: FSF
|
725
|
7
|
4839
|
8 ;; This file is part of GNU Emacs.
|
725
|
9
|
6736
|
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
11 ;; it under the terms of the GNU General Public License as published by
|
|
12 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
13 ;; any later version.
|
725
|
14
|
6736
|
15 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
18 ;; GNU General Public License for more details.
|
|
19
|
|
20 ;; You should have received a copy of the GNU General Public License
|
14169
|
21 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
23 ;; Boston, MA 02111-1307, USA.
|
725
|
24
|
2230
|
25 ;;; Commentary:
|
|
26
|
725
|
27 ;; Instructions
|
|
28
|
1142
|
29 ;; For programmed use of isearch-mode, e.g. calling (isearch-forward),
|
|
30 ;; isearch-mode behaves modally and does not return until the search
|
|
31 ;; is completed. It uses a recursive-edit to behave this way. Note:
|
|
32 ;; gnus does it wrong: (call-interactively 'isearch-forward).
|
|
33
|
725
|
34 ;; The key bindings active within isearch-mode are defined below in
|
1142
|
35 ;; `isearch-mode-map' which is given bindings close to the default
|
|
36 ;; characters of the original isearch.el. With `isearch-mode',
|
|
37 ;; however, you can bind multi-character keys and it should be easier
|
|
38 ;; to add new commands. One bug though: keys with meta-prefix cannot
|
|
39 ;; be longer than two chars. Also see minibuffer-local-isearch-map
|
|
40 ;; for bindings active during `isearch-edit-string'.
|
725
|
41
|
1142
|
42 ;; Note to emacs version 19 users: isearch-mode should work even if
|
|
43 ;; you switch windows with the mouse, in which case isearch-mode is
|
|
44 ;; terminated automatically before the switch. This is true of lemacs
|
|
45 ;; too, with a few more cleanups I've neglected in this release.
|
|
46 ;; No one has supplied patches for epoch yet.
|
725
|
47
|
1142
|
48 ;; The search ring and completion commands automatically put you in
|
|
49 ;; the minibuffer to edit the string. This gives you a chance to
|
|
50 ;; modify the search string before executing the search. There are
|
|
51 ;; three commands to terminate the editing: C-s and C-r exit the
|
|
52 ;; minibuffer and search forward and reverse respectively, while C-m
|
|
53 ;; exits and does a nonincremental search.
|
|
54
|
|
55 ;; Exiting immediately from isearch uses isearch-edit-string instead
|
|
56 ;; of nonincremental-search, if search-nonincremental-instead is non-nil.
|
|
57 ;; The name of this option should probably be changed if we decide to
|
|
58 ;; keep the behavior. No point in forcing nonincremental search until
|
|
59 ;; the last possible moment.
|
|
60
|
|
61 ;; TODO
|
3591
|
62 ;; - Integrate the emacs 19 generalized command history.
|
1142
|
63 ;; - Think about incorporating query-replace.
|
|
64 ;; - Hooks and options for failed search.
|
792
|
65
|
2230
|
66 ;;; Change Log:
|
|
67
|
14169
|
68 ;; Changes before those recorded in ChangeLog:
|
792
|
69
|
14169
|
70 ;; Revision 1.4 92/09/14 16:26:02 liberte
|
|
71 ;; Added prefix args to isearch-forward, etc. to switch between
|
|
72 ;; string and regular expression searching.
|
|
73 ;; Added some support for lemacs.
|
|
74 ;; Added general isearch-highlight option - but only for lemacs so far.
|
|
75 ;; Added support for frame switching in emacs 19.
|
|
76 ;; Added word search option to isearch-edit-string.
|
|
77 ;; Renamed isearch-quit to isearch-abort.
|
|
78 ;; Numerous changes to comments and doc strings.
|
|
79 ;;
|
|
80 ;; Revision 1.3 92/06/29 13:10:08 liberte
|
|
81 ;; Moved modal isearch-mode handling into isearch-mode.
|
|
82 ;; Got rid of buffer-local isearch variables.
|
|
83 ;; isearch-edit-string used by ring adjustments, completion, and
|
|
84 ;; nonincremental searching. C-s and C-r are additional exit commands.
|
|
85 ;; Renamed all regex to regexp.
|
|
86 ;; Got rid of found-start and found-point globals.
|
|
87 ;; Generalized handling of upper-case chars.
|
792
|
88
|
14169
|
89 ;; Revision 1.2 92/05/27 11:33:57 liberte
|
|
90 ;; Emacs version 19 has a search ring, which is supported here.
|
|
91 ;; Other fixes found in the version 19 isearch are included here.
|
|
92 ;;
|
|
93 ;; Also see variables search-caps-disable-folding,
|
|
94 ;; search-nonincremental-instead, search-whitespace-regexp, and
|
|
95 ;; commands isearch-toggle-regexp, isearch-edit-string.
|
|
96 ;;
|
|
97 ;; semi-modal isearching is supported.
|
|
98
|
|
99 ;; Changes for 1.1
|
|
100 ;; 3/18/92 Fixed invalid-regexp.
|
|
101 ;; 3/18/92 Fixed yanking in regexps.
|
792
|
102
|
2230
|
103 ;;; Code:
|
1142
|
104
|
|
105
|
9935
|
106 ;;; Some additional options and constants.
|
1142
|
107
|
1143
|
108 (defconst search-exit-option t
|
1169
|
109 "*Non-nil means random control characters terminate incremental search.")
|
725
|
110
|
1143
|
111 (defvar search-slow-window-lines 1
|
|
112 "*Number of lines in slow search display windows.
|
|
113 These are the short windows used during incremental search on slow terminals.
|
|
114 Negative means put the slow search window at the top (normally it's at bottom)
|
|
115 and the value is minus the number of lines.")
|
725
|
116
|
1143
|
117 (defvar search-slow-speed 1200
|
|
118 "*Highest terminal speed at which to use \"slow\" style incremental search.
|
|
119 This is the style where a one-line window is created to show the line
|
|
120 that the search has reached.")
|
725
|
121
|
3526
|
122 (defvar search-upper-case 'not-yanks
|
725
|
123 "*If non-nil, upper case chars disable case fold searching.
|
1142
|
124 That is, upper and lower case chars must match exactly.
|
|
125 This applies no matter where the chars come from, but does not
|
1143
|
126 apply to chars in regexps that are prefixed with `\\'.
|
|
127 If this value is `not-yanks', yanked text is always downcased.")
|
725
|
128
|
|
129 (defvar search-nonincremental-instead t
|
|
130 "*If non-nil, do a nonincremental search instead if exiting immediately.
|
1142
|
131 Actually, `isearch-edit-string' is called to let you enter the search
|
|
132 string, and RET terminates editing and does a nonincremental search.")
|
725
|
133
|
|
134 (defconst search-whitespace-regexp "\\s-+"
|
|
135 "*If non-nil, regular expression to match a sequence of whitespace chars.
|
|
136 You might want to use something like \"[ \\t\\r\\n]+\" instead.")
|
|
137
|
1142
|
138 (defvar search-highlight nil
|
3526
|
139 "*Non-nil means incremental search highlights the current match.")
|
1142
|
140
|
|
141 (defvar isearch-mode-hook nil
|
|
142 "Function(s) to call after starting up an incremental search.")
|
|
143
|
|
144 (defvar isearch-mode-end-hook nil
|
|
145 "Function(s) to call after terminating an incremental search.")
|
|
146
|
725
|
147 ;;; Search ring.
|
|
148
|
|
149 (defvar search-ring nil
|
|
150 "List of search string sequences.")
|
1142
|
151 (defvar regexp-search-ring nil
|
725
|
152 "List of regular expression search string sequences.")
|
|
153
|
|
154 (defconst search-ring-max 16
|
|
155 "*Maximum length of search ring before oldest elements are thrown away.")
|
1142
|
156 (defconst regexp-search-ring-max 16
|
|
157 "*Maximum length of regexp search ring before oldest elements are thrown away.")
|
725
|
158
|
|
159 (defvar search-ring-yank-pointer nil
|
1146
|
160 "Index in `search-ring' of last string reused.
|
|
161 nil if none yet.")
|
1142
|
162 (defvar regexp-search-ring-yank-pointer nil
|
1146
|
163 "Index in `regexp-search-ring' of last string reused.
|
|
164 nil if none yet.")
|
725
|
165
|
1142
|
166 (defvar search-ring-update nil
|
|
167 "*Non-nil if advancing or retreating in the search ring should cause search.
|
|
168 Default value, nil, means edit the string instead.")
|
|
169
|
725
|
170 ;;; Define isearch-mode keymap.
|
|
171
|
|
172 (defvar isearch-mode-map nil
|
|
173 "Keymap for isearch-mode.")
|
|
174
|
1142
|
175 (or isearch-mode-map
|
|
176 (let* ((i 0)
|
1143
|
177 (map (make-keymap)))
|
2857
|
178 (or (vectorp (nth 1 map))
|
|
179 (error "The initialization of isearch-mode-map must be updated"))
|
|
180 ;; Give this map a vector 256 long, for dense binding
|
|
181 ;; of a larger range of ordinary characters.
|
|
182 (setcar (cdr map) (make-vector 256 nil))
|
1142
|
183
|
1458
|
184 ;; Make function keys, etc, exit the search.
|
|
185 (define-key map [t] 'isearch-other-control-char)
|
1142
|
186 ;; Control chars, by default, end isearch mode transparently.
|
1458
|
187 ;; We need these explicit definitions because, in a dense keymap,
|
|
188 ;; the binding for t does not affect characters.
|
|
189 ;; We use a dense keymap to save space.
|
1142
|
190 (while (< i ?\ )
|
|
191 (define-key map (make-string 1 i) 'isearch-other-control-char)
|
|
192 (setq i (1+ i)))
|
|
193
|
2889
debc28aaae2c
(isearch-mode-map): Use vector, not string, to bind printing characters.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
194 ;; Printing chars extend the search string by default.
|
1458
|
195 (setq i ?\ )
|
2788
|
196 (while (< i (length (nth 1 map)))
|
2889
debc28aaae2c
(isearch-mode-map): Use vector, not string, to bind printing characters.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
197 (define-key map (vector i) 'isearch-printing-char)
|
1142
|
198 (setq i (1+ i)))
|
|
199
|
10166
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
200 ;; To handle local bindings with meta char prefix keys, define
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
201 ;; another full keymap. This must be done for any other prefix
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
202 ;; keys as well, one full keymap per char of the prefix key. It
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
203 ;; would be simpler to disable the global keymap, and/or have a
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
204 ;; default local key binding for any key not otherwise bound.
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
205 (let ((meta-map (make-sparse-keymap)))
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
206 (define-key map (char-to-string meta-prefix-char) meta-map)
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
207 (define-key map [escape] meta-map))
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
208 (define-key map (vector meta-prefix-char t) 'isearch-other-meta-char)
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
209
|
1142
|
210 ;; Several non-printing chars change the searching behavior.
|
|
211 (define-key map "\C-s" 'isearch-repeat-forward)
|
|
212 (define-key map "\C-r" 'isearch-repeat-backward)
|
|
213 (define-key map "\177" 'isearch-delete-char)
|
|
214 (define-key map "\C-g" 'isearch-abort)
|
10166
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
215 ;; This assumes \e is the meta-prefix-char.
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
216 (or (= ?\e meta-prefix-char)
|
2cc7d710cf56
(isearch-mode-map): Move the code to set up the meta submap earlier in
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
217 (error "Inconsistency in isearch.el"))
|
10117
|
218 (define-key map "\e\e\e" 'isearch-cancel)
|
|
219 (define-key map [escape escape escape] 'isearch-cancel)
|
1142
|
220
|
|
221 (define-key map "\C-q" 'isearch-quote-char)
|
|
222
|
|
223 (define-key map "\r" 'isearch-exit)
|
|
224 (define-key map "\C-j" 'isearch-printing-char)
|
|
225 (define-key map "\t" 'isearch-printing-char)
|
|
226 (define-key map " " 'isearch-whitespace-chars)
|
|
227
|
|
228 (define-key map "\C-w" 'isearch-yank-word)
|
|
229 (define-key map "\C-y" 'isearch-yank-line)
|
|
230
|
|
231 ;; Define keys for regexp chars * ? |.
|
|
232 ;; Nothing special for + because it matches at least once.
|
|
233 (define-key map "*" 'isearch-*-char)
|
|
234 (define-key map "?" 'isearch-*-char)
|
|
235 (define-key map "|" 'isearch-|-char)
|
|
236
|
2425
|
237 ;;; Turned off because I find I expect to get the global definition--rms.
|
|
238 ;;; ;; Instead bind C-h to special help command for isearch-mode.
|
|
239 ;;; (define-key map "\C-h" 'isearch-mode-help)
|
1142
|
240
|
|
241 (define-key map "\M-n" 'isearch-ring-advance)
|
|
242 (define-key map "\M-p" 'isearch-ring-retreat)
|
4876
|
243 (define-key map "\M-y" 'isearch-yank-kill)
|
1557
|
244
|
1142
|
245 (define-key map "\M-\t" 'isearch-complete)
|
|
246
|
12284
|
247 ;; Pass frame events transparently so they won't exit the search.
|
|
248 ;; In particular, if we have more than one display open, then a
|
|
249 ;; switch-frame might be generated by someone typing at another keyboard.
|
|
250 (define-key map [switch-frame] nil)
|
|
251 (define-key map [delete-frame] nil)
|
|
252 (define-key map [iconify-frame] nil)
|
|
253 (define-key map [make-frame-visible] nil)
|
|
254
|
1142
|
255 (setq isearch-mode-map map)
|
|
256 ))
|
|
257
|
|
258 ;; Some bindings you may want to put in your isearch-mode-hook.
|
|
259 ;; Suggest some alternates...
|
7294
|
260 ;; (define-key isearch-mode-map "\C-t" 'isearch-toggle-case-fold)
|
1142
|
261 ;; (define-key isearch-mode-map "\C-t" 'isearch-toggle-regexp)
|
|
262 ;; (define-key isearch-mode-map "\C-^" 'isearch-edit-string)
|
725
|
263
|
|
264
|
1142
|
265 (defvar minibuffer-local-isearch-map nil
|
|
266 "Keymap for editing isearch strings in the minibuffer.")
|
725
|
267
|
1142
|
268 (or minibuffer-local-isearch-map
|
|
269 (let ((map (copy-keymap minibuffer-local-map)))
|
|
270 (define-key map "\r" 'isearch-nonincremental-exit-minibuffer)
|
1184
|
271 (define-key map "\M-n" 'isearch-ring-advance-edit)
|
|
272 (define-key map "\M-p" 'isearch-ring-retreat-edit)
|
1142
|
273 (define-key map "\M-\t" 'isearch-complete-edit)
|
|
274 (define-key map "\C-s" 'isearch-forward-exit-minibuffer)
|
|
275 (define-key map "\C-r" 'isearch-reverse-exit-minibuffer)
|
|
276 (setq minibuffer-local-isearch-map map)
|
|
277 ))
|
725
|
278
|
|
279 ;; Internal variables declared globally for byte-compiler.
|
1142
|
280 ;; These are all set with setq while isearching
|
|
281 ;; and bound locally while editing the search string.
|
|
282
|
|
283 (defvar isearch-forward nil) ; Searching in the forward direction.
|
|
284 (defvar isearch-regexp nil) ; Searching for a regexp.
|
|
285 (defvar isearch-word nil) ; Searching for words.
|
725
|
286
|
1142
|
287 (defvar isearch-cmds nil) ; Stack of search status sets.
|
|
288 (defvar isearch-string "") ; The current search string.
|
|
289 (defvar isearch-message "") ; text-char-description version of isearch-string
|
|
290
|
|
291 (defvar isearch-success t) ; Searching is currently successful.
|
|
292 (defvar isearch-invalid-regexp nil) ; Regexp not well formed.
|
5601
|
293 (defvar isearch-within-brackets nil) ; Regexp has unclosed [.
|
1142
|
294 (defvar isearch-other-end nil) ; Start (end) of match if forward (backward).
|
|
295 (defvar isearch-wrapped nil) ; Searching restarted from the top (bottom).
|
725
|
296 (defvar isearch-barrier 0)
|
13799
|
297 (defvar isearch-just-started nil)
|
725
|
298
|
7294
|
299 ; case-fold-search while searching.
|
|
300 ; either nil, t, or 'yes. 'yes means the same as t except that mixed
|
|
301 ; case in the search string is ignored.
|
|
302 (defvar isearch-case-fold-search nil)
|
725
|
303
|
|
304 (defvar isearch-adjusted nil)
|
|
305 (defvar isearch-slow-terminal-mode nil)
|
1142
|
306 ;;; If t, using a small window.
|
|
307 (defvar isearch-small-window nil)
|
|
308 (defvar isearch-opoint 0)
|
|
309 ;;; The window configuration active at the beginning of the search.
|
|
310 (defvar isearch-window-configuration nil)
|
725
|
311
|
1142
|
312 ;; Flag to indicate a yank occurred, so don't move the cursor.
|
|
313 (defvar isearch-yank-flag nil)
|
725
|
314
|
1142
|
315 ;;; A function to be called after each input character is processed.
|
|
316 ;;; (It is not called after characters that exit the search.)
|
|
317 ;;; It is only set from an optional argument to `isearch-mode'.
|
|
318 (defvar isearch-op-fun nil)
|
725
|
319
|
1142
|
320 ;;; Is isearch-mode in a recursive edit for modal searching.
|
|
321 (defvar isearch-recursive-edit nil)
|
725
|
322
|
1142
|
323 ;;; Should isearch be terminated after doing one search?
|
|
324 (defvar isearch-nonincremental nil)
|
|
325
|
|
326 ;; New value of isearch-forward after isearch-edit-string.
|
|
327 (defvar isearch-new-forward nil)
|
|
328
|
725
|
329
|
|
330 ;; Minor-mode-alist changes - kind of redundant with the
|
|
331 ;; echo area, but if isearching in multiple windows, it can be useful.
|
|
332
|
|
333 (or (assq 'isearch-mode minor-mode-alist)
|
|
334 (nconc minor-mode-alist
|
|
335 (list '(isearch-mode isearch-mode))))
|
|
336
|
1142
|
337 (defvar isearch-mode nil) ;; Name of the minor mode, if non-nil.
|
725
|
338 (make-variable-buffer-local 'isearch-mode)
|
|
339
|
1143
|
340 (define-key global-map "\C-s" 'isearch-forward)
|
|
341 (define-key esc-map "\C-s" 'isearch-forward-regexp)
|
|
342 (define-key global-map "\C-r" 'isearch-backward)
|
|
343 (define-key esc-map "\C-r" 'isearch-backward-regexp)
|
|
344
|
725
|
345 ;;; Entry points to isearch-mode.
|
1142
|
346 ;;; These four functions should replace those in loaddefs.el
|
2572
|
347 ;;; An alternative is to defalias isearch-forward etc to isearch-mode,
|
1142
|
348 ;;; and look at this-command to set the options accordingly.
|
725
|
349
|
1883
|
350 (defun isearch-forward (&optional regexp-p no-recursive-edit)
|
725
|
351 "\
|
|
352 Do incremental search forward.
|
1142
|
353 With a prefix argument, do an incremental regular expression search instead.
|
725
|
354 \\<isearch-mode-map>
|
1142
|
355 As you type characters, they add to the search string and are found.
|
|
356 The following non-printing keys are bound in `isearch-mode-map'.
|
|
357
|
|
358 Type \\[isearch-delete-char] to cancel characters from end of search string.
|
725
|
359 Type \\[isearch-exit] to exit, leaving point at location found.
|
1142
|
360 Type LFD (C-j) to match end of line.
|
|
361 Type \\[isearch-repeat-forward] to search again forward,\
|
|
362 \\[isearch-repeat-backward] to search again backward.
|
|
363 Type \\[isearch-yank-word] to yank word from buffer onto end of search\
|
|
364 string and search for it.
|
|
365 Type \\[isearch-yank-line] to yank rest of line onto end of search string\
|
|
366 and search for it.
|
725
|
367 Type \\[isearch-quote-char] to quote control character to search for it.
|
1142
|
368 \\[isearch-abort] while searching or when search has failed cancels input\
|
|
369 back to what has
|
|
370 been found successfully.
|
|
371 \\[isearch-abort] when search is successful aborts and moves point to\
|
|
372 starting point.
|
725
|
373
|
|
374 Also supported is a search ring of the previous 16 search strings.
|
|
375 Type \\[isearch-ring-advance] to search for the next item in the search ring.
|
1142
|
376 Type \\[isearch-ring-retreat] to search for the previous item in the search\
|
|
377 ring.
|
|
378 Type \\[isearch-complete] to complete the search string using the search ring.
|
725
|
379
|
1142
|
380 The above keys, bound in `isearch-mode-map', are often controlled by
|
|
381 options; do M-x apropos on search-.* to find them.
|
|
382 Other control and meta characters terminate the search
|
|
383 and are then executed normally (depending on `search-exit-option').
|
13112
|
384 Likewise for function keys and mouse button events.
|
725
|
385
|
1142
|
386 If this function is called non-interactively, it does not return to
|
|
387 the calling function until the search is done."
|
|
388
|
1883
|
389 (interactive "P\np")
|
1885
|
390 (isearch-mode t (not (null regexp-p)) nil (not no-recursive-edit)))
|
1142
|
391
|
1883
|
392 (defun isearch-forward-regexp (&optional not-regexp no-recursive-edit)
|
725
|
393 "\
|
|
394 Do incremental search forward for regular expression.
|
1142
|
395 With a prefix argument, do a regular string search instead.
|
725
|
396 Like ordinary incremental search except that your input
|
|
397 is treated as a regexp. See \\[isearch-forward] for more info."
|
1883
|
398 (interactive "P\np")
|
1885
|
399 (isearch-mode t (null not-regexp) nil (not no-recursive-edit)))
|
725
|
400
|
1883
|
401 (defun isearch-backward (&optional regexp-p no-recursive-edit)
|
725
|
402 "\
|
|
403 Do incremental search backward.
|
1142
|
404 With a prefix argument, do a regular expression search instead.
|
725
|
405 See \\[isearch-forward] for more information."
|
1883
|
406 (interactive "P\np")
|
1885
|
407 (isearch-mode nil (not (null regexp-p)) nil (not no-recursive-edit)))
|
725
|
408
|
1883
|
409 (defun isearch-backward-regexp (&optional not-regexp no-recursive-edit)
|
725
|
410 "\
|
|
411 Do incremental search backward for regular expression.
|
1142
|
412 With a prefix argument, do a regular string search instead.
|
725
|
413 Like ordinary incremental search except that your input
|
|
414 is treated as a regexp. See \\[isearch-forward] for more info."
|
1883
|
415 (interactive "P\np")
|
1885
|
416 (isearch-mode nil (null not-regexp) nil (not no-recursive-edit)))
|
725
|
417
|
|
418
|
1142
|
419 (defun isearch-mode-help ()
|
|
420 (interactive)
|
|
421 (describe-function 'isearch-forward)
|
|
422 (isearch-update))
|
725
|
423
|
|
424
|
|
425 ;; isearch-mode only sets up incremental search for the minor mode.
|
|
426 ;; All the work is done by the isearch-mode commands.
|
|
427
|
1142
|
428 ;; Not used yet:
|
|
429 ;;(defconst isearch-commands '(isearch-forward isearch-backward
|
|
430 ;; isearch-forward-regexp isearch-backward-regexp)
|
|
431 ;; "List of commands for which isearch-mode does not recursive-edit.")
|
|
432
|
|
433
|
|
434 (defun isearch-mode (forward &optional regexp op-fun recursive-edit word-p)
|
11643
|
435 "Start isearch minor mode. Called by `isearch-forward', etc.
|
|
436
|
|
437 \\{isearch-mode-map}"
|
725
|
438
|
|
439 ;; Initialize global vars.
|
|
440 (setq isearch-forward forward
|
|
441 isearch-regexp regexp
|
1142
|
442 isearch-word word-p
|
725
|
443 isearch-op-fun op-fun
|
|
444 isearch-case-fold-search case-fold-search
|
|
445 isearch-string ""
|
|
446 isearch-message ""
|
|
447 isearch-cmds nil
|
|
448 isearch-success t
|
|
449 isearch-wrapped nil
|
|
450 isearch-barrier (point)
|
|
451 isearch-adjusted nil
|
|
452 isearch-yank-flag nil
|
|
453 isearch-invalid-regexp nil
|
5601
|
454 isearch-within-brackets nil
|
9940
|
455 isearch-slow-terminal-mode (and (<= baud-rate search-slow-speed)
|
725
|
456 (> (window-height)
|
|
457 (* 4 search-slow-window-lines)))
|
|
458 isearch-other-end nil
|
|
459 isearch-small-window nil
|
13799
|
460 isearch-just-started t
|
725
|
461
|
|
462 isearch-opoint (point)
|
1146
|
463 search-ring-yank-pointer nil
|
|
464 regexp-search-ring-yank-pointer nil)
|
13799
|
465 (looking-at "")
|
5554
0ac0776c23af
(isearch-mode): If not slow, clear isearch-window-configuration.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
466 (setq isearch-window-configuration
|
0ac0776c23af
(isearch-mode): If not slow, clear isearch-window-configuration.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
467 (if isearch-slow-terminal-mode (current-window-configuration) nil))
|
3476
6c6d1c6afb57
(isearch-mode): Set isearch-window-configuration only if in slow mode.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
468
|
725
|
469 (setq isearch-mode " Isearch") ;; forward? regexp?
|
11579
|
470 (force-mode-line-update)
|
725
|
471
|
|
472 (isearch-push-state)
|
|
473
|
12265
1d2296cfa1e3
(isearch-mode): Use overriding-terminal-local-map, not overriding-local-map.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
474 (setq overriding-terminal-local-map isearch-mode-map)
|
725
|
475 (isearch-update)
|
|
476 (run-hooks 'isearch-mode-hook)
|
1142
|
477
|
14939
|
478 (add-hook 'mouse-leave-buffer-hook 'isearch-done)
|
10257
|
479
|
1142
|
480 ;; isearch-mode can be made modal (in the sense of not returning to
|
|
481 ;; the calling function until searching is completed) by entering
|
|
482 ;; a recursive-edit and exiting it when done isearching.
|
3385
|
483 (if recursive-edit
|
|
484 (let ((isearch-recursive-edit t))
|
|
485 (recursive-edit)))
|
8663
|
486 isearch-success)
|
725
|
487
|
|
488
|
|
489 ;; Some high level utilities. Others below.
|
|
490
|
|
491 (defun isearch-update ()
|
|
492 ;; Called after each command to update the display.
|
9935
|
493 (if (null unread-command-events)
|
725
|
494 (progn
|
|
495 (if (not (input-pending-p))
|
|
496 (isearch-message))
|
|
497 (if (and isearch-slow-terminal-mode
|
|
498 (not (or isearch-small-window
|
|
499 (pos-visible-in-window-p))))
|
1142
|
500 (let ((found-point (point)))
|
725
|
501 (setq isearch-small-window t)
|
|
502 (move-to-window-line 0)
|
|
503 (let ((window-min-height 1))
|
|
504 (split-window nil (if (< search-slow-window-lines 0)
|
|
505 (1+ (- search-slow-window-lines))
|
|
506 (- (window-height)
|
|
507 (1+ search-slow-window-lines)))))
|
|
508 (if (< search-slow-window-lines 0)
|
|
509 (progn (vertical-motion (- 1 search-slow-window-lines))
|
|
510 (set-window-start (next-window) (point))
|
|
511 (set-window-hscroll (next-window)
|
|
512 (window-hscroll))
|
|
513 (set-window-hscroll (selected-window) 0))
|
|
514 (other-window 1))
|
1142
|
515 (goto-char found-point)))
|
|
516 (if isearch-other-end
|
|
517 (if (< isearch-other-end (point)) ; isearch-forward?
|
|
518 (isearch-highlight isearch-other-end (point))
|
5328
|
519 (isearch-highlight (point) isearch-other-end))
|
|
520 (isearch-dehighlight nil))
|
1142
|
521 ))
|
725
|
522 (setq ;; quit-flag nil not for isearch-mode
|
|
523 isearch-adjusted nil
|
|
524 isearch-yank-flag nil)
|
|
525 )
|
|
526
|
8663
|
527 (defun isearch-done (&optional nopush edit)
|
14939
|
528 (remove-hook 'mouse-leave-buffer-hook 'isearch-done)
|
725
|
529 ;; Called by all commands that terminate isearch-mode.
|
1184
|
530 ;; If NOPUSH is non-nil, we don't push the string on the search ring.
|
12265
1d2296cfa1e3
(isearch-mode): Use overriding-terminal-local-map, not overriding-local-map.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
531 (setq overriding-terminal-local-map nil)
|
1142
|
532 ;; (setq pre-command-hook isearch-old-pre-command-hook) ; for lemacs
|
|
533 (isearch-dehighlight t)
|
|
534 (let ((found-start (window-start (selected-window)))
|
|
535 (found-point (point)))
|
3476
6c6d1c6afb57
(isearch-mode): Set isearch-window-configuration only if in slow mode.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
536 (if isearch-window-configuration
|
6c6d1c6afb57
(isearch-mode): Set isearch-window-configuration only if in slow mode.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
537 (set-window-configuration isearch-window-configuration))
|
1142
|
538
|
4379
|
539 (if isearch-small-window
|
|
540 (goto-char found-point)
|
|
541 ;; Exiting the save-window-excursion clobbers window-start; restore it.
|
10183
|
542 (set-window-start (selected-window) found-start t))
|
4379
|
543
|
1142
|
544 ;; If there was movement, mark the starting position.
|
|
545 ;; Maybe should test difference between and set mark iff > threshold.
|
|
546 (if (/= (point) isearch-opoint)
|
10183
|
547 (or (and transient-mark-mode mark-active)
|
|
548 (progn
|
|
549 (push-mark isearch-opoint t)
|
13682
|
550 (or executing-kbd-macro (> (minibuffer-depth) 0)
|
10183
|
551 (message "Mark saved where search started"))))))
|
1142
|
552
|
|
553 (setq isearch-mode nil)
|
11579
|
554 (force-mode-line-update)
|
725
|
555
|
1184
|
556 (if (and (> (length isearch-string) 0) (not nopush))
|
725
|
557 ;; Update the ring data.
|
11100
|
558 (isearch-update-ring isearch-string isearch-regexp))
|
725
|
559
|
1142
|
560 (run-hooks 'isearch-mode-end-hook)
|
8663
|
561 (and (not edit) isearch-recursive-edit (exit-recursive-edit)))
|
1142
|
562
|
11100
|
563 (defun isearch-update-ring (string &optional regexp)
|
|
564 "Add STRING to the beginning of the search ring.
|
|
565 REGEXP says which ring to use."
|
|
566 (if regexp
|
|
567 (if (or (null regexp-search-ring)
|
11526
|
568 (not (string= string (car regexp-search-ring))))
|
11100
|
569 (progn
|
|
570 (setq regexp-search-ring
|
11526
|
571 (cons string regexp-search-ring))
|
11100
|
572 (if (> (length regexp-search-ring) regexp-search-ring-max)
|
|
573 (setcdr (nthcdr (1- search-ring-max) regexp-search-ring)
|
|
574 nil))))
|
|
575 (if (or (null search-ring)
|
11526
|
576 (not (string= string (car search-ring))))
|
11100
|
577 (progn
|
11526
|
578 (setq search-ring (cons string search-ring))
|
11100
|
579 (if (> (length search-ring) search-ring-max)
|
|
580 (setcdr (nthcdr (1- search-ring-max) search-ring) nil))))))
|
|
581
|
1142
|
582 ;;; Switching buffers should first terminate isearch-mode.
|
3591
|
583 ;;; This is done quite differently for each variant of emacs.
|
1142
|
584 ;;; For lemacs, see Exiting in lemacs below
|
725
|
585
|
1142
|
586 ;; For Emacs 19, the frame switch event is handled.
|
|
587 (defun isearch-switch-frame-handler ()
|
|
588 (interactive) ;; Is this necessary?
|
|
589 ;; First terminate isearch-mode.
|
|
590 (isearch-done)
|
2296
|
591 (handle-switch-frame (car (cdr (isearch-last-command-char)))))
|
725
|
592
|
|
593
|
|
594 ;; Commands active while inside of the isearch minor mode.
|
|
595
|
|
596 (defun isearch-exit ()
|
|
597 "Exit search normally.
|
|
598 However, if this is the first command after starting incremental
|
|
599 search and `search-nonincremental-instead' is non-nil, do a
|
1142
|
600 nonincremental search instead via `isearch-edit-string'."
|
725
|
601 (interactive)
|
|
602 (if (and search-nonincremental-instead
|
|
603 (= 0 (length isearch-string)))
|
1142
|
604 (let ((isearch-nonincremental t))
|
|
605 (isearch-edit-string)))
|
725
|
606 (isearch-done))
|
|
607
|
|
608
|
|
609 (defun isearch-edit-string ()
|
1142
|
610 "Edit the search string in the minibuffer.
|
|
611 The following additional command keys are active while editing.
|
|
612 \\<minibuffer-local-isearch-map>
|
|
613 \\[exit-minibuffer] to resume incremental searching with the edited string.
|
|
614 \\[isearch-nonincremental-exit-minibuffer] to do one nonincremental search.
|
|
615 \\[isearch-forward-exit-minibuffer] to resume isearching forward.
|
7378
|
616 \\[isearch-reverse-exit-minibuffer] to resume isearching backward.
|
1142
|
617 \\[isearch-ring-advance-edit] to replace the search string with the next item in the search ring.
|
3591
|
618 \\[isearch-ring-retreat-edit] to replace the search string with the previous item in the search ring.
|
1142
|
619 \\[isearch-complete-edit] to complete the search string using the search ring.
|
7378
|
620 \\<isearch-mode-map>
|
1142
|
621 If first char entered is \\[isearch-yank-word], then do word search instead."
|
|
622
|
|
623 ;; This code is very hairy for several reasons, explained in the code.
|
|
624 ;; Mainly, isearch-mode must be terminated while editing and then restarted.
|
|
625 ;; If there were a way to catch any change of buffer from the minibuffer,
|
|
626 ;; this could be simplified greatly.
|
3591
|
627 ;; Editing doesn't back up the search point. Should it?
|
725
|
628 (interactive)
|
1142
|
629 (condition-case err
|
4095
f60102c4b948
(isearch-edit-string): Bind isearch-nonincremental to its own value, not to
Roland McGrath <roland@gnu.org>
diff
changeset
|
630 (let ((isearch-nonincremental isearch-nonincremental)
|
1142
|
631
|
|
632 ;; Locally bind all isearch global variables to protect them
|
|
633 ;; from recursive isearching.
|
|
634 ;; isearch-string -message and -forward are not bound
|
|
635 ;; so they may be changed. Instead, save the values.
|
|
636 (isearch-new-string isearch-string)
|
|
637 (isearch-new-message isearch-message)
|
|
638 (isearch-new-forward isearch-forward)
|
|
639 (isearch-new-word isearch-word)
|
|
640
|
|
641 (isearch-regexp isearch-regexp)
|
|
642 (isearch-op-fun isearch-op-fun)
|
|
643 (isearch-cmds isearch-cmds)
|
|
644 (isearch-success isearch-success)
|
|
645 (isearch-wrapped isearch-wrapped)
|
|
646 (isearch-barrier isearch-barrier)
|
|
647 (isearch-adjusted isearch-adjusted)
|
|
648 (isearch-yank-flag isearch-yank-flag)
|
|
649 (isearch-invalid-regexp isearch-invalid-regexp)
|
5601
|
650 (isearch-within-brackets isearch-within-brackets)
|
11969
|
651 ;;; Don't bind this. We want isearch-search, below, to set it.
|
|
652 ;;; And the old value won't matter after that.
|
|
653 ;;; (isearch-other-end isearch-other-end)
|
|
654 ;;; Perhaps some of these other variables should be bound for a
|
|
655 ;;; shorter period, ending before the next isearch-search.
|
|
656 ;;; But there doesn't seem to be a real bug, so let's not risk it now.
|
1142
|
657 (isearch-opoint isearch-opoint)
|
|
658 (isearch-slow-terminal-mode isearch-slow-terminal-mode)
|
|
659 (isearch-small-window isearch-small-window)
|
|
660 (isearch-recursive-edit isearch-recursive-edit)
|
|
661 ;; Save current configuration so we can restore it here.
|
|
662 (isearch-window-configuration (current-window-configuration))
|
|
663 )
|
|
664
|
|
665 ;; Actually terminate isearching until editing is done.
|
|
666 ;; This is so that the user can do anything without failure,
|
|
667 ;; like switch buffers and start another isearch, and return.
|
|
668 (condition-case err
|
8663
|
669 (isearch-done t t)
|
1142
|
670 (exit nil)) ; was recursive editing
|
|
671
|
|
672 (isearch-message) ;; for read-char
|
|
673 (unwind-protect
|
|
674 (let* (;; Why does following read-char echo?
|
|
675 ;;(echo-keystrokes 0) ;; not needed with above message
|
1480
|
676 (e (let ((cursor-in-echo-area t))
|
4601
|
677 (read-event)))
|
1142
|
678 ;; Binding minibuffer-history-symbol to nil is a work-around
|
|
679 ;; for some incompatibility with gmhist.
|
10397
|
680 (minibuffer-history-symbol)
|
|
681 (message-log-max nil))
|
1142
|
682 ;; If the first character the user types when we prompt them
|
|
683 ;; for a string is the yank-word character, then go into
|
|
684 ;; word-search mode. Otherwise unread that character and
|
|
685 ;; read a key the normal way.
|
|
686 ;; Word search does not apply (yet) to regexp searches,
|
|
687 ;; no check is made here.
|
|
688 (message (isearch-message-prefix nil nil t))
|
|
689 (if (eq 'isearch-yank-word
|
4601
|
690 (lookup-key isearch-mode-map (vector e)))
|
1142
|
691 (setq isearch-word t ;; so message-prefix is right
|
|
692 isearch-new-word t)
|
|
693 (isearch-unread e))
|
1146
|
694 (setq cursor-in-echo-area nil)
|
|
695 (setq isearch-new-string
|
1184
|
696 (let (junk-ring)
|
9768
|
697 (read-from-minibuffer
|
|
698 (isearch-message-prefix nil nil isearch-nonincremental)
|
|
699 isearch-string
|
|
700 minibuffer-local-isearch-map nil
|
|
701 'junk-ring))
|
8670
|
702 isearch-new-message
|
|
703 (mapconcat 'isearch-text-char-description
|
|
704 isearch-new-string "")))
|
1142
|
705 ;; Always resume isearching by restarting it.
|
|
706 (isearch-mode isearch-forward
|
|
707 isearch-regexp
|
|
708 isearch-op-fun
|
8663
|
709 nil
|
1142
|
710 isearch-word)
|
|
711
|
|
712 ;; Copy new local values to isearch globals
|
|
713 (setq isearch-string isearch-new-string
|
|
714 isearch-message isearch-new-message
|
|
715 isearch-forward isearch-new-forward
|
|
716 isearch-word isearch-new-word))
|
|
717
|
|
718 ;; Empty isearch-string means use default.
|
|
719 (if (= 0 (length isearch-string))
|
13682
|
720 (setq isearch-string (or (car (if isearch-regexp
|
|
721 regexp-search-ring
|
|
722 search-ring))
|
|
723 ""))
|
1169
|
724 ;; This used to set the last search string,
|
|
725 ;; but I think it is not right to do that here.
|
|
726 ;; Only the string actually used should be saved.
|
|
727 )
|
1142
|
728
|
|
729 ;; Reinvoke the pending search.
|
|
730 (isearch-push-state)
|
|
731 (isearch-search)
|
|
732 (isearch-update)
|
|
733 (if isearch-nonincremental
|
|
734 (progn
|
|
735 ;; (sit-for 1) ;; needed if isearch-done does: (message "")
|
|
736 (isearch-done))))
|
|
737
|
|
738 (quit ; handle abort-recursive-edit
|
|
739 (isearch-abort) ;; outside of let to restore outside global values
|
|
740 )))
|
|
741
|
|
742 (defun isearch-nonincremental-exit-minibuffer ()
|
|
743 (interactive)
|
|
744 (setq isearch-nonincremental t)
|
|
745 (exit-minibuffer))
|
|
746
|
|
747 (defun isearch-forward-exit-minibuffer ()
|
|
748 (interactive)
|
|
749 (setq isearch-new-forward t)
|
|
750 (exit-minibuffer))
|
|
751
|
|
752 (defun isearch-reverse-exit-minibuffer ()
|
|
753 (interactive)
|
|
754 (setq isearch-new-forward nil)
|
|
755 (exit-minibuffer))
|
725
|
756
|
10117
|
757 (defun isearch-cancel ()
|
|
758 "Terminate the search and go back to the starting point."
|
|
759 (interactive)
|
|
760 (goto-char isearch-opoint)
|
|
761 (isearch-done t)
|
|
762 (signal 'quit nil)) ; and pass on quit signal
|
725
|
763
|
1142
|
764 (defun isearch-abort ()
|
13991
|
765 "Abort incremental search mode if searching is successful, signaling quit.
|
1142
|
766 Otherwise, revert to previous successful search and continue searching.
|
13991
|
767 Use `isearch-exit' to quit without signaling."
|
725
|
768 (interactive)
|
3591
|
769 ;; (ding) signal instead below, if quitting
|
725
|
770 (discard-input)
|
|
771 (if isearch-success
|
|
772 ;; If search is successful, move back to starting point
|
|
773 ;; and really do quit.
|
|
774 (progn (goto-char isearch-opoint)
|
11046
|
775 (setq isearch-success nil)
|
1184
|
776 (isearch-done t) ; exit isearch
|
1146
|
777 (signal 'quit nil)) ; and pass on quit signal
|
11061
|
778 ;; If search is failing, or has an incomplete regexp,
|
|
779 ;; rub out until it is once more successful.
|
|
780 (while (or (not isearch-success) isearch-invalid-regexp)
|
|
781 (isearch-pop-state))
|
725
|
782 (isearch-update)))
|
|
783
|
|
784 (defun isearch-repeat (direction)
|
|
785 ;; Utility for isearch-repeat-forward and -backward.
|
|
786 (if (eq isearch-forward (eq direction 'forward))
|
|
787 ;; C-s in forward or C-r in reverse.
|
|
788 (if (equal isearch-string "")
|
|
789 ;; If search string is empty, use last one.
|
|
790 (setq isearch-string
|
|
791 (or (if isearch-regexp
|
1146
|
792 (car regexp-search-ring)
|
|
793 (car search-ring))
|
725
|
794 "")
|
|
795 isearch-message
|
1142
|
796 (mapconcat 'isearch-text-char-description
|
725
|
797 isearch-string ""))
|
|
798 ;; If already have what to search for, repeat it.
|
|
799 (or isearch-success
|
|
800 (progn
|
|
801
|
|
802 (goto-char (if isearch-forward (point-min) (point-max)))
|
|
803 (setq isearch-wrapped t))))
|
|
804 ;; C-s in reverse or C-r in forward, change direction.
|
|
805 (setq isearch-forward (not isearch-forward)))
|
|
806
|
|
807 (setq isearch-barrier (point)) ; For subsequent \| if regexp.
|
5411
|
808
|
|
809 (if (equal isearch-string "")
|
|
810 (setq isearch-success t)
|
13799
|
811 (if (and isearch-success (equal (match-end 0) (match-beginning 0))
|
|
812 (not isearch-just-started))
|
725
|
813 ;; If repeating a search that found
|
|
814 ;; an empty string, ensure we advance.
|
5411
|
815 (if (if isearch-forward (eobp) (bobp))
|
|
816 ;; If there's nowhere to advance to, fail (and wrap next time).
|
|
817 (progn
|
|
818 (setq isearch-success nil)
|
|
819 (ding))
|
|
820 (forward-char (if isearch-forward 1 -1))
|
|
821 (isearch-search))
|
|
822 (isearch-search)))
|
|
823
|
725
|
824 (isearch-push-state)
|
|
825 (isearch-update))
|
|
826
|
|
827 (defun isearch-repeat-forward ()
|
|
828 "Repeat incremental search forwards."
|
|
829 (interactive)
|
|
830 (isearch-repeat 'forward))
|
|
831
|
|
832 (defun isearch-repeat-backward ()
|
|
833 "Repeat incremental search backwards."
|
|
834 (interactive)
|
|
835 (isearch-repeat 'backward))
|
|
836
|
|
837 (defun isearch-toggle-regexp ()
|
|
838 "Toggle regexp searching on or off."
|
|
839 ;; The status stack is left unchanged.
|
|
840 (interactive)
|
|
841 (setq isearch-regexp (not isearch-regexp))
|
1142
|
842 (if isearch-regexp (setq isearch-word nil))
|
725
|
843 (isearch-update))
|
|
844
|
7294
|
845 (defun isearch-toggle-case-fold ()
|
|
846 "Toggle case folding in searching on or off."
|
|
847 (interactive)
|
|
848 (setq isearch-case-fold-search
|
|
849 (if isearch-case-fold-search nil 'yes))
|
10397
|
850 (let ((message-log-max nil))
|
|
851 (message "%s%s [case %ssensitive]"
|
|
852 (isearch-message-prefix nil nil isearch-nonincremental)
|
|
853 isearch-message
|
|
854 (if isearch-case-fold-search "in" "")))
|
7294
|
855 (setq isearch-adjusted t)
|
|
856 (sit-for 1)
|
|
857 (isearch-update))
|
|
858
|
725
|
859 (defun isearch-delete-char ()
|
|
860 "Discard last input item and move point back.
|
|
861 If no previous match was done, just beep."
|
|
862 (interactive)
|
|
863 (if (null (cdr isearch-cmds))
|
|
864 (ding)
|
|
865 (isearch-pop-state))
|
|
866 (isearch-update))
|
|
867
|
|
868
|
|
869 (defun isearch-yank (chunk)
|
|
870 ;; Helper for isearch-yank-word and isearch-yank-line
|
4876
|
871 ;; CHUNK should be word, line or kill.
|
|
872 (let ((string (cond
|
|
873 ((eq chunk 'kill)
|
|
874 (current-kill 0))
|
|
875 (t
|
|
876 (save-excursion
|
|
877 (and (not isearch-forward) isearch-other-end
|
|
878 (goto-char isearch-other-end))
|
|
879 (buffer-substring
|
|
880 (point)
|
|
881 (save-excursion
|
|
882 (cond
|
|
883 ((eq chunk 'word)
|
|
884 (forward-word 1))
|
|
885 ((eq chunk 'line)
|
|
886 (end-of-line)))
|
|
887 (point))))))))
|
1142
|
888 ;; Downcase the string if not supposed to case-fold yanked strings.
|
|
889 (if (and isearch-case-fold-search
|
1143
|
890 (eq 'not-yanks search-upper-case))
|
1142
|
891 (setq string (downcase string)))
|
|
892 (if isearch-regexp (setq string (regexp-quote string)))
|
|
893 (setq isearch-string (concat isearch-string string)
|
725
|
894 isearch-message
|
|
895 (concat isearch-message
|
1142
|
896 (mapconcat 'isearch-text-char-description
|
|
897 string ""))
|
725
|
898 ;; Don't move cursor in reverse search.
|
|
899 isearch-yank-flag t))
|
|
900 (isearch-search-and-update))
|
|
901
|
4876
|
902 (defun isearch-yank-kill ()
|
|
903 "Pull string from kill ring into search string."
|
|
904 (interactive)
|
|
905 (isearch-yank 'kill))
|
725
|
906
|
|
907 (defun isearch-yank-word ()
|
|
908 "Pull next word from buffer into search string."
|
|
909 (interactive)
|
|
910 (isearch-yank 'word))
|
|
911
|
|
912 (defun isearch-yank-line ()
|
|
913 "Pull rest of line from buffer into search string."
|
|
914 (interactive)
|
|
915 (isearch-yank 'line))
|
|
916
|
|
917
|
|
918 (defun isearch-search-and-update ()
|
|
919 ;; Do the search and update the display.
|
|
920 (if (and (not isearch-success)
|
|
921 ;; unsuccessful regexp search may become
|
|
922 ;; successful by addition of characters which
|
|
923 ;; make isearch-string valid
|
|
924 (not isearch-regexp))
|
|
925 nil
|
|
926 ;; In reverse search, adding stuff at
|
|
927 ;; the end may cause zero or many more chars to be
|
|
928 ;; matched, in the string following point.
|
|
929 ;; Allow all those possibilities without moving point as
|
|
930 ;; long as the match does not extend past search origin.
|
|
931 (if (and (not isearch-forward) (not isearch-adjusted)
|
|
932 (condition-case ()
|
13799
|
933 (let ((case-fold-search isearch-case-fold-search))
|
|
934 (looking-at (if isearch-regexp isearch-string
|
|
935 (regexp-quote isearch-string))))
|
725
|
936 (error nil))
|
|
937 (or isearch-yank-flag
|
|
938 (<= (match-end 0)
|
|
939 (min isearch-opoint isearch-barrier))))
|
|
940 (setq isearch-success t
|
|
941 isearch-invalid-regexp nil
|
5601
|
942 isearch-within-brackets nil
|
725
|
943 isearch-other-end (match-end 0))
|
|
944 ;; Not regexp, not reverse, or no match at point.
|
|
945 (if (and isearch-other-end (not isearch-adjusted))
|
|
946 (goto-char (if isearch-forward isearch-other-end
|
|
947 (min isearch-opoint
|
|
948 isearch-barrier
|
|
949 (1+ isearch-other-end)))))
|
|
950 (isearch-search)
|
|
951 ))
|
|
952 (isearch-push-state)
|
|
953 (if isearch-op-fun (funcall isearch-op-fun))
|
|
954 (isearch-update))
|
|
955
|
|
956
|
|
957 ;; *, ?, and | chars can make a regexp more liberal.
|
1142
|
958 ;; They can make a regexp match sooner or make it succeed instead of failing.
|
725
|
959 ;; So go back to place last successful search started
|
|
960 ;; or to the last ^S/^R (barrier), whichever is nearer.
|
1142
|
961 ;; + needs no special handling because the string must match at least once.
|
725
|
962
|
|
963 (defun isearch-*-char ()
|
|
964 "Handle * and ? specially in regexps."
|
|
965 (interactive)
|
|
966 (if isearch-regexp
|
|
967
|
|
968 (progn
|
|
969 (setq isearch-adjusted t)
|
|
970 (let ((cs (nth (if isearch-forward
|
|
971 5 ; isearch-other-end
|
|
972 2) ; saved (point)
|
|
973 (car (cdr isearch-cmds)))))
|
|
974 ;; (car isearch-cmds) is after last search;
|
|
975 ;; (car (cdr isearch-cmds)) is from before it.
|
|
976 (setq cs (or cs isearch-barrier))
|
|
977 (goto-char
|
|
978 (if isearch-forward
|
|
979 (max cs isearch-barrier)
|
|
980 (min cs isearch-barrier))))))
|
1142
|
981 (isearch-process-search-char (isearch-last-command-char)))
|
725
|
982
|
|
983
|
|
984 (defun isearch-|-char ()
|
|
985 "If in regexp search, jump to the barrier."
|
|
986 (interactive)
|
|
987 (if isearch-regexp
|
|
988 (progn
|
|
989 (setq isearch-adjusted t)
|
|
990 (goto-char isearch-barrier)))
|
1142
|
991 (isearch-process-search-char (isearch-last-command-char)))
|
725
|
992
|
|
993
|
2572
|
994 (defalias 'isearch-other-control-char 'isearch-other-meta-char)
|
725
|
995
|
|
996 (defun isearch-other-meta-char ()
|
2031
|
997 "Exit the search normally and reread this key sequence.
|
1184
|
998 But only if `search-exit-option' is non-nil, the default.
|
|
999 If it is the symbol `edit', the search string is edited in the minibuffer
|
|
1000 and the meta character is unread so that it applies to editing the string."
|
725
|
1001 (interactive)
|
12106
|
1002 (let* ((key (this-command-keys))
|
|
1003 (main-event (aref key 0))
|
|
1004 (keylist (listify-key-sequence key)))
|
12716
|
1005 (cond ((and (= (length key) 1)
|
12824
|
1006 (let ((lookup (lookup-key function-key-map key)))
|
14288
|
1007 (not (or (null lookup) (integerp lookup)
|
|
1008 (keymapp lookup)))))
|
12716
|
1009 ;; Handle a function key that translates into something else.
|
|
1010 ;; If the key has a global definition too,
|
|
1011 ;; exit and unread the key itself, so its global definition runs.
|
|
1012 ;; Otherwise, unread the translation,
|
|
1013 ;; so that the translated key takes effect within isearch.
|
12824
|
1014 (cancel-kbd-macro-events)
|
12716
|
1015 (if (lookup-key global-map key)
|
|
1016 (progn
|
|
1017 (isearch-done)
|
|
1018 (apply 'isearch-unread keylist))
|
|
1019 (apply 'isearch-unread
|
|
1020 (listify-key-sequence (lookup-key function-key-map key)))))
|
|
1021 (
|
12106
|
1022 ;; Handle an undefined shifted control character
|
|
1023 ;; by downshifting it if that makes it defined.
|
|
1024 ;; (As read-key-sequence would normally do,
|
|
1025 ;; if we didn't have a default definition.)
|
|
1026 (let ((mods (event-modifiers main-event)))
|
|
1027 (and (integerp main-event)
|
|
1028 (memq 'shift mods)
|
|
1029 (memq 'control mods)
|
|
1030 (lookup-key isearch-mode-map
|
|
1031 (let ((copy (copy-sequence key)))
|
|
1032 (aset copy 0
|
|
1033 (- main-event (- ?\C-\S-a ?\C-a)))
|
|
1034 copy)
|
|
1035 nil)))
|
|
1036 (setcar keylist (- main-event (- ?\C-\S-a ?\C-a)))
|
12824
|
1037 (cancel-kbd-macro-events)
|
12106
|
1038 (apply 'isearch-unread keylist))
|
|
1039 ((eq search-exit-option 'edit)
|
|
1040 (apply 'isearch-unread keylist)
|
|
1041 (isearch-edit-string))
|
|
1042 (search-exit-option
|
|
1043 (let (window)
|
12824
|
1044 (cancel-kbd-macro-events)
|
12106
|
1045 (apply 'isearch-unread keylist)
|
|
1046 ;; Properly handle scroll-bar and mode-line clicks
|
|
1047 ;; for which a dummy prefix event was generated as (aref key 0).
|
|
1048 (and (> (length key) 1)
|
|
1049 (symbolp (aref key 0))
|
|
1050 (listp (aref key 1))
|
|
1051 (not (numberp (posn-point (event-start (aref key 1)))))
|
|
1052 ;; Convert the event back into its raw form,
|
|
1053 ;; with the dummy prefix implicit in the mouse event,
|
|
1054 ;; so it will get split up once again.
|
|
1055 (progn (setq unread-command-events
|
|
1056 (cdr unread-command-events))
|
|
1057 (setq main-event (car unread-command-events))
|
|
1058 (setcar (cdr (event-start main-event))
|
|
1059 (car (nth 1 (event-start main-event))))))
|
|
1060 ;; If we got a mouse click, maybe it was read with the buffer
|
|
1061 ;; it was clicked on. If so, that buffer, not the current one,
|
|
1062 ;; is in isearch mode. So end the search in that buffer.
|
|
1063 (if (and (listp main-event)
|
|
1064 (setq window (posn-window (event-start main-event)))
|
|
1065 (windowp window))
|
|
1066 (save-excursion
|
|
1067 (set-buffer (window-buffer window))
|
|
1068 (isearch-done))
|
|
1069 (isearch-done))))
|
|
1070 (t;; otherwise nil
|
|
1071 (isearch-process-search-string key key)))))
|
725
|
1072
|
|
1073 (defun isearch-quote-char ()
|
|
1074 "Quote special characters for incremental search."
|
|
1075 (interactive)
|
|
1076 (isearch-process-search-char (read-quoted-char (isearch-message t))))
|
|
1077
|
|
1078 (defun isearch-return-char ()
|
|
1079 "Convert return into newline for incremental search.
|
|
1080 Obsolete."
|
|
1081 (interactive)
|
|
1082 (isearch-process-search-char ?\n))
|
|
1083
|
|
1084 (defun isearch-printing-char ()
|
2533
|
1085 "Add this ordinary printing character to the search string and search."
|
725
|
1086 (interactive)
|
1142
|
1087 (isearch-process-search-char (isearch-last-command-char)))
|
725
|
1088
|
|
1089 (defun isearch-whitespace-chars ()
|
1142
|
1090 "Match all whitespace chars, if in regexp mode.
|
2533
|
1091 If you want to search for just a space, type C-q SPC."
|
725
|
1092 (interactive)
|
1142
|
1093 (if isearch-regexp
|
5601
|
1094 (if (and search-whitespace-regexp (not isearch-within-brackets))
|
1142
|
1095 (isearch-process-search-string search-whitespace-regexp " ")
|
|
1096 (isearch-printing-char))
|
|
1097 (progn
|
3591
|
1098 ;; This way of doing word search doesn't correctly extend current search.
|
1142
|
1099 ;; (setq isearch-word t)
|
|
1100 ;; (setq isearch-adjusted t)
|
|
1101 ;; (goto-char isearch-barrier)
|
|
1102 (isearch-printing-char))))
|
725
|
1103
|
|
1104 (defun isearch-process-search-char (char)
|
|
1105 ;; Append the char to the search string, update the message and re-search.
|
1142
|
1106 (isearch-process-search-string
|
|
1107 (isearch-char-to-string char)
|
|
1108 (isearch-text-char-description char)))
|
725
|
1109
|
|
1110 (defun isearch-process-search-string (string message)
|
|
1111 (setq isearch-string (concat isearch-string string)
|
|
1112 isearch-message (concat isearch-message message))
|
|
1113 (isearch-search-and-update))
|
|
1114
|
|
1115
|
|
1116 ;; Search Ring
|
|
1117
|
1142
|
1118 (defun isearch-ring-adjust1 (advance)
|
|
1119 ;; Helper for isearch-ring-adjust
|
|
1120 (let* ((ring (if isearch-regexp regexp-search-ring search-ring))
|
725
|
1121 (length (length ring))
|
|
1122 (yank-pointer-name (if isearch-regexp
|
1142
|
1123 'regexp-search-ring-yank-pointer
|
725
|
1124 'search-ring-yank-pointer))
|
|
1125 (yank-pointer (eval yank-pointer-name)))
|
|
1126 (if (zerop length)
|
|
1127 ()
|
|
1128 (set yank-pointer-name
|
|
1129 (setq yank-pointer
|
4512
ed1f6abba5c5
(isearch-ring-adjust1, isearch-ring-advance-edit): Replace `%' by `mod' and simplify.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
1130 (mod (+ (or yank-pointer 0)
|
ed1f6abba5c5
(isearch-ring-adjust1, isearch-ring-advance-edit): Replace `%' by `mod' and simplify.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
1131 (if advance -1 1))
|
ed1f6abba5c5
(isearch-ring-adjust1, isearch-ring-advance-edit): Replace `%' by `mod' and simplify.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
1132 length)))
|
1146
|
1133 (setq isearch-string (nth yank-pointer ring)
|
1142
|
1134 isearch-message (mapconcat 'isearch-text-char-description
|
|
1135 isearch-string "")))))
|
|
1136
|
|
1137 (defun isearch-ring-adjust (advance)
|
|
1138 ;; Helper for isearch-ring-advance and isearch-ring-retreat
|
|
1139 (if (cdr isearch-cmds) ;; is there more than one thing on stack?
|
|
1140 (isearch-pop-state))
|
|
1141 (isearch-ring-adjust1 advance)
|
725
|
1142 (isearch-push-state)
|
1142
|
1143 (if search-ring-update
|
|
1144 (progn
|
|
1145 (isearch-search)
|
|
1146 (isearch-update))
|
|
1147 (isearch-edit-string)
|
|
1148 ))
|
725
|
1149
|
|
1150 (defun isearch-ring-advance ()
|
|
1151 "Advance to the next search string in the ring."
|
1142
|
1152 ;; This could be more general to handle a prefix arg, but who would use it.
|
725
|
1153 (interactive)
|
|
1154 (isearch-ring-adjust 'advance))
|
|
1155
|
|
1156 (defun isearch-ring-retreat ()
|
|
1157 "Retreat to the previous search string in the ring."
|
|
1158 (interactive)
|
|
1159 (isearch-ring-adjust nil))
|
|
1160
|
1146
|
1161 (defun isearch-ring-advance-edit (n)
|
|
1162 "Insert the next element of the search history into the minibuffer."
|
|
1163 (interactive "p")
|
|
1164 (let* ((yank-pointer-name (if isearch-regexp
|
|
1165 'regexp-search-ring-yank-pointer
|
|
1166 'search-ring-yank-pointer))
|
|
1167 (yank-pointer (eval yank-pointer-name))
|
|
1168 (ring (if isearch-regexp regexp-search-ring search-ring))
|
|
1169 (length (length ring)))
|
|
1170 (if (zerop length)
|
|
1171 ()
|
|
1172 (set yank-pointer-name
|
|
1173 (setq yank-pointer
|
4512
ed1f6abba5c5
(isearch-ring-adjust1, isearch-ring-advance-edit): Replace `%' by `mod' and simplify.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
1174 (mod (- (or yank-pointer 0) n)
|
ed1f6abba5c5
(isearch-ring-adjust1, isearch-ring-advance-edit): Replace `%' by `mod' and simplify.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
1175 length)))
|
725
|
1176
|
1146
|
1177 (erase-buffer)
|
1184
|
1178 (insert (nth yank-pointer ring))
|
1380
|
1179 (goto-char (point-max)))))
|
725
|
1180
|
1146
|
1181 (defun isearch-ring-retreat-edit (n)
|
|
1182 "Inserts the previous element of the search history into the minibuffer."
|
|
1183 (interactive "p")
|
|
1184 (isearch-ring-advance-edit (- n)))
|
|
1185
|
|
1186 ;;(defun isearch-ring-adjust-edit (advance)
|
|
1187 ;; "Use the next or previous search string in the ring while in minibuffer."
|
|
1188 ;; (isearch-ring-adjust1 advance)
|
|
1189 ;; (erase-buffer)
|
|
1190 ;; (insert isearch-string))
|
|
1191
|
|
1192 ;;(defun isearch-ring-advance-edit ()
|
|
1193 ;; (interactive)
|
|
1194 ;; (isearch-ring-adjust-edit 'advance))
|
|
1195
|
|
1196 ;;(defun isearch-ring-retreat-edit ()
|
|
1197 ;; "Retreat to the previous search string in the ring while in the minibuffer."
|
|
1198 ;; (interactive)
|
|
1199 ;; (isearch-ring-adjust-edit nil))
|
725
|
1200
|
|
1201
|
1142
|
1202 (defun isearch-complete1 ()
|
|
1203 ;; Helper for isearch-complete and isearch-complete-edit
|
|
1204 ;; Return t if completion OK, nil if no completion exists.
|
|
1205 (let* ((ring (if isearch-regexp regexp-search-ring search-ring))
|
|
1206 (alist (mapcar (function (lambda (string) (list string))) ring))
|
|
1207 (completion-ignore-case case-fold-search)
|
|
1208 (completion (try-completion isearch-string alist)))
|
|
1209 (cond
|
|
1210 ((eq completion t)
|
|
1211 ;; isearch-string stays the same
|
|
1212 t)
|
|
1213 ((or completion ; not nil, must be a string
|
13991
|
1214 (= 0 (length isearch-string))) ; shouldn't have to say this
|
1142
|
1215 (if (equal completion isearch-string) ;; no extension?
|
|
1216 (if completion-auto-help
|
|
1217 (with-output-to-temp-buffer "*Isearch completions*"
|
|
1218 (display-completion-list
|
|
1219 (all-completions isearch-string alist))))
|
|
1220 (setq isearch-string completion))
|
|
1221 t)
|
|
1222 (t
|
|
1223 (message "No completion") ; waits a second if in minibuffer
|
|
1224 nil))))
|
|
1225
|
|
1226 (defun isearch-complete ()
|
|
1227 "Complete the search string from the strings on the search ring.
|
|
1228 The completed string is then editable in the minibuffer.
|
|
1229 If there is no completion possible, say so and continue searching."
|
|
1230 (interactive)
|
|
1231 (if (isearch-complete1)
|
|
1232 (isearch-edit-string)
|
|
1233 ;; else
|
|
1234 (sit-for 1)
|
|
1235 (isearch-update)))
|
|
1236
|
|
1237 (defun isearch-complete-edit ()
|
|
1238 "Same as `isearch-complete' except in the minibuffer."
|
|
1239 (interactive)
|
|
1240 (setq isearch-string (buffer-string))
|
|
1241 (if (isearch-complete1)
|
725
|
1242 (progn
|
1142
|
1243 (erase-buffer)
|
|
1244 (insert isearch-string))))
|
725
|
1245
|
|
1246
|
|
1247 ;; The search status stack (and isearch window-local variables, not used).
|
1142
|
1248 ;; Need a structure for this.
|
725
|
1249
|
|
1250 (defun isearch-top-state ()
|
|
1251 (let ((cmd (car isearch-cmds)))
|
|
1252 (setq isearch-string (car cmd)
|
|
1253 isearch-message (car (cdr cmd))
|
|
1254 isearch-success (nth 3 cmd)
|
|
1255 isearch-forward (nth 4 cmd)
|
|
1256 isearch-other-end (nth 5 cmd)
|
1142
|
1257 isearch-word (nth 6 cmd)
|
|
1258 isearch-invalid-regexp (nth 7 cmd)
|
|
1259 isearch-wrapped (nth 8 cmd)
|
5601
|
1260 isearch-barrier (nth 9 cmd)
|
5637
|
1261 isearch-within-brackets (nth 10 cmd)
|
|
1262 isearch-case-fold-search (nth 11 cmd))
|
725
|
1263 (goto-char (car (cdr (cdr cmd))))))
|
|
1264
|
|
1265 (defun isearch-pop-state ()
|
|
1266 (setq isearch-cmds (cdr isearch-cmds))
|
|
1267 (isearch-top-state)
|
|
1268 )
|
|
1269
|
|
1270 (defun isearch-push-state ()
|
|
1271 (setq isearch-cmds
|
|
1272 (cons (list isearch-string isearch-message (point)
|
|
1273 isearch-success isearch-forward isearch-other-end
|
1142
|
1274 isearch-word
|
5601
|
1275 isearch-invalid-regexp isearch-wrapped isearch-barrier
|
5637
|
1276 isearch-within-brackets isearch-case-fold-search)
|
725
|
1277 isearch-cmds)))
|
|
1278
|
|
1279
|
|
1280 ;; Message string
|
|
1281
|
|
1282 (defun isearch-message (&optional c-q-hack ellipsis)
|
|
1283 ;; Generate and print the message string.
|
|
1284 (let ((cursor-in-echo-area ellipsis)
|
|
1285 (m (concat
|
1142
|
1286 (isearch-message-prefix c-q-hack ellipsis isearch-nonincremental)
|
725
|
1287 isearch-message
|
|
1288 (isearch-message-suffix c-q-hack ellipsis)
|
|
1289 )))
|
10397
|
1290 (if c-q-hack
|
|
1291 m
|
|
1292 (let ((message-log-max nil))
|
|
1293 (message "%s" m)))))
|
725
|
1294
|
1142
|
1295 (defun isearch-message-prefix (&optional c-q-hack ellipsis nonincremental)
|
725
|
1296 ;; If about to search, and previous search regexp was invalid,
|
|
1297 ;; check that it still is. If it is valid now,
|
|
1298 ;; let the message we display while searching say that it is valid.
|
|
1299 (and isearch-invalid-regexp ellipsis
|
|
1300 (condition-case ()
|
|
1301 (progn (re-search-forward isearch-string (point) t)
|
7378
|
1302 (setq isearch-invalid-regexp nil
|
|
1303 isearch-within-brackets nil))
|
725
|
1304 (error nil)))
|
|
1305 ;; If currently failing, display no ellipsis.
|
|
1306 (or isearch-success (setq ellipsis nil))
|
|
1307 (let ((m (concat (if isearch-success "" "failing ")
|
13254
|
1308 (if (and isearch-wrapped
|
|
1309 (if isearch-forward
|
|
1310 (> (point) isearch-opoint)
|
|
1311 (< (point) isearch-opoint)))
|
|
1312 "over")
|
725
|
1313 (if isearch-wrapped "wrapped ")
|
1142
|
1314 (if isearch-word "word " "")
|
725
|
1315 (if isearch-regexp "regexp " "")
|
1142
|
1316 (if nonincremental "search" "I-search")
|
725
|
1317 (if isearch-forward ": " " backward: ")
|
|
1318 )))
|
|
1319 (aset m 0 (upcase (aref m 0)))
|
|
1320 m))
|
|
1321
|
|
1322
|
|
1323 (defun isearch-message-suffix (&optional c-q-hack ellipsis)
|
|
1324 (concat (if c-q-hack "^Q" "")
|
|
1325 (if isearch-invalid-regexp
|
|
1326 (concat " [" isearch-invalid-regexp "]")
|
|
1327 "")))
|
|
1328
|
|
1329
|
|
1330 ;;; Searching
|
|
1331
|
|
1332 (defun isearch-search ()
|
|
1333 ;; Do the search with the current search string.
|
|
1334 (isearch-message nil t)
|
7294
|
1335 (if (and (eq isearch-case-fold-search t) search-upper-case)
|
3526
|
1336 (setq isearch-case-fold-search
|
|
1337 (isearch-no-upper-case-p isearch-string isearch-regexp)))
|
725
|
1338 (condition-case lossage
|
|
1339 (let ((inhibit-quit nil)
|
|
1340 (case-fold-search isearch-case-fold-search))
|
|
1341 (if isearch-regexp (setq isearch-invalid-regexp nil))
|
5601
|
1342 (setq isearch-within-brackets nil)
|
725
|
1343 (setq isearch-success
|
|
1344 (funcall
|
1142
|
1345 (cond (isearch-word
|
|
1346 (if isearch-forward
|
|
1347 'word-search-forward 'word-search-backward))
|
|
1348 (isearch-regexp
|
|
1349 (if isearch-forward
|
|
1350 're-search-forward 're-search-backward))
|
|
1351 (t
|
|
1352 (if isearch-forward 'search-forward 'search-backward)))
|
725
|
1353 isearch-string nil t))
|
13799
|
1354 (setq isearch-just-started nil)
|
725
|
1355 (if isearch-success
|
|
1356 (setq isearch-other-end
|
|
1357 (if isearch-forward (match-beginning 0) (match-end 0)))))
|
|
1358
|
5196
|
1359 (quit (isearch-unread ?\C-g)
|
725
|
1360 (setq isearch-success nil))
|
|
1361
|
|
1362 (invalid-regexp
|
|
1363 (setq isearch-invalid-regexp (car (cdr lossage)))
|
5601
|
1364 (setq isearch-within-brackets (string-match "\\`Unmatched \\["
|
|
1365 isearch-invalid-regexp))
|
725
|
1366 (if (string-match
|
|
1367 "\\`Premature \\|\\`Unmatched \\|\\`Invalid "
|
|
1368 isearch-invalid-regexp)
|
1534
dd292c7ef749
(isearch-search): Handle all sorts of errors from regexp search.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1369 (setq isearch-invalid-regexp "incomplete input")))
|
dd292c7ef749
(isearch-search): Handle all sorts of errors from regexp search.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1370 (error
|
dd292c7ef749
(isearch-search): Handle all sorts of errors from regexp search.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1371 ;; stack overflow in regexp search.
|
dd292c7ef749
(isearch-search): Handle all sorts of errors from regexp search.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1372 (setq isearch-invalid-regexp (car (cdr lossage)))))
|
725
|
1373
|
|
1374 (if isearch-success
|
|
1375 nil
|
|
1376 ;; Ding if failed this time after succeeding last time.
|
|
1377 (and (nth 3 (car isearch-cmds))
|
|
1378 (ding))
|
|
1379 (goto-char (nth 2 (car isearch-cmds)))))
|
|
1380
|
1142
|
1381
|
|
1382
|
|
1383 ;;; Highlighting
|
|
1384
|
3526
|
1385 (defvar isearch-overlay nil)
|
1142
|
1386
|
3526
|
1387 (defun isearch-highlight (beg end)
|
5649
|
1388 (if (or (null search-highlight) (null window-system))
|
1142
|
1389 nil
|
3526
|
1390 (or isearch-overlay (setq isearch-overlay (make-overlay beg end)))
|
|
1391 (move-overlay isearch-overlay beg end (current-buffer))
|
3717
|
1392 (overlay-put isearch-overlay 'face
|
|
1393 (if (internal-find-face 'isearch nil)
|
|
1394 'isearch 'region))))
|
1142
|
1395
|
3526
|
1396 (defun isearch-dehighlight (totally)
|
|
1397 (if isearch-overlay
|
|
1398 (delete-overlay isearch-overlay)))
|
725
|
1399
|
1142
|
1400 ;;; General utilities
|
|
1401
|
|
1402
|
3526
|
1403 (defun isearch-no-upper-case-p (string regexp-flag)
|
|
1404 "Return t if there are no upper case chars in STRING.
|
13991
|
1405 If REGEXP-FLAG is non-nil, disregard letters preceded by `\\' (but not `\\\\')
|
3526
|
1406 since they have special meaning in a regexp."
|
1142
|
1407 (let ((case-fold-search nil))
|
3526
|
1408 (not (string-match (if regexp-flag "\\(^\\|\\\\\\\\\\|[^\\]\\)[A-Z]"
|
|
1409 "[A-Z]")
|
|
1410 string))))
|
1142
|
1411
|
|
1412
|
3526
|
1413 ;; Portability functions to support various Emacs versions.
|
725
|
1414
|
1142
|
1415 ;; To quiet the byte-compiler.
|
|
1416 (defvar unread-command-event)
|
1821
|
1417 (defvar unread-command-events)
|
1142
|
1418 (defvar last-command-event)
|
|
1419
|
|
1420 (defun isearch-char-to-string (c)
|
9940
|
1421 (make-string 1 c))
|
1142
|
1422
|
|
1423 (defun isearch-text-char-description (c)
|
5277
|
1424 (if (and (integerp c) (or (< c ?\ ) (= c ?\^?)))
|
|
1425 (text-char-description c)
|
|
1426 (isearch-char-to-string c)))
|
1142
|
1427
|
9934
|
1428 ;; General function to unread characters or events.
|
13799
|
1429 ;; Also insert them in a keyboard macro being defined.
|
2031
|
1430 (defun isearch-unread (&rest char-or-events)
|
13799
|
1431 (mapcar 'store-kbd-macro-event char-or-events)
|
9934
|
1432 (setq unread-command-events
|
|
1433 (append char-or-events unread-command-events)))
|
1142
|
1434
|
|
1435 (defun isearch-last-command-char ()
|
|
1436 ;; General function to return the last command character.
|
9935
|
1437 last-command-char)
|
1142
|
1438
|
2230
|
1439 ;;; isearch.el ends here
|