|
25829
|
1 @c This is part of the Emacs manual.
|
|
64890
|
2 @c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001, 2002,
|
|
79791
|
3 @c 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
|
|
25829
|
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
|
|
38127
|
17 occurrences of one string and replaces them with another, Emacs has a
|
|
|
18 more flexible replacement command called @code{query-replace}, which
|
|
72724
|
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
|
|
25829
|
27
|
|
|
28 @menu
|
|
52968
|
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.
|
64918
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
34 * Regexp Backslash:: Regular expression constructs starting with `\'.
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
35 * Regexp Example:: A complex regular expression explained.
|
|
52968
|
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.
|
|
25829
|
39 @end menu
|
|
|
40
|
|
60860
|
41 @node Incremental Search
|
|
25829
|
42 @section Incremental Search
|
|
72519
|
43 @cindex incremental search
|
|
|
44 @cindex isearch
|
|
25829
|
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
|
|
60860
|
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
|
|
25829
|
76 @kindex C-s
|
|
|
77 @findex isearch-forward
|
|
38127
|
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
|
|
38880
|
81 cursor after the first @samp{F} (the first following the starting point, since
|
|
38127
|
82 this is a forward search). Then if you type an @kbd{O}, you will see
|
|
68515
|
83 the cursor move to just after the first @samp{FO} (the @samp{F} in that
|
|
38127
|
84 @samp{FO} may or may not be the first @samp{F}). After another
|
|
68515
|
85 @kbd{O}, the cursor moves to just after the first @samp{FOO} after the place
|
|
38127
|
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.
|
|
25829
|
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
|
|
37235
|
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
|
|
25829
|
104 special within searches (@kbd{C-q}, @kbd{C-w}, @kbd{C-r}, @kbd{C-s},
|
|
56306
|
105 @kbd{C-y}, @kbd{M-y}, @kbd{M-r}, @kbd{M-c}, @kbd{M-e}, and some other
|
|
37235
|
106 meta-characters).
|
|
25829
|
107
|
|
60860
|
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
|
|
38127
|
117 Sometimes you search for @samp{FOO} and find one, but not the one you
|
|
36177
|
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}.
|
|
25829
|
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
|
|
60860
|
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
|
|
25829
|
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
|
|
56306
|
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}
|
|
25829
|
143 to terminate editing the string and search for it.
|
|
|
144
|
|
68515
|
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
|
|
60860
|
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
|
|
68515
|
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.
|
|
60860
|
159
|
|
|
160 @node Error in Isearch
|
|
|
161 @subsection Errors in Incremental Search
|
|
|
162
|
|
25829
|
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
|
|
38127
|
170 remain there. Or you can type @kbd{C-g}, which
|
|
25829
|
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
|
|
60860
|
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
|
|
25829
|
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
|
|
36177
|
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
|
|
60860
|
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
|
|
60864
|
217 @node Non-ASCII Isearch
|
|
60860
|
218 @subsection Isearch for Non-@acronym{ASCII} Characters
|
|
52979
|
219 @cindex searching for non-@acronym{ASCII} characters
|
|
35904
|
220 @cindex input method, during incremental search
|
|
60860
|
221
|
|
64939
|
222 To enter non-@acronym{ASCII} characters in an incremental search,
|
|
72153
|
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:
|
|
35904
|
228
|
|
|
229 @example
|
|
36177
|
230 I-search [@var{im}]:
|
|
35904
|
231 @end example
|
|
|
232
|
|
|
233 @noindent
|
|
|
234 @findex isearch-toggle-input-method
|
|
|
235 @findex isearch-toggle-specified-input-method
|
|
72153
|
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-^}
|
|
35904
|
241 (@code{isearch-toggle-specified-input-method}), which prompts for the
|
|
38880
|
242 name of the input method. The input method you enable during
|
|
|
243 incremental search remains enabled in the current buffer afterwards.
|
|
35904
|
244
|
|
60860
|
245 @node Isearch Yank
|
|
|
246 @subsection Isearch Yanking
|
|
25829
|
247
|
|
56306
|
248 The characters @kbd{C-w} and @kbd{C-y} can be used in incremental
|
|
46242
|
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
|
57382
2ad6f5610930
Update the documentation of C-y in the case that point is already at the
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
258 current line into the search string. If point is already at the end
|
2ad6f5610930
Update the documentation of C-y in the case that point is already at the
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
259 of a line, it grabs the entire next line. Both @kbd{C-y} and
|
2ad6f5610930
Update the documentation of C-y in the case that point is already at the
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
260 @kbd{C-w} convert the text they copy to lower case if the search is
|
2ad6f5610930
Update the documentation of C-y in the case that point is already at the
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
261 currently not case-sensitive; this is so the search remains
|
2ad6f5610930
Update the documentation of C-y in the case that point is already at the
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
262 case-insensitive.
|
|
25829
|
263
|
|
56306
|
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
|
|
25829
|
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.
|
|
36177
|
274 @kbd{Mouse-2} in the echo area does the same.
|
|
25829
|
275 @xref{Yanking}.
|
|
|
276
|
|
60860
|
277 @node Highlight Isearch
|
|
|
278 @subsection Lazy Search Highlighting
|
|
27217
|
279 @cindex lazy search highlighting
|
|
|
280 @vindex isearch-lazy-highlight
|
|
60860
|
281
|
|
36177
|
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}.
|
|
27217
|
289
|
|
31062
|
290 @cindex faces for highlighting search matches
|
|
38049
|
291 You can control how this highlighting looks by customizing the faces
|
59428
856e8ee31fcb
(Query Replace): Mention faces query-replace and lazy-highlight.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
292 @code{isearch} (used for the current match) and @code{lazy-highlight}
|
|
68515
|
293 (for all the other matches).
|
|
31062
|
294
|
|
60860
|
295 @node Isearch Scroll
|
|
52968
|
296 @subsection Scrolling During Incremental Search
|
|
|
297
|
|
68515
|
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
|
|
52968
|
302 commands such as @kbd{@key{PRIOR}} (@code{scroll-down}),
|
|
68515
|
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.
|
|
52968
|
310
|
|
68515
|
311 The feature also affects some other commands, such as @kbd{C-x 2}
|
|
52968
|
312 (@code{split-window-vertically}) and @kbd{C-x ^}
|
|
68515
|
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.
|
|
52968
|
317
|
|
68515
|
318 For example, to make @kbd{C-h l} usable within an incremental search
|
64148
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
319 in all future Emacs sessions, use @kbd{C-h c} to find what command it
|
|
68515
|
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}):
|
64148
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
323
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
324 @example
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
325 (put 'view-lossage 'isearch-scroll t)
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
326 @end example
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
327
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
328 @noindent
|
|
68515
|
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.
|
|
52968
|
333
|
|
60860
|
334 @node Slow Isearch
|
|
25829
|
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
|
|
38049
|
341 comes into play as soon as point moves outside of the text that is already
|
|
25829
|
342 on the screen.
|
|
|
343
|
|
|
344 When you terminate the search, the single-line window is removed.
|
|
38049
|
345 Emacs then redisplays the window in which the search was done, to show
|
|
25829
|
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},
|
64148
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
351 initially 1200. See also the discussion of the variable @code{baud-rate}
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
352 (@pxref{baud-rate,, Customization of Display}).
|
|
25829
|
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
|
|
60860
|
358 @node Nonincremental Search
|
|
25829
|
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
|
|
38127
|
375 found, the search command signals an error.
|
|
25829
|
376
|
|
38127
|
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.
|
|
70755
|
384 @ifnottex
|
|
25829
|
385 @xref{Word Search}.
|
|
70755
|
386 @end ifnottex
|
|
38127
|
387 @kbd{C-r @key{RET}} does likewise, for a reverse incremental search.
|
|
25829
|
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
|
|
68515
|
395 historical reasons, and to avoid the need to find separate key sequences
|
|
25829
|
396 for them.
|
|
|
397
|
|
60860
|
398 @node Word Search
|
|
25829
|
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,
|
|
38049
|
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.
|
|
25829
|
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
|
|
73606
|
420 Word search as a special case of nonincremental search is invoked
|
|
25829
|
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
|
|
73606
|
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.
|
|
|
435
|
|
25829
|
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
|
|
38127
|
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
|
|
68515
|
442 to avoid the need to find separate key sequences for them.
|
|
25829
|
443
|
|
60860
|
444 @node Regexp Search
|
|
25829
|
445 @section Regular Expression Search
|
|
|
446 @cindex regular expression
|
|
|
447 @cindex regexp
|
|
|
448
|
|
38127
|
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
|
|
60860
|
452 nonincremental ways to search for a match for a regexp. The syntax of
|
|
|
453 regular expressions is explained in the following section.
|
|
25829
|
454
|
|
|
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}
|
|
56306
|
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
|
|
38127
|
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}
|
|
56306
|
468 (@code{isearch-backward-regexp}), @kbd{C-r} with a prefix argument,
|
|
|
469 or @kbd{M-r} within a backward incremental search.
|
|
25829
|
470
|
|
|
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}.
|
|
|
478
|
|
65693
|
479 @vindex search-whitespace-regexp
|
|
25829
|
480 If you type @key{SPC} in incremental regexp search, it matches any
|
|
65693
|
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
|
|
68515
|
483 bare space matches by setting the variable
|
|
65693
|
484 @code{search-whitespace-regexp} to the desired regexp.
|
|
25829
|
485
|
|
68515
|
486 In some cases, adding characters to the regexp in an incremental regexp
|
|
25829
|
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}.
|
|
|
490
|
|
74845
|
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.
|
|
|
497
|
|
25829
|
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}}.
|
|
|
505
|
|
|
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}.
|
|
|
510
|
|
60860
|
511 @node Regexps
|
|
25829
|
512 @section Syntax of Regular Expressions
|
|
36263
|
513 @cindex syntax of regexps
|
|
25829
|
514
|
|
50604
|
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,,,
|
|
56778
|
518 elisp, The Emacs Lisp Reference Manual}.
|
|
50604
|
519
|
|
25829
|
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{$},
|
69340
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
524 @samp{^}, @samp{.}, @samp{*}, @samp{+}, @samp{?}, @samp{[}, and
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
525 @samp{\}. The character @samp{]} is special if it ends a character
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
526 alternative (see later). The character @samp{-} is special inside a
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
527 character alternative. Any other character appearing in a regular
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
528 expression is ordinary, unless a @samp{\} precedes it. (When you use
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
529 regular expressions in a Lisp program, each @samp{\} must be doubled,
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
530 see the example near the end of this section.)
|
|
25829
|
531
|
|
|
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.)
|
|
|
539
|
|
|
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
|
|
|
544
|
|
|
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.
|
|
|
549
|
|
49984
|
550 @table @asis
|
|
|
551 @item @kbd{.}@: @r{(Period)}
|
|
25829
|
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
|
|
|
556
|
|
49984
|
557 @item @kbd{*}
|
|
25829
|
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).
|
|
|
562
|
|
|
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.
|
|
|
566
|
|
|
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
|
|
|
577
|
|
49984
|
578 @item @kbd{+}
|
|
25829
|
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.
|
|
|
583
|
|
49984
|
584 @item @kbd{?}
|
|
25829
|
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.
|
|
|
588
|
|
49984
|
589 @item @kbd{*?}, @kbd{+?}, @kbd{??}
|
|
27139
|
590 @cindex non-greedy regexp matching
|
|
27094
|
591 are non-greedy variants of the operators above. The normal operators
|
|
36177
|
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.
|
|
|
596
|
|
|
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).
|
|
|
602
|
|
44062
|
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.
|
|
|
609
|
|
49984
|
610 @item @kbd{\@{@var{n}\@}}
|
|
36177
|
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.
|
|
27094
|
615
|
|
49984
|
616 @item @kbd{\@{@var{n},@var{m}\@}}
|
|
36177
|
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{+}.
|
|
27694
|
624
|
|
49984
|
625 @item @kbd{[ @dots{} ]}
|
|
25829
|
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.
|
|
|
629
|
|
|
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.
|
|
|
634
|
|
|
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,
|
|
52979
|
637 @samp{[a-z]} matches any lower-case @acronym{ASCII} letter. Ranges may be
|
|
25829
|
638 intermixed freely with individual characters, as in @samp{[a-z$%.]},
|
|
52979
|
639 which matches any lower-case @acronym{ASCII} letter or @samp{$}, @samp{%} or
|
|
25829
|
640 period.
|
|
|
641
|
|
|
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{^}.
|
|
|
645
|
|
|
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{-}.
|
|
|
651
|
|
|
652 To include @samp{^} in a set, put it anywhere but at the beginning of
|
|
37235
|
653 the set. (At the beginning, it complements the set---see below.)
|
|
25829
|
654
|
|
|
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.
|
|
|
659
|
|
49984
|
660 @item @kbd{[^ @dots{} ]}
|
|
25829
|
661 @samp{[^} begins a @dfn{complemented character set}, which matches any
|
|
|
662 character except the ones specified. Thus, @samp{[^a-z0-9A-Z]} matches
|
|
52979
|
663 all characters @emph{except} @acronym{ASCII} letters and digits.
|
|
25829
|
664
|
|
|
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).
|
|
|
668
|
|
|
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}.
|
|
|
672
|
|
49984
|
673 @item @kbd{^}
|
|
25829
|
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.
|
|
|
678
|
|
54273
|
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{\|}.
|
|
|
682
|
|
49984
|
683 @item @kbd{$}
|
|
25829
|
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.
|
|
|
686
|
|
54273
|
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{\|}.
|
|
|
690
|
|
49984
|
691 @item @kbd{\}
|
|
25829
|
692 has two functions: it quotes the special characters (including
|
|
|
693 @samp{\}), and it introduces additional special constructs.
|
|
|
694
|
|
|
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.
|
64918
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
698
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
699 See the following section for the special constructs that begin
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
700 with @samp{\}.
|
|
25829
|
701 @end table
|
|
|
702
|
64918
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
703 Note: for historical compatibility, special characters are treated as
|
|
25829
|
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,
|
64918
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
708 regardless of where it appears.
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
709
|
69340
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
710 As a @samp{\} is not special inside a character alternative, it can
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
711 never remove the special meaning of @samp{-} or @samp{]}. So you
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
712 should not quote these characters when they have no special meaning
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
713 either. This would not clarify anything, since backslashes can
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
714 legitimately precede these characters where they @emph{have} special
|
|
69411
|
715 meaning, as in @samp{[^\]} (@code{"[^\\]"} for Lisp string syntax),
|
69340
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
716 which matches any single character except a backslash.
|
704ddb133dad
(Regexps): More accurately describe which characters are special in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
717
|
64918
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
718 @node Regexp Backslash
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
719 @section Backslash in Regular Expressions
|
|
25829
|
720
|
64918
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
721 For the most part, @samp{\} followed by any character matches only
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
722 that character. However, there are several exceptions: two-character
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
723 sequences starting with @samp{\} that have special meanings. The
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
724 second character in the sequence is always an ordinary character when
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
725 used on its own. Here is a table of @samp{\} constructs.
|
|
25829
|
726
|
|
|
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}.
|
|
|
733
|
|
|
734 Thus, @samp{foo\|bar} matches either @samp{foo} or @samp{bar}
|
|
|
735 but no other string.@refill
|
|
|
736
|
|
|
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
|
|
|
740
|
|
|
741 Full backtracking capability exists to handle multiple uses of @samp{\|}.
|
|
|
742
|
|
|
743 @item \( @dots{} \)
|
|
|
744 is a grouping construct that serves three purposes:
|
|
|
745
|
|
|
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}.
|
|
|
750
|
|
|
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
|
|
|
756
|
|
|
757 @item
|
|
|
758 To record a matched substring for future reference.
|
|
|
759 @end enumerate
|
|
|
760
|
|
|
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
|
|
36177
|
764 there is usually no conflict between the two meanings; when there is
|
|
|
765 a conflict, you can use a ``shy'' group.
|
|
28063
|
766
|
|
|
767 @item \(?: @dots{} \)
|
|
36177
|
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
|
|
68699
|
773 the numbering of the groups that are meant to be referred to.
|
|
25829
|
774
|
|
|
775 @item \@var{d}
|
69971
fbf2a5887b37
(Regexp Backslash, Regexp Replace): Add index entries for ``back reference''
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
776 @cindex back reference, in regexp
|
|
25829
|
777 matches the same text that matched the @var{d}th occurrence of a
|
|
69976
|
778 @samp{\( @dots{} \)} construct. This is called a @dfn{back
|
|
|
779 reference}.
|
|
25829
|
780
|
|
|
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.''
|
|
|
786
|
|
|
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.
|
|
|
792
|
|
|
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.
|
|
|
797
|
|
|
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.
|
|
|
801
|
|
|
802 @item \`
|
|
40929
|
803 matches the empty string, but only at the beginning of the string or
|
|
|
804 buffer (or its accessible portion) being matched against.
|
|
25829
|
805
|
|
|
806 @item \'
|
|
40929
|
807 matches the empty string, but only at the end of the string or buffer
|
|
|
808 (or its accessible portion) being matched against.
|
|
25829
|
809
|
|
|
810 @item \=
|
|
|
811 matches the empty string, but only at point.
|
|
|
812
|
|
|
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
|
|
|
818
|
|
|
819 @samp{\b} matches at the beginning or end of the buffer
|
|
|
820 regardless of what text appears next to it.
|
|
|
821
|
|
|
822 @item \B
|
|
|
823 matches the empty string, but @emph{not} at the beginning or
|
|
|
824 end of a word.
|
|
|
825
|
|
|
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.
|
|
|
830
|
|
|
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.
|
|
|
835
|
|
|
836 @item \w
|
|
|
837 matches any word-constituent character. The syntax table
|
|
|
838 determines which characters these are. @xref{Syntax}.
|
|
|
839
|
|
|
840 @item \W
|
|
|
841 matches any character that is not a word-constituent.
|
|
|
842
|
|
55693
|
843 @item \_<
|
|
58434
|
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
|
|
58436
|
847 @samp{w} or @samp{_}. @samp{\_<} matches at the beginning of the
|
|
58434
|
848 buffer only if a symbol-constituent character follows.
|
|
55693
|
849
|
|
|
850 @item \_>
|
56467
e2448fa3dca4
(Regexps): Delete redundant definition of `symbol' in description of
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
851 matches the empty string, but only at the end of a symbol. @samp{\_>}
|
e2448fa3dca4
(Regexps): Delete redundant definition of `symbol' in description of
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
852 matches at the end of the buffer only if the contents end with a
|
e2448fa3dca4
(Regexps): Delete redundant definition of `symbol' in description of
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
853 symbol-constituent character.
|
|
55693
|
854
|
|
25829
|
855 @item \s@var{c}
|
|
|
856 matches any character whose syntax is @var{c}. Here @var{c} is a
|
|
37235
|
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}.
|
|
25829
|
860
|
|
|
861 @item \S@var{c}
|
|
|
862 matches any character whose syntax is not @var{c}.
|
|
35904
|
863
|
|
|
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}}.
|
|
|
872
|
|
|
873 @item \C@var{c}
|
|
|
874 matches any character that does @emph{not} belong to category
|
|
|
875 @var{c}.
|
|
25829
|
876 @end table
|
|
|
877
|
|
|
878 The constructs that pertain to words and syntax are controlled by the
|
|
|
879 setting of the syntax table (@pxref{Syntax}).
|
|
|
880
|
64918
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
881 @node Regexp Example
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
882 @section Regular Expression Example
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
883
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
884 Here is a complicated regexp---a simplified version of the regexp
|
80b859b476aa
(Regexp Backslash, Regexp Example): New nodes split out of Regexps.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
885 that Emacs uses, by default, to recognize the end of a sentence
|
57374
384212f1e3a5
(Regexps): The regexp described in the example is no longer stored in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
886 together with any whitespace that follows. We show its Lisp syntax to
|
384212f1e3a5
(Regexps): The regexp described in the example is no longer stored in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
887 distinguish the spaces from the tab characters. In Lisp syntax, the
|
384212f1e3a5
(Regexps): The regexp described in the example is no longer stored in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
888 string constant begins and ends with a double-quote. @samp{\"} stands
|
384212f1e3a5
(Regexps): The regexp described in the example is no longer stored in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
889 for a double-quote as part of the regexp, @samp{\\} for a backslash as
|
384212f1e3a5
(Regexps): The regexp described in the example is no longer stored in
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
890 part of the regexp, @samp{\t} for a tab, and @samp{\n} for a newline.
|
|
25829
|
891
|
|
|
892 @example
|
|
37235
|
893 "[.?!][]\"')]*\\($\\| $\\|\t\\| \\)[ \t\n]*"
|
|
25829
|
894 @end example
|
|
|
895
|
|
|
896 @noindent
|
|
37235
|
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.
|
|
25829
|
904
|
40521
549e09fb7907
Clarify how to enter regexps in isearch and in the miniubuffer.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
905 To enter the same regexp in incremental search, you would type
|
549e09fb7907
Clarify how to enter regexps in isearch and in the miniubuffer.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
906 @key{TAB} to enter a tab, and @kbd{C-j} to enter a newline. You would
|
549e09fb7907
Clarify how to enter regexps in isearch and in the miniubuffer.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
907 also type single backslashes as themselves, instead of doubling them
|
549e09fb7907
Clarify how to enter regexps in isearch and in the miniubuffer.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
908 for Lisp syntax. In commands that use ordinary minibuffer input to
|
549e09fb7907
Clarify how to enter regexps in isearch and in the miniubuffer.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
909 read a regexp, you would quote the @kbd{C-j} by preceding it with a
|
549e09fb7907
Clarify how to enter regexps in isearch and in the miniubuffer.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
910 @kbd{C-q} to prevent @kbd{C-j} from exiting the minibuffer.
|
|
25829
|
911
|
|
60860
|
912 @node Search Case
|
|
25829
|
913 @section Searching and Case
|
|
|
914
|
|
|
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
|
|
|
921
|
|
|
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.
|
|
|
927
|
|
37235
|
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.
|
|
|
932
|
|
|
933 @vindex case-fold-search
|
|
60860
|
934 @vindex default-case-fold-search
|
|
25829
|
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
|
|
60860
|
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}).
|
|
52968
|
943
|
|
65327
|
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}}.
|
|
|
949
|
|
60860
|
950 @node Replace
|
|
25829
|
951 @section Replacement Commands
|
|
|
952 @cindex replacement
|
|
|
953 @cindex search-and-replace commands
|
|
|
954 @cindex string substitution
|
|
|
955 @cindex global substitution
|
|
|
956
|
|
38127
|
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
|
|
56306
|
959 replace-string} command which replaces all occurrences,
|
|
64941
|
960 there is @kbd{M-%} (@code{query-replace}), which presents each occurrence
|
|
38127
|
961 of the pattern and asks you whether to replace it.
|
|
25829
|
962
|
|
|
963 The replace commands normally operate on the text from point to the
|
|
46193
|
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
|
|
68515
|
966 basic replace commands replace one string (or regexp) with one
|
|
46193
|
967 replacement string. It is possible to perform several replacements in
|
|
|
968 parallel using the command @code{expand-region-abbrevs}
|
|
|
969 (@pxref{Expanding Abbrevs}).
|
|
25829
|
970
|
|
|
971 @menu
|
|
52968
|
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.
|
|
25829
|
976 @end menu
|
|
|
977
|
|
|
978 @node Unconditional Replace, Regexp Replace, Replace, Replace
|
|
|
979 @subsection Unconditional Replacement
|
|
|
980 @findex replace-string
|
|
|
981
|
|
|
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
|
|
|
986
|
|
|
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}).
|
|
|
996
|
|
|
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.
|
|
|
1001
|
|
|
1002 A numeric argument restricts replacement to matches that are surrounded
|
|
|
1003 by word boundaries. The argument's value doesn't matter.
|
|
|
1004
|
77441
1e02a80ad090
(Unconditional Replace, Query Replace): Add xref to "Replacement and Case".
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
1005 @xref{Replacement and Case}, for details about case-sensitivity in
|
1e02a80ad090
(Unconditional Replace, Query Replace): Add xref to "Replacement and Case".
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
1006 replace commands.
|
1e02a80ad090
(Unconditional Replace, Query Replace): Add xref to "Replacement and Case".
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
1007
|
|
48533
|
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:
|
|
|
1009
|
|
|
1010 @example
|
|
56230
|
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}
|
|
48533
|
1014 @end example
|
|
|
1015
|
|
|
1016 @noindent
|
|
|
1017 This works provided the string @samp{@@TEMP@@} does not appear
|
|
|
1018 in your text.
|
|
|
1019
|
|
25829
|
1020 @node Regexp Replace, Replacement and Case, Unconditional Replace, Replace
|
|
|
1021 @subsection Regexp Replacement
|
|
60860
|
1022 @findex replace-regexp
|
|
25829
|
1023
|
|
|
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.
|
|
|
1027
|
|
60860
|
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
|
|
|
1032
|
69971
fbf2a5887b37
(Regexp Backslash, Regexp Replace): Add index entries for ``back reference''
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
1033 @cindex back reference, in regexp replacement
|
|
56251
|
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
|
|
72101
|
1039 grouping in @var{regexp}. (This is called a ``back reference.'')
|
|
69976
|
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,
|
|
25829
|
1044
|
|
|
1045 @example
|
|
|
1046 M-x replace-regexp @key{RET} c[ad]+r @key{RET} \&-safe @key{RET}
|
|
|
1047 @end example
|
|
|
1048
|
|
|
1049 @noindent
|
|
|
1050 replaces (for example) @samp{cadr} with @samp{cadr-safe} and @samp{cddr}
|
|
|
1051 with @samp{cddr-safe}.
|
|
|
1052
|
|
|
1053 @example
|
|
|
1054 M-x replace-regexp @key{RET} \(c[ad]+r\)-safe @key{RET} \1 @key{RET}
|
|
|
1055 @end example
|
|
|
1056
|
|
|
1057 @noindent
|
|
56251
|
1058 performs the inverse transformation. To include a @samp{\} in the
|
|
|
1059 text to replace with, you must enter @samp{\\}.
|
|
25829
|
1060
|
64148
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1061 If you want to enter part of the replacement string by hand each
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1062 time, use @samp{\?} in the replacement string. Each replacement will
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1063 ask you to edit the replacement string in the minibuffer, putting
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1064 point where the @samp{\?} was.
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1065
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1066 The remainder of this subsection is intended for specialized tasks
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1067 and requires knowledge of Lisp. Most readers can skip it.
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1068
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1069 You can use Lisp expressions to calculate parts of the
|
|
56251
|
1070 replacement string. To do this, write @samp{\,} followed by the
|
|
|
1071 expression in the replacement string. Each replacement calculates the
|
56527
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1072 value of the expression and converts it to text without quoting (if
|
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1073 it's a string, this means using the string's contents), and uses it in
|
|
56251
|
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
|
56527
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1076 symbol name goes with the symbol name, so the value replaces them
|
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1077 both.
|
|
56251
|
1078
|
56527
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1079 Inside such an expression, you can use some special sequences.
|
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1080 @samp{\&} and @samp{\@var{n}} refer here, as usual, to the entire
|
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1081 match as a string, and to a submatch as a string. @var{n} may be
|
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1082 multiple digits, and the value of @samp{\@var{n}} is @code{nil} if
|
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1083 subexpression @var{n} did not match. You can also use @samp{\#&} and
|
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1084 @samp{\#@var{n}} to refer to those matches as numbers (this is valid
|
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1085 when the match or submatch has the form of a numeral). @samp{\#} here
|
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1086 too stands for the number of already-completed replacements.
|
|
56230
|
1087
|
|
|
1088 Repeating our example to exchange @samp{x} and @samp{y}, we can thus
|
|
|
1089 do it also this way:
|
|
|
1090
|
|
|
1091 @example
|
|
|
1092 M-x replace-regexp @key{RET} \(x\)\|y @key{RET}
|
|
|
1093 \,(if \1 "y" "x") @key{RET}
|
|
|
1094 @end example
|
|
|
1095
|
56527
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1096 For computing replacement strings for @samp{\,}, the @code{format}
|
|
56778
|
1097 function is often useful (@pxref{Formatting Strings,,, elisp, The Emacs
|
56527
1e634b993162
(Regexp Replace): Further update text for new replacement operators.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1098 Lisp Reference Manual}). For example, to add consecutively numbered
|
|
56251
|
1099 strings like @samp{ABC00042} to columns 73 @w{to 80} (unless they are
|
|
|
1100 already occupied), you can use
|
|
56247
|
1101
|
|
|
1102 @example
|
|
|
1103 M-x replace-regexp @key{RET} ^.\@{0,72\@}$ @key{RET}
|
|
|
1104 \,(format "%-72sABC%05d" \& \#) @key{RET}
|
|
|
1105 @end example
|
|
|
1106
|
|
25829
|
1107 @node Replacement and Case, Query Replace, Regexp Replace, Replace
|
|
|
1108 @subsection Replace Commands and Case
|
|
|
1109
|
|
|
1110 If the first argument of a replace command is all lower case, the
|
|
38016
|
1111 command ignores case while searching for occurrences to
|
|
25829
|
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.
|
|
|
1115
|
|
|
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
|
|
|
1120
|
|
|
1121 @example
|
|
|
1122 M-x replace-string @key{RET} foo @key{RET} bar @key{RET}
|
|
|
1123 @end example
|
|
|
1124
|
|
|
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.)
|
|
|
1131
|
|
|
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.
|
|
|
1138
|
|
|
1139 @node Query Replace,, Replacement and Case, Replace
|
|
|
1140 @subsection Query Replace
|
|
|
1141 @cindex query replace
|
|
|
1142
|
|
|
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
|
|
|
1151
|
|
|
1152 @kindex M-%
|
|
|
1153 @findex query-replace
|
|
|
1154 If you want to change only some of the occurrences of @samp{foo} to
|
79604
37a6ca546c99
(Query Replace): Make exp of query-replace more self-contained, and clarify.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1155 @samp{bar}, not all of them, use @kbd{M-%} (@code{query-replace}).
|
|
25829
|
1156 This command finds occurrences of @samp{foo} one by one, displays each
|
|
37235
|
1157 occurrence and asks you whether to replace it. Aside from querying,
|
79604
37a6ca546c99
(Query Replace): Make exp of query-replace more self-contained, and clarify.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1158 @code{query-replace} works just like @code{replace-string}
|
37a6ca546c99
(Query Replace): Make exp of query-replace more self-contained, and clarify.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1159 (@pxref{Unconditional Replace}). In particular, it preserves case
|
37a6ca546c99
(Query Replace): Make exp of query-replace more self-contained, and clarify.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1160 provided @code{case-replace} is non-@code{nil}, as it normally is
|
77441
1e02a80ad090
(Unconditional Replace, Query Replace): Add xref to "Replacement and Case".
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
1161 (@pxref{Replacement and Case}). A numeric argument means consider
|
1e02a80ad090
(Unconditional Replace, Query Replace): Add xref to "Replacement and Case".
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
1162 only occurrences that are bounded by word-delimiter characters.
|
|
25829
|
1163
|
|
|
1164 @kindex C-M-%
|
|
|
1165 @findex query-replace-regexp
|
|
37235
|
1166 @kbd{C-M-%} performs regexp search and replace (@code{query-replace-regexp}).
|
59428
856e8ee31fcb
(Query Replace): Mention faces query-replace and lazy-highlight.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1167 It works like @code{replace-regexp} except that it queries
|
856e8ee31fcb
(Query Replace): Mention faces query-replace and lazy-highlight.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1168 like @code{query-replace}.
|
856e8ee31fcb
(Query Replace): Mention faces query-replace and lazy-highlight.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1169
|
856e8ee31fcb
(Query Replace): Mention faces query-replace and lazy-highlight.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1170 @cindex faces for highlighting query replace
|
856e8ee31fcb
(Query Replace): Mention faces query-replace and lazy-highlight.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1171 These commands highlight the current match using the face
|
856e8ee31fcb
(Query Replace): Mention faces query-replace and lazy-highlight.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1172 @code{query-replace}. They highlight other matches using
|
856e8ee31fcb
(Query Replace): Mention faces query-replace and lazy-highlight.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1173 @code{lazy-highlight} just like incremental search (@pxref{Incremental
|
856e8ee31fcb
(Query Replace): Mention faces query-replace and lazy-highlight.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1174 Search}).
|
|
25829
|
1175
|
|
37235
|
1176 The characters you can type when you are shown a match for the string
|
|
|
1177 or regexp are:
|
|
25829
|
1178
|
|
|
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
|
|
|
1191
|
|
|
1192 @c WideCommands
|
|
|
1193 @table @kbd
|
|
|
1194 @item @key{SPC}
|
|
|
1195 to replace the occurrence with @var{newstring}.
|
|
|
1196
|
|
|
1197 @item @key{DEL}
|
|
|
1198 to skip to the next occurrence without replacing this one.
|
|
|
1199
|
|
|
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.
|
|
|
1205
|
|
|
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}).
|
|
|
1211
|
|
|
1212 @item @key{RET}
|
|
|
1213 to exit without doing any more replacements.
|
|
|
1214
|
|
|
1215 @item .@: @r{(Period)}
|
|
|
1216 to replace this occurrence and then exit without searching for more
|
|
|
1217 occurrences.
|
|
|
1218
|
|
|
1219 @item !
|
|
|
1220 to replace all remaining occurrences without asking again.
|
|
|
1221
|
|
|
1222 @item ^
|
|
|
1223 to go back to the position of the previous occurrence (or what used to
|
|
56230
|
1224 be an occurrence), in case you changed it by mistake or want to
|
|
|
1225 reexamine it.
|
|
25829
|
1226
|
|
|
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}.
|
|
|
1232
|
|
|
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.
|
|
|
1238
|
|
36177
|
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.
|
|
|
1244
|
|
25829
|
1245 @item C-l
|
|
|
1246 to redisplay the screen. Then you must type another character to
|
|
|
1247 specify what to do with this occurrence.
|
|
|
1248
|
|
|
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
|
|
|
1253
|
|
|
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}.
|
|
|
1257
|
|
|
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.
|
|
|
1262
|
|
|
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}.
|
|
|
1267
|
|
72207
|
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.
|
|
25829
|
1272
|
|
60860
|
1273 @node Other Repeating Search
|
|
25829
|
1274 @section Other Search-and-Loop Commands
|
|
|
1275
|
|
|
1276 Here are some other commands that find matches for a regular
|
|
36177
|
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}.
|
|
44823
|
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.
|
|
25829
|
1282
|
|
|
1283 @findex list-matching-lines
|
|
|
1284 @findex occur
|
|
44823
|
1285 @findex multi-occur
|
|
68515
|
1286 @findex multi-occur-in-matching-buffers
|
|
32035
|
1287 @findex how-many
|
|
25829
|
1288 @findex delete-non-matching-lines
|
|
|
1289 @findex delete-matching-lines
|
|
|
1290 @findex flush-lines
|
|
|
1291 @findex keep-lines
|
|
|
1292
|
|
|
1293 @table @kbd
|
|
|
1294 @item M-x occur @key{RET} @var{regexp} @key{RET}
|
|
36177
|
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}
|
|
36383
|
1298 specifies that @var{n} lines of context are to be displayed before and
|
64148
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1299 after each matching line. Currently, @code{occur} can not correctly
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1300 handle multiline matches.
|
|
25829
|
1301
|
|
|
1302 @kindex RET @r{(Occur mode)}
|
|
46213
|
1303 @kindex o @r{(Occur mode)}
|
|
|
1304 @kindex C-o @r{(Occur mode)}
|
|
25829
|
1305 The buffer @samp{*Occur*} containing the output serves as a menu for
|
|
46213
|
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.
|
|
25829
|
1312
|
|
68515
|
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}.
|
|
56874
|
1315
|
|
25829
|
1316 @item M-x list-matching-lines
|
|
|
1317 Synonym for @kbd{M-x occur}.
|
|
|
1318
|
|
44823
|
1319 @item M-x multi-occur @key{RET} @var{buffers} @key{RET} @var{regexp} @key{RET}
|
|
44858
|
1320 This function is just like @code{occur}, except it is able to search
|
|
68515
|
1321 through multiple buffers. It asks you to specify the buffer names one by one.
|
|
44823
|
1322
|
|
68515
|
1323 @item M-x multi-occur-in-matching-buffers @key{RET} @var{bufregexp} @key{RET} @var{regexp} @key{RET}
|
|
44858
|
1324 This function is similar to @code{multi-occur}, except the buffers to
|
|
68515
|
1325 search are specified by a regular expression that matches visited
|
|
71587
|
1326 file names. With a prefix argument, it uses the regular expression to match
|
|
68515
|
1327 buffer names instead.
|
|
44823
|
1328
|
|
32035
|
1329 @item M-x how-many @key{RET} @var{regexp} @key{RET}
|
|
36177
|
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.
|
|
25829
|
1333
|
|
|
1334 @item M-x flush-lines @key{RET} @var{regexp} @key{RET}
|
64148
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1335 This command deletes each line that contains a match for @var{regexp},
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1336 operating on the text after point; it deletes the current line
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1337 if it contains a match starting after point. In Transient Mark mode,
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1338 if the region is active, the command operates on the region instead;
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1339 it deletes a line partially contained in the region if it contains a
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1340 match entirely contained in the region.
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1341
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1342 If a match is split across lines, @code{flush-lines} deletes all those
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1343 lines. It deletes the lines before starting to look for the next
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1344 match; hence, it ignores a match starting on the same line at which
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1345 another match ended.
|
|
25829
|
1346
|
|
|
1347 @item M-x keep-lines @key{RET} @var{regexp} @key{RET}
|
64148
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1348 This command deletes each line that @emph{does not} contain a match for
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1349 @var{regexp}, operating on the text after point; if point is not at the
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1350 beginning of a line, it always keeps the current line. In Transient
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1351 Mark mode, if the region is active, the command operates on the region
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1352 instead; it never deletes lines that are only partially contained in
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1353 the region (a newline that ends a line counts as part of that line).
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1354
|
a77d510ff94d
(Isearch Scroll): Add example of using the `isearch-scroll' property.
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
1355 If a match is split across lines, this command keeps all those lines.
|
|
25829
|
1356 @end table
|
|
|
1357
|
|
52401
|
1358 @ignore
|
|
|
1359 arch-tag: fd9d8e77-66af-491c-b212-d80999613e3e
|
|
|
1360 @end ignore
|
