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