(Fmodify_frame_parameters): Doc fix.
[emacs.git] / man / search.texi
blob64dee038ae92a094e3427f873d7561d6350305e6
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, 2007, 2008 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
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.
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.
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}).
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
41 @node Incremental Search
42 @section Incremental Search
43 @cindex incremental search
44 @cindex isearch
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}.
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
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
73 @node Basic Isearch
74 @subsection Basics of Incremental Search
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.
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.
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).
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.
114 @node Repeat Isearch
115 @subsection Repeating Incremental Search
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}.
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.''
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.
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.
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}.
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.
160 @node Error in Isearch
161 @subsection Errors in Incremental Search
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.
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.
188 @node Special Isearch
189 @subsection Special Input for Incremental Search
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}.
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.
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}.
208   Entering @key{RET} when the search string is empty launches
209 nonincremental search (@pxref{Nonincremental Search}).
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}}.
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
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:
229 @example
230 I-search [@var{im}]:
231 @end example
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.
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.
245 @node Isearch Yank
246 @subsection Isearch Yanking
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.
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.
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.
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}.
277 @node Highlight Isearch
278 @subsection Lazy Search Highlighting
279 @cindex lazy search highlighting
280 @vindex isearch-lazy-highlight
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}.
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).
295 @node Isearch Scroll
296 @subsection Scrolling During Incremental Search
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.
308   This feature won't let you scroll the current match out of visibility,
309 however.
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.
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}):
324 @example
325 (put 'view-lossage 'isearch-scroll t)
326 @end example
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.
334 @node Slow Isearch
335 @subsection Slow Terminal Incremental Search
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.
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.
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}).
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.
358 @node Nonincremental Search
359 @section Nonincremental Search
360 @cindex nonincremental search
362   Emacs also has conventional nonincremental search commands, which require
363 you to type the entire search string before searching begins.
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
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.
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.
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.
398 @node Word Search
399 @section Word Search
400 @cindex word search
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.
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.
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
420   Word search as a special case of nonincremental search 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}.
427   Use @kbd{C-r @key{RET} C-w} to do backward word search.
429   You can also invoke word search with @kbd{C-s M-e C-w} or @kbd{C-r
430 M-e C-w} followed by the search string and terminated with @key{RET},
431 @kbd{C-s} or @kbd{C-r}.  This puts word search into incremental mode
432 where you can use all keys available for incremental search.  However,
433 when you type more words in incremental word search, it will fail
434 until you type complete words.
436 @findex word-search-forward
437 @findex word-search-backward
438   Forward and backward word searches are implemented by the commands
439 @code{word-search-forward} and @code{word-search-backward}.  These
440 commands may be bound to keys in the usual manner.  They are available
441 via the incremental search commands both for historical reasons and
442 to avoid the need to find separate key sequences for them.
444 @node Regexp Search
445 @section Regular Expression Search
446 @cindex regular expression
447 @cindex regexp
449   A @dfn{regular expression} (@dfn{regexp}, for short) is a pattern
450 that denotes a class of alternative strings to match, possibly
451 infinitely many.  GNU Emacs provides both incremental and
452 nonincremental ways to search for a match for a regexp.  The syntax of
453 regular expressions is explained in the following section.
455 @kindex C-M-s
456 @findex isearch-forward-regexp
457 @kindex C-M-r
458 @findex isearch-backward-regexp
459   Incremental search for a regexp is done by typing @kbd{C-M-s}
460 (@code{isearch-forward-regexp}), by invoking @kbd{C-s} with a
461 prefix argument (whose value does not matter), or by typing @kbd{M-r}
462 within a forward incremental search.  This command reads a
463 search string incrementally just like @kbd{C-s}, but it treats the
464 search string as a regexp rather than looking for an exact match
465 against the text in the buffer.  Each time you add text to the search
466 string, you make the regexp longer, and the new regexp is searched
467 for.  To search backward for a regexp, use @kbd{C-M-r}
468 (@code{isearch-backward-regexp}), @kbd{C-r} with a prefix argument,
469 or @kbd{M-r} within a backward incremental search.
471   All of the control characters that do special things within an
472 ordinary incremental search have the same function in incremental regexp
473 search.  Typing @kbd{C-s} or @kbd{C-r} immediately after starting the
474 search retrieves the last incremental search regexp used; that is to
475 say, incremental regexp and non-regexp searches have independent
476 defaults.  They also have separate search rings that you can access with
477 @kbd{M-p} and @kbd{M-n}.
479 @vindex search-whitespace-regexp
480   If you type @key{SPC} in incremental regexp search, it matches any
481 sequence of whitespace characters, including newlines.  If you want to
482 match just a space, type @kbd{C-q @key{SPC}}.  You can control what a
483 bare space matches by setting the variable
484 @code{search-whitespace-regexp} to the desired regexp.
486   In some cases, adding characters to the regexp in an incremental regexp
487 search can make the cursor move back and start again.  For example, if
488 you have searched for @samp{foo} and you add @samp{\|bar}, the cursor
489 backs up in case the first @samp{bar} precedes the first @samp{foo}.
491   Forward and backward regexp search are not symmetrical, because
492 regexp matching in Emacs always operates forward, starting with the
493 beginning of the regexp.  Thus, forward regexp search scans forward,
494 trying a forward match at each possible starting position.  Backward
495 regexp search scans backward, trying a forward match at each possible
496 starting position.  These search methods are not mirror images.
498 @findex re-search-forward
499 @findex re-search-backward
500   Nonincremental search for a regexp is done by the functions
501 @code{re-search-forward} and @code{re-search-backward}.  You can invoke
502 these with @kbd{M-x}, or bind them to keys, or invoke them by way of
503 incremental regexp search with @kbd{C-M-s @key{RET}} and @kbd{C-M-r
504 @key{RET}}.
506   If you use the incremental regexp search commands with a prefix
507 argument, they perform ordinary string search, like
508 @code{isearch-forward} and @code{isearch-backward}.  @xref{Incremental
509 Search}.
511 @node Regexps
512 @section Syntax of Regular Expressions
513 @cindex syntax of regexps
515   This manual describes regular expression features that users
516 typically want to use.  There are additional features that are
517 mainly used in Lisp programs; see @ref{Regular Expressions,,,
518 elisp, The Emacs Lisp Reference Manual}.
520   Regular expressions have a syntax in which a few characters are
521 special constructs and the rest are @dfn{ordinary}.  An ordinary
522 character is a simple regular expression which matches that same
523 character and nothing else.  The special characters are @samp{$},
524 @samp{^}, @samp{.}, @samp{*}, @samp{+}, @samp{?}, @samp{[}, and
525 @samp{\}.  The character @samp{]} is special if it ends a character
526 alternative (see later).  The character @samp{-} is special inside a
527 character alternative.  Any other character appearing in a regular
528 expression is ordinary, unless a @samp{\} precedes it.  (When you use
529 regular expressions in a Lisp program, each @samp{\} must be doubled,
530 see the example near the end of this section.)
532   For example, @samp{f} is not a special character, so it is ordinary, and
533 therefore @samp{f} is a regular expression that matches the string
534 @samp{f} and no other string.  (It does @emph{not} match the string
535 @samp{ff}.)  Likewise, @samp{o} is a regular expression that matches
536 only @samp{o}.  (When case distinctions are being ignored, these regexps
537 also match @samp{F} and @samp{O}, but we consider this a generalization
538 of ``the same string,'' rather than an exception.)
540   Any two regular expressions @var{a} and @var{b} can be concatenated.  The
541 result is a regular expression which matches a string if @var{a} matches
542 some amount of the beginning of that string and @var{b} matches the rest of
543 the string.@refill
545   As a simple example, we can concatenate the regular expressions @samp{f}
546 and @samp{o} to get the regular expression @samp{fo}, which matches only
547 the string @samp{fo}.  Still trivial.  To do something nontrivial, you
548 need to use one of the special characters.  Here is a list of them.
550 @table @asis
551 @item @kbd{.}@: @r{(Period)}
552 is a special character that matches any single character except a newline.
553 Using concatenation, we can make regular expressions like @samp{a.b}, which
554 matches any three-character string that begins with @samp{a} and ends with
555 @samp{b}.@refill
557 @item @kbd{*}
558 is not a construct by itself; it is a postfix operator that means to
559 match the preceding regular expression repetitively as many times as
560 possible.  Thus, @samp{o*} matches any number of @samp{o}s (including no
561 @samp{o}s).
563 @samp{*} always applies to the @emph{smallest} possible preceding
564 expression.  Thus, @samp{fo*} has a repeating @samp{o}, not a repeating
565 @samp{fo}.  It matches @samp{f}, @samp{fo}, @samp{foo}, and so on.
567 The matcher processes a @samp{*} construct by matching, immediately,
568 as many repetitions as can be found.  Then it continues with the rest
569 of the pattern.  If that fails, backtracking occurs, discarding some
570 of the matches of the @samp{*}-modified construct in case that makes
571 it possible to match the rest of the pattern.  For example, in matching
572 @samp{ca*ar} against the string @samp{caaar}, the @samp{a*} first
573 tries to match all three @samp{a}s; but the rest of the pattern is
574 @samp{ar} and there is only @samp{r} left to match, so this try fails.
575 The next alternative is for @samp{a*} to match only two @samp{a}s.
576 With this choice, the rest of the regexp matches successfully.@refill
578 @item @kbd{+}
579 is a postfix operator, similar to @samp{*} except that it must match
580 the preceding expression at least once.  So, for example, @samp{ca+r}
581 matches the strings @samp{car} and @samp{caaaar} but not the string
582 @samp{cr}, whereas @samp{ca*r} matches all three strings.
584 @item @kbd{?}
585 is a postfix operator, similar to @samp{*} except that it can match the
586 preceding expression either once or not at all.  For example,
587 @samp{ca?r} matches @samp{car} or @samp{cr}; nothing else.
589 @item @kbd{*?}, @kbd{+?}, @kbd{??}
590 @cindex non-greedy regexp matching
591 are non-greedy variants of the operators above.  The normal operators
592 @samp{*}, @samp{+}, @samp{?} are @dfn{greedy} in that they match as
593 much as they can, as long as the overall regexp can still match.  With
594 a following @samp{?}, they are non-greedy: they will match as little
595 as possible.
597 Thus, both @samp{ab*} and @samp{ab*?} can match the string @samp{a}
598 and the string @samp{abbbb}; but if you try to match them both against
599 the text @samp{abbb}, @samp{ab*} will match it all (the longest valid
600 match), while @samp{ab*?}  will match just @samp{a} (the shortest
601 valid match).
603 Non-greedy operators match the shortest possible string starting at a
604 given starting point; in a forward search, though, the earliest
605 possible starting point for match is always the one chosen.  Thus, if
606 you search for @samp{a.*?$} against the text @samp{abbab} followed by
607 a newline, it matches the whole string.  Since it @emph{can} match
608 starting at the first @samp{a}, it does.
610 @item @kbd{\@{@var{n}\@}}
611 is a postfix operator that specifies repetition @var{n} times---that
612 is, the preceding regular expression must match exactly @var{n} times
613 in a row.  For example, @samp{x\@{4\@}} matches the string @samp{xxxx}
614 and nothing else.
616 @item @kbd{\@{@var{n},@var{m}\@}}
617 is a postfix operator that specifies repetition between @var{n} and
618 @var{m} times---that is, the preceding regular expression must match
619 at least @var{n} times, but no more than @var{m} times.  If @var{m} is
620 omitted, then there is no upper limit, but the preceding regular
621 expression must match at least @var{n} times.@* @samp{\@{0,1\@}} is
622 equivalent to @samp{?}. @* @samp{\@{0,\@}} is equivalent to
623 @samp{*}. @* @samp{\@{1,\@}} is equivalent to @samp{+}.
625 @item @kbd{[ @dots{} ]}
626 is a @dfn{character set}, which begins with @samp{[} and is terminated
627 by @samp{]}.  In the simplest case, the characters between the two
628 brackets are what this set can match.
630 Thus, @samp{[ad]} matches either one @samp{a} or one @samp{d}, and
631 @samp{[ad]*} matches any string composed of just @samp{a}s and @samp{d}s
632 (including the empty string), from which it follows that @samp{c[ad]*r}
633 matches @samp{cr}, @samp{car}, @samp{cdr}, @samp{caddaar}, etc.
635 You can also include character ranges in a character set, by writing the
636 starting and ending characters with a @samp{-} between them.  Thus,
637 @samp{[a-z]} matches any lower-case @acronym{ASCII} letter.  Ranges may be
638 intermixed freely with individual characters, as in @samp{[a-z$%.]},
639 which matches any lower-case @acronym{ASCII} letter or @samp{$}, @samp{%} or
640 period.
642 Note that the usual regexp special characters are not special inside a
643 character set.  A completely different set of special characters exists
644 inside character sets: @samp{]}, @samp{-} and @samp{^}.
646 To include a @samp{]} in a character set, you must make it the first
647 character.  For example, @samp{[]a]} matches @samp{]} or @samp{a}.  To
648 include a @samp{-}, write @samp{-} as the first or last character of the
649 set, or put it after a range.  Thus, @samp{[]-]} matches both @samp{]}
650 and @samp{-}.
652 To include @samp{^} in a set, put it anywhere but at the beginning of
653 the set.  (At the beginning, it complements the set---see below.)
655 When you use a range in case-insensitive search, you should write both
656 ends of the range in upper case, or both in lower case, or both should
657 be non-letters.  The behavior of a mixed-case range such as @samp{A-z}
658 is somewhat ill-defined, and it may change in future Emacs versions.
660 @item @kbd{[^ @dots{} ]}
661 @samp{[^} begins a @dfn{complemented character set}, which matches any
662 character except the ones specified.  Thus, @samp{[^a-z0-9A-Z]} matches
663 all characters @emph{except} @acronym{ASCII} letters and digits.
665 @samp{^} is not special in a character set unless it is the first
666 character.  The character following the @samp{^} is treated as if it
667 were first (in other words, @samp{-} and @samp{]} are not special there).
669 A complemented character set can match a newline, unless newline is
670 mentioned as one of the characters not to match.  This is in contrast to
671 the handling of regexps in programs such as @code{grep}.
673 @item @kbd{^}
674 is a special character that matches the empty string, but only at the
675 beginning of a line in the text being matched.  Otherwise it fails to
676 match anything.  Thus, @samp{^foo} matches a @samp{foo} that occurs at
677 the beginning of a line.
679 For historical compatibility reasons, @samp{^} can be used with this
680 meaning only at the beginning of the regular expression, or after
681 @samp{\(} or @samp{\|}.
683 @item @kbd{$}
684 is similar to @samp{^} but matches only at the end of a line.  Thus,
685 @samp{x+$} matches a string of one @samp{x} or more at the end of a line.
687 For historical compatibility reasons, @samp{$} can be used with this
688 meaning only at the end of the regular expression, or before @samp{\)}
689 or @samp{\|}.
691 @item @kbd{\}
692 has two functions: it quotes the special characters (including
693 @samp{\}), and it introduces additional special constructs.
695 Because @samp{\} quotes special characters, @samp{\$} is a regular
696 expression that matches only @samp{$}, and @samp{\[} is a regular
697 expression that matches only @samp{[}, and so on.
699 See the following section for the special constructs that begin
700 with @samp{\}.
701 @end table
703   Note: for historical compatibility, special characters are treated as
704 ordinary ones if they are in contexts where their special meanings make no
705 sense.  For example, @samp{*foo} treats @samp{*} as ordinary since there is
706 no preceding expression on which the @samp{*} can act.  It is poor practice
707 to depend on this behavior; it is better to quote the special character anyway,
708 regardless of where it appears.
710 As a @samp{\} is not special inside a character alternative, it can
711 never remove the special meaning of @samp{-} or @samp{]}.  So you
712 should not quote these characters when they have no special meaning
713 either.  This would not clarify anything, since backslashes can
714 legitimately precede these characters where they @emph{have} special
715 meaning, as in @samp{[^\]} (@code{"[^\\]"} for Lisp string syntax),
716 which matches any single character except a backslash.
718 @node Regexp Backslash
719 @section Backslash in Regular Expressions
721   For the most part, @samp{\} followed by any character matches only
722 that character.  However, there are several exceptions: two-character
723 sequences starting with @samp{\} that have special meanings.  The
724 second character in the sequence is always an ordinary character when
725 used on its own.  Here is a table of @samp{\} constructs.
727 @table @kbd
728 @item \|
729 specifies an alternative.  Two regular expressions @var{a} and @var{b}
730 with @samp{\|} in between form an expression that matches some text if
731 either @var{a} matches it or @var{b} matches it.  It works by trying to
732 match @var{a}, and if that fails, by trying to match @var{b}.
734 Thus, @samp{foo\|bar} matches either @samp{foo} or @samp{bar}
735 but no other string.@refill
737 @samp{\|} applies to the largest possible surrounding expressions.  Only a
738 surrounding @samp{\( @dots{} \)} grouping can limit the grouping power of
739 @samp{\|}.@refill
741 Full backtracking capability exists to handle multiple uses of @samp{\|}.
743 @item \( @dots{} \)
744 is a grouping construct that serves three purposes:
746 @enumerate
747 @item
748 To enclose a set of @samp{\|} alternatives for other operations.
749 Thus, @samp{\(foo\|bar\)x} matches either @samp{foox} or @samp{barx}.
751 @item
752 To enclose a complicated expression for the postfix operators @samp{*},
753 @samp{+} and @samp{?} to operate on.  Thus, @samp{ba\(na\)*} matches
754 @samp{bananana}, etc., with any (zero or more) number of @samp{na}
755 strings.@refill
757 @item
758 To record a matched substring for future reference.
759 @end enumerate
761 This last application is not a consequence of the idea of a
762 parenthetical grouping; it is a separate feature that is assigned as a
763 second meaning to the same @samp{\( @dots{} \)} construct.  In practice
764 there is usually no conflict between the two meanings; when there is
765 a conflict, you can use a ``shy'' group.
767 @item \(?: @dots{} \)
768 @cindex shy group, in regexp
769 specifies a ``shy'' group that does not record the matched substring;
770 you can't refer back to it with @samp{\@var{d}}.  This is useful
771 in mechanically combining regular expressions, so that you
772 can add groups for syntactic purposes without interfering with
773 the numbering of the groups that are meant to be referred to.
775 @item \@var{d}
776 @cindex back reference, in regexp
777 matches the same text that matched the @var{d}th occurrence of a
778 @samp{\( @dots{} \)} construct.  This is called a @dfn{back
779 reference}.
781 After the end of a @samp{\( @dots{} \)} construct, the matcher remembers
782 the beginning and end of the text matched by that construct.  Then,
783 later on in the regular expression, you can use @samp{\} followed by the
784 digit @var{d} to mean ``match the same text matched the @var{d}th time
785 by the @samp{\( @dots{} \)} construct.''
787 The strings matching the first nine @samp{\( @dots{} \)} constructs
788 appearing in a regular expression are assigned numbers 1 through 9 in
789 the order that the open-parentheses appear in the regular expression.
790 So you can use @samp{\1} through @samp{\9} to refer to the text matched
791 by the corresponding @samp{\( @dots{} \)} constructs.
793 For example, @samp{\(.*\)\1} matches any newline-free string that is
794 composed of two identical halves.  The @samp{\(.*\)} matches the first
795 half, which may be anything, but the @samp{\1} that follows must match
796 the same exact text.
798 If a particular @samp{\( @dots{} \)} construct matches more than once
799 (which can easily happen if it is followed by @samp{*}), only the last
800 match is recorded.
802 @item \`
803 matches the empty string, but only at the beginning of the string or
804 buffer (or its accessible portion) being matched against.
806 @item \'
807 matches the empty string, but only at the end of the string or buffer
808 (or its accessible portion) being matched against.
810 @item \=
811 matches the empty string, but only at point.
813 @item \b
814 matches the empty string, but only at the beginning or
815 end of a word.  Thus, @samp{\bfoo\b} matches any occurrence of
816 @samp{foo} as a separate word.  @samp{\bballs?\b} matches
817 @samp{ball} or @samp{balls} as a separate word.@refill
819 @samp{\b} matches at the beginning or end of the buffer
820 regardless of what text appears next to it.
822 @item \B
823 matches the empty string, but @emph{not} at the beginning or
824 end of a word.
826 @item \<
827 matches the empty string, but only at the beginning of a word.
828 @samp{\<} matches at the beginning of the buffer only if a
829 word-constituent character follows.
831 @item \>
832 matches the empty string, but only at the end of a word.  @samp{\>}
833 matches at the end of the buffer only if the contents end with a
834 word-constituent character.
836 @item \w
837 matches any word-constituent character.  The syntax table
838 determines which characters these are.  @xref{Syntax}.
840 @item \W
841 matches any character that is not a word-constituent.
843 @item \_<
844 matches the empty string, but only at the beginning of a symbol.
845 A symbol is a sequence of one or more symbol-constituent characters.
846 A symbol-constituent character is a character whose syntax is either
847 @samp{w} or @samp{_}.  @samp{\_<} matches at the beginning of the
848 buffer only if a symbol-constituent character follows.
850 @item \_>
851 matches the empty string, but only at the end of a symbol.  @samp{\_>}
852 matches at the end of the buffer only if the contents end with a
853 symbol-constituent character.
855 @item \s@var{c}
856 matches any character whose syntax is @var{c}.  Here @var{c} is a
857 character that designates a particular syntax class: thus, @samp{w}
858 for word constituent, @samp{-} or @samp{ } for whitespace, @samp{.}
859 for ordinary punctuation, etc.  @xref{Syntax}.
861 @item \S@var{c}
862 matches any character whose syntax is not @var{c}.
864 @cindex categories of characters
865 @cindex characters which belong to a specific language
866 @findex describe-categories
867 @item \c@var{c}
868 matches any character that belongs to the category @var{c}.  For
869 example, @samp{\cc} matches Chinese characters, @samp{\cg} matches
870 Greek characters, etc.  For the description of the known categories,
871 type @kbd{M-x describe-categories @key{RET}}.
873 @item \C@var{c}
874 matches any character that does @emph{not} belong to category
875 @var{c}.
876 @end table
878   The constructs that pertain to words and syntax are controlled by the
879 setting of the syntax table (@pxref{Syntax}).
881 @node Regexp Example
882 @section Regular Expression Example
884   Here is a complicated regexp---a simplified version of the regexp
885 that Emacs uses, by default, to recognize the end of a sentence
886 together with any whitespace that follows.  We show its Lisp syntax to
887 distinguish the spaces from the tab characters.  In Lisp syntax, the
888 string constant begins and ends with a double-quote.  @samp{\"} stands
889 for a double-quote as part of the regexp, @samp{\\} for a backslash as
890 part of the regexp, @samp{\t} for a tab, and @samp{\n} for a newline.
892 @example
893 "[.?!][]\"')]*\\($\\| $\\|\t\\|  \\)[ \t\n]*"
894 @end example
896 @noindent
897 This contains four parts in succession: a character set matching
898 period, @samp{?}, or @samp{!}; a character set matching
899 close-brackets, quotes, or parentheses, repeated zero or more times; a
900 set of alternatives within backslash-parentheses that matches either
901 end-of-line, a space at the end of a line, a tab, or two spaces; and a
902 character set matching whitespace characters, repeated any number of
903 times.
905   To enter the same regexp in incremental search, you would type
906 @key{TAB} to enter a tab, and @kbd{C-j} to enter a newline.  You would
907 also type single backslashes as themselves, instead of doubling them
908 for Lisp syntax.  In commands that use ordinary minibuffer input to
909 read a regexp, you would quote the @kbd{C-j} by preceding it with a
910 @kbd{C-q} to prevent @kbd{C-j} from exiting the minibuffer.
912 @node Search Case
913 @section Searching and Case
915   Incremental searches in Emacs normally ignore the case of the text
916 they are searching through, if you specify the text in lower case.
917 Thus, if you specify searching for @samp{foo}, then @samp{Foo} and
918 @samp{foo} are also considered a match.  Regexps, and in particular
919 character sets, are included: @samp{[ab]} would match @samp{a} or
920 @samp{A} or @samp{b} or @samp{B}.@refill
922   An upper-case letter anywhere in the incremental search string makes
923 the search case-sensitive.  Thus, searching for @samp{Foo} does not find
924 @samp{foo} or @samp{FOO}.  This applies to regular expression search as
925 well as to string search.  The effect ceases if you delete the
926 upper-case letter from the search string.
928   Typing @kbd{M-c} within an incremental search toggles the case
929 sensitivity of that search.  The effect does not extend beyond the
930 current incremental search to the next one, but it does override the
931 effect of including an upper-case letter in the current search.
933 @vindex case-fold-search
934 @vindex default-case-fold-search
935   If you set the variable @code{case-fold-search} to @code{nil}, then
936 all letters must match exactly, including case.  This is a per-buffer
937 variable; altering the variable affects only the current buffer, but
938 there is a default value in @code{default-case-fold-search} that you
939 can also set.  @xref{Locals}.  This variable applies to nonincremental
940 searches also, including those performed by the replace commands
941 (@pxref{Replace}) and the minibuffer history matching commands
942 (@pxref{Minibuffer History}).
944   Several related variables control case-sensitivity of searching and
945 matching for specific commands or activities.  For instance,
946 @code{tags-case-fold-search} controls case sensitivity for
947 @code{find-tag}.  To find these variables, do @kbd{M-x
948 apropos-variable @key{RET} case-fold-search @key{RET}}.
950 @node Replace
951 @section Replacement Commands
952 @cindex replacement
953 @cindex search-and-replace commands
954 @cindex string substitution
955 @cindex global substitution
957   Global search-and-replace operations are not needed often in Emacs,
958 but they are available.  In addition to the simple @kbd{M-x
959 replace-string} command which replaces all occurrences,
960 there is @kbd{M-%} (@code{query-replace}), which presents each occurrence
961 of the pattern and asks you whether to replace it.
963   The replace commands normally operate on the text from point to the
964 end of the buffer; however, in Transient Mark mode (@pxref{Transient
965 Mark}), when the mark is active, they operate on the region.  The
966 basic replace commands replace one string (or regexp) with one
967 replacement string.  It is possible to perform several replacements in
968 parallel using the command @code{expand-region-abbrevs}
969 (@pxref{Expanding Abbrevs}).
971 @menu
972 * Unconditional Replace::       Replacing all matches for a string.
973 * Regexp Replace::              Replacing all matches for a regexp.
974 * Replacement and Case::        How replacements preserve case of letters.
975 * Query Replace::               How to use querying.
976 @end menu
978 @node Unconditional Replace, Regexp Replace, Replace, Replace
979 @subsection Unconditional Replacement
980 @findex replace-string
982 @table @kbd
983 @item M-x replace-string @key{RET} @var{string} @key{RET} @var{newstring} @key{RET}
984 Replace every occurrence of @var{string} with @var{newstring}.
985 @end table
987   To replace every instance of @samp{foo} after point with @samp{bar},
988 use the command @kbd{M-x replace-string} with the two arguments
989 @samp{foo} and @samp{bar}.  Replacement happens only in the text after
990 point, so if you want to cover the whole buffer you must go to the
991 beginning first.  All occurrences up to the end of the buffer are
992 replaced; to limit replacement to part of the buffer, narrow to that
993 part of the buffer before doing the replacement (@pxref{Narrowing}).
994 In Transient Mark mode, when the region is active, replacement is
995 limited to the region (@pxref{Transient Mark}).
997   When @code{replace-string} exits, it leaves point at the last
998 occurrence replaced.  It sets the mark to the prior position of point
999 (where the @code{replace-string} command was issued); use @kbd{C-u
1000 C-@key{SPC}} to move back there.
1002   A numeric argument restricts replacement to matches that are surrounded
1003 by word boundaries.  The argument's value doesn't matter.
1005   @xref{Replacement and Case}, for details about case-sensitivity in
1006 replace commands.
1008   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:
1010 @example
1011 M-x replace-string @key{RET} x @key{RET} @@TEMP@@ @key{RET}
1012 M-< M-x replace-string @key{RET} y @key{RET} x @key{RET}
1013 M-< M-x replace-string @key{RET} @@TEMP@@ @key{RET} y @key{RET}
1014 @end example
1016 @noindent
1017 This works provided the string @samp{@@TEMP@@} does not appear
1018 in your text.
1020 @node Regexp Replace, Replacement and Case, Unconditional Replace, Replace
1021 @subsection Regexp Replacement
1022 @findex replace-regexp
1024   The @kbd{M-x replace-string} command replaces exact matches for a
1025 single string.  The similar command @kbd{M-x replace-regexp} replaces
1026 any match for a specified pattern.
1028 @table @kbd
1029 @item M-x replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET}
1030 Replace every match for @var{regexp} with @var{newstring}.
1031 @end table
1033 @cindex back reference, in regexp replacement
1034   In @code{replace-regexp}, the @var{newstring} need not be constant:
1035 it can refer to all or part of what is matched by the @var{regexp}.
1036 @samp{\&} in @var{newstring} stands for the entire match being
1037 replaced.  @samp{\@var{d}} in @var{newstring}, where @var{d} is a
1038 digit, stands for whatever matched the @var{d}th parenthesized
1039 grouping in @var{regexp}.  (This is called a ``back reference.'')
1040 @samp{\#} refers to the count of replacements already made in this
1041 command, as a decimal number.  In the first replacement, @samp{\#}
1042 stands for @samp{0}; in the second, for @samp{1}; and so on.  For
1043 example,
1045 @example
1046 M-x replace-regexp @key{RET} c[ad]+r @key{RET} \&-safe @key{RET}
1047 @end example
1049 @noindent
1050 replaces (for example) @samp{cadr} with @samp{cadr-safe} and @samp{cddr}
1051 with @samp{cddr-safe}.
1053 @example
1054 M-x replace-regexp @key{RET} \(c[ad]+r\)-safe @key{RET} \1 @key{RET}
1055 @end example
1057 @noindent
1058 performs the inverse transformation.  To include a @samp{\} in the
1059 text to replace with, you must enter @samp{\\}.
1061   If you want to enter part of the replacement string by hand each
1062 time, use @samp{\?} in the replacement string.  Each replacement will
1063 ask you to edit the replacement string in the minibuffer, putting
1064 point where the @samp{\?} was.
1066   The remainder of this subsection is intended for specialized tasks
1067 and requires knowledge of Lisp.  Most readers can skip it.
1069   You can use Lisp expressions to calculate parts of the
1070 replacement string.  To do this, write @samp{\,} followed by the
1071 expression in the replacement string.  Each replacement calculates the
1072 value of the expression and converts it to text without quoting (if
1073 it's a string, this means using the string's contents), and uses it in
1074 the replacement string in place of the expression itself.  If the
1075 expression is a symbol, one space in the replacement string after the
1076 symbol name goes with the symbol name, so the value replaces them
1077 both.
1079   Inside such an expression, you can use some special sequences.
1080 @samp{\&} and @samp{\@var{n}} refer here, as usual, to the entire
1081 match as a string, and to a submatch as a string.  @var{n} may be
1082 multiple digits, and the value of @samp{\@var{n}} is @code{nil} if
1083 subexpression @var{n} did not match.  You can also use @samp{\#&} and
1084 @samp{\#@var{n}} to refer to those matches as numbers (this is valid
1085 when the match or submatch has the form of a numeral).  @samp{\#} here
1086 too stands for the number of already-completed replacements.
1088   Repeating our example to exchange @samp{x} and @samp{y}, we can thus
1089 do it also this way:
1091 @example
1092 M-x replace-regexp @key{RET} \(x\)\|y @key{RET}
1093 \,(if \1 "y" "x") @key{RET}
1094 @end example
1096   For computing replacement strings for @samp{\,}, the @code{format}
1097 function is often useful (@pxref{Formatting Strings,,, elisp, The Emacs
1098 Lisp Reference Manual}).  For example, to add consecutively numbered
1099 strings like @samp{ABC00042} to columns 73 @w{to 80} (unless they are
1100 already occupied), you can use
1102 @example
1103 M-x replace-regexp @key{RET} ^.\@{0,72\@}$ @key{RET}
1104 \,(format "%-72sABC%05d" \& \#) @key{RET}
1105 @end example
1107 @node Replacement and Case, Query Replace, Regexp Replace, Replace
1108 @subsection Replace Commands and Case
1110   If the first argument of a replace command is all lower case, the
1111 command ignores case while searching for occurrences to
1112 replace---provided @code{case-fold-search} is non-@code{nil}.  If
1113 @code{case-fold-search} is set to @code{nil}, case is always significant
1114 in all searches.
1116 @vindex case-replace
1117   In addition, when the @var{newstring} argument is all or partly lower
1118 case, replacement commands try to preserve the case pattern of each
1119 occurrence.  Thus, the command
1121 @example
1122 M-x replace-string @key{RET} foo @key{RET} bar @key{RET}
1123 @end example
1125 @noindent
1126 replaces a lower case @samp{foo} with a lower case @samp{bar}, an
1127 all-caps @samp{FOO} with @samp{BAR}, and a capitalized @samp{Foo} with
1128 @samp{Bar}.  (These three alternatives---lower case, all caps, and
1129 capitalized, are the only ones that @code{replace-string} can
1130 distinguish.)
1132   If upper-case letters are used in the replacement string, they remain
1133 upper case every time that text is inserted.  If upper-case letters are
1134 used in the first argument, the second argument is always substituted
1135 exactly as given, with no case conversion.  Likewise, if either
1136 @code{case-replace} or @code{case-fold-search} is set to @code{nil},
1137 replacement is done without case conversion.
1139 @node Query Replace,, Replacement and Case, Replace
1140 @subsection Query Replace
1141 @cindex query replace
1143 @table @kbd
1144 @item M-% @var{string} @key{RET} @var{newstring} @key{RET}
1145 @itemx M-x query-replace @key{RET} @var{string} @key{RET} @var{newstring} @key{RET}
1146 Replace some occurrences of @var{string} with @var{newstring}.
1147 @item C-M-% @var{regexp} @key{RET} @var{newstring} @key{RET}
1148 @itemx M-x query-replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET}
1149 Replace some matches for @var{regexp} with @var{newstring}.
1150 @end table
1152 @kindex M-%
1153 @findex query-replace
1154   If you want to change only some of the occurrences of @samp{foo} to
1155 @samp{bar}, not all of them, use @kbd{M-%} (@code{query-replace}).
1156 This command finds occurrences of @samp{foo} one by one, displays each
1157 occurrence and asks you whether to replace it.  Aside from querying,
1158 @code{query-replace} works just like @code{replace-string}
1159 (@pxref{Unconditional Replace}).  In particular, it preserves case
1160 provided @code{case-replace} is non-@code{nil}, as it normally is
1161 (@pxref{Replacement and Case}).  A numeric argument means consider
1162 only occurrences that are bounded by word-delimiter characters.
1164 @kindex C-M-%
1165 @findex query-replace-regexp
1166   @kbd{C-M-%} performs regexp search and replace (@code{query-replace-regexp}).
1167 It works like @code{replace-regexp} except that it queries
1168 like @code{query-replace}.
1170 @cindex faces for highlighting query replace
1171   These commands highlight the current match using the face
1172 @code{query-replace}.  They highlight other matches using
1173 @code{lazy-highlight} just like incremental search (@pxref{Incremental
1174 Search}).
1176   The characters you can type when you are shown a match for the string
1177 or regexp are:
1179 @ignore @c Not worth it.
1180 @kindex SPC @r{(query-replace)}
1181 @kindex DEL @r{(query-replace)}
1182 @kindex , @r{(query-replace)}
1183 @kindex RET @r{(query-replace)}
1184 @kindex . @r{(query-replace)}
1185 @kindex ! @r{(query-replace)}
1186 @kindex ^ @r{(query-replace)}
1187 @kindex C-r @r{(query-replace)}
1188 @kindex C-w @r{(query-replace)}
1189 @kindex C-l @r{(query-replace)}
1190 @end ignore
1192 @c WideCommands
1193 @table @kbd
1194 @item @key{SPC}
1195 to replace the occurrence with @var{newstring}.
1197 @item @key{DEL}
1198 to skip to the next occurrence without replacing this one.
1200 @item , @r{(Comma)}
1201 to replace this occurrence and display the result.  You are then asked
1202 for another input character to say what to do next.  Since the
1203 replacement has already been made, @key{DEL} and @key{SPC} are
1204 equivalent in this situation; both move to the next occurrence.
1206 You can type @kbd{C-r} at this point (see below) to alter the replaced
1207 text.  You can also type @kbd{C-x u} to undo the replacement; this exits
1208 the @code{query-replace}, so if you want to do further replacement you
1209 must use @kbd{C-x @key{ESC} @key{ESC} @key{RET}} to restart
1210 (@pxref{Repetition}).
1212 @item @key{RET}
1213 to exit without doing any more replacements.
1215 @item .@: @r{(Period)}
1216 to replace this occurrence and then exit without searching for more
1217 occurrences.
1219 @item !
1220 to replace all remaining occurrences without asking again.
1222 @item ^
1223 to go back to the position of the previous occurrence (or what used to
1224 be an occurrence), in case you changed it by mistake or want to
1225 reexamine it.
1227 @item C-r
1228 to enter a recursive editing level, in case the occurrence needs to be
1229 edited rather than just replaced with @var{newstring}.  When you are
1230 done, exit the recursive editing level with @kbd{C-M-c} to proceed to
1231 the next occurrence.  @xref{Recursive Edit}.
1233 @item C-w
1234 to delete the occurrence, and then enter a recursive editing level as in
1235 @kbd{C-r}.  Use the recursive edit to insert text to replace the deleted
1236 occurrence of @var{string}.  When done, exit the recursive editing level
1237 with @kbd{C-M-c} to proceed to the next occurrence.
1239 @item e
1240 to edit the replacement string in the minibuffer.  When you exit the
1241 minibuffer by typing @key{RET}, the minibuffer contents replace the
1242 current occurrence of the pattern.  They also become the new
1243 replacement string for any further occurrences.
1245 @item C-l
1246 to redisplay the screen.  Then you must type another character to
1247 specify what to do with this occurrence.
1249 @item C-h
1250 to display a message summarizing these options.  Then you must type
1251 another character to specify what to do with this occurrence.
1252 @end table
1254   Some other characters are aliases for the ones listed above: @kbd{y},
1255 @kbd{n} and @kbd{q} are equivalent to @key{SPC}, @key{DEL} and
1256 @key{RET}.
1258   Aside from this, any other character exits the @code{query-replace},
1259 and is then reread as part of a key sequence.  Thus, if you type
1260 @kbd{C-k}, it exits the @code{query-replace} and then kills to end of
1261 line.
1263   To restart a @code{query-replace} once it is exited, use @kbd{C-x
1264 @key{ESC} @key{ESC}}, which repeats the @code{query-replace} because it
1265 used the minibuffer to read its arguments.  @xref{Repetition, C-x ESC
1266 ESC}.
1268   @xref{Operating on Files}, for the Dired @kbd{Q} command which
1269 performs query replace on selected files.  See also @ref{Transforming
1270 File Names}, for Dired commands to rename, copy, or link files by
1271 replacing regexp matches in file names.
1273 @node Other Repeating Search
1274 @section Other Search-and-Loop Commands
1276   Here are some other commands that find matches for a regular
1277 expression.  They all ignore case in matching, if the pattern contains
1278 no upper-case letters and @code{case-fold-search} is non-@code{nil}.
1279 Aside from @code{occur} and its variants, all operate on the text from
1280 point to the end of the buffer, or on the active region in Transient
1281 Mark mode.
1283 @findex list-matching-lines
1284 @findex occur
1285 @findex multi-occur
1286 @findex multi-occur-in-matching-buffers
1287 @findex how-many
1288 @findex delete-non-matching-lines
1289 @findex delete-matching-lines
1290 @findex flush-lines
1291 @findex keep-lines
1293 @table @kbd
1294 @item M-x occur @key{RET} @var{regexp} @key{RET}
1295 Display a list showing each line in the buffer that contains a match
1296 for @var{regexp}.  To limit the search to part of the buffer, narrow
1297 to that part (@pxref{Narrowing}).  A numeric argument @var{n}
1298 specifies that @var{n} lines of context are to be displayed before and
1299 after each matching line.  Currently, @code{occur} can not correctly
1300 handle multiline matches.
1302 @kindex RET @r{(Occur mode)}
1303 @kindex o @r{(Occur mode)}
1304 @kindex C-o @r{(Occur mode)}
1305 The buffer @samp{*Occur*} containing the output serves as a menu for
1306 finding the occurrences in their original context.  Click
1307 @kbd{Mouse-2} on an occurrence listed in @samp{*Occur*}, or position
1308 point there and type @key{RET}; this switches to the buffer that was
1309 searched and moves point to the original of the chosen occurrence.
1310 @kbd{o} and @kbd{C-o} display the match in another window; @kbd{C-o}
1311 does not select it.
1313 After using @kbd{M-x occur}, you can use @code{next-error} to visit
1314 the occurrences found, one by one.  @ref{Compilation Mode}.
1316 @item M-x list-matching-lines
1317 Synonym for @kbd{M-x occur}.
1319 @item M-x multi-occur @key{RET} @var{buffers} @key{RET} @var{regexp} @key{RET}
1320 This function is just like @code{occur}, except it is able to search
1321 through multiple buffers.  It asks you to specify the buffer names one by one.
1323 @item M-x multi-occur-in-matching-buffers @key{RET} @var{bufregexp} @key{RET} @var{regexp} @key{RET}
1324 This function is similar to @code{multi-occur}, except the buffers to
1325 search are specified by a regular expression that matches visited
1326 file names.  With a prefix argument, it uses the regular expression to match
1327 buffer names instead.
1329 @item M-x how-many @key{RET} @var{regexp} @key{RET}
1330 Print the number of matches for @var{regexp} that exist in the buffer
1331 after point.  In Transient Mark mode, if the region is active, the
1332 command operates on the region instead.
1334 @item M-x flush-lines @key{RET} @var{regexp} @key{RET}
1335 This command deletes each line that contains a match for @var{regexp},
1336 operating on the text after point; it deletes the current line
1337 if it contains a match starting after point.  In Transient Mark mode,
1338 if the region is active, the command operates on the region instead;
1339 it deletes a line partially contained in the region if it contains a
1340 match entirely contained in the region.
1342 If a match is split across lines, @code{flush-lines} deletes all those
1343 lines.  It deletes the lines before starting to look for the next
1344 match; hence, it ignores a match starting on the same line at which
1345 another match ended.
1347 @item M-x keep-lines @key{RET} @var{regexp} @key{RET}
1348 This command deletes each line that @emph{does not} contain a match for
1349 @var{regexp}, operating on the text after point; if point is not at the
1350 beginning of a line, it always keeps the current line.  In Transient
1351 Mark mode, if the region is active, the command operates on the region
1352 instead; it never deletes lines that are only partially contained in
1353 the region (a newline that ends a line counts as part of that line).
1355 If a match is split across lines, this command keeps all those lines.
1356 @end table
1358 @ignore
1359    arch-tag: fd9d8e77-66af-491c-b212-d80999613e3e
1360 @end ignore