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 automatically 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 characters 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 indentations of pro-
grams; view more than one file at once; and dealing in terms of charac-
ters, 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 command set; if you
prefer to use arrow keys for the four basic cursor motion commands (up,
down, left and right), you can. Another sort of customization is writ-
ing 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 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
_________________________
*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 editors, and you should not rely on their
behaving identically.
USD:17-2 JOVE Manual for UNIX Users
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 com-
mands 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 nor-
mally, 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 ^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.
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
JOVE Manual for UNIX Users USD:17-3
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 ``^'' (caret) followed by another character. Thus, ^A is
the character you get when you type A with the Control key (sometimes
labeled CTRL) down. Most control characters when present in the JOVE
buffer are displayed this way. Rubout (or DEL) is displayed as ^?,
escape as ^[.
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 possi-
bility. For example, if you have typed the letters ``au'' and you then
type a question mark, you will see the list
USD:17-4 JOVE Manual for UNIX Users
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 supply 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 com-
mand, 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. The
variable bad-filename-extensions 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.
4. Commands and Variables
JOVE is composed of commands which have long names such as next-line.
Then keys such as ^N are connected to commands through the command
dispatch table. When we say that ^N moves the cursor down a line, we
are glossing over a distinction which is unimportant for ordinary use,
but essential for simple customization: it is the command next-line
which knows how to move a down line, and ^N moves down a line because it
is connected to that command. The name for this connection is a bind-
ing; we say that the key ^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 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 customizing 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
JOVE Manual for UNIX Users USD:17-5
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 prefix characters built into JOVE: Escape and
Control-X. How the next character is interpreted depends on which pre-
fix 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 indi-
cated as ``ESC,'' which is also what JOVE displays on the message 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, ^X-?
(describe-key) will work. A description of an individual command is
available by using ESC ? (describe-command), and descriptions of vari-
ables by using ESC X describe-variable. If you can't remember the name
of the thing you want to know about, ESC H (apropos) will tell you if a
command or variable has a given string in its name. For example, ESC H
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 forward. Any char-
acters 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 ^H. ^H 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 ^H, they cancel out.
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 ^H 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 ^O (newline-and-backup) command to
``open'' several empty lines at once; then you can insert the new text,
USD:17-6 JOVE Manual for UNIX Users
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 distracting.
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 themselves. If you
need to insert a control character, Escape, or ^H, you must first quote
it by typing the ^ ~ (quoted-insert) command first.
5.2. Moving the Cursor
To do more than insert characters, you have to know how to move the cur-
sor. Here are a few of the commands for doing that.
^A Move to the beginning of the line.
^E Move to the end of the line.
^F Move forward over one character.
^B Move backward over one character.
^N Move down one line, vertically. If you start in the mid-
dle of one line, you end in the middle of the next.
^P Move up one line, vertically.
ESC < Move to the beginning of the entire buffer.
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
^H Delete the character before the cursor.
^D Delete the character after the cursor.
^K Kill to the end of the line.
You already know about the ^H command which deletes the character before
the cursor. Another command, ^D, deletes the character after the
JOVE Manual for UNIX Users USD:17-7
cursor, causing the rest of the text on the line to shift left. If ^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 ^K command, which kills a line
at a time. If ^K is done at the beginning or middle of a line, it kills
all the text up to the end of the line. If ^K is done at the end of a
line, it joins that line and the next line. If ^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 ^X-
^R foo.bar<return>. This reads the file foo.bar so that its contents
appear on the screen for editing. You can make changes, and then save
the file by typing ^X-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 ^X-S the file will be created.
5.5. Exiting and Pausing - Leaving JOVE
The command ^X-^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 the command, look at what
buffers are modified but unsaved using ^X-^B (list-buffers), save the
valuable ones, and then exit. If what you want to do, on the other
hand, is preserve the editing session but return to the shell tem-
porarily you can (under Berkeley UNIX only) issue the command ESC P
(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 inter-
pret the argument as a repetition count. For example, giving an argu-
ment of ten to the ^F command (forward-character) moves forward ten
characters. With these commands, no argument is equivalent to an argu-
ment 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)
_________________________
- UNIX is a trademark of Bell Laboratories.
USD:17-8 JOVE Manual for UNIX Users
with an argument n goes to the beginning of the n'th line. But ESC G
with no argument prompts for the line number. Similarly, ^K with an
argument kills that many lines, including their line separators.
Without an argument, ^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, ^K
deletes the line separator.
The fundamental way of specifying an argument is to use ESC followed 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 ^U means do the next command four times. Two such ^U's multiply
the next command by sixteen. Thus, ^U ^U ^F moves forward sixteen char-
acters. 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:
^U ^U ^N (move down a good fraction of the screen), ^U ^U ^O (make ``a
lot'' of blank lines), and ^U ^K (kill four lines - note that typing ^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 terminal 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 arguments.
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 usu-
ally 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.
^@ Set the mark where point is.
^X ^X Interchange mark and point.
For example, if you wish to convert part of the buffer to all upper-
case, you can use the ^X ^U command, which operates on the text in the
region. You can first go to the beginning of the text to be capital-
ized, put the mark there, move to the end, and then type ^X ^U. Or, you
can set the mark at the end of the text, move to the beginning, and then
type ^X ^U. ^X ^U runs the command case-region-upper, whose name signi-
fies that the region, or everything between point and mark, is to be
capitalized.
The way to set the mark is with the ^@ command or (on some terminals)
the ^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
JOVE Manual for UNIX Users USD:17-9
you where the mark is located. You have to remember. The usual solu-
tion 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
^X ^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 location of the mark.
5.8. The Ring of Marks
Aside from delimiting the region, the mark is also useful for remember-
ing 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 ^U ^@. 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 ^U ^@ bring
point back to where it was originally.
Some commands whose primary purpose is to move point a great distance
take advantage of the stack of marks to give you a way to undo the com-
mand. The best example is ESC <, which moves to the beginning of the
buffer. If there are more than 22 lines between the beginning of the
buffer and point, ESC < sets the mark first, so that you can use ^U ^@
or ^X ^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 set-
ting it to 0, you can make these commands always set the mark. By set-
ting 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 mov-
ing 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 ^D and ^H, which delete only one
character at a time, and those commands that delete only spaces or line
separators. 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.
^D Delete next character.
USD:17-10 JOVE Manual for UNIX Users
^H Delete previous character.
ESC \ Delete spaces and tabs around point.
^X ^O Delete blank lines around the current line.
^K Kill rest of line or one or more lines.
^W Kill region (from point to the mark).
ESC D Kill word.
ESC ^H Kill word backwards.
ESC K Kill to end of sentence.
^X-^H Kill to beginning of sentence.
5.11. Deletion
The most basic delete commands are ^D and ^H. ^D deletes the character
after the cursor, the one the cursor is "on top of" or "underneath".
The cursor doesn't move. ^H deletes the character before the cursor,
and moves the cursor back. Line separators act like normal characters
when deleted. Actually, ^D and ^H aren't always delete commands; if you
give an argument, they kill instead. This prevents you from losing a
great deal of text by typing a large argument to a ^D or ^H.
The other delete commands are those which delete only formatting charac-
ters: spaces, tabs, and line separators. ESC \ (delete-white-space)
deletes all the spaces and tab characters before and after point. ^X-^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 ^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 ^K's, the line disappears completely.
More generally, ^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 fol-
lowing the line, thus merging the next line into the current one.
Invisible spaces and tabs at the end of the line are ignored when decid-
ing 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.
^K with an argument of zero kills all the text before point on the
current line.
JOVE Manual for UNIX Users USD:17-11
5.13. Other Kill Commands
A kill command which is very general is ^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 ^H and ESC D;
and, sentences, with ESC K and ^X-^H.
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 one or more
times.
^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 ^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 ^Y
undoes the ^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 ^W followed by ^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 visit-
ing a new file, whatever was last killed in the previous file is still
on top of the kill ring. This is important for moving text between
files.
5.15. Appending Kills
Normally, each kill command pushes a new block onto the kill ring. How-
ever, 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 ^Y command gets it all back as it was before it
was killed. This means that you don't have to kill all the text in one
command; you can keep killing line after line, or word after word, until
you have killed it all, and you can still get it all back at once.
_________________________
*Often users switch this binding from ^W to ^X-^K because it is too
easy to hit ^W accidentally.
USD:17-12 JOVE Manual for UNIX Users
Commands that kill forward from point add onto the end of the previous
killed text. Commands that kill backward from point add onto the begin-
ning. This way, any sequence of mixed forward and backward kill com-
mands puts all the killed text into one entry without needing rearrange-
ment.
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 ^Y (yank) command or another ESC Y. It takes the un-killed text
inserted by the ^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 ^Y
to recover the last kill, and then discard it by use of ESC Y to move
back to the previous kill.
You can think of all the last few kills as living on a ring. After a ^Y
command, the text at the front of the ring is also present in the
buffer. ESC Y ``rotates'' the ring bringing the previous string of text
to the front and this text replaces the other text in the buffer as
well. Enough ESC Y commands can rotate any part of the ring to the
front, so you can get at any killed text so long as it is recent enough
to be still in the ring. Eventually the ring rotates all the way around
and the most recently killed text comes to the front (and into the
buffer) again. ESC Y with a negative argument rotates the ring back-
wards.
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 ^Y gets another copy of what you rotated to the front with
ESC Y.
If you change your mind about un-killing, ^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 arbitrary posi-
tions 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 rear-
range the key bindings (see below).
6.1. Conventional Search
ESC S Search forward.
ESC R Search backward.
JOVE Manual for UNIX Users USD:17-13
To search for the string ``FOO'' you type ``ESC 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. ESC S searches forward from
point so only occurrences of FOO after point are found. To search in
the other direction use ESC R. It is exactly the same as ESC 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 ESC S.
While JOVE is searching it prints the search string on the message line.
This is so you know what JOVE is doing. When the system 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 search
for the same string you can type ``ESC S <return>.'' If you mistyped
the last search string, you can type ESC S followed by ESC R. ESC 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 ESC X i-search-forward. This command reads in
characters and positions the cursor at the first occurrence of the char-
acters that you have typed so far. If you type ESC X i-search-forward
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 erase it out. After the FOO,
typing a ^H makes the ``O'' disappear from the message line, leaving
only ``FO.'' The cursor moves back in the buffer to the ``FO.'' Eras-
ing 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, typing ^A would exit
the search and then move to the beginning of the line. Return is neces-
sary only if the next character you want to type is a printing charac-
ter, ^H, Return, or another search command, since those are the charac-
ters 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 ESC S <return> and the cursor will find
USD:17-14 JOVE Manual for UNIX Users
the next FOO. This can be done any number of times. If you overshoot,
you can return to previous finds with the search-backward command ESC R.
After you exit a search, you can search for the same string again by
typing just ESC S <return>.
If your string is not found at all, the message line says Failing 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. 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 ^G, which undoes the search alto-
gether and positions you back where you started the search.
You can also type ESC 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 ESC R's keep looking backward for more
occurrences of the last search string. A ESC S starts going forward
again.
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 expres-
sions 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 begin-
ning with the letters ``Exec.''
An \| signals the beginning of an alternative - that is, the pattern
``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 ``foobaz-
bie.''
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 document 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
JOVE Manual for UNIX Users USD:17-15
is a Query Replace operation which asks, for each occurrence of the pat-
tern, whether to replace it.
7.1. Global replacement
To replace every occurrence of FOO after point with BAR, you can do,
e.g., ``ESC ^E FOO<return>BAR'' as the replace-string command is bound
to the ESC ^E. 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.
^H or N 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.
^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 ^X-^C
and the next FOO will be displayed.
^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 ^X-^C and the
next FOO will be displayed.
^U or U move to the last replacement and undo changes to this
line.
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.
USD:17-16 JOVE Manual for UNIX Users
8.1. Word Commands
JOVE has commands for moving over or operating on words. By convention,
they are all ESC commands.
ESC F Move Forward over a word.
ESC B Move Backward over a word.
ESC D Kill forward to the end of a word.
ESC ^H Kill backward to the beginning of a word.
Notice how these commands form a group that parallels the character-
based commands, ^F, ^B, ^D, and ^H.
The commands ESC F and ESC B move forward and backward over words. They
are thus analogous to ^F and ^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 ^H. ESC D takes arguments
just like ESC F.
ESC ^H 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-^H.
8.2. Sentence Commands
The JOVE commands for manipulating sentences and paragraphs are mostly
ESC commands, so as to resemble the word-handling commands.
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.
^X-^H 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 ^A and ^E,
which move to the beginning and end of a line. Unlike them, ESC A and
JOVE Manual for UNIX Users USD:17-17
ESC E if repeated or given numeric arguments move over successive sen-
tences. JOVE considers a sentence 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 sentence.
Just as ^A and ^E have a kill command, ^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, ^X-^H 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 X backward-paragraph
Move back to previous paragraph beginning.
ESC ] Move forward to next paragraph end.
ESC X backward-paragraph moves to the beginning of the current or previ-
ous paragraph, 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.
^J 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 character.
The way to request indentation is with the Tab command. Its precise
effect depends on the major mode. In Text mode, it indents to the next
tab stop. In C mode, it indents to the ``right'' position for C pro-
grams.
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.
USD:17-18 JOVE Manual for UNIX Users
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. 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 para-
graph you set left-margin to the new position and type ^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
JOVE Manual for UNIX Users USD:17-19
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 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 useful 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.
^H Delete last character.
ESC ^H Kill last word.
^X-^H Kill to beginning of sentence.
^T Transpose two characters.
^X-^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 ^H command is the most important correction command. When used
among printing (self-inserting) characters, it can be thought of as can-
celing the last character typed.
When your mistake is longer than a couple of characters, it might be
more convenient to use ESC ^H or ^X-^H. ESC ^H kills back to the start
of the last word, and ^X-^H kills back to the start of the last sen-
tence. ^X-^H is particularly useful when you are thinking of what to
write as you type it, in case you change your mind about phrasing. ESC
^H and ^X-^H save the killed text for ^Y and ESC Y to retrieve.
ESC ^H 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 ^H 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
USD:17-20 JOVE Manual for UNIX Users
loaded.
If you were typing a command or command parameters, ^G will abort the
command with no further processing.
8.9. Transposition
The common error of transposing two characters can be fixed with the ^T
(transpose-characters) command. Normally, ^T transposes the two charac-
ters on either side of the cursor and moves the cursor forward one char-
acter. 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 charac-
ter of the line with the line separator, which would be useless, ^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 ^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 ESC X transpose-lines command. The line
containing the cursor is exchanged with the line above it; the cursor is
left at the beginning of the line following 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 opportunity 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 forward to each misspelled word with ^X-^N (next-error)
and backward with ^X-^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
^X-^V Visit a file.
^X-^R Same as ^X-^V.
^X-^S Save the visited file.
JOVE Manual for UNIX Users USD:17-21
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 ^X-^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 ^G, or edit the filename with many of the
standard JOVE commands (e.g., ^A, ^E, ^F, ESC F, ESC ^H). If the
filename you wish to visit is similar to the filename in the mode line
(the default filename), you can type ^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 ^X-S.
After the save is finished, ^X-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 disappear.
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 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.
USD:17-22 JOVE Manual for UNIX Users
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 some-
thing 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 modified 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 ^X ^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 informa-
tion about the files you're editing every so many changes to a buffer to
make recovery possible. Since a relatively small amount of information
is involved it's hardly even noticeable when JOVE does this. The vari-
able ``sync-frequency'' says how often to save the necessary informa-
tion, 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 characters 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 ^X-S,
write-file saves even if the buffer has not been changed. ^X-^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 contents. You can
also use ^X-^I to get this command.
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>.
JOVE Manual for UNIX Users USD:17-23
10. Using Multiple Buffers
When we speak of ``the buffer,'' which contains the text you are edit-
ing, 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.
^X-B Select or create a buffer.
^X-^F Visit a file in its own buffer.
^X-^B List the existing buffers.
^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 specified files to edit in the shell com-
mand 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 ^X-B FOO<return>, which is the command ^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 ^X-B FOO<return> is used, since ^X-B can tell whether a buffer
named FOO exists already or not. ^X-B Main<return> reselects the buffer
Main that JOVE started out with. Just ^X-B<return> reselects the previ-
ous buffer. Repeated ^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: ^X-^F (find-file), followed by the filename. The name of the
buffer is the last element of the file's pathname. ^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 ^X-^F
can be reselected later with ^X-B or ^X-^F, whichever you find more con-
venient. Nonexistent files can be created with ^X-^F just as they can
with ^X-^V.
USD:17-24 JOVE Manual for UNIX Users
10.2. Using Existing Buffers
To get a list of all the buffers that exist, do ^X-^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 ^X-^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 ^X-^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 ^X-S. If you give ^X-^M an argument, JOVE will ask for con-
firmation 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 ^X-K
(delete-buffer) command. You can kill the buffer FOO by doing ^X- K
FOO<return>. If you type ^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 file.
ESC ^L Reposition point at a specified vertical position, OR
clear and redraw the screen with point in the same place.
^V Scroll forwards (a screen or a few lines).
ESC V Scroll backwards.
^Z Scroll forward some lines.
JOVE Manual for UNIX Users USD:17-25
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 por-
tion. The available 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 window that the line con-
taining point is placed. A value of 0 (the initial value) means center
point in the window.
The basic display control command is ESC ^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.
ESC ^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 ESC ^L's in a row are guaranteed to clear the
current window. ^L will clear and redraw the entire screen.
The scrolling commands ^V, ESC V, ^Z, and ESC Z, let you move the whole
display up or down a few lines. ^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 ESC ^L might. ^V 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 ^V command with no argu-
ment. 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 ^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).
^Z and ESC Z scroll one line forward and one line backward, respec-
tively. These are convenient for moving in units of lines without hav-
ing to type a numeric argument.
USD:17-26 JOVE Manual for UNIX Users
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.
^X 2 Divide the current window into two smaller ones.
^X-1 Delete all windows but the current one.
^X-D Delete current window.
^X-N Switch to the next window.
^X-P Switch to the previous window.
^X-O Same as ^X-P.
^X-^ Make this window bigger.
ESC ^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 normally takes place in that window
alone. To edit in another window, you would give a command to move the
cursor to the other window, and then edit there.
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 set-
ting the variable mode-line-should-standout to ``on'' you can have JOVE
display the mode-line in reverse video (assuming your particular termi-
nal has the reverse video capability).
The command ^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 contain the same buffer and
display the same position in it, namely where point was at the time you
issued the command. The cursor moves to the second window.
To return to viewing only one window, use the command ^X-1 (delete-
other-windows). The current window expands to fill the whole screen,
and the other windows disappear until the next ^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 ^X-N (next-window) to
switch to the next window, and ^X-P (previous-window) to switch to the
previous one. If you are in the bottom window and you type ^X-N, you
will be placed in the top window, and the same kind of thing happens
when you type ^X-P in the top window, namely you will be placed in the
JOVE Manual for UNIX Users USD:17-27
bottom window. ^X-O is the same as ^X-P. It stands for ``other win-
dow'' because when there are only two windows, repeated use of this com-
mand will switch between the two windows.
Often you will be editing one window while using the other just for
reference. Then, the command ESC-^V (page-next-window) is very useful.
It scrolls the next window, as if you switched to the next window, typed
^V, and switched back, without your having to do all that. With a nega-
tive argument, ESC-^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 ^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 ^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 ^X-O or ^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 ^X-^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 ^X-B or ^X-^F,
perhaps).
A convenient ``combination'' command for viewing something in another
window is ^X-4 (window-find). With this command you can ask to see any
specified buffer, file or tag in the other window. Follow the ^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.
^X- B is similar to ^X-2 ^X-B. ^X-4 F is similar to ^X-2 ^X-^F. ^X-4 T
is similar to ^X-2 ^X T. The difference is one of efficiency, and also
that ^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.
USD:17-28 JOVE Manual for UNIX Users
12.1. Non-interactive UNIX commands
To run a UNIX command from JOVE just type ^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:
^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 contents. If the buffer it
selects holds a file, not output from a previous shell command, you must
first delete that buffer with ^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. Otherwise, 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 running.
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 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 mis-
typed it, or you changed your mind) you can type ^]. Typing this inside
JOVE while a process is running is the same as typing ^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 ^])
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 ^X-!
_________________________
*This is a bug and should be fixed, but probably won't be for a while.
JOVE Manual for UNIX Users USD:17-29
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.
^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 compi-
lation error messages (see Compiling C Programs), or with the grep com-
mands.
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 cer-
tain types of jobs:
(i) You can go off and do some editing while the command is running.
This is useful for commands that do sporadic output and run for
fairly long periods of time.
(ii) Unlike non-interactive processes, you can type input to these. In
addition, you can edit what you type with the power of all the 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 win-
dows, 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 output from the process. You
don't have to worry about missing anything when the buffer isn't visi-
ble.
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 session in a
_________________________
- For example, the version provided with 4.3BSD.
USD:17-30 JOVE Manual for UNIX Users
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 commands. In addition, you can save
yourself retyping a command (or a similar one) by sending edited ver-
sions 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 posi-
tioned 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-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 shell<return> to start up a shell. As with ^X-!, JOVE will
create a buffer, called *shell*-1, and select a window for this new
buffer. But unlike ^X-! you will be left in the new window. Now, the
shell process is said to be attached to shell-1.
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 directory
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
JOVE Manual for UNIX Users USD:17-31
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, whenever 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 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 original 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 function definitions,
producing a file called tags as its output.
JOVE has a command called ^X-T (find-tag) that prompts you for the name
of a function (a tag), looks up the tag reference in the previously con-
structed 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 ^U ^X-T, and JOVE will prompt for
a file name. If you find yourself 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:
USD:17-32 JOVE Manual for UNIX Users
% 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 ^X-^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 (^U is good enough) and you will be
prompted for the command to execute.
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, ^X-^N
(next-error), and ^X-^P (previous-error) can be used to traverse the
list of errors.
If you already have a file called errs containing, say, c compiler mes-
sages 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 docu-
ment; 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 pro-
gram, JOVE has several major modes. These are as follows:
15.1.1. Text mode
This is the default major mode. Nothing special is done.
JOVE Manual for UNIX Users USD:17-33
15.1.2. C mode
This mode affects the behavior of the tab and parentheses characters.
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 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 contents.
(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 abbrevi-
ations; whenever you type an abbreviation, it is replaced by the text
that it abbreviates. This can save typing if a particular word or
phrase must be entered many times. The abbreviations and their expan-
sions are held in a file that looks like:
USD:17-34 JOVE Manual for UNIX Users
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.
15.3. Variables
JOVE can be tailored to suit your needs by changing the values of vari-
ables. A JOVE variable can be given a value with the set command, 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 commands 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 exe-
cuted. Since it is very slow to have to type in the name of each com-
mand 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 Conventions).
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 ^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 ^X-). You now have a
keyboard macro. To run this command sequence again, use the command
execute-keyboard-macro, usually bound to ^X-E. You may find this
JOVE Manual for UNIX Users USD:17-35
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. To retrieve your macros
in the next editing session (but not their bindings), you can simply
execute the source command on that file.
15.6. Initialization Files
Users will likely want to modify the default key bindings to their lik-
ing. 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.
USD:17-36 JOVE Manual for UNIX Users
16. Alphabetical List of Commands and Variables
16.1. abort-char (variable)
This variable defines JOVE'S abort characer. When the abort character
is typed, the current JOVE command is aborted. The default value is ^G.
16.2. add-lisp-special [Unbound]
This command is to tell JOVE what identifiers require special indenta-
tion in lisp mode. Lisp functions like defun and let are two of the
default functions that get treated specially. This is just a kludge to
define some of your own. It prompts for the function name.
16.3. allow-^S-and-^Q (variable)
This variable, when set, tells JOVE that your terminal does not need to
use the characters ^S and ^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.4. allow-bad-filenames (variable)
If set, this variable permits filenames to contain ``bad'' characters
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.5. append-region [Unbound]
This appends the region to a specified file. If the file does not
already exist it is created.
16.6. apropos ESC-h
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
ESC-h window<Return>
16.7. 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 typing ``JOVE'' would give you
``Jonathan's Own Version of Emacs.'' When this variable is ``off,''
upper and lower case are distinguished when looking for the abbrevia-
tion, i.e., in the example above, ``JOVE'' and ``Jove'' would not be
JOVE Manual for UNIX Users USD:17-37
expanded unless they were defined separately.
16.8. auto-execute-command [Unbound]
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.9. auto-execute-macro [Unbound]
This is like auto-execute-command except you use it to execute macros
automatically instead of built-in commands.
16.10. auto-fill-mode [Unbound]
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 72 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.11. auto-indent-mode [Unbound]
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.
16.12. backward-character ^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.13. backward-list ESC-^P
This moves backward over a list as opposed to an s-expression. The
difference between this and backward-s-expression is that this first
searchs for a ``)'' and then moves to the matching ``(.'' This is use-
ful when you're trying to find unmatched parens in a program.
16.14. backward-paragraph [Unbound]
This moves point backward to the beginning of the current or previous
USD:17-38 JOVE Manual for UNIX Users
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 para-
graph to be indented differently from the other lines.
16.15. backward-s-expression ESC-^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 previous
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-up-list ESC-^U
This is similar to backward-s-expression except it backs up and OUT of
the enclosing s-expression. In other words, it moves backward to the
``('' that would match a ``)'' if you were to type it right then.
16.18. backward-word ESC-b
This moves point backward to the beginning of the current or previous
word.
16.19. bad-filename-extensions (variable)
This contains a list of words separated by spaces which are to be con-
sidered 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.20. begin-kbd-macro ^X-(
This starts defining the keyboard macro by remembering all your key
strokes until you execute end-kbd-macro, by typing ^X ). Because of a
bug in JOVE you shouldn't terminate the macro by typing ``ESC X end-
kbd-macro;'' end-kbd-macro must be bound to ^X ) in order to make things
work correctly. To execute the remembered key strokes you type ^X-E
which runs the execute-kbd-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.21. beginning-of-file ESC-<
This moves point backward to the beginning of the buffer. This some-
times 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.
JOVE Manual for UNIX Users USD:17-39
16.22. beginning-of-line ^A
This moves point to the beginning of the current line.
16.23. beginning-of-window ESC-,
This moves point to the beginning of the current window. The 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.24. bind-keymap-to-key [Unbound]
This is the way to build nested keymaps. For example, when JOVE starts
up, internally it does a
bind-keymap-to-key ES^map ^[
To make the arrow keys on vt100's work, you would do the following.
make-keymap vt100-map
bind-keymap-to-key vt100-map ^[[
bind-to-key next-line ^[[A
bind-to-key previous-line ^[[B
bind-to-key forward-character ^[[C
bind-to-key backward-character ^[[D
I may have gotten the escape sequences wrong, but you get the general
idea. Theoretically you can use these keymaps to bind arbitrarily long
key sequences, like those generated by the SUN keyboards, but that is a
bit of a pain because you will have to generate a bunch of keymaps by
hand, almost one per key, because of the way the key sequences are
organized. Eventually there will be a more general way to have these
keymaps built for you.
16.25. bind-macro-to-key [Unbound]
This is like bind-to-key except you use it to attach keys to named mac-
ros.
16.26. bind-macro-to-word-abbrev [Unbound]
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 (^@) and
then exchange the point and mark last (^X-^X).
16.27. bind-to-key [Unbound]
This attaches a key to an internal JOVE command so that future hits on
that key invoke that command. For example, to make ``^W'' erase the
previous word, you type ``ESC X bind-to-key kill-previous-word ^W.''
USD:17-40 JOVE Manual for UNIX Users
16.28. buffer-position [Unbound]
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.29. c-argument-indentation (variable)
This variable describes how to indent lines which are part of nested
expressions in C. The default is -1, which means to indent a continued
line by lining it up with the first argument of the current expression.
Otherwise, the line will be indented by c-argument-indentation charac-
ters past the indent of the first line of the expression. For example,
the default value produces:
Typeout(fmt, itoa(bcount++), line_cnt(b, nbuf),
TypeNames[b->b_type],
IsModified(b) ? "*" : b->b_ntbf ? "+" : NullStr,
buf_width, b->b_name, filename(b));
16.30. c-indentation-increment (variable)
This defines a set of tabstops independent of the value of internal-
tabstops and physical-tabstops. This value will be used in C mode, and
JOVE will insert the correct number of spaces and Tabs to get the right
behavior. For programmers that like to indent with 4 spaces, set this
value to 4. Don't set internal-tabstops to 4 because that will not work
anymore. Setting internal-tabstops to 4 tells JOVE to display Tabs as
every 4 spaces. This will cause your programs to look terrible with
anyone else who displays the file with normal tabstops at every 8 char-
acters. Not to mention printing your program won't look right. But all
that aside, if you set c-indentation-increment to 8 (the default), and
then set internal-tabstops to 4 as well, JOVE will insert TWO Tabs to
get the indentation to 8, which is clearly not what you want.
16.31. c-mode [Unbound]
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 little 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.32. case-character-capitalize [Unbound]
This capitalizes the character after point, i.e., the character under
the cursor. If a negative argument is supplied that many characters
before point are upper cased.
16.33. 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 variable is
JOVE Manual for UNIX Users USD:17-41
``off.''
16.34. case-region-lower ^X-^L
This changes all the upper case letters in the region to their lower
case equivalent.
16.35. case-region-upper ^X-^U
This changes all the lower case letters in the region to their upper
case equivalent.
16.36. 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.37. 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.38. 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.39. cd [Unbound]
This changes the current directory.
16.40. character-to-octal-insert [Unbound]
This inserts a Back-slash followed by the ascii value of the next char-
acter typed. For example, ^G inserts the string ``\007.''
16.41. clear-and-redraw ^L
This clears the entire screen and redraws all the windows. Use this
USD:17-42 JOVE Manual for UNIX Users
when JOVE gets confused about what's on the screen, or when the screen
gets filled with garbage characters or output from another program.
16.42. 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.43. compile-it ^X-^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 command. To compile a C program without
``make,'' use ^U ^X-^E and JOVE will prompt for a command to run instead
of make. (And then the command you type will become the default com-
mand.) You can use this to parse the output from the C compiler or the
``grep'' or ``lint'' programs. See also error-format-string to make it
possible to parse errors of a different format.
16.44. continue-process [Unbound]
This sends SIGCONT to the current interactive process, if the process is
currently stopped.
16.45. 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 com-
mand. See the kill-region and yank commands.
16.46. current-error [Unbound]
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.47. date [Unbound]
This prints the date on the message line.
16.48. dbx-format-string (variable)
This is the default regular-expression search string used by JOVE to
parse output from dbx running in a shell process. The default format
string works when you type ``where'' or while you're stepping through a
program, or when you reach a breakpoint. You shouldn't have to change
this unless you are using gdb or some other symbolic debugger.
JOVE Manual for UNIX Users USD:17-43
16.49. define-global-word-abbrev [Unbound]
This defines a global abbreviation.
16.50. define-macro [Unbound]
This provides a different mechanism for defining keyboard macros.
Instead of gathering keystrokes and storing them into the ``keyboard-
macro'' (which is how start-kbd-macro works), define-macro prompts for a
macro name (terminated with Space, or Newline) and then for the actual
macro body. If you wish to specify control characters in the macro, you
may simply insert them (using the quoted-insert command) or by inserting
the character '^' followed by the appropriate letter for that character
(e.g., ^A would be the two characters '^' followed by 'A'). You may use
Back-slash to prevent the '^' from being interpreted as part of a con-
trol character when you really wish to insert one (e.g., a macro body
``\^foo'' would insert the string ``^foo'' into the buffer, whereas the
body ``^foo'' would be the same as typing ^F and then inserting the
string `oo''). See write-macros-to-file to see how to save macros.
16.51. define-mode-word-abbrev [Unbound]
This defines a mode-specific abbreviation.
16.52. delete-blank-lines ^X-^O
This deletes all the blank lines around point. This is useful when you
previously opened many lines with ^O and now wish to delete the unused
ones.
16.53. delete-buffer ^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 forever. 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.54. delete-current-window ^X-d
This deletes the current window and moves point into one of the remain-
ing ones. It is an error to try to delete the only remaining window.
16.55. delete-macro [Unbound]
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 for-
ever. If you are about to save macros to a file and decide you don't
want to save a particular one, delete it.
16.56. delete-next-character ^D
This deletes the character that's just after point (that is, the charac-
ter under the cursor). If point is at the end of a line, the line
USD:17-44 JOVE Manual for UNIX Users
separator is deleted and the next line is joined with the current one.
16.57. delete-other-windows ^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.58. delete-previous-character Backspace, or ^H
This deletes the character that's just before point (that is, the char-
acter 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.59. delete-white-space ESC-\
This deletes all the Tabs and Spaces around point.
16.60. describe-bindings [Unbound]
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 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.61. describe-command ESC-?
This prints some info on a specified command.
16.62. describe-key ^X-?
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 ESC-? describe-command to find out exactly what
it does.
16.63. describe-variable [Unbound]
This prints some info on a specified variable.
16.64. 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 com-
mand. Then that command is executes with the numeric argument you
specified.
16.65. digit-1 [Unbound]
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 argument.
JOVE Manual for UNIX Users USD:17-45
16.66. digit-2 [Unbound]
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 argument.
16.67. digit-3 [Unbound]
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 argument.
16.68. digit-4 [Unbound]
This pretends you typed ``ESC 4.'' 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 argument.
16.69. digit-5 [Unbound]
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 argument.
16.70. digit-6 [Unbound]
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 argument.
16.71. digit-7 [Unbound]
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 argument.
16.72. digit-8 [Unbound]
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 argument.
16.73. digit-9 [Unbound]
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
USD:17-46 JOVE Manual for UNIX Users
type ``ESC'' when you want to specify an argument.
16.74. digit-0 [Unbound]
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 argument.
16.75. dirs [Unbound]
This prints out the directory stack. See the cd, pushd, popd commands
for more info.
16.76. 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 immedi-
ately apparent but will not cause indiscriminate writing on the
display). The default is ``off.''
16.77. display-bad-filenames (variable)
This variable affects only filename completion, in particular, what hap-
pens when ``?'' is typed while prompting for a file. When this variable
is ON, any files that end with one of the extensions defined by the
variable bad-filename-extensions will be displayed with an ``!'' in
front of their names. When display-bad-filenames is OFF the files will
not be displayed at all. The default value is on.
16.78. down-list ESC-^D
This is the opposite of backward-up-list. It's not clear to me that
this command serves any useful purpose in life. Try it out, and let me
know what you think.
16.79. dstop-process [Unbound]
Send the ``dsusp'' character to the current process. This is the char-
acter that suspends a process on the next read from the terminal. Most
people have it set to ^Y. This only works if you have the interactive
process feature, and if you are in a buffer bound to a process.
16.80. edit-word-abbrevs [Unbound]
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 abbrevi-
ations 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 ^X-^C to exit
the recursive edit.
JOVE Manual for UNIX Users USD:17-47
16.81. end-kbd-macro ^X-)
This stops the definition of the keyboard macro. Because of a bug in
JOVE, this must be bound to ^X-), or some key sequence which is one or
two characters long. Anything else will not work properly.
16.82. end-of-file ESC->
This moves point forward to the end of the buffer. This sometimes
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.83. end-of-line ^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 leftmost visible character or
when you move off the line altogether.
16.84. end-of-window ESC-.
This moves point to the last character in the window.
16.85. eof-process [Unbound]
Sends EOF to the current interactive process. This only works on ver-
sions of JOVE running under versions of UNIX with pty's.
16.86. erase-buffer [Unbound]
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.87. error-format-string (variable)
This is the error format string that is used by parse-errors to find the
error messages in a buffer. The way it works is by using this string as
a JOVE regular expression search string, where the \('s and \)'s regular
expression operators are used to pick out the file name and line number
from the line containing an error message. For instance, a typical
error message might look like this:
"file.c", line 540: missing semi-colon
For strings of this format, an appropriate value for error-format-string
would be something like this:
^"\([^"]*\)", line \([0-9]*\):
What this means is, to find an error message, search for a line
USD:17-48 JOVE Manual for UNIX Users
beginning with a double-quote. Then it says that all the following
characters up to another double-quote should be remembered as one unit,
namely the filename that the error is in (that's why the first set of
parens are surrounding it). Then it says that after the filename there
will be the string ``, line '' followed by a line number, which should
be remembered as a single unit (which is why the second set of parens is
around that). The only constraints on the error messages is that the
file name and line number appear on the same line, and that the file
name appears before the line number. Most compilers seem to do this
anyway, so this is not an unreasonable restriction.
If you do not know how to use regular expressions then this variable
will be hard for you to use. Also note that you can look at the default
value of this variable by printing it out, but it is a really compli-
cated string because it is trying to accommodate the outputs of more
than one compiler at a time.
16.88. 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.89. exchange-point-and-mark ^X-^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.90. execute-kbd-macro ^X-e
This executes the keyboard macro. If you supply a numeric argument the
macro is executed that many times.
16.91. execute-macro [Unbound]
This executes a specified macro. If you supply a numeric argument the
macro is executed that many times.
16.92. 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 command. 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 find yourself constantly executing the same com-
mands 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.93. exit-jove ^X-^C
This exits JOVE. If any buffers need saving JOVE will print a warning
JOVE Manual for UNIX Users USD:17-49
message and ask for confirmation. If you leave without saving your
buffers all your work will be lost. If you made a 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.94. expand-environment-variables (variable)
When this variable is on JOVE will try to expand any strings of the form
``$var'' into the value of the environment variable ``var'' when in the
minibuffer. For example, if you type $HOME/.joverc, ``$HOME'' will be
replaced with you home directory. The default value is off.
16.95. 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.96. files-should-end-with-newline (variable)
This variable indicates that all files should always have a newline at
the end. This is often necessary for line printers and the like. When
set, if JOVE is writing a file whose last character is not a newline, it
will add one automatically.
16.97. fill-comment [Unbound]
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 char-
acter 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.98. 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 possible, ensuring that
none of the lines will be greater than the right margin. The default
value for right-margin is 72, but can be changed with the set and
right-margin-here commands. JOVE has a complicated algorithm for deter-
mining 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 ^U ESC-j) and JOVE will indent each line
USD:17-50 JOVE Manual for UNIX Users
to the column specified by the left-margin variable. See also the
left-margin variable and left-margin-here command.
16.99. fill-region [Unbound]
This is like fill-paragraph, except it operates on a region instead of
just a paragraph.
16.100. filter-region [Unbound]
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 ^Y.
16.101. find-file ^X-^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.102. find-tag ^X-t or ^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 variable 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.103. find-tag-at-point [Unbound]
This finds the file that contains the tag that point is currently on.
See find-tag.
16.104. first-non-blank ESC-m
This moves point back to the indent of the current line.
16.105. forward-character ^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.
JOVE Manual for UNIX Users USD:17-51
16.106. forward-list ESC-^N
This is like forward-s-expression except it moves over lists ONLY. What
this does is search for the next ``('' and then move to the matching
``).'' This is useful for when you are trying to find mismatched
parentheses in a program.
16.107. forward-paragraph ESC-]
This moves point forward to the end of the current or next 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.108. forward-s-expression ESC-^F
This moves point forward over a s-expression. If the first significant
character after point is ``(,'' this moves past the matching ``).'' 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 identif-
iers in C mode. JOVE also matches ``{.''
16.109. forward-sentence ESC-e
This moves point forward to the end of the current or next sentence.
JOVE considers the end of a sentence to be the characters ``.'', ``!''
or ``?'' followed by a Return, or one or more spaces.
16.110. forward-word ESC-f
This moves point forward to the end of the current or next word.
16.111. fundamental-mode [Unbound]
This sets the major mode to Fundamental. This affects what JOVE consid-
ers 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.112. gather-numeric-argument ^U
This command is one of two ways to specify a numeric argument to a com-
mand. It's usually bound to ^U. Typing ^U once means, Do the next com-
mand 4 times. Typing ^U twice will do the next command 16 times, and so
on. If at any point you type a number, then that number will be used
instead of 4. For instance, ^U 3 5 means do the next command 35 times.
16.113. goto-line ESC-g
If a numeric argument is supplied point moves to the beginning of that
line. If no argument is supplied one is prompted for.
USD:17-52 JOVE Manual for UNIX Users
16.114. goto-window-with-buffer [Unbound]
This command prompts for a buffer name and then selects that buffer. If
the buffer is currently being displayed in one of the windows, that win-
dow is selected instead.
16.115. grind-s-expr [Unbound]
When point is positioned on a ``(,'' this re-indents that LISP expres-
sion.
16.116. grow-window ^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.117. handle-tab ^I
This handles indenting to the ``right'' place in C and Lisp mode, and
just inserts itself in Text mode.
16.118. i-search-forward [Unbound]
Incremental search. Like search-forward except that instead of prompt-
ing for a string and searching for that string all at once, it accepts
the string one character at a time. After each character 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 ^H and the search will back up to the
position before that character was typed. ^G aborts the search.
16.119. i-search-reverse ^R
Incremental search. Like search-reverse except that instead of prompt-
ing for a string and searching for that string all at once, it accepts
the string one character at a time. After each character 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 ^H and the search will back up to the
position before that character was typed. ^G aborts the search.
16.120. i-shell-command [Unbound]
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.
16.121. insert-file ^X-^I
This inserts a specified file into the current buffer at point. Point
is positioned at the beginning of the inserted file.
JOVE Manual for UNIX Users USD:17-53
16.122. internal-tabstop (variable)
The number of spaces JOVE should print when it displays a tab character.
The default value is 8.
16.123. interrupt-character (variable)
This is set to the character that interrupts JOVE (with a signal) no
matter what JOVE is doing. It's main use is for interrupting non-
interactive processes, but it also has uses for debugging. Unfor-
tunately there is no way to turn off the interrupt character.
16.124. interrupt-process [Unbound]
This sends the interrupt character (usually ^C) to the interactive pro-
cess 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.125. kill-next-word ESC-d
This kills the text from point to the end of the current or next word.
16.126. kill-previous-word ESC-^H or ESC-
Backspace
This kills the text from point to the beginning of the current or previ-
ous word.
16.127. kill-process [Unbound]
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.128. kill-region ^W
This deletes the text in the region and saves it on the kill ring. Com-
mands that delete text but save it on the kill ring all have the word
``kill'' in their names. Type ^Y to yank back the most recent kill.
16.129. kill-s-expression ESC-^K
This kills the text from point to the end of the current or next s-
expression.
16.130. kill-some-buffers[Unbound]
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.
USD:17-54 JOVE Manual for UNIX Users
16.131. kill-to-beginning-of-sentence ^X-^H or ^X-
Backspace
This kills from point to the beginning of the current or previous sen-
tence.
16.132. kill-to-end-of-line ^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.133. kill-to-end-of-sentence ESC-k
This kills from point to the end of the current or next sentence. If a
negative numeric argument is supplied it kills from point to the begin-
ning of the current or previous sentence.
16.134. 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 ^J). It
is also used by fill-paragraph and auto-fill mode. If the value is zero
(the default) then the left margin is determined from the surrounding
lines.
16.135. left-margin-here [Unbound]
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 actually is.
16.136. lisp-mode [Unbound]
This turns on Lisp mode. Lisp mode is one of four mutually exclusive
major modes: Fundamental, Text, C, and Lisp. In Lisp mode, the charac-
ters Tab and ) are treated specially, similar to the way they are
treated in C mode. Also, Auto Indent mode is affected, and handled spe-
cially.
16.137. list-buffers ^X-^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
JOVE Manual for UNIX Users USD:17-55
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,'' ``IProcess.'' ``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 com-
mand; ``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.
16.138. list-processes [Unbound]
This makes a list somewhat like list-buffers does, except its list con-
sists of the current interactive processes. Right now the list looks
like this:
Buffer Status Pid Command
------ ------ --- -------
*shell* Running 18415shell
fgrep Done 18512 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 process 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; otherwise the process is running.
The last column is the name of the command that is being run.
16.139. mail-check-frequency (variable)
This is how often (in seconds) JOVE should check your mailbox for incom-
ing mail. If you set this to ZERO JOVE won't check for new mail. See
also the mailbox and disable-biff variables.
16.140. 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.141. 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.
USD:17-56 JOVE Manual for UNIX Users
16.142. 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.143. make-keymap [Unbound]
This creates an empty keymap with a name you supply. That name can be
used to reference the keymap in other commands, such as bind-keymap-to-
key.
16.144. make-macro-interactive ESC-i
This command is meaningful only while you are defining a keyboard macro,
and when you are in the minibuffer. 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 defini-
tion. If you 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 argument which
will be used during the definition process.
16.145. 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.146. 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 posi-
tion of a mark is adjusted to compensate for each insertion and dele-
tion. This makes marks much more sensible to use, at the cost of slow-
ing down insertion and deletion somewhat. The default value is ``on.''
16.147. 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 ``Search-
ing with Regular Expressions'' for more information.
16.148. 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
JOVE Manual for UNIX Users USD:17-57
can be entered by holding down Meta and typing Y. NOTE: In some sys-
tems, this disables interrupting noninteractive shell commands.
16.149. 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 format similar to that used
by printf(3), with the special things being marked as ``%x.'' Digits
may be used between the 'x' may be:
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 extra space in modeline is distributed evenly
among the place %e is used (used for justifying,
separating, or centering parts of the modeline)
f the current file name
l the current load average (updated automatically)
mxy x, when the buffer is modified or y, when not
n the current buffer number
p interactive process status for process windows
s space, but only if previous character is not a space
t the current time (updated automatically)
w a '>' for windows which are scrolled left
[ ] 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.150. 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.151. name-kbd-macro [Unbound]
This copies the keyboard macro and gives it a name freeing up the key-
board 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
define-macro, source and write-macros-to-file commands.
16.152. newline Return or ^M
This divides the current line at point moving all the text to the right
USD:17-58 JOVE Manual for UNIX Users
of point down onto the newly created line. Point moves down to the
beginning of the new line.
16.153. newline-and-backup ^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.
16.154. newline-and-indent ^J
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.155. next-error ^X-^N
This moves to the next error in the list of errors that were parsed with
parse-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 con-
tains the error. Point is positioned in this window on the line where
the error occurred.
16.156. next-line ^N
This moves down to the next line.
16.157. next-page ^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.158. next-window ^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.159. number-lines-in-window [Unbound]
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.160. over-write-mode [Unbound]
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
JOVE Manual for UNIX Users USD:17-59
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, ^H 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.
16.161. page-next-window ESC-^V
This displays the next page in the next window. This is exactly the
same as ^X-n ^V ^X-p.
16.162. 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.163. 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.164. parse-errors [Unbound]
This takes the list of C compilation errors (or output from another pro-
gram 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. current-error is automatically executed
after one of the parse commands, so you end up at the first error. See
also error-format-string to make it possible to parse errors of a dif-
ferent format.
16.165. parse-spelling-errors-in-buffer [Unbound]
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.166. pause-jove ESC-p
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 con-
trol facility. To return to JOVE you type fg to the shell.
16.167. physical-tabstop (variable)
How many spaces your terminal prints when it prints a tab character.
USD:17-60 JOVE Manual for UNIX Users
16.168. pop-mark [Unbound]
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 backward through
the ring of marks. If you execute pop-mark enough times you will even-
tually get back to where you started.
16.169. popd [Unbound]
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.170. previous-error ^X-^P
This is the same as next-error except it goes to the previous error.
See next-error for documentation.
16.171. previous-line ^P or ^P-^P
This moves up to the previous line.
16.172. 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 argu-
ment is supplied the screen is scrolled down that many lines; if the
argument is negative the screen is scrolled up.
16.173. previous-window ^X-p or ^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 previous one
you are moved to the bottom window. It is an error to use this command
with only one window.
16.174. print [Unbound]
This prints the value of a JOVE variable.
16.175. process-bind-keymap-to-key [Unbound]
This is just like bind-to-key except that it starts at the process-
keymap map, instead of the default mainmap.
16.176. process-bind-to-key [Unbound]
This command is identical to bind-to-key, except that it only affects
your bindings when you are in a buffer attached to a process. When you
enter the process buffer, any keys bound with this command will automat-
ically 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
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, ^Z will execute stop-process and ^C will execute interrupt- pro-
cess. When you switch back to a non-process buffer, ^Z will go back to
executing scroll-up (or whatever you have it bound to).
16.177. process-dbx-output [Unbound]
This command only makes sense in a buffer running a shell process. If
you are running dbx in a window, JOVE will automatically find the file
you are currently stepping through and display it in another window.
The string DBX will appear in the modeline along with the other minor
modes when this feature is enabled.
16.178. process-newline [Unbound]
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.179. process-prompt (variable)
What a prompt looks like from the shell and i-shell-command processes.
The default is ``% ,'' the default C-hell 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.180. process-send-data-no-return [Unbound]
This is like process-newline except it sends everything to the process
without the newline. Normally, when you type return in a process buffer
it sends everything you typed including the Return. This command just
provides a way to send data to the process without having to send a new-
line as well.
16.181. push-shell [Unbound]
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
USD:17-62 JOVE Manual for UNIX Users
every time. To return to JOVE you type ^D.
16.182. pushd [Unbound]
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.183. pwd [Unbound]
This prints the working directory.
16.184. query-replace-string ESC-q
This replaces the occurrences of a specified string with a specified
replacement string. When an occurrence is found point is moved to it
and then JOVE asks what to do. The options are:
Spaceto replace this occurrence and go on to the next one.
Periodto replace this occurrence and then stop.
^H to skip this occurrence and go on to the next one.
^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 ^X-^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.
^W to delete the matched string and then enter a recursive
edit.
U to undo all changes to the last modified line.
P or !to go ahead and replace the remaining occurrences without
asking.
Returnto 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.185. quit-process [Unbound]
This is the same as typing ``^\'' (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 pro-
cess.
16.186. quoted-insert ^~ or ^_ or ^/ or ^.
This lets you insert characters that normally would be executed as other
JOVE commands. For example, to insert ``^F'' you type ^~ ^F.
JOVE Manual for UNIX Users USD:17-63
16.187. read-only-mode [Unbound]
Read-only-mode is a minor mode. It puts a buffer in read-only mode, so
that any attempts to modify the buffer fail. When a file is found, and
it's not got write permission, JOVE automatically puts the buffer in
read-only mode. This is very helpful when you are in environments which
use source control programs like RCS and SCCS. It prevents accidents
like making a bunch of changes and only THEN discovering that you
haven't checked the file out for making changes. This, like other minor
modes, toggles.
16.188. read-word-abbrev-file [Unbound]
This reads a specified file that contains a bunch of abbreviation defin-
itions, and makes those abbreviations available. If the selected buffer
is not already in Word Abbrev mode this command puts it in that mode.
16.189. recursive-edit [Unbound]
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.190. redraw-display ESC-^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 example, ESC-0 ESC-^L positions the
line containing point at the top of the window.
16.191. rename-buffer [Unbound]
This lets you rename the current buffer.
16.192. replace-in-region [Unbound]
This is the same as replace-string except that it is restricted to
occurrences between Point and Mark.
16.193. replace-string ESC-^E
This replaces all occurrences of a specified string with a specified
replacement string. This is just like query-replace-string except it
replaces without asking.
16.194. right-margin (variable)
Where the right margin is for ``Auto mode and the justify-paragraph and
justify-region commands. The default is 72.
16.195. right-margin-here [Unbound]
This sets the right-margin variable to the current position of point.
USD:17-64 JOVE Manual for UNIX Users
This is an easy way to say, ``Make the right margin begin here,''
without having to count the number of spaces over it actually is.
16.196. save-file ^X-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 save. If you
really do want to write the file you can use ^X-^W which executes
write-file.
16.197. scroll-all-lines (variable)
When this is turned on, the entire window will be scrolled left or right
when the current line scrolls. The default value is OFF, which will
cause JOVE to behave in the familiar way, namely to scroll only the
current line.
16.198. 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.199. scroll-left [Unbound]
This scrolls the text in the current window 10 character positions to
the left. If a numeric argument is specified then the text is scrolled
that number of character positions. If the variable scroll-all-lines is
ON then scroll-left may actually do nothing if the scrolling would cause
Point not to be visible.
16.200. scroll-right [Unbound]
This scrolls the text in the current window 10 character positions to
the right. If a numeric argument is specified then the text is scrolled
that number of character positions. If the variable scroll-all-lines is
ON then scroll-right may actually do nothing if the scrolling would
cause Point not to be visible.
16.201. scroll-step (variable)
How many lines should be scrolled if the previous-line or next-line com-
mands move you off the top or bottom of the screen. You may wish to
decrease this variable if you are on a slow terminal. The default value
is 0, which means to center the current line in the window. If the
value is negative, the behavior is slightly different. If you move off
the top of the window, and scroll-step is, say, -5 then the new line
will be displayed 5 lines from the bottom of the window. If you move
off the bottom of the window, the new line will be positioned 5 lines
from the top of the window.
JOVE Manual for UNIX Users USD:17-65
16.202. scroll-up ^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 win-
dow. If a numeric argument is supplied that many lines are scrolled; if
the argument is negative the screen is scrolled down instead.
16.203. 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.204. search-forward ESC-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.205. search-forward-nd [Unbound]
This is just like search-forward except that it doesn't assume a default
search string, and it doesn't set the default search string. This is
useful for defining macros, when you want to search for something, but
you don't want it to affect the current default search string.
16.206. search-reverse ESC-r
This searches backward for a specified search string and positions 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 begin-
ning of the buffer, so any matches after point will be missed.
16.207. search-reverse-nd [Unbound]
This is just like search-reverse except that it doesn't assume a default
search string, and it doesn't set the default search string. This is
useful for defining macros, when you want to search for something, but
you don't want it to affect the current default search string.
16.208. select-buffer ^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 typ-
ing Escape or Space will complete it for you. If you want to create a
new buffer you can type Return instead of Space, and a new empty buffer
will be created.
16.209. self-insert (Most Printing Charac-
ters)
This inserts the character that invoked it into the buffer at point.
USD:17-66 JOVE Manual for UNIX Users
Initially all but a few of the printing characters are bound to self-
insert.
16.210. 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 commands like
list-buffers, list-processes, and commands that use completion. The
default value is ``off.''
16.211. set [Unbound]
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.212. set-mark ^@ or ^SPACE
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 previous 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 ^U ^@, or execute the pop-mark command. If you
type this enough times you will get back to where you started.
16.213. 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.214. shell [Unbound]
This starts up an interactive shell in a window. JOVE uses ``*shell*''
as the name of the buffer in which the interacting takes place. See the
manual for information on how to use interactive processes.
16.215. shell-command ^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 window. 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 hold-
ing 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.
JOVE Manual for UNIX Users USD:17-67
16.216. shell-command-no-buffer [Unbound]
This is just like shell-command except it just runs the command without
saving the output to any buffer. It will report the success of the com-
mand in the usual way.
16.217. shell-command-to-buffer [Unbound]
This is just like shell-command except it lets you specify the buffer to
use instead of JOVE.
16.218. shell-command-with-typeout [Unbound]
This is just like shell-command except that instead of saving the output
to a buffer, and displaying it in a window, this just types out the out-
put in the same way that list-buffers does. Actually, how this behaves
depends on the value of the variable send-typeout-to-buffer. If it is
on then shell-command-with-typeout will behave just like shell-command.
16.219. 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.220. shift-region-left [Unbound]
This shifts the region left by c-indentation-increment OR by the numeric
argument, if one is supplied. If a negative argument is supplied the
region is shifted the other way.
16.221. shift-region-right [Unbound]
This shifts the region left by c-indentation-increment OR by the numeric
argument, if one is supplied. If a negative argument is supplied the
region is shifted the other way.
16.222. show-match-mode [Unbound]
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 compli-
cated 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 visi-
ble, the line containing the match is displayed at the bottom of the
screen.
16.223. shrink-window [Unbound]
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
USD:17-68 JOVE Manual for UNIX Users
mode line.
16.224. source [Unbound]
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 ^R call the i-search-reverse command and ^S call
i-search-forward and ESC S call pause-jove.
16.225. spell-buffer [Unbound]
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.
16.226. split-current-window ^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 ^X-1 to go back to 1 window mode. If a numeric
argument is supplied, the window is split ``evenly'' that many times
(when possible).
16.227. start-remembering ^X-(
This is just another name for the begin-kbd-macro name. It is included
for backward compatibility.
16.228. stop-process [Unbound]
This sends a stop signal (^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.229. stop-remembering ^X-)
This is just another name for the end-kbd-macro command. It is included
for backward compatibility.
16.230. string-length ^X-c
This prints the number of characters in the string that point sits in.
Strings are surrounded by double quotes. JOVE knows that ``\007'' is
JOVE Manual for UNIX Users USD:17-69
considered a single character, namely ^G, and also knows about other
common ones, like ``\r'' (Return) and ``\n'' (LineFeed). This is mostly
useful only for C programmers.
16.231. suspend-jove ESC-p
This is a synonym for pause-jove.
16.232. 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 probably shouldn't fool
with this.
16.233. tag-file (variable)
This the name of the file in which JOVE should look up tag definitions.
The default value is ``./tags.''
16.234. text-mode [Unbound]
This sets the major mode to Text. Currently the other modes are Funda-
mental, C and Lisp mode.
16.235. tmp-file-pathname (variable)
This tells JOVE where to put the tmp files, which is where JOVE stores
buffers internally. The default is usually in /tmp, but if you want to
store them somewhere else, you can set this variable. If your system
crashes a lot it might be a good idea to set this variable to somewhere
other than /tmp because the system removes all the files in /tmp upon
reboot, and so you would not be able to recover editor buffers using the
``jove -r'' command.
NOTE: In order for this to work correctly you must set this variable
BEFORE JOVE creates the tmp file. You can set this in your .joverc (the
closer to tbe beginning the better), or as soon as you start up JOVE
before you visit any files.
16.236. transpose-characters ^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 ^T to drag a character down the
length of a line. This command pretty quickly becomes very useful.
16.237. transpose-lines [Unbound]
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.
USD:17-70 JOVE Manual for UNIX Users
16.238. unbind-key [Unbound]
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.239. 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.240. 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 charac-
ter capability, you will get weird (perhaps fatal) results.
16.241. version [Unbound]
Displays the version number of this JOVE.
16.242. visible-bell (variable)
Use the terminal's visible bell instead of beeping. This is set
automatically if your terminal has the capability.
16.243. visible-spaces-in-window [Unbound]
This displays an underscore character instead of each space in the win-
dow 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.244. visit-file ^X-^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.245. window-find ^X-4
This lets you select another buffer in another window three different
ways. This waits for another character which can be one of the follow-
ing:
JOVE Manual for UNIX Users USD:17-71
T Finds a tag in the other window.
^T Finds the tag at point 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 ^X-2 (or ^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 hav-
ing to redisplay. In addition, you don't have to decide whether to type
^X-2 or ^X-o since ^X-O ^X-4 does the right thing.
16.246. word-abbrev-mode [Unbound]
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 abbrevia-
tion) 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 abbrevia-
tion 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. 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 yourself.
16.247. 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.248. write-file ^X-^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.249. 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.250. write-macros-to-file [Unbound]
This writes the currently defined macros to a specified file in a format
USD:17-72 JOVE Manual for UNIX Users
appropriate for reading them back in with the source command. The pur-
pose of this command is to allow you to define macros once and use them
in other instances of JOVE.
16.251. write-modified-files ^X-^M or ^X-RETURN
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.252. write-region [Unbound]
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.253. write-word-abbrev-file [Unbound]
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.254. yank ^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 ^Y yanks back all of them.
16.255. 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 following a ^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.
WE REALLY WANT TO KNOW...
Have you found this publication useful? Are there ways we
might improve or supplement it or other ITC publications?
Did you find this document in Web or in hard copy?
We really want your opinion. Send e-mail to: newsdesk@virginia.edu