jove.2

早期freebsd实现

Thus, each C-V shows the "next page of text",
except for one line of overlap to provide context.
To move backward,
use ESC V without an argument,
which moves a whole window backwards (again with a line of overlap).
.LP
C-Z and ESC Z scroll one line forward and one line backward,
respectively.
These are convenient for moving in units of lines
without having to type a numeric argument.
.NH 2
Multiple Windows
.XS \n(PN 5n
\*(SN Multiple Windows
.XE
.LP
\s-2JOVE\s0 allows you to split the screen into two or more \fIwindows\fP and
use them to display parts of different files,
or different parts of the same file.
.IP "C-X 2" 15n
Divide the current window into two smaller ones.
.IP "C-X 1" 15n
Delete all windows but the current one.
.IP "C-X D" 15n
Delete current window.
.IP "C-X N" 15n
Switch to the next window.
.IP "C-X P" 15n
Switch to the previous window.
.IP "C-X O" 15n
Same as C-X P.
.IP "C-X ^" 15n
Make this window bigger.
.IP "ESC C-V" 15n
Scroll the other window.
.LP
.LP
When using \fImultiple window\fP mode,
the text portion of the screen
is divided into separate parts called \fIwindows\fP,
which can display different pieces of text.
Each window can display different files,
or parts of the same file.
Only one of the windows is 
.I active; 
that is
the window which the cursor is in.
Editing normally takes place in that window alone.
To edit in another window,
you would give a command to move the cursor to the other window,
and then edit there.
.LP
Each window displays a mode line for the buffer it's displaying.
This is useful to keep track of which window corresponds with which
file.  In addition, the mode line serves as a separator between windows.
By setting the variable \fImode-line-should-standout\fP to "on" you can
have \s-2JOVE\s0 display the mode-line in reverse video (assuming your
particular terminal has the reverse video capability).
.LP
The command C-X 2 (\fIsplit-current-window\fP) enters multiple window mode.
A new mode line appears across the middle of the screen,
dividing the text display area into two halves.
Both windows contain the same buffer and display the same position in it,
namely where point was at the time you issued the command.
The cursor moves to the second window.
.LP
To return to viewing only one window,
use the command C-X 1 (\fIdelete-other-windows\fP).
The current window expands to fill the whole screen,
and the other windows disappear until the next C-X 2.
(The buffers and their contents are unaffected by any of the
window operations).
.LP
While there is more than one window,
you can use C-X N (\fInext-window\fP) to switch to the next window,
and C-X P (\fIprevious-window\fP) to switch to the previous one.
If you are in the bottom window and you type C-X N,
you will be placed in the top window,
and the same kind of thing happens when you type C-X P in the top window,
namely you will be placed in the bottom window.
C-X O is the same as C-X P.
It stands for "other window" because when there are only two windows,
repeated use of this command will switch between the two windows.
.LP
Often you will be editing one window while using the other just for reference.
Then,
the command ESC C-V (\fIpage-next-window\fP) is very useful.
It scrolls the next window,
as if you switched to the next window,
typed C-V,
and switched back,
without your having to do all that.
With a negative argument,
ESC C-V will do an ESC V in the next window.
.LP
When a window splits,
both halves are approximately the same size.
You can redistribute the screen space between the windows with
the C-X ^ (\fIgrow-window\fP) command.
It makes the currently selected window grow one line bigger,
or as many lines as is specified with a numeric argument.
Use ESC X \fIshrink-window\fP to make the current window smaller.
.NH 2
Multiple Windows and Multiple Buffers
.XS \n(PN 5n
\*(SN Multiple Windows and Multiple Buffers
.XE
.LP
Buffers can be selected independently in each window.
The C-X B command selects a new buffer in whichever window contains
the cursor.
Other windows' buffers do not change.
.LP
You can view the same buffer in more than one window.
Although the same buffer appears in both windows,
they have different values of point,
so you can move around in one window while the other window
continues to show the same text.
Then,
having found one place you wish to refer to, you can go back into the
other window with C-X O or C-X P to make your changes.
.LP
If you have the same buffer in both windows,
you must beware of trying to visit a different file in one of
the windows with C-X C-V,
because if you bring a new file into this buffer,
it will replaced the old file in \fIboth\fP windows.
To view different files in different windows,
you must switch buffers in one of the windows first
(with C-X B or C-X C-F, perhaps).
.LP
A convenient "combination" command for viewing something in another
window is C-X 4 (\fIwindow-find\fP).
With this command you can ask to see any specified buffer,
file or tag in the other window.
Follow the C-X 4 with either B and a buffer name,
F and a filename,
or T and a tag name.
This switches to the other window and finds there what you specified.
If you were previously in one-window mode,
multiple-window mode is entered.
C-X 4 B is similar to C-X 2 C-X B.
C-X 4 F is similar to C-X 2 C-X C-F.
C-X 4 T is similar to C-X 2 C-X
T.
The difference is one of efficiency,
and also that C-X 4 works equally well if you are already using two windows.
.NH 1
Processes Under \s-2JOVE\s0
.XS \n(PN
\*(SN Processes Under \s-2JOVE\s0
.XE
.LP
Another feature in \s-2JOVE\s0 is its ability to interact with
.UX
in a useful way.
You can run other
.UX
commands from \s-2JOVE\s0 and catch their output in \s-2JOVE\s0 buffers.
In this chapter we will discuss the different
ways to run and interact with
.UX
commands.
.NH 2
Non-interactive
.UX
commands
.XS \n(PN 5n
\*(SN Non-interactive
.XE
.LP
To run a
.UX
command from \s-2JOVE\s0 just type "C-X !" followed by the name
of the command terminated with Return.
For example,
to get a list of all the users on the system,
you do:
.DS I
C-X ! who<return>
.DE
Then \s-2JOVE\s0 picks a reasonable buffer in which the output from the
command will be placed.
E.g.,
"who" uses a buffer called \fBwho\fP;
"ps alx" uses \fBps\fP;
and "fgrep -n foo *.c" uses \fBfgrep\fP.
If \s-2JOVE\s0
wants to use a buffer that already exists it first erases the old contents.
If the buffer it selects holds a file,
not output from a previous shell command,
you must first delete that buffer with C-X K.
.LP
Once \s-2JOVE\s0 has picked a buffer it puts that buffer in a window so you
can see the command's output as it is running.
If there is only one window \s-2JOVE\s0 will automatically make another one.
Otherwise,
\s-2JOVE\s0
tries to pick the most convenient window which isn't the current one.
.LP
It's not a good idea to type anything while the command is running.
There are two reasons for this:
.IP (i)
\s-2JOVE\s0 won't see the characters (thus won't execute them) until the
command finishes,
so you may forget what you've typed.
.IP (ii)
Although \s-2JOVE\s0 won't know what you've typed,
it 
.I will
know that you've typed something,
and then it will try to be "smart" and not update the
display until it's interpreted what you've typed.
But,
of course,
\s-2JOVE\s0 won't interpret what you type until the
.UX
command completes,
so you're left with the uneasy feeling you get when you
don't know what the hell the computer is doing*.
.FS
*This is a bug and should be fixed,
but probably won't be for a while.
.FE
.LP
If you want to interrupt the command for some reason (perhaps you
mistyped it, or you changed your mind) you can type C-].
Typing this
inside \s-2JOVE\s0 while a process is running is the same as typing C-C when
you are outside \s-2JOVE\s0,
namely the process stops in a hurry.
.LP
When the command finishes, \s-2JOVE\s0 puts you back in the window in which 
you started.
Then it prints a message indicating whether or not the command
completed successfully in its (the command's) opinion.
That is,
if the command had what it considers an error
(or you interrupt it with C-])
\s-2JOVE\s0 will print an appropriate message.

.NH 2
Limitations of Non-Interactive Processes
.XS \n(PN 5n
\*(SN Limitations of Non-Interactive Processes
.XE
.LP
The reason these are called non-interactive processes is that you
can't type any input to them; you can't interact with them; they can't
ask you questions because there is no way for you to answer.
For example,
you can't run a command interpreter (a shell), or 
.I mail
or 
.I crypt
with C-X ! because there is no way to provide it with input.
Remember that \s-2JOVE\s0 (not the process in the window)
is listening to your keyboard,
and \s-2JOVE\s0 waits until the process dies before it looks at
what you type.
.LP
C-X ! is useful for running commands that do some output and then exit.
For example,
it's very useful to use with the C compiler to
catch compilation error messages (see Compiling C Programs),
or with the \fIgrep\fP commands.
.NH 2
Interactive Processes \(em Run a Shell in a Window
.XS \n(PN 5n
\*(SN Interactive Processes \(em Run a Shell in a Window
.XE
.LP
Some versions of \s-2JOVE\s0\(dg
.FS
\(dg For example, the version provided with 4.3BSD.
.FE
have the capability of running interactive
processes.
This is more useful than non-interactive processes for
certain types of jobs:
.IP (i)
You can go off and do some editing while the command is running.
This is useful for commands that do sporadic output and run for fairly long
periods of time.
.IP (ii)
Unlike non-interactive processes,
you can type input to these.
In addition,
you can edit what you type with the power of all the \s-2JOVE\s0
commands \fIbefore\fP you send the input to the process.
This is a really important feature,
and is especially useful for running a shell in a window.
.IP (iii)
Because you can continue with normal editing while one of the
processes is running,
you can create a bunch of contexts and manage them
(select them, delete them, or temporarily put them aside)
with \s-2JOVE\s0's window and buffer mechanisms.
.LP
Although we may have given an image of processes being attached to 
.I windows,
in fact they are attached to 
.I buffers.
Therefore,
once an \fIi-process\fP is running you can select another buffer into that window,
or if you wish you can delete the window altogether.
If you reselect that buffer later it will be up to date.
That is,
even though the
buffer wasn't visible it was still receiving output from the process.
You don't have to worry about missing anything when the buffer isn't visible.
.NH 2
Advantages of Running Processes in \s-2JOVE\s0 Windows.
.XS \n(PN 5n
\*(SN Advantages of Running Processes in \s-2JOVE\s0 Windows.
.XE
.LP
There are several advantages to running a shell in a window.
What you type isn't seen immediately by the process;
instead \s-2JOVE\s0 waits until
you type an entire line before passing it on to the process to read.
This means that before you type <return>
all of \s-2JOVE\s0's editing
capabilities are available for fixing errors on your input line.
If you discover an error at the beginning of the line,
rather than erasing the whole line and starting over,
you can simply move to the error,
correct it,
move back and continue typing.
.LP
Another feature is that you have the entire history of your session in
a \s-2JOVE\s0 buffer.
You don't have to worry about output from a command
moving past the top of the screen.
If you missed some output you can
move back through it with ESC V and other commands.
In addition,
you can save yourself retyping a command (or a similar one) by sending
edited versions of previous commands, or edit the output of one command
to become a list of commands to be executed ("immediate shell scripts").
.NH 2
Differences between Normal and I-process Buffers
.XS \n(PN 5n
\*(SN Differences between Normal and I-process Buffers
.XE
.LP
\s-2JOVE\s0 behaves differently in several ways when you are in an \fIi-process\fP
buffer.
Most obviously, <return> does different things
depending on both your position in the buffer and on the state of the process.
In the normal case,
when point is at the end of the buffer,
Return does what you'd expect: it inserts a line-separator and then
sends the line to the process.
If you are somewhere else in the buffer,
possibly positioned at a previous command that you want to edit,
Return will place a copy of that line
(with the prompt discarded if there is one)
at the end of the buffer and move you there.
Then you can edit the line and type Return as in the normal case.
If the process has died for some reason,
Return does nothing.
It doesn't even insert itself.
If that happens unexpectedly,
you should type ESC X \fIlist-processes\fP<return>
to get a list of each process and its state.
If your process died abnormally,
\fIlist-processes\fP may help you figure out why.
.NH 2
How to Run a Shell in a Window
.XS \n(PN 5n
\*(SN How to Run a Shell in a Window
.XE
.LP
Type ESC X \fIi-shell\fP<return> to start up a shell.
As with C-X !,
\s-2JOVE\s0 will
create a buffer,
called \fBshell\-1\fP,
and select a window for this new buffer.
But unlike C-X ! you will be left in the new window.
Now,
the shell process is said to be attached to \fBshell\-1\fP,
and it is considered an \fIi-process\fP buffer.