








                   [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 custom-
ized 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 spa-
ces 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 buf-
fers, 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 buf-
fer so that you can edit them.  To visit a file, use the  command
^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' buf-
fers 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 buf-
fer.  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 buf-
fers ([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 buf-
fer  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 spell-
ing mistakes in <filename> and display it in a window.   However,
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 particu-
lar  from  [4mcc[24m, [4mgrep[24m [4m-n[24m and [4mlint[24m).  [4mParse-errors[24m then does a [4mfind-[0m









42                  JOVE Manual for UNIX Users


[4mfile[24m on the first such filename and a [4mgoto-line[24m on  its  linenum-
ber.   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 (perhaps in a
different file).  Or you can type ^X ^P ([4mprevious-error[24m) or ESC X
[4mcurrent-error[24m.  The rules JOVE uses to interpret error message in
a buffer are specified in the variable [4merror-format-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.


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









                    JOVE Manual for UNIX Users                 43


[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.

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).










44                  JOVE Manual for UNIX Users


[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.

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









                    JOVE Manual for UNIX Users                 45


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  buf-
                                        fer 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
            process.

%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  buf-
fer.   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  use-
ful 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  which-
ever  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
process bindings.   Any  previous  global  binding  of  this  key
sequence  is discarded.  For example, to make "^W" erase the pre-
vious 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-buf-[0m
[4mfer[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 buf-
fer 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 buf-
fer.   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  buf-
fers  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 buf-
fer.  There are four types: File, Scratch, Process and I-Process.
"File"  is  simply  a  buffer that holds a file; "Scratch" is for
buffers that JOVE uses internally; "Process" is  one  that  holds
the  output  from  a UNIX command; "I-Process" is one that has an
interactive process attached to it.  The next column contains the
name  of the buffer.  And the last column is the name of the file
that's attached to the buffer.  In this case,  both  Minibuf  and
commands.doc  have  been  changed  but  not  yet  saved.  In fact
Minibuf won't be saved since it's 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
process has exited normally the status is "Done" as in fgrep;  if









                    JOVE Manual for UNIX Users                 81


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

[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
process.

[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 oper-
ands  the  name of an environment variable and a pattern.  If the
environment variable is defined and its value  matches  the  pat-
tern, 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
process.

[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 buf-
fer.  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 spec-
ify  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.


























































