JOVE Manual for UNIX Users USD:17-1
JOVE Manual for UNIX Users
Jonathan Payne
(revised for 4.3BSD by Doug Kingston and Mark Seiden)
1. Introduction
JOVE* is an advanced, self-documenting, customizable real-time
display editor. It (and this tutorial introduction) are based on
the original EMACS editor and user manual written at M.I.T. by
Richard Stallman+.
JOVE is considered a display editor because normally the text
being edited is visible on the screen and is updated automati-
cally as you type your commands.
It's considered a real-time editor because the display is updated
very frequently, usually after each character or pair of charac-
ters you type. This minimizes the amount of information you must
keep in your head as you edit.
JOVE is advanced because it provides facilities that go beyond
simple insertion and deletion: filling of text; automatic inden-
tations of programs; view more than one file at once; and dealing
in terms of characters, words, lines, sentences and paragraphs.
It is much easier to type one command meaning "go to the end of
the paragraph" than to find the desired spot with repetition of
simpler commands.
Self-documenting means that at almost any time you can easily
find out what a command does, or to find all the commands that
pertain to a topic.
Customizable means that you can change the definition of JOVE
commands in little ways. For example, you can rearrange the com-
mand set; if you prefer to use arrow keys for the four basic cur-
sor motion commands (up, down, left and right), you can. Another
sort of customization is writing new commands by combining built
in commands.
2. The Organization of the Screen
JOVE divides the screen up into several sections. The biggest of
these sections is used to display the text you are editing. The
terminal's cursor shows the position of point, the location at
_________________________
*JOVE stands for Jonathan's Own Version of Emacs.
+Although JOVE is meant to be compatible with EMACS,
and indeed many of the basic commands are very similar,
there are some major differences between the two edi-
tors, and you should not rely on their behaving identi-
cally.
April 27, 2013
USD:17-2 JOVE Manual for UNIX Users
which editing takes place. While the cursor appears to point at a
character, point should be thought of as between characters; it
points before the character that the cursor appears on top of.
Terminals have only one cursor, and when output is in progress it
must appear where the typing is being done. This doesn't mean
that point is moving; it is only that JOVE has no way of showing
you the location of point except when the terminal is idle.
The lines of the screen are usually available for displaying text
but sometimes are pre-empted by typeout from certain commands
(such as a listing of all the editor commands). Most of the time,
output from commands like these is only desired for a short
period of time, usually just long enough to glance at it. When
you have finished looking at the output, you can type Space to
make your text reappear. (Usually a Space that you type inserts
itself, but when there is typeout on the screen, it does nothing
but get rid of that). Any other command executes normally, after
redrawing your text.
2.1. The Message Line
The bottom line on the screen, called the message line, is
reserved for printing messages and for accepting input from the
user, such as filenames or search strings. When JOVE prompts for
input, the cursor will temporarily appear on the bottom line,
waiting for you to type a string. When you have finished typing
your input, you can type a Return to send it to JOVE. If you
change your mind about running the command that is waiting for
input, you can type Control-G to abort, and you can continue with
your editing.
When JOVE is prompting for a filename, all the usual editing
facilities can be used to fix typos and such; in addition, JOVE
has the following extra functions:
^N Insert the next filename from the argument list.
^P Insert the previous filename from the argument list.
^R Insert the full pathname of the file in the current buffer.
Sometimes you will see --more-- on the message line. This happens
when typeout from a command is too long to fit in the screen. It
means that if you type a Space the next screenful of typeout will
be printed. If you are not interested, typing anything but a
Space will cause the rest of the output to be discarded. Typing
C-G will discard the output and print Aborted where the --more--
was. Typing any other command will discard the rest of the output
and also execute the command.
The message line and the list of filenames from the shell command
that invoked JOVE are kept in a special buffer called Minibuf
that can be edited like any other buffer.
April 27, 2013
JOVE Manual for UNIX Users USD:17-3
2.2. The Mode Line
At the bottom of the screen, but above the message line, is the
mode line. The mode line format looks like this:
JOVE (major minor) Buffer: bufr "file" *
major is the name of the current major mode. At any time, JOVE
can be in only one major mode at a time. Currently there are only
four major modes: Fundamental, Text, Lisp and C.
minor is a list of the minor modes that are turned on. Abbrev
means that Word Abbrev mode is on; AI means that Auto Indent mode
is on; Fill means that Auto Fill mode is on; OvrWt means that
Over Write mode is on. Def means that you are in the process of
defining a keyboard macro. This is not really a mode, but it's
useful to be reminded about it. The meanings of these modes are
described later in this document.
bufr is the name of the currently selected buffer. Each buffer
has its own name and holds a file being edited; this is how JOVE
can hold several files at once. But at any given time you are
editing only one of them, the selected buffer. When we speak of
what some command does to "the buffer", we are talking about the
currently selected buffer. Multiple buffers makes it easy to
switch around between several files, and then it is very useful
that the mode line tells you which one you are editing at any
time. (You will see later that it is possible to divide the
screen into multiple windows, each showing a different buffer.
If you do this, there is a mode line beneath each window.)
file is the name of the file that you are editing. This is the
default filename for commands that expect a filename as input.
The asterisk at the end of the mode line means that there are
changes in the buffer that have not been saved in the file. If
the file has not been changed since it was read in or saved,
there is no asterisk.
3. Command Input Conventions
3.1. Notational Conventions for ASCII Characters
In this manual, "Control" characters (that is, characters that
are typed with the Control key and some other key at the same
time) are represented by "C-" followed by another character.
Thus, C-A is the character you get when you type A with the Con-
trol key (sometimes labeled CTRL) down. Most control characters
when present in the JOVE buffer are displayed with a caret; thus,
^A for C-A. Rubout (or DEL) is displayed as ^?, escape as ^[.
April 27, 2013
USD:17-4 JOVE Manual for UNIX Users
3.2. Command and Filename Completion
When you are typing the name of a JOVE command, you need type
only enough letters to make the name unambiguous. At any point
in the course of typing the name, you can type question mark (?)
to see a list of all the commands whose names begin with the
characters you've already typed; you can type Space to have JOVE
supply as many characters as it can; or you can type Return to
complete the command if there is only one possibility. For exam-
ple, if you have typed the letters "au" and you then type a ques-
tion mark, you will see the list
auto-execute-command
auto-execute-macro
auto-fill-mode
auto-indent-mode
If you type a Return at this point, JOVE will complain by ringing
the bell, because the letters you've typed do not unambiguously
specify a single command. But if you type Space, JOVE will sup-
ply the characters "to-" because all commands that begin "au"
also begin "auto-". You could then type the letter "f" followed
by either Space or Return, and JOVE would complete the entire
command.
Whenever JOVE is prompting you for a filename, say in the find-
file command, you also need only type enough of the name to make
it unambiguous with respect to files that already exist. In this
case, question mark and Space work just as they do in command
completion, but Return always accepts the name just as you've
typed it, because you might want to create a new file with a name
similar to that of an existing file.
4. Commands and Variables
JOVE is composed of commands which have long names such as next-
line. Then keys such as C-N are connected to commands through the
command dispatch table. When we say that C-N moves the cursor
down a line, we are glossing over a distinction which is unimpor-
tant for ordinary use, but essential for simple customization: it
is the command next-line which knows how to move a down line, and
C-N moves down a line because it is connected to that command.
The name for this connection is a binding; we say that the key
C-N is bound to the command next-line.
Not all commands are bound to keys. To invoke a command that
isn't bound to a key, you can type the sequence ESC X, which is
bound to the command execute-named-command. You will then be
able to type the name of whatever command you want to execute on
the message line.
Sometimes the description of a command will say "to change this,
set the variable mumble-foo". A variable is a name used to
remember a value. JOVE contains variables which are there so that
April 27, 2013
JOVE Manual for UNIX Users USD:17-5
you can change them if you want to customize. The variable's
value is examined by some command, and changing that value makes
the command behave differently. Until you are interesting in cus-
tomizing JOVE, you can ignore this information.
4.1. Prefix Characters
Because there are more command names than keys, JOVE provides
prefix characters to increase the number of commands that can be
invoked quickly and easily. When you type a prefix character JOVE
will wait for another character before deciding what to do. If
you wait more than a second or so, JOVE will print the prefix
character on the message line as a reminder and leave the cursor
down there until you type your next character. There are two pre-
fix characters built into JOVE: Escape and Control-X. How the
next character is interpreted depends on which prefix character
you typed. For example, if you type Escape followed by B you'll
run backward-word, but if you type Control-X followed by B you'll
run select-buffer. Elsewhere in this manual, the Escape key is
indicated as "ESC", which is also what JOVE displays on the mes-
sage line for Escape.
4.2. Help
To get a list of keys and their associated commands, you type ESC
X describe-bindings. If you want to describe a single key, ESC X
describe-key will work. A description of an individual command
is available by using ESC X describe-command, and descriptions of
variables by using ESC X describe-variable. If you can't
remember the name of the thing you want to know about, ESC X
apropos will tell you if a command or variable has a given string
in its name. For example, ESC X apropos describe will list the
names of the four describe commands mentioned briefly in this
section.
5. Basic Editing Commands
5.1. Inserting Text
To insert printing characters into the text you are editing, just
type them. All printing characters you type are inserted into the
text at the cursor (that is, at point), and the cursor moves for-
ward. Any characters after the cursor move forward too. If the
text in the buffer is FOOBAR, with the cursor before the B, then
if you type XX, you get FOOXXBAR, with the cursor still before
the B.
To correct text you have just inserted, you can use Rubout.
Rubout deletes the character before the cursor (not the one that
the cursor is on top of or under; that is the character after the
cursor). The cursor and all characters after it move backwards.
Therefore, if you typing a printing character and then type
Rubout, they cancel out.
April 27, 2013
USD:17-6 JOVE Manual for UNIX Users
To end a line and start typing a new one, type Return. Return
operates by inserting a line-separator, so if you type Return in
the middle of a line, you break the line in two. Because a line-
separator is just a single character, you can type Rubout at the
beginning of a line to delete the line-separator and join it with
the preceding line.
As a special case, if you type Return at the end of a line and
there are two or more empty lines just below it, JOVE does not
insert a line-separator but instead merely moves to the next
(empty) line. This behavior is convenient when you want to add
several lines of text in the middle of a buffer. You can use the
Control-O (newline-and-backup) command to "open" several empty
lines at once; then you can insert the new text, filling up these
empty lines. The advantage is that JOVE does not have to redraw
the bottom part of the screen for each Return you type, as it
would ordinarily. That "redisplay" can be both slow and dis-
tracting.
If you add too many characters to one line, without breaking it
with Return, the line will grow too long to display on one screen
line. When this happens, JOVE puts an "!" at the extreme right
margin, and doesn't bother to display the rest of the line unless
the cursor happens to be in it. The "!" is not part of your text;
conversely, even though you can't see the rest of your line, it's
still there, and if you break the line, the "!" will go away.
Direct insertion works for printing characters and space, but
other characters act as editing commands and do not insert them-
selves. If you need to insert a control character, Escape, or
Rubout, you must first quote it by typing the Control-Q command
first.
5.2. Moving the Cursor
To do more than insert characters, you have to know how to move
the cursor. Here are a few of the commands for doing that.
C-A Move to the beginning of the line.
C-E Move to the end of the line.
C-F Move forward over one character.
C-B Move backward over one character.
C-N Move down one line, vertically. If you start in
the middle of one line, you end in the middle of
the next.
C-P Move up one line, vertically.
ESC < Move to the beginning of the entire buffer.
April 27, 2013
JOVE Manual for UNIX Users USD:17-7
ESC > Move to the end of the entire buffer.
ESC , Move to the beginning of the visible window.
ESC . Move to the end of the visible window.
5.3. Erasing Text
Rubout Delete the character before the cursor.
C-D Delete the character after the cursor.
C-K Kill to the end of the line.
You already know about the Rubout command which deletes the char-
acter before the cursor. Another command, Control-D, deletes the
character after the cursor, causing the rest of the text on the
line to shift left. If Control-D is typed at the end of a line,
that line and the next line are joined together.
To erase a larger amount of text, use the Control-K command,
which kills a line at a time. If Control-K is done at the begin-
ning or middle of a line, it kills all the text up to the end of
the line. If Control-K is done at the end of a line, it joins
that line and the next line. If Control-K is done twice, it kills
the rest of the line and the line separator also.
5.4. Files - Saving Your Work
The commands above are sufficient for creating text in the JOVE
buffer. The more advanced JOVE commands just make things easier.
But to keep any text permanently you must put it in a file. Files
are the objects which UNIX- uses for storing data for a length of
time. To tell JOVE to read text into a file, choose a filename,
such as foo.bar, and type C-X C-R foo.bar<return>. This reads the
file foo.bar so that its contents appear on the screen for edit-
ing. You can make changes, and then save the file by typing C-X
C-S (save-file). This makes the changes permanent and actually
changes the file foo.bar. Until then, the changes are only inside
JOVE, and the file foo.bar is not really changed. If the file
foo.bar doesn't exist, and you want to create it, read it as if
it did exist. When you save your text with C-X C-S the file will
be created.
5.5. Exiting and Pausing - Leaving JOVE
The command C-X C-C (exit-jove) will terminate the JOVE session
and return to the shell. If there are modified but unsaved
buffers, JOVE will ask you for confirmation, and you can abort
_________________________
- UNIX is a registered trademark of AT&T Bell Labora-
tories in the USA and other countries.
April 27, 2013
USD:17-8 JOVE Manual for UNIX Users
the command, look at what buffers are modified but unsaved using
C-X C-B (list-buffers), save the valuable ones, and then exit.
If what you want to do, on the other hand, is preserve the edit-
ing session but return to the shell temporarily you can (under
Berkeley UNIX only) issue the command ESC S (pause-jove), do your
UNIX work within the c-shell, then return to JOVE using the fg
command to resume editing at the point where you paused. For this
sort of situation you might consider using an interactive shell
(that is, a shell in a JOVE window) which lets you use editor
commands to manipulate your UNIX commands (and their output)
while never leaving the editor. (The interactive shell feature is
described below.)
5.6. Giving Numeric Arguments to JOVE Commands
Any JOVE command can be given a numeric argument. Some commands
interpret the argument as a repetition count. For example, giving
an argument of ten to the C-F command (forward-character) moves
forward ten characters. With these commands, no argument is
equivalent to an argument of 1.
Some commands use the value of the argument, but do something
peculiar (or nothing) when there is no argument. For example, ESC
G (goto-line) with an argument n goes to the beginning of the
n'th line. But ESC G with no argument doesn't do anything. Simi-
larly, C-K with an argument kills that many lines, including
their line separators. Without an argument, C-K when there is
text on the line to the right of the cursor kills that text; when
there is no text after the cursor, C-K deletes the line separa-
tor.
The fundamental way of specifying an argument is to use ESC fol-
lowed by the digits of the argument, for example, ESC 123 ESC G
to go to line 123. Negative arguments are allowed, although not
all of the commands know what to do with one.
Typing C-U means do the next command four times. Two such C-U's
multiply the next command by sixteen. Thus, C-U C-U C-F moves
forward sixteen characters. This is a good way to move forward
quickly, since it moves about 1/4 of a line on most terminals.
Other useful combinations are: C-U C-U C-N (move down a good
fraction of the screen), C-U C-U C-O (make "a lot" of blank
lines), and C-U C-K (kill four lines - note that typing C-K four
times would kill 2 lines).
There are other, terminal-dependent ways of specifying arguments.
They have the same effect but may be easier to type. If your ter-
minal has a numeric keypad which sends something recognizably
different from the ordinary digits, it is possible to program
JOVE to to allow use of the numeric keypad for specifying argu-
ments.
April 27, 2013
JOVE Manual for UNIX Users USD:17-9
5.7. The Mark and the Region
In general, a command that processes an arbitrary part of the
buffer must know where to start and where to stop. In JOVE, such
commands usually operate on the text between point and the mark.
This body of text is called the region. To specify a region, you
set point to one end of it and mark at the other. It doesn't
matter which one comes earlier in the text.
C-@ Set the mark where point is.
C-X C-X Interchange mark and point.
For example, if you wish to convert part of the buffer to all
upper-case, you can use the C-X C-U command, which operates on
the text in the region. You can first go to the beginning of the
text to be capitalized, put the mark there, move to the end, and
then type C-X C-U. Or, you can set the mark at the end of the
text, move to the beginning, and then type C-X C-U. C-X C-U runs
the command case-region-upper, whose name signifies that the
region, or everything between point and mark, is to be capital-
ized.
The way to set the mark is with the C-@ command or (on some ter-
minals) the C-Space command. They set the mark where point is.
Then you can move point away, leaving mark behind. When the mark
is set, "[Point pushed]" is printed on the message line.
Since terminals have only one cursor, there is no way for JOVE to
show you where the mark is located. You have to remember. The
usual solution to this problem is to set the mark and then use it
soon, before you forget where it is. But you can see where the
mark is with the command C-X C-X which puts the mark where point
was and point where mark was. The extent of the region is
unchanged, but the cursor and point are now at the previous loca-
tion of the mark.
5.8. The Ring of Marks
Aside from delimiting the region, the mark is also useful for
remembering a spot that you may want to go back to. To make this
feature more useful, JOVE remembers 16 previous locations of the
mark. Most commands that set the mark push the old mark onto this
stack. To return to a marked location, use C-U C-@. This moves
point to where the mark was, and restores the mark from the stack
of former marks. So repeated use of this command moves point to
all of the old marks on the stack, one by one. Since the stack is
actually a ring, enough uses of C-U C-@ bring point back to where
it was originally.
Some commands whose primary purpose is to move point a great dis-
tance take advantage of the stack of marks to give you a way to
undo the command. The best example is ESC <, which moves to the
beginning of the buffer. If there are more than 22 lines between
April 27, 2013
USD:17-10 JOVE Manual for UNIX Users
the beginning of the buffer and point, ESC < sets the mark first,
so that you can use C-U C-@ or C-X C-X to go back to where you
were. You can change the number of lines from 22 since it is kept
in the variable mark-threshold. By setting it to 0, you can make
these commands always set the mark. By setting it to a very large
number you can prevent these commands from ever setting the mark.
If a command decides to set the mark, it prints the message
[Point pushed].
5.9. Killing and Moving Text
The most common way of moving or copying text with JOVE is to
kill it, and get it back again in one or more places. This is
very safe because the last several pieces of killed text are all
remembered, and it is versatile, because the many commands for
killing syntactic units can also be used for moving those units.
There are also other ways of moving text for special purposes.
5.10. Deletion and Killing
Most commands which erase text from the buffer save it so that
you can get it back if you change your mind, or move or copy it
to other parts of the buffer. These commands are known as kill
commands. The rest of the commands that erase text do not save
it; they are known as delete commands. The delete commands
include C-D and Rubout, which delete only one character at a
time, and those commands that delete only spaces or line separa-
tors. Commands that can destroy significant amounts of nontrivial
data generally kill. A command's name and description will use
the words kill or delete to say which one it does.
C-D Delete next character.
Rubout Delete previous character.
ESC \ Delete spaces and tabs around point.
C-X C-O Delete blank lines around the current line.
C-K Kill rest of line or one or more lines.
C-W Kill region (from point to the mark).
ESC D Kill word.
ESC Rubout Kill word backwards.
ESC K Kill to end of sentence.
C-X Rubout Kill to beginning of sentence.
5.11. Deletion
The most basic delete commands are C-D and Rubout. C-D deletes
April 27, 2013
JOVE Manual for UNIX Users USD:17-11
the character after the cursor, the one the cursor is "on top of"
or "underneath". The cursor doesn't move. Rubout deletes the
character before the cursor, and moves the cursor back. Line
separators act like normal characters when deleted. Actually, C-D
and Rubout aren't always delete commands; if you give an argu-
ment, they kill instead. This prevents you from losing a great
deal of text by typing a large argument to a C-D or Rubout.
The other delete commands are those which delete only formatting
characters: spaces, tabs, and line separators. ESC \ (delete-
white-space) deletes all the spaces and tab characters before and
after point. C-X C-O (delete-blank-lines) deletes all blank lines
after the current line, and if the current line is blank deletes
all the blank lines preceding the current line as well (leaving
one blank line, the current line).
5.12. Killing by Lines
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.
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.
C-K with an argument of zero kills all the text before point on
the current line.
5.13. Other Kill Commands
A kill command which is very general is C-W (kill-region), which
kills everything between point and the mark.* 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.
Other syntactic units can be killed, too; words, with ESC Rubout
and ESC D; and, sentences, with ESC K and C-X Rubout.
5.14. Un-killing
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
_________________________
*Often users switch this binding from C-W to C-X C-K
because it is too easy to hit C-W accidentally.
April 27, 2013
USD:17-12 JOVE Manual for UNIX Users
one or more times.
C-Y Yank (re-insert) last killed text.
ESC Y Replace re-inserted killed text with the previously
killed text.
ESC W Save region as last killed text without killing.
Killed text is pushed onto a ring buffer called the kill ring
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 (yank) 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.
If you wish to copy a block of text, you might want to use ESC W
(copy-region), 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.
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 mov-
ing text between files.
5.15. Appending Kills
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 kil-
ling line after line, or word after word, until you have killed
it all, and you can still get it all back at once.
Commands that kill forward from point add onto the end of the
previous killed text. Commands that kill backward from 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.
5.16. Un-killing Earlier Kills
To recover killed text that is no longer the most recent kill,
you need the ESC Y (yank-pop) 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.
April 27, 2013
JOVE Manual for UNIX Users USD:17-13
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 pre-
vious 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.
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.
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.
6. Searching
The search commands are useful for finding and moving to arbi-
trary 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: string
search and incremental search. The former is the default flavor-
if you want to use incremental search you must rearrange the key
bindings (see below).
6.1. Conventional Search
C-S Search forward.
C-R Search backward.
To search for the string "FOO" you type "C-S FOO<return>". If
JOVE finds FOO it moves point to the end of it; otherwise JOVE
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.
While JOVE is searching it prints the search string on the mes-
sage line. This is so you know what JOVE is doing. When the sys-
tem is heavily loaded and editing in exceptionally large buffers,
searches can take several (sometimes many) seconds.
JOVE remembers the last search string you used, so if you want to
April 27, 2013
USD:17-14 JOVE Manual for UNIX Users
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.
6.2. Incremental Search
This search command is unusual in that is is incremental; it
begins to search before you have typed the complete search
string. As you type in the search string, JOVE 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.
The command to search is C-S (i-search-forward). 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.
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.
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, typ-
ing 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.
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 rub-
bing out the C-S's.
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".
If your string is not found at all, the message line says "Fail-
ing I-search". The cursor is after the place where JOVE 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.
April 27, 2013
JOVE Manual for UNIX Users USD:17-15
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
JOVE 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.
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 back-
ward 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.
6.3. Searching with Regular Expressions
In addition to the searching facilities described above, JOVE can
search for patterns using regular expressions. The handling of
regular expressions in JOVE is like that of ed(1) or vi(1), but
with some notable additions. The extra metacharacters understood
by JOVE are \<, \>, \| and \{. The first two of these match the
beginnings and endings of words; Thus the search pattern,
"\<Exec" would match all words beginning with the letters "Exec".
An \| signals the beginning of an alternative - that is, the pat-
tern "foo\|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\{bar,baz\}bie"
matches "foobarbie" or "foobazbie".
JOVE only regards metacharacters as special if the variable
match-regular-expressions is set to "on". The ability to have
JOVE ignore these characters is useful if you're editing a docu-
ment about patterns and regular expressions or when a novice is
learning JOVE.
Another variable that affects searching is case-ignore-search.
If this variable is set to "on" then upper case and lower case
letters are considered equal.
7. Replacement Commands
Global search-and-replace operations are not needed as often in
JOVE 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.
7.1. Global replacement
To replace every occurrence of FOO after point with BAR, you can
do, e.g., "ESC R FOO<return>BAR" as the replace-string command is
April 27, 2013
USD:17-16 JOVE Manual for UNIX Users
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.
7.2. Query Replace
If you want to change only some of the occurrences of FOO, not
all, then the global replace-string is inappropriate; Instead,
use, e.g., "ESC Q FOO<return>BAR", to run the command query-
replace-string. 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:
Space to replace the FOO.
Rubout to skip to the next FOO without replacing this
one.
Return to stop without doing any more replacements.
Period to replace this FOO and then stop.
! or P to replace all remaining FOO's without asking.
C-R or R 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.
C-W 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.
U move to the last replacement and undo it.
Another alternative is using replace-in-region which is just like
replace-string except it searches only within the region.
8. Commands for English Text
JOVE has many commands that work on the basic units of English
text: words, sentences and paragraphs.
8.1. Word Commands
JOVE has commands for moving over or operating on words. By con-
vention, they are all ESC commands.
ESC F Move Forward over a word.
April 27, 2013
JOVE Manual for UNIX Users USD:17-17
ESC B Move Backward over a word.
ESC D Kill forward to the end of a word.
ESC Rubout Kill backward to the beginning of a word.
Notice how these commands form a group that parallels the
character- based commands, C-F, C-B, C-D, and Rubout.
The commands ESC F and ESC B move forward and backward over
words. They are thus analogous to Control-F and Control-B, which
move over single characters. Like their Control- analogues, ESC F
and ESC B move several words if given an argument. ESC F with a
negative argument moves backward like ESC B, and ESC B with a
negative argument moves forward. Forward motion stops right after
the last letter of the word, while backward motion stops right
before the first letter.
It is easy to kill a word at a time. ESC D kills the word after
point. To be precise, it kills everything from point to the place
ESC F would move to. Thus, if point is in the middle of a word,
only the part after point is killed. If some punctuation comes
after point, and before the next word, it is killed along with
the word. If you wish to kill only the next word but not the
punctuation, simply do ESC F to get to the end, and kill the word
backwards with ESC Rubout. ESC D takes arguments just like ESC F.
ESC Rubout kills the word before point. It kills everything from
point back to where ESC B would move to. If point is after the
space in "FOO, BAR", then "FOO, " is killed. If you wish to kill
just "FOO", then do a ESC B and a ESC D instead of a ESC Rubout.
8.2. Sentence Commands
The JOVE commands for manipulating sentences and paragraphs are
mostly ESC commands, so as to resemble the word-handling com-
mands.
ESC A Move back to the beginning of the sentence.
ESC E Move forward to the end of the sentence.
ESC K Kill forward to the end of the sentence.
C-X Rubout Kill back to the beginning of the sentence.
The commands ESC A and ESC E move to the beginning and end of the
current sentence, respectively. They were chosen to resemble
Control-A and Control-E, which move to the beginning and end of a
line. Unlike them, ESC A and ESC E if repeated or given numeric
arguments move over successive sentences. JOVE considers a sen-
tence to end wherever there is a ".", "?", or "!" followed by the
end of a line or by one or more spaces. Neither ESC A nor ESC E
moves past the end of the line or spaces which delimit the
April 27, 2013
USD:17-18 JOVE Manual for UNIX Users
sentence.
Just as C-A and C-E have a kill command, C-K, to go with them, so
ESC A and ESC E have a corresponding kill command ESC K which
kills from point to the end of the sentence. With minus one as an
argument it kills back to the beginning of the sentence. Positive
arguments serve as a repeat count.
There is a special command, C-X Rubout for killing back to the
beginning of a sentence, because this is useful when you change
your mind in the middle of composing text.
8.3. Paragraph Commands
The JOVE commands for handling paragraphs are
ESC [ Move back to previous paragraph beginning.
ESC ] Move forward to next paragraph end.
ESC [ moves to the beginning of the current or previous para-
graph, while ESC ] moves to the end of the current or next para-
graph. Paragraphs are delimited by lines of differing indent, or
lines with text formatter commands, or blank lines. JOVE knows
how to deal with most indented paragraphs correctly, although it
can get confused by one- or two-line paragraphs delimited only by
indentation.
8.4. Text Indentation Commands
Tab Indent "appropriately" in a mode-dependent
fashion.
LineFeed Is the same as Return, except it copies the
indent of the line you just left.
ESC M Moves to the line's first non-blank charac-
ter.
The way to request indentation is with the Tab command. Its pre-
cise effect depends on the major mode. In Text mode, it indents
to the next tab stop. In C mode, it indents to the "right" posi-
tion for C programs.
To move over the indentation on a line, do ESC M (first-non-
blank). This command, given anywhere on a line, positions the
cursor at the first non-blank, non-tab character on the line.
8.5. Text Filling
Auto Fill mode causes text to be filled (broken up into lines
that fit in a specified width) automatically as you type it in.
April 27, 2013
JOVE Manual for UNIX Users USD:17-19
If you alter existing text so that it is no longer properly
filled, JOVE can fill it again if you ask.
Entering Auto Fill mode is done with ESC X auto-fill-mode. From
then on, lines are broken automatically at spaces when they get
longer than the desired width. To leave Auto Fill mode, once
again execute ESC X auto-fill-mode. When Auto Fill mode is in
effect, the word Fill appears in the mode line.
If you edit the middle of a paragraph, it may no longer correctly
be filled. To refill a paragraph, use the command ESC J (fill-
paragraph). It causes the paragraph that point is inside to be
filled. All the line breaks are removed and new ones inserted
where necessary.
The maximum line width for filling is in the variable right-
margin. Both ESC J and auto-fill make sure that no line exceeds
this width. The value of right-margin is initially 72.
Normally ESC J figures out the indent of the paragraph and uses
that same indent when filling. If you want to change the indent
of a paragraph you set left-margin to the new position and type
C-U ESC J. fill-paragraph, when supplied a numeric argument, uses
the value of left-margin.
If you know where you want to set the right margin but you don't
know the actual value, move to where you want to set the value
and use the right-margin-here command. left-margin-here does the
same for the left-margin variable.
8.6. Case Conversion Commands
ESC L Convert following word to lower case.
ESC U Convert following word to upper case.
ESC C Capitalize the following word.
The word conversion commands are most useful. ESC L converts the
word after point to lower case, moving past it. Thus, successive
ESC L's convert successive words. ESC U converts to all capitals
instead, while ESC C puts the first letter of the word into upper
case and the rest into lower case. All these commands convert
several words at once if given an argument. They are especially
convenient for converting a large amount of text from all upper
case to mixed case, because you can move through the test using
ESC L, ESC U or ESC C on each word as appropriate.
When given a negative argument, the word case conversion commands
apply to the appropriate number of words before point, but do not
move point. This is convenient when you have just typed a word in
the wrong case. You can give the case conversion command and
April 27, 2013
USD:17-20 JOVE Manual for UNIX Users
continue typing.
If a word case conversion command is given in the middle of a
word, it applies only to the part of the word which follows the
cursor, treating it as a whole word.
The other case conversion functions are case-region-upper and
case-region-lower, which convert everything between point and
mark to the specified case. Point and mark remain unchanged.
8.7. Commands for Fixing Typos
In this section we describe the commands that are especially use-
ful for the times when you catch a mistake on your text after you
have made it, or change your mind while composing text on line.
Rubout Delete last character.
ESC Rubout Kill last word.
C-X Rubout Kill to beginning of sentence.
C-T Transpose two characters.
C-X C-T Transpose two lines.
ESC Minus ESC L Convert last word to lower case.
ESC Minus ESC U Convert last word to upper case.
ESC Minus ESC C Convert last word to lower case with
capital initial.
8.8. Killing Your Mistakes
The Rubout command is the most important correction command. When
used among printing (self-inserting) characters, it can be
thought of as canceling the last character typed.
When your mistake is longer than a couple of characters, it might
be more convenient to use ESC Rubout or C-X Rubout. ESC Rubout
kills back to the start of the last word, and C-X Rubout kills
back to the start of the last sentence. C-X Rubout is particu-
larly useful when you are thinking of what to write as you type
it, in case you change your mind about phrasing. ESC Rubout and
C-X Rubout save the killed text for C-Y and ESC Y to retrieve.
ESC Rubout is often useful even when you have typed only a few
characters wrong, if you know you are confused in your typing and
aren't sure what you typed. At such a time, you cannot correct
with Rubout except by looking at the screen to see what you did.
It requires less thought to kill the whole word and start over
again, especially if the system is heavily loaded.
April 27, 2013
JOVE Manual for UNIX Users USD:17-21
If you were typing a command or command parameters, C-G will
abort the command with no further processing.
8.9. Transposition
The common error of transposing two characters can be fixed with
the C-T (transpose-characters) command. Normally, C-T transposes
the two characters on either side of the cursor and moves the
cursor forward one character. Repeating the command several
times "drags" a character to the right. (Remember that point is
considered to be between two characters, even though the visible
cursor in your terminal is on only one of them.) When given at
the end of a line, rather than switching the last character of
the line with the line separator, which would be useless, C-T
transposes the last two characters on the line. So, if you catch
your transposition error right away, you can fix it with just a
C-T. If you don't catch it so fast, you must move the cursor back
to between the two characters.
To transpose two lines, use the C-X C-T (transpose-lines) com-
mand. The line containing the cursor is exchanged with the line
above it; the cursor is left at the beginning of the line follow-
ing its original position.
8.10. Checking and Correcting Spelling
When you write a paper, you should correct its spelling at some
point close to finishing it. To correct the entire buffer, do ESC
X spell-buffer. This invokes the UNIX spell program, which prints
a list of all the misspelled words. JOVE catches the list and
places it in a JOVE buffer called Spell. You are given an oppor-
tunity to delete from that buffer any words that aren't really
errors; then JOVE looks up each misspelled word and remembers
where it is in the buffer being corrected. Then you can go for-
ward to each misspelled word with C-X C-N (next-error) and back-
ward with C-X C-P (previous-error). See the section entitled
Error Message Parsing.
9. File Handling
The basic unit of stored data is the file. Each program, each
paper, lives usually in its own file. To edit a program or paper,
the editor must be told the name of the file that contains it.
This is called visiting a file. To make your changes to the file
permanent on disk, you must save the file.
9.1. Visiting Files
C-X C-V Visit a file.
C-X C-R Same as C-X C-V.
C-X C-S Save the visited file.
April 27, 2013
USD:17-22 JOVE Manual for UNIX Users
ESC ~ Tell JOVE to forget that the buffer has been
changed.
Visiting a file means copying its contents into JOVE where you
can edit them. JOVE remembers the name of the file you visited.
Unless you use the multiple buffer feature of JOVE, you can only
be visiting one file at a time. The name of the current selected
buffer is visible in the mode line.
The changes you make with JOVE are made in a copy inside JOVE.
The file itself is not changed. The changed text is not permanent
until you save it in a file. The first time you change the text,
an asterisk appears at the end of the mode line; this indicates
that the text contains fresh changes which will be lost unless
you save them.
To visit a file, use the command C-X C-V. Follow the command with
the name of the file you wish to visit, terminated by a Return.
You can abort the command by typing C-G, or edit the filename
with many of the standard JOVE commands (e.g., C-A, C-E, C-F, ESC
F, ESC Rubout). If the filename you wish to visit is similar to
the filename in the mode line (the default filename), you can
type C-R to insert the default and then edit it. If you do type a
Return to finish the command, the new file's text appears on the
screen, and its name appears in the mode line. In addition, its
name becomes the new default filename.
If you wish to save the file and make your changes permanent,
type C-X C-S. After the save is finished, C-X C-S prints the
filename and the number of characters and lines that it wrote to
the file. If there are no changes to save (no asterisk at the end
of the mode line), the file is not saved; otherwise the changes
saved and the asterisk at the end of the mode line will disap-
pear.
What if you want to create a file? Just visit it. JOVE prints
(New file) but aside from that behaves as if you had visited an
existing empty file. If you make any changes and save them, the
file is created. If you visit a nonexistent file unintentionally
(because you typed the wrong filename), go ahead and visit the
file you meant. If you don't save the unwanted file, it is not
created.
If you alter one file and then visit another in the same buffer,
JOVE offers to save the old one. If you answer YES, the old file
is saved; if you answer NO, all the changes you have made to it
since the last save are lost. You should not type ahead after a
file visiting command, because your type-ahead might answer an
unexpected question in a way that you would regret.
Sometimes you will change a buffer by accident. Even if you undo
the effect of the change by editing, JOVE still knows that "the
buffer has been changed". You can tell JOVE to pretend that there
April 27, 2013
JOVE Manual for UNIX Users USD:17-23
have been no changes with the ESC ~ command (make-buffer-
unmodified). This command simply clears the "modified" flag which
says that the buffer contains changes which need to be saved.
Even if the buffer really is changed JOVE will still act as if it
were not.
If JOVE is about to save a file and sees that the date of the
version on disk does not match what JOVE last read or wrote, JOVE
notifies you of this fact, and asks what to do, because this
probably means that something is wrong. For example, somebody
else may have been editing the same file. If this is so, there is
a good chance that your work or his work will be lost if you
don't take the proper steps. You should first find out exactly
what is going on. If you determine that somebody else has modi-
fied the file, save your file under a different filename and then
DIFF the two files to merge the two sets of changes. (The
"patch" command is useful for applying the results of context
diffs directly). Also get in touch with the other person so that
the files don't diverge any further.
9.2. How to Undo Drastic Changes to a File
If you have made several extensive changes to a file and then
change your mind about them, and you haven't yet saved them, you
can get rid of them by reading in the previous version of the
file. You can do this with the C-X C-V command, to visit the
unsaved version of the file.
9.3. Recovering from system/editor crashes
JOVE does not have Auto Save mode, but it does provide a way to
recover your work in the event of a system or editor crash. JOVE
saves information about the files you're editing every so many
changes to a buffer to make recovery possible. Since a rela-
tively small amount of information is involved it's hardly even
noticeable when JOVE does this. The variable "sync-frequency"
says how often to save the necessary information, and the default
is every 50 changes. 50 is a very reasonable number: if you are
writing a paper you will not lose more than the last 50 charac-
ters you typed, which is less than the average length of a line.
9.4. Miscellaneous File Operations
ESC X write-file <file><return> writes the contents of the buffer
into the file <file>, and then visits that file. It can be
thought of as a way of "changing the name" of the file you are
visiting. Unlike C-X C-S, write-file saves even if the buffer has
not been changed. C-X C-W is another way of getting this command.
ESC X insert-file <file><return> inserts the contents of <file>
into the buffer at point, leaving point unchanged before the con-
tents. You can also use C-X C-I to get this command.
April 27, 2013
USD:17-24 JOVE Manual for UNIX Users
ESC X write-region <file><return> writes the region (the text
between point and mark) to the specified file. It does not set
the visited filename. The buffer is not changed.
ESC X append-region <file><return> appends the region to <file>.
The text is added to the end of <file>.
10. Using Multiple Buffers
When we speak of "the buffer", which contains the text you are
editing, we have given the impression that there is only one. In
fact, there may be many of them, each with its own body of text.
At any time only one buffer can be selected and available for
editing, but it isn't hard to switch to a different one. Each
buffer individually remembers which file it is visiting, what
modes are in effect, and whether there are any changes that need
saving.
C-X B Select or create a buffer.
C-X C-F Visit a file in its own buffer.
C-X C-B List the existing buffers.
C-X K Kill a buffer.
Each buffer in JOVE has a single name, which normally doesn't
change. A buffer's name can be any length. The name of the
currently selected buffer and the name of the file visited in it
are visible in the mode line when you are at top level. A newly
started JOVE has only one buffer, named Main, unless you speci-
fied files to edit in the shell command that started JOVE.
10.1. Creating and Selecting Buffers
To create a new buffer, you need only think of a name for it
(say, FOO) and then do C-X B FOO<return>, which is the command
C-X B (select-buffer) followed by the name. This makes a new,
empty buffer (if one by that name didn't previously exist) and
selects it for editing. The new buffer is not visiting any file,
so if you try to save it you will be asked for the filename to
use. Each buffer has its own major mode; the new buffer's major
mode is Text mode by default.
To return to buffer FOO later after having switched to another,
the same command C-X B FOO<return> is used, since C-X B can tell
whether a buffer named FOO exists already or not. C-X B
Main<return> reselects the buffer Main that JOVE started out
with. Just C-X B<return> reselects the previous buffer. Repeated
C-X B<return>'s alternate between the last two buffers selected.
You can also read a file into its own newly created buffer, all
with one command: C-X C-F (find-file), followed by the filename.
The name of the buffer is the last element of the file's
April 27, 2013
JOVE Manual for UNIX Users USD:17-25
pathname. C-F stands for "Find", because if the specified file
already resides in a buffer in your JOVE, that buffer is
reselected. So you need not remember whether you have brought the
file in already or not. A buffer created by C-X C-F can be
reselected later with C-X B or C-X C-F, whichever you find more
convenient. Nonexistent files can be created with C-X C-F just as
they can with C-X C-V.
10.2. Using Existing Buffers
To get a list of all the buffers that exist, do C-X C-B (list-
buffers). Each buffer's type, name, and visited filename is
printed. An asterisk before the buffer name indicates a buffer
which contains changes that have not been saved. The number that
appears at the beginning of a line in a C-X C-B listing is that
buffer's buffer number. You can select a buffer by typing its
number in place of its name. If a buffer with that number doesn't
already exist, a new buffer is created with that number as its
name.
If several buffers have modified text in them, you should save
some of them with C-X C-M (write-modified-files). This finds all
the buffers that need saving and then saves them. Saving the
buffers this way is much easier and more efficient (but more
dangerous) than selecting each one and typing C-X C-S. If you
give C-X C-M an argument, JOVE will ask for confirmation before
saving each buffer.
ESC X rename-buffer <new name><return> changes the name of the
currently selected buffer.
ESC X erase-buffer <buffer name><return> erases the contents of
the <buffer name> without deleting the buffer entirely.
10.3. Killing Buffers
After you use a JOVE for a while, it may fill up with buffers
which you no longer need. Eventually you can reach a point where
trying to create any more results in an "out of memory" or "out
of lines" error. When this happens you will want to kill some
buffers with the C-X K (delete-buffer) command. You can kill the
buffer FOO by doing C-X K FOO<return>. If you type C-X K <return>
JOVE will kill the previously selected buffer. If you try to kill
a buffer that needs saving JOVE will ask you to confirm it.
If you need to kill several buffers, use the command kill-some-
buffers. This prompts you with the name of each buffer and asks
for confirmation before killing that buffer.
11. Controlling the Display
Since only part of a large file will fit on the screen, JOVE
tries to show the part that is likely to be interesting. The
display control commands allow you to see a different part of the
April 27, 2013
USD:17-26 JOVE Manual for UNIX Users
file.
C-L Reposition point at a specified vertical position,
OR clear and redraw the screen with point in the
same place.
C-V Scroll forwards (a screen or a few lines).
ESC V Scroll backwards.
C-Z Scroll forward some lines.
ESC Z Scroll backwards some lines.
The terminal screen is rarely large enough to display all of your
file. If the whole buffer doesn't fit on the screen, JOVE shows a
contiguous portion of it, containing point. It continues to show
approximately the same portion until point moves outside of what
is displayed; then JOVE chooses a new portion centered around the
new point. This is JOVE's guess as to what you are most
interested in seeing, but if the guess is wrong, you can use the
display control commands to see a different portion. The avail-
able screen area through which you can see part of the buffer is
called the window, and the choice of where in the buffer to start
displaying is also called the window. (When there is only one
window, it plus the mode line and the input line take up the
whole screen).
First we describe how JOVE chooses a new window position on its
own. The goal is usually to place point half way down the window.
This is controlled by the variable scroll-step, whose value is
the number of lines above the bottom or below the top of the win-
dow that the line containing point is placed. A value of 0 (the
initial value) means center point in the window.
The basic display control command is C-L (redraw-display). In its
simplest form, with no argument, it tells JOVE to choose a new
window position, centering point half way from the top as usual.
C-L with a positive argument chooses a new window so as to put
point that many lines from the top. An argument of zero puts
point on the very top line. Point does not move with respect to
the text; rather, the text and point move rigidly on the screen.
If point stays on the same line, the window is first cleared and
then redrawn. Thus, two C-L's in a row are guaranteed to clear
the current window. ESC C-L will clear and redraw the entire
screen.
The scrolling commands C-V, ESC V, C-Z, and ESC Z, let you move
the whole display up or down a few lines. C-V (next-page) with an
argument shows you that many more lines at the bottom of the
screen, moving the text and point up together as C-L might. C-V
April 27, 2013
JOVE Manual for UNIX Users USD:17-27
with a negative argument shows you more lines at the top of the
screen, as does ESC V (previous-page) with a positive argument.
To read the buffer a window at a time, use the C-V command with
no argument. It takes the last line at the bottom of the window
and puts it at the top, followed by nearly a whole window of
lines not visible before. Point is put at the top of the window.
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).
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.
11.1. Multiple Windows
JOVE allows you to split the screen into two or more windows and
use them to display parts of different files, or different parts
of the same file.
C-X 2 Divide the current window into two smaller ones.
C-X 1 Delete all windows but the current one.
C-X D Delete current window.
C-X N Switch to the next window.
C-X P Switch to the previous window.
C-X O Same as C-X P.
C-X ^ Make this window bigger.
ESC C-V Scroll the other window.
When using multiple window mode, the text portion of the screen
is divided into separate parts called windows, 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
active; that is the window which the cursor is in. Editing nor-
mally takes place in that window alone. To edit in another win-
dow, you would give a command to move the cursor to the other
window, and then edit there.
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 mode-line-should-
standout to "on" you can have JOVE display the mode-line in
reverse video (assuming your particular terminal has the reverse
April 27, 2013
USD:17-28 JOVE Manual for UNIX Users
video capability).
The command C-X 2 (split-current-window) 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 con-
tain 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.
To return to viewing only one window, use the command C-X 1
(delete-other-windows). 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).
While there is more than one window, you can use C-X N (next-
window) to switch to the next window, and C-X P (previous-window)
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.
Often you will be editing one window while using the other just
for reference. Then, the command ESC C-V (page-next-window) is
very useful. It scrolls the next window, as if you switched to
the next window, typed C-V, and switched back, without your hav-
ing to do all that. With a negative argument, ESC C-V will do an
ESC V in the next window.
When a window splits, both halves are approximately the same
size. You can redistribute the screen space between the windows
with the C-X ^ (grow-window) 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 shrink-window to
make the current window smaller.
11.2. Multiple Windows and Multiple Buffers
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.
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.
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
April 27, 2013
JOVE Manual for UNIX Users USD:17-29
C-V, because if you bring a new file into this buffer, it will
replaced the old file in both 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).
A convenient "combination" command for viewing something in
another window is C-X 4 (window-find). 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 effi-
ciency, and also that C-X 4 works equally well if you are already
using two windows.
12. Processes Under JOVE
Another feature in JOVE is its ability to interact with UNIX in a
useful way. You can run other UNIX commands from JOVE and catch
their output in JOVE buffers. In this chapter we will discuss the
different ways to run and interact with UNIX commands.
12.1. Non-interactive UNIX commands
To run a UNIX command from JOVE 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:
C-X ! who<return>
Then JOVE picks a reasonable buffer in which the output from the
command will be placed. E.g., "who" uses a buffer called who; "ps
alx" uses ps; and "fgrep -n foo *.c" uses fgrep. If JOVE wants to
use a buffer that already exists it first erases the old con-
tents. 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.
Once JOVE 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 JOVE will automatically make another one. Other-
wise, JOVE tries to pick the most convenient window which isn't
the current one.
It's not a good idea to type anything while the command is run-
ning. There are two reasons for this:
(i) JOVE won't see the characters (thus won't execute them)
until the command finishes, so you may forget what you've
typed.
(ii) Although JOVE won't know what you've typed, it will know
April 27, 2013
USD:17-30 JOVE Manual for UNIX Users
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, JOVE won't interpret what
you type until the UNIX command completes, so you're left
with the uneasy feeling you get when you don't know what the
hell the computer is doing*.
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 JOVE while a process is running is the same as typing
C-C when you are outside JOVE, namely the process stops in a
hurry.
When the command finishes, JOVE 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-]) JOVE will print an appropriate
message.
12.2. Limitations of Non-Interactive Processes
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 mail or crypt with C-X ! because there is no way to
provide it with input. Remember that JOVE (not the process in the
window) is listening to your keyboard, and JOVE waits until the
process dies before it looks at what you type.
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 grep commands.
12.3. Interactive Processes - Run a Shell in a Window
Some versions of JOVE- have the capability of running interactive
processes. This is more useful than non-interactive processes for
certain types of jobs:
(i) You can go off and do some editing while the command is run-
ning. This is useful for commands that do sporadic output
and run for fairly long periods of time.
(ii) Unlike non-interactive processes, you can type input to
these. In addition, you can edit what you type with the
_________________________
*This is a bug and should be fixed, but probably won't
be for a while.
- For example, the version provided with 4.3BSD.
April 27, 2013
JOVE Manual for UNIX Users USD:17-31
power of all the JOVE commands before you send the input to
the process. This is a really important feature, and is
especially useful for running a shell in a window.
(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 JOVE's window and buffer mechanisms.
Although we may have given an image of processes being attached
to windows, in fact they are attached to buffers. Therefore, once
an i-process 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 out-
put from the process. You don't have to worry about missing any-
thing when the buffer isn't visible.
12.4. Advantages of Running Processes in JOVE Windows.
There are several advantages to running a shell in a window. What
you type isn't seen immediately by the process; instead JOVE
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
JOVE'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.
Another feature is that you have the entire history of your ses-
sion in a JOVE 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 com-
mands. 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").
12.5. Differences between Normal and I-process Buffers
JOVE behaves differently in several ways when you are in an i-
process 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 list-
April 27, 2013
USD:17-32 JOVE Manual for UNIX Users
processes<return> to get a list of each process and its state. If
your process died abnormally, list-processes may help you figure
out why.
12.6. How to Run a Shell in a Window
Type ESC X i-shell<return> to start up a shell. As with C-X !,
JOVE will create a buffer, called shell-1, 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 shell-1,
and it is considered an i-process buffer.
13. Directory Handling
To save having to use absolute pathnames when you want to edit a
nearby file JOVE allows you to move around the UNIX filesystem
just as the c-shell does. These commands are:
cd dir Change to the specified directory.
pushd [dir] Like cd, but save the old directory on the direc-
tory stack. With no directory argument, simply
exchange the top two directories on the stack and
cd to the new top.
popd Take the current directory off the stack and cd to
the directory now at the top.
dirs Display the contents of the directory stack.
The names and behavior of these commands were chosen to mimic
those in the c-shell.
14. Editing C Programs
This section details the support provided by JOVE for working on
C programs.
14.1. Indentation Commands
To save having to lay out C programs "by hand", JOVE has an idea
of the correct indentation of a line, based on the surrounding
context. When you are in C Mode, JOVE treats tabs specially -
typing a tab at the beginning of a new line means "indent to the
right place". Closing braces are also handled specially, and are
indented to match the corresponding open brace.
14.2. Parenthesis and Brace Matching
To check that parentheses and braces match the way you think they
do, turn on Show Match mode (ESC X show-match-mode). Then, when-
ever you type a close brace or parenthesis, the cursor moves
momentarily to the matching opener, if it's currently visible.
If it's not visible, JOVE displays the line containing the
April 27, 2013
JOVE Manual for UNIX Users USD:17-33
matching opener on the message line.
14.3. C Tags
Often when you are editing a C program, especially someone else's
code, you see a function call and wonder what that function does.
You then search for the function within the current file and if
you're lucky find the definition, finally returning to the origi-
nal spot when you are done. However, if are unlucky, the function
turns out to be external (defined in another file) and you have
to suspend the edit, grep for the function name in every .c that
might contain it, and finally visit the appropriate file.
To avoid this diversion or the need to remember which function is
defined in which file, Berkeley UNIX has a program called
ctags(1), which takes a set of source files and looks for func-
tion definitions, producing a file called tags as its output.
JOVE has a command called C-X T (find-tag) that prompts you for
the name of a function (a tag), looks up the tag reference in the
previously constructed tags file, then visits the file containing
that tag in a new buffer, with point positioned at the definition
of the function. There is another version of this command, namely
find-tag-at-point, that uses the identifier at point.
So, when you've added new functions to a module, or moved some
old ones around, run the ctags program to regenerate the tags
file. JOVE looks in the file specified in the tag-file variable.
The default is "./tags", that is, the tag file in the current
directory. If you wish to use an alternate tag file, you use C-
U C-X T, and JOVE will prompt for a file name. If you find your-
self specifying the same file again and again, you can set tag-
file to that file, and run find-tag with no numeric argument.
To begin an editing session looking for a particular tag, use the
-t tag command line option to JOVE. For example, say you wanted
to look at the file containing the tag SkipChar, you would invoke
JOVE as:
% jove -t SkipChar
14.4. Compiling Your Program
You've typed in a program or altered an existing one and now you
want to run it through the compiler to check for errors. To save
having to suspend the edit, run the compiler, scribble down error
messages, and then resume the edit, JOVE allows you to compile
your code while in the editor. This is done with the C-X C-E
(compile-it) command. If you run compile-it with no argument it
runs the UNIX make program into a buffer; If you need a special
command or want to pass arguments to make, run compile-it with
any argument (C-U is good enough) and you will be prompted for
the command to execute.
April 27, 2013
USD:17-34 JOVE Manual for UNIX Users
If any error messages are produced, they are treated specially by
JOVE. That treatment is the subject of the next section.
14.5. Error Message Parsing and Spelling Checking
JOVE knows how to interpret the error messages from many UNIX
commands; In particular, the messages from cc, grep and lint can
be understood. After running the compile-it command, the parse-
errors command is automatically executed, and any errors found
are displayed in a new buffer. The files whose names are found in
parsing the error messages are each brought into JOVE buffers and
the point is positioned at the first error in the first file. The
commands current-error, C-X C-N (next-error), and C-X C-P
(previous-error) can be used to traverse the list of errors.
If you already have a file called errs containing, say, c com-
piler messages then you can get JOVE to interpret the messages by
invoking it as:
% jove -p errs
JOVE has a special mechanism for checking the the spelling of a
document; It runs the UNIX spell program into a buffer. You then
delete from this buffer all those words that are not spelling
errors and then JOVE runs the parse-spelling-errors command to
yield a list of errors just as in the last section.
15. Simple Customization
15.1. Major Modes
To help with editing particular types of file, say a paper or a C
program, JOVE has several major modes. These are as follows:
15.1.1. Text mode
This is the default major mode. Nothing special is done.
15.1.2. C mode
This mode affects the behavior of the tab and parentheses charac-
ters. Instead of just inserting the tab, JOVE determines where
the text "ought" to line up for the C language and tabs to that
position instead. The same thing happens with the close brace
and close parenthesis; they are tabbed to the "right" place and
then inserted. Using the auto-execute-command command, you can
make JOVE enter C Mode whenever you edit a file whose name ends
in .c.
15.1.3. Lisp mode
This mode is analogous to C Mode, but performs the indentation
April 27, 2013
JOVE Manual for UNIX Users USD:17-35
needed to lay out Lisp programs properly. Note also the grind-s-
expr command that prettyprints an s-expression and the kill-
mode-expression command.
15.2. Minor Modes
In addition to the major modes, JOVE has a set of minor modes.
These are as follows:
15.2.1. Auto Indent
In this mode, JOVE indents each line the same way as that above
it. That is, the Return key in this mode acts as the Linefeed
key ordinarily does.
15.2.2. Show Match
Move the cursor momentarily to the matching opening parenthesis
when a closing parenthesis is typed.
15.2.3. Auto Fill
In Auto Fill mode, a newline is automatically inserted when the
line length exceeds the right margin. This way, you can type a
whole paper without having to use the Return key.
15.2.4. Over Write
In this mode, any text typed in will replace the previous con-
tents. (The default is for new text to be inserted and "push" the
old along.) This is useful for editing an already-formatted
diagram in which you want to change some things without moving
other things around on the screen.
15.2.5. Word Abbrev
In this mode, every word you type is compared to a list of word
abbreviations; whenever you type an abbreviation, it is replaced
by the text that it abbreviates. This can save typing if a par-
ticular word or phrase must be entered many times. The abbrevia-
tions and their expansions are held in a file that looks like:
abbrev:phrase
This file can be set up in your ~/.joverc with the read-word-
abbrev-file command. Then, whenever you are editing a buffer in
Word Abbrev mode, JOVE checks for the abbreviations you've given.
See also the commands read-word-abbrev-file, write-word-abbrev-
file, edit-word-abbrevs, define-global-word-abbrev, define-mode-
word-abbrev, and bind-macro-to-word-abbrev, and the variable
auto-case-abbrev.
April 27, 2013
USD:17-36 JOVE Manual for UNIX Users
15.3. Variables
JOVE can be tailored to suit your needs by changing the values of
variables. A JOVE variable can be given a value with the set com-
mand, and its value displayed with the print command.
The variables JOVE understands are listed along with the commands
in the alphabetical list at the end of this document.
15.4. Key Re-binding
Many of the commands built into JOVE are not bound to specific
keys. The command handler in JOVE is used to invoke these com-
mands and is activated by the execute-extended-command command
(ESC X). When the name of a command typed in is unambiguous, that
command will be executed. Since it is very slow to have to type
in the name of each command every time it is needed, JOVE makes
it possible to bind commands to keys. When a command is bound to
a key any future hits on that key will invoke that command. All
the printing characters are initially bound to the command self-
insert. Thus, typing any printing character causes it to be
inserted into the text. Any of the existing commands can be bound
to any key. (A key may actually be a control character or an
escape sequence as explained previously under Command Input Con-
ventions).
Since there are more commands than there are keys, two keys are
treated as prefix commands. When a key bound to one of the prefix
commands is typed, the next character typed is interpreted on the
basis that it was preceded by one of the prefix keys. Initially
^X and ESC are the prefix keys and many of the built in commands
are initially bound to these "two stroke" keys. (For historical
reasons, the Escape key is often referred to as "Meta").
15.5. Keyboard Macros
Although JOVE has many powerful commands, you often find that you
have a task that no individual command can do. JOVE allows you to
define your own commands from sequences of existing ones "by
example"; Such a sequence is termed a macro. The procedure is as
follows: First you type the start-remembering command, usually
bound to C-X (. Next you "perform" the commands which as they are
being executed are also remembered, which will constitute the
body of the macro. Then you give the stop-remembering command,
usually bound to C-X ). You now have a keyboard macro. To run
this command sequence again, use the command execute-keyboard-
macro, usually bound to C-X E. You may find this bothersome to
type and re-type, so there is a way to bind the macro to a key.
First, you must give the keyboard macro a name using the name-
keyboard-macro command. Then the binding is made with the bind-
macro-to-key command. We're still not finished because all this
hard work will be lost if you leave JOVE. What you do is to save
your macros into a file with the write-macros-to-file command.
There is a corresponding read-macros-from-file command to
April 27, 2013
JOVE Manual for UNIX Users USD:17-37
retrieve your macros in the next editing session.
15.6. Initialization Files
Users will likely want to modify the default key bindings to
their liking. Since it would be quite annoying to have to set up
the bindings each time JOVE is started up, JOVE has the ability
to read in a "startup" file. Whenever JOVE is started, it reads
commands from the file .joverc in the user's home directory.
These commands are read as if they were typed to the command
handler (ESC X) during an edit. There can be only one command per
line in the startup file. If there is a file
/usr/lib/jove/joverc, then this file will be read before the
user's .joverc file. This can be used to set up a system-wide
default startup mode for JOVE that is tailored to the needs of
that system.
The source command can be used to read commands from a specified
file at any time during an editing session, even from inside the
.joverc file. This means that a macro can be used to change the
key bindings, e.g., to enter a mode, by reading from a specified
file which contains all the necessary bindings.
April 27, 2013
USD:17-38 JOVE Manual for UNIX Users
16. Alphabetical List of Commands and Variables
16.1. Prefix-1 (Escape)
This reads the next character and runs a command based on the
character typed. If you wait for more than a second or so before
typing the next character, the message "ESC" will be printed on
the message line to remind you that JOVE is waiting for another
character.
16.2. Prefix-2 (C-X)
This reads the next character and runs a command based on the
character typed. If you wait for more than a second or so before
typing another character, the message "C-X" will be printed on
the message line to remind you that JOVE is waiting for another
character.
16.3. Prefix-3 (Not Bound)
This reads the next character and runs a command based on the
character typed. If you wait for more than a second or so before
typing the next character, the character that invoked Prefix-3
will be printed on the message line to remind you that JOVE is
waiting for another one.
16.4. allow-^S-and-^Q (variable)
This variable, when set, tells JOVE that your terminal does not
need to use the characters C-S and C-Q for flow control, and that
it is okay to bind things to them. This variable should be set
depending upon what kind of terminal you have.
16.5. allow-bad-filenames (variable)
If set, this variable permits filenames to contain "bad" charac-
ters such as those from the set *&%!"`[]{}. These files are
harder to deal with, because the characters mean something to the
shell. The default value is "off".
16.6. append-region (Not Bound)
This appends the region to a specified file. If the file does
not already exist it is created.
16.7. apropos (Not Bound)
This types out all the commands, variables and macros with the
specific keyword in their names. For each command and macro that
contains the string, the key sequence that can be used to execute
the command or macro is printed; with variables, the current
value is printed. So, to find all the commands that are related
to windows, you type
April 27, 2013
JOVE Manual for UNIX Users USD:17-39
ESC X apropos window<Return>
16.8. auto-case-abbrev (variable)
When this variable is on (the default), word abbreviations are
adjusted for case automatically. For example, if "jove" were the
abbreviation for "jonathan's own version of emacs", then typing
"jove" would give you "jonathan's own version of emacs", typing
"Jove" would give you "Jonathan's own version of emacs", and typ-
ing "JOVE" would give you "Jonathan's Own Version of Emacs".
When this variable is "off", upper and lower case are dis-
tinguished when looking for the abbreviation, i.e., in the exam-
ple above, "JOVE" and "Jove" would not be expanded unless they
were defined separately.
16.9. auto-execute-command (Not Bound)
This tells JOVE to execute a command automatically when a file
whose name matches a specified pattern is visited. The first
argument is the command you want executed and the second is a
regular expression pattern that specifies the files that apply.
For example, if you want to be in show-match-mode when you edit C
source files (that is, files that end with ".c" or ".h") you can
type
ESC X auto-execute-command show-match-mode .*.[ch]$
16.10. auto-execute-macro (Not Bound)
This is like auto-execute-command except you use it to execute
macros automatically instead of built-in commands.
16.11. auto-fill-mode (Not Bound)
This turns on Auto Fill mode (or off if it's currently on) in the
selected buffer. When JOVE is in Auto Fill mode it automatically
breaks lines for you when you reach the right margin so you don't
have to remember to hit Return. JOVE uses 78 as the right margin
but you can change that by setting the variable right-margin to
another value. See the set command to learn how to do this.
16.12. auto-indent-mode (Not Bound)
This turns on Auto Indent mode (or off if it's currently on) in
the selected buffer. When JOVE is in Auto Indent mode, Return
indents the new line to the same position as the line you were
just on. This is useful for lining up C code (or any other
language (but what else is there besides C?)). This is out of
date because of the new command called newline-and-indent but it
remains because of several "requests" on the part of, uh,
enthusiastic and excitable users, that it be left as it is.
April 27, 2013
USD:17-40 JOVE Manual for UNIX Users
16.13. backward-character (C-B)
This moves point backward over a single character. If point is
at the beginning of the line it moves to the end of the previous
line.
16.14. backward-paragraph (ESC [)
This moves point backward to the beginning of the current or pre-
vious paragraph. Paragraphs are bounded by lines that begin with
a Period or Tab, or by blank lines; a change in indentation may
also signal a break between paragraphs, except that JOVE allows
the first line of a paragraph to be indented differently from the
other lines.
16.15. backward-s-expression (ESC C-B)
This moves point backward over a s-expression. It is just like
forward-s-expression with a negative argument.
16.16. backward-sentence (ESC A)
This moves point backward to the beginning of the current or pre-
vious sentence. JOVE considers the end of a sentence to be the
characters ".", "!" or "?" followed by a Return or by one or more
spaces.
16.17. backward-word (ESC B)
This moves point backward to the beginning of the current or pre-
vious word.
16.18. bad-filename-extensions (variable)
This contains a list of words separated by spaces which are to be
considered bad filename extensions, and so will not be counted in
filename completion. The default is ".o" so if you have jove.c
and jove.o in the same directory, the filename completion will
not complain of an ambiguity because it will ignore jove.o.
16.19. beginning-of-file (ESC <)
This moves point backward to the beginning of the buffer. This
sometimes prints the "Point Pushed" message. If the top of the
buffer isn't on the screen JOVE will set the mark so you can go
back to where you were if you want.
16.20. beginning-of-line (C-A)
This moves point to the beginning of the current line.
16.21. beginning-of-window (ESC ,)
This moves point to the beginning of the current window. The
April 27, 2013
JOVE Manual for UNIX Users USD:17-41
sequence "ESC ," is the same as "ESC <" (beginning of file)
except without the shift key on the "<", and can thus can easily
be remembered.
16.22. bind-to-key (Not Bound)
This attaches a key to an internal JOVE command so that future
hits on that key invoke that command. For example, to make "C-W"
erase the previous word, you type "ESC X bind-to-key kill-
previous-word C-W".
16.23. bind-macro-to-key (Not Bound)
This is like bind-to-key except you use it to attach keys to
named macros.
16.24. bind-macro-to-word-abbrev (Not Bound)
This command allows you to bind a macro to a previously defined
word abbreviation. Whenever you type the abbreviation, it will
first be expanded as an abbreviation, and then the macro will be
executed. Note that if the macro moves around, you should set
the mark first (C-@) and then exchange the point and mark last
(C-X C-X).
16.25. buffer-position (Not Bound)
This displays the current file name, current line number, total
number of lines, percentage of the way through the file, and the
position of the cursor in the current line.
16.26. c-mode (Not Bound)
This turns on C mode in the currently selected buffer. This is
one of currently four possible major modes: Fundamental, Text,
C, Lisp. When in C or Lisp mode, Tab, "}", and ")" behave a lit-
tle differently from usual: They are indented to the "right"
place for C (or Lisp) programs. In JOVE, the "right" place is
simply the way the author likes it (but I've got good taste).
16.27. case-character-capitalize (Not Bound)
This capitalizes the character after point, i.e., the character
undo the cursor. If a negative argument is supplied that many
characters before point are upper cased.
16.28. case-ignore-search (variable)
This variable, when set, tells JOVE to treat upper and lower case
as the same when searching. Thus "jove" and "JOVE" would match,
and "JoVe" would match either. The default value of this vari-
able is "off".
April 27, 2013
USD:17-42 JOVE Manual for UNIX Users
16.29. case-region-lower (Not Bound)
This changes all the upper case letters in the region to their
lower case equivalent.
16.30. case-region-upper (Not Bound)
This changes all the lower case letters in the region to their
upper case equivalent.
16.31. case-word-capitalize (ESC C)
This capitalizes the current word by making the current letter
upper case and making the rest of the word lower case. Point is
moved to the end of the word. If point is not positioned on a
word it is first moved forward to the beginning of the next word.
If a negative argument is supplied that many words before point
are capitalized. This is useful for correcting the word just
typed without having to move point to the beginning of the word
yourself.
16.32. case-word-lower (ESC L)
This lower-cases the current word and leaves point at the end of
it. If point is in the middle of a word the rest of the word is
converted. If point is not in a word it is first moved forward
to the beginning of the next word. If a negative argument is
supplied that many words before point are converted to lower
case. This is useful for correcting the word just typed without
having to move point to the beginning of the word yourself.
16.33. case-word-upper (ESC U)
This upper-cases the current word and leaves point at the end of
it. If point is in the middle of a word the rest of the word is
converted. If point is not in a word it is first moved forward
to the beginning of the next word. If a negative argument is
supplied that many words before point are converted to upper
case. This is useful for correcting the word just typed without
having to move point to the beginning of the word yourself.
16.34. character-to-octal-insert (Not Bound)
This inserts a Back-slash followed by the ascii value of the next
character typed. For example, "C-G" inserts the string "\007".
16.35. cd (Not Bound)
This changes the current directory.
16.36. clear-and-redraw (ESC C-L)
This clears the entire screen and redraws all the windows. Use
this when JOVE gets confused about what's on the screen, or when
April 27, 2013
JOVE Manual for UNIX Users USD:17-43
the screen gets filled with garbage characters or output from
another program.
16.37. comment-format (variable)
This variable tells JOVE how to format your comments when you run
the command fill-comment. Its format is this:
<open pattern>%!<line header>%c<line trailer>%!<close pattern>
The %!, %c, and %! must appear in the format; everything else is
optional. A newline (represented by %n) may appear in the open or
close patterns. %% is the representation for %. The default
comment format is for C comments. See fill-comment for more.
16.38. compile-it (C-X C-E)
This compiles your program by running the UNIX command "make"
into a buffer, and automatically parsing the error messages that
are created (if any). See the parse-errors and parse-special-
errors commands. To compile a C program without "make", use "C-U
C-X C-E" and JOVE will prompt for a command to run instead of
make. (And then the command you type will become the default
command.) You can use this to parse the output from the C com-
piler or the "grep" or "lint" programs.
16.39. continue-process (Not Bound)
This sends SIGCONT to the current interactive process, if the
process is currently stopped.
16.40. copy-region (ESC W)
This takes all the text in the region and copies it onto the kill
ring buffer. This is just like running kill-region followed by
the yank command. See the kill-region and yank commands.
16.41. current-error (Not Bound)
This moves to the current error in the list of parsed errors.
See the next-error and previous-error commands for more detailed
information.
16.42. date (Not Bound)
This prints the date on the message line.
16.43. define-mode-word-abbrev (Not Bound)
This defines a mode-specific abbreviation.
16.44. define-global-word-abbrev (Not Bound)
This defines a global abbreviation.
April 27, 2013
USD:17-44 JOVE Manual for UNIX Users
16.45. delete-blank-lines (C-X C-O)
This deletes all the blank lines around point. This is useful
when you previously opened many lines with "C-O" and now wish to
delete the unused ones.
16.46. delete-buffer (C-X K)
This deletes a buffer and frees up all the memory associated with
it. Be careful! Once a buffer has been deleted it is gone for-
ever. JOVE will ask you to confirm if you try to delete a buffer
that needs saving. This command is useful for when JOVE runs out
of space to store new buffers.
16.47. delete-macro (Not Bound)
This deletes a macro from the list of named macros. It is an
error to delete the keyboard-macro. Once the macro is deleted it
is gone forever. If you are about to save macros to a file and
decide you don't want to save a particular one, delete it.
16.48. delete-next-character (C-D)
This deletes the character that's just after point (that is, the
character under the cursor). If point is at the end of a line,
the line separator is deleted and the next line is joined with
the current one.
16.49. delete-other-windows (C-X 1)
This deletes all the other windows except the current one. This
can be thought of as going back into One Window mode.
16.50. delete-previous-character (Rubout)
This deletes the character that's just before point (that is, the
character before the cursor). If point is at the beginning of
the line, the line separator is deleted and that line is joined
with the previous one.
16.51. delete-white-space (ESC \)
This deletes all the Tabs and Spaces around point.
16.52. delete-current-window (C-X D)
This deletes the current window and moves point into one of the
remaining ones. It is an error to try to delete the only remain-
ing window.
16.53. describe-bindings (Not Bound)
This types out a list containing each bound key and the command
that gets invoked every time that key is typed. To make a wall
April 27, 2013
JOVE Manual for UNIX Users USD:17-45
chart of JOVE commands, set send-typeout-to-buffer to "on" and
JOVE will store the key bindings in a buffer which you can save
to a file and then print.
16.54. describe-command (Not Bound)
This prints some info on a specified command.
16.55. describe-key (Not Bound)
This waits for you to type a key and then tells the name of the
command that gets invoked every time that key is hit. Once you
have the name of the command you can use the describe-command
command to find out exactly what it does.
16.56. describe-variable (Not Bound)
This prints some info on a specified variable.
16.57. digit (ESC [0-9])
This reads a numeric argument. When you type "ESC" followed by a
number, "digit" keeps reading numbers until you type some other
command. Then that command is executes with the numeric argument
you specified.
16.58. digit-1 (Not Bound)
This pretends you typed "ESC 1". This is useful for terminals
that have keypads that send special sequences for numbers typed
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
16.59. digit-2 (Not Bound)
This pretends you typed "ESC 2". This is useful for terminals
that have keypads that send special sequences for numbers typed
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
16.60. digit-3 (Not Bound)
This pretends you typed "ESC 3". This is useful for terminals
that have keypads that send special sequences for numbers typed
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
16.61. digit-4 (Not Bound)
This pretends you typed "ESC 4". This is useful for terminals
that have keypads that send special sequences for numbers typed
April 27, 2013
USD:17-46 JOVE Manual for UNIX Users
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
16.62. digit-5 (Not Bound)
This pretends you typed "ESC 5". This is useful for terminals
that have keypads that send special sequences for numbers typed
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
16.63. digit-6 (Not Bound)
This pretends you typed "ESC 6". This is useful for terminals
that have keypads that send special sequences for numbers typed
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
16.64. digit-7 (Not Bound)
This pretends you typed "ESC 7". This is useful for terminals
that have keypads that send special sequences for numbers typed
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
16.65. digit-8 (Not Bound)
This pretends you typed "ESC 8". This is useful for terminals
that have keypads that send special sequences for numbers typed
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
16.66. digit-9 (Not Bound)
This pretends you typed "ESC 9". This is useful for terminals
that have keypads that send special sequences for numbers typed
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
16.67. digit-0 (Not Bound)
This pretends you typed "ESC 0". This is useful for terminals
that have keypads that send special sequences for numbers typed
on the keypad as opposed to numbers typed from the keyboard.
This can save having type "ESC" when you want to specify an argu-
ment.
April 27, 2013
JOVE Manual for UNIX Users USD:17-47
16.68. dirs (Not Bound)
This prints out the directory stack. See the "cd", "pushd",
"popd" commands for more info.
16.69. disable-biff (variable)
When this is set, JOVE disables biff when you're editing and
enables it again when you get out of JOVE, or when you pause to
the parent shell or push to a new shell. (This means arrival of
new mail will not be immediately apparent but will not cause
indiscriminate writing on the display). The default is "off".
16.70. dstop-process (Not Bound)
Send the "dsusp" character to the current process. This is the
character that suspends a process on the next read from the ter-
minal. Most people have it set to C-Y. This only works if you
have the interactive process feature, and if you are in a buffer
bound to a process.
16.71. edit-word-abbrevs (Not Bound)
This creates a buffer with a list of each abbreviation and the
phrase it expands into, and enters a recursive edit to let you
change the abbreviations or add some more. The format of this
list is "abbreviation:phrase" so if you add some more you should
follow that format. It's probably simplest just to copy some
already existing abbreviations and edit them. When you are done
you type "C-X C-C" to exit the recursive edit.
16.72. end-of-file (ESC >)
This moves point forward to the end of the buffer. This some-
times prints the "Point Pushed" message. If the end of the
buffer isn't on the screen JOVE will set the mark so you can go
back to where you were if you want.
16.73. end-of-line (C-E)
This moves point to the end of the current line. If the line is
too long to fit on the screen JOVE will scroll the line to the
left to make the end of the line visible. The line will slide
back to its normal position when you move backward past the left-
most visible character or when you move off the line altogether.
16.74. end-of-window (ESC .)
This moves point to the last character in the window.
16.75. eof-process (Not Bound)
Sends EOF to the current interactive process. This only works on
versions of JOVE which run under 4.2-3 BSD VAX UNIX. You can't
April 27, 2013
USD:17-48 JOVE Manual for UNIX Users
send EOF to processes on the 2.9 BSD PDP-11 UNIX.
16.76. erase-buffer (Not Bound)
This erases the contents of the specified buffer. This is like
delete-buffer except it only erases the contents of the buffer,
not the buffer itself. If you try to erase a buffer that needs
saving you will be asked to confirm it.
16.77. error-window-size (variable)
This is the percentage of the screen to use for the error-window
on the screen. When you execute compile-it, error-window-size
percent of the screen will go to the error window. If the window
already exists and is a different size, it is made to be this
size. The default value is 20%.
16.78. exchange-point-and-mark (C-X C-X)
This moves point to mark and makes mark the old point. This is
for quickly moving from one end of the region to another.
16.79. execute-named-command (ESC X)
This is the way to execute a command that isn't bound to any key.
When you are prompted with ": " you can type the name of the com-
mand. You don't have to type the entire name. Once the command
is unambiguous you can type Space and JOVE will fill in the rest
for you. If you are not sure of the name of the command, type "?"
and JOVE will print a list of all the commands that you could
possibly match given what you've already typed. If you don't
have any idea what the command's name is but you know it has
something to do with windows (for example), you can do "ESC X
apropos window" and JOVE will print a list of all the commands
that are related to windows. If you find yourself constantly exe-
cuting the same commands this way you probably want to bind them
to keys so that you can execute them more quickly. See the
bind-to-key command.
16.80. execute-keyboard-macro (C-X E)
This executes the keyboard macro. If you supply a numeric argu-
ment the macro is executed that many times.
16.81. execute-macro (Not Bound)
This executes a specified macro. If you supply a numeric argu-
ment the macro is executed that many times.
16.82. exit-jove (C-X C-C)
This exits JOVE. If any buffers need saving JOVE will print a
warning message and ask for confirmation. If you leave without
saving your buffers all your work will be lost. If you made a
April 27, 2013
JOVE Manual for UNIX Users USD:17-49
mistake and really do want to exit then you can. If you are in a
recursive editing level exit-jove will return you from that.
16.83. file-creation-mode (variable)
This variable has an octal value. It contains the mode (see
chmod(1) ) with which files should be created. This mode gets
modified by your current umask setting (see umask(1) ). The
default value is usually 0666 or 0644.
16.84. files-should-end-with-newline (variable)
This variable indicates that all files should always have a new-
line at the end. This is often necessary for line printers and
the like. When set, if JOVE is writing a file whose last charac-
ter is not a newline, it will add one automatically.
16.85. fill-comment (Not Bound)
This command fills in your C comments to make them pretty and
readable. This filling is done according the variable comment-
format.
/*
* the default format makes comments like this.
*/
This can be changed by changing the format variable. Other
languages may be supported by changing the format variable
appropriately. The formatter looks backwards from dot for an
open comment symbol. If found, all indentation is done relative
the position of the first character of the open symbol. If there
is a matching close symbol, the entire comment is formatted. If
not, the region between dot and the open symbol is reformatted.
16.86. fill-paragraph (ESC J)
This rearranges words between lines so that all the lines in the
current paragraph extend as close to the right margin as possi-
ble, ensuring that none of the lines will be greater than the
right margin. The default value for right-margin is 78, but can
be changed with the set and right-margin-here commands. JOVE has
a complicated algorithm for determining the beginning and end of
the paragraph. In the normal case JOVE will give all the lines
the same indent as they currently have, but if you wish to force
a new indent you can supply a numeric argument to fill-paragraph
(e.g., by typing C-U ESC J) and JOVE will indent each line to the
column specified by the left-margin variable. See also the
left-margin variable and left-margin-here command.
16.87. fill-region (Not Bound)
This is like fill-paragraph, except it operates on a region
instead of just a paragraph.
April 27, 2013
USD:17-50 JOVE Manual for UNIX Users
16.88. filter-region (Not Bound)
This sends the text in the region to a UNIX command, and replaces
the region with the output from that command. For example, if
you are lazy and don't like to take the time to write properly
indented C code, you can put the region around your C file and
filter-region it through cb, the UNIX C beautifier. If you have
a file that contains a bunch of lines that need to be sorted you
can do that from inside JOVE too, by filtering the region through
the sort UNIX command. Before output from the command replaces
the region JOVE stores the old text in the kill ring, so if you
are unhappy with the results you can easily get back the old text
with "C-Y".
16.89. find-file (C-X C-F)
This visits a file into its own buffer and then selects that
buffer. If you've already visited this file in another buffer,
that buffer is selected. If the file doesn't yet exist, JOVE
will print "(New file)" so that you know.
16.90. find-tag (C-X T)
This finds the file that contains the specified tag. JOVE looks
up tags by default in the "tags" file in the current directory.
You can change the default tag name by setting the tag-file vari-
able to another name. If you specify a numeric argument to this
command, you will be prompted for a tag file. This is a good way
to specify another tag file without changing the default. If the
tag cannot be found the error is reported and point stays where
it is.
16.91. find-tag-at-point (Not Bound)
This finds the file that contains the tag that point is currently
on. See find-tag.
16.92. first-non-blank (ESC M)
This moves point back to the indent of the current line.
16.93. forward-character (C-F)
This moves forward over a single character. If point is at the
end of the line it moves to the beginning of the next one.
16.94. forward-paragraph (ESC ])
This moves point forward to the end of the current or next para-
graph. Paragraphs are bounded by lines that begin with a Period
or Tab, or by blank lines; a change in indentation may also sig-
nal a break between paragraphs, except that JOVE allows the first
line of a paragraph to be indented differently from the other
lines.
April 27, 2013
JOVE Manual for UNIX Users USD:17-51
16.95. forward-s-expression (ESC C-F)
This moves point forward over a s-expression. If the first sig-
nificant character after point is "(", this moves past the match-
ing ")". If the character begins an identifier, this moves just
past it. This is mode dependent, so this will move over atoms in
LISP mode and C identifiers in C mode. JOVE also matches "{".
16.96. forward-sentence (ESC E)
This moves point forward to the end of the current or next sen-
tence. JOVE considers the end of a sentence to be the characters
".", "!" or "?" followed by a Return, or one or more spaces.
16.97. forward-word (ESC F)
This moves point forward to the end of the current or next word.
16.98. fundamental-mode (Not Bound)
This sets the major mode to Fundamental. This affects what JOVE
considers as characters that make up words. For instance,
Single-quote is not part of a word in Fundamental mode, but is in
Text mode.
16.99. goto-line (ESC G)
If a numeric argument is supplied point moves to the beginning of
that line. If no argument is supplied, point remains where it
is. This is so you don't lose your place unintentionally, by
accidentally hitting the "G" instead of "F".
16.100. grind-s-expr (Not Bound)
When point is positioned on a "(", this re-indents that LISP
expression.
16.101. grow-window (C-X ^)
This makes the current window one line bigger. This only works
when there is more than one window and provided there is room to
change the size.
16.102. paren-flash () } ])
This handles the C mode curly brace indentation, the Lisp mode
paren indentation, and the Show Match mode paren/curly
brace/square bracket flashing.
16.103. handle-tab (Tab)
This handles indenting to the "right" place in C and Lisp mode,
and just inserts itself in Text mode.
April 27, 2013
USD:17-52 JOVE Manual for UNIX Users
16.104. i-search-forward (Not Bound)
Incremental search. Like search-forward except that instead of
prompting for a string and searching for that string all at once,
it accepts the string one character at a time. After each char-
acter you type as part of the search string, it searches for the
entire string so far. When you like what it found, type the
Return key to finish the search. You can take back a character
with Rubout and the search will back up to the position before
that character was typed. C-G aborts the search.
16.105. i-search-reverse (Not Bound)
Incremental search. Like search-reverse except that instead of
prompting for a string and searching for that string all at once,
it accepts the string one character at a time. After each char-
acter you type as part of the search string, it searches for the
entire string so far. When you like what it found, type the
Return key to finish the search. You can take back a character
with Rubout and the search will back up to the position before
that character was typed. C-G aborts the search.
16.106. insert-file (C-X C-I)
This inserts a specified file into the current buffer at point.
Point is positioned at the beginning of the inserted file.
16.107. internal-tabstop (variable)
The number of spaces JOVE should print when it displays a tab
character. The default value is 8.
16.108. interrupt-process (Not Bound)
This sends the interrupt character (usually C-C) to the interac-
tive process in the current buffer. This is only for versions of
JOVE that have the interactive processes feature. This only
works when you are inside a buffer that's attached to a process.
16.109. i-shell (Not Bound)
This starts up an interactive shell in a window. JOVE uses
"shell-1" as the name of the buffer in which the interacting
takes place. See the manual for information on how to use
interactive processes.
16.110. i-shell-command (Not Bound)
This is like shell-command except it lets you continue with your
editing while the command is running. This is really useful for
long running commands with sporadic output. See the manual for
information on how to use interactive processes.
April 27, 2013
JOVE Manual for UNIX Users USD:17-53
16.111. kill-next-word (ESC D)
This kills the text from point to the end of the current or next
word.
16.112. kill-previous-word (ESC Rubout)
This kills the text from point to the beginning of the current or
previous word.
16.113. kill-process (Not Bound)
This command prompts for a buffer name or buffer number (just as
select-buffer does) and then sends the process in that buffer a
kill signal (9).
16.114. kill-region (C-W)
This deletes the text in the region and saves it on the kill
ring. Commands that delete text but save it on the kill ring all
have the word "kill" in their names. Type "C-Y" to yank back the
most recent kill.
16.115. kill-s-expression (ESC C-K)
This kills the text from point to the end of the current or next
s-expression.
16.116. kill-some-buffers (Not Bound)
This goes through all the existing buffers and asks whether or
not to kill them. If you decide to kill a buffer, and it turns
out that the buffer is modified, JOVE will offer to save it
first. This is useful for when JOVE runs out of memory to store
lines (this only happens on PDP-11's) and you have lots of
buffers that you are no longer using.
16.117. kill-to-beginning-of-sentence (C-X Rubout)
This kills from point to the beginning of the current or previous
sentence.
16.118. kill-to-end-of-line (C-K)
This kills from point to the end of the current line. When point
is at the end of the line the line separator is deleted and the
next line is joined with current one. If a numeric argument is
supplied that many lines are killed; if the argument is negative
that many lines before point are killed; if the argument is zero
the text from point to the beginning of the line is killed.
16.119. kill-to-end-of-sentence (ESC K)
This kills from point to the end of the current or next sentence.
April 27, 2013
USD:17-54 JOVE Manual for UNIX Users
If a negative numeric argument is supplied it kills from point to
the beginning of the current or previous sentence.
16.120. left-margin (variable)
This is how far lines should be indented when auto-indent mode is
on, or when the newline-and-indent command is run (usually by
typing LineFeed). It is also used by fill-paragraph and auto-
fill mode. If the value is zero (the default) then the left mar-
gin is determined from the surrounding lines.
16.121. left-margin-here (Not Bound)
This sets the left-margin variable to the current position of
point. This is an easy way to say, "Make the left margin begin
here," without having to count the number of spaces over it actu-
ally is.
16.122. lisp-mode (Not Bound)
This turns on Lisp mode. Lisp mode is one of four mutually
exclusive major modes: Fundamental, Text, C, and Lisp. In Lisp
mode, the characters Tab and ) are treated specially, similar to
the way they are treated in C mode. Also, Auto Indent mode is
affected, and handled specially.
16.123. list-buffers (C-X C-B)
This types out a list containing various information about each
buffer. Right now that list looks like this:
(* means the buffer needs saving)
NO Lines Type Name File
-- ----- ---- ---- ----
1 1 File Main [No file]
2 1 Scratch * Minibuf [No file]
3 519 File * commands.doc commands.doc
The first column lists the buffer's number. When JOVE prompts
for a buffer name you can either type in the full name, or you
can simply type the buffer's number. The second column is the
number of lines in the buffer. The third says what type of
buffer. There are four types: "File", "Scratch", "Process", "I-
Process". "File" is simply a buffer that holds a file; "Scratch"
is for buffers that JOVE uses internally; "Process" is one that
holds the output from a UNIX command; "I-Process" is one that has
an interactive process attached to it. The next column contains
the name of the buffer. And the last column is the name of the
file that's attached to the buffer. In this case, both Minibuf
and commands.doc have been changed but not yet saved. In fact
Minibuf won't be saved since it's an internal JOVE buffer that I
don't even care about.
April 27, 2013
JOVE Manual for UNIX Users USD:17-55
16.124. list-processes (Not Bound)
This makes a list somewhat like "list-buffers" does, except its
list consists of the current interactive processes. Right now
the list looks like this:
Buffer Status Command name
------ ------ ------- ----
shell-1 Running i-shell
fgrep Done fgrep -n Buffer *.c
The first column has the name of the buffer to which the process
is attached. The second has the status of the process; if a pro-
cess has exited normally the status is "Done" as in fgrep; if the
process exited with an error the status is "Exit N" where N is
the value of the exit code; if the process was killed by some
signal the status is the name of the signal that was used; other-
wise the process is running. The last column is the name of the
command that is being run.
16.125. mailbox (variable)
Set this to the full pathname of your mailbox. JOVE will look
here to decide whether or not you have any unread mail. This
defaults to /usr/spool/mail/$USER, where $USER is set to your
login name.
16.126. mail-check-frequency (variable)
This is how often (in seconds) JOVE should check your mailbox for
incoming mail. See also the mailbox and disable-biff variables.
16.127. make-backup-files (variable)
If this variable is set, then whenever JOVE writes out a file, it
will move the previous version of the file (if there was one) to
"#filename". This is often convenient if you save a file by
accident. The default value of this variable is "off". Note:
this is an optional part of JOVE, and your guru may not have it
enabled, so it may not work.
16.128. make-buffer-unmodified (ESC ~)
This makes JOVE think the selected buffer hasn't been changed
even if it has. Use this when you accidentally change the buffer
but don't want it considered changed. Watch the mode line to see
the * disappear when you use this command.
16.129. make-macro-interactive (Not Bound)
This command is meaningful only while you are defining a keyboard
macro. Ordinarily, when a command in a macro definition requires
a trailing text argument (file name, search string, etc.), the
argument you supply becomes part of the macro definition. If you
April 27, 2013
USD:17-56 JOVE Manual for UNIX Users
want to be able to supply a different argument each time the
macro is used, then while you are defining it, you should give
the make-macro-interactive command just before typing the argu-
ment which will be used during the definition process. Note: you
must bind this command to a key in order to use it; you can't say
ESC X make-macro-interactive.
16.130. mark-threshold (variable)
This variable contains the number of lines point may move by
before the mark is set. If, in a search or something, point
moves by more than this many lines, the mark is set so that you
may return easily. The default value of this variable is 22 (one
screenful, on most terminals).
16.131. marks-should-float (variable)
When this variable is "off", the position of a mark is remembered
as a line number within the buffer and a character number within
the line. If you add or delete text before the mark, it will no
longer point to the text you marked originally because that text
is no longer at the same line and character number. When this
variable is "on", the position of a mark is adjusted to compen-
sate for each insertion and deletion. This makes marks much more
sensible to use, at the cost of slowing down insertion and dele-
tion somewhat. The default value is "on".
16.132. match-regular-expressions (variable)
When set, JOVE will match regular expressions in search patterns.
This makes special the characters ., *, [, ], ^, and $, and the
two-character sequences \<, \>, \{, \} and \|. See the ed(1)
manual page, the tutorial "Advanced Editing in UNIX ", and the
section above "Searching with Regular Expressions" for more
information.
16.133. meta-key (variable)
You should set this variable to "on" if your terminal has a real
Meta key. If your terminal has such a key, then a key sequence
like ESC Y can be entered by holding down Meta and typing Y.
16.134. mode-line (variable)
The format of the mode line can be determined by setting this
variable. The items in the line are specified using a printf(3)
format, with the special things being marked as "%x". Digits may
be used between the 'x' may be:
April 27, 2013
JOVE Manual for UNIX Users USD:17-57
C check for new mail, and displays "[New mail]" if there
is any (see also the mail-check-interval and disable-biff
variables)
F the current file name, with leading path stripped
M the current list of major and minor modes
b the current buffer name
c the fill character (-)
d the current directory
e end of string--this must be the last item in the string
f the current file name
l the current load average (updated automatically)
m the buffer-modified symbol (*)
n the current buffer number
s space, but only if previous character is not a space
t the current time (updated automatically)
[ ] the square brackets printed when in a recursive edit
( ) items enclosed in %( ... %) will only be printed on
the bottom mode line, rather than copied when the
window is split
In addition, any other character is simply copied into the mode
line. Characters may be escaped with a backslash. To get a feel
for all this, try typing "ESC X print mode-line" and compare the
result with your current mode line.
16.135. mode-line-should-standout (variable)
If set, the mode line will be printed in reverse video, if your
terminal supports it. The default for this variable is "off".
16.136. name-keyboard-macro (Not Bound)
This copies the keyboard macro and gives it a name freeing up the
keyboard macro so you can define some more. Keyboard macros with
their own names can be bound to keys just like built in commands
can. See the read-macros-file-file and write-macros-to-file com-
mands.
16.137. newline (Return)
This divides the current line at point moving all the text to the
right of point down onto the newly created line. Point moves
down to the beginning of the new line.
16.138. newline-and-backup (C-O)
This divides the current line at point moving all the text to the
right of point down onto the newly created line. The difference
between this and "newline" is that point does not move down to
the beginning of the new line.
April 27, 2013
USD:17-58 JOVE Manual for UNIX Users
16.139. newline-and-indent (LineFeed)
This behaves the same was as Return does when in Auto Indent
mode. This makes Auto Indent mode obsolete but it remains in the
name of backward compatibility.
16.140. next-error (C-X C-N)
This moves to the next error in the list of errors that were
parsed with parse-errors or parse-special-errors. In one window
the list of errors is shown with the current one always at the
top. In another window is the file that contains the error.
Point is positioned in this window on the line where the error
occurred.
16.141. next-line (C-N)
This moves down to the next line.
16.142. next-page (C-V)
This displays the next page of the buffer by taking the bottom
line of the window and redrawing the window with it at the top.
If there isn't another page in the buffer JOVE rings the bell.
If a numeric argument is supplied the screen is scrolled up that
many lines; if the argument is negative the screen is scrolled
down.
16.143. next-window (C-X N)
This moves into the next window. Windows live in a circular list
so when you're in the bottom window and you try to move to the
next one you are moved to the top window. It is an error to use
this command with only one window.
16.144. number-lines-in-window (Not Bound)
This displays the line numbers for each line in the buffer being
displayed. The number isn't actually part of the text; it's just
printed before the actual buffer line is. To turn this off you
run the command again; it toggles.
16.145. over-write-mode (Not Bound)
This turns Over Write mode on (or off if it's currently on) in
the selected buffer. When on, this mode changes the way the
self-inserting characters work. Instead of inserting themselves
and pushing the rest of the line over to the right, they replace
or over-write the existing character. Also, Rubout replaces the
character before point with a space instead of deleting it. When
Over Write mode is on "OvrWt" is displayed on the mode line.
April 27, 2013
JOVE Manual for UNIX Users USD:17-59
16.146. page-next-window (ESC C-V)
This displays the next page in the next window. This is exactly
the same as "C-X N C-V C-X P".
16.147. paren-flash-delay (variable)
How long, in tenths of seconds, JOVE should pause on a matching
parenthesis in Show mode. The default is 5.
16.148. parse-errors (Not Bound)
This takes the list of C compilation errors (or output from
another program in the same format) in the current buffer and
parses them for use with the next-error and previous-error and
current-error commands. This is a very useful tool and helps with
compiling C programs and when used in conjunction with the "grep"
UNIX command very helpful in making changes to a bunch of files.
This command understands errors produced by cc, cpp, and lint;
plus any other program with the same format (e.g., "grep -n").
JOVE visits each file that has an error and remembers each line
that contains an error. It doesn't matter if later you insert or
delete some lines in the buffers containing errors; JOVE
remembers where they are regardless. next-error is automatically
executed after one of the parse commands, so you end up at the
first error.
16.149. parse-special-errors (Not Bound)
This parses errors in an unknown format. Error parsing works
with regular expression search strings with \('s around the the
file name and the line number. So, you can use parse-special-
errors to parse lines that are in a slightly different format by
typing in your own search string. If you don't know how to use
regular expressions you can't use this command.
16.150. parse-spelling-errors-in-buffer (Not Bound)
This parses a list of words in the current buffer and looks them
up in another buffer that you specify. This will probably go
away soon.
16.151. pause-jove (ESC S)
This stops JOVE and returns control to the parent shell. This
only works for users using the C-shell, and on systems that have
the job control facility. To return to JOVE you type "fg" to the
C-shell.
16.152. physical-tabstop (variable)
How many spaces your terminal prints when it prints a tab charac-
ter.
April 27, 2013
USD:17-60 JOVE Manual for UNIX Users
16.153. pop-mark (Not Bound)
This gets executed when you run set-mark with a numeric argument.
JOVE remembers the last 16 marks and you use pop-mark to go back-
ward through the ring of marks. If you execute " pop-mark enough
times you will eventually get back to where you started.
16.154. popd (Not Bound)
This pops one entry off the directory stack. Entries are pushed
with the pushd command. The names were stolen from the C-shell
and the behavior is the same.
16.155. previous-error (C-X C-P)
This is the same as next-error except it goes to the previous
error. See next-error for documentation.
16.156. previous-line (C-P)
This moves up to the previous line.
16.157. previous-page (ESC V)
This displays the previous page of the current buffer by taking
the top line and redrawing the window with it at the bottom. If
a numeric argument is supplied the screen is scrolled down that
many lines; if the argument is negative the screen is scrolled
up.
16.158. previous-window (C-X P and C-X O)
This moves into the next window. Windows live in a circular list
so when you're in the top window and you try to move to the pre-
vious one you are moved to the bottom window. It is an error to
use this command with only one window.
16.159. print (Not Bound)
This prints the value of a JOVE variable.
16.160. print-message (Not Bound)
This command prompts for a message, and then prints it on the
bottom line where JOVE messages are printed.
16.161. process-bind-to-key (Not Bound)
This command is identical to bind-to-key, except that it only
affects your bindings when you are in a buffer attached to a pro-
cess. When you enter the process buffer, any keys bound with
this command will automatically take their new values. When you
switch to a non-process buffer, the old bindings for those keys
will be restored. For example, you might want to execute
April 27, 2013
JOVE Manual for UNIX Users USD:17-61
process-bind-to-key stop-process ^Z
process-bind-to-key interrupt-process ^C
Then, when you start up an interactive process and switch into
that buffer, C-Z will execute stop-process and C-C will execute
interrupt- process. When you switch back to a non-process
buffer, C-Z will go back to executing scroll-up (or whatever you
have it bound to).
16.162. process-newline (Return)
This this only gets executed when in a buffer that is attached to
an interactive-process. JOVE does two different things depending
on where you are when you hit Return. When you're at the end of
the I-Process buffer this does what Return normally does, except
it also makes the line available to the process. When point is
positioned at some other position that line is copied to the end
of the buffer (with the prompt stripped) and point is moved there
with it, so you can then edit that line before sending it to the
process. This command must be bound to the key you usually use
to enter shell commands (Return), or else you won't be able to
enter any.
16.163. process-prompt (variable)
What a prompt looks like from the i-shell and i-shell-command
processes. The default is "% ", the default C-shell prompt.
This is actually a regular expression search string. So you can
set it to be more than one thing at once using the \| operator.
For instance, for LISP hackers, the prompt can be
"% -> <[0-9]>: ".
16.164. push-shell (Not Bound)
This spawns a child shell and relinquishes control to it. This
works on any version of UNIX, but this isn't as good as pause-
jove because it takes time to start up the new shell and you get
a brand new environment every time. To return to JOVE you type
"C-D".
16.165. pushd (Not Bound)
This pushes a directory onto the directory stack and cd's into
it. It asks for the directory name but if you don't specify one
it switches the top two entries no the stack. It purposely
behaves the same as C-shell's pushd.
16.166. pwd (Not Bound)
This prints the working directory.
April 27, 2013
USD:17-62 JOVE Manual for UNIX Users
16.167. quadruple-numeric-argument (C-U)
This multiplies the numeric argument by 4. So, "C-U C-F" means
forward 4 characters and "C-U C-U C-N" means down 16 lines.
16.168. query-replace-string (ESC Q)
This replaces the occurrences of a specified string with a speci-
fied replacement string. When an occurrence is found point is
moved to it and then JOVE asks what to do. The options are:
Space to replace this occurrence and go on to the next one.
Period to replace this occurrence and then stop.
Rubout to skip this occurrence and go on to the next one.
C-R to enter a recursive edit. This lets you temporarily
suspend the replace, do some editing, and then return
to continue where you left off. To continue with the
Query Replace type "C-X C-C" as if you were trying to
exit JOVE. Normally you would but when you are in a
recursive edit all it does is exit that recursive
editing level.
C-W to delete the matched string and then enter a recursive
edit.
U to undo the last replacement.
P or ! to go ahead and replace the remaining occurrences without
asking.
Return to stop the Query Replace.
The search for occurrences starts at point and goes to the end of
the buffer, so to replace in the entire buffer you must first go
to the beginning.
16.169. quit-process (Not Bound)
This is the same as typing "C-\" (the Quit character) to a normal
UNIX process, except it sends it to the current process in JOVE.
This is only for versions of JOVE that have the interactive
processes feature. This only works when you are inside a buffer
that's attached to a process.
16.170. quoted-insert (C-Q)
This lets you insert characters that normally would be executed
as other JOVE commands. For example, to insert "C-F" you type
"C-Q C-F".
16.171. read-word-abbrev-file (Not Bound)
This reads a specified file that contains a bunch of abbreviation
definitions, and makes those abbreviations available. If the
selected buffer is not already in Word Abbrev mode this command
puts it in that mode.
April 27, 2013
JOVE Manual for UNIX Users USD:17-63
16.172. read-macros-from-file (Not Bound)
This reads the specified file that contains a bunch of macro
definitions, and defines all the macros that were currently
defined when the file was created. See write-macros-to-file to
see how to save macros.
16.173. redraw-display (C-L)
This centers the line containing point in the window. If that
line is already in the middle the window is first cleared and
then redrawn. If a numeric argument is supplied, the line is
positioned at that offset from the top of the window. For exam-
ple, "ESC 0 C-L" positions the line containing point at the top
of the window.
16.174. recursive-edit (Not Bound)
This enters a recursive editing level. This isn't really very
useful. I don't know why it's available for public use. I think
I'll delete it some day.
16.175. rename-buffer (Not Bound)
This lets you rename the current buffer.
16.176. replace-in-region (Not Bound)
This is the same as replace-string except that it is restricted
to occurrences between Point and Mark.
16.177. replace-string (ESC R)
This replaces all occurrences of a specified string with a speci-
fied replacement string. This is just like query-replace-string
except it replaces without asking.
16.178. right-margin (variable)
Where the right margin is for Auto Fill mode and the justify-
paragraph and justify-region commands. The default is 78.
16.179. right-margin-here (Not Bound)
This sets the right-margin variable to the current position of
point. This is an easy way to say, "Make the right margin begin
here," without having to count the number of spaces over it actu-
ally is.
16.180. save-file (C-X C-S)
This saves the current buffer to the associated file. This makes
your changes permanent so you should be sure you really want to.
If the buffer has not been modified save-file refuses to do the
April 27, 2013
USD:17-64 JOVE Manual for UNIX Users
save. If you really do want to write the file you can use "C-X
C-W" which executes write-file.
16.181. scroll-down (ESC Z)
This scrolls the screen one line down. If the line containing
point moves past the bottom of the window point is moved up to
the center of the window. If a numeric argument is supplied that
many lines are scrolled; if the argument is negative the screen
is scrolled up instead.
16.182. scroll-step (variable)
How many lines should be scrolled if the previous-line or next-
line commands move you off the top or bottom of the screen. You
may wish to decrease this variable if you are on a slow terminal.
16.183. scroll-up (C-Z)
This scrolls the screen one line up. If the line containing
point moves past the top of the window point is moved down to the
center of the window. If a numeric argument is supplied that
many lines are scrolled; if the argument is negative the screen
is scrolled down instead.
16.184. search-exit-char (variable)
Set this to the character you want to use to exit incremental
search. The default is Newline, which makes i-search compatible
with normal string search.
16.185. search-forward (C-S)
This searches forward for a specified search string and positions
point at the end of the string if it's found. If the string is
not found point remains unchanged. This searches from point to
the end of the buffer, so any matches before point will be
missed.
16.186. search-reverse (C-R)
This searches backward for a specified search string and posi-
tions point at the beginning if the string if it's found. If the
string is not found point remains unchanged. This searches from
point to the beginning of the buffer, so any matches after point
will be missed.
16.187. select-buffer (C-X B)
This selects a new or already existing buffer making it the
current one. You can type either the buffer name or number. If
you type in the name you need only type the name until it is
unambiguous, at which point typing Escape or Space will complete
it for you. If you want to create a new buffer you can type
April 27, 2013
JOVE Manual for UNIX Users USD:17-65
Return instead of Space, and a new empty buffer will be created.
16.188. self-insert (Most Printing Characters)
This inserts the character that invoked it into the buffer at
point. Initially all but a few of the printing characters are
bound to self-insert.
16.189. send-typeout-to-buffer (variable)
When this is set JOVE will send output that normally overwrites
the screen (temporarily) to a buffer instead. This affects com-
mands like list-buffers, list-processes, and other commands that
use command completion. The default value is "off".
16.190. set (Not Bound)
This gives a specified variable a new value. Occasionally you'll
see lines like "set this variable to that value to do this".
Well, you use the set command to do that.
16.191. set-mark (C-@)
This sets the mark at the current position in the buffer. It
prints the message "Point pushed" on the message line. It says
that instead of "Mark set" because when you set the mark the pre-
vious mark is still remembered on a ring of 16 marks. So "Point
pushed" means point is pushed onto the ring of marks and becomes
the value of "the mark". To go through the ring of marks you type
"C-U C-@", or execute the pop-mark command. If you type this
enough times you will get back to where you started.
16.192. shell (variable)
The shell to be used with all the shell commands command. If
your SHELL environment variable is set, it is used as the value
of shell; otherwise "/bin/csh" is the default.
16.193. shell-command (C-X !)
This runs a UNIX command and places the output from that command
in a buffer. JOVE creates a buffer that matches the name of the
command you specify and then attaches that buffer to a window.
So, when you have only one window running this command will cause
JOVE to split the window and attach the new buffer to that win-
dow. Otherwise, JOVE finds the most convenient of the available
windows and uses that one instead. If the buffer already exists
it is first emptied, except that if it's holding a file, not some
output from a previous command, JOVE prints an error message and
refuses to execute the command. If you really want to execute
the command you should delete that buffer (saving it first, if
you like) or use shell-command-to-buffer, and try again.
April 27, 2013
USD:17-66 JOVE Manual for UNIX Users
16.194. shell-command-to-buffer (Not Bound)
This is just like shell-command except it lets you specify the
buffer to use instead of JOVE.
16.195. shell-flags (variable)
This defines the flags that are passed to shell commands. The
default is "-c". See the shell variable to change the default
shell.
16.196. show-match-mode (Not Bound)
This turns on Show Match mode (or off if it's currently on) in
the selected buffer. This changes "}" and ")" so that when they
are typed the are inserted as usual, and then the cursor flashes
back to the matching "{" or "(" (depending on what was typed) for
about half a second, and then goes back to just after the "}" or
")" that invoked the command. This is useful for typing in com-
plicated expressions in a program. You can change how long the
cursor sits on the matching paren by setting the "paren-flash-
delay" variable in tenths of a second. If the matching "{" or
"(" isn't visible nothing happens.
16.197. shrink-window (Not Bound)
This makes the current window one line shorter, if possible.
Windows must be at least 2 lines high, one for the text and the
other for the mode line.
16.198. source (Not Bound)
This reads a bunch of JOVE commands from a file. The format of
the file is the same as that in your initialization file (your
".joverc") in your main directory. There should be one command
per line and it should be as though you typed "ESC X" while in
JOVE. For example, here's part of my initialization file:
bind-to-key i-search-reverse ^R
bind-to-key i-search-forward ^S
bind-to-key pause-jove ^[S
What they do is make "C-R" call the i-search-reverse command and
"C-S" call i-search-forward and "ESC S" call pause-jove.
16.199. spell-buffer (Not Bound)
This runs the current buffer through the UNIX spell program and
places the output in buffer "Spell". Then JOVE lets you edit the
list of words, expecting you to delete the ones that you don't
care about, i.e., the ones you know are spelled correctly. Then
the parse-spelling-errors-in-buffer command comes along and finds
all the misspelled words and sets things up so the error commands
work.
April 27, 2013
JOVE Manual for UNIX Users USD:17-67
16.200. split-current-window (C-X 2)
This splits the current window into two equal parts (providing
the resulting windows would be big enough) and displays the
selected buffer in both windows. Use "C-X 1" to go back to 1
window mode.
16.201. start-remembering (C-X ()
This starts remembering your key strokes in the Keyboard macro.
To stop remembering you type "C-X )". Because of a bug in JOVE
you can't stop remembering by typing "ESC X stop-remembering";
stop-remembering must be bound to "C-X )" in order to make things
work correctly. To execute the remembered key strokes you type
"C-X E" which runs the execute-keyboard-macro command. Sometimes
you may want a macro to accept different input each time it runs.
To see how to do this, see the make-macro-interactive command.
16.202. stop-process (Not Bound)
This sends a stop signal (C-Z, for most people) to the current
process. It only works if you have the interactive process
feature, and you are in a buffer attached to a process.
16.203. stop-remembering (C-X ))
This stop the definition of the keyboard macro. Because of a bug
in JOVE, this must be bound to "C-X )". Anything else will not
work properly.
16.204. string-length (Not Bound)
This prints the number of characters in the string that point
sits in. Strings are surrounded by double quotes. JOVE knows
that "\007" is considered a single character, namely "C-G", and
also knows about other common ones, like "\r" (Return) and "\n"
(LineFeed). This is mostly useful only for C programmers.
16.205. suspend-jove (ESC S)
This is a synonym for pause-jove.
16.206. sync-frequency (variable)
The temporary files used by JOVE are forced out to disk every
sync-frequency modifications. The default is 50, which really
makes good sense. Unless your system is very unstable, you prob-
ably shouldn't fool with this.
16.207. tag-file (variable)
This the name of the file in which JOVE should look up tag defin-
itions. The default value is "./tags".
April 27, 2013
USD:17-68 JOVE Manual for UNIX Users
16.208. text-mode (Not Bound)
This sets the major mode to Text. Currently the other modes are
Fundamental, C and Lisp mode.
16.209. transpose-characters (C-T)
This switches the character before point with the one after
point, and then moves forward one. This doesn't work at the
beginning of the line, and at the end of the line it switches the
two characters before point. Since point is moved forward, so
that the character that was before point is still before point,
you can use "C-T" to drag a character down the length of a line.
This command pretty quickly becomes very useful.
16.210. transpose-lines (C-X C-T)
This switches the current line with the one above it, and then
moves down one so that the line that was above point is still
above point. This, like transpose-characters, can be used to drag
a line down a page.
16.211. unbind-key (Not Bound)
Use this to unbind any key sequence. You can use this to unbind
even a prefix command, since this command does not use "key-map
completion". For example, "ESC X unbind-key ESC [" unbinds the
sequence "ESC [". This is useful for "turning off" something set
in the system-wide ".joverc" file.
16.212. update-time-frequency (variable)
How often the mode line is updated (and thus the time and load
average, if you display them). The default is 30 seconds.
16.213. use-i/d-char (variable)
If your terminal has insert/delete character capability you can
tell JOVE not to use it by setting this to "off". In my opinion
it is only worth using insert/delete character at low baud rates.
WARNING: if you set this to "on" when your terminal doesn't have
insert/delete character capability, you will get weird (perhaps
fatal) results.
16.214. version (Not Bound)
Displays the version number of this JOVE.
16.215. visible-bell (variable)
Use the terminal's visible bell instead of beeping. This is set
automatically if your terminal has the capability.
April 27, 2013
JOVE Manual for UNIX Users USD:17-69
16.216. visible-spaces-in-window (Not Bound)
This displays an underscore character instead of each space in
the window and displays a greater-than followed by spaces for
each tab in the window. The actual text in the buffer is not
changed; only the screen display is affected. To turn this off
you run the command again; it toggles.
16.217. visit-file (C-X C-V)
This reads a specified file into the current buffer replacing the
old text. If the buffer needs saving JOVE will offer to save it
for you. Sometimes you use this to start over, say if you make
lots of changes and then change your mind. If that's the case
you don't want JOVE to save your buffer and you answer "NO" to
the question.
16.218. window-find (C-X 4)
This lets you select another buffer in another window three dif-
ferent ways. This waits for another character which can be one
of the following:
T Finds a tag in the other window.
F Finds a file in the other window.
B Selects a buffer in the other window.
This is just a convenient short hand for "C-X 2" (or "C-X O" if
there are already two windows) followed by the appropriate
sequence for invoking each command. With this, though, there
isn't the extra overhead of having to redisplay. In addition,
you don't have to decide whether to type "C-X 2" or "C-X O" since
"C-X 4" does the right thing.
16.219. word-abbrev-mode (Not Bound)
This turns on Word Abbrev mode (or off if it's currently on) in
the selected buffer. Word Abbrev mode lets you specify a word
(an abbreviation) and a phrase with which JOVE should substitute
the abbreviation. You can use this to define words to expand
into long phrases, e.g., "jove" can expand into "Jonathan's Own
Version of Emacs"; another common use is defining words that you
often misspell in the same way, e.g., "thier" => "their" or "teh"
=> "the". See the information on the auto-case-abbrev variable.
There are two kinds of abbreviations: mode specific and global.
If you define a Mode specific abbreviation in C mode, it will
expand only in buffers that are in C mode. This is so you can
have the same abbreviation expand to different things depending
on your context. Global abbreviations expand regardless of the
major mode of the buffer. The way it works is this: JOVE looks
first in the mode specific table, and then in the global table.
Whichever it finds it in first is the one that's used in the
expansion. If it doesn't find the word it is left untouched.
April 27, 2013
USD:17-70 JOVE Manual for UNIX Users
JOVE tries to expand words as they are typed, when you type a
punctuation character or Space or Return. If you are in Auto
Fill mode the expansion will be filled as if you typed it your-
self.
16.220. wrap-search (variable)
If set, searches will "wrap around" the ends of the buffer
instead of stopping at the bottom or top. The default is "off".
16.221. write-files-on-make (variable)
When set, all modified files will be written out before calling
make when the compile-it command is executed. The default is
"on".
16.222. write-word-abbrev-file (Not Bound)
This writes the currently defined abbreviations to a specified
file. They can be read back in and automatically defined with
read-word-abbrev-file.
16.223. write-file (C-X C-W)
This saves the current buffer to a specified file, and then makes
that file the default file name for this buffer. If you specify
a file that already exists you are asked to confirm over-writing
it.
16.224. write-macros-to-file (Not Bound)
This writes the currently defined macros to a specified file.
The macros can be read back in with read-macros-from-file so you
can define macros and still use them in other instantiations of
JOVE.
16.225. write-modified-files (C-X C-M)
This saves all the buffers that need saving. If you supply a
numeric argument it asks for each buffer whether you really want
to save it.
16.226. write-region (Not Bound)
This writes the text in the region to a specified file. If the
file already exists you are asked to confirm over-writing it.
16.227. yank (C-Y)
This undoes the last kill command. That is, it inserts the
killed text at point. When you do multiple kill commands in a
row, they are merged so that yanking them back with "C-Y" yanks
back all of them.
April 27, 2013
JOVE Manual for UNIX Users USD:17-71
16.228. yank-pop (ESC Y)
This yanks back previous killed text. JOVE has a kill ring on
which the last 10 kills are stored. Yank yanks a copy of the text
at the front of the ring. If you want one of the last ten kills
you use "ESC Y" which rotates the ring so another different entry
is now at the front. You can use "ESC Y" only immediately fol-
lowing a "C-Y" or another "ESC Y". If you supply a negative
numeric argument the ring is rotated the other way. If you use
this command enough times in a row you will eventually get back
to where you started. Experiment with this. It's extremely use-
ful.
April 27, 2013
Generated on 2013-04-27 00:20:00 by $MirOS: src/scripts/roff2htm,v 1.77 2013/01/01 20:49:09 tg Exp $
These manual pages and other documentation are copyrighted by their respective writers;
their source is available at our CVSweb,
AnonCVS, and other mirrors. The rest is Copyright © 2002‒2013 The MirOS Project, Germany.
This product includes material
provided by Thorsten Glaser.
This manual page’s HTML representation is supposed to be valid XHTML/1.1; if not, please send a bug report – diffs preferred.