]> code.delx.au - gnu-emacs/blob - man/search.texi
improve page/line breaks
[gnu-emacs] / man / search.texi
1 @c This is part of the Emacs manual.
2 @c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001, 2002,
3 @c 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
4 @c See file emacs.texi for copying conditions.
5 @node Search, Fixit, Display, Top
6 @chapter Searching and Replacement
7 @cindex searching
8 @cindex finding strings within text
9
10 Like other editors, Emacs has commands for searching for occurrences of
11 a string. The principal search command is unusual in that it is
12 @dfn{incremental}; it begins to search before you have finished typing the
13 search string. There are also nonincremental search commands more like
14 those of other editors.
15
16 Besides the usual @code{replace-string} command that finds all
17 occurrences of one string and replaces them with another, Emacs has a
18 more flexible replacement command called @code{query-replace}, which
19 asks interactively which occurrences to replace. There are also
20 commands to find and operate on all matches for a pattern.
21
22 You can also search multiple files under control of a tags
23 table (@pxref{Tags Search}) or through the Dired @kbd{A} command
24 (@pxref{Operating on Files}), or ask the @code{grep} program to do it
25 (@pxref{Grep Searching}).
26
27
28 @menu
29 * Incremental Search:: Search happens as you type the string.
30 * Nonincremental Search:: Specify entire string and then search.
31 * Word Search:: Search for sequence of words.
32 * Regexp Search:: Search for match for a regexp.
33 * Regexps:: Syntax of regular expressions.
34 * Regexp Backslash:: Regular expression constructs starting with `\'.
35 * Regexp Example:: A complex regular expression explained.
36 * Search Case:: To ignore case while searching, or not.
37 * Replace:: Search, and replace some or all matches.
38 * Other Repeating Search:: Operating on all matches for some regexp.
39 @end menu
40
41 @node Incremental Search
42 @section Incremental Search
43 @cindex incremental search
44 @cindex isearch
45
46 An incremental search begins searching as soon as you type the first
47 character of the search string. As you type in the search string, Emacs
48 shows you where the string (as you have typed it so far) would be
49 found. When you have typed enough characters to identify the place you
50 want, you can stop. Depending on what you plan to do next, you may or
51 may not need to terminate the search explicitly with @key{RET}.
52
53 @table @kbd
54 @item C-s
55 Incremental search forward (@code{isearch-forward}).
56 @item C-r
57 Incremental search backward (@code{isearch-backward}).
58 @end table
59
60 @menu
61 * Basic Isearch:: Basic incremental search commands.
62 * Repeat Isearch:: Searching for the same string again.
63 * Error in Isearch:: When your string is not found.
64 * Special Isearch:: Special input in incremental search.
65 * Non-ASCII Isearch:: How to search for non-ASCII characters.
66 * Isearch Yank:: Commands that grab text into the search string
67 or else edit the search string.
68 * Highlight Isearch:: Isearch highlights the other possible matches.
69 * Isearch Scroll:: Scrolling during an incremental search.
70 * Slow Isearch:: Incremental search features for slow terminals.
71 @end menu
72
73 @node Basic Isearch
74 @subsection Basics of Incremental Search
75
76 @kindex C-s
77 @findex isearch-forward
78 @kbd{C-s} starts a forward incremental search. It reads characters
79 from the keyboard, and moves point past the next occurrence of those
80 characters. If you type @kbd{C-s} and then @kbd{F}, that puts the
81 cursor after the first @samp{F} (the first following the starting point, since
82 this is a forward search). Then if you type an @kbd{O}, you will see
83 the cursor move to just after the first @samp{FO} (the @samp{F} in that
84 @samp{FO} may or may not be the first @samp{F}). After another
85 @kbd{O}, the cursor moves to just after the first @samp{FOO} after the place
86 where you started the search. At each step, the buffer text that
87 matches the search string is highlighted, if the terminal can do that;
88 the current search string is always displayed in the echo area.
89
90 If you make a mistake in typing the search string, you can cancel
91 characters with @key{DEL}. Each @key{DEL} cancels the last character of
92 search string. This does not happen until Emacs is ready to read another
93 input character; first it must either find, or fail to find, the character
94 you want to erase. If you do not want to wait for this to happen, use
95 @kbd{C-g} as described below.
96
97 When you are satisfied with the place you have reached, you can type
98 @key{RET}, which stops searching, leaving the cursor where the search
99 brought it. Also, any command not specially meaningful in searches
100 stops the searching and is then executed. Thus, typing @kbd{C-a}
101 would exit the search and then move to the beginning of the line.
102 @key{RET} is necessary only if the next command you want to type is a
103 printing character, @key{DEL}, @key{RET}, or another character that is
104 special within searches (@kbd{C-q}, @kbd{C-w}, @kbd{C-r}, @kbd{C-s},
105 @kbd{C-y}, @kbd{M-y}, @kbd{M-r}, @kbd{M-c}, @kbd{M-e}, and some other
106 meta-characters).
107
108 When you exit the incremental search, it sets the mark where point
109 @emph{was} before the search. That is convenient for moving back
110 there. In Transient Mark mode, incremental search sets the mark
111 without activating it, and does so only if the mark is not already
112 active.
113
114 @node Repeat Isearch
115 @subsection Repeating Incremental Search
116
117 Sometimes you search for @samp{FOO} and find one, but not the one you
118 expected to find. There was a second @samp{FOO} that you forgot
119 about, before the one you were aiming for. In this event, type
120 another @kbd{C-s} to move to the next occurrence of the search string.
121 You can repeat this any number of times. If you overshoot, you can
122 cancel some @kbd{C-s} characters with @key{DEL}.
123
124 After you exit a search, you can search for the same string again by
125 typing just @kbd{C-s C-s}: the first @kbd{C-s} is the key that invokes
126 incremental search, and the second @kbd{C-s} means ``search again.''
127
128 If a search is failing and you ask to repeat it by typing another
129 @kbd{C-s}, it starts again from the beginning of the buffer.
130 Repeating a failing reverse search with @kbd{C-r} starts again from
131 the end. This is called @dfn{wrapping around}, and @samp{Wrapped}
132 appears in the search prompt once this has happened. If you keep on
133 going past the original starting point of the search, it changes to
134 @samp{Overwrapped}, which means that you are revisiting matches that
135 you have already seen.
136
137 To reuse earlier search strings, use the @dfn{search ring}. The
138 commands @kbd{M-p} and @kbd{M-n} move through the ring to pick a search
139 string to reuse. These commands leave the selected search ring element
140 in the minibuffer, where you can edit it. To edit the current search
141 string in the minibuffer without replacing it with items from the
142 search ring, type @kbd{M-e}. Type @kbd{C-s} or @kbd{C-r}
143 to terminate editing the string and search for it.
144
145 You can change to searching backwards with @kbd{C-r}. For instance,
146 if you are searching forward but you realize you were looking for
147 something above the starting point, you can do this. Repeated
148 @kbd{C-r} keeps looking for more occurrences backwards. A @kbd{C-s}
149 starts going forwards again. @kbd{C-r} in a search can be canceled
150 with @key{DEL}.
151
152 @kindex C-r
153 @findex isearch-backward
154 If you know initially that you want to search backwards, you can use
155 @kbd{C-r} instead of @kbd{C-s} to start the search, because @kbd{C-r}
156 as a key runs a command (@code{isearch-backward}) to search backward.
157 A backward search finds matches that end before the starting point,
158 just as a forward search finds matches that begin after it.
159
160 @node Error in Isearch
161 @subsection Errors in Incremental Search
162
163 If your string is not found at all, the echo area says @samp{Failing
164 I-Search}. The cursor is after the place where Emacs found as much of your
165 string as it could. Thus, if you search for @samp{FOOT}, and there is no
166 @samp{FOOT}, you might see the cursor after the @samp{FOO} in @samp{FOOL}.
167 At this point there are several things you can do. If your string was
168 mistyped, you can rub some of it out and correct it. If you like the place
169 you have found, you can type @key{RET} or some other Emacs command to
170 remain there. Or you can type @kbd{C-g}, which
171 removes from the search string the characters that could not be found (the
172 @samp{T} in @samp{FOOT}), leaving those that were found (the @samp{FOO} in
173 @samp{FOOT}). A second @kbd{C-g} at that point cancels the search
174 entirely, returning point to where it was when the search started.
175
176 @cindex quitting (in search)
177 The @kbd{C-g} ``quit'' character does special things during searches;
178 just what it does depends on the status of the search. If the search has
179 found what you specified and is waiting for input, @kbd{C-g} cancels the
180 entire search. The cursor moves back to where you started the search. If
181 @kbd{C-g} is typed when there are characters in the search string that have
182 not been found---because Emacs is still searching for them, or because it
183 has failed to find them---then the search string characters which have not
184 been found are discarded from the search string. With them gone, the
185 search is now successful and waiting for more input, so a second @kbd{C-g}
186 will cancel the entire search.
187
188 @node Special Isearch
189 @subsection Special Input for Incremental Search
190
191 An upper-case letter in the search string makes the search
192 case-sensitive. If you delete the upper-case character from the search
193 string, it ceases to have this effect. @xref{Search Case}.
194
195 To search for a newline, type @kbd{C-j}. To search for another
196 control character, such as control-S or carriage return, you must quote
197 it by typing @kbd{C-q} first. This function of @kbd{C-q} is analogous
198 to its use for insertion (@pxref{Inserting Text}): it causes the
199 following character to be treated the way any ``ordinary'' character is
200 treated in the same context. You can also specify a character by its
201 octal code: enter @kbd{C-q} followed by a sequence of octal digits.
202
203 @kbd{M-%} typed in incremental search invokes @code{query-replace}
204 or @code{query-replace-regexp} (depending on search mode) with the
205 current search string used as the string to replace. @xref{Query
206 Replace}.
207
208 Entering @key{RET} when the search string is empty launches
209 nonincremental search (@pxref{Nonincremental Search}).
210
211 @vindex isearch-mode-map
212 To customize the special characters that incremental search understands,
213 alter their bindings in the keymap @code{isearch-mode-map}. For a list
214 of bindings, look at the documentation of @code{isearch-mode} with
215 @kbd{C-h f isearch-mode @key{RET}}.
216
217 @node Non-ASCII Isearch
218 @subsection Isearch for Non-@acronym{ASCII} Characters
219 @cindex searching for non-@acronym{ASCII} characters
220 @cindex input method, during incremental search
221
222 To enter non-@acronym{ASCII} characters in an incremental search,
223 you can use @kbd{C-q} (see the previous section), but it is easier to
224 use an input method (@pxref{Input Methods}). If an input method is
225 enabled in the current buffer when you start the search, you can use
226 it in the search string also. Emacs indicates that by including the
227 input method mnemonic in its prompt, like this:
228
229 @example
230 I-search [@var{im}]:
231 @end example
232
233 @noindent
234 @findex isearch-toggle-input-method
235 @findex isearch-toggle-specified-input-method
236 where @var{im} is the mnemonic of the active input method.
237
238 You can toggle (enable or disable) the input method while you type
239 the search string with @kbd{C-\} (@code{isearch-toggle-input-method}).
240 You can turn on a certain (non-default) input method with @kbd{C-^}
241 (@code{isearch-toggle-specified-input-method}), which prompts for the
242 name of the input method. The input method you enable during
243 incremental search remains enabled in the current buffer afterwards.
244
245 @node Isearch Yank
246 @subsection Isearch Yanking
247
248 The characters @kbd{C-w} and @kbd{C-y} can be used in incremental
249 search to grab text from the buffer into the search string. This
250 makes it convenient to search for another occurrence of text at point.
251 @kbd{C-w} copies the character or word after point as part of the
252 search string, advancing point over it. (The decision, whether to
253 copy a character or a word, is heuristic.) Another @kbd{C-s} to
254 repeat the search will then search for a string including that
255 character or word.
256
257 @kbd{C-y} is similar to @kbd{C-w} but copies all the rest of the
258 current line into the search string. If point is already at the end
259 of a line, it grabs the entire next line. Both @kbd{C-y} and
260 @kbd{C-w} convert the text they copy to lower case if the search is
261 currently not case-sensitive; this is so the search remains
262 case-insensitive.
263
264 @kbd{C-M-w} and @kbd{C-M-y} modify the search string by only one
265 character at a time: @kbd{C-M-w} deletes the last character from the
266 search string and @kbd{C-M-y} copies the character after point to the
267 end of the search string. An alternative method to add the character
268 after point into the search string is to enter the minibuffer by
269 @kbd{M-e} and to type @kbd{C-f} at the end of the search string in the
270 minibuffer.
271
272 The character @kbd{M-y} copies text from the kill ring into the search
273 string. It uses the same text that @kbd{C-y} as a command would yank.
274 @kbd{Mouse-2} in the echo area does the same.
275 @xref{Yanking}.
276
277 @node Highlight Isearch
278 @subsection Lazy Search Highlighting
279 @cindex lazy search highlighting
280 @vindex isearch-lazy-highlight
281
282 When you pause for a little while during incremental search, it
283 highlights all other possible matches for the search string. This
284 makes it easier to anticipate where you can get to by typing @kbd{C-s}
285 or @kbd{C-r} to repeat the search. The short delay before highlighting
286 other matches helps indicate which match is the current one.
287 If you don't like this feature, you can turn it off by setting
288 @code{isearch-lazy-highlight} to @code{nil}.
289
290 @cindex faces for highlighting search matches
291 You can control how this highlighting looks by customizing the faces
292 @code{isearch} (used for the current match) and @code{lazy-highlight}
293 (for all the other matches).
294
295 @node Isearch Scroll
296 @subsection Scrolling During Incremental Search
297
298 You can enable the use of vertical scrolling during incremental
299 search (without exiting the search) by setting the customizable
300 variable @code{isearch-allow-scroll} to a non-@code{nil} value. This
301 applies to using the vertical scroll-bar and to certain keyboard
302 commands such as @kbd{@key{PRIOR}} (@code{scroll-down}),
303 @kbd{@key{NEXT}} (@code{scroll-up}) and @kbd{C-l} (@code{recenter}).
304 You must run these commands via their key sequences to stay in the
305 search---typing @kbd{M-x} will terminate the search. You can give
306 prefix arguments to these commands in the usual way.
307
308 This feature won't let you scroll the current match out of visibility,
309 however.
310
311 The feature also affects some other commands, such as @kbd{C-x 2}
312 (@code{split-window-vertically}) and @kbd{C-x ^}
313 (@code{enlarge-window}) which don't exactly scroll but do affect where
314 the text appears on the screen. In general, it applies to any command
315 whose name has a non-@code{nil} @code{isearch-scroll} property. So you
316 can control which commands are affected by changing these properties.
317
318 For example, to make @kbd{C-h l} usable within an incremental search
319 in all future Emacs sessions, use @kbd{C-h c} to find what command it
320 runs. (You type @kbd{C-h c C-h l}; it says @code{view-lossage}.)
321 Then you can put the following line in your @file{.emacs} file
322 (@pxref{Init File}):
323
324 @example
325 (put 'view-lossage 'isearch-scroll t)
326 @end example
327
328 @noindent
329 This feature can be applied to any command that doesn't permanently
330 change point, the buffer contents, the match data, the current buffer,
331 or the selected window and frame. The command must not itself attempt
332 an incremental search.
333
334 @node Slow Isearch
335 @subsection Slow Terminal Incremental Search
336
337 Incremental search on a slow terminal uses a modified style of display
338 that is designed to take less time. Instead of redisplaying the buffer at
339 each place the search gets to, it creates a new single-line window and uses
340 that to display the line that the search has found. The single-line window
341 comes into play as soon as point moves outside of the text that is already
342 on the screen.
343
344 When you terminate the search, the single-line window is removed.
345 Emacs then redisplays the window in which the search was done, to show
346 its new position of point.
347
348 @vindex search-slow-speed
349 The slow terminal style of display is used when the terminal baud rate is
350 less than or equal to the value of the variable @code{search-slow-speed},
351 initially 1200. See also the discussion of the variable @code{baud-rate}
352 (@pxref{baud-rate,, Customization of Display}).
353
354 @vindex search-slow-window-lines
355 The number of lines to use in slow terminal search display is controlled
356 by the variable @code{search-slow-window-lines}. Its normal value is 1.
357
358 @node Nonincremental Search
359 @section Nonincremental Search
360 @cindex nonincremental search
361
362 Emacs also has conventional nonincremental search commands, which require
363 you to type the entire search string before searching begins.
364
365 @table @kbd
366 @item C-s @key{RET} @var{string} @key{RET}
367 Search for @var{string}.
368 @item C-r @key{RET} @var{string} @key{RET}
369 Search backward for @var{string}.
370 @end table
371
372 To do a nonincremental search, first type @kbd{C-s @key{RET}}. This
373 enters the minibuffer to read the search string; terminate the string
374 with @key{RET}, and then the search takes place. If the string is not
375 found, the search command signals an error.
376
377 When you type @kbd{C-s @key{RET}}, the @kbd{C-s} invokes incremental
378 search as usual. That command is specially programmed to invoke
379 nonincremental search, @code{search-forward}, if the string you
380 specify is empty. (Such an empty argument would otherwise be
381 useless.) But it does not call @code{search-forward} right away. First
382 it checks the next input character to see if is @kbd{C-w},
383 which specifies a word search.
384 @ifnottex
385 @xref{Word Search}.
386 @end ifnottex
387 @kbd{C-r @key{RET}} does likewise, for a reverse incremental search.
388
389 @findex search-forward
390 @findex search-backward
391 Forward and backward nonincremental searches are implemented by the
392 commands @code{search-forward} and @code{search-backward}. These
393 commands may be bound to keys in the usual manner. The feature that you
394 can get to them via the incremental search commands exists for
395 historical reasons, and to avoid the need to find separate key sequences
396 for them.
397
398 @node Word Search
399 @section Word Search
400 @cindex word search
401
402 Word search searches for a sequence of words without regard to how the
403 words are separated. More precisely, you type a string of many words,
404 using single spaces to separate them, and the string can be found even
405 if there are multiple spaces, newlines, or other punctuation characters
406 between these words.
407
408 Word search is useful for editing a printed document made with a text
409 formatter. If you edit while looking at the printed, formatted version,
410 you can't tell where the line breaks are in the source file. With word
411 search, you can search without having to know them.
412
413 @table @kbd
414 @item C-s @key{RET} C-w @var{words} @key{RET}
415 Search for @var{words}, ignoring details of punctuation.
416 @item C-r @key{RET} C-w @var{words} @key{RET}
417 Search backward for @var{words}, ignoring details of punctuation.
418 @end table
419
420 Word search is a special case of nonincremental search and is invoked
421 with @kbd{C-s @key{RET} C-w}. This is followed by the search string,
422 which must always be terminated with @key{RET}. Being nonincremental,
423 this search does not start until the argument is terminated. It works
424 by constructing a regular expression and searching for that; see
425 @ref{Regexp Search}.
426
427 Use @kbd{C-r @key{RET} C-w} to do backward word search.
428
429 @findex word-search-forward
430 @findex word-search-backward
431 Forward and backward word searches are implemented by the commands
432 @code{word-search-forward} and @code{word-search-backward}. These
433 commands may be bound to keys in the usual manner. They are available
434 via the incremental search commands both for historical reasons and
435 to avoid the need to find separate key sequences for them.
436
437 @node Regexp Search
438 @section Regular Expression Search
439 @cindex regular expression
440 @cindex regexp
441
442 A @dfn{regular expression} (@dfn{regexp}, for short) is a pattern
443 that denotes a class of alternative strings to match, possibly
444 infinitely many. GNU Emacs provides both incremental and
445 nonincremental ways to search for a match for a regexp. The syntax of
446 regular expressions is explained in the following section.
447
448 @kindex C-M-s
449 @findex isearch-forward-regexp
450 @kindex C-M-r
451 @findex isearch-backward-regexp
452 Incremental search for a regexp is done by typing @kbd{C-M-s}
453 (@code{isearch-forward-regexp}), by invoking @kbd{C-s} with a
454 prefix argument (whose value does not matter), or by typing @kbd{M-r}
455 within a forward incremental search. This command reads a
456 search string incrementally just like @kbd{C-s}, but it treats the
457 search string as a regexp rather than looking for an exact match
458 against the text in the buffer. Each time you add text to the search
459 string, you make the regexp longer, and the new regexp is searched
460 for. To search backward for a regexp, use @kbd{C-M-r}
461 (@code{isearch-backward-regexp}), @kbd{C-r} with a prefix argument,
462 or @kbd{M-r} within a backward incremental search.
463
464 All of the control characters that do special things within an
465 ordinary incremental search have the same function in incremental regexp
466 search. Typing @kbd{C-s} or @kbd{C-r} immediately after starting the
467 search retrieves the last incremental search regexp used; that is to
468 say, incremental regexp and non-regexp searches have independent
469 defaults. They also have separate search rings that you can access with
470 @kbd{M-p} and @kbd{M-n}.
471
472 @vindex search-whitespace-regexp
473 If you type @key{SPC} in incremental regexp search, it matches any
474 sequence of whitespace characters, including newlines. If you want to
475 match just a space, type @kbd{C-q @key{SPC}}. You can control what a
476 bare space matches by setting the variable
477 @code{search-whitespace-regexp} to the desired regexp.
478
479 In some cases, adding characters to the regexp in an incremental regexp
480 search can make the cursor move back and start again. For example, if
481 you have searched for @samp{foo} and you add @samp{\|bar}, the cursor
482 backs up in case the first @samp{bar} precedes the first @samp{foo}.
483
484 @findex re-search-forward
485 @findex re-search-backward
486 Nonincremental search for a regexp is done by the functions
487 @code{re-search-forward} and @code{re-search-backward}. You can invoke
488 these with @kbd{M-x}, or bind them to keys, or invoke them by way of
489 incremental regexp search with @kbd{C-M-s @key{RET}} and @kbd{C-M-r
490 @key{RET}}.
491
492 If you use the incremental regexp search commands with a prefix
493 argument, they perform ordinary string search, like
494 @code{isearch-forward} and @code{isearch-backward}. @xref{Incremental
495 Search}.
496
497 @node Regexps
498 @section Syntax of Regular Expressions
499 @cindex syntax of regexps
500
501 This manual describes regular expression features that users
502 typically want to use. There are additional features that are
503 mainly used in Lisp programs; see @ref{Regular Expressions,,,
504 elisp, The Emacs Lisp Reference Manual}.
505
506 Regular expressions have a syntax in which a few characters are
507 special constructs and the rest are @dfn{ordinary}. An ordinary
508 character is a simple regular expression which matches that same
509 character and nothing else. The special characters are @samp{$},
510 @samp{^}, @samp{.}, @samp{*}, @samp{+}, @samp{?}, @samp{[}, and
511 @samp{\}. The character @samp{]} is special if it ends a character
512 alternative (see later). The character @samp{-} is special inside a
513 character alternative. Any other character appearing in a regular
514 expression is ordinary, unless a @samp{\} precedes it. (When you use
515 regular expressions in a Lisp program, each @samp{\} must be doubled,
516 see the example near the end of this section.)
517
518 For example, @samp{f} is not a special character, so it is ordinary, and
519 therefore @samp{f} is a regular expression that matches the string
520 @samp{f} and no other string. (It does @emph{not} match the string
521 @samp{ff}.) Likewise, @samp{o} is a regular expression that matches
522 only @samp{o}. (When case distinctions are being ignored, these regexps
523 also match @samp{F} and @samp{O}, but we consider this a generalization
524 of ``the same string,'' rather than an exception.)
525
526 Any two regular expressions @var{a} and @var{b} can be concatenated. The
527 result is a regular expression which matches a string if @var{a} matches
528 some amount of the beginning of that string and @var{b} matches the rest of
529 the string.@refill
530
531 As a simple example, we can concatenate the regular expressions @samp{f}
532 and @samp{o} to get the regular expression @samp{fo}, which matches only
533 the string @samp{fo}. Still trivial. To do something nontrivial, you
534 need to use one of the special characters. Here is a list of them.
535
536 @table @asis
537 @item @kbd{.}@: @r{(Period)}
538 is a special character that matches any single character except a newline.
539 Using concatenation, we can make regular expressions like @samp{a.b}, which
540 matches any three-character string that begins with @samp{a} and ends with
541 @samp{b}.@refill
542
543 @item @kbd{*}
544 is not a construct by itself; it is a postfix operator that means to
545 match the preceding regular expression repetitively as many times as
546 possible. Thus, @samp{o*} matches any number of @samp{o}s (including no
547 @samp{o}s).
548
549 @samp{*} always applies to the @emph{smallest} possible preceding
550 expression. Thus, @samp{fo*} has a repeating @samp{o}, not a repeating
551 @samp{fo}. It matches @samp{f}, @samp{fo}, @samp{foo}, and so on.
552
553 The matcher processes a @samp{*} construct by matching, immediately,
554 as many repetitions as can be found. Then it continues with the rest
555 of the pattern. If that fails, backtracking occurs, discarding some
556 of the matches of the @samp{*}-modified construct in case that makes
557 it possible to match the rest of the pattern. For example, in matching
558 @samp{ca*ar} against the string @samp{caaar}, the @samp{a*} first
559 tries to match all three @samp{a}s; but the rest of the pattern is
560 @samp{ar} and there is only @samp{r} left to match, so this try fails.
561 The next alternative is for @samp{a*} to match only two @samp{a}s.
562 With this choice, the rest of the regexp matches successfully.@refill
563
564 @item @kbd{+}
565 is a postfix operator, similar to @samp{*} except that it must match
566 the preceding expression at least once. So, for example, @samp{ca+r}
567 matches the strings @samp{car} and @samp{caaaar} but not the string
568 @samp{cr}, whereas @samp{ca*r} matches all three strings.
569
570 @item @kbd{?}
571 is a postfix operator, similar to @samp{*} except that it can match the
572 preceding expression either once or not at all. For example,
573 @samp{ca?r} matches @samp{car} or @samp{cr}; nothing else.
574
575 @item @kbd{*?}, @kbd{+?}, @kbd{??}
576 @cindex non-greedy regexp matching
577 are non-greedy variants of the operators above. The normal operators
578 @samp{*}, @samp{+}, @samp{?} are @dfn{greedy} in that they match as
579 much as they can, as long as the overall regexp can still match. With
580 a following @samp{?}, they are non-greedy: they will match as little
581 as possible.
582
583 Thus, both @samp{ab*} and @samp{ab*?} can match the string @samp{a}
584 and the string @samp{abbbb}; but if you try to match them both against
585 the text @samp{abbb}, @samp{ab*} will match it all (the longest valid
586 match), while @samp{ab*?} will match just @samp{a} (the shortest
587 valid match).
588
589 Non-greedy operators match the shortest possible string starting at a
590 given starting point; in a forward search, though, the earliest
591 possible starting point for match is always the one chosen. Thus, if
592 you search for @samp{a.*?$} against the text @samp{abbab} followed by
593 a newline, it matches the whole string. Since it @emph{can} match
594 starting at the first @samp{a}, it does.
595
596 @item @kbd{\@{@var{n}\@}}
597 is a postfix operator that specifies repetition @var{n} times---that
598 is, the preceding regular expression must match exactly @var{n} times
599 in a row. For example, @samp{x\@{4\@}} matches the string @samp{xxxx}
600 and nothing else.
601
602 @item @kbd{\@{@var{n},@var{m}\@}}
603 is a postfix operator that specifies repetition between @var{n} and
604 @var{m} times---that is, the preceding regular expression must match
605 at least @var{n} times, but no more than @var{m} times. If @var{m} is
606 omitted, then there is no upper limit, but the preceding regular
607 expression must match at least @var{n} times.@* @samp{\@{0,1\@}} is
608 equivalent to @samp{?}. @* @samp{\@{0,\@}} is equivalent to
609 @samp{*}. @* @samp{\@{1,\@}} is equivalent to @samp{+}.
610
611 @item @kbd{[ @dots{} ]}
612 is a @dfn{character set}, which begins with @samp{[} and is terminated
613 by @samp{]}. In the simplest case, the characters between the two
614 brackets are what this set can match.
615
616 Thus, @samp{[ad]} matches either one @samp{a} or one @samp{d}, and
617 @samp{[ad]*} matches any string composed of just @samp{a}s and @samp{d}s
618 (including the empty string), from which it follows that @samp{c[ad]*r}
619 matches @samp{cr}, @samp{car}, @samp{cdr}, @samp{caddaar}, etc.
620
621 You can also include character ranges in a character set, by writing the
622 starting and ending characters with a @samp{-} between them. Thus,
623 @samp{[a-z]} matches any lower-case @acronym{ASCII} letter. Ranges may be
624 intermixed freely with individual characters, as in @samp{[a-z$%.]},
625 which matches any lower-case @acronym{ASCII} letter or @samp{$}, @samp{%} or
626 period.
627
628 Note that the usual regexp special characters are not special inside a
629 character set. A completely different set of special characters exists
630 inside character sets: @samp{]}, @samp{-} and @samp{^}.
631
632 To include a @samp{]} in a character set, you must make it the first
633 character. For example, @samp{[]a]} matches @samp{]} or @samp{a}. To
634 include a @samp{-}, write @samp{-} as the first or last character of the
635 set, or put it after a range. Thus, @samp{[]-]} matches both @samp{]}
636 and @samp{-}.
637
638 To include @samp{^} in a set, put it anywhere but at the beginning of
639 the set. (At the beginning, it complements the set---see below.)
640
641 When you use a range in case-insensitive search, you should write both
642 ends of the range in upper case, or both in lower case, or both should
643 be non-letters. The behavior of a mixed-case range such as @samp{A-z}
644 is somewhat ill-defined, and it may change in future Emacs versions.
645
646 @item @kbd{[^ @dots{} ]}
647 @samp{[^} begins a @dfn{complemented character set}, which matches any
648 character except the ones specified. Thus, @samp{[^a-z0-9A-Z]} matches
649 all characters @emph{except} @acronym{ASCII} letters and digits.
650
651 @samp{^} is not special in a character set unless it is the first
652 character. The character following the @samp{^} is treated as if it
653 were first (in other words, @samp{-} and @samp{]} are not special there).
654
655 A complemented character set can match a newline, unless newline is
656 mentioned as one of the characters not to match. This is in contrast to
657 the handling of regexps in programs such as @code{grep}.
658
659 @item @kbd{^}
660 is a special character that matches the empty string, but only at the
661 beginning of a line in the text being matched. Otherwise it fails to
662 match anything. Thus, @samp{^foo} matches a @samp{foo} that occurs at
663 the beginning of a line.
664
665 For historical compatibility reasons, @samp{^} can be used with this
666 meaning only at the beginning of the regular expression, or after
667 @samp{\(} or @samp{\|}.
668
669 @item @kbd{$}
670 is similar to @samp{^} but matches only at the end of a line. Thus,
671 @samp{x+$} matches a string of one @samp{x} or more at the end of a line.
672
673 For historical compatibility reasons, @samp{$} can be used with this
674 meaning only at the end of the regular expression, or before @samp{\)}
675 or @samp{\|}.
676
677 @item @kbd{\}
678 has two functions: it quotes the special characters (including
679 @samp{\}), and it introduces additional special constructs.
680
681 Because @samp{\} quotes special characters, @samp{\$} is a regular
682 expression that matches only @samp{$}, and @samp{\[} is a regular
683 expression that matches only @samp{[}, and so on.
684
685 See the following section for the special constructs that begin
686 with @samp{\}.
687 @end table
688
689 Note: for historical compatibility, special characters are treated as
690 ordinary ones if they are in contexts where their special meanings make no
691 sense. For example, @samp{*foo} treats @samp{*} as ordinary since there is
692 no preceding expression on which the @samp{*} can act. It is poor practice
693 to depend on this behavior; it is better to quote the special character anyway,
694 regardless of where it appears.
695
696 As a @samp{\} is not special inside a character alternative, it can
697 never remove the special meaning of @samp{-} or @samp{]}. So you
698 should not quote these characters when they have no special meaning
699 either. This would not clarify anything, since backslashes can
700 legitimately precede these characters where they @emph{have} special
701 meaning, as in @samp{[^\]} (@code{"[^\\]"} for Lisp string syntax),
702 which matches any single character except a backslash.
703
704 @node Regexp Backslash
705 @section Backslash in Regular Expressions
706
707 For the most part, @samp{\} followed by any character matches only
708 that character. However, there are several exceptions: two-character
709 sequences starting with @samp{\} that have special meanings. The
710 second character in the sequence is always an ordinary character when
711 used on its own. Here is a table of @samp{\} constructs.
712
713 @table @kbd
714 @item \|
715 specifies an alternative. Two regular expressions @var{a} and @var{b}
716 with @samp{\|} in between form an expression that matches some text if
717 either @var{a} matches it or @var{b} matches it. It works by trying to
718 match @var{a}, and if that fails, by trying to match @var{b}.
719
720 Thus, @samp{foo\|bar} matches either @samp{foo} or @samp{bar}
721 but no other string.@refill
722
723 @samp{\|} applies to the largest possible surrounding expressions. Only a
724 surrounding @samp{\( @dots{} \)} grouping can limit the grouping power of
725 @samp{\|}.@refill
726
727 Full backtracking capability exists to handle multiple uses of @samp{\|}.
728
729 @item \( @dots{} \)
730 is a grouping construct that serves three purposes:
731
732 @enumerate
733 @item
734 To enclose a set of @samp{\|} alternatives for other operations.
735 Thus, @samp{\(foo\|bar\)x} matches either @samp{foox} or @samp{barx}.
736
737 @item
738 To enclose a complicated expression for the postfix operators @samp{*},
739 @samp{+} and @samp{?} to operate on. Thus, @samp{ba\(na\)*} matches
740 @samp{bananana}, etc., with any (zero or more) number of @samp{na}
741 strings.@refill
742
743 @item
744 To record a matched substring for future reference.
745 @end enumerate
746
747 This last application is not a consequence of the idea of a
748 parenthetical grouping; it is a separate feature that is assigned as a
749 second meaning to the same @samp{\( @dots{} \)} construct. In practice
750 there is usually no conflict between the two meanings; when there is
751 a conflict, you can use a ``shy'' group.
752
753 @item \(?: @dots{} \)
754 @cindex shy group, in regexp
755 specifies a ``shy'' group that does not record the matched substring;
756 you can't refer back to it with @samp{\@var{d}}. This is useful
757 in mechanically combining regular expressions, so that you
758 can add groups for syntactic purposes without interfering with
759 the numbering of the groups that are meant to be referred to.
760
761 @item \@var{d}
762 @cindex back reference, in regexp
763 matches the same text that matched the @var{d}th occurrence of a
764 @samp{\( @dots{} \)} construct. This is called a @dfn{back
765 reference}.
766
767 After the end of a @samp{\( @dots{} \)} construct, the matcher remembers
768 the beginning and end of the text matched by that construct. Then,
769 later on in the regular expression, you can use @samp{\} followed by the
770 digit @var{d} to mean ``match the same text matched the @var{d}th time
771 by the @samp{\( @dots{} \)} construct.''
772
773 The strings matching the first nine @samp{\( @dots{} \)} constructs
774 appearing in a regular expression are assigned numbers 1 through 9 in
775 the order that the open-parentheses appear in the regular expression.
776 So you can use @samp{\1} through @samp{\9} to refer to the text matched
777 by the corresponding @samp{\( @dots{} \)} constructs.
778
779 For example, @samp{\(.*\)\1} matches any newline-free string that is
780 composed of two identical halves. The @samp{\(.*\)} matches the first
781 half, which may be anything, but the @samp{\1} that follows must match
782 the same exact text.
783
784 If a particular @samp{\( @dots{} \)} construct matches more than once
785 (which can easily happen if it is followed by @samp{*}), only the last
786 match is recorded.
787
788 @item \`
789 matches the empty string, but only at the beginning of the string or
790 buffer (or its accessible portion) being matched against.
791
792 @item \'
793 matches the empty string, but only at the end of the string or buffer
794 (or its accessible portion) being matched against.
795
796 @item \=
797 matches the empty string, but only at point.
798
799 @item \b
800 matches the empty string, but only at the beginning or
801 end of a word. Thus, @samp{\bfoo\b} matches any occurrence of
802 @samp{foo} as a separate word. @samp{\bballs?\b} matches
803 @samp{ball} or @samp{balls} as a separate word.@refill
804
805 @samp{\b} matches at the beginning or end of the buffer
806 regardless of what text appears next to it.
807
808 @item \B
809 matches the empty string, but @emph{not} at the beginning or
810 end of a word.
811
812 @item \<
813 matches the empty string, but only at the beginning of a word.
814 @samp{\<} matches at the beginning of the buffer only if a
815 word-constituent character follows.
816
817 @item \>
818 matches the empty string, but only at the end of a word. @samp{\>}
819 matches at the end of the buffer only if the contents end with a
820 word-constituent character.
821
822 @item \w
823 matches any word-constituent character. The syntax table
824 determines which characters these are. @xref{Syntax}.
825
826 @item \W
827 matches any character that is not a word-constituent.
828
829 @item \_<
830 matches the empty string, but only at the beginning of a symbol.
831 A symbol is a sequence of one or more symbol-constituent characters.
832 A symbol-constituent character is a character whose syntax is either
833 @samp{w} or @samp{_}. @samp{\_<} matches at the beginning of the
834 buffer only if a symbol-constituent character follows.
835
836 @item \_>
837 matches the empty string, but only at the end of a symbol. @samp{\_>}
838 matches at the end of the buffer only if the contents end with a
839 symbol-constituent character.
840
841 @item \s@var{c}
842 matches any character whose syntax is @var{c}. Here @var{c} is a
843 character that designates a particular syntax class: thus, @samp{w}
844 for word constituent, @samp{-} or @samp{ } for whitespace, @samp{.}
845 for ordinary punctuation, etc. @xref{Syntax}.
846
847 @item \S@var{c}
848 matches any character whose syntax is not @var{c}.
849
850 @cindex categories of characters
851 @cindex characters which belong to a specific language
852 @findex describe-categories
853 @item \c@var{c}
854 matches any character that belongs to the category @var{c}. For
855 example, @samp{\cc} matches Chinese characters, @samp{\cg} matches
856 Greek characters, etc. For the description of the known categories,
857 type @kbd{M-x describe-categories @key{RET}}.
858
859 @item \C@var{c}
860 matches any character that does @emph{not} belong to category
861 @var{c}.
862 @end table
863
864 The constructs that pertain to words and syntax are controlled by the
865 setting of the syntax table (@pxref{Syntax}).
866
867 @node Regexp Example
868 @section Regular Expression Example
869
870 Here is a complicated regexp---a simplified version of the regexp
871 that Emacs uses, by default, to recognize the end of a sentence
872 together with any whitespace that follows. We show its Lisp syntax to
873 distinguish the spaces from the tab characters. In Lisp syntax, the
874 string constant begins and ends with a double-quote. @samp{\"} stands
875 for a double-quote as part of the regexp, @samp{\\} for a backslash as
876 part of the regexp, @samp{\t} for a tab, and @samp{\n} for a newline.
877
878 @example
879 "[.?!][]\"')]*\\($\\| $\\|\t\\| \\)[ \t\n]*"
880 @end example
881
882 @noindent
883 This contains four parts in succession: a character set matching
884 period, @samp{?}, or @samp{!}; a character set matching
885 close-brackets, quotes, or parentheses, repeated zero or more times; a
886 set of alternatives within backslash-parentheses that matches either
887 end-of-line, a space at the end of a line, a tab, or two spaces; and a
888 character set matching whitespace characters, repeated any number of
889 times.
890
891 To enter the same regexp in incremental search, you would type
892 @key{TAB} to enter a tab, and @kbd{C-j} to enter a newline. You would
893 also type single backslashes as themselves, instead of doubling them
894 for Lisp syntax. In commands that use ordinary minibuffer input to
895 read a regexp, you would quote the @kbd{C-j} by preceding it with a
896 @kbd{C-q} to prevent @kbd{C-j} from exiting the minibuffer.
897
898 @node Search Case
899 @section Searching and Case
900
901 Incremental searches in Emacs normally ignore the case of the text
902 they are searching through, if you specify the text in lower case.
903 Thus, if you specify searching for @samp{foo}, then @samp{Foo} and
904 @samp{foo} are also considered a match. Regexps, and in particular
905 character sets, are included: @samp{[ab]} would match @samp{a} or
906 @samp{A} or @samp{b} or @samp{B}.@refill
907
908 An upper-case letter anywhere in the incremental search string makes
909 the search case-sensitive. Thus, searching for @samp{Foo} does not find
910 @samp{foo} or @samp{FOO}. This applies to regular expression search as
911 well as to string search. The effect ceases if you delete the
912 upper-case letter from the search string.
913
914 Typing @kbd{M-c} within an incremental search toggles the case
915 sensitivity of that search. The effect does not extend beyond the
916 current incremental search to the next one, but it does override the
917 effect of including an upper-case letter in the current search.
918
919 @vindex case-fold-search
920 @vindex default-case-fold-search
921 If you set the variable @code{case-fold-search} to @code{nil}, then
922 all letters must match exactly, including case. This is a per-buffer
923 variable; altering the variable affects only the current buffer, but
924 there is a default value in @code{default-case-fold-search} that you
925 can also set. @xref{Locals}. This variable applies to nonincremental
926 searches also, including those performed by the replace commands
927 (@pxref{Replace}) and the minibuffer history matching commands
928 (@pxref{Minibuffer History}).
929
930 Several related variables control case-sensitivity of searching and
931 matching for specific commands or activities. For instance,
932 @code{tags-case-fold-search} controls case sensitivity for
933 @code{find-tag}. To find these variables, do @kbd{M-x
934 apropos-variable @key{RET} case-fold-search @key{RET}}.
935
936 @node Replace
937 @section Replacement Commands
938 @cindex replacement
939 @cindex search-and-replace commands
940 @cindex string substitution
941 @cindex global substitution
942
943 Global search-and-replace operations are not needed often in Emacs,
944 but they are available. In addition to the simple @kbd{M-x
945 replace-string} command which replaces all occurrences,
946 there is @kbd{M-%} (@code{query-replace}), which presents each occurrence
947 of the pattern and asks you whether to replace it.
948
949 The replace commands normally operate on the text from point to the
950 end of the buffer; however, in Transient Mark mode (@pxref{Transient
951 Mark}), when the mark is active, they operate on the region. The
952 basic replace commands replace one string (or regexp) with one
953 replacement string. It is possible to perform several replacements in
954 parallel using the command @code{expand-region-abbrevs}
955 (@pxref{Expanding Abbrevs}).
956
957 @menu
958 * Unconditional Replace:: Replacing all matches for a string.
959 * Regexp Replace:: Replacing all matches for a regexp.
960 * Replacement and Case:: How replacements preserve case of letters.
961 * Query Replace:: How to use querying.
962 @end menu
963
964 @node Unconditional Replace, Regexp Replace, Replace, Replace
965 @subsection Unconditional Replacement
966 @findex replace-string
967
968 @table @kbd
969 @item M-x replace-string @key{RET} @var{string} @key{RET} @var{newstring} @key{RET}
970 Replace every occurrence of @var{string} with @var{newstring}.
971 @end table
972
973 To replace every instance of @samp{foo} after point with @samp{bar},
974 use the command @kbd{M-x replace-string} with the two arguments
975 @samp{foo} and @samp{bar}. Replacement happens only in the text after
976 point, so if you want to cover the whole buffer you must go to the
977 beginning first. All occurrences up to the end of the buffer are
978 replaced; to limit replacement to part of the buffer, narrow to that
979 part of the buffer before doing the replacement (@pxref{Narrowing}).
980 In Transient Mark mode, when the region is active, replacement is
981 limited to the region (@pxref{Transient Mark}).
982
983 When @code{replace-string} exits, it leaves point at the last
984 occurrence replaced. It sets the mark to the prior position of point
985 (where the @code{replace-string} command was issued); use @kbd{C-u
986 C-@key{SPC}} to move back there.
987
988 A numeric argument restricts replacement to matches that are surrounded
989 by word boundaries. The argument's value doesn't matter.
990
991 What if you want to exchange @samp{x} and @samp{y}: replace every @samp{x} with a @samp{y} and vice versa? You can do it this way:
992
993 @example
994 M-x replace-string @key{RET} x @key{RET} @@TEMP@@ @key{RET}
995 M-< M-x replace-string @key{RET} y @key{RET} x @key{RET}
996 M-< M-x replace-string @key{RET} @@TEMP@@ @key{RET} y @key{RET}
997 @end example
998
999 @noindent
1000 This works provided the string @samp{@@TEMP@@} does not appear
1001 in your text.
1002
1003 @node Regexp Replace, Replacement and Case, Unconditional Replace, Replace
1004 @subsection Regexp Replacement
1005 @findex replace-regexp
1006
1007 The @kbd{M-x replace-string} command replaces exact matches for a
1008 single string. The similar command @kbd{M-x replace-regexp} replaces
1009 any match for a specified pattern.
1010
1011 @table @kbd
1012 @item M-x replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET}
1013 Replace every match for @var{regexp} with @var{newstring}.
1014 @end table
1015
1016 @cindex back reference, in regexp replacement
1017 In @code{replace-regexp}, the @var{newstring} need not be constant:
1018 it can refer to all or part of what is matched by the @var{regexp}.
1019 @samp{\&} in @var{newstring} stands for the entire match being
1020 replaced. @samp{\@var{d}} in @var{newstring}, where @var{d} is a
1021 digit, stands for whatever matched the @var{d}th parenthesized
1022 grouping in @var{regexp}. (This is called a ``back reference.'')
1023 @samp{\#} refers to the count of replacements already made in this
1024 command, as a decimal number. In the first replacement, @samp{\#}
1025 stands for @samp{0}; in the second, for @samp{1}; and so on. For
1026 example,
1027
1028 @example
1029 M-x replace-regexp @key{RET} c[ad]+r @key{RET} \&-safe @key{RET}
1030 @end example
1031
1032 @noindent
1033 replaces (for example) @samp{cadr} with @samp{cadr-safe} and @samp{cddr}
1034 with @samp{cddr-safe}.
1035
1036 @example
1037 M-x replace-regexp @key{RET} \(c[ad]+r\)-safe @key{RET} \1 @key{RET}
1038 @end example
1039
1040 @noindent
1041 performs the inverse transformation. To include a @samp{\} in the
1042 text to replace with, you must enter @samp{\\}.
1043
1044 If you want to enter part of the replacement string by hand each
1045 time, use @samp{\?} in the replacement string. Each replacement will
1046 ask you to edit the replacement string in the minibuffer, putting
1047 point where the @samp{\?} was.
1048
1049 The remainder of this subsection is intended for specialized tasks
1050 and requires knowledge of Lisp. Most readers can skip it.
1051
1052 You can use Lisp expressions to calculate parts of the
1053 replacement string. To do this, write @samp{\,} followed by the
1054 expression in the replacement string. Each replacement calculates the
1055 value of the expression and converts it to text without quoting (if
1056 it's a string, this means using the string's contents), and uses it in
1057 the replacement string in place of the expression itself. If the
1058 expression is a symbol, one space in the replacement string after the
1059 symbol name goes with the symbol name, so the value replaces them
1060 both.
1061
1062 Inside such an expression, you can use some special sequences.
1063 @samp{\&} and @samp{\@var{n}} refer here, as usual, to the entire
1064 match as a string, and to a submatch as a string. @var{n} may be
1065 multiple digits, and the value of @samp{\@var{n}} is @code{nil} if
1066 subexpression @var{n} did not match. You can also use @samp{\#&} and
1067 @samp{\#@var{n}} to refer to those matches as numbers (this is valid
1068 when the match or submatch has the form of a numeral). @samp{\#} here
1069 too stands for the number of already-completed replacements.
1070
1071 Repeating our example to exchange @samp{x} and @samp{y}, we can thus
1072 do it also this way:
1073
1074 @example
1075 M-x replace-regexp @key{RET} \(x\)\|y @key{RET}
1076 \,(if \1 "y" "x") @key{RET}
1077 @end example
1078
1079 For computing replacement strings for @samp{\,}, the @code{format}
1080 function is often useful (@pxref{Formatting Strings,,, elisp, The Emacs
1081 Lisp Reference Manual}). For example, to add consecutively numbered
1082 strings like @samp{ABC00042} to columns 73 @w{to 80} (unless they are
1083 already occupied), you can use
1084
1085 @example
1086 M-x replace-regexp @key{RET} ^.\@{0,72\@}$ @key{RET}
1087 \,(format "%-72sABC%05d" \& \#) @key{RET}
1088 @end example
1089
1090 @node Replacement and Case, Query Replace, Regexp Replace, Replace
1091 @subsection Replace Commands and Case
1092
1093 If the first argument of a replace command is all lower case, the
1094 command ignores case while searching for occurrences to
1095 replace---provided @code{case-fold-search} is non-@code{nil}. If
1096 @code{case-fold-search} is set to @code{nil}, case is always significant
1097 in all searches.
1098
1099 @vindex case-replace
1100 In addition, when the @var{newstring} argument is all or partly lower
1101 case, replacement commands try to preserve the case pattern of each
1102 occurrence. Thus, the command
1103
1104 @example
1105 M-x replace-string @key{RET} foo @key{RET} bar @key{RET}
1106 @end example
1107
1108 @noindent
1109 replaces a lower case @samp{foo} with a lower case @samp{bar}, an
1110 all-caps @samp{FOO} with @samp{BAR}, and a capitalized @samp{Foo} with
1111 @samp{Bar}. (These three alternatives---lower case, all caps, and
1112 capitalized, are the only ones that @code{replace-string} can
1113 distinguish.)
1114
1115 If upper-case letters are used in the replacement string, they remain
1116 upper case every time that text is inserted. If upper-case letters are
1117 used in the first argument, the second argument is always substituted
1118 exactly as given, with no case conversion. Likewise, if either
1119 @code{case-replace} or @code{case-fold-search} is set to @code{nil},
1120 replacement is done without case conversion.
1121
1122 @node Query Replace,, Replacement and Case, Replace
1123 @subsection Query Replace
1124 @cindex query replace
1125
1126 @table @kbd
1127 @item M-% @var{string} @key{RET} @var{newstring} @key{RET}
1128 @itemx M-x query-replace @key{RET} @var{string} @key{RET} @var{newstring} @key{RET}
1129 Replace some occurrences of @var{string} with @var{newstring}.
1130 @item C-M-% @var{regexp} @key{RET} @var{newstring} @key{RET}
1131 @itemx M-x query-replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET}
1132 Replace some matches for @var{regexp} with @var{newstring}.
1133 @end table
1134
1135 @kindex M-%
1136 @findex query-replace
1137 If you want to change only some of the occurrences of @samp{foo} to
1138 @samp{bar}, not all of them, then you cannot use an ordinary
1139 @code{replace-string}. Instead, use @kbd{M-%} (@code{query-replace}).
1140 This command finds occurrences of @samp{foo} one by one, displays each
1141 occurrence and asks you whether to replace it. Aside from querying,
1142 @code{query-replace} works just like @code{replace-string}. It
1143 preserves case, like @code{replace-string}, provided
1144 @code{case-replace} is non-@code{nil}, as it normally is. A numeric
1145 argument means consider only occurrences that are bounded by
1146 word-delimiter characters.
1147
1148 @kindex C-M-%
1149 @findex query-replace-regexp
1150 @kbd{C-M-%} performs regexp search and replace (@code{query-replace-regexp}).
1151 It works like @code{replace-regexp} except that it queries
1152 like @code{query-replace}.
1153
1154 @cindex faces for highlighting query replace
1155 These commands highlight the current match using the face
1156 @code{query-replace}. They highlight other matches using
1157 @code{lazy-highlight} just like incremental search (@pxref{Incremental
1158 Search}).
1159
1160 The characters you can type when you are shown a match for the string
1161 or regexp are:
1162
1163 @ignore @c Not worth it.
1164 @kindex SPC @r{(query-replace)}
1165 @kindex DEL @r{(query-replace)}
1166 @kindex , @r{(query-replace)}
1167 @kindex RET @r{(query-replace)}
1168 @kindex . @r{(query-replace)}
1169 @kindex ! @r{(query-replace)}
1170 @kindex ^ @r{(query-replace)}
1171 @kindex C-r @r{(query-replace)}
1172 @kindex C-w @r{(query-replace)}
1173 @kindex C-l @r{(query-replace)}
1174 @end ignore
1175
1176 @c WideCommands
1177 @table @kbd
1178 @item @key{SPC}
1179 to replace the occurrence with @var{newstring}.
1180
1181 @item @key{DEL}
1182 to skip to the next occurrence without replacing this one.
1183
1184 @item , @r{(Comma)}
1185 to replace this occurrence and display the result. You are then asked
1186 for another input character to say what to do next. Since the
1187 replacement has already been made, @key{DEL} and @key{SPC} are
1188 equivalent in this situation; both move to the next occurrence.
1189
1190 You can type @kbd{C-r} at this point (see below) to alter the replaced
1191 text. You can also type @kbd{C-x u} to undo the replacement; this exits
1192 the @code{query-replace}, so if you want to do further replacement you
1193 must use @kbd{C-x @key{ESC} @key{ESC} @key{RET}} to restart
1194 (@pxref{Repetition}).
1195
1196 @item @key{RET}
1197 to exit without doing any more replacements.
1198
1199 @item .@: @r{(Period)}
1200 to replace this occurrence and then exit without searching for more
1201 occurrences.
1202
1203 @item !
1204 to replace all remaining occurrences without asking again.
1205
1206 @item ^
1207 to go back to the position of the previous occurrence (or what used to
1208 be an occurrence), in case you changed it by mistake or want to
1209 reexamine it.
1210
1211 @item C-r
1212 to enter a recursive editing level, in case the occurrence needs to be
1213 edited rather than just replaced with @var{newstring}. When you are
1214 done, exit the recursive editing level with @kbd{C-M-c} to proceed to
1215 the next occurrence. @xref{Recursive Edit}.
1216
1217 @item C-w
1218 to delete the occurrence, and then enter a recursive editing level as in
1219 @kbd{C-r}. Use the recursive edit to insert text to replace the deleted
1220 occurrence of @var{string}. When done, exit the recursive editing level
1221 with @kbd{C-M-c} to proceed to the next occurrence.
1222
1223 @item e
1224 to edit the replacement string in the minibuffer. When you exit the
1225 minibuffer by typing @key{RET}, the minibuffer contents replace the
1226 current occurrence of the pattern. They also become the new
1227 replacement string for any further occurrences.
1228
1229 @item C-l
1230 to redisplay the screen. Then you must type another character to
1231 specify what to do with this occurrence.
1232
1233 @item C-h
1234 to display a message summarizing these options. Then you must type
1235 another character to specify what to do with this occurrence.
1236 @end table
1237
1238 Some other characters are aliases for the ones listed above: @kbd{y},
1239 @kbd{n} and @kbd{q} are equivalent to @key{SPC}, @key{DEL} and
1240 @key{RET}.
1241
1242 Aside from this, any other character exits the @code{query-replace},
1243 and is then reread as part of a key sequence. Thus, if you type
1244 @kbd{C-k}, it exits the @code{query-replace} and then kills to end of
1245 line.
1246
1247 To restart a @code{query-replace} once it is exited, use @kbd{C-x
1248 @key{ESC} @key{ESC}}, which repeats the @code{query-replace} because it
1249 used the minibuffer to read its arguments. @xref{Repetition, C-x ESC
1250 ESC}.
1251
1252 @xref{Operating on Files}, for the Dired @kbd{Q} command which
1253 performs query replace on selected files. See also @ref{Transforming
1254 File Names}, for Dired commands to rename, copy, or link files by
1255 replacing regexp matches in file names.
1256
1257 @node Other Repeating Search
1258 @section Other Search-and-Loop Commands
1259
1260 Here are some other commands that find matches for a regular
1261 expression. They all ignore case in matching, if the pattern contains
1262 no upper-case letters and @code{case-fold-search} is non-@code{nil}.
1263 Aside from @code{occur} and its variants, all operate on the text from
1264 point to the end of the buffer, or on the active region in Transient
1265 Mark mode.
1266
1267 @findex list-matching-lines
1268 @findex occur
1269 @findex multi-occur
1270 @findex multi-occur-in-matching-buffers
1271 @findex how-many
1272 @findex delete-non-matching-lines
1273 @findex delete-matching-lines
1274 @findex flush-lines
1275 @findex keep-lines
1276
1277 @table @kbd
1278 @item M-x occur @key{RET} @var{regexp} @key{RET}
1279 Display a list showing each line in the buffer that contains a match
1280 for @var{regexp}. To limit the search to part of the buffer, narrow
1281 to that part (@pxref{Narrowing}). A numeric argument @var{n}
1282 specifies that @var{n} lines of context are to be displayed before and
1283 after each matching line. Currently, @code{occur} can not correctly
1284 handle multiline matches.
1285
1286 @kindex RET @r{(Occur mode)}
1287 @kindex o @r{(Occur mode)}
1288 @kindex C-o @r{(Occur mode)}
1289 The buffer @samp{*Occur*} containing the output serves as a menu for
1290 finding the occurrences in their original context. Click
1291 @kbd{Mouse-2} on an occurrence listed in @samp{*Occur*}, or position
1292 point there and type @key{RET}; this switches to the buffer that was
1293 searched and moves point to the original of the chosen occurrence.
1294 @kbd{o} and @kbd{C-o} display the match in another window; @kbd{C-o}
1295 does not select it.
1296
1297 After using @kbd{M-x occur}, you can use @code{next-error} to visit
1298 the occurrences found, one by one. @ref{Compilation Mode}.
1299
1300 @item M-x list-matching-lines
1301 Synonym for @kbd{M-x occur}.
1302
1303 @item M-x multi-occur @key{RET} @var{buffers} @key{RET} @var{regexp} @key{RET}
1304 This function is just like @code{occur}, except it is able to search
1305 through multiple buffers. It asks you to specify the buffer names one by one.
1306
1307 @item M-x multi-occur-in-matching-buffers @key{RET} @var{bufregexp} @key{RET} @var{regexp} @key{RET}
1308 This function is similar to @code{multi-occur}, except the buffers to
1309 search are specified by a regular expression that matches visited
1310 file names. With a prefix argument, it uses the regular expression to match
1311 buffer names instead.
1312
1313 @item M-x how-many @key{RET} @var{regexp} @key{RET}
1314 Print the number of matches for @var{regexp} that exist in the buffer
1315 after point. In Transient Mark mode, if the region is active, the
1316 command operates on the region instead.
1317
1318 @item M-x flush-lines @key{RET} @var{regexp} @key{RET}
1319 This command deletes each line that contains a match for @var{regexp},
1320 operating on the text after point; it deletes the current line
1321 if it contains a match starting after point. In Transient Mark mode,
1322 if the region is active, the command operates on the region instead;
1323 it deletes a line partially contained in the region if it contains a
1324 match entirely contained in the region.
1325
1326 If a match is split across lines, @code{flush-lines} deletes all those
1327 lines. It deletes the lines before starting to look for the next
1328 match; hence, it ignores a match starting on the same line at which
1329 another match ended.
1330
1331 @item M-x keep-lines @key{RET} @var{regexp} @key{RET}
1332 This command deletes each line that @emph{does not} contain a match for
1333 @var{regexp}, operating on the text after point; if point is not at the
1334 beginning of a line, it always keeps the current line. In Transient
1335 Mark mode, if the region is active, the command operates on the region
1336 instead; it never deletes lines that are only partially contained in
1337 the region (a newline that ends a line counts as part of that line).
1338
1339 If a match is split across lines, this command keeps all those lines.
1340 @end table
1341
1342 @ignore
1343 arch-tag: fd9d8e77-66af-491c-b212-d80999613e3e
1344 @end ignore