jove.1

早期freebsd实现

.LP
The simplest kill command is the C-K command.
If issued at the beginning of a line,
it kills all the text on the line,
leaving it blank.
If given on a line containing only white space (blanks and tabs)
the line disappears.
As a consequence,
if you go to the front of a non-blank line and type two C-K's,
the line disappears completely.
.LP
More generally,
C-K kills from point up to the end of the line,
unless it is at the end of a line.
In that case,
it kills the line separator following the line,
thus merging the next line into the current one.
Invisible spaces and tabs at the end of the line are ignored when
deciding which case applies,
so if point appears to be at the end of the line,
you can be sure the line separator will be killed.
.LP
C-K with an argument of zero kills all the text before
point on the current line.
.NH 2
Other Kill Commands
.XS \n(PN 5n
\*(SN Other Kill Commands
.XE
.LP
A kill command which is very general is C-W (\fIkill-region\fP),
which kills everything between point and the mark.*
.FS
*Often users switch this binding from C-W to C-X C-K because it is too
easy to hit C-W accidentally.
.FE
With this command,
you can kill and save contiguous characters,
if you first set the mark at one end of them and go to the other end.
.LP
Other syntactic units can be killed, too;
words,
with ESC Rubout and ESC D;
and, sentences,
with ESC K and C-X Rubout.
.NH 2
Un-killing
.XS \n(PN 5n
\*(SN Un-killing (Yanking)
.XE
.LP
Un-killing (yanking) is getting back text which was killed.
The usual way to
move or copy text is to kill it and then un-kill it one or more times.
.IP "C-Y" 10n
Yank (re-insert) last killed text.
.IP "ESC Y" 10n
Replace re-inserted killed text with the previously killed text.
.IP "ESC W" 10n
Save region as last killed text without killing.
.LP
Killed text is pushed onto a \fIring buffer\fP called the \fIkill
ring\fP that remembers the last 10 blocks of text that were killed.
(Why it is called a ring buffer will be explained below).
The command C-Y (\fIyank\fP) reinserts the text of the most recent kill.
It leaves the cursor at the end of the text,
and puts the mark at the beginning.
Thus,
a single C-Y undoes the C-W.
.LP
If you wish to copy a block of text,
you might want to use ESC W (\fIcopy-region\fP),
which copies the region into the kill ring without removing it from the buffer.
This is approximately equivalent to C-W followed by C-Y,
except that ESC W does not mark the buffer as
"changed" and does not cause the screen to be rewritten.
.LP
There is only one kill ring shared among all the buffers.
After visiting a new file,
whatever was last killed in the previous file is still on top of the kill ring.
This is important for moving text between files.
.NH 2
Appending Kills
.XS \n(PN 5n
\*(SN Appending Kills
.XE
.LP
Normally,
each kill command pushes a new block onto the kill ring.
However,
two or more kill commands immediately in a row (without any other
intervening commands) combine their text into a
single entry on the ring,
so that a single C-Y command gets it all back as it was before it was killed.
This means that you don't have to kill all the text in one command;
you can keep killing line after line,
or word after word,
until you have killed it all,
and you can still get it all back at once.
.LP
Commands that kill forward from 
.I point 
add onto the end of the previous
killed text.
Commands that kill backward from 
.I point
add onto the beginning.
This way,
any sequence of mixed forward and backward kill
commands puts all the killed text into one entry without needing rearrangement.
.NH 2
Un-killing Earlier Kills
.XS \n(PN 5n
\*(SN Un-killing Earlier Kills
.XE
.LP
To recover killed text that is no longer the most recent kill,
you need the ESC Y (\fIyank-pop\fP) command.
The ESC Y command can be used
only after a C-Y (yank) command or another ESC Y.
It takes the un-killed
text inserted by the C-Y and replaces it with the text from an earlier
kill.
So,
to recover the text of the next-to-the-last kill,
you first use C-Y to recover the last kill,
and then discard it by use of ESC Y to move back to the previous kill.
.LP
You can think of all the last few kills as living on a ring.
After a C-Y command,
the text at the front of the ring is also present in the buffer.
ESC Y "rotates" the ring bringing the previous string of text to the front
and this text replaces the other text in the buffer as well.
Enough ESC Y commands can rotate any part of the ring to the front,
so you can get at any killed text so long as it is recent enough
to be still in the ring.
Eventually the ring rotates all the way
around and the most recently killed text comes to the front
(and into the buffer) again.
ESC Y with a negative argument rotates the ring backwards.
.LP
When the text you are looking for is brought into the buffer,
you can stop doing ESC Y's and the text will stay there.
It's really just a copy of what's at the front of the ring,
so editing it does not change what's in the ring.
And the ring,
once rotated,
stays rotated,
so that doing another C-Y gets another copy of what you rotated to the
front with ESC Y.
.LP
If you change your
mind about un-killing,
C-W gets rid of the un-killed text, even
after any number of ESC Y's.
.NH 1
Searching
.XS \n(PN
\*(SN Searching
.XE
.LP
The search commands are useful for finding and moving to arbitrary
positions in the buffer in one swift motion.
For example,
if you just ran the spell program on a paper
and you want to correct some word,
you can use the search commands to move directly to that word.  There are
two flavors of search: \fIstring search\fP and \fIincremental search\fP.
The former is the default flavor\(emif you want to use incremental search
you must rearrange the key bindings (see below).
.NH 2
Conventional Search
.XS \n(PN 5n
\*(SN Conventional Search
.XE
.LP
.IP "C-S" 15n
Search forward.
.IP "C-R" 15n
Search backward.
.LP
To search for the string "FOO" you type "C-S FOO<return>".
If \s-2JOVE\s0 finds
FOO it moves point to the end of it; otherwise \s-2JOVE\s0 prints an error
message and leaves point unchanged.
C-S searches forward from point
so only occurrences of FOO after point are found.
To search in the other direction use C-R.
It is exactly the same as C-S except it searches in the opposite direction,
and if it finds the string,
it leaves point at the beginning of it,
not at the end as in C-S.
.LP
While \s-2JOVE\s0 is searching it prints the search string on the message line.
This is so you know what \s-2JOVE\s0 is doing.
When the system is heavily loaded and
editing in exceptionally large buffers,
searches can take several (sometimes many) seconds.
.LP
\s-2JOVE\s0 remembers the last search string you used,
so if you want to search for the same string you can type "C-S <return>".
If you mistyped the last search string,
you can type C-S followed by C-R.
C-R,
as usual,
inserts the default search string into the minibuffer,
and then you can fix it up.
.NH 2
Incremental Search
.XS \n(PN 5n
\*(SN Incremental Search
.XE
.LP
This search command is unusual in that is is \fIincremental\fP;
it begins to search before you have typed the complete search string.
As you type in the search string,
\s-2JOVE\s0 shows you where it would be found.
When you have typed enough characters to identify the place you want,
you can stop.
Depending on what you will do next,
you may or may not need to terminate the search explicitly with a Return first.
.LP
The command to search is C-S (\fIi-search-forward\fP).
C-S reads in characters and positions the cursor at the first
occurrence of the characters that you have typed so far.
If you type C-S and then F,
the cursor moves in the text just after the next "F".
Type an "O",
and see the cursor move to after the next "FO".
After another "O",
the cursor is after the next "FOO".
At the same time,
the "FOO" has echoed on the message line.
.LP
If you type a mistaken character,
you can rub it out.
After the FOO,
typing a Rubout makes the "O" disappear from the message line,
leaving only "FO".
The cursor moves back in the buffer to the "FO".
Rubbing out the "O" and "F" moves the cursor back to where you
started the search.
.LP
When you are satisfied with the place you have reached,
you can type a Return,
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.
Return is necessary only if the next character you want to type is a printing
character,
Rubout,
Return,
or another search command,
since those are the characters that have special meanings inside the search.
.LP
Sometimes you search for "FOO" and find it,
but not the one you hoped to find.
Perhaps there is a second FOO that you forgot about,
after the one you just found.
Then type another C-S and the cursor will find the next FOO.
This can be done any number of times.
If you overshoot,
you can return to previous finds by rubbing out the C-S's.
.LP
After you exit a search,
you can search for the same string again by typing just C-S C-S:
one C-S command to start the search and then
another C-S to mean "search again for the same string".
.LP
If your string is not found at all,
the message line says "Failing I-search".
The cursor is after the place where \s-2JOVE\s0 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 Return or some other \s-2JOVE\s0 command
to "accept what the search offered".
Or you can type C-G,
which undoes the search altogether and positions you back where you started
the search.
.LP
You can also type C-R at any time to start searching backwards.
If a search fails because the place you started was too late in the file,
you should do this.
Repeated C-R's keep looking backward for more occurrences of the last search string.
A C-S starts going forward again.
C-R's can be rubbed out just like anything else.
.NH 2
Searching with Regular Expressions
.XS \n(PN 5n
\*(SN Searching with Regular Expressions
.XE
.LP
In addition to the searching facilities described above,
\s-2JOVE\s0
can search for patterns using regular expressions.
The handling of regular expressions in \s-2JOVE\s0 is like that of \fIed(1)\fP
or \fIvi(1)\fP, but with some notable additions.
The extra metacharacters understood by \s-2JOVE\s0 are \e<,
\e>,
\e\|| and \e\|{.
The first two of these match the beginnings and endings of words;
Thus the search pattern,
"\|\e<Exec" would match all words beginning with the letters "Exec".
.LP
An \e\|| signals the beginning of an alternative \(em that is, the
pattern "foo\e\||bar" would match either "foo" or "bar".  The "curly
brace" is a way of introducing several sub-alternatives into a pattern.
It parallels the [] construct of regular expressions, except it specifies
a list of alternative words instead of just alternative characters.  So
the pattern "foo\e\|{bar,baz\e\|}bie" matches "foobarbie" or "foobazbie".
.LP
\s-2JOVE\s0 only regards metacharacters as special if the variable
\fImatch-regular-expressions\fP is set to "on".
The ability to have \s-2JOVE\s0 ignore these characters is useful if
you're editing a document about patterns and regular expressions or
when a novice is learning \s-2JOVE\s0.
.LP
Another variable that affects searching is \fIcase-ignore-search\fP.  If
this variable is set to "on" then upper case and lower case letters are
considered equal.
.NH 1
Replacement Commands
.XS \n(PN
\*(SN Replacement Commands
.XE
.LP
Global search-and-replace operations are not needed as often in \s-2JOVE\s0
as they are in other editors,
but they are available.
In addition to
the simple Replace operation which is like that found in most editors,
there is a Query Replace operation which asks,
for each occurrence of the pattern,
whether to replace it.
.NH 2
Global replacement
.XS \n(PN 5n
\*(SN Global Replacement
.XE
.LP
To replace every occurrence of FOO after point with BAR,
you can do, e.g., "ESC R FOO<return>BAR" as the \fIreplace-string\fP command
is bound to the ESC R.
Replacement takes place only between point and the end of the buffer
so if you want to cover the whole buffer you must go to the beginning first.
.NH 2
Query Replace
.XS \n(PN 5n
\*(SN Query Replace
.XE
.LP
If you want to change only some of the occurrences of FOO,
not all,
then the global \fIreplace-string\fP is inappropriate;
Instead,
use, e.g., "ESC Q FOO<return>BAR", to run the command \fIquery-replace-string\fP.
This displays each occurrence of FOO and waits for you to say whether
to replace it with a BAR.
The things you can type when you are shown an occurrence of FOO are:
.IP "Space" 15n
to replace the FOO.
.IP "Rubout" 15n
to skip to the next FOO without replacing this one.
.IP "Return" 15n
to stop without doing any more replacements.
.IP "Period" 15n
to replace this FOO and then stop.
.IP "! or P" 15n
to replace all remaining FOO's without asking.
.IP "C-R or R" 15n
to enter a recursive editing level,
in case the FOO needs to be edited rather than just replaced with a BAR.
When you are done,
exit the recursive editing level with C-X C-C and the next FOO will
be displayed.
.IP "C-W" 15n
to delete the FOO, and then start editing the buffer.
When you are finished editing whatever is to replace the FOO,
exit the recursive editing level with C-X C-C
and the next FOO will be displayed.
.IP "U" 15n
move to the last replacement and undo it.
.LP
Another alternative is using \fIreplace-in-region\fP which is just like
\fIreplace-string\fP except it searches only within the region.
.LP