








                   [1mJOVE Manual for UNIX Users[0m
                          [1mVersion 4.16[0m

                         [4mJonathan[24m [4mPayne[0m
[4m(with[24m [4mrevisions[24m [4mby[24m [4mDoug[24m [4mKingston,[24m [4mMark[24m [4mSeiden[24m [4mand[24m [4mCharles[24m [4mLindsey)[0m




[1m1.  Introduction[0m

JOVE*  is  an  advanced,  self-documenting, customizable, display
editor.  It (and this tutorial introduction)  are  based  on  the
original  EMACS  editor  and  user  manual  written  at M.I.T. by
Richard Stallman|-.

JOVE is considered a display editor  because  normally  the  text
being  edited  is  visible on the screen and is updated automati-
cally as you type your commands.  What You See Is What You Get.

JOVE provides many facilities that go beyond simple insertion and
deletion.  Some of the more advanced features are:

     cut and paste (or kill and yank in our terminology);
     search and replace using regular-expressions;
     multiple files, buffers and windows available simultaneously;
     filling of text, both on demand and as you type;
     manipulation of words, lines, sentences and paragraphs;
     automatic indentation of programs;
     automatic location of procedure definitions;
     executing programs, capturing their output in buffers;
     automatic location of spelling and compilation errors;
     parenthesis matching.


JOVE  is self-documenting insofar as you can call up descriptions
of commands, variables and key bindings.







-----------
*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 simi-
lar, there are some major differences between the  two
editors,  and  you  should  not rely on their behaving
identically.









2                   JOVE Manual for UNIX Users


JOVE is customizable insofar as you can

     change its behavior by changing appropriate variables;
     change its behavior by setting appropriate modes;
     automatically set the modes for a buffer from its filename;
     define macros to perform complex tasks;
     change the key bindings to match features of the particular keyboard.

All of these options can be exercised by the  system  administra-
tor, or by the user at startup, or even in the middle of a job.

Finally, mouse support is available (on screens which support the
X-Windows package from M.I.T.)  using the front end program [4mxjove[0m
(or  alternatively via the mouse-reporting facilities of the ter-
minal emulator [4mxterm[24m).

[1m2.  The Organization of the Screen[0m

JOVE divides the screen into several sections.

+--------------------------------------------------+|
|#include <stdio.h>                                ||
|                                                  ||
|void main()                                       ||
|{                                                 ||
|    printf("Hello world!\n");                     ||
|    return 0;                                     ||< the Window
|}                                                 ||
|                                                  ||
+--------------------------------------------------+|
|[1mJOVE (C OvrWt)   [Main:1]  "hello.c"  *  /home/foo[22m||< the Mode Line
+--------------------------------------------------+|
|: write-file (default hello.c) aloha.c[]          ||< the Message Line
+--------------------------------------------------+|


[1m2.1.  The Window[0m

The Window section is used to display the text you  are  editing.
The  terminal's  cursor shows the position of [4mpoint[24m, the location
at which editing takes place.  While the cursor appears to  point
[4mat[24m a character, point should be thought of as between characters;
it points [4mbefore[24m the character that the cursor appears to  be  on
top  of.   Terminals  have only one cursor, and when output is in
progress it must appear where the typing  is  being  done.   This
doesn't  mean  that  point is moving; it is only that JOVE has no
way of showing you the location of point except when the terminal
is  idle.  In the example, the user is in the middle of issuing a
[4mwrite-file[24m command, so the cursor is at the end  of  the  message
line.













                    JOVE Manual for UNIX Users                  3


[1m2.1.1.  Typeout[0m

The lines of the window are usually available for displaying text
but sometimes are pre-empted by  typeout  from  certain  commands
(such as a listing of all the buffers).  You can always recognize
such [4mtypeout[24m because it is terminated by either an  [1m--end--  [22mline
or  a [1m--more-- [22mline.  Most of the time, output from commands like
these is only desired for a short period of  time,  usually  just
long  enough  to glance at it.  When you have finished looking at
the output, you can type Space to make the text reappear (usually
a  Space  that you type inserts itself, but when there is typeout
in the window, it does nothing but get rid of that).   Any  other
command executes normally, [4mafter[24m redrawing your text.

You  will  see [1m--more-- [22mon the line above the last mode line when
typeout from a command is too long to  fit  on  the  screen.   It
means that if you type a Space the next screenful of typeout will
be printed.  If you are not interested, typing ^G will cause  the
rest  of  the  output to be discarded.  Typing any other key will
discard the rest of the output and that key will be taken as  the
next  keyboard  input.  Similarly, [1m--end-- [22msignifies that typeout
is complete; the same responses are accepted.

Sometimes you may wish to keep a permanent record of the  typeout
from  these commands.  To do this, set the variable [4msend-typeout-[0m
[4mto-buffer[24m to [4mon[24m.  The typeout will then be put into a  newly-cre-
ated buffer, which you can arrange to save to a permanent file.

[1m2.2.  The Mode Line[0m

The Mode Line gives information about the window above it.  There
is a variable [4mmode-line[24m which determines the layout of  the  mode
line.   For  the  example above, this was set as described in the
section on customizing JOVE.

[1m(C OvrWt) [22mshows that [1mC [22mis the name of the current [4mmajor[24m [4mmode[24m  and
that the Over Write [4mminor[24m [4mmode[24m is turned on.

At any time, JOVE can be in only one major mode.  Currently there
are four major modes: [4mFundamental[24m, [4mText[24m, [4mLisp[24m and  [4mC[24m.   New  ones
may be added in the future.

The words which indicate which minor modes are turned on are:

     [1mAbbrev [22mmeaning that [4mWord[24m [4mAbbrev[24m mode is on;
     [1mAI [22mmeaning that [4mAuto[24m [4mIndent[24m mode is on;
     [1mFill [22mmeaning that [4mAuto[24m [4mFill[24m mode is on;
     [1mOvrWt [22mmeaning that [4mOver[24m [4mWrite[24m mode is on;
     [1mRO [22mmeaning that [4mRead[24m [4mOnly[24m mode is on.
     [1mDBX [22mmeaning that [4mDBX[24m mode is on.
     [1mDef [22mmeaning 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.









4                   JOVE Manual for UNIX Users


[1m[Main:1] [22mshows that the name of the currently selected [4mbuffer[24m  is
[1mMain [22mand its number is [1m1[22m.  Each buffer has its own name and holds
a file being edited, which is how JOVE can hold several files  at
once.   But  at  any given time you are editing only one of them,
the [4mselected[24m buffer.  When we speak of what some command does  to
"the buffer", we are talking about the currently selected buffer.
Multiple buffers make 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.

[1m"hello.c" [22mshows the name of the file being edited in buffer [1mMain[22m.
This  is  also  the  default  filename for commands that expect a
filename as input, as can be seen in the message line which  fol-
lows.

The * in the mode line means that there are changes in the buffer
that have not been saved in the file.  If the buffer had not been
changed  since  it  was  read  in or last saved, there would be a
minus instead.

Sometimes a file is changed  ``behind  JOVE's  back'':  something
changes  the  file (not the buffer) after it has been loaded into
or saved from a buffer.  This can be  quite  dangerous,  so  JOVE
tests  for  this  when it reads, writes, or finds the file.  JOVE
indicates the problem by displaying a # before the change indica-
tor.  It also asks for confirmation before performing the read or
write.

[1m/home/foo [22mshows the name of the current directory.

[1m15.23 [22mshows the time.

[1m2.3.  The Message Line[0m

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  temporar-
ily  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 ^G to abort,  and
you can then continue with your editing.

The message line and the list of filenames from the shell command
that invoked JOVE are kept in a  special  buffer  called  [4mMinibuf[0m
that  can  be edited like any other buffer.  It is instructive to
view the Minibuf in a window and to observe  how  it  changes  as
parameters  to commands are typed, and as the ^N and ^P functions
are invoked.

[1m2.4.  Multiple Windows[0m

The window area, described above, can in fact be split into  sev-
eral  [4mwindows[24m,  each  showing  a  different  [4mbuffer[24m,  or possibly









                    JOVE Manual for UNIX Users                  5


different parts of the same buffer.  Each window has its own mode
line  beneath it.  The methods of creating and destroying windows
will be described presently.

[1m3.  Input Conventions[0m


[1m3.1.  Keyboard Usage[0m

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 a circumflex  (^)  followed  by  another
character.   Thus,  ^A  is  the character you get when you type A
with the Control key (sometimes labeled CTRL) held down.  Control
characters  in  the JOVE buffer are displayed with a caret; thus,
^A for Control-A.  DEL is displayed as ^?, ESC as ^[.

If the keyboard has extra keys, such as Function keys, Arrow keys
and the like, then JOVE can be customized to use them.

[1m3.2.  The Character Set[0m

JOVE normally accepts the ASCII character set, with its 95 print-
ing characters, including Space, (which appear on the  screen  as
themselves) and its 33 Control characters (which, except for TAB,
appear on the screen as, e.g. "^C").   There  are,  however,  two
characters that may not appear.  One is the NL character (because
it is always converted into a [4mline-separator[24m, which is not  quite
a  character)  and  the  other is the NUL character (^@) which is
used internally within JOVE to delimit lines (lines also  have  a
maximum length, which is 1023 in most systems).

However,  JOVE  is  "8-bit clean", so if your keyboard is able to
produce all 256 8-bit characters, the extra ones will  appear  in
octal  (e.g.  "\277").  Moreover, if your UNIX(R) system supports
the [4mLocale[24m facility (as most modern ones do),  you  may  set  the
variable  [4mlc-ctype[24m to "C" (the default, which corresponds to pure
ASCII), or to "iso_8859_1"  (which  corresponds  to  the  Latin-1
alphabet  with  a  total of 192 printing characters, all of which
JOVE should be able to display), or to any other [4mLocale[24m available
on your system.  The initial value of [4mlc-ctype[24m is taken from your
LC_CTYPE environment variable, and  otherwise  defaults  to  "C".
With each [4mLocale[24m JOVE will know which of the extra characters are
upper-case letters, lower-case letters, etc.

[1m3.3.  Name Completion[0m

JOVE knows the names of all sorts of objects, such as  JOVE  Com-
mands,  JOVE  Variables,  Macros, Keymaps, Buffers and even (with
some help from the UNIX directories) Files.  Since names must  be
entered often, JOVE has features to make this easier.

For  many names, JOVE is willing to supply a default if you enter
an empty answer.  For example, when you are telling [4mselect-buffer[0m









6                   JOVE Manual for UNIX Users


which  buffer  to select, it will default to the previous buffer.
When the prompt mentions a default, this is the value  that  will
be used in place of an empty answer.

If  the default isn't the name you want, name completion can help
you enter a name.  When you are prompted for  a  name,  you  need
type only enough letters to make it unambiguous.  At any point in
the course of typing the name, you can type question mark (?)  to
see a list of all the relevant names which begin with the charac-
ters you have already typed; you can type Tab to have JOVE supply
as many characters as it can; or you can type Return to terminate
your input, or you can type Space to do both (supply the  charac-
ters  and  terminate).  For example, you are typing a Command and
you have so far typed the letters "[4mau[24m" and you then type a  ques-
tion mark, you will see the list

        auto-execute-command
        auto-execute-macro
        auto-fill-mode
        auto-indent-mode

If you type a Return at this point, JOVE will complain by ringing
the bell, because the letters you have typed do not unambiguously
specify  a  single  command.   But if you type Tab or Space, JOVE
will supply the characters "[4mto-[24m" because all commands that  begin
"[4mau[24m" also begin "[4mauto-[24m".  You could then type the letter "f" fol-
lowed by either Space or Return, and JOVE would complete and obey
the entire command.

There are in fact two cases that can arise.

1.   [1mThe  name  you are typing is supposed to exist already [22m(Com-
     mands, Variables and  Keymaps  always,  Macros  and  Buffers
     except when you are trying to create a new one).
     If  you  type Return and what you have typed is not an unam-
     biguous prefix of any name of the right kind, you will  hear
     the  bell;  otherwise,  it will complete what you have typed
     and then use it.  Tab will complete what  it  can  (you  can
     then  type  Return  if it looks right).  Space will complete
     what it can and use it if it then matches.

2.   [1mThe name you are typing may be  a  new  one  [22m(Files  always,
     Macros (including the Keyboard Macro) and Buffers if you are
     allowed to create or rename one at that point).
     If you type Return, and it does not match any name, then  it
     will  take  exactly  what you have typed as a new name.  Tab
     and Space try to complete as before.

If you type ^R, it will insert a name that might be useful.  Even
if this name is not the one you wish to enter, it is often conve-
nient to edit this name into the desired one.  The inserted  name
will  be  the default (if there is one), or the current value (if
there is one).  When JOVE is asking for  a  command  or  variable
name, ^R will insert the last one named.









                    JOVE Manual for UNIX Users                  7


Buffers,  keymaps,  and macros are also numbered (if you type "?"
when first prompted, you will see the numbers as well as the pos-
sible names), and the number may be used in place of the name.

[1m3.3.1.  Filename Completion[0m

Whenever  JOVE  is prompting you for a filename, say in the [4mfind-[0m
[4mfile[24m command, things happen as just described and  Return  always
accepts  the  name just as it is (because you might be wanting to
create a new file with a name similar  to  that  of  an  existing
one).   The  variable  [4mbad-filename-extensions[24m contains a list of
words separated by spaces which are to be considered bad filename
extensions; any filename with one of these extensions will not be
counted in filename completion.  The default includes ".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.

When JOVE is prompting for a [4mfilename[24m, it has the following extra
functions:

^N   Insert the next filename  from  the  argument  list  in  the
     Minibuf.

^P   Insert  the  previous filename from the argument list in the
     Minibuf.

[1m4.  Commands and Variables[0m

[1m4.1.  Commands[0m

JOVE uses [4mcommands[24m which have long names such as [4mnext-line[24m.  Then
[4mkeys[24m  such  as  ^N  are connected to commands through the [4mcommand[0m
[4mdispatch[24m [4mtable[24m.  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  [4mnext-line[24m  which  knows  how to move down a line, and ^N
moves down a line because it is connected to that  command.   The
name  for this connection is a [4mbinding[24m; we say that the key ^N [4mis[0m
[4mbound[24m [4mto[24m the command [4mnext-line[24m (or vice versa).   JOVE  has  many
bindings already [4mbuilt-in[24m, but you (or your system administrator)
may also add your own, e.g. to make full use of any Function Keys
provided on your particular keyboard.

Thus there may be three ways to refer to a command -- by its full
name, or by its standard (built-in)  binding,  or  by  your  cus-
tomized binding.  Throughout this manual, we shall always use the
standard bindings, followed by the full name (in  italics).   The
standard bindings are designed to work on any ASCII keyboard, and
can always be used so long as you (or your system  administrator)
have  not  actually changed them.  But they are hard to remember,
so you may well prefer to  use  your  own,  particularly  if  you
always  use  the same terminal.  See the section on Customization
for more details.









8                   JOVE Manual for UNIX Users


Some terminals and modems cannot accept characters flat out at  a
reasonable  baud  rate,  and  therefore require the use of a flow
control protocol using the characters ^S and ^Q (see the variable
[4mallow-^S-and-^Q[24m).   These  characters cannot, therefore, be typed
by the user.  It has therefore  been  arranged  that  whenever  a
standard  binding  requires ^S (^Q) to be typed, a spare standard
binding for that facility is also provided in which ^\  (^^)  can
be typed in its place.

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  [4mexecute-named-command[24m.  You will then be
able to type the name of whatever command you want to execute  on
the message line.

[1m4.2.  Prefix Characters[0m

Because  there  are  more  command names than keys, JOVE allows a
sequence of keystrokes to be bound to a  command.   Usually,  the
first  character  of  the  sequence will be one of the two [4mprefix[0m
[4mcharacters[24m ^X or ESC.  When you type such a prefix character JOVE
will  wait for the next 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 while you type the rest of the  sequence.   Many  JOVE
commands  are  bound  to  a 2-stroke sequence starting with ^X or
ESC.  How the next character is interpreted depends on  which  of
them  you  typed.  For example, if you type ESC followed by B you
will run [4mbackward-word[24m, but if you type ^X followed by B you will
run [4mselect-buffer[24m.

[1m4.3.  Variables[0m

Sometimes  the description of a command will say "to change this,
set the variable [4mmumble-foo[24m".  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  vari-
able's  value  may be examined by some command, and changing that
value makes the command behave differently.  However, the facili-
ties  provided  are  pretty  limited: you cannot invent new vari-
ables, or use them for other than their  built-in  purposes,  and
their  values  apply globally to all buffers irrespective of mode
settings.

  [4mset[24m    Sets the value of a variable.
  [4mprint[24m  Displays the current value of a variable.


To set or change the value of a variable, type ESC X  [4mset[24m  <vari-
able-name> <value><return>.  Values may be [4mon[24m of [4moff[24m (for Boolean
variables) or numbers  (numeric  variables)  or  strings  (string
variables).   To  inspect  the  current value of a variable, type
ESC X print <variable-name><return>.










                    JOVE Manual for UNIX Users                  9


[1m4.4.  Giving Numeric Arguments to JOVE Commands[0m

Many JOVE commands can be given a [4mnumeric[24m  [4margument[24m.   Many  com-
mands interpret the argument as a repetition count (possibly neg-
ative).  For example, giving an argument of ten to the ^F command
([4mforward-character[24m)  moves  forward  ten  characters.  With these
commands, no argument is equivalent to an argument of 1.

Some commands use the value of the argument,  or  even  just  its
presence  or absence, in highly idiosyncratic ways.  For example,
the commands which change the minor  modes  (such  as  [4mauto-fill-[0m
[4mmode[24m)  toggle the mode if there is no argument, but turn the more
off with a zero argument, and on with any other argument.

The fundamental way of specifying an argument is to use ESC  fol-
lowed  by  the digits of the argument, for example, ESC 123 ESC G
to go to line 123.  Negative arguments are allowed, although  not
all commands know what to do with them.  Unless otherwise stated,
ESC Minus ... is equivalent to ESC Minus 1 ... .  Note that  when
giving  arguments to [4msourced[24m commands (described later under Cus-
tomization) different rules apply.

Typing ^U means "supply an argument of 4".  Two such ^U's  supply
sixteen.   Thus, ^U ^U ^F moves forward sixteen characters.  This
is a good way to move forward quickly, since it moves  about  1/4
of  a  line on most terminals.  Other useful combinations are: ^U
^U ^N (move down a good fraction of the screen),  and  ^U  ^U  ^O
(make "a lot" of blank lines).

There  are  other,  terminal-dependent,  ways of specifying argu-
ments.  They have the same effect but may be easier to type.   If
your  terminal  has a numeric keypad which sends something recog-
nizably different from the ordinary digits,  it  is  possible  to
customize  JOVE to allow use of the numeric keypad for specifying
arguments.

[1m4.5.  Help[0m

To get a list of keys and their  associated  commands,  you  type
ESC X  [4mdescribe-bindings[24m  (warning: the list runs to many screen-
fuls; type Space to see the next one, or ^G when  you  have  seen
enough).   If  you want to describe a single key, ^X ? ([4mdescribe-[0m
[4mkey[24m) will work.  A description of an individual command is avail-
able by using ESC ? ([4mdescribe-command[24m), and descriptions of vari-
ables by using ESC X [4mdescribe-variable[24m.  If  you  can't  remember
the  name of the thing you want to know about, ESC X [4mapropos[24m will
tell you if a command or variable has a given string in its name.
For  example,  ESC X  [4mapropos[24m [4mdescribe[24m will list the names of the
four describe commands just mentioned.

[1m5.  Basic Editing Commands[0m












10                  JOVE Manual for UNIX Users


[1m5.1.  Inserting Text[0m

To insert printing characters into the text, just type them.  All
such  printing  characters you type are inserted into the text at
the cursor (that is, at [4mpoint[24m), and  the  cursor  moves  forward.
Any characters after the cursor move forward too.  If the text in
the buffer is FOOBAR, with the cursor before the B, then  if  you
type XX you get FOOXXBAR, with the cursor still before the B.

To  correct  text  you  have just inserted, you can use DEL.  DEL
deletes the character [4mbefore[24m the cursor (not  the  one  that  the
cursor  is  on  top  of or under; that is the character [4mafter[24m the
cursor).  The cursor and all characters after it move  backwards.
Therefore,  if you typing a printing character and then type DEL,
they cancel out.

To end a line and start typing a new one,  type  Return.   Return
operates  by inserting a [4mline-separator[24m, so if you type Return in
the middle of a line, you break the line in two.  Because a line-
separator  behaves  like  a single character, you can type DEL at
the beginning of a line to delete the line-separator and join  it
with  the  preceding line.  Note that the line separator is [1mnot [22ma
character (it is not the ASCII NL character, for example) so that
you cannot include it in search or replace strings.

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 ([4mnewline-and-backup[24m) command to "open" several empty lines  at
once;  then  you  can insert the new text, filling up these empty
lines.  The advantage is that JOVE does not have  to  redraw  the
bottom  part  of the screen for each Return you type, as it would
ordinarily.  That "redisplay" can be both slow and 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 is still there, and if you break the line, the "!"  will
go away.

Direct  insertion  works  for  printing characters and space, but
other characters act as editing commands and do not insert  them-
selves.   If you need to insert a control character, ESC, or DEL,
you must first [4mquote[24m it by typing the ^Q command  ([4mquoted-insert[24m)
first, for example ^Q ^C to insert a genuine ^C.













                    JOVE Manual for UNIX Users                 11


[1m5.2.  Moving the Cursor[0m

To  do  more than insert characters, you have to know how to move
the cursor.  Here are the commands for doing that.

^A        [4mbeginning-of-line[24m    Move to the beginning of the line.
^E        [4mend-of-line[24m          Move to the end of the line.
^F or ->  [4mforward-character[24m    Move forward over one character.
^B or <-  [4mbackward-character[24m   Move backward over one character.
^N or |v   [4mnext-line[24m            Move down  one  line,  vertically.   If  you
                               start  in the middle of one line, you end in
                               the middle of the next.
^P or |^   [4mprevious-line[24m        Move up one line, vertically.
ESC <     [4mbeginning-of-file[24m    Move to the beginning of the entire buffer.
ESC >     [4mend-of-file[24m          Move to the end of the entire buffer.
ESC ,     [4mbeginning-of-window[24m  Move to the beginning of the visible window.
ESC [1m.     [4m[22mend-of-window[24m        Move to the end of the visible window.
^Z        [4mscroll-up[24m            Move the lines in the  window  upwards.   If
                               this  brings  the cursor outside of the win-
                               dow, it is automatically relocated.
ESC Z     [4mscroll-down[24m          Move the lines in the window downwards.

Observe the use of the arrow keys (->, <-, |v and |^)  as  alterna-
tives  for  ^F, ^B, ^N and ^P.  These should be available on just
about any terminal.  You (or your system administrator) may  find
it  convenient to bind other Function Keys available on your key-
board to some of these commands, especially if those keys already
have  appropriate  engravings  on  them.  See the section on Cus-
tomizing JOVE.

[1m5.3.  Deleting Text[0m

DEL    [4mdelete-previous-character[24m  Delete the character before the cursor.
^D     [4mdelete-next-character[24m      Delete the character after the cursor.
ESC \  [4mdelete-white-space[24m         Delete spaces and tabs around point.
^X ^O  [4mdelete-blank-lines[24m         Delete blank lines around the current line.


You already know about the DEL command which deletes the  charac-
ter  [4mbefore[24m the cursor.  Another command, ^D, deletes the charac-
ter [4mafter[24m the cursor, the one  the  cursor  is  "on  top  of"  or
"underneath",  causing  the rest of the text on the line to shift
left.  Line-separators act like normal characters  when  deleted,
so  if  ^D  is typed at the end of a line, that line and the next
line are joined together.

The other delete commands are those which delete only  formatting
characters:  spaces,  tabs,  and line-separators.  ESC \ ([4mdelete-[0m
[4mwhite-space[24m) deletes all the spaces and tab characters before and
after  point.  ^X ^O ([4mdelete-blank-lines[24m) 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).










12                  JOVE Manual for UNIX Users


[1m5.4.  Files -- Saving Your Work[0m

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  into  a  [4mfile[24m.
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 [4mfoo.bar[24m, and type ^X ^F [4mfoo.bar[24m<return> ([4mfind-[0m
[4mfile[24m).  This reads the file [4mfoo.bar[24m so that its  contents  appear
in  a  new buffer on the screen for editing.  Alternatively, type
^X ^R [4mfoo.bar[24m<return> ([4mread-file[24m) to have the file appear  in  an
existing buffer.  You can make changes, and then save the file by
typing ^X ^S ([4msave-file[24m).  This makes the changes  permanent  and
actually  changes  the file [4mfoo.bar[24m.  Until then, the changes are
only inside JOVE, and the file [4mfoo.bar[24m is not really changed.  If
the  file [4mfoo.bar[24m does not 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 then.

[1m5.5.  Exiting and Pausing -- Leaving JOVE[0m

The command ^X ^C ([4mexit-jove[24m) 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 com-
mand, look at what buffers are modified but unsaved  using  ^X ^B
([4mlist-buffers[24m),  save  the valuable ones, and then exit.  If what
you want to do, on the other hand, is  to  [4mpreserve[24m  the  editing
session  but  return to the shell temporarily you can (under most
modern versions of UNIX) issue the command ESC S ([4mpause-jove[24m), do
your  UNIX  work within your shell, and then return to JOVE using
the [4mfg[24m command to resume editing at the point where  you  paused.
Alternatively,  for  this  sort  of situation, you might consider
using an [4minteractive[24m [4mshell[24m (that is, a shell in  a  JOVE  window)
which  lets  you  use  the editor to issue your UNIX commands and
manipulate their output, while  never  leaving  the  editor  (the
interactive shell feature is described later).

[1m6.  Kill and Yank (or Cut and Paste)[0m

Any editor needs a facility for dealing with large blocks of text
-- deleting them or moving them to other places.  The usual  ter-
minology speaks of "Cut" (to remove a block of text), "Paste" (to
replace it somewhere else) and "Copy" (to copy it for  subsequent
pasting without removal from its original place).  For historical
reasons, editors based on EMACS use the terms Kill, Yank and Copy
with  essentially  the same meanings, and we shall continue to do
so in this manual.  However, it may be sensible, if your keyboard
has  keys  marked  Cut, Paste and Copy, to bind appropriate Kill,
Yank and Copy commands to them as part of your  local  customiza-
tion.













                    JOVE Manual for UNIX Users                 13


[1m6.1.  The Mark and the Region[0m

In  general,  a  command  that processes an arbitrary part of the
buffer must know where to start and where to stop.  In JOVE, such
commands  usually operate on the text between [4mpoint[24m and [4mthe[24m [4mmark[24m.
On most terminals, the position  of  the  mark  is  indicated  by
underlining.  This body of text is called [4mthe[24m [4mregion[24m.  To specify
a region, you set point at one end of it and mark at  the  other.
It doesn't matter which one comes earlier in the text.

^@     [4mset-mark[24m                 Set the mark where point is.
^X ^X  [4mexchange-point-and-mark[24m  Interchange point and mark.
       [4mpop-mark[24m                 Move to the previous mark in the ring.


The way to set the mark is with the ^@ command or (on some termi-
nals) the ^Space command.  They set  the  mark  where  point  is.
Then  you can move point away, leaving the mark behind.  When the
mark is set, "[Point pushed]" is printed on the message line.

For example, if you wish to convert part of  the  buffer  to  all
upper-case,  you  can  use  the  [4mcase-region-upper[24m command, which
operates on the text in the region.  You  can  first  go  to  the
beginning of the text to be capitalized, put the mark there, move
to the other end, and then type ESC X [4mcase-region-upper[24m.  Or, you
can  set  the mark at the end of the text, move to the beginning,
and then type the same thing.

On terminals with the requisite capabilities, the marked  charac-
ter  is  underlined.  Otherwise, you have to remember where it is
(the usual method is to set the  mark  and  then  use  it  soon).
Alternatively,  you  can  see  where the mark is with the command
^X ^X which puts the mark where point was  and  point  where  the
mark  was.  The extent of the region is unchanged, but the cursor
and point are now at the previous location of the mark.

[1m6.2.  The Ring of Marks[0m

Aside from delimiting the region, the mark  is  also  useful  for
remembering a spot that you may want to go back to.  To make this
feature more useful, JOVE remembers 16 previous locations of  the
mark.   Most  commands  that  set the mark push the old mark onto
this stack.  To return to a marked location, use  ^U ^@  (equiva-
lent  to  [4mpop-mark[24m).  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 dis-
tance take advantage of the stack of marks to give you a  way  to
undo the command.  The best example is ESC < ([4mbeginning-of-file[24m),
which moves to the beginning of the buffer.  If  there  are  more
than  22  lines  between  the  beginning of the buffer and point,









14                  JOVE Manual for UNIX Users


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 [4mmark-threshold[24m.  By set-
ting it to 0, you can make these commands always set the mark and
by setting it to a very large number you can make them never  set
it.   If a command decides to set the mark, it prints the message
[Point pushed].

[1m6.3.  Killing and Moving Text[0m

The way of moving text with JOVE is to [4mkill[24m (cut)  it,  and  [4myank[0m
(paste)  it back again later 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.

[1m6.3.1.  Deletion and Killing[0m

Most  commands  which  erase text from the buffer save it so that
you can get it back if you change your mind, or you can  copy  it
to other parts of the buffer (even to a different buffer).  These
commands are known as [4mkill[24m commands.  The rest  of  the  commands
that  erase  text  do  not save it; they are known as [4mdelete[24m com-
mands.  The delete commands include ^D and DEL, 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 [4mkill[24m or [4mdelete[24m  to  say  which  it
does.

^D       [4mdelete-next-character[24m          Delete next character.
DEL      [4mdelete-previous-character[24m      Delete previous character.
ESC \    [4mdelete-white-space[24m             Delete spaces and tabs around point.
^X ^O    [4mdelete-blank-lines[24m             Delete blank lines around the current line.
^K       [4mkill-to-end-of-line[24m            Kill rest of line or one or more lines.
^W       [4mkill-region[24m                    Kill the region (from point to mark).
ESC D    [4mkill-next-word[24m                 Kill word.
ESC DEL  [4mkill-previous-word[24m             Kill word backwards.
ESC K    [4mkill-to-end-of-sentence[24m        Kill to end of sentence.
^X DEL   [4mkill-to-beginning-of-sentence[24m  Kill to beginning of sentence.
ESC ^K   [4mkill-s-expression[24m              Kill from point to the end of an s-expression.


[1m6.3.2.  Deletion[0m

The  various  delete commands have already been described.  Actu-
ally, ^D and DEL aren't always [4mdelete[24m commands; if  you  give  an
argument,  they  [4mkill[24m  instead.   This prevents you from losing a
great deal of text by typing a large argument to a ^D or DEL.

[1m6.3.3.  Killing (and Copying) the region,  and  Yanking  it  back[0m
[1magain[0m











                    JOVE Manual for UNIX Users                 15


The commonest kill  command  is  ^W  ([4mkill-region[24m),  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 then go to the other end.

^W     [4mkill-region[24m  Kill everything between point and mark.
ESC W  [4mcopy-region[24m  Save the region without killing.


Yanking (un-killing) is getting back text which was killed.   The
usual  way  to  move  or copy text is to kill or copy it and then
yank it one or more times.

^Y     [4myank[24m      Yank (re-insert) the last killed text.
ESC Y  [4myank-pop[24m  Replace re-inserted killed text with the previously killed text.


Killed text is pushed onto a [4mring[24m [4mbuffer[24m  called  the  [4mkill[24m  [4mring[0m
that  remembers  the last sixteen blocks of text that were killed
(why it is called a ring buffer will be  explained  below).   The
command  ^Y  ([4myank[24m)  reinserts  the text of the most recent kill.
The yanked text becomes the new region.  Thus, a single ^Y undoes
the ^W and vice versa.

If  you wish to copy a block of text, you might want to use ESC W
([4mcopy-region[24m), which copies the region into the kill ring without
removing it from the buffer.

There  is only one kill ring shared among all the buffers.  After
reading a new file or selecting a new buffer, whatever  was  last
killed in the previous file or buffer is still on top of the kill
ring.  This is important for moving text between buffers.

[1m6.3.4.  Other Kill commands[0m

Other syntactic units can be killed,  too;  words,  with  ESC DEL
([4mkill-previous-word[24m)  and  ESC D ([4mkill-next-word[24m); and sentences,
with ESC K ([4mkill-to-end-of-sentence[24m) and  ^X DEL  ([4mkill-to-begin-[0m
[4mning-of-sentence[24m).

[1m6.3.5.  Killing by Lines[0m

Another kill command is the ^K command ([4mkill-to-end-of-line[24m).  If
issued at the beginning of a line, it kills all the text  on  the
line,  leaving  it  blank.   If given in the middle of a line, it
kills all the text up to the end of the line.  If given on a line
that  is empty or contains only white space (blanks and tabs) the
line disappears.  If ^K is done at the end of a  line,  it  joins
that  line and the next line.  As a consequence, if you go to the
front of a non-blank line and type two ^K's, the line  disappears
completely  (but  be  careful,  because  one  ^K is sufficient to
-----------
*Often  users  switch  this  binding  from ^W to ^X ^K
because it is too easy to hit ^W accidentally.









16                  JOVE Manual for UNIX Users


remove an empty line).

In general, ^K kills from point up to the end of the line, unless
it is at the end of a line, in which case it kills the line-sepa-
rator following the line, thus merging the  next  line  into  the
current  one.   Invisible  spaces and tabs at the end of the line
are ignored when deciding which case applies, so if point appears
to  be at the end of the line, you can be sure the line-separator
will be killed.

^K with an argument kills that many lines, including  their  line
separators  (whether  the  lines  are  empty or not).  Without an
argument, ^K behaves as described in the previous paragraph.   ^U
^K  kills  four  lines  (but note that typing ^K four times would
kill only 2 lines)

^K with an argument of zero kills all the text  before  point  on
the current line.

[1m6.3.6.  Appending Kills[0m

Normally,  each  kill  command  pushes  a new block onto the kill
ring.  However, two or more kill commands immediately  in  a  row
(without  any other intervening commands) combine their text into
a single entry on the ring, so that a single  ^Y  ([4myank[24m)  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.

Commands that kill forward from point add onto  the  end  of  the
previously  killed  text.  Commands that kill backward from point
add onto the beginning.  This way, any sequence of mixed  forward
and  backward  kill  commands  puts  all the killed text into one
entry without needing rearrangement.

Suppose, for example you have a line containing FOO BAR BAZ  with
the  cursor  at  the  start of BAR.  Type ESC D ([4mkill-next-word[24m),
then ESC DEL ([4mkill-previous-word[24m), then ESC F  ([4mforward-word[24m)  to
put the cursor after BAZ, and Space to insert a space.  Then type
^Y ([4myank[24m) and your line will contain BAZ FOO BAR.

[1m6.4.  The Kill Ring[0m

To recover killed text that is no longer the  most  recent  kill,
you  need the ESC Y ([4myank-pop[24m) command.  The ESC Y command can be
used only immediately after a ^Y ([4myank[24m) command or another ESC Y.
It  takes the yanked 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
one.











                    JOVE Manual for UNIX Users                 17


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  still
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 round 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  is
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 yanking, ^W ([4mkill-region[24m) gets  rid
of the yanked text, even after any number of ESC Y's.

[1m7.  Searching and Replacing[0m

[1m7.1.  Searching[0m

The  search  commands  are useful for finding and moving to arbi-
trary positions in the buffer in one swift motion.  For  example,
if  you  just ran the spell program on a document 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: [4mstring[0m
[4msearch[24m and [4mincremental[24m [4msearch[24m.  The former is the default  flavor
--  if  you want to use incremental search you must rearrange the
key bindings (see below).

[1m7.1.1.  Conventional Search[0m

^S or ^\  [4msearch-forward[24m  Search forward.
^R        [4msearch-reverse[24m  Search backward.


To search for the string "FOO" you type ^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.  ^S searches forward
from  point so only occurrences of FOO after point are found.  To
search in the other direction use ^R.  It is exactly the same  as
^S  except  that 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 ^S.

While JOVE is searching it displays the search string on the mes-
sage 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.









18                  JOVE Manual for UNIX Users


JOVE remembers the last search string you used, so if you want to
search  for  the  same string again you can type ^S <return>.  If
you mistyped the last search string, you  can  type  ^S  followed
immediately  by  ^R  (which  is [4mnot[24m the [4msearch-reverse[24m command in
this context) which inserts the default search string,  and  then
you can fix it up.

Note  that  the  precise  interpretation  of the search string is
dependent on the variable [4mmatch-regular-expressions[24m and  is  sub-
ject  to  the  rules  for  [4mregular-expressions[24m  to  be  described
shortly.

[1m7.1.2.  Incremental Search[0m

This search command is unusual in  that  is  is  [4mincremental[24m;  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.

To use the incremental searches, you first have to bind  them  to
suitable  keys,  for  example  to  ^S and ^R if you want all your
searching to become incremental.  To do this, type

     [4mESC[24m [4mX[24m [4mbind-to-key[24m [4mi-search-forward[24m [4m^S[0m
     [4mESC[24m [4mX[24m [4mbind-to-key[24m [4mi-search-reverse[24m [4m^R[0m

The command to search is now ^S ([4mi-search-forward[24m).  ^S reads  in
characters  and  positions  the cursor at the first occurrence of
the characters that you have typed so far.  If you  type  ^S  and
then  F,  the  cursor  moves in the text just after the next "F".
Type an "O", and see the cursor move  to  after  the  next  "FO".
After  another  "O",  the cursor is after the next "FOO".  At the
same time, "FOO" has echoed on the message line.

If you type a mistaken character, you can rub it out.  After  the
FOO,  typing a DEL makes the "O" disappear from the message line,
leaving only "FO".  The cursor moves back in the  buffer  to  the
"FO".  Rubbing out the "O" and "F" moves the cursor back to where
you started the search.

When you are satisfied with the place you have reached,  you  can
type  a  Return,  which stops searching, leaving the cursor where
the search brought it.  Also, any command not specially  meaning-
ful  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  necessary only if the next character you
want to type is a printing character,  DEL,  Return,  or  another
search  command, since those are the characters that have special
meanings inside the search.











                    JOVE Manual for UNIX Users                 19


Sometimes you search for "FOO" and find it, but not the  one  you
hoped  to  find.  Perhaps there is a second FOO after the one you
just found.  Then type another "^S" and the cursor will find  the
next  FOO.   This  can be done any number of times.  If you over-
shoot, you can return to previous finds by rubbing out the "^S"s.
Note that, in this context, "^S" (alternatively "^\") is a built-
in use of the ^S character  and  not  another  invocation  of  [4mi-[0m
[4msearch-forward[24m (which is why I have shown it in "quotes").

After you exit a search, you can search for the same string again
by typing just ^S ^S: one ^S command to start the search and then
another "^S" to mean "search again for the same string".

If  your string is not found at all, the message line says "Fail-
ing I-search".  The cursor is after the place where JOVE found as
much  of  your  string as it could.  Thus, if you search for FOOT
and there is no FOOT, you might see the cursor after the  FOO  in
FOOL.   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 altogether and positions
you back where you started the search.

You can also type ^R ([4mi-search-reverse[24m)  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
"^R"s  keep  looking  backward  for  more occurrences of the last
search string.  A "^S" starts going forward again.  "^R"s can  be
rubbed out just like anything else.

Unlike conventional searching, incremental searching does not use
the rules for regular-expressions.

[1m7.2.  Replacing[0m

In addition to the simple Replace operation which  is  like  that
found  in  most editors, there is a Query Replace operation which
asks, for each occurrence of the pattern, whether to  replace  it
or not.

ESC R  [4mreplace-string[24m        Replace every occurrence of the
                             string from point to the end of
                             the buffer.
       [4mreplace-in-region[24m     Replace every occurrence of the
                             string within the region.
ESC Q  [4mquery-replace-string[24m  Replace  occurrences   of   the
                             string from point to the end of
                             the buffer, but asking for con-
                             firmation  before each replace-
                             ment.












20                  JOVE Manual for UNIX Users


[1m7.2.1.  Global replacement[0m

To replace every occurrence of FOO after point with BAR, you  can
do,  ESC R  FOO<return>BAR<return> ([4mreplace-string[24m).  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.

Another alternative is to use  [4mreplace-in-region[24m  which  is  just
like [4mreplace-string[24m except it searches only within the region.

[1m7.2.2.  Query Replace[0m

If  you  want  to change only some of the occurrences of FOO, not
all, then the global [4mreplace-string[24m  is  inappropriate;  instead,
use,  e.g.,  ESC Q FOO<return>BAR<return> ([4mquery-replace-string[24m).
This moves the cursor to each occurrence of FOO and waits for you
to  say  whether to replace it with BAR.  The things you can type
when you are shown an occurrence of FOO are:

Space or Y or y      to replace the FOO with BAR.

Period               to replace this FOO and then stop.

DEL or BS or N or n  to skip to the next  FOO  without  replacing
                     this one.

^R or 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
                     ([4mexit-jove[24m)  and  the  next FOO will be dis-
                     played.

^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 ([4mexit-[0m
                     [4mjove[24m) and the [4mquery-replace[24m will continue at
                     the next FOO.

^U or U or u         move  to  the  last replacement and undo all
                     changes made on that line.

! or P or p          to replace all remaining FOO's without  ask-
                     ing, as in [4mreplace-string[24m.

Return or Q or q     to stop without doing any more replacements.

^L                   redraw the screen.













                    JOVE Manual for UNIX Users                 21


[1m7.3.  Searching with Regular Expressions[0m

When we use the searching and  replacement  facilities  described
above,  JOVE  can  search for patterns using [4mregular-expressions[24m.
The handling of regular-expressions in JOVE is somewhat like that
of  [4med(1)[24m or [4mvi(1)[24m, but with some notable additions.  The precise
behavior depends on the setting of  the  variable  [4mmatch-regular-[0m
[4mexpressions[24m.  If this variable is [4mon[24m, we use true [4mregular-expres-[0m
[4msions[24m.  If it is [4moff[24m, we have just [4msimple-expressions[24m.   In  what
follows,  the  term  [4mexpression[24m  should be interpreted as simple-
expression or regular-expression according to the state  of  that
variable.

Another  variable  that  affects searching is [4mcase-ignore-search[24m.
If this variable is set to [4mon[24m then upper case and lower case let-
ters  are  considered  equal  (except, of course, within regular-
expressions such as [A-Za-z]).

Note that the rules which follow are complex, arbitrary, and dif-
ferent  from  those  in other editors.  Hence they may be changed
significantly in future versions of JOVE.

[1m7.3.1.  Simple Regular Expressions[0m

If the variable [4mmatch-regular-expressions[24m is [4moff[24m, the search pat-
tern is interpreted as follows:

^ (at the start of a pattern or sub-pattern)
              Matches  the  empty  string  at  the beginning of a
              line.

$ (at the end of a pattern or sub-pattern)
              Matches the empty string at the end of a line.

\<            Matches the empty string  at  the  beginning  of  a
              word.   What  makes  up a word depends on the major
              mode of the buffer that you are searching  in.   In
              all  modes a word is a contiguous sequence of char-
              acters which have some defined pattern, bounded  by
              characters  that  don't  fit that pattern or by the
              beginning or  end  of  the  line.   The  individual
              modes' word patterns are as follows:





















22                  JOVE Manual for UNIX Users


              [4mFundamental[24m upper  and  lower case letters and dig-
                          its.

              [4mText[24m        upper and lower case letters and digits
                          plus apostrophe (').

              [4mC[24m           upper and lower case letters and digits
                          plus "$" and "_" (underscore).

              [4mLisp[24m        upper and lower case letters and digits
                          plus  "!$%&*+-/:<=>?^_{|}~" and Delete.

\>            Matches the empty string at the end of a word.

\[4mc[24m            Matches the character [4mc[24m where [4mc[24m is not one of <, >,
              (,  ),  {,  }  or  |.  In particular, \^, \$ and \\
              match the characters ^, $ and \.  When  full  regu-
              lar-expressions are in use, \[1m.[22m, \* and \[ will also
              be required.

[4mc[24m             Matches the character [4mc[24m where [4mc[24m is not \ or  ^  (at
              the  start of a pattern) or $ (at the end of a pat-
              tern) (plus a few further things if  [4mmatch-regular-[0m
              [4mexpressions[24m is [4mon[24m).

\{[4mc1...cN[24m\}   Matches  whatever  the  sequence of regular-expres-
              sions [4mc1..cN[24m would have matched.   Note  that  full
              regular-expression  capability  (even  the  \| con-
              struct described below) is provided within  \{...\}
              whatever the setting of the variable [4mmatch-regular-[0m
              [4mexpressions[24m.  \{...\} provides a grouping construct
              like  parentheses  in  algebraic expressions.  Thus
              "aa\{xx\|yy\}bb" searches for "aaxxbb" or "aayybb".

\([4mc1..cN[24m\)    Matches whatever the sequence of expressions [4mc1..cN[0m
              would have matched, where the expressions  are  any
              of  those  described above (and also the additional
              full regular-expressions  if  [4mmatch-regular-expres-[0m
              [4msions[24m  is  [4mon[24m).   This  is  used to tag part of the
              search text for later reference via \[1mn [22m(see below).
              \([4mc1..cN[24m\)  patterns  may  be nested.  Observe that
              use of the \| construct (see below) directly within
              a \(...\) is precluded.

\[4mn[24m            Matches  the  [4mn[24m'th  \([4mc1..cN[24m\)  pattern  where [4mn[24m is
              between 1 and 9.  The \([4mc1..cN[24m\) patterns are  num-
              bered  by  counting  the \( sequences starting from
              the beginning of the search pattern, resetting to 1
              (or  to  the  value  at  the  start of an enclosing
              \{...\}) whenever a \| is  encountered.   To  avoid
              confusion in the counting, it is required that each
              alternative (separated  by  \|)  within  a  \{...\}
              should  contain  the  same number of \(...\)s.  For
              example, the  search  pattern  "^\(\{ab\|cd\}\)\1$"









                    JOVE Manual for UNIX Users                 23


              searches for all non-empty lines which contain just
              "abab" or "cdcd" (but not "abcd").  It is an  error
              in  the  search  pattern  to reference a \([4mc1..cN[24m\)
              pattern that follows the occurrence of \[4mn[24m.

[4mc1..cN[24m        Matches the longest string matched by [4mc1[24m,  followed
              by  the  longest  string  matched by [4mc2[24m, and so on.
              The expressions [4mc1..cN[24m are any of  those  described
              above (and also the additional full regular-expres-
              sions if [4mmatch-regular-expressions[24m is [4mon[24m).

[4mc1..cN[24m\|[4md1..dN[0m
              Matches the longest string matched  by  [4mc1..cN[24m,  if
              any,  and  otherwise  the longest string matched by
              [4md1..dN[24m.  Multiple \| sequences may be used to indi-
              cate  more  alternatives.  The sequences [4mc1..cN[24m and
              [4md1..dN[24m are any  of  those  described  above,  which
              means  that \| has lower precedence than any of the
              other operators.  Each alternative  must  have  the
              same   number   of   \(...\)   groups,  as  already
              explained.  Thus, "\<foo\|bar\|baz\>"  matches  any
              word  beginning  with  "foo", any occurrence of the
              string "bar", or any word ending in "baz".

In the replacement string:

\[4mn[24m            Is replaced with the characters matched by the [4mn[24m'th
              \([4mc1..cN[24m\) in the search pattern where [4mn[24m is between
              1  and  9.   For   example,   one   could   replace
              "\<\(\{FOO\|BAR\|BAZ\}\)\>"  with "[\1]" to enclose
              every occurrence of the  words  FOO,  BAR  and  BAZ
              within [...].

\0            Is  replaced  with  the  characters  matched by the
              entire search pattern.

\[4mc[24m            Inserts the character [4mc[24m where [4mc[24m is not a digit.

[4mc[24m             Inserts the character [4mc[24m where [4mc[24m is not \.

[1m7.3.2.  Full Regular Expressions[0m

If the variable [4mmatch-regular-expressions[24m is  [4mon[24m,  the  following
additional special matching rules are used.  Observe that special
meanings now attach to the characters  [1m.[22m,  *  and  [,  which  can
therefore no longer stand for themselves.

In the search pattern:

[4mc[24m             Matches the character [4mc[24m where [4mc[24m is not one of [1m.[22m, *,
              [, \, ^ (at the start of a line) or $ (at  the  end
              of a line).











24                  JOVE Manual for UNIX Users


[1m.             [22mMatches any character, but not a line-separator.

[[4mc1..cN[24m]      Matches  any  of  the characters in the sequence of
              characters [4mc1..cN[24m provided circumflex  (^)  is  not
              the  first  character  of the sequence (see below).
              The only special characters recognized while  pars-
              ing  the sequence are "]", "-" and "\".  All may be
              represented by escaping them with a backslash  (\):
              "\]",  "\-",  "\\".   Ranges  of  characters may be
              indicated by [4ma[24m-[4mb[24m where [4ma[24m is the first character  of
              the  range  and [4mb[24m is the last.  The special meaning
              of - is lost if it appears as  the  first  or  last
              character  of the sequence.  The special meaning of
              ] is lost if it appears as the first  character  of
              the sequence.

[^[4mc1..cN[24m]     Matches any character except those contained in the
              sequence of characters [4mc1..cN[24m.  The circumflex  (^)
              is  not  special  except  immediately following the
              left bracket.

[4mc[24m*            Matches zero or more occurrences of the  expression
              [4mc[24m.   The expression [4mc[24m may be any of the expressions
              covered above except for ^ and $ (which match  null
              strings),   \([4mc1..cN[24m\)  and  [4mc1..cN[24m\|[4md1..dN[24m  (which
              would not work), and \{[4mc1...cN[24m\} (arbitrarily  for-
              bidden).

[1m8.  Commands for English Text[0m

JOVE  has  many  commands that work on the basic units of English
text: words, sentences and paragraphs.

[1m8.1.  Word Commands[0m

JOVE has commands for moving over or operating on words.  By con-
vention, they are all ESC commands.

ESC F    [4mforward-word[24m        Move Forward over a word.
ESC B    [4mbackward-word[24m       Move Backward over a word.
ESC D    [4mkill-next-word[24m      Kill forward to the end of a word.
ESC DEL  [4mkill-previous-word[24m  Kill backward to the beginning of a word.


Notice how these commands form a group that parallels the charac-
ter-based commands, ^F, ^B, ^D, and DEL.

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  over  several words if given an argument (and in the
opposite direction  with  negative  arguments).   Forward  motion
stops  right  after  the last letter of the word; backward motion
stops right before the first letter.









                    JOVE Manual for UNIX Users                 25


ESC D kills the word after point.  To be precise, it kills every-
thing  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 DEL.   ESC D
takes arguments just like ESC F.

ESC DEL  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 an ESC B and an ESC D instead of an  ESC DEL.

Note  that the term "word" in all of these commands refers simply
to a sequence of upper and lower case letters and digits.  It  is
not  dependent  on  the  major mode of the buffer as was the case
with regular-expressions involving  \<  and  \>.   Thus  it  will
require  two uses of ESC D to remove a word such as "isn't", even
if the major mode is Text mode.

[1m8.2.  Sentence Commands[0m

The JOVE commands for manipulating sentences and  paragraphs  are
mostly  ESC  commands,  so  as to resemble the word-handling com-
mands.

ESC A   [4mbackward-sentence[24m              Move back to the beginning of the sentence.
ESC E   [4mforward-sentence[24m               Move forward to the end of the sentence.
ESC K   [4mkill-to-end-of-sentence[24m        Kill forward to the end of the sentence.
^X DEL  [4mkill-to-beginning-of-sentence[24m  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 ESC E if repeated or given numeric arguments move
over successive sentences.  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 the spaces which delimit the sen-
tence.

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.  Pos-
itive arguments serve as a repeat count.

There is a special command ^X DEL for killing back to the  begin-
ning  of  a sentence, because this is useful when you change your
mind in the middle of composing text.











26                  JOVE Manual for UNIX Users


[1m8.3.  Paragraph Commands[0m

The JOVE commands for handling paragraphs are

       [4mbackward-paragraph[24m  Move back to the start of the previous paragraph.
ESC ]  [4mforward-paragraph[24m   Move forward to the end of the next paragraph.


Note that "ESC [" is not bound to  [4mbackward-paragraph[24m,  as  might
have  been  expected,  on  most  (i.e.  ANSI-compliant) terminals
because that sequence is used as a prefix for codes generated  by
the Function Keys.

[4mBackward-paragraph[24m  moves to the beginning of the current or pre-
vious paragraph, while [4mforward-paragraph[24m moves to the end of  the
current  or next paragraph.  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 cor-
rectly, although it can get confused by one-  or  two-line  para-
graphs delimited only by indentation.

[1m8.4.  Text Indentation Commands[0m


Tab       [4mhandle-tab[24m          Indent "appropriately" in a mode-dependent fashion.
Linefeed  [4mnewline-and-indent[24m  Is  the same as Return, except it copies the indent
                              of the line you just left.
ESC M     [4mfirst-non-blank[24m     Moves to the line's first non-blank character.


The way to request indentation is with the Tab command.  Its pre-
cise  effect depends on the major mode.  In [4mText[24m mode, it indents
to the next tab stop (as determined by  the  variable  [4mtab-width[24m,
whose default value is 8).  In [4mC[24m mode or [4mLisp[24m mode, it indents to
the "right" position for those programs (see later).

To move over the indentation on  a  line,  do  ESC M  ([4mfirst-non-[0m
[4mblank[24m).   This  command,  given anywhere on a line, positions the
cursor at the first non-blank, non-tab character on the line.

[1m8.5.  Text Filling[0m

       [4mauto-fill-mode[24m     Toggle the minor mode [4mauto[24m [4mfill[24m.
ESC J  [4mfill-paragraph[24m     Refill the paragraph containing the cursor.
       [4mfill-region[24m        Refill the region.
       [4mfill-comment[24m       Refill a comment, depending on the major mode.
       [4mleft-margin-here[24m   Sets the variable [4mleft-margin[24m from point.
       [4mright-margin-here[24m  Sets the variable [4mright-margin[24m from point.


[4mAuto[24m [4mFill[24m mode is a minor mode that  causes  text  to  be  [4mfilled[0m
(broken  up  into  lines that fit in a specified width) automati-
cally 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.









                    JOVE Manual for UNIX Users                 27


Entering [4mAuto[24m [4mFill[24m mode is done with ESC X [4mauto-fill-mode[24m.   From
then  on,  lines are broken automatically at spaces when they get
longer than the desired width.  To leave  [4mAuto[24m  [4mFill[24m  mode,  once
again  execute  ESC X  [4mauto-fill-mode[24m.  When [4mAuto[24m [4mFill[24m mode is in
effect, the word [1mFill [22mappears in the mode line.

If you edit the middle of a paragraph, it may no longer be filled
correctly.   To  refill a paragraph, use the command ESC J ([4mfill-[0m
[4mparagraph[24m).  It causes the paragraph that point is inside  to  be
filled.   All  the  line breaks are removed and new ones inserted
where necessary.  Similarly, [4mfill-region[24m may be used to refill  a
region  other than a paragraph.  The special command [4mfill-comment[0m
is only meaningful in those major modes,  currently  C  mode  and
Lisp mode, which support it.

The  maximum line width for filling is in the variable [4mright-mar-[0m
[4mgin[24m.  Both ESC J and auto-fill make sure  that  no  line  exceeds
this width.  The value of [4mright-margin[24m is initially 78.

Normally  ESC J  figures out the indent of the paragraph and uses
that same indent when filling.  If you want to force  some  other
indent  for  a paragraph, you set [4mleft-margin[24m to the new position
and type ^U ESC J, since [4mfill-paragraph[24m uses the value  of  [4mleft-[0m
[4mmargin[24m when supplied with a numeric argument.

If  you  know where you want to set the variable [4mright-margin[24m but
you don't know the actual value, move to where you  want  to  set
the  value  and  use the [4mright-margin-here[24m command.  [4mleft-margin-[0m
[4mhere[24m does the same for the [4mleft-margin[24m variable.

[1m8.6.  Case Conversion Commands[0m

ESC L  [4mcase-word-lower[24m            Convert the following word to lower case.
ESC U  [4mcase-word-upper[24m            Convert the following word to upper case.
ESC C  [4mcase-word-capitalize[24m       Capitalize the following word.
       [4mcase-character-capitalize[24m  Capitalize the character after point.
       [4mcase-region-lower[24m          Convert the region to lower case.
       [4mcase-region-upper[24m          Convert the region to upper case.


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 text using
ESC L, ESC U or ESC C on each word as appropriate.

When given a negative argument, the word case conversion commands
apply to the appropriate number of words before point, but do not
move point.  This is convenient when you have just typed  a  word
in  the wrong case.  You can give the case conversion command and









28                  JOVE Manual for UNIX Users


continue typing.

If a word case conversion command is given in  the  middle  of  a
word,  it  applies only to the part of the word which follows the
cursor, treating it as a whole word.

[1m8.7.  Commands for Fixing Typos[0m

In this section we summarize the  commands  that  are  especially
useful  for  the times when you catch a mistake in your text just
after you have made it, or you change your mind  while  composing
text on a line.

DEL              [4mdelete-previous-character[24m      Delete last character.
ESC DEL          [4mkill-previous-word[24m             Kill last word.
^X DEL           [4mkill-to-beginning-of-sentence[24m  Kill to beginning of sentence.
^T               [4mtranspose-characters[24m           Transpose two characters.
^X ^T            [4mtranspose-lines[24m                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 initial capital.



[1m8.7.1.  Killing Your Mistakes[0m

The  DEL  command is the most important correction command.  When
used  among  printing  (self-inserting)  characters,  it  can  be
thought of as canceling the last character typed.

When your mistake is longer than a couple of characters, it might
be more convenient to use ESC DEL or ^X DEL.  ^X DEL is  particu-
larly  useful  when you are thinking of what to write as you type
it, in case you change your mind  about  phrasing.   ESC DEL  and
^X DEL save the killed text for subsequent yanking.

ESC DEL is often useful even when you have typed only a few char-
acters 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 DEL except by looking at the screen to see what you did.  It
requires  less  thought  to  kill  the  whole word and start over
again.

[1m8.7.2.  Transposition[0m

The common error of transposing two characters can be fixed  with
the  ^T  ([4mtranspose-characters[24m) command.  Normally, ^T transposes
the two characters on either side of the  cursor  and  moves  the
cursor  forward  one  character.   Repeating  the command several
times "drags" a character to the right.  When given at the end of
a line, rather than switching the last character of the line with
the line-separator, which would be  useless,  ^T  transposes  the
last  two characters on the line.  So, if you catch your transpo-
sition error right away, you can fix it with just a ^T.   If  you









                    JOVE Manual for UNIX Users                 29


don't  catch  it  so  quickly,  you  must move the cursor back to
between the two characters.

To transpose two lines, use the ^X ^T ([4mtranspose-lines[24m)  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.

[1m8.8.  Checking and Correcting Spelling[0m

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  [4mspell-buffer[24m.   This invokes the UNIX [4mspell[24m program, which
prints a list of all the misspelled words.  JOVE catches the list
and  places  it  in a JOVE buffer called [1mSpell[22m.  You now edit the
[1mSpell [22mbuffer (technically, you are in a recursive  edit  at  this
point)  by deleting from that buffer any words that aren't really
errors.  Next, type ^X ^C ([4mexit-jove[24m) to escape from  the  recur-
sive  edit,  and  JOVE  now positions you at the first misspelled
word in the original buffer.  Correct that mistake with the usual
editor  commands.   Then  you  can  go forward to each other mis-
spelled word with ^X ^N ([4mnext-error[24m) or backward with ^X ^P ([4mpre-[0m
[4mvious-error[24m).   If,  in  the course of editing a mistake, you get
completely lost, the command [4mcurrent-error[24m will put you  back  at
the error you were supposed to be correcting.

[1m9.  Buffers[0m

When  we  speak  of "the buffer", which contains the text you are
editing, we may 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 [4mcurrent[24m  and  available
for  editing,  but it is easy to switch to a different one.  Each
buffer individually remembers which file it contains, what  modes
are  in  effect, and whether there are any changes that need sav-
ing.

^X B           [4mselect-buffer[24m           Select or create a buffer.
^X ^B          [4mlist-buffers[24m            List the existing buffers.
^X K           [4mdelete-buffer[24m           Delete the contents of a buffer and destroy it.
               [4merase-buffer[24m            Delete the contents of a buffer.
               [4mkill-some-buffers[24m       Destroy unwanted buffers.
               [4mrename-buffer[24m           Rename the selected buffer.
               [4mbuffer-position[24m         Report the position of point within the buffer.
ESC ~          [4mmake-buffer-unmodified[24m  Tell JOVE to forget that the buffer has been changed.
^X ^F          [4mfind-file[24m               Read a file into its own buffer.
^X ^S or ^X \  [4msave-file[24m               Save the selected buffer.
^X ^M          [4mwrite-modified-files[24m    Save all modified buffers.


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 cur-
rently selected buffer and the name of the file contained  in  it
are  visible  in  the  mode  line  of  any window displaying that









30                  JOVE Manual for UNIX Users


buffer.  A newly started JOVE has only one  buffer,  named  [1mMain[22m,
unless  you  specified  files  to  edit in the shell command that
started JOVE.

[1m9.1.  Creating and Selecting Buffers[0m

To create a new buffer, you need only think  of  a  name  for  it
(say,  FOO) and then type ^X B FOO<return> ([4mselect-buffer[24m).  This
makes a new, empty buffer (if one by that name didn't exist  pre-
viously)  and  selects  it  for editing.  The new buffer does not
contain 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.    Just
^X B<return>    reselects    the   previous   buffer.    Repeated
^X B<return>'s alternate between the last two buffers selected.

[1m9.2.  Using Existing Buffers[0m

To get a list of all the buffers that exist,  type  ^X ^B  ([4mlist-[0m
[4mbuffers[24m).   Each  buffer's  type, name, and contained filename is
printed.  An asterisk before the buffer name indicates that there
are  changes  that  have  not  yet  been  saved.  The number that
appears at the beginning of a line in a  ^X ^B  listing  is  that
buffer's  [4mbuffer[24m  [4mnumber[24m.   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 can save  them
with  ^X ^M  ([4mwrite-modified-files[24m).   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  ([4msave-file[24m).   If  you  give
^X ^M  an  argument, JOVE will ask for confirmation before saving
each buffer.

ESC X [4mrename-buffer[24m <new name><return> changes the  name  of  the
selected buffer.

ESC X  [4merase-buffer[24m  <buffer name><return> erases the contents of
<buffer name> without destroying it entirely.

ESC X [4mbuffer-position[24m reports the position of  point  within  the
selected  buffer,  both  as lines/total-lines, chars/total-chars,
and as a percentage.

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 ([4mmake-buffer-[0m









                    JOVE Manual for UNIX Users                 31


[4munmodified[24m).  This command  simply  clears  the  "modified"  flag
which  says  that  the  buffer  contains changes which need to be
saved.  Even if the buffer really [4mis[24m changed JOVE will still  act
as if it were not.

[1m9.2.1.  Killing Buffers[0m

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 destroy some
buffers  with  the ^X K ([4mdelete-buffer[24m) command.  You can destroy
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  con-
firm it.

If  you  need to kill several buffers, use the command [4mkill-some-[0m
[4mbuffers[24m.  This prompts you with the name of each buffer and  asks
for confirmation before killing it.

[1m10.  File Handling[0m

The  basic  unit  of stored data is the file.  Each program, each
document, lives usually in its own file.  To edit  a  program  or
document,  the file that contains it must first be brought into a
buffer, either  an  existing  one  ([4mvisit-file[24m)  or  one  created
specifically  for that file ([4mfind-file[24m).  To make your changes to
the file permanent on disk, you must [4msave[24m the file.

[1m10.1.  Reading Files[0m

^X ^F  [4mfind-file[24m    Read a file into its own buffer.
^X ^V  [4mvisit-file[24m   Visit a file.
^X ^R  [4mvisit-file[24m   An alternative to ^X ^V.
^X ^I  [4minsert-file[24m  Insert a file at point.


JOVE remembers the name of the file that  is  contained  in  each
buffer  (remember the ^X ^B ([4mlist-buffers[24m) command).  The name of
the buffer is visible in its mode line together with the name  of
its file.

You  can  read a file into its own newly created buffer by typing
^X ^F ([4mfind-file[24m), followed by the filename.  The name of the new
buffer  will be the last element of the file's pathname.  You can
abort the command by typing ^G, or edit the filename with any  of
the  standard  JOVE  commands (e.g., ^A, ^E, ^F, ESC F, ESC DEL).
If the filename you wish to visit is similar to the  filename  in
the  current mode line (the default filename), you can type ^R to
insert the default and then edit it.  For  more  about  this  and
other special methods of constructing filenames, see the sections
on [4mThe[24m [4mMessage[24m [4mLine[24m and [4mName[24m [4mCompletion[24m earlier in  this  manual.
When  you are satisfied type Return, and the new file's text will









32                  JOVE Manual for UNIX Users


appear on the screen, and its name in the mode line.

The ^F in ^X ^F stands for "Find", because if the specified  file
already resides in some buffer, that buffer is simply 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 convenient.

[4mVisiting[24m a file means  copying  its  contents  into  an  existing
buffer  so that you can edit them.  To visit a file, use the com-
mand ^X ^V or ^X ^R ([4mvisit-file[24m), followed by the filename.   The
name of the new file will appear in the mode line but the name of
the buffer will be unchanged.

If you alter one file and then visit another in the same  buffer,
JOVE  offers  to save the old one.  If you answer YES (or y), the
old file is saved; if you answer NO (or n), 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.

^X ^I ([4minsert-file[24m) followed by a filename  reads  the  file  and
inserts  it  into  the  buffer at point, leaving point before the
file contents and the mark at their end.

The changes you make with JOVE are made in a  copy  inside  JOVE.
The  file  itself is not changed.  The changed text is not perma-
nent until you [4msave[24m it in a file.  The first time you change  the
text,  an  asterisk appears in the mode line; this indicates that
the text contains fresh changes which will  be  lost  unless  you
save them.

What  if  you want to create a file?  Just read it with [4mfind-file[0m
or [4mvisit-file[24m.  JOVE  prints  [4m(New[24m  [4mfile)[24m  but  aside  from  that
behaves  as  if you had read an existing empty file.  If you make
any changes and save them, the file is created then.  If you read
a  nonexistent  file unintentionally (because you typed the wrong
filename), go ahead and read the file you  meant.   The  unwanted
file will not have been created.

[1m10.2.  Writing files[0m

^X ^S or ^X ^\  [4msave-file[24m      Save the file in the selected buffer.
^X ^W           [4mwrite-file[24m     Write the selected buffer to a different file.
                [4mwrite-region[24m   Write the region to the specified file.
                [4mappend-region[24m  Append the region to the specified file.


If  you  wish  to  save the file and make your changes permanent,
type ^X ^S.  After the save is finished, ^X ^S prints  the  file-
name  and the number of characters and lines that it wrote to the
file.  If there are no changes to save (no asterisk in  the  mode
line), the file is not saved; otherwise the changes are saved and









                    JOVE Manual for UNIX Users                 33


the asterisk in the mode line disappears.

If JOVE is about to save a file and sees that  the  date  of  the
version on disk does not match what JOVE last read or wrote, JOVE
notifies you of this fact, and asks  what  to  do,  because  this
probably  means  that  something is wrong.  For example, somebody
else may have been editing the same file.  If this is  so,  there
is  a  good chance that your work or his work will be lost if you
don't take the proper steps.  You should first find  out  exactly
what  is going on.  If you determine that somebody else has modi-
fied the file, save your file under a different filename and then
DIFF  the  two  files  to  merge  the  two sets of changes.  (The
"patch" command is useful for applying  the  results  of  context
diffs directly).  Also get in touch with the other person so that
the files don't diverge any further.

^X ^W <filename><return> ([4mwrite-file[24m) writes the contents of  the
buffer  into  the  file <filename>, changing the name of the file
recorded in the mode line accordingly.  It can be thought of as a
way  of  "changing  the  name" of the file in the buffer.  Unlike
^X ^S, [4mwrite-file[24m saves even if the buffer has not been  changed.

ESC X  [4mwrite-region[24m  <file><return>  writes  the region (the text
between point and mark) to  the  specified  file.   It  does  not
change the buffer's filename.

ESC X  [4mappend-region[24m <file><return> appends the region to <file>.
The text is added to the end of <file>.

[1m10.3.  How to Undo Drastic Changes to a File[0m

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 ([4mvisit-file[24m) command, to
visit the unsaved version of the file.  Remember to tell  it  not
to save your existing changes when it asks.

[1m11.  Windows[0m

[1m11.1.  Multiple Windows[0m

JOVE  allows you to split the screen into two or more [4mwindows[24m and
use them to display parts  of  different  buffers,  or  different
parts of the same buffer.


















34                  JOVE Manual for UNIX Users


+-----------------------------------------------------+|
|#define getchar()    getc(stdin)                     ||
|#define putchar(x)   putc((x), stdout)               ||< first Window
+-----------------------------------------------------+|
|[1mJOVE (C RO)   [stdio.h:1]  "/usr/include/stdio.h"  --[22m||< the Mode Line
+-----------------------------------------------------+|
|{                                                    ||
|    printf("Hello world!\n");                        ||
|    return 0;                                        ||< second Window
|}[]                                                  ||
+-----------------------------------------------------+|
|[1mJOVE (C OvrWt)   [Main:1]  "aloha.c"  --  /home/foo  [22m||< the Mode Line
+-----------------------------------------------------+|
|[Point pushed]                                       ||< the Message Line
+-----------------------------------------------------+|


^X 2    [4msplit-current-window[24m   Divide the active window into two smaller ones.
^X 1    [4mdelete-other-windows[24m   Delete all windows but the current one.
^X D    [4mdelete-current-window[24m  Delete the active window.
^X N    [4mnext-window[24m            Switch to the next window.
^X P    [4mprevious-window[24m        Switch to the previous window.
^X O    [4mprevious-window[24m        Same as ^X P.
^X ^    [4mgrow-window[24m            Make this window bigger.
        [4mshrink-window[24m          Make this window smaller.
ESC ^V  [4mpage-next-window[24m       Scroll the other window.
^X 4    [4mwindow-find[24m            Combination window command.


When using [4mmultiple[24m [4mwindow[24m mode, the window portion of the screen
is divided into [4mwindows[24m, which can display  different  pieces  of
text.   Each  window  can display different buffers, or different
parts of the same buffer.  Only one of  the  windows  is  [4mactive[24m,
viz.   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 includes a mode line for the buffer it is displaying.
This  is  useful  to  keep track of which window corresponds with
which buffer and which file.  In addition, the mode  line  serves
as  a  separator  between  windows.  Normally, the variable [4mmode-[0m
[4mline-should-standout[24m is [4mon[24m so that JOVE displays the mode-line in
reverse  video (assuming your particular terminal has the reverse
video capability).  However, if the variable [4mscroll-bar[24m  is  also
[4mon[24m,  a portion of the mode line is left clear to indicate how the
window is located within the buffer.

The command ^X 2 ([4msplit-current-window[24m) divides the active window
into two.  A new mode line appears across the middle of the orig-
inal window, dividing its 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.









                    JOVE Manual for UNIX Users                 35


To  return  to  viewing  only  one  window,  use the command ^X 1
([4mdelete-other-windows[24m).  The active 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 ([4mnext-win-[0m
[4mdow[24m) to switch to the next window, and ^X P ([4mprevious-window[24m)  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
opposite  thing  happens  when  you  type ^X P in the top window.
^X O is the same as ^X P.  It stands for "other window"  because,
when  there  are  only  two windows, repeated use of this command
will switch between them.

Often you will be editing one window while using the  other  just
for  reference.   Then,  the command ESC ^V ([4mpage-next-window[24m) is
very useful.  It scrolls the next  window  up,  just  as  if  you
switched to the next window, typed ^V, and switched back.  With a
negative argument, ESC ^V will scroll down.

When a window splits, both  halves  are  approximately  the  same
size.   You can redistribute the screen space between the windows
with the ^X ^ ([4mgrow-window[24m) command.  It makes the active  window
grow  one  line  bigger,  or as many lines as is specified with a
numeric argument.  Use ESC X [4mshrink-window[24m  to  make  the  active
window smaller.

[1m11.2.  Multiple Buffers in Multiple Windows[0m

Buffers  can  be selected independently in each window.  The ^X B
([4mselect-buffer[24m) command selects a different buffer in the  active
window  (i.e.  the  one  containing  the cursor).  Other windows'
buffers do not change.  Likewise, the ^X ^F  ([4mfind-file[24m)  command
reads a new file into a new buffer in the active window.

You  can  view the same buffer in more than one window.  Although
the same buffer appears in both windows, they have different val-
ues  of  point,  so  you  can move around in one window while the
other window continues to  show  the  same  text.   If  you  make
changes  in  one window, and the same place in the buffer happens
to be visible in the  other  window,  your  changes  will  appear
simultaneously in both places.

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
replace the old file in [4mboth[24m windows.  To view different files in
different  windows, you must switch buffers in one of the windows
first (with ^X B) or use ^X ^F ([4mfind-file[24m).

A convenient  "combination"  command  for  viewing  something  in
another  window is ^X 4 ([4mwindow-find[24m).  With this command you can
ask to see any specified buffer, file or tag in the other window.









36                  JOVE Manual for UNIX Users


Follow  the  ^X 4  with either B and a buffer name, F and a file-
name, 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 4 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.

[1m11.3.  Controlling the Display[0m

Since  only part of a large file will fit in a window, JOVE tries
to show the portion that is likely to be interesting.   The  dis-
play  control  commands allow you to bring a different portion of
the buffer within the active window.

^L      [4mredraw-display[24m          Reposition point at a specified vertical
                                position, OR clear and redraw the window
                                with point in the same place.
ESC ^L  [4mclear-and-redraw[24m        Clear and redraw the entire screen.
^V      [4mnext-page[24m               Scroll forwards (a page or a few lines).
ESC V   [4mprevious-page[24m           Scroll backwards.
^Z      [4mscroll-up[24m               Scroll forward some lines.
ESC Z   [4mscroll-down[24m             Scroll backwards some lines.
        [4mscroll-left[24m             Scroll the window to the left.
        [4mscroll-right[24m            Scroll the window to the right.
        [4mnumber-lines-in-window[24m  Number the lines in the window.


A window is rarely large enough to display all of your file.   If
the whole buffer doesn't fit on the screen, JOVE shows a contigu-
ous 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  a
new  point.   This is JOVE's guess as to what you are most inter-
ested in seeing, but if the guess is wrong, you can use the  dis-
play control commands to see a different portion.

If  the  window holds only a part of the buffer, and if the vari-
able [4mscroll-bar[24m is [4mon[24m, a clear patch in the  (otherwise  reverse-
videoed) mode line indicates what proportion is visible.  This is
especially useful for mouse-based versions of the editor, such as
[4mxjove[24m.

First  we  describe how JOVE chooses a new window position on its
own.  The goal is usually to place point half way down  the  win-
dow.  This is controlled by the variable [4mscroll-step[24m, whose value
is the number of lines above the bottom or below the top  of  the
window  that  the  line containing point is placed.  A value of 0
(the initial value) means center point in the window.

The basic display control command is ^L ([4mredraw-display[24m).  In its
simplest  form,  with  no argument, it tells JOVE to choose a new
portion of the buffer, centering the existing point half way from
the  top  as  usual.   ^L  with a positive argument chooses a new









                    JOVE Manual for UNIX Users                 37


portion 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 during the ^L command point stays on the same line, the window
is first cleared and then redrawn.  Thus, two ^L's in a  row  are
guaranteed to clear and redraw the active window.  ESC ^L ([4mclear-[0m
[4mand-redraw[24m) will clear and redraw the entire screen.

The [4mscrolling[24m commands ^V, ESC V, ^Z, and ESC Z let you move  the
whole  display  up  or down a few lines.  In fact, with a numeric
argument, ^V is identical to ^Z and ESC V to ESC Z.  So ^V ([4mnext-[0m
[4mpage[24m) or ^Z ([4mscroll-up[24m) with an argument shows you that many more
lines at the bottom of the screen, moving the text and  point  up
together  as  ^L  might.  ^V or ^Z with a negative argument shows
you more lines at the top of the screen, as does ESC V ([4mprevious-[0m
[4mpage[24m) or ESC Z ([4mscroll-down[24m) with a positive argument.

^V  with  no  argument scrolls the buffer a window at a time.  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  argu-
ment,  which moves a whole window backwards (again with a line of
overlap).

With no argument, ^Z and ESC Z scroll one line  forward  and  one
line  backward, respectively.  These are convenient for moving in
units of one line without having to type a numeric argument.

The commands [4mscroll-left[24m and [4mscroll-right[24m scroll the entire  win-
dow  in the specified direction by the amount of the argument (or
for 10 characters by default).  The argument may be negative.

The command [4mnumber-lines-in-window[24m causes each line displayed  to
be  preceded  by  its  line-number  (and giving the command again
restores the former state).  Note that this state is  a  property
of the window, not of the buffer.

[1m12.  Processes Under JOVE[0m

An  important  feature  of  JOVE  is its ability to interact with
UNIX.  You can run UNIX commands from JOVE and catch their output
in  JOVE  buffers.  Two mechanisms are provided, [4minteractive[24m [4mpro-[0m
[4mcesses[24m and [4mnon-interactive[24m [4mprocesses[24m.

[1m12.1.  Interactive Processes[0m

With most modern UNIX systems, JOVE has the capability of running
interactive  processes,  accepting  your input and capturing your
output in a buffer.










38                  JOVE Manual for UNIX Users


  [4mshell[24m            Run a shell in  an  interactive
                   process buffer.
  [4mi-shell-command[24m  Run a UNIX command in an inter-
                   active process buffer.


[1m12.1.1.  How to Run a Shell in a Window[0m

Type ESC X [4mshell[24m<return> to start up a shell.  JOVE will create a
buffer,  called  [1m*shell*-1[22m,  and  choose  a  window  for this new
buffer.  The shell process is now said  to  be  attached  to  the
buffer.   The  program  that is now running in the buffer is that
specified by the variable [4mshell[24m, which is itself initialized from
your  SHELL  environment  variable.   The shell command is called
with the flag "-c", or whatever else the variable [4mshell-flags[24m has
been set to.

Use  an  argument  ([1mn[22m)  with  the  [4mshell[24m  command to create other
buffers ([1m*shell*-n[22m) running independent shells.

Once an interactive process is running  you  can  select  another
buffer  into  that  window,  or  you can delete that window alto-
gether.  You can go off and do some other editing while the  com-
mand  is  running.   This is useful for commands that do sporadic
output and run for fairly long periods of time.  When  you  rese-
lect  that  buffer  later  it  will be up to date.  That is, even
though the buffer wasn't visible it was  still  receiving  output
from the process.  You don't have to worry about missing anything
when the buffer isn't visible.

[1m12.1.2.  How to Run a Command in a Window[0m

To run a UNIX command interactively from JOVE type ESC X [4mi-shell-[0m
[4mcommand[24m  <command-name><return>.   For  example,  to run the desk
calculator, you do:

     ESC X i-shell-command dc<return>

Then JOVE picks a buffer in which the  output  from  the  command
will  be placed, named after the command ([4mdc[24m in this case).  Com-
pare this command to  the  non-interactive  [4mshell-command[24m  to  be
described presently.

[1m12.1.3.  Facilities available in interactive windows[0m

What  you type into an interactive process 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.










                    JOVE Manual for UNIX Users                 39


In fact Return does different things depending on both your posi-
tion  in the buffer and on the state of the process.  In the nor-
mal case, when point is in the last line of  the  buffer,  Return
does  as  already described: it inserts a line-separator and then
sends the line to the process.  If you are somewhere else in  the
buffer,  possibly  positioned at a previous command that you want
to edit, Return will place a copy of that line at the end of  the
buffer  and move you there (the prompt will be discarded if there
is one -- the variable [4mprocess-prompt[24m specifies what to  discard)
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 [4mlist-processes[24m<return> to get a  list  of  each
process  and  its  state.  If your process died abnormally, [4mlist-[0m
[4mprocesses[24m may help you figure out why.

Another feature is that you have the entire history of your  ses-
sion  in  the  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 versions of previous com-
mands, or edit the output of one command to become a list of com-
mands to be executed ("immediate shell scripts").

There  are several special commands available only in interactive
windows.

Return  [4mprocess-newline[24m              Send a line to a process.
        [4mprocess-send-data-no-return[24m  Send a line to a process, but without the  line-separa-
                                     tor.
^C ^C   [4minterrupt-process[24m            Send SIGINT to the process.
^C \    [4mquit-process[24m                 Send SIGQUIT to the process.
^C ^Z   [4mstop-process[24m                 Send SIGTSTP to the process.
^C ^Y   [4mdstop-process[24m                Send SIGTSTP when next the process tries to read input.
        [4mcontinue-process[24m             Send SIGCONT to the process.
        [4mkill-process[24m                 Send SIGKILL to the process in a specified buffer.
^C ^D   [4meof-process[24m                  Send EOF to the process.

Although  Return  is  automatically bound to [4mprocess-newline[24m, the
various ^C ... must be explicitly bound in your (or  your  system
administrator's)  customization.  The effects of Return ([4mprocess-[0m
[4mnewline[24m) in various circumstances  have  already  been  described
above.   The  effects  of  ^C ^[1mx  [22mfor various [1mx [22mare equivalent to
sending ^[1mx [22mto the shell, assuming the customary bindings  as  set
up  by  [4mstty[24m.   Observe  that ^[1mx [22mwithout a preceding ^C will have
some other effect in JOVE (for example,  ^D  is  still  bound  to
[4mdelete-next-character[24m).

[1m12.1.4.  DBX in interactive windows[0m

If  the  debugging program [4mdbx[24m is provided with your UNIX system,
you may of course run it in an interactive window.  Before  doing
this,  you should turn on the dbx minor mode.  The effect of this









40                  JOVE Manual for UNIX Users


is that, every time [4mdbx[24m halts with a message  line  specifying  a
filename and linenumber (at every breakpoint, for example), [4mfind-[0m
[4mfile[24m will automatically be  called  on  that  filename,  it  will
appear  in  another window, and point will be moved to that line.
Thus you may easily follow the  progress  of  the  program  being
debugged.

[1m12.2.  Non-interactive Processes[0m

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.  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 !  [4mshell-command[24m               Run a UNIX command in a buffer.
      [4mshell-command-no-buffer[24m     Run a UNIX command without any buffer.
      [4mshell-command-to-buffer[24m     Run a UNIX command in a named buffer.
      [4mshell-command-with-typeout[24m  Run a UNIX command sending  output  to
                                  the screen.


To  run  a  UNIX  command  from  JOVE  just  type  ^X ! <command-
name><return>.  For example, to get a list of all  the  users  on
the system, you do:

     ^X ! who<return>

Then  JOVE  picks  a  buffer in which the output from the command
will be placed, named after the  command.   E.g.,  "who"  uses  a
buffer  called [1mwho[22m; "ps alx" uses [1mps[22m; and "egrep -n foo *.c" uses
[1megrep[22m.  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 ([4mdelete-buffer[24m).  There are variants
of the command where there is no buffer, where you can name  your
own buffer, and where the output is direct to the screen (see the
section on typeout at the start of this manual).

Once JOVE has picked a buffer it puts that buffer in a window  so
you  can  see the command's output as it is running.  If there is
only one window JOVE will automatically make another one.  Other-
wise,  JOVE  tries  to pick the most convenient window other than
the current one.

It is not a good idea to type anything while the command is  run-
ning  because  JOVE won't see the characters (and thus won't exe-
cute them) until the command finishes, so you may forget what you
have  typed.   If  you really want to carry on with other editing
tasks while it is running, it is better to use  the  [4mi-shell-com-[0m
[4mmand[24m described previously.











                    JOVE Manual for UNIX Users                 41


If you want to interrupt the command for some reason (perhaps you
mistyped it, or you changed your mind) you can type ^] (or  what-
ever  else  has  been  put  in the variable [4minterrupt-character[24m).
Typing this inside JOVE while a process is running is the same as
typing ^C when you are outside JOVE, namely the process is inter-
rupted.

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 mes-
sage.

[1m12.2.1.  Applications of Non-Interactive Processes[0m

^X !  ([4mshell-command[24m) is useful for running commands that do some
output and then exit.  So you could type  ^X !  spell  <filename>
and  it  would  create  a  buffer  "spell",  fill it with all the
spelling mistakes in <filename> and display it in a window.  How-
ever,  as  we have already seen, there is a built-in JOVE command
to do this job  (and  more)  which,  behind  the  scenes,  issues
exactly  that  [4mshell-command[24m.   Thus,  the built in usage of this
facility by JOVE itself is as important  as  any  use  you  might
invent for yourself.

You  could  run a program through a compiler using [4mshell-command[24m,
but again JOVE provides a special command for the job.   This  is
the  ^X ^E  ([4mcompile-it[24m)  command.  If you run [4mcompile-it[24m with no
argument it runs the UNIX [4mmake[24m program into  a  buffer.   If  you
need  a  special  command  or want to pass arguments to [4mmake[24m, run
[4mcompile-it[24m 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.

Another  useful  example  of  using the [4mshell-command[24m would be to
type ^X ! egrep -l <identifier> *.c, to give you a  list  of  all
your .c files containing that <identifier>.

[1m12.2.1.1.  Error Message Parsing[0m

       [4mparse-errors[24m                     Prepare to exhibit the errors listed in the buffer.
       [4mparse-spelling-errors-in-buffer[24m  Prepare to exhibit the listed spelling errors.
^X ^N  [4mnext-error[24m                       Move to the next listed error.
^X ^P  [4mprevious-error[24m                   Move to the previous listed error.
       [4mcurrent-error[24m                    Move to the current listed error.


When  you have your error messages in a buffer as produced by the
[4mshell-command[24m, you run the  [4mparse-errors[24m  command  (this  happens
automatically  after  a  [4mcompile-it[24m).   Each  line in this buffer
should specify a filename and a linenumber  (JOVE  knows  how  to
interpret   the  error  messages  from  many  UNIX  commands;  in









42                  JOVE Manual for UNIX Users


particular from [4mcc[24m, [4mgrep[24m [4m-n[24m and [4mlint[24m).  [4mParse-errors[24m then does  a
[4mfind-file[24m  on  the  first  such  filename  and a [4mgoto-line[24m on its
linenumber.  When you have dealt with  the  error  on  that  line
(perhaps  editing lines elsewhere in your program in the process)
you can type ^X ^N ([4mnext-error[24m) to move to the next  error  (per-
haps  in  a  different  file).   Or you can type ^X ^P ([4mprevious-[0m
[4merror[24m) or ESC X [4mcurrent-error[24m.  The rules JOVE uses to  interpret
error  message  in  a buffer are specified in the variable [4merror-[0m
[4mformat-string[24m.

The action following the JOVE command [4mspell[24m  is  similar,  except
that  it calls (automatically) the command [4mparse-spelling-errors-[0m
[4min-buffer[24m instead of [4mparse-errors[24m.

If you already have a file called [4merrs[24m containing,  say,  C  com-
piler messages then you can get JOVE to interpret the messages by
invoking it as:

     [4m%[24m [4mjove[24m [4m-p[24m [4merrs[0m


[1m12.2.1.2.  Filtering[0m

  [4mfilter-region[24m  Pass the region through a  com-
                 mand  and  replace  it with the
                 output.


Suppose your buffer contains a table.  You make  this  table  the
region  (put mark at the start of it and point at the end).  Type
ESC X [4mfilter-region[24m [4msort[24m<return> (or  any  other  UNIX  command).
Your  table  will  be passed through the UNIX [4msort[24m command and be
replaced by the sorted version of itself.   The  old  version  is
placed  in  the  kill ring, and you can restore the status quo by
obeying the [4myank-pop[24m command.

[1m13.  Directory Handling[0m

To save having to use absolute pathnames when you want to edit  a
nearby  file JOVE maintains a [4mcurrent[24m [4mdirectory[24m and allows you to
move around the UNIX filesystem just as a shell would.

  [4mcd[24m dir       Change to the specified directory.
  [4mpushd[24m [dir]  Like [4mcd[24m, but saves the old directory on  the
               directory  stack.   With  no directory argu-
               ment, simply exchanges the top two  directo-
               ries on the stack and [4mcd[24ms to the new top.
  [4mpushlibd[24m     Does a [4mpushd[24m on the directory containing all
               of JOVE's standard customization files.
  [4mpopd[24m         Take the current directory off the stack and
               restore the previous one.
  [4mdirs[24m         Display the contents of the directory stack.











                    JOVE Manual for UNIX Users                 43


The  names  and  behavior  of these commands were chosen to mimic
those in the c-shell.

[1m14.  Major and Minor Modes[0m

[1m14.1.  Major Modes[0m

To help with editing particular types of file, say a document  or
a  C  program,  JOVE  has several [4mmajor[24m [4mmodes[24m.  Each mode defines
rules as to which characters constitute a "word"  (for  the  pur-
poses  of  regular-expressions,  language  identifiers, abbrevia-
tions, and double-clicking in [4mxjove[24m), how indentation  is  to  be
performed,  and maybe other specialized services.  These are cur-
rently as follows:

[1m14.1.1.  Fundamental Mode[0m

This is the simplest mode, with no frills, and is used  when  you
are operating within the message line at the bottom of the screen
(hence it is the mode of the Minibuf).

[1m14.1.2.  Text mode[0m

This is the default major mode.  Nothing special is  done  beyond
making apostrophe (') be a word character.

[1m14.1.3.  C mode[0m

In this mode, "$" and "_" are word characters, and there are spe-
cial facilities for indentation.  Using the  [4mauto-execute-command[0m
command,  you can make JOVE enter [4mC[24m [4mMode[24m whenever you edit a file
whose name ends in [4m.c[24m.

[1m14.1.3.1.  Indentation Commands[0m

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" (actually, it just goes back to the line  containing
the  nearest  unmatched  "{",  and  indents  1 Tab more than that
line).  The indentation will be in multiples of the  variable  [4mc-[0m
[4mindentation-increment[24m  (which defaults to 8).  Closing braces are
also handled specially, and are indented to match the correspond-
ing open brace.

If  you  Tab  in  the  middle of a (...) (for example, you call a
function whose actual-parameters stretch over  many  lines)  then
you  have  a choice depending on the variable [4mc-argument-indenta-[0m
[4mtion[24m.  If its value is -1, you will be aligned  with  the  corre-
sponding  actual-parameter on the line above.  Otherwise, [4mc-argu-[0m
[4mment-indentation[24m gives the extra number of characters by which to
indent this continuation line.










44                  JOVE Manual for UNIX Users


If  you really want a Tab to mean a single Tab on some particular
occasion, you can always precede it by a ^Q ([4mquoted-insert[24m).

[1m14.1.3.2.  Parenthesis and Brace Matching[0m

        [4mshow-match-mode[24m   Toggle the [4mShow[24m [4mMatch[24m minor mode.
ESC ^N  [4mforward-list[24m      Move forwards over a (...).
ESC ^P  [4mbackward-list[24m     Move backwards over a (...).
ESC ^D  [4mdown-list[24m         Move forward to just inside the next (...).
ESC ^U  [4mbackward-up-list[24m  Move backwards to the start of the  enclos-
                          ing (...).


To check that parentheses and braces match the way you think they
do, turn on the [4mShow[24m [4mMatch[24m minor  mode  (ESC X  [4mshow-match-mode[24m).
Then,  whenever you type a close brace or parenthesis, the cursor
moves momentarily to the matching opener, if it is currently vis-
ible.  If it's not visible, JOVE displays the line containing the
matching opener on the message line.

If your parenthesized expressions are already typed, then you may
find  ESC ^N  and  ESC ^P useful to find a closing parenthesis to
match an opening one somewhere just after point, or a closing one
to  match  an opening one somewhere just before point.  Note that
these commands handle all kinds of parentheses ((...), [...]  and
{...})  and  properly  matched  internal  pairs are skipped over.
These two commands take arguments and go in the  opposite  direc-
tion  if  the argument is negative.  Likewise, the commands ESC D
([4mdown-list[24m) and ESC U ([4mbackward-up-list[24m) may be used to find more
or less (respectively) deeply nested parentheses.

[1m14.1.3.3.  C Tags[0m

Often when you are editing a C program, especially someone else's
code, you see a function call and wonder what that function does.
So  you  have  to suspend the edit, [4mgrep[24m for the function-name in
every .c file that might contain it, and finally visit the appro-
priate file.

To avoid this diversion or the need to remember which function is
defined in which file, many UNIX systems provide a program called
[4mctags(1)[24m,  which  takes a set of source files and looks for func-
tion definitions, producing a file called [4mtags[24m as its output.

^X T  [4mfind-tag[24m           Find the file/line where the specified tag is declared.
      [4mfind-tag-at-point[24m  Find the tag immediately following point.


JOVE has a command called ^X T ([4mfind-tag[24m) that  prompts  you  for
the name of a function (a [4mtag[24m), looks up the tag reference in the
previously constructed [4mtags[24m file, then performs  a  [4mfind-file[24m  on
the  file containing that tag, with point positioned at the defi-
nition of the function.  There is another version  of  this  com-
mand, [4mfind-tag-at-point[24m, that uses the identifier at point.









                    JOVE Manual for UNIX Users                 45


So,  when  you've  added new functions to a module, or moved some
old ones around, run the [4mctags[24m program  to  regenerate  the  [4mtags[0m
file.  JOVE looks in the file specified by the variable [4mtag-file[24m.
The default is "[1m.[22m/tags", i.e. the tag file in the current  direc-
tory.   If  you wish to use an alternate tag file you use ^U ^X T
and JOVE will prompt for a file name.

To begin an editing session looking for a particular tag, use the
[4m-t[24m  [4mtag[24m command line option to JOVE.  For example, say you wanted
to look at the file containing the tag [4mSkipChar[24m, you would invoke
JOVE as:

     [4m%[24m [4mjove[24m [4m-t[24m [4mSkipChar[0m


[1m14.1.4.  Lisp mode[0m

In  this  mode,  any  of the characters "!$%&*+-/:<=>?^_{|}~" and
Delete are word characters (in  other  words,  "words"  are  Lisp
atoms).  The mode is analogous to [4mC[24m [4mMode[24m, but performs the inden-
tation needed to lay out Lisp programs properly.

[1m14.1.4.1.  Parenthesis Matching[0m

In addition to the parenthesis matching commands available  under
C mode, we have:

ESC ^F  [4mforward-s-expression[24m   Move backward over an atom or list.
ESC ^B  [4mbackward-s-expression[24m  Move forward over an atom or a list.
        [4mgrind-s-expression[24m     Re-indent an s-expression.
ESC ^K  [4mkill-s-expression[24m      Kill from point to the end of an s-expression.


In fact the first two of these commands work in other modes also,
but for "atom" read "identifier".

[1m14.2.  Minor Modes[0m

In addition to the major modes, JOVE has a  set  of  minor  modes
whose state is controlled by the following commands:

  [4mauto-indent-mode[0m
  [4mauto-fill-mode[0m
  [4mdbx-mode[0m
  [4mover-write-mode[0m
  [4mread-only-mode[0m
  [4mshow-match-mode[0m
  [4mword-abbrev-mode[0m


With  no  argument,  these commands toggle the mode.  With a zero
argument they turn it [4moff[24m, and with any other argument they  turn
it [4mon[24m.










46                  JOVE Manual for UNIX Users


[1m14.2.1.  Auto Indent[0m

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.   This mode is only likely to be useful if
you are afflicted with a keyboard without a Linefeed key.

[1m14.2.2.  Auto Fill[0m

In [4mAuto[24m [4mFill[24m mode, a newline is automatically inserted  when  the
line  length  exceeds the right margin.  This way, you can type a
whole paragraph without having to use the Return key.

[1m14.2.3.  DBX[0m

This mode is useful if dbx is being run in an interactive window.
It is described in the section on interactive windows.

[1m14.2.4.  Over Write[0m

In  this  mode,  any text typed in will replace the previous con-
tents (the default is for new text to be inserted and "push"  the
old along).  This is useful for editing an already-formatted dia-
gram in which you want to change some things without moving other
things around on the screen.

[1m14.2.5.  Read Only[0m

In  this  mode,  modifying the buffer is inhibited.  This mode is
set automatically on any attempt to read a file for which you  do
not have write permission.

[1m14.2.6.  Show Match[0m

Move  the  cursor momentarily to the matching opening parenthesis
when a closing parenthesis is typed.

[1m14.2.7.  Word Abbrev[0m

In this mode, every word you type is compared to a list  of  word
abbreviations;  whenever you type an abbreviation, it is replaced
by the text that it abbreviates.  This can save typing if a  par-
ticular  word or phrase must be entered many times.  For example,
your programming language might have reserved words that you cus-
tomarily  type  in  upper  case  (identifiers etc. being in lower
case).  So you might define B as an abbreviation for BEGIN, E for
END, P for PROCEDURE, and so on.

  [4mdefine-global-word-abbrev[24m  Define a new global abbreviation.
  [4mdefine-word-abbrev[24m         Define  a new abbreviation within the cur-
                             rent major mode.
  [4medit-word-abbrev[24m           Edit the list of abbreviations.
  [4mwrite-word-abbrev-file[24m     Write the list of abbreviations to a file.










                    JOVE Manual for UNIX Users                 47


  [4mread-word-abbrev-file[24m      Read a list of abbreviations from a file.


The abbreviations and their expansions are held in  a  list  that
looks like:

     abbrev:phrase

for example

     jove:jonathan's own version of EMACS

Use  [4mdefine-global-word-abbrev[24m  to  add  an  entry  that is to be
effective in all buffers and [4mdefine-word-abbrev[24m for an entry that
is  to be effective only in buffers of the same major mode as the
selected buffer.  Use  [4medit-word-abbrev[24m  to  edit  the  list  (it
enters  a  recursive  edit on a buffer containing the list -- use
^X ^C ([4mexit[24m [4mjove[24m) when you are finished).  Use [4mwrite-word-abbrev-[0m
[4mfile[24m  to  write  the  list to a file and [4mread-word-abbrev-file[24m to
read it back again (this command might be used  in  your  [1m.joverc[0m
file) .

If  the variable [4mauto-case-abbrev[24m is [4mon[24m, and the abbreviations in
the list are all in lower case (as in the "jove"  example  above)
then, whenever you type "jove" you will get

     jonathan's own version of EMACS

but if you type "Jove" you will get

     Jonathan's own version of EMACS

and  if  you type "JOVE" (with at least 2 upper case letters) you
will get

     Jonathan's Own Version Of EMACS


On the other hand, if the variable [4mauto-case-abbrev[24m is [4moff[24m (as it
should be for the reserved word example) the case of the abbrevi-
ation is significant and must be matched exactly.

[1m15.  Macros[0m

^X (   [4mbegin-kbd-macro[24m            Start recording your commands.
^X )   [4mend-kbd-macro[24m              Stop recording your commands.
ESC I  [4mmake-macro-interactive[24m     Call for a parameter to be typed at this point.
^X E   [4mexecute-kbd-macro[24m          Replay the recording.
       [4mname-kbd-macro[24m             Name the recording.
       [4mdefine-macro[24m               Define a named macro.
       [4mexecute-macro[24m              Execute a named macro.
       [4mwrite-macros-to-file[24m       Write all named macros to a file.
       [4mbind-macro-to-key[24m          Bind named macro to a key-sequence.










48                  JOVE Manual for UNIX Users


       [4mbind-macro-to-word-abbrev[24m  Bind named macro to an abbrev.


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.  The
easiest way to do this is "by example".

[1m15.1.  Keyboard Macros[0m

First  you  type  ^X ( ([4mbegin-kbd-macro[24m).  Next you "perform" the
commands which will constitute the body of the  macro  (they  are
executed  as well as being remembered).  Then you type ^X ) ([4mend-[0m
[4mkbd-macro[24m).  You now have a [4mkeyboard[24m [4mmacro[24m.

To run this command sequence again, type ^X E  ([4mexecute-keyboard-[0m
[4mmacro[24m).

If  your  macro  needs a parameter (a filename to be opened, per-
haps), include the command needing the parameter (e.g. ^X ^F)  at
the  appropriate place in the macro followed immediately by ESC I
([4mmake-macro-interactive[24m).  When the macro is executed,  you  will
be  given  an opportunity to type in the actual-parameter at this
point.

[1m15.2.  Named Macros[0m

You may give the keyboard macro a name using  the  [4mname-keyboard-[0m
[4mmacro[24m command (or you may create a named macro from scratch using
the [4mdefine-macro[24m command).  We're still not finished because  all
this  hard work will be lost if you leave JOVE.  What you do next
is to save your macros into a file with the  [4mwrite-macros-to-file[0m
command.   To  retrieve  your macros in the next editing session,
you can simply execute  the  [4msource[24m  command  on  that  file,  or
include that file in your personal [1m.joverc [22mfile.

A  named  macro  can  be  executed  by typing ESC X [4mexecute-macro[0m
<macro-name><return>.  It is unfortunate  that  macro  names  are
kept  in  a  different name space than command names, so that you
cannot type ESC X <macro-name>.  This may well be  changed  in  a
future release.

[1m15.3.  Binding[0m

Finally,  if  you  find  all this bothersome to type and re-type,
there is a way to bind the macro to a key.  The binding  is  made
with  the  [4mbind-macro-to-key[24m  command, or alternatively the [4mbind-[0m
[4mmacro-to-word-abbrev[24m command (in which case  the  macro  will  be
executed  upon  typing  the  abbrev word you have specified -- it
will get expanded as well unless it was an abbreviation for noth-
ing).












                    JOVE Manual for UNIX Users                 49


[1m16.  Customizing Jove[0m

[1m16.1.  The jove.rc and .joverc files[0m

JOVE  is aware of a directory, the [4msharedir[24m, in which system-wide
customization files are kept.  Chief amongst these  is  the  file
[1mjove.rc  [22mwhich  is read each time JOVE is started up ([1mjove.rc [22mmay
then initiate the reading of other files in the sharedir, such as
initialization  files  for specific terminals).  After that, JOVE
reads your personal [1m.joverc [22min your $HOME directory, if you  have
one.   And  if  all  that is not enough, you may at any time read
other customization files using the [4msource[24m command.

The JOVE distribution  comes  with  a  recommended  [1mjove.rc  [22mfile
together  with specific [1mjove.rc.TERM [22mfiles for various terminals.
It is up to system administrators to decide whether to use  these
as they stand or to modify them to accord with local conventions.
Note that these files are well commented and worthy of  study  by
those who decide to "roll their own".

There  are  command-line  options  that  can be used when JOVE is
started to substitute a different [4msharedir[24m or to suppress reading
of  the  [1mjove.rc [22mor [1m.joverc [22mfiles or both -- see the Man page for
JOVE.  Thus everything is ultimately under  the  control  of  the
individual JOVE user.

[1m16.2.  The source Command[0m

Type  ESC X  [4msource[24m  <filename><return> to read and obey the com-
mands in <filename>.   If  a  numeric  argument  is  supplied  to
[4msource[24m, it will silently ignore a request for a non-existent file
(otherwise an error message will be produced).  The format of the
[4msource[24md file, as of the [1mjove.rc [22mand [1m.joverc [22mfiles, is as follows.

Each line consists of a command name (no need to precede it  with
ESC X) followed by whatever parameters that command requires.  To
give a numeric argument to the command, simply precede  the  com-
mand  name  by  a  number.  Thus it is possible to to do anything
that the user could do while JOVE is running.

But there is more than this.  You can say
     [4mif[24m <shell-command>
          <command>
          <command>
     [4melse[0m
          <command>
          <command>
     [4mendif[0m
The <shell-command> is run, and if it succeeds the first  lot  of
<command>s is obeyed, and otherwise the second lot (the [4melse[24m part
is optional).  Another variant of this feature allows you to say,
in  place  of  [4mif[24m  <shell-command>,  [4mifenv[24m <environment-variable>
<pattern>, which succeeds if <environment-variable> exists and if
its  value  matches <pattern>.  These conditional commands can be









50                  JOVE Manual for UNIX Users


nested in the usual way; also indentation and empty lines have no
effect.   Finally,  you  can  include  comments  on any line that
starts with a "#".

Here are some examples taken from the provided [1mjove.rc[22m.
     pushlibd
     # This is for the shell window.  Supports sh, csh and ksh.
     set process-prompt ^[^%$#]*[%$#]
     # Modern terminals do not need ^S/^Q for flow control.
     # The exceptions (e.g. vt100) should turn it  off  again  in
     jove.rc.TERM.
     set allow-^S-and-^Q on
     # source any TERMinal-specific rc file
     1 source jove.rc.$TERM
     popd

The  [4mpushlibd[24m  ensures  that  any  files it tries to read will be
taken from the [4msharedir[24m (observe the matching [4mpopd[24m at  the  end).
Then  follow  some  settings  of variables such as [4mprocess-prompt[0m
(see the discussion of interactive processes earlier in this man-
ual).   Observe  how environment variables such as $TERM are hon-
ored within parameters, and note  how  that  [4msource[24m  command  was
given  a  numeric argument so that there would be no complaint if
the file [1mjove.rc.$TERM [22mdid not exist.

On the other hand, if [1mjove.rc.$TERM [22mdoes exist for the particular
terminal  specified  in $TERM, that file will now be [4msource[24md.  It
will likely set many key bindings particular  to  that  terminal,
and then say
     define-macro keychart ^[xpushlibd^M
          ^U^[Xshell-command-with-typeout cat keychart.$TERM^M
          ^[Xpopd^M
     # except that should really have been all on one line
     bind-macro-to-key keychart ^[[~

Quite  some  mouthful! What it does is to define a macro [4mkeychart[0m
(the hard way) and bind it to ESC [ ~.  In general, any  terminal
for  which  extensive  key  bindings are provided ought to define
this macro and bind it to a  suitable  key  (preferably  the  one
inscribed  "Help").   When this key is pressed, it will cause the
file [1mkeychart.$TERM [22mto be displayed  on  the  screen  in  [4mtypeout[0m
style.   This  file  should  exhibit a map of the terminal's key-
board, showing what has been bound to  each  key.   The  [4msharedir[0m
contains several such keychart files.

Although  Control characters may be stored as themselves in these
files (as produced by the [4mquoted-insert[24m command, for example), it
is better to store them using an explicit "^" (e.g. as ^C), since
this form is accepted by the [4msource[24m command, and editing files in
this form is much easier.













                    JOVE Manual for UNIX Users                 51


[1m16.3.  Key Re-binding[0m

Many  of  the  commands built into JOVE are not bound to specific
keys.  You must type ESC X <command-name> ([4mexecute-named-command[24m)
in  order  to  invoke  these commands.  Also, many of the keys to
which commands [4mare[24m bound are hard to remember (although at  least
compatible  across all terminals) whilst all sorts of interesting
keys on the particular keyboard remain unused.   For  both  these
reasons, JOVE makes it possible to [4mbind[24m commands to keys.

  [4mbind-to-key[24m                 Bind a command to a key-sequence.
  [4mbind-macro-to-key[24m           Bind a named macro to a key-sequence.
  [4mbind-macro-to-word-abbrev[24m   Bind a named macro to an abbrev.
  [4mbind-keymap-to-key[24m          Bind an extra key-sequence to a keymap.
  [4mdescribe-bindings[24m           Exhibit all key bindings as a screen typeout.

  [4mlocal-bind-to-key[24m           As  bind-to-key,  for  use  in  the  selected
                              buffer only.
  [4mlocal-bind-macro-to-key[24m     As bind-macro-to-key, for use in the selected
                              buffer only.
  [4mlocal-bind-keymap-to-key[24m    As   bind-keymap-to-key,   for   use  in  the
                              selected buffer only.

  [4mprocess-bind-to-key[24m         Bind interactive process command  to  a  key-
                              sequence.
  [4mprocess-bind-macro-to-key[24m   Bind  a  macro  within  interactive processes
                              only.
  [4mprocess-bind-keymap-to-key[24m  Bind a keymap  within  interactive  processes
                              only.


Although  these  commands  can  be typed in by the user, they are
mostly intended for use in [4msource[24md files.   Here  are  some  more
examples from [1mjove.rc[22m.
     #  if  you  have  job control, this puts Jove out of the way
     temporarily.
     bind-to-key pause-jove ^[S
     bind-to-key pause-jove ^[s
     # The following apply to shell windows.   Note  the  use  of
     ^C^C, ^C^D etc.,
     process-bind-to-key interrupt-process ^C^C
     process-bind-to-key eof-process ^C^D
     # This makes the arrow keys work on most terminals.
     bind-to-key previous-line ^[[A
     bind-to-key next-line ^[[B

When a command is [4mbound[24m to a key any future hits on that key will
invoke that command.  All the printing characters  are  initially
bound  to  the  command  [4mself-insert[24m.   Thus, typing any printing
character causes it to be inserted into the text.   To  unbind  a
key, simply bind it to the fictitious command [4munbound[24m.

Observe how key-sequences are often derived from common prefixes,
such as ^X ...,  ESC ...  (to  be  typed  as  ^[ ...  in  binding









52                  JOVE Manual for UNIX Users


commands)  and ESC [ ... (or ^[ [ ...).  Internally, JOVE creates
tables for each prefix encountered, but it cannot  create  a  new
prefix  from  a  manually entered [4mbind-[24m command (it does not know
when you have finished your binding).  To overcome this, give the
[4mbind-[24m  command  an  argument and terminate it with a Return (this
applies automatically within [4msource[24md files).  Obviously, you must
not have two bindings where one is a prefix of the other.

Very  rarely, you may want two prefixes to be regarded as equiva-
lent for all commands (for example, you have a keyboard  with  no
ESC  key, and it would be tedious to have to rebind every command
in the system with a different prefix).  In this  case,  you  can
type   ESC X   [4mbind-keymap-to-key[24m   <named-keymap>   <prefix-key-
sequence>.  The only recognized <named-keymap>s are "ESC-map" and
"Ctlx-map", and the customary replacement for ESC is "`".

For  historical  reasons,  the Escape key is often referred to as
"Meta".  Indeed, if your terminal has a Meta-key which forces the
8th-bit  of  a character, and if the variable [4mmeta-key[24m is [4mon[24m, you
may type Y whilst holding the Meta-key down to achieve  the  same
effect as when typing ESC Y.

[1m16.3.1.  The Provided Terminal Bindings[0m

The  terminals  for  which  keybindings  have been provided are a
mixed bunch (we would welcome suggestions for other common termi-
nals).  However, there are certain principles which were followed
in setting them up.

1.   Groupings of keys that are found in bindings for other  ter-
     minals were adhered to so far as possible.  Rather than say-
     ing that the F1 key  always  does  so-and-so,  groupings  of
     Function Keys that are physically associated on the keyboard
     were mapped onto similar groupings on other keyboards,  even
     though the engravings on them might be quite different.

2    Keys which do related things should be close together.

3    Keys which customarily do certain things under other editors
     normally used with that keyboard should do the same (or sim-
     ilar) things under JOVE.

4    Keys which have suggestive engravings on them should do what
     the engravings suggest.  Sometimes,  this  necessitated  the
     creation of a macro where no JOVE command existed to do pre-
     cisely that job (for example, the macro [4mkill-line[24m).

[1m16.4.  Auto-execution of Commands[0m

It is useful, when a file is recognized as being in a  particular
programming  language,  for  the appropriate major mode and other
relevant facilities to be set up automatically in any buffer into
which such a file is read.










                    JOVE Manual for UNIX Users                 53


  [4mauto-execute-command[24m  Obey the given command for each
                        filename matched by  the  given
                        regular-expression.
  [4mauto-execute-macro[24m    Obey the given macro likewise.


Here is an example taken from [1mjove.rc[22m.
     # set various language modes.
     1 auto-execute-command c-mode .*.[chy]$
     1 auto-execute-command lisp-mode .*.l$.*.lisp$.*.scm$
     # all the languages need show-match-mode.
     1            auto-execute-command            show-match-mode
     .*.[lchyfp]$.*.lisp$.*.scm$

The effect of this is that whenever a filename matches the  regu-
lar-expression  ".*.[chy]$"  the  command [4mc-mode[24m is obeyed in the
buffer into which the file is being read, and similarly for [4mlisp-[0m
[4mmode[24m.   An attempt is then made to set [4mshow-match-mode[24m for both C
and Lisp programs.  Observe that all the [4mauto-execute-command[24ms in
this  example  have an argument of 1.  This argument is passed on
to the obeyed command so that, for example, it is ensured that [4mc-[0m
[4mmode[24m  is  definitely  set to be [4mon[24m, rather than merely being tog-
gled.

[1m16.5.  Customizing the Mode Line[0m

The format of the mode line is controlled by the  variable  [4mmode-[0m
[4mline[24m.  Here is a suggested setting.

     %[Jove%]%w%w%c(%M)%3c[%b:%n]%2c"%f"%2c%m*-%m*-%2c%p%2s%(%d%e(%t)%)


and here is what it all means.

%[...%]     Puts brackets around Jove when in a recursive edit.

%w%w        Warns with >> if the window is scrolled left.

(%M)        Gives the current major and minor modes.

[%b:%n]     Shows the buffer name and number.

"%f"        Shows the filename.

%m*-%m*-    Displays ** if the buffer is modified, -- if not.

%p          In process windows only, shows the status of the pro-
            cess.

%d          Shows the current directory.

(%t)        Shows the time of day.











54                  JOVE Manual for UNIX Users


Everything else is layout.  See the full description of the [4mmode-[0m
[4mline[24m variable for further details.

[1m17.  Xjove and Xterm[0m

If you run JOVE on a workstation equipped with the X-Windows sys-
tem from M.I.T., then it is advised to run JOVE under one of  the
terminal  emulators [4mxjove[24m or [4mxterm[24m.  [4mXterm[24m is provided as a stan-
dard part of the X-Windows system, but  the  facilities  provided
are a small subset of those available with [4mxjove[24m, which was writ-
ten especially to support JOVE.  However, [4mxjove[24m suffers from  the
disadvantage  that  it  must  be compiled under the XView Toolkit
which, although available free from M.I.T., may not be  available
on  your  system.  Note that, in either case, special keybindings
must   be   provided   (see   the   files   [1mjove.rc.sun-cmd   [22mand
[1mjove.rc.xterm[22m).   See  the  Man page for [4mxjove[24m for how to call it
and the flags and options available.

[1m17.1.  Basic Mouse Operations[0m

When running under [4mxjove[24m or [4mxterm[24m you may click  the  LEFT  mouse
button  in  order  to  set  the position of point, and the MIDDLE
mouse button to set the position of point and mark.  If you  hold
the  MIDDLE  button  down,  you  may sweep it along, leaving mark
where you started and point where you finished, thus defining the
region.   If  you  hold  the Control key down while you are doing
this, the region is copied to the kill ring, as  with  the  [4mcopy-[0m
[4mregion[24m  command,  and if you hold both the Control and Shift keys
down, the region is killed (and sent to the kill  ring)  as  with
the  [4mkill-region[24m command.  To have the killed text yanked at some
other point, click the LEFT mouse button there, holding the  Con-
trol key down at the same time.

To  switch  to  a different window, simply click either button in
the window you want to be in (note  that  this  does  not  affect
point  or  mark  in  that window -- it takes two clicks to change
windows and then change point).

To scroll rapidly to a different part of the buffer, simply click
either  mouse button in the mode line at a position corresponding
to the percentage way down the file you want to be.  It helps  to
have  set  the  variable [4mscroll-bar[24m [4mon[24m so that you can see by the
uninverted part of the mode line which part of the buffer is cur-
rently  visible in the window.  When you have finished, the mouse
pointer should be exactly in the middle of the uninverted region.

[1m17.2.  Additional Xjove Features[0m

When  running  under  [4mxjove[24m there are some additional facilities.
Firstly, the setting when pointing into the  mode  line  is  more
sensitive,  because  it  notes  the mouse position to the nearest
pixel instead of the nearest character, and  it  is  possible  to
hold  the mouse button down and watch the window scrolling as you
drag it (although this can consume considerable machine resources









                    JOVE Manual for UNIX Users                 55


and  it may have difficulty in keeping up).  Also, it is possible
to follow the position of point in real  time  as  you  drag  the
mouse around when delineating a region.

If you do a double click with the MIDDLE button in [4mxjove[24m, it will
set the region spanning the word you were over (or  spanning  the
gap  if  you  were  between  words).  Note that the definition of
"word" here follows the major mode.  If you do a triple click, it
will  likewise  select  the  whole line.  These operations may be
combined with the Control key, or  the  Control  and  Shift  keys
together, to obtain copying and killing as before.

If your keyboard has keys marked Paste and Cut, it is possible to
bring text from another part of the buffer (even from a different
window) without changing the position of point (this is useful if
you are constructing text at some point,  bringing  in  fragments
from  other places -- you would prefer not to have to keep moving
point to those other places to acquire some  text  for  the  kill
ring,  only to have to move it back again before yanking).  To do
this, with point where you want the text to be inserted, you hold
the Paste key down while you select a region with the MIDDLE but-
ton (multi-clicking or dragging as usual).  When  you  have  fin-
ished,  a  copy  of the region you selected will appear at point,
with point moved beyond it (since it went via the kill ring, this
text  is  also  available for conventional yanking subsequently).
If you change your mind in mid stream, let  go  of  Paste  before
releasing MIDDLE.  Likewise, if you do the same thing holding the
Cut key down, the text will also  be  killed  from  its  original
position.

Finally, if you press the RIGHT mouse button, you will be offered
a menu which enables you to issue any JOVE  command  or  set  any
JOVE  variable.  Particularly useful if you need some obscure and
rarely used command, and  cannot  remember  exactly  what  it  is
called.

[1m18.  Recovering from system/editor crashes[0m

JOVE  does  not have an [4mAuto[24m [4mSave[24m mode, but it does provide a way
to recover your work in the event of a system  or  editor  crash.
JOVE  saves  information  about  the  files you are editing every
[4msync-frequency[24m changes to a special buffer, so as to make  recov-
ery  possible.  Since a relatively small amount of information is
involved it is hardly even noticeable when JOVE does  this.   The
variable  [4msync-frequency[24m  says  how  often  to save the necessary
information, and the default is every 50 changes.  50 is  a  very
reasonable  number:  if you are writing a paper you will not lose
more than the last 50 characters you typed, which  is  less  than
the average length of a line.

If  JOVE,  or  the operating system, crashes, you may now use the
JOVE [4mrecover[24m program to get back your files.  You invoke this  by
running  JOVE  with  the  -r flag.  See the Man page for JOVE for
further details.









56                  JOVE Manual for UNIX Users


Another worthwhile precaution you can take is to set the variable
[4mmake-backup-files[24m  [4mon[24m.  Then, whenever you save a file with [4msave-[0m
[4mfile[24m it will leave behind the original version of that file  with
the name "#[4mfilename[24m~".



























































                    JOVE Manual for UNIX Users                 57


[1m19.  Alphabetical List of Commands and Variables[0m

In  this  chapter, the standard binding is shown for each command
which has one.  Generally, these are the built-in  bindings,  but
occasionally  they are ones taken from the provided [1mjove.rc [22mfile.

[1m19.1.  abort-char (variable)[0m

This variable defines JOVE'S abort character.   When  JOVE  reads
this  character  from  the  keyboard,  it  stops what it is doing
(unless the character is quoted  in  some  way).   Unfortunately,
JOVE won't notice the character until it reads from the keyboard.
The default value is ^G.  See also [4minterrupt-character[24m.

[1m19.2.  add-lisp-special (Not Bound)[0m

This command is to tell JOVE  what  identifiers  require  special
indentation  in lisp mode.  Lisp functions like [4mdefun[24m and [4mlet[24m 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.

[1m19.3.  allow-^S-and-^Q (variable)[0m

This variable, when set, tells JOVE that your terminal  will  not
need  to  use the characters ^S and ^Q for flow control, in which
case JOVE will instruct the system's  tty  driver  to  pass  them
through  as  normal characters.  Otherwise, if the tty driver was
already using these characters for flow control, it will continue
to  do  so.  Certain terminals and communications systems require
that this variable be set [4moff[24m; in other circumstances it is  bet-
ter set [4mon[24m.

[1m19.4.  allow-bad-characters-in-filenames (variable)[0m

If  set,  this  variable  permits the creation of filenames which
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 [4moff[24m.

[1m19.5.  append-region (Not Bound)[0m

This appends the region to a specified file.  If  the  file  does
not already exist it is created.

[1m19.6.  apropos (Not Bound)[0m

This  types  out each command, variable and macro with the speci-
fied string in its name ("?" matches every name).  For each  com-
mand  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










58                  JOVE Manual for UNIX Users


     : apropos window<Return> .


[1m19.7.  auto-case-abbrev (variable)[0m

When this variable is [4mon[24m (the default),  word  abbreviations  are
adjusted  for  case  automatically.  If the abbreviation is typed
with no uppercase letter, the expansion is not changed; if it  is
typed  with one or more uppercase letters, the first character in
the expansion is capitalized; additionally, if  the  abbreviation
is  typed with more than one uppercase letter, each letter in the
expansion immediately preceded by whitespace or - is capitalized.
For  example, if "jove" were the abbreviation for "jonathan's own
version of EMACS", the following table shows how the abbreviation
would be expanded.

     jove   jonathan's own version of EMACS
     Jove   Jonathan's own version of EMACS
     JOVE   Jonathan's Own Version Of EMACS
     JoVe   Jonathan's Own Version Of EMACS

When this variable is [4moff[24m, upper and lower case are distinguished
when looking for the abbreviation, i.e., in  the  example  above,
"JOVE"  and "Jove" would not be expanded unless they were defined
separately.  See also the [4mword-abbrev-mode[24m command.

[1m19.8.  auto-execute-command (Not Bound)[0m

This tells JOVE to execute a command automatically  when  a  file
whose  name matches a specified pattern is read.  The first argu-
ment is the command you wish to have executed.  The second  argu-
ment is the pattern, a regular expression that is matched against
the start of the file name.  If you wish to match a suffix, start
the pattern with ".*"; to match every file, use that as the whole
pattern.  Any numeric argument will be passed on to  the  command
when  it  is executed (this is useful when combined with commands
that adjust a minor mode).  For example, if you  want  to  be  in
[4mshow-match-mode[24m when you edit C source files (that is, files that
end with [1m.c [22mor [1m.h[22m) you can type

     : auto-execute-command show-match-mode .*\.[ch]$

Actually, this command toggles the Show  Match  minor  mode,  but
since  it is initially off, it will have the desired effect.  For
more certain control, give the  [4mauto-execute-command[24m  a  non-zero
numeric  argument: this will be passed on to the [4mshow-match-mode[24m.

[1m19.9.  auto-execute-macro (Not Bound)[0m

This is like [4mauto-execute-command[24m except you use  it  to  execute
macros automatically instead of built-in commands.












                    JOVE Manual for UNIX Users                 59


[1m19.10.  auto-fill-mode (Not Bound)[0m

This  turns  on  or  off the Auto Fill minor mode in the selected
buffer.  Without a numeric  argument,  the  command  toggles  the
mode;  with  a zero argument, the mode is turned off; with a non-
zero argument, the mode is turned on.  When JOVE is in Auto  Fill
mode  it  automatically  breaks  lines for you when you reach the
right margin so you don't have to remember to hit  Return.   JOVE
uses  78  as  the right margin but you can change that by setting
the variable [4mright-margin[24m to another value.

[1m19.11.  auto-indent-mode (Not Bound)[0m

This turns on or off Auto  Indent  minor  mode  in  the  selected
buffer.   Without  a  numeric  argument,  the command toggles the
mode; with a zero argument, the mode is turned off; with  a  non-
zero  argument,  the  mode  is  turned  on.  When JOVE is in Auto
Indent mode, the [4mnewline[24m command  (which  is  normally  bound  to
Return)  acts  identically to [4mnewline-and-indent[24m: the new line is
indented 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?)).  Furthermore, if  a  line  is  broken
because  of  Auto  Fill mode, and Auto Indent mode is on, the new
line will be indented as the old line was.

[1m19.12.  backward-character (^B)[0m

This moves point backward over a single character or line-separa-
tor.   Thus  if point is at the beginning of the line it moves to
the end of the previous line.

[1m19.13.  backward-list (ESC ^P)[0m

This moves point backward over a list, which is any text  between
properly matching (...), [...] or {...}.  It first searches back-
ward for a ")" and then moves to the matching "(".  This is  use-
ful  when  you are trying to find unmatched parentheses in a pro-
gram.  Arguments are accepted, and negative arguments search for-
wards.  See also [4mbackward-s-expression[24m.

[1m19.14.  backward-paragraph (Usually Not Bound)[0m

This moves point backward to the beginning of the current or pre-
vious paragraph.  Paragraphs are  bounded  by  lines  that  match
[4mparagraph-delimiter-pattern[24m  (by default, those that are empty or
look like troff or TeX commands).  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.   Arguments  are  accepted,  and negative arguments
search forwards.













60                  JOVE Manual for UNIX Users


[1m19.15.  backward-s-expression (ESC ^B)[0m

This moves point backward over an s-expression, that  is  over  a
Lisp  atom or a C identifier (depending on the major mode) ignor-
ing punctuation and whitespace; or, if the nearest preceding sig-
nificant  character  is one of ")]}", over a list as in [4mbackward-[0m
[4mlist[24m.  Arguments are accepted, and negative arguments search for-
wards.

[1m19.16.  backward-sentence (ESC A)[0m

This moves point backward to the beginning of the current or pre-
vious sentence.  JOVE considers the end of a sentence to  be  the
characters ".", "!" or "?" followed by a Return or by one or more
spaces.  Arguments are accepted, and  negative  arguments  search
forwards.

[1m19.17.  backward-up-list (ESC ^U)[0m

This  is  similar  to [4mbackward-list[24m except it backs up and OUT of
the enclosing  list.   In  other  words,  it  moves  backward  to
whichever  of  "([{" would match one of ")]}" if you were to type
it right then.  Arguments are accepted,  and  negative  arguments
search forwards as in [4mdown-list[24m.

[1m19.18.  backward-word (ESC B)[0m

This moves point backward to the beginning of the current or pre-
vious word.   Arguments  are  accepted,  and  negative  arguments
search forwards.

[1m19.19.  bad-filename-extensions (variable)[0m

This contains a list of words separated by spaces which are to be
considered bad filename extensions, and so will not  be  included
in filename completion.  The default contains, amongst much else,
[1m.o [22mso if you have [1mjove.c [22mand [1mjove.o [22min the  same  directory,  the
filename  completion will not complain of an ambiguity because it
will ignore [1mjove.o[22m.

[1m19.20.  begin-kbd-macro (^X ()[0m

This starts defining the keyboard macro by remembering  all  your
key  strokes  until  you execute [4mend-kbd-macro[24m, by typing "^X )".
Because of a bug in JOVE you shouldn't  terminate  the  macro  by
typing  "ESC X  end-kbd-macro";  [4mend-kbd-macro[24m  must  be bound to
"^X )" in order to make things work correctly.  The  [4mexecute-kbd-[0m
[4mmacro[24m command will execute the remembered key strokes.  Sometimes
you may want a macro to accept different input each time it runs.
To see how to do this, see the [4mmake-macro-interactive[24m command.













                    JOVE Manual for UNIX Users                 61


[1m19.21.  beginning-of-file (ESC <)[0m

This  moves  point backward to the beginning of the buffer.  This
sometimes prints the "[Point pushed]" message  to  indicate  that
JOVE has set the mark so you can go back to where you were if you
want.  See also the variable [4mmark-threshold[24m.

[1m19.22.  beginning-of-line (^A)[0m

This moves point to the beginning of the current line.

[1m19.23.  beginning-of-window (ESC ,)[0m

This moves point to the beginning of the active window.  If there
is  a numeric argument, point moves that many lines below the top
line.  With the default bindings, the  sequence  "ESC ,"  is  the
same  as "ESC <" ([4mbeginning-of-file[24m) but without the shift key on
the "<", and can thus easily be remembered.

[1m19.24.  bind-keymap-to-key (Not Bound)[0m

This is like [4mbind-to-key[24m except that you use it to attach  a  key
sequence  to  a named keymap.  The only reasonable use is to bind
some extra key to [4mESC-map[24m for  keyboards  that  make  typing  ESC
painful.

[1m19.25.  bind-macro-to-key (Not Bound)[0m

This  is  like  [4mbind-to-key[24m  except  you  use  it to attach a key
sequence to a named macro.

[1m19.26.  bind-macro-to-word-abbrev (Not Bound)[0m

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 (which could  be  empty,  of
course),  and  then the macro will be executed.  Note that if the
macro moves point around, you  should  first  [4mset-mark[24m  and  then
[4mexchange-point-and-mark[24m.

[1m19.27.  bind-to-key (Not Bound)[0m

This  attaches a key sequence to an internal JOVE command so that
future hits on that key sequence invoke that  command.   This  is
called  a  global binding, as compared to local bindings and pro-
cess bindings.  Any previous global binding of this key  sequence
is discarded.  For example, to make "^W" erase the previous word,
you type

     : bind-to-key kill-previous-word ^W .

It isn't possible to have two globally bound key sequences  where
one  is a prefix of the other: JOVE wouldn't know whether to obey
the shorter sequence or wait for the longer sequence.   Normally,









62                  JOVE Manual for UNIX Users


when  the  [4mbind-to-key[24m  command  is issued interactively, the key
sequence is taken to end one keystroke after the longest sequence
matching any proper prefix of another binding (thus no new prefix
can be created).  If the command is given a numeric argument, the
key  sequence is taken up to the next Return keystroke (kludge!);
bindings to any prefix of the sequence are discarded.   When  the
command  is issued from a [4msource[24md file, the key sequence is taken
up to the end of the line (it is also processed so  that  control
characters can and should be entered using the ^A notation).

Note  that neither process nor local bindings are changed by this
command, although they can be eclipsed.  Given a  choice  between
bindings, the shortest is executed; if there is still a choice, a
process binding is preferred to a  local  binding,  and  a  local
binding is preferred to a global binding.

[1m19.28.  buffer-position (Not Bound)[0m

This  displays  the current file name, current line number, total
number of lines, current character number, total number of  char-
acters,  percentage of the way through the file, and the position
of the cursor in the current line.

[1m19.29.  c-argument-indentation (variable)[0m

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 [4mc-argument-indentation[24m characters 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));


[1m19.30.  c-indentation-increment (variable)[0m

This defines a set of tabstops independent of the value  of  [4mtab-[0m
[4mwidth[24m.   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.  Some people prefer to set this to 4  and  leave  tab-width
set  to  8.   This  will  create files whose indentation steps in
4-space increments, and which look the same  anywhere  that  tabs
are  expanded to 8 spaces (i.e. in most settings).  Others prefer
to have one tab character per indentation level, then fiddle  the
tab expansion width to get the appearance they like.  They should
set both [4mc-indentation-increment[24m and [4mtab-width[24m  to  4.   Whenever
using  a  non-standard  tab width ([4mtab-width[24m) you should only use
tabs for indentation, and use spaces for all  columnar  alignment
later in the lines.









                    JOVE Manual for UNIX Users                 63


[1m19.31.  c-mode (Not Bound)[0m

This  turns on the C major mode in the currently selected buffer.
When in C or Lisp mode, Tab, "}", and ")" behave a little differ-
ently  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).

[1m19.32.  case-character-capitalize (Not Bound)[0m

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.

[1m19.33.  case-ignore-search (variable)[0m

This  variable, when [4mon[24m, tells JOVE to treat upper and lower case
the same when searching.  Thus "jove"  would  match  "JOVE",  and
"JoVe" would match either.  The default value of this variable is
[4moff[24m.

[1m19.34.  case-region-lower (Not Bound)[0m

This changes all the upper case letters in the  region  to  their
lower case equivalents.

[1m19.35.  case-region-upper (Not Bound)[0m

This  changes  all  the lower case letters in the region to their
upper case equivalents.

[1m19.36.  case-word-capitalize (ESC C)[0m

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.

[1m19.37.  case-word-lower (ESC L)[0m

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.












64                  JOVE Manual for UNIX Users


[1m19.38.  case-word-upper (ESC U)[0m

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.

[1m19.39.  cd (Not Bound)[0m

This changes the current directory.

[1m19.40.  character-to-octal-insert (Not Bound)[0m

This inserts a Back-slash followed by the ascii value of the next
character typed.  For example, "^G" inserts the string "\007".

[1m19.41.  clear-and-redraw (ESC ^L)[0m

This clears the entire screen and redraws all the  windows.   Use
this  when JOVE gets confused about what's on the screen, or when
the screen gets filled with garbage  characters  or  output  from
another program.

[1m19.42.  comment-format (variable)[0m

This variable tells JOVE how to format your comments when you run
the command [4mfill-comment[24m.  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 [4mfill-comment[24m for more
details.

[1m19.43.  compile-it (^X ^E)[0m

This compiles your program by running the UNIX command [4mmake[24m  into
a  buffer,  and automatically parsing the error messages that are
created (if any).  See the [4mparse-errors[24m command.   If  [4mcompile-it[0m
is  given a numeric argument, it will prompt for a command to run
in place of the plain make and the command you enter will  become
the  new  default.   See  also [4merror-format-string[24m which makes it
possible to parse errors of a different format and see  also  the
variable [4merror-window-size[24m.

[1m19.44.  continue-process (Not Bound)[0m

This  sends  the signal SIGCONT to the interactive process in the
current buffer, IF the process is currently stopped.









                    JOVE Manual for UNIX Users                 65


[1m19.45.  copy-region (ESC W)[0m

This takes all the text in the region and copies it onto the kill
ring  buffer.   This is just like running [4mkill-region[24m followed by
the [4myank[24m command.  See the [4mkill-region[24m and [4myank[24m commands.

[1m19.46.  current-error (Not Bound)[0m

This moves to the current error in the  list  of  parsed  errors.
See  the [4mnext-error[24m and [4mprevious-error[24m commands for more detailed
information.

[1m19.47.  date (Not Bound)[0m

This prints the date on the message line.

[1m19.48.  dbx-format-string (variable)[0m

This is the default regular-expression search string used by JOVE
to parse output from [4mdbx[24m running in a shell process (see the [4mdbx-[0m
[4mmode[24m command).  You shouldn't have to change this unless you  are
using something other than [4mDBX[24m.

[1m19.49.  dbx-mode (Not Bound)[0m

This  turns  on or off the DBX minor mode in the selected buffer.
Without a numeric argument, the command toggles the mode; with  a
zero  argument, the mode is turned off; with a non-zero argument,
the mode is turned on.  This mode only makes sense  in  a  buffer
running  an interactive shell process.  If you are running [4mdbx[24m in
a window and and the buffer is in DBX minor mode, JOVE will auto-
matically  track the source location in another window.  Whenever
you type "where" or while you're stepping through a  program,  or
when you reach a breakpoint, JOVE will present the source file in
another window and move to the line  that  is  being  referenced.
See also the variable [4mdbx-format-string[24m.

[1m19.50.  define-global-word-abbrev (Not Bound)[0m

This  defines  a  global  abbreviation.  See the [4mword-abbrev-mode[0m
command.

[1m19.51.  define-macro (Not Bound)[0m

This provides a different mechanism for defining keyboard macros.
Instead  of  gathering keystrokes and storing them into the "key-
board-macro" (which is how [4mbegin-kbd-macro[24m  works),  [4mdefine-macro[0m
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
[4mquoted-insert[24m 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 control









66                  JOVE Manual for UNIX Users


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 [4mwrite-macros-to-file[24m to see how to save
macros.

[1m19.52.  define-mode-word-abbrev (Not Bound)[0m

This defines a mode-specific abbreviation.  See the  [4mword-abbrev-[0m
[4mmode[24m command.

[1m19.53.  delete-blank-lines (^X ^O)[0m

This  deletes  all  the blank lines around point.  This is useful
when you previously opened many lines with the [4mnewline-and-backup[0m
command and now wish to delete the unused ones.

[1m19.54.  delete-buffer (^X K)[0m

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.  See also the [4merase-[0m
[4mbuffer[24m command and the [4mkill-some-buffers[24m command.

[1m19.55.  delete-current-window (^X D))[0m

This deletes the active window and moves point into  one  of  the
remaining ones.  It is an error to try to delete the only remain-
ing window.

[1m19.56.  delete-next-character (^D)[0m

This deletes the character that's just after point (that is,  the
character  under  the cursor).  If point is at the end of a line,
the line-separator is deleted and the next line  is  joined  with
the  current  one.  If an argument is given, that many characters
are deleted and placed on the kill ring.  If the argument is neg-
ative the deletion is forwards.

[1m19.57.  delete-other-windows (^X 1)[0m

This  deletes all the other windows except the current one.  This
can be thought of as going back into One Window mode.

[1m19.58.  delete-previous-character (DEL and ^H)[0m

This deletes the character that's just before point (that is, the
character  before  the  cursor).  If point is at the beginning of
the line, the line separator is deleted and that line  is  joined
with  the previous one.  If an argument is given, that many char-
acters are deleted and placed on the kill ring.  If the  argument
is negative the deletion is backwards.









                    JOVE Manual for UNIX Users                 67


[1m19.59.  delete-white-space (ESC \)[0m

This deletes all the Tabs and Spaces around point.

[1m19.60.  describe-bindings (Not Bound)[0m

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 [4msend-typeout-to-buffer[24m to [4mon[24m and JOVE
will store the key bindings in a buffer which you can save  to  a
file and then print.

[1m19.61.  describe-command (ESC ?)[0m

This  waits for you to type a command and then prints an explana-
tion of that command, together with its current bindings.

[1m19.62.  describe-key (^X ?)[0m

This waits for you to type a key and then tells the name  of  the
command  that  gets invoked every time that key is hit.  Once you
have the name of the command you  can  use  the  [4mdescribe-command[0m
command to find out exactly what it does.

[1m19.63.  describe-variable (Not Bound)[0m

This prints an explanation of a specified variable.

[1m19.64.  digit (ESC 0 through ESC 9)[0m

Starts  or  continues  the  entry  of a numeric argument with the
digit typed.  It continues reading digits  until  you  type  some
other  command.   Then  that command is executed with the numeric
argument you specified.

[1m19.65.  digit-0 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  0.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 0 key
on the numeric keypad.

[1m19.66.  digit-1 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  1.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 1 key
on the numeric keypad.













68                  JOVE Manual for UNIX Users


[1m19.67.  digit-2 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  2.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 2 key
on the numeric keypad.

[1m19.68.  digit-3 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  3.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 3 key
on the numeric keypad.

[1m19.69.  digit-4 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  4.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 4 key
on the numeric keypad.

[1m19.70.  digit-5 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  5.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 5 key
on the numeric keypad.

[1m19.71.  digit-6 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  6.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 6 key
on the numeric keypad.

[1m19.72.  digit-7 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  7.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 7 key
on the numeric keypad.

[1m19.73.  digit-8 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  8.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 8 key









                    JOVE Manual for UNIX Users                 69


on the numeric keypad.

[1m19.74.  digit-9 (Not Bound)[0m

Starts or continues the entry of  a  numeric  argument  with  the
digit  9.   It continues reading digits until you type some other
command.  Then that command is executed with the numeric argument
you  specified.   Sometimes it is handy to bind this to the 9 key
on the numeric keypad.

[1m19.75.  digit-minus (ESC -)[0m

Starts the entry of a numeric argument with  a  minus  sign.   It
continues reading digits until you type some other command.  Then
that command is executed with the numeric argument you specified.
Sometimes it is handy to bind this to the - key on a numeric key-
pad.  In the absence  of  further  digits  and  unless  otherwise
stated (e.g.  [4mnext-page[24m), the argument -1 is assumed.

[1m19.76.  dirs (Not Bound)[0m

This prints out the directory stack.  See the [4mcd[24m, [4mpushd[24m, [4mpushlibd[0m
and [4mpopd[24m commands for more information.

[1m19.77.  disable-biff (variable)[0m

When this is set, JOVE disables  biff  when  you're  editing  and
enables  it  again when you get out of JOVE, or when you pause to
the parent shell or push to a new shell.  (This means arrival  of
new  mail  will  not  be  immediately apparent but will not cause
indiscriminate writing on the  display).   The  default  is  [4moff[24m,
although  it is always safe to set it [4mon[24m, even on systems that do
not provide the biff facility.  Note that the variable  [4mmode-line[0m
can  be  set up to announce the arrival of new mail during a JOVE
session.

[1m19.78.  display-default-filenames (variable)[0m

If this is set when JOVE asks for a filename, it will display the
default (unless that would take too much of the prompt line).

[1m19.79.  display-filenames-with-bad-extensions (variable)[0m

This variable affects only filename  completion,  in  particular,
what  happens when "?" is typed while prompting for a file.  When
this variable is [4mon[24m, any files that end with one  of  the  exten-
sions  defined  by  the  variable [4mbad-filename-extensions[24m will be
displayed with an "!" in front of  their  names.   When  [4mdisplay-[0m
[4mfilenames-with-bad-extensions[24m  is  [4moff[24m the files will not be dis-
played at all.  The default value is [4mon[24m.













70                  JOVE Manual for UNIX Users


[1m19.80.  down-list (ESC ^D)[0m

This is the opposite of [4mbackward-up-list[24m.   It  enters  the  next
list.   In other words, it moves forward to whichever of "([{" it
first encounters.  Arguments are accepted, and negative arguments
search backwards as in [4mbackward-up-list[24m.

[1m19.81.  dstop-process (Proc: ^C ^Y)[0m

Send  the  signal  SIGTSTP  to  the  interactive  process  in the
selected buffer when next it tries to read input.  This is equiv-
alent  to  sending  the "dsusp" character (which most people have
set to ^Y) to the process.  This only  works  if  you  are  in  a
buffer bound to an interactive process.

[1m19.82.  edit-word-abbrevs (Not Bound)[0m

This creates (if necessary) a buffer with a list of each abbrevi-
ation and the phrase it expands into, and enters a recursive edit
to let you change the abbreviations or add some more.  The format
of this list is "abbreviation:phrase" so if you add some more you
should  follow  that format.  It's probably simplest just to copy
some already existing abbreviations and edit them.  Use the [4mexit-[0m
[4mjove[24m command to exit the recursive edit.

[1m19.83.  end-kbd-macro (^X ))[0m

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.  See [4mbegin-kbd-macro[24m for more details.

[1m19.84.  end-of-file (ESC >)[0m

This moves point forward to the end of the  buffer.   This  some-
times  prints  the "[Point pushed]" message to indicate that JOVE
has set the mark so you can go back to  where  you  were  if  you
want.  See also the variable [4mmark-threshold[24m.

[1m19.85.  end-of-line (^E)[0m

This  moves point to the end of the current line.  If the line is
too long to fit on the screen, it will be scrolled  horizontally.
This is described with the variables [4mscroll-width[24m and [4mscroll-all-[0m
[4mlines[24m.

[1m19.86.  end-of-window (ESC .)[0m

This moves point to the last character in the active window.   If
there  is  a  numeric  argument,  the point moves that many lines
above the bottom line.  With the default bindings,  the  sequence
"ESC ."  is  the  same  as  "ESC >" ([4mend-of-file[24m) but without the
shift key on the ">", and can thus easily be remembered.










                    JOVE Manual for UNIX Users                 71


[1m19.87.  enhanced-keyboard (variable)[0m

(IBM PC version only) This is a boolean variable which can be set
to  enable the enhanced AT-style keyboard.  The enhanced keyboard
contains function keys and key combinations  that  are  not  sup-
ported  on  the  original  IBM PCs and XTs.  The default value is
determined by a bit in the BIOS data area, but this method appar-
ently  does  not  work with a few BIOS implementations.  WARNING:
setting enhanced-keyboard [4mon[24m on systems without an enhanced  key-
board will lock up your system and require you to reboot.

[1m19.88.  eof-process (^C ^D)[0m

Sends EOF to the current interactive process.  This only works on
versions of JOVE running under versions of UNIX with pty's.

[1m19.89.  erase-buffer (Not Bound)[0m

This erases the contents of the specified buffer.  This  is  like
[4mdelete-buffer[24m  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.

[1m19.90.  error-format-string (variable)[0m

This  is  the error format string that is used by [4mparse-errors[24m 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 \(...\) regular expression feature is 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 [4merror-for-[0m
[4mmat-string[24m would be something like this:

     ^"\([^"]*\)", line \([0-9]*\):

What this means is, to find an error message, search for  a  line
beginning with a double-quote.  Then it says that all the follow-
ing characters up to another double-quote should be remembered as
one  unit,  namely the filename that the error is in (that is why
the first set of parentheses is surrounding it).   Then  it  says
that  after  the filename there will be the string ", line " fol-
lowed by a line number, which should be remembered  as  a  single
unit (which is why the second set of parentheses is around that).
The only constraint on the error messages is that the  file  name
and  line number appear on the same line.  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 vari-
able will be hard for you to use.  Also note that you can look at









72                  JOVE Manual for UNIX Users


the default value of this variable by printing it out, but it  is
a  really  complicated string because it is trying to accommodate
the outputs of more than one compiler.

[1m19.91.  error-window-size (variable)[0m

This is the percentage of the screen to use for the  error-window
on  the  screen.   When  you  execute [4mcompile-it[24m or [4mspell-buffer[24m,
[4merror-window-size[24m percent of the screen will go to the error win-
dow.  If the window already exists and is a different size, it is
made to be this size.  The default value is 20%.

[1m19.92.  exchange-point-and-mark (^X ^X)[0m

This moves point to mark and makes mark the old point.   This  is
for quickly moving from one end of the region to the other.

[1m19.93.  execute-kbd-macro (^X E)[0m

This  executes the keyboard macro.  If you supply a numeric argu-
ment the macro is executed that many times.  See  the  [4mbegin-kbd-[0m
[4mmacro[24m command for more details.

[1m19.94.  execute-macro (Not Bound)[0m

This  executes  a specified macro.  If you supply a numeric argu-
ment the macro is executed that many times.

[1m19.95.  execute-named-command (ESC X)[0m

This is the way to execute a command that isn't bound to any key.
When you are prompted with ": " you can type the name of the com-
mand.  You don't have to type the entire name.   After  typing  a
few  characters, Tab will fill in as many more as it can (as will
Space, but that will also obey the command if it is now unambigu-
ous).   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.  Once the command
is unambiguous, typing Return will cause it to be obeyed.

If you don't have any idea what the command's  name  is  but  you
know  it  has something to do with windows (for example), you can
do "ESC X apropos window" and JOVE will print a list of  all  the
commands  that are related to windows.  If you find yourself con-
stantly executing the same commands this way you probably want to
bind them to keys so that you can execute them more quickly.  See
the [4mbind-to-key[24m command.

[1m19.96.  exit-jove (^X ^C)[0m

This exits JOVE.  If any buffers need saving JOVE  will  print  a
warning  message  and ask for confirmation.  If you leave without
saving your buffers all your work will be lost.  If  you  made  a
mistake  and  really  do want to exit then you can.  If there are









                    JOVE Manual for UNIX Users                 73


any interactive processes running, JOVE  will  also  ask  whether
they should be terminated.

If you are in a recursive editing level [4mexit-jove[24m will return you
from that.  The selected buffer will be set back  to  the  buffer
that  was current when the recursive edit was entered.  Normally,
point will be returned to its position at the time of entry,  but
if  the  [4mexit-jove[24m  command is given a numeric argument, point is
left at its most recent position within that buffer.

[1m19.97.  expand-environment-variables (variable)[0m

When this variable is [4mon[24m JOVE will try to expand any  strings  of
the  form "$var" into the value of the environment variable "var"
when  asking  for  a  filename.   For  example,   if   you   type
[1m$HOME/.joverc[22m, "$HOME" will be replaced with your home directory.
The default value is [4mon[24m.

[1m19.98.  file-creation-mode (variable)[0m

This variable has an octal value.   It  contains  the  mode  (see
[4mchmod[24m(1))  with  which  files  should be created.  This mode gets
modified by your  current  umask  setting  (see  [4mumask[24m(1)).   The
default value is usually 0666 or 0644.

[1m19.99.  files-should-end-with-newline (variable)[0m

This  variable indicates that all files should always have a new-
line at the end.  This is often necessary for line  printers  and
the like.  When set, if JOVE is writing a file whose last charac-
ter is not a newline, it will add one automatically.  The default
value is [4mon[24m.

[1m19.100.  fill-comment (Not Bound)[0m

This  command  fills  in  your C comments to make them pretty and
readable.  This filling is done according the  variable  [4mcomment-[0m
[4mformat[24m.

     /*
      * the default format makes comments like this.
      */

This  can  be  changed  by  changing the [4mformat-comment[24m variable.
Other languages may be supported by changing the format  variable
appropriately.   The  formatter looks backwards from point for an
open comment symbol.  If found, all indentation is done  relative
to  the  position  of the first character of the open symbol.  If
there is a matching close symbol, the entire comment  is  format-
ted.   If  not,  the  region between the open symbol and point is
reformatted.  The original text is saved  in  the  kill  ring;  a
[4myank-pop[24m command will undo the formatting.











74                  JOVE Manual for UNIX Users


[1m19.101.  fill-paragraph (ESC J)[0m

This  rearranges words between lines so that all the lines in the
current paragraph extend as close to the right margin  as  possi-
ble,  ensuring  that  none  of the lines will be greater than the
right margin.  The default value for [4mright-margin[24m is 78, but  can
be changed with the [4mset[24m and [4mright-margin-here[24m commands.

The  rearrangement  may  cause  an  end of line to be replaced by
whitespace.  Normally, this whitespace is a single space  charac-
ter.   If the variable [4mspace-sentence-2[24m is [4mon[24m, and the end of the
line was apparently the end of a sentence or the line ended  with
a  colon,  two spaces will be used.  However, a sentence or colon
followed by a single space already within  a  line  will  not  be
altered.

JOVE  has  a  complicated algorithm for determining the beginning
and end of the paragraph.  In the normal case JOVE will give  all
the lines the same indent as they currently have, but if you wish
to force a new indent you can supply a numeric argument to  [4mfill-[0m
[4mparagraph[24m  and JOVE will indent each line to the column specified
by the [4mleft-margin[24m variable.  See also the  [4mleft-margin[24m  variable
and [4mleft-margin-here[24m command.

[1m19.102.  fill-region (Not Bound)[0m

This  is  like  [4mfill-paragraph[24m,  except  it  operates on a region
instead of just a paragraph.

[1m19.103.  filter-region (Not Bound)[0m

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
[4mfilter-region[24m it through [4mcb[24m, 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  UNIX  [4msort[24m command.  Before output from the command replaces
the region JOVE stores the old text in the kill ring.  If you are
unhappy with the results a [4myank-pop[24m command will get back the old
text.

[1m19.104.  find-file (^X ^F)[0m

This reads a specified file into its own buffer and then  selects
that  buffer.   If  you've  already read this file into a buffer,
that buffer is simply selected.  If the file doesn't  yet  exist,
JOVE  will print "(New file)" so that you know.  If possible, the
buffer is named after the filename (ignoring any directory part).













                    JOVE Manual for UNIX Users                 75


[1m19.105.  find-tag (^X T)[0m

This  finds the file that contains the specified tag.  JOVE looks
up tags by default in the [1mtags [22mfile in the current directory,  as
created by the UNIX command [4mctags(1)[24m.  You can change the default
tag name by setting the [4mtag-file[24m 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.

[1m19.106.  find-tag-at-point (Not Bound)[0m

This finds the file that contains the tag that point is currently
in.  See [4mfind-tag[24m.

[1m19.107.  first-non-blank (ESC M)[0m

This moves point (backwards or forwards) to  the  indent  of  the
current line.

[1m19.108.  forward-character (^F)[0m

This  moves point forward over a single character or line-separa-
tor.  Thus if point is at the end of the line  it  moves  to  the
beginning of the next one.

[1m19.109.  forward-list (ESC ^N)[0m

This  moves  point forward over a list, which is any text between
properly matching (...), [...] or {...}.  It first searches  for-
ward  for a "(" and then moves to the matching ")".  This is use-
ful when you are trying to find unmatched parentheses in  a  pro-
gram.   Arguments  are  accepted,  and  negative arguments search
backwards.  See also [4mforward-s-expression[24m.

[1m19.110.  forward-paragraph (ESC ])[0m

This moves point forward to the end of the current or next  para-
graph.   Paragraphs  are  bounded  by lines that match [4mparagraph-[0m
[4mdelimiter-pattern[24m (by default, those that are empty or look  like
troff  or TeX commands).  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.  Arguments are accepted,  and  negative  arguments  search
backwards.

[1m19.111.  forward-s-expression (ESC ^F)[0m

This  moves  point  forward  over an s-expression, that is over a
Lisp atom or a C identifier (depending on the major mode)  ignor-
ing  punctuation  and  whitespace;  or, if the nearest succeeding
significant character is one of "([{", over a list as in [4mforward-[0m
[4mlist[24m.   Arguments  are  accepted,  and  negative arguments search
backwards.









76                  JOVE Manual for UNIX Users


[1m19.112.  forward-sentence (ESC E)[0m

This moves point forward to the end of the current or  next  sen-
tence.  JOVE considers the end of a sentence to be the characters
".", "!" or "?", followed possibly by "'", "''", or """, followed
by  a Return or whitespace.  Arguments are accepted, and negative
arguments search backwards.

[1m19.113.  forward-word (ESC F)[0m

This moves point forward to the end of the current or next  word.

[1m19.114.  fundamental-mode (Not Bound)[0m

This sets the major mode to Fundamental.  Fundamental mode is the
mode of the Minibuf, and hence of anything typed in  the  message
line.

[1m19.115.  gather-numeric-argument (^U)[0m

This  command is one of two ways to specify a numeric argument to
a command.  Typing this command once means, Do the next command 4
times.  Typing it 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 com-
mand 35 times (assuming [4mgather-numeric-argument[24m is bound to  ^U).

[1m19.116.  goto-line (ESC G)[0m

If  a  positive  numeric argument is supplied, point moves to the
beginning of that line.  If the argument is  negative,  it  indi-
cates how many lines from the end of the buffer to move point to.
If no argument is supplied one is prompted for.

[1m19.117.  goto-window-with-buffer (Not Bound)[0m

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 window is selected instead.

[1m19.118.  grind-s-expr (Not Bound)[0m

When point is positioned on a  "(",  this  re-indents  that  LISP
expression.

[1m19.119.  grow-window (^X ^)[0m

This  makes  the  active window one line bigger.  This only works
when there is more than one window and provided there is room  to
change the size.  See also [4mshrink-window[24m.













                    JOVE Manual for UNIX Users                 77


[1m19.120.  handle-tab (Tab)[0m

This  handles  indenting to the "right" place in C and Lisp mode,
and just inserts itself in Text mode.

[1m19.121.  highlight-attribute (variable)[0m

(IBM PC version only) This specifies how the attribute (color) of
a  character is to be changed when it is highlighted.  Highlight-
ing is indicated by exclusive oring this value  with  the  normal
attribute for the character.  The default is 16.

[1m19.122.  highlight-mark (variable)[0m

When  this is on, jove will highlight the mark if currently visi-
ble.  The mark is highlighted with an underscore.

[1m19.123.  i-search-forward (Not Bound)[0m

Incremental search.  Like search-forward except that  instead  of
prompting for a string and searching for that string all at once,
it accepts the string one character at a time.  After each  char-
acter  you type as part of the search string, it searches for the
entire string so far.  When you like what it found,  type  Return
to finish the search.  You can take back a character with DEL and
the search will back up to the position before that character was
typed.  ^G aborts the search.

[1m19.124.  i-search-reverse (Not Bound)[0m

Incremental  search.   Like search-reverse except that instead of
prompting for a string and searching for that string all at once,
it  accepts the string one character at a time.  After each char-
acter you type as part of the search string, it searches for  the
entire  string  so far.  When you like what it found, type Return
to finish the search.  You can take back a character with DEL and
the search will back up to the position before that character was
typed.  ^G aborts the search.

[1m19.125.  i-shell-command (Not Bound)[0m

This is like [4mshell-command[24m except that it launches an interactive
process and so lets you continue with your editing while the com-
mand is running.  This is really useful for long running commands
with  sporadic output.  See also the variable [4mwrap-process-lines[24m.

[1m19.126.  insert-file (^X ^I)[0m

This inserts a specified file into the selected buffer at  point.
Point is positioned at the beginning of the inserted file.













78                  JOVE Manual for UNIX Users


[1m19.127.  interrupt-character (variable)[0m

This  specifies  what  character  should be used as the operating
system's tty driver interrupt character.  When this character  is
typed,  the tty driver generates SIGINT signal.  This will inter-
rupt a non-interactive process.  If no such process  is  running,
JOVE'S  will  offer  you  the  option  of continuing, or crashing
JOVE'S (trying to save your work).  This is a crude and desperate
way  to  stop  JOVE'S.  Unfortunately there is no way to turn off
the interrupt character.  The default is  ^].   See  also  [4mabort-[0m
[4mchar[24m.

[1m19.128.  interrupt-process (Proc: ^C ^C)[0m

This  sends  the  signal SIGINT to the interactive process in the
selected buffer.  This only works if  you  are  inside  a  buffer
bound to an interactive process.

[1m19.129.  kill-next-word (ESC D)[0m

This  kills the text from point to the end of the current or next
word.  The killed text is sent to the kill ring.

[1m19.130.  kill-previous-word (ESC DEL)[0m

This kills the text from point to the beginning of the current or
previous word.  The killed text is sent to the kill ring.

[1m19.131.  kill-process (Not Bound)[0m

This  command prompts for a buffer name or buffer number (just as
[4mselect-buffer[24m does) and then sends the process in that buffer the
signal SIGKILL.

[1m19.132.  kill-region (^W)[0m

This  deletes  the  text  in  the region and saves it on the kill
ring.  Commands that delete text but save it on the kill ring all
have the word "kill" in their names.  Use the [4myank[24m command to get
back the most recent kill.

[1m19.133.  kill-s-expression (ESC ^K)[0m

This kills the text from point to the end of the current or  next
s-expression.  The killed text is sent to the kill ring.

[1m19.134.  kill-some-buffers (Not Bound)[0m

This  goes  through  all the existing buffers and asks whether or
not to delete each one.  If you decide to delete 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.  See also the [4mdelete-buffer[0m









                    JOVE Manual for UNIX Users                 79


command.

[1m19.135.  kill-to-beginning-of-sentence (^X DEL)[0m

This kills from point to the beginning of the current or previous
sentence.  If a negative numeric argument is  supplied  it  kills
from  point  to  the  end  of  the current or next sentence.  The
killed text is sent to the kill ring.

[1m19.136.  kill-to-end-of-line (^K)[0m

This kills from point to the end of the current line.  When point
is at the end of the line (discounting any white space) the line-
separator is also deleted and the next line is joined  with  cur-
rent  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.  The killed text is sent to  the
kill ring.

[1m19.137.  kill-to-end-of-sentence (ESC K)[0m

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  beginning  of  the current or previous sentence.  The killed
text is sent to the kill ring.

[1m19.138.  lc-ctype (variable)[0m

This string variable determines how non-ASCII characters are dis-
played,  and which characters are to be considered as upper-case,
lower-case, printable, etc.  The default is  the  implementation-
defined  native  environment;  under  POSIX,  it is determined by
whichever of the environment variables LC_ALL, LC_CTYPE  or  LANG
is first found to be set, and is otherwise "C".  Some useful val-
ues of [4mlc-ctype[24m might be:

     ""             Default: the native environment.
     "C"            Strict ASCII.  All other characters greater than \177
                    rendered in octal.
     "iso_8859_1"   Latin-1 alphabet.


[1m19.139.  left-margin (variable)[0m

This is how far lines should be indented when Auto Indent mode is
on,  or  when  the  [4mnewline-and-indent[24m command is run (usually by
typing Linefeed).  It is also used  by  [4mfill-paragraph[24m  and  Auto
Fill mode.  If the value is zero (the default) then the left mar-
gin is determined from the surrounding lines.













80                  JOVE Manual for UNIX Users


[1m19.140.  left-margin-here (Not Bound)[0m

This sets the [4mleft-margin[24m variable to  the  current  position  of
point.   This  is an easy way to say, "Make the left margin begin
here," without having to count the number of spaces over it actu-
ally is.

[1m19.141.  lisp-mode (Not Bound)[0m

This  turns on the Lisp major mode.  In Lisp mode, the characters
Tab and ")" are treated specially, similar to the  way  they  are
treated  in C mode.  Also, Auto Indent mode is affected, and han-
dled specially.  See also the [4mc-mode[24m command.

[1m19.142.  list-buffers (^X ^B)[0m

This types out a list containing various information  about  each
buffer.  The list looks like this:

      (* means the buffer needs saving)
      NO  Lines Type        Name           File
      --  ----- ----        ----           ----
      1   1     File        Main           [No file]
      2   1     Scratch   * Minibuf        [No file]
      3   519   File      * commands.doc   commands.doc

The  first  column  lists the buffer's number.  When JOVE prompts
for a buffer name you can either type in the full  name,  or  you
can  simply  type  the buffer's number.  The second column is the
number of lines in the buffer.   The  third  says  what  type  of
buffer.   There are four types: File, Scratch, Process and I-Pro-
cess.  "File" is simply a buffer that holds a file; "Scratch"  is
for  buffers  that  JOVE  uses  internally; "Process" is one that
holds the output from a UNIX command; "I-Process" is one that has
an  interactive process attached to it.  The next column contains
the name of the buffer.  And the last column is the name  of  the
file  that's  attached to the buffer.  In this case, both Minibuf
and commands.doc have been changed but not yet  saved.   In  fact
Minibuf won't be saved since it's a Scratch buffer.

[1m19.143.  list-processes (Not Bound)[0m

This  makes  a list somewhat like "list-buffers" does, except its
list consists of the current  interactive  processes.   The  list
looks like this:

      Buffer           Status           Pid       Command
      ------           ------           ---       -------
      *shell*          Running          18415     shell
      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 pro-
cess has exited normally the status is "Done" as in fgrep; if the









                    JOVE Manual for UNIX Users                 81


process exited with an error the status is "Exit N"  where  N  is
the  value  of  the  exit code; if the process was killed by some
signal the status is the name of the signal that was used; other-
wise  the process is running.  The last column is the name of the
command that is being run.

[1m19.144.  local-bind-keymap-to-key (Not Bound)[0m

This is like [4mlocal-bind-to-key[24m except that you use it to attach a
key  sequence  to  a named keymap.  The only reasonable use is to
bind some extra key to [4mESC-map[24m for keyboards that make typing ESC
painful.

[1m19.145.  local-bind-macro-to-key (Not Bound)[0m

This  is like [4mlocal-bind-to-key[24m except you use it to attach a key
sequence to a named macro.

[1m19.146.  local-bind-to-key (Not Bound)[0m

This is like [4mbind-to-key[24m, except that the binding is only enabled
when  the selected buffer is the buffer that was current when the
command was executed.  In other words, the binding  only  applies
to the selected buffer.

[1m19.147.  macify (variable)[0m

(Mac  version  only)  When this variable is on, JOVE will use the
standard Macintosh file-selector dialog in place  of  the  tradi-
tional JOVE Minibuffer.

[1m19.148.  mail-check-frequency (variable)[0m

This is how often (in seconds) JOVE should check your mailbox for
incoming mail.  If you set this to zero JOVE won't check for  new
mail.   See  also  the  [4mmode-line[24m, [4mmailbox[24m and [4mdisable-biff[24m vari-
ables.  The default is 60.

[1m19.149.  mailbox (variable)[0m

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 [1m/usr/spool/mail/$USER[22m, where "$USER" is set  to  your
login name.

[1m19.150.  make-backup-files (variable)[0m

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 [4moff[24m.












82                  JOVE Manual for UNIX Users


[1m19.151.  make-buffer-unmodified (ESC ~)[0m

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.

[1m19.152.  make-macro-interactive (ESC I)[0m

This command is meaningful only while you are defining a keyboard
macro, and when you are expecting  input  in  the  message  line.
Ordinarily,  when  a  command  in  a  macro definition requires a
trailing text argument (file  name,  search  string,  etc.),  the
argument you supply becomes part of the macro definition.  If you
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 [4mmake-macro-interactive[24m command just before typing  the  argu-
ment which will be used during the definition process.  Note: you
must bind this command to a key in order to use it; you can't say
"ESC X make-macro-interactive".

[1m19.153.  mark-threshold (variable)[0m

This  variable  contains  the  number  of lines point may move by
before the mark is set.  If, in a search or  some  other  command
that  may  move  point, 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).  See
also the commands [4msearch-forward[24m,  [4msearch-reverse[24m,  [4mbeginning-of-[0m
[4mfile[24m and [4mend-of-file[24m.

[1m19.154.  match-regular-expressions (variable)[0m

When set, JOVE will match regular expressions in search patterns.
This makes special the characters ., *, [ and ].   See  the  JOVE
Manual for a full discussion of regular-expressions.

[1m19.155.  meta-key (variable)[0m

You  should  set  this variable to [4mon[24m if your terminal has a real
Meta key which forces the 8th bit of  each  character.   If  your
terminal  has  such  a key, then a key sequence like ESC Y can be
entered by holding down Meta and typing Y.  On the IBM  PC,  this
variable  affects  how  ALT is interpreted.  On the Macintosh, it
affects how Option is interpreted.  NOTE: In some older UNIX sys-
tems,  JOVE  must  switch the tty to raw mode to accept the 8-bit
characters generated by a meta key.   Unfortunately,  the  [4minter-[0m
[4mrupt-character[24m does not generate an interrupt in raw mode.

[1m19.156.  mode-line (variable)[0m

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 [4mprintf(3)[24m, with the special things being









                    JOVE Manual for UNIX Users                 83


marked as "%x".  Digits may be used between the '%' and  the  'x'
to mean repeat that many times.  'x' may be:

          C    checks for new mail, and displays "[New mail]" if there is any
               (see also the [4mmail-check-frequency[24m and [4mmailbox[24m variables)
          F    the current file name, with leading path stripped
          M    the current list of major and minor modes
          b    the selected buffer name
          c    the fill character (-)
          d    the current directory
          e    extra space in mode line is distributed evenly
               among the places %e is used (used for justifying,
               separating, or centering parts of the mode line)
          f    the current file name
          ixy  x, when the buffer's file has been changed behind JOVE's back,
               y, when not
          mxy  x, when the buffer is modified or y, when not
          n    the selected 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.

[1m19.157.  mode-line-attribute (variable)[0m

(IBM PC version only) This specifies the screen attribute (color)
for  characters  in  the mode line.  The default is 112 (black on
white).

[1m19.158.  mode-line-should-standout (variable)[0m

If set, the mode line will be printed in reverse video,  if  your
terminal supports it.  The default for this variable is [4mon[24m.

[1m19.159.  name-kbd-macro (Not Bound)[0m

This copies the keyboard macro and gives it a name freeing up the
keyboard macro so you can define some more.  Keyboard macros with
their  own names can be bound to keys just like built in commands
can.  See the [4mdefine-macro[24m, [4msource[24m and [4mwrite-macros-to-file[24m  com-
mands.













84                  JOVE Manual for UNIX Users


[1m19.160.  newline (Return)[0m

This divides the current line at point moving all the text to the
right of point down onto the newly  created  line.   Point  moves
down  to the beginning of the new line.  In Auto Indent mode, the
new line will be indented to match the old line.

[1m19.161.  newline-and-backup (^O)[0m

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 [4mnewline[24m is that point does not move down to  the
beginning of the new line.

[1m19.162.  newline-and-indent (Linefeed)[0m

This  behaves  in  any  mode the same way as [4mnewline[24m does in Auto
Indent mode.

[1m19.163.  next-error (^X ^N)[0m

This moves to the next error in the  list  of  errors  that  were
parsed  with  [4mparse-errors[24m.   In one window the list of errors is
shown with the current one always at the top.  If the  file  that
contains  the  error  is  not already in a buffer, it is read in.
Its buffer is displayed in another window and point is positioned
in this window on the line where the error occurred.

[1m19.164.  next-line (^N)[0m

This  moves  point down to the corresponding position on the next
line (or the end of that line if it does not extend so far).

[1m19.165.  next-page (^V)[0m

This displays the next page of the selected 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 of only - (with no digits) is sup-
plied, the previous page is displayed.  Otherwise, if  a  numeric
argument  is  supplied the screen is scrolled up that many lines,
exactly as in the [4mscroll-up[24m command; if the argument is  negative
the screen is scrolled down.

[1m19.166.  next-window (^X N)[0m

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.













                    JOVE Manual for UNIX Users                 85


[1m19.167.  number-lines-in-window (Not Bound)[0m

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.

[1m19.168.  one-key-confirmation (variable)[0m

If this variable is set, a single keystroke of y or n is expected
in answer to yes/no questions.  Normally, a yes/no question  must
be answered with any non-empty prefix of yes or no, followed by a
Return

[1m19.169.  over-write-mode (Not Bound)[0m

This turns Over Write minor  mode  on  in  the  selected  buffer.
Without  a numeric argument, the command toggles the mode; with a
zero argument, the mode is turned off; with a non-zero  argument,
the  mode  is  turned on.  When on, this mode changes the way the
self-inserting characters work.  Instead of inserting  themselves
and  pushing the rest of the line over to the right, they replace
or over-write the existing character.   Also,  DEL  replaces  the
character before point with a space instead of deleting it.  When
Over Write mode is on "OvrWt" is displayed in the mode line.

[1m19.170.  page-next-window (ESC ^V)[0m

This displays the next page in the next window.  It  switches  to
the  next  window, performs a [4mnext-page[24m command (with any numeric
argument), and switches back to the original window.   Note  that
an argument of just "-" will thus display the previous page.

[1m19.171.  paren-flash () } ])[0m

This  command  causes  the characters bound to it to be inserted,
and then to partake in C mode curly brace indentation, Lisp  mode
parenthesis  indentation,  and  the  Show Match mode paren/curly-
brace/square-bracket flashing.

[1m19.172.  paragraph-delimiter-pattern (variable)[0m

When JOVE is searching for a paragraph boundary, if this  pattern
(a  regular expression) matches the start of a line, that line is
treated as a paragraph delimiter.  The default pattern recognizes
blank  lines,  troff control lines, and lines starting with a TeX
control sequence.

There is a special provision for TeX: if a line is matched by the
pattern,  and  the match is of exactly an initial \, that line is
only treated as a delimiter if the next line also starts with  \.












86                  JOVE Manual for UNIX Users


[1m19.173.  paren-flash-delay (variable)[0m

How  long, in tenths of a second, JOVE should pause on a matching
parenthesis in Show Match mode.  The default is 5.

[1m19.174.  parse-errors (Not Bound)[0m

This takes the list of C compilation errors (or the  output  from
another  program  in an acceptable format) in the selected buffer
and parses them for use with the [4mnext-error[24m,  [4mprevious-error[24m  and
[4mcurrent-error[24m  commands.   This  is  a very useful tool and helps
with compiling C programs or, when used in conjunction  with  the
UNIX [4mgrep[24m command, with making changes to a bunch of files.  JOVE
finds 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  remem-
bers  where  they are regardless.  [4mcurrent-error[24m is automatically
executed after one of the parse commands, so you end  up  at  the
first  error.   The  variable  [4merror-format-string[24m  specifies, by
means of regular-expressions, the format of errors to  be  recog-
nized.   Its default value can handle messages from [4mcc[24m, [4mcpp[24m, [4mlint[0m
and [4mgrep[24m [4m-n[24m.

[1m19.175.  parse-spelling-errors-in-buffer (Not Bound)[0m

This parses a list of words in the selected buffer and looks them
up  in  another buffer that you specify.  It is invoked automati-
cally by the [4mspell-buffer[24m command.

[1m19.176.  pause-jove (ESC S)[0m

This stops JOVE and returns control to the  parent  shell.   This
only  works  on  systems  that have the job control facility.  To
return to JOVE you type "fg" to the shell.

[1m19.177.  pop-mark (Not Bound)[0m

JOVE remembers the last eight marks and you use  [4mpop-mark[24m  to  go
backward  through  the  ring  of  marks.  If you execute [4mpop-mark[0m
enough times you will eventually get back to where  you  started.
This  command  is  also  executed  when  you  run [4mset-mark[24m with a
numeric argument.

[1m19.178.  popd (Not Bound)[0m

This pops one entry off the directory stack.  Entries are  pushed
with  the [4mpushd[24m or [4mpushlibd[24m commands.  The names were stolen from
the C-shell and the behavior is the same.

[1m19.179.  previous-error (^X ^P)[0m

This is the same as [4mnext-error[24m except it  goes  to  the  previous
error.  See [4mnext-error[24m for documentation.










                    JOVE Manual for UNIX Users                 87


[1m19.180.  previous-line (^P)[0m

This moves point up to the corresponding position on the previous
line (or the end of that line if it does not extend so far).

[1m19.181.  previous-page (ESC V)[0m

This displays the previous page of the selected buffer by  taking
the  top line and redrawing the window with it at the bottom.  If
a numeric argument of only - (with no digits)  is  supplied,  the
next page is displayed.  Otherwise, if a numeric argument is sup-
plied the screen is scrolled down that many lines, exactly as  in
the  [4mscroll-down[24m  command; if the argument is negative the screen
is scrolled up.

[1m19.182.  previous-window (^X P or ^X O)[0m

This moves into the previous 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.

[1m19.183.  print (Not Bound)[0m

This displays the value of a JOVE variable in the message line.

[1m19.184.  process-bind-keymap-to-key (Not Bound)[0m

This is like [4mprocess-bind-to-key[24m except that you use it to attach
a key sequence to named keymap.  The only reasonable  use  is  to
bind  some  extra  key  to [4mESC-map[24m for keyboards that make typing
ESC painful.

[1m19.185.  process-bind-macro-to-key (Not Bound)[0m

This is like [4mprocess-bind-to-key[24m except you use it  to  attach  a
key sequence to a named macro.

[1m19.186.  process-bind-to-key (Not Bound)[0m

This  command  is  identical  to [4mbind-to-key[24m, except that it only
affects your bindings when you are in a  buffer  attached  to  an
interactive process.  When you enter the process buffer, any keys
bound with this command will automatically take their new values.
When  you  switch  to  a non-process buffer, the old bindings for
those keys will be restored.  For example, you might want to exe-
cute

     process-bind-to-key stop-process ^C ^Z
     process-bind-to-key interrupt-process ^C ^C

Then,  when  you  start up an interactive process and switch into
that buffer, ^C ^Z will execute [4mstop-process[24m and ^C ^C will  exe-
cute  [4minterrupt-process[24m.   Bindings  effective  only  in  process









88                  JOVE Manual for UNIX Users


windows are shown with a "Proc:" prefix in this manual and by the
[4mapropos[24m and [4mdescribe-bindings[24m commands.

[1m19.187.  process-newline (Proc: Return)[0m

This command is normally bound to Return as if by a [4mprocess-bind-[0m
[4mto-key[24m so that it will only be bound in a process  window.   JOVE
does two different things depending on where you are when you hit
Return.  When you're in the last line of the interactive  process
buffer,  point  moves  to the end of the line, the line is termi-
nated, and the line is made available as input  to  the  process.
When  point is positioned in some other line, 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 send-
ing 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.  See the variable [4mprocess-prompt[24m.

[1m19.188.  process-prompt (variable)[0m

What a prompt looks like from the [4mshell[24m and [4mi-shell-command[24m  pro-
cesses.   The  default is "% ", the default C-shell prompt.  This
is actually a regular expression search string.  So you  can  set
it  to be more than one thing at once using the \| operator.  For
instance, for LISP hackers, the prompt can be

     "% \|-> \|<[0-9]>: ".


[1m19.189.  process-send-data-no-return (Not Bound)[0m

This is like [4mprocess-newline[24m 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 newline as well.

[1m19.190.  push-shell (Not Bound)[0m

This spawns a child shell and relinquishes control to it.  Within
this  shell,  $1 can be used to refer to the filename (if any) of
the selected buffer.  This works on any version of UNIX, but this
isn't as good as [4mpause-jove[24m because it takes time to start up the
new shell and you get a brand new  environment  every  time.   To
return to JOVE, simply exit the shell.

[1m19.191.  pushd (Not Bound)[0m

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  on the stack.  It purposely
behaves the same as C-shell's [4mpushd[24m.











                    JOVE Manual for UNIX Users                 89


[1m19.192.  pushlibd (Not Bound)[0m

Performs same function as [4mpushd[24m except that it  pushes  the  Jove
sharable library directory.  This directory holds the system-wide
[1mjove.rc [22mand the text used by the [4mdescribe-command[24m  and  [4mdescribe-[0m
[4mvariable[24m  commands.   It  is  mainly  intended  for  use with the
[1mjove.rc [22mfile.

[1m19.193.  pwd (Not Bound)[0m

This prints the pathname of the working directory, as in the UNIX
[4mpwd[24m command.

[1m19.194.  query-replace-string (ESC Q)[0m

This  replaces  strings  matching  a specified regular-expression
with a specified replacement string.   When  a  match  is  found,
point  is moved to it and then JOVE asks what to do.  The options
are:

     Space or Y or y     to replace this match and go on to the next one.
     Period              to replace this match and then stop.
     DEL, BS, or N or n  to skip this match and go on to the next one.
     ^R or R or 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
                         [4mquery-replace-string[24m, use the [4mexit-jove[24m command.
     ^W                  to delete the match and then enter a recursive edit.
     ^U or U or u        to undo all changes to the last modified line and
                         continue the search from the start of that line.
     ! or P or p         to go ahead and replace the remaining matches without
                         asking, as in [4mreplace-string[24m.
     Return or Q or q    to stop the [4mquery-replace-string[24m.
     ^L                  to redraw the screen

It is often useful to include a piece of the  matched  string  in
the  replacement, especially if the piece was not matched by lit-
eral text.  To select which part of the matched string is  to  be
used,  the corresponding part of the pattern is bracketed with \(
and \).  More than one set of brackets may be used,  as  long  as
they  are properly nested.  The matching substring is selected in
the replacement string using \ followed by a digit:  \1  for  the
first,  \2  for  the  second, and so on.  Conveniently, \0 always
stands for the complete matched string, as if the  whole  regular
expression  were  bracketed.   For example, the following command
will reverse pairs of comma-separated numbers:

     : query-replace-string \([0-9]*\),\([0-9]*\) with \2,\1

The search for a match 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.  Each subsequent search  starts  at  the  position
after  the  previous  match;  if  the previous match was an empty
string, the search is first advanced  one  character  to  prevent









90                  JOVE Manual for UNIX Users


unbounded repetition.

[1m19.195.  quit-process (Proc: ^C ^\)[0m

Send  the  signal  SIGQUIT  to  the  interactive  process  in the
selected buffer.  This is equivalent to sending the "quit"  char-
acter  (which most people have bound to ^\) to the process.  This
only works if you are in a buffer bound to  an  interactive  pro-
cess.

[1m19.196.  quoted-insert (^Q or ^^)[0m

This  lets  you insert characters that normally would be executed
as other JOVE commands.  For example, to insert "^F" you type "^Q
^F"  (assuming [4mquoted-insert[24m is bound to ^Q).  NUL cannot be rep-
resented in the buffer, so [4mquoted-insert[24m will insert "^@" in  its
stead.  On the IBM PC under DOS, non-ASCII keystrokes are seen by
JOVE as a hex FF character followed by another character; [4mquoted-[0m
[4minsert[24m will quote both characters.

[1m19.197.  read-only-mode (Not Bound)[0m

This turns on or off the Read-only minor mode.  Without a numeric
argument, the command toggles the mode; with a zero argument, the
mode  is turned off; with a non-zero argument, the mode is turned
on.  When a buffer is in Read-only mode, any  attempt  to  modify
the  buffer  will  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 acci-
dents  like  making  a bunch of changes and only THEN discovering
that you haven't checked the file out for making changes.

[1m19.198.  read-word-abbrev-file (Not Bound)[0m

This reads a specified file that contains a bunch of abbreviation
definitions,  and  makes  those abbreviations available.  See the
[4mword-abbrev-mode[24m command.

[1m19.199.  recursive-edit (Not Bound)[0m

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.

[1m19.200.  redraw-display (^L)[0m

This vertically centers the line containing point within the win-
dow.   If  that  line  is  already  in place, the screen 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 ^L" positions the line  containing  point  at
the top of the window (assuming [4mredraw-display[24m is bound to ^L).










                    JOVE Manual for UNIX Users                 91


[1m19.201.  rename-buffer (Not Bound)[0m

This lets you rename the selected buffer.

[1m19.202.  replace-in-region (Not Bound)[0m

This  is  the same as [4mreplace-string[24m except that it is restricted
to occurrences between point and the mark.

[1m19.203.  replace-string (ESC R)[0m

This replaces all occurrences of a specified string with a speci-
fied  replacement string.  This is just like [4mquery-replace-string[0m
except that it replaces without asking.

[1m19.204.  right-margin (variable)[0m

Where the right margin is for Auto Fill mode and  the  [4mfill-para-[0m
[4mgraph[24m and [4mfill-region[24m commands.  The default is 78.

[1m19.205.  right-margin-here (Not Bound)[0m

This  sets  the  [4mright-margin[24m variable to the current position of
point.  This is an easy way to say, "Make the right margin  begin
here," without having to count the number of spaces over it actu-
ally is.

[1m19.206.  save-file (^X ^S or ^X S or ^X \)[0m

This saves the selected buffer  to  the  associated  file.   This
makes  your  changes  permanent  so you should be sure you really
want to do it.  If the buffer has  not  been  modified  [4msave-file[0m
refuses  to do the save.  If you really do want to write the file
you must use [4mwrite-file[24m.

[1m19.207.  save-on-exit (variable)[0m

If this is [4mon[24m when JOVE is about to exit, it will ask,  for  each
modified buffer, whether you wish it to be saved.  See [4mwrite-mod-[0m
[4mified-files[24m.

[1m19.208.  scroll-all-lines (variable)[0m

When this is [4moff[24m, (the default) horizontal  scrolling  will  only
affect  the  line  containing  point.   When it is [4mon[24m, horizontal
scrolling will affect the whole window.   See  also  the  [4mscroll-[0m
[4mwidth[24m variable.

[1m19.209.  scroll-bar (variable)[0m

When this is turned [4mon[24m, a section of the mode line at the foot of
each window is left in not-reverse-video, to show the position of
the  window relative to the whole of the file represented by that
buffer (however, if the whole of the buffer is within the window,









92                  JOVE Manual for UNIX Users


the whole mode line remains inverted).

[1m19.210.  scroll-down (ESC Z)[0m

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  top  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.  See the [4mprevious-page[24m command.

[1m19.211.  scroll-left (Not Bound)[0m

This  scrolls  the  text  in the active window to the left.  If a
numeric argument is specified then the text is scrolled that num-
ber of columns.  Otherwise, the text is scrolled by the number of
columns specified by the variable [4mscroll-width[24m.  If the  variable
[4mscroll-all-lines[24m  is  ON then [4mscroll-left[24m may actually do nothing
if the scrolling would cause point not to be visible.  A negative
argument  scrolls  right.   If the [4mmode-line[24m variable is suitably
set, an indication that the text is scrolled will be given in the
mode line.

[1m19.212.  scroll-right (Not Bound)[0m

This  scrolls  the  text in the active window to the right.  If a
numeric argument is specified then the text is scrolled that num-
ber of columns.  Otherwise, the text is scrolled by the number of
columns specified by the variable [4mscroll-width[24m.  If the  variable
[4mscroll-all-lines[24m  is ON then [4mscroll-right[24m may actually do nothing
if the scrolling would cause point not to be visible.  A negative
argument scrolls left.

[1m19.213.  scroll-step (variable)[0m

How  many  lines should be scrolled if the [4mprevious-line[24m or [4mnext-[0m
[4mline[24m commands move you off the top or bottom of the screen.   You
may wish to decrease this variable if you are on a slow terminal.
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  [4mscroll-[0m
[4mstep[24m 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 win-
dow,  the new line will be positioned 5 lines from the top of the
window.

[1m19.214.  scroll-up (^Z)[0m

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 top of the window.  If a numeric argument  is  supplied  that
many  lines  are scrolled; if the argument is negative the screen
is scrolled down instead.  See also the [4mnext-page[24m command.











                    JOVE Manual for UNIX Users                 93


[1m19.215.  scroll-width (variable)[0m

Just as a buffer may be too long to be completely displayed in  a
window,  a line may be too wide.  JOVE handles wide lines through
horizontal scrolling, displaying only  a  portion  of  the  line.
This  variable affects horizontal scrolling.  If point is outside
the displayed portion of its line, but is  within  the  specified
number  of  columns beyond either side, the line is scrolled that
much.  Otherwise, the line will be scrolled to center point.  The
default value is 10.  If the variable is 0, centering will always
be used.  See also the [4mscroll-all-lines[24m variable.

[1m19.216.  search-exit-char (variable)[0m

Set this to the character you want to  use  to  exit  incremental
search.   The  default  is Newline, which makes [4mi-search[24m commands
compatible with normal string search.

[1m19.217.  search-forward (^S or ^\)[0m

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.  If point is moved by more than the variable [4mmark-thresh-[0m
[4mold[24m, the old point will be pushed.

[1m19.218.  search-forward-nd (Not Bound)[0m

This  is just like [4msearch-forward[24m 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.

[1m19.219.  search-reverse (^R)[0m

This  searches  backward  for a specified search string and posi-
tions point at the beginning if the string if it's found.  If the
string  is not found point remains unchanged.  This searches from
point to the beginning of the buffer, so any matches after  point
will  be  missed.   If  point  is moved by more than the variable
[4mmark-threshold[24m, the old point will be pushed.

[1m19.220.  search-reverse-nd (Not Bound)[0m

This is just like [4msearch-reverse[24m 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.












94                  JOVE Manual for UNIX Users


[1m19.221.  select-buffer (^X B)[0m

This selects a new or already existing buffer making it the  cur-
rent 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  unam-
biguous,  at which point typing Tab 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.

[1m19.222.  select-buffer-1 (Not Bound)[0m

This selects buffer number 1, if it exists.

[1m19.223.  select-buffer-10 (Not Bound)[0m

This selects buffer number 10, if it exists.

[1m19.224.  select-buffer-2 (Not Bound)[0m

This selects buffer number 2, if it exists.

[1m19.225.  select-buffer-3 (Not Bound)[0m

This selects buffer number 3, if it exists.

[1m19.226.  select-buffer-4 (Not Bound)[0m

This selects buffer number 4, if it exists.

[1m19.227.  select-buffer-5 (Not Bound)[0m

This selects buffer number 5, if it exists.

[1m19.228.  select-buffer-6 (Not Bound)[0m

This selects buffer number 6, if it exists.

[1m19.229.  select-buffer-7 (Not Bound)[0m

This selects buffer number 7, if it exists.

[1m19.230.  select-buffer-8 (Not Bound)[0m

This selects buffer number 8, if it exists.

[1m19.231.  select-buffer-9 (Not Bound)[0m

This selects buffer number 9, if it exists.

[1m19.232.  self-insert (Most Printing Characters)[0m

This  inserts  the  character  that invoked it into the buffer at
point.  Initially all but a few of the  printing  characters  are
bound to [4mself-insert[24m.  See also [4mparen-flash[24m.









                    JOVE Manual for UNIX Users                 95


[1m19.233.  send-typeout-to-buffer (variable)[0m

When  this  is  [4mon[24m JOVE will send output that normally overwrites
the screen (temporarily) to a buffer instead.  This affects  com-
mands like [4mlist-buffers[24m, [4mlist-processes[24m, [4mshell-command-with-type-[0m
[4mout[24m, and commands that use completion.  The default value is [4moff[24m.

[1m19.234.  set (Not Bound)[0m

This sets a specified variable to a new value.

[1m19.235.  set-mark (^@)[0m

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 eight  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,  use  the [4mpop-mark[24m command.  If you type this enough times
you will get back to where you started.  If a [4mset-mark[24m command is
given a numeric argument, it acts like a [4mpop-mark[24m command.

[1m19.236.  shell (variable)[0m

The  shell  to be used with all the shell-* commands command.  If
your SHELL environment variable is set, it is used as the default
value  of  [4mshell[24m;  otherwise "/bin/csh" is the default.  See also
the description of the [4mshell-flags[24m variable to see how to  change
the flags passed to this shell.

[1m19.237.  shell (Not Bound)[0m

This  starts  up  an  interactive  shell in a window; if there is
already an interactive shell, it just selects that buffer.   JOVE
uses  "*shell-n*" (where [1mn [22mis the argument of the command) as the
name of the buffer in which the interacting  takes  place.   Thus
different  argument values refer to different interactive shells.
See the JOVE manual for information on  how  to  use  interactive
processes.  See also the variable [4mwrap-process-lines[24m.

[1m19.238.  shell-command (^X !)[0m

This  runs a UNIX command and places the output from that command
in a buffer.  Within the command, $1 can be used to refer the the
filename  (if any) of the selected 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
(unless a numeric argument is specified).  If it's already  hold-
ing  a  file,  not some output from a previous command, JOVE asks









96                  JOVE Manual for UNIX Users


permission before emptying the buffer.  Beware  that  if  you  go
ahead,  not only do you lose any unsaved changes that you made to
the buffer, but the buffer's file name  remains  set,  making  it
easy to later accidentally overwrite the original file.  See also
the variable [4mwrap-process-lines[24m.

[1m19.239.  shell-command-no-buffer (Not Bound)[0m

This is just like [4mshell-command[24m except it just runs  the  command
without saving the output to any buffer.  It will report the suc-
cess of the command in the usual way.

[1m19.240.  shell-command-to-buffer (Not Bound)[0m

This is just like [4mshell-command[24m except it lets  you  specify  the
buffer to use.

[1m19.241.  shell-command-with-typeout (Not Bound)[0m

This is just like [4mshell-command[24m except that instead of saving the
output to a buffer, and displaying it  in  a  window,  this  just
types  out  the  output  in  the same way that [4mlist-buffers[24m does.
Actually, how this behaves depends on the value of  the  variable
[4msend-typeout-to-buffer[24m.   If  it  is  [4mon[24m then [4mshell-command-with-[0m
[4mtypeout[24m will behave just like [4mshell-command[24m.  If a numeric  argu-
ment is given, the "completed successfully" message at the end is
suppressed.

[1m19.242.  shell-flags (variable)[0m

This specifies a flag argument that directs the shell to take the
next  argument  as a command to be executed.  The default is "-c"
(suitable for all known UNIX shells).  Under MSDOS,  the  default
is  "/c"  (suitable  for  command.com  and similar MSDOS shells).
Other MSDOS shells, such as MKS KSH require that this be  changed
to  "-c".  Under MSDOS, JOVE puts quotes around the command argu-
ment if [4mshell-flags[24m starts with "-".  See the [4mshell[24m  variable  to
change the default shell.

[1m19.243.  shift-region-left (Not Bound)[0m

This  shifts the region left by [4mc-indentation-increment[24m OR by the
numeric argument, if one is supplied.  If a negative argument  is
supplied the region is shifted the other way.

[1m19.244.  shift-region-right (Not Bound)[0m

This shifts the region right by [4mc-indentation-increment[24m OR by the
numeric argument, if one is supplied.  If a negative argument  is
supplied the region is shifted the other way.













                    JOVE Manual for UNIX Users                 97


[1m19.245.  show-match-mode (Not Bound)[0m

This  turns  on  or off the Show Match minor mode in the selected
buffer.  Without a numeric  argument,  the  command  toggles  the
mode;  with  a zero argument, the mode is turned off; with a non-
zero argument, the mode is turned on.  This mode changes "}", ")"
and  "]"  so that when they are typed they 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 com-
mand.   This is useful for typing in complicated expressions in a
program.  You can change how long the cursor sits on the matching
parenthesis  by  setting the [4mparen-flash-delay[24m variable in tenths
of a second.  If the matching "{", "(" or "[" isn't visible,  the
line containing the match is displayed on the message line.

[1m19.246.  shrink-window (Not Bound)[0m

This makes the active window one line shorter, if possible.  Win-
dows must be at least 2 lines high, one  for  the  text  and  the
other for the mode line.  See also [4mgrow-window[24m.

[1m19.247.  source (Not Bound)[0m

This  reads  a  bunch of JOVE commands from a file.  If a numeric
argument is supplied to the [4msource[24m command, it  will  quietly  do
nothing if it cannot read the file.

The  format  of the file is the same as that in the [1mjove.rc [22mfile,
or your private [1m.joverc [22min your home directory.  There should  be
one command per line and it should be as though you were respond-
ing to an [4mexecute-named-command[24m command while in JOVE.  A command
can be optionally preceded by a numeric argument.  Lines commenc-
ing with a # are treated as comments.  Control characters such as
^R  may  be represented as themselves, or as "^" followed by "R".
ESC should be represented by ^[.

Sometimes it is useful to do different things in  different  cir-
cumstances.   To  make  this  possible, there are two conditional
commands: [4mif[24m and [4mifenv[24m.  The [4mif[24m command takes  as  an  operand  a
shell  command, which it runs.  If the command succeeds, the com-
mands after the [4mif[24m, until a line containing [4melse[24m  or  [4mendif[24m,  are
performed.  Otherwise, these commands are suppressed and the com-
mands after any [4melse[24m, up until an [4mendif[24m,  are  executed.   Condi-
tionals  nest  in  the  normal  way.   The [4mifenv[24m command takes as
operands the name of an environment variable and a  pattern.   If
the  environment  variable  is  defined and its value matches the
pattern, the [4mifenv[24m succeeds.

For example, here are some lines from the file [1mjove.rc[22m.













98                  JOVE Manual for UNIX Users


     bind-to-key pause-jove ^[S
     bind-to-key pause-jove ^[s
     set process-prompt ^[^%$#]*[%$#]
     # source any TERMinal-specific rc file
     1 source jove.rc.$TERM

What they do is to  provide  two  alternative  key  bindings  for
[4mpause-jove[24m,  set the variable [4mprocess-prompt[24m, and attempt to call
the [4msource[24m command on the file  [1mjove.rc.$TERM[22m.   Because  of  the
numeric  argument 1, there will be no complaint if this file can-
not be found.

[1m19.248.  space-sentence-2 (variable)[0m

If set [4mon[24m, two spaces are left after each  sentence  by  commands
such  as  [4mfill-paragraph[24m;  otherwise,  one  space  is  left.  The
default is [4mon[24m.

[1m19.249.  spell-buffer (Not Bound)[0m

This runs the selected buffer through the UNIX [4mspell[24m 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 [4mparse-spelling-errors-in-buffer[24m command comes along and finds
all the misspelled words and sets things up so the error commands
[4mnext-error[24m, [4mprevious-error[24m and [4mcurrent-error[24m work.  See also  the
variable [4merror-window-size[24m.

[1m19.250.  split-current-window (^X 2)[0m

This splits the active window into two equal parts (providing the
resulting windows would be big enough) and displays the  selected
buffer in both windows.  Use [4mdelete-other-windows[24m to go back to 1
window mode.  If a numeric argument is supplied,  the  window  is
split "evenly" that many times (when possible).

[1m19.251.  start-remembering (Not Bound)[0m

This is just another name for the [4mbegin-kbd-macro[24m command.  It is
included for backward compatibility.

[1m19.252.  stop-process (Not Bound)[0m

Send the  signal  SIGTSTP  to  the  interactive  process  in  the
selected  buffer.  This is equivalent to sending the "stop" char-
acter (which most people have bound to ^Z) to the process.   This
only  works  if  you are in a buffer bound to an interactive pro-
cess.

[1m19.253.  stop-remembering (Not Bound)[0m

This is just another name for the [4mend-kbd-macro[24m command.   It  is
included for backward compatibility.









                    JOVE Manual for UNIX Users                 99


[1m19.254.  string-length (Not Bound)[0m

This  prints  the  number  of characters in the string that point
sits in.  Strings are surrounded by double  quotes.   JOVE  knows
that  "\007"  is  considered a single character, namely "^G", and
also knows about other common ones, like "\r" (Return)  and  "\n"
(Linefeed).  This is mostly useful only for C programmers.

[1m19.255.  suspend-jove (Not Bound)[0m

This is a synonym for [4mpause-jove[24m.

[1m19.256.  sync-frequency (variable)[0m

The  temporary  files  used  by JOVE are forced out to disk every
[4msync-frequency[24m modifications.  The default is  50,  which  really
makes good sense.  Unless your system is very unstable, you prob-
ably shouldn't fool with this.

[1m19.257.  tab-width (variable)[0m

When JOVE displays a Tab character, it moves point forward to the
next  multiple  of this variable.  If the value is 0, tab is dis-
played as ^I, not whitespace.  The default value is 8.

[1m19.258.  tag-file (variable)[0m

This is the name of the file in which JOVE  should  look  up  tag
definitions.  The default value is "./tags".

[1m19.259.  text-attribute (variable)[0m

(IBM PC version only) This specifies the screen attribute (color)
for normal text characters.  The default is 7 (white on black).

[1m19.260.  text-mode (Not Bound)[0m

This sets the major mode to Text.  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.

[1m19.261.  tmp-file-pathname (variable)[0m

This tells JOVE where to put the tmp files, which is  where  JOVE
stores  buffers internally.  The default is in [1m/tmp[22m, or as set up
when your system was compiled, 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  [1m/tmp  [22mbecause  the system removes all the
files in [1m/tmp [22mupon reboot, and  so  you  would  not  be  able  to
recover editor buffers using the [4mjove[24m [4m-r[24m command.

NOTE: In order for this to work correctly you must set this vari-
able BEFORE JOVE creates the tmp file.  You can set this in  your









100                 JOVE Manual for UNIX Users


[1m.joverc  [22m(the  closer to the beginning the better), or as soon as
you start up JOVE before you read any files.

[1m19.262.  transpose-characters (^T)[0m

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  [4mtranspose-characters[24m  to drag a character down the
length of a line.

[1m19.263.  transpose-lines (^X ^T)[0m

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 [4mtranspose-characters[24m,  can  be  used  to
drag a line down a page.

[1m19.264.  unbound (Not Bound)[0m

This  command  acts as if an unbound key sequence were typed.  In
fact, that is its use: if you wish to unbind a key sequence, sim-
ply bind it to this command.

[1m19.265.  update-time-frequency (variable)[0m

How  often  the  mode  line  is updated (and thus the time).  The
default is 30 seconds.

[1m19.266.  use-i/d-char (variable)[0m

If your terminal has insert/delete character capability  you  can
tell JOVE not to use it by setting this to [4moff[24m.  In my opinion it
is only worth using insert/delete character at  low  baud  rates.
WARNING:  if  you  set this to [4mon[24m when your terminal doesn't have
insert/delete character capability, you will get  weird  (perhaps
fatal) results.

[1m19.267.  version (Not Bound)[0m

Displays the version number of this JOVE.

[1m19.268.  visible-bell (variable)[0m

If the terminal has a visible bell, use it instead of beeping.

[1m19.269.  visible-spaces-in-window (Not Bound)[0m

This  displays  an  underscore character instead of each Space in
the window and displays a greater-than  followed  by  spaces  for
each  Tab  in  the  window.  The actual text in the buffer is not
changed; only the screen display is affected.  To turn  this  off









                    JOVE Manual for UNIX Users                101


you run the command again; it toggles.

[1m19.270.  visit-file (^X ^V or ^X ^R)[0m

This  reads  a  specified file into the selected 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.

[1m19.271.  window-find (^X 4)[0m

This lets you select another buffer in another window three  dif-
ferent  ways.   This waits for another character which can be one
of the following:

     T    Finds a tag in the other window.
     ^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 [4msplit-current-window[24m (or
[4mprevious-window[24m if there are already two windows) followed by the
appropriate sequence  for  invoking  each  command.   With  this,
though,  there  isn't  the extra overhead of having to redisplay.
In addition, you don't have to decide whether to  use  [4msplit-cur-[0m
[4mrent-window[24m  or  [4mprevious-window[24m since [4mwindow-find[24m does the right
thing.

[1m19.272.  word-abbrev-mode (Not Bound)[0m

This turns on or off Word  Abbrev  minor  mode  in  the  selected
buffer.   Without  a  numeric  argument,  the command toggles the
mode; with a zero argument, the mode is turned off; with  a  non-
zero  argument, the mode is turned on.  Word Abbrev mode lets you
specify a word (an abbreviation) and a  phrase  with  which  JOVE
should  substitute  the abbreviation.  You can use this to define
words to expand into long phrases, e.g., "jove" can  expand  into
"Jonathan's Own Version of Emacs"; another common use is defining
words that you often misspell in the same way, e.g.,  "thier"  =>
"their" or "teh" => "the".  See the information on the [4mauto-case-[0m
[4mabbrev[24m variable.

There are two kinds of abbreviations: mode specific  and  global.
If  you  define  a  Mode specific abbreviation in C mode, it will
expand only in buffers that are in C mode.  This is  so  you  can
have  the  same abbreviation expand to different things depending
on your context.  Global abbreviations expand regardless  of  the
major  mode  of the buffer.  The way it works is this: JOVE looks
first in the mode specific table, and then in the  global  table.
Whichever  it  finds  it  in  first is the one that's used in the
expansion.  If it doesn't find the word  it  is  left  untouched.
JOVE  tries to expand words when you type a punctuation character









102                 JOVE Manual for UNIX Users


or Space or Return.  If you are in Auto Fill mode  the  expansion
will be filled as if you typed it yourself.

[1m19.273.  wrap-process-lines (variable)[0m

If  this variable is [4mon[24m, the process output that is captured in a
buffer is wrapped just before the line would have as many charac-
ters  as  there are columns on the screen.  This introduces extra
newlines, but it makes the output more readable.  Note  that  the
folding  does not take into account that some characters (notably
tabs) occupy more than one column of the display.  The output  of
the  [4mfilter-region[24m  command  is not processed in this way because
the extra newlines are presumed to be undesired in this case.

[1m19.274.  wrap-search (variable)[0m

If set, searches will  "wrap  around"  the  ends  of  the  buffer
instead of stopping at the bottom or top.  The default is [4moff[24m.

[1m19.275.  write-file (^X ^W)[0m

This  saves  the  selected  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.

[1m19.276.  write-files-on-make (variable)[0m

When set, all modified files will be written out  before  calling
make when the [4mcompile-it[24m command is executed.  The default is [4mon[24m.

[1m19.277.  write-macros-to-file (Not Bound)[0m

This writes the currently defined macros to a specified file in a
format  appropriate for reading them back in with the [4msource[24m com-
mand.  The purpose of this command is  to  allow  you  to  define
macros  once  and  use them in other instances of JOVE.  See also
the [4mdefine-macro[24m command.

[1m19.278.  write-modified-files (^X ^M)[0m

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.

[1m19.279.  write-region (Not Bound)[0m

This writes the text in the region to a specified file.   If  the
file already exists you are asked to confirm over-writing it.

[1m19.280.  write-word-abbrev-file (Not Bound)[0m

This  writes  the  currently defined abbreviations to a specified
file.  They can be read back in and  automatically  defined  with









                    JOVE Manual for UNIX Users                103


[4mread-word-abbrev-file[24m.

[1m19.281.  xj-mouse-commands (^X m*)[0m

Programs such as XJove and JoveTool generate these commands when-
ever a mouse button is pressed or released, or the mouse is moved
while  the  button  is  pressed.  They are followed by parameters
giving parameters for the button pressed, the coordinates of  the
mouse,  etc.   They are not intended for direct use by the normal
user.

The individual commands will now be described.

[1m19.282.  xj-mouse-copy-cut (^X m8)[0m

Performs a [4mcopy-region[24m if the CTRL key was down, or a [4mkill-region[0m
if both CTRL and SHIFT were down.  This command is normally bound
to the release of button 2.

[1m19.283.  xj-mouse-line (^X m7)[0m

Sets the region to be the whole line containing the cursor.  This
command is normally bound to a triple down click of button 2, and
the presumed effects of the  preceding  double  click  are  first
undone.

[1m19.284.  xj-mouse-mark (^X m5)[0m

Both  point and mark are set to the cursor.  This command is nor-
mally bound to the pressing of button 2.

[1m19.285.  xj-mouse-point (^X m[01249])[0m

Point is set to the cursor.  This command is  normally  bound  to
the  single,  double,  and  triple down-click and the dragging of
button 1; also the dragging of button 2.

[1m19.286.  xj-mouse-word (^X m6)[0m

Sets the region to be the word (or the  gap  between  two  words)
containing  the cursor.  This command is normally bound to a dou-
ble down click of button 2, and the presumed effects of the  pre-
ceding single click are first undone.

[1m19.287.  xj-mouse-yank (^X m3)[0m

Performs  a  [4myank[24m if the CTRL key was down.  This command is nor-
mally bound to the release of button 1.

[1m19.288.  xt-mouse (variable)[0m

When set, JOVE sends XTerm escape sequences to enable and disable
the mouse messages at appropriate times.  Warning: due to the way
XTerm encodes mouse events, if [4mmeta-key[24m  is  set,  mouse  actions









104                 JOVE Manual for UNIX Users


beyond  column  95  or row 95 will be misunderstood; in any case,
mouse actions beyond column 223 or row 223 will be misunderstood.

[1m19.289.  xt-mouse-commands (ESC [ M*)[0m

Programs  such  as XTerm generate these commands whenever a mouse
button is pressed or released.  XTerm does not give the  user  as
much  power as XJove.  They are followed by parameters specifying
the button pressed, the coordinates of the mouse, etc.  They  are
not intended for direct use by the normal user.  Set the variable
[4mxt-mouse[24m on to enable XTerm mouse mode.

The individual commands will now be described.

[1m19.290.  xt-mouse-mark (^X m5)[0m

Both point and mark are set to the cursor.  This command is  nor-
mally bound to the pressing of button 2.

[1m19.291.  xt-mouse-point (^X m[01249])[0m

Point  is  set  to the cursor.  This command is normally bound to
the down-click of button 1.

[1m19.292.  xt-mouse-up (^X m6)[0m

As the name implies,  this  command  is  normally  bound  to  the
release  of  any  button (XTerm does not specify which button was
released).  Note that a normally configured XTerm will  not  pass
on  mouse events if the CTRL or SHIFT keys are pressed.  Point is
set to the cursor.  If the most recently pressed button was  but-
ton  1  and  the  CTRL key was down (and not the SHIFT key), this
command performs a [4myank[24m.  If the most recently pressed button was
button 2 and the CTRL key was down, this command performs a [4mcopy-[0m
[4mregion[24m.  If the most recently pressed button was button 2 and the
CTRL  and  SHIFT  keys  were  down, this command performs a [4mkill-[0m
[4mregion[24m.

[1m19.293.  yank (^Y)[0m

This inserts the text at the front of the kill ring (as set by an
earlier  [4mcopy-region[24m,  [4mkill-region[24m,  etc.) at point.  When you do
multiple kill commands in a row, they are merged so that the [4myank[0m
command yanks back all of them.

[1m19.294.  yank-pop (ESC Y)[0m

JOVE  has a kill ring on which the last sixteen kills are stored.
This command yanks back previous texts from the kill ring.   [4myank[0m
yanks  a  copy of the text at the front of the ring.  If you want
one of the last sixteen kills you then use [4myank-pop[24m which rotates
the ring so another different entry is now at the front.  You can
use [4myank-pop[24m only immediately following a [4myank[24m or  another  [4myank-[0m
[4mpop[24m.   If  you  supply  a  negative  numeric argument the ring is









                    JOVE Manual for UNIX Users                105


rotated the other way.  If you use this command enough times in a
row you will eventually get back to where you started.


























































