GNU Info
(emacs)Incremental Search
Incremental Search
==================
An incremental search begins searching as soon as you type the first
character of the search string. As you type in the search string, Emacs
shows you where the string (as you have typed it so far) would be
found. When you have typed enough characters to identify the place you
want, you can stop. Depending on what you plan to do next, you may or
may not need to terminate the search explicitly with <RET>.
`C-s'
Incremental search forward (`isearch-forward').
`C-r'
Incremental search backward (`isearch-backward').
`C-s' starts a forward incremental search. It reads characters from
the keyboard, and moves point past the next occurrence of those
characters. If you type `C-s' and then `F', that puts the cursor after
the first `F' (the first following the starting point, since this is a
forward search). Then if you type an `O', you will see the cursor move
just after the first `FO' (the `F' in that `FO' may or may not be the
first `F'). After another `O', the cursor moves after the first `FOO'
after the place where you started the search. At each step, the buffer
text that matches the search string is highlighted, if the terminal can
do that; the current search string is always displayed in the echo area.
If you make a mistake in typing the search string, you can cancel
characters with <DEL>. Each <DEL> cancels the last character of search
string. This does not happen until Emacs is ready to read another
input character; first it must either find, or fail to find, the
character you want to erase. If you do not want to wait for this to
happen, use `C-g' as described below.
When you are satisfied with the place you have reached, you can type
<RET>, which stops searching, leaving the cursor where the search
brought it. Also, any command not specially meaningful in searches
stops the searching and is then executed. Thus, typing `C-a' would
exit the search and then move to the beginning of the line. <RET> is
necessary only if the next command you want to type is a printing
character, <DEL>, <RET>, or another character that is special within
searches (`C-q', `C-w', `C-r', `C-s', `C-y', `M-y', `M-r', `M-s', and
some other meta-characters).
Sometimes you search for `FOO' and find one, but not the one you
expected to find. There was a second `FOO' that you forgot about,
before the one you were aiming for. In this event, type another `C-s'
to move to the next occurrence of the search string. You can repeat
this any number of times. If you overshoot, you can cancel some `C-s'
characters with <DEL>.
After you exit a search, you can search for the same string again by
typing just `C-s C-s': the first `C-s' is the key that invokes
incremental search, and the second `C-s' means "search again."
To reuse earlier search strings, use the "search ring". The
commands `M-p' and `M-n' move through the ring to pick a search string
to reuse. These commands leave the selected search ring element in the
minibuffer, where you can edit it. Type `C-s' or `C-r' to terminate
editing the string and search for it.
If your string is not found at all, the echo area says `Failing
I-Search'. The cursor is after the place where Emacs found as much of
your string as it could. Thus, if you search for `FOOT', and there is
no `FOOT', you might see the cursor after the `FOO' in `FOOL'. At this
point there are several things you can do. If your string was
mistyped, you can rub some of it out and correct it. If you like the
place you have found, you can type <RET> or some other Emacs command to
remain there. Or you can type `C-g', which removes from the search
string the characters that could not be found (the `T' in `FOOT'),
leaving those that were found (the `FOO' in `FOOT'). A second `C-g' at
that point cancels the search entirely, returning point to where it was
when the search started.
An upper-case letter in the search string makes the search
case-sensitive. If you delete the upper-case character from the search
string, it ceases to have this effect. Note: Search Case.
To search for a newline, type `C-j'. To search for another control
character, such as control-S or carriage return, you must quote it by
typing `C-q' first. This function of `C-q' is analogous to its use for
insertion (Note: Inserting Text): it causes the following character
to be treated the way any "ordinary" character is treated in the same
context. You can also specify a character by its octal code: enter
`C-q' followed by a sequence of octal digits.
To search for non-ASCII characters, you must use an input method
(Note: Input Methods). If an input method is enabled in the current
buffer when you start the search, you can use it while you type the
search string also. Emacs indicates that by including the input method
mnemonic in its prompt, like this:
I-search [IM]:
where IM is the mnemonic of the active input method. You can toggle
(enable or disable) the input method while you type the search string
with `C-\' (`isearch-toggle-input-method'). You can turn on a certain
(non-default) input method with `C-^'
(`isearch-toggle-specified-input-method'), which prompts for the name
of the input method. The input method you enable during incremental
search remains enabled in the current buffer afterwards.
If a search is failing and you ask to repeat it by typing another
`C-s', it starts again from the beginning of the buffer. Repeating a
failing reverse search with `C-r' starts again from the end. This is
called "wrapping around", and `Wrapped' appears in the search prompt
once this has happened. If you keep on going past the original
starting point of the search, it changes to `Overwrapped', which means
that you are revisiting matches that you have already seen.
The `C-g' "quit" character does special things during searches; just
what it does depends on the status of the search. If the search has
found what you specified and is waiting for input, `C-g' cancels the
entire search. The cursor moves back to where you started the search.
If `C-g' is typed when there are characters in the search string that
have not been found--because Emacs is still searching for them, or
because it has failed to find them--then the search string characters
which have not been found are discarded from the search string. With
them gone, the search is now successful and waiting for more input, so
a second `C-g' will cancel the entire search.
You can change to searching backwards with `C-r'. If a search fails
because the place you started was too late in the file, you should do
this. Repeated `C-r' keeps looking for more occurrences backwards. A
`C-s' starts going forwards again. `C-r' in a search can be canceled
with <DEL>.
If you know initially that you want to search backwards, you can use
`C-r' instead of `C-s' to start the search, because `C-r' as a key runs
a command (`isearch-backward') to search backward. A backward search
finds matches that are entirely before the starting point, just as a
forward search finds matches that begin after it.
The characters `C-y' and `C-w' can be used in incremental search to
grab text from the buffer into the search string. This makes it
convenient to search for another occurrence of text at point. `C-w'
copies the word after point as part of the search string, advancing
point over that word. Another `C-s' to repeat the search will then
search for a string including that word. `C-y' is similar to `C-w' but
copies all the rest of the current line into the search string. Both
`C-y' and `C-w' convert the text they copy to lower case if the search
is currently not case-sensitive; this is so the search remains
case-insensitive.
The character `M-y' copies text from the kill ring into the search
string. It uses the same text that `C-y' as a command would yank.
`Mouse-2' in the echo area does the same. Note: Yanking.
When you exit the incremental search, it sets the mark to where point
_was_, before the search. That is convenient for moving back there.
In Transient Mark mode, incremental search sets the mark without
activating it, and does so only if the mark is not already active.
When you pause for a little while during incremental search, it
highlights all other possible matches for the search string. This
makes it easier to anticipate where you can get to by typing `C-s' or
`C-r' to repeat the search. The short delay before highlighting other
matches helps indicate which match is the current one. If you don't
like this feature, you can turn it off by setting
`isearch-lazy-highlight' to `nil'.
You can control how this highlighting looks by customizing the faces
`isearch' (used for the current match) and
`isearch-lazy-highlight-face' (for all the other matches).
To customize the special characters that incremental search
understands, alter their bindings in the keymap `isearch-mode-map'.
For a list of bindings, look at the documentation of `isearch-mode' with
`C-h f isearch-mode <RET>'.
Slow Terminal Incremental Search
--------------------------------
Incremental search on a slow terminal uses a modified style of
display that is designed to take less time. Instead of redisplaying
the buffer at each place the search gets to, it creates a new
single-line window and uses that to display the line that the search
has found. The single-line window comes into play as soon as point
moves outside of the text that is already on the screen.
When you terminate the search, the single-line window is removed.
Emacs then redisplays the window in which the search was done, to show
its new position of point.
The slow terminal style of display is used when the terminal baud
rate is less than or equal to the value of the variable
`search-slow-speed', initially 1200. See `baud-rate' in Note: Display
Custom.
The number of lines to use in slow terminal search display is
controlled by the variable `search-slow-window-lines'. Its normal
value is 1.
automatically generated by info2www version 1.2.2.9