








                        [1mJOVE User Manual[0m
                          [1mVersion 4.17[0m


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




[1m1.  Introduction[0m

JOVE* is an advanced, self‐documenting, customizable, display ed‐
itor.  It (and this tutorial introduction) are based on the orig‐
inal  EMACS  editor  and user manual written at M.I.T. by Richard
Stallman†.

JOVE is considered a display editor because normally the text be‐
ing  edited is visible on the screen and is updated automatically
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 User Manual


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 User Manual                       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 User Manual


[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  mi‐
nus 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 ac‐
cepting input from the user, such as filenames or search strings.
When  JOVE  prompts for input, the cursor will temporarily appear
on the bottom line, waiting for you to type a string.   When  you
have finished typing your input, you can type a Return to send it
to JOVE.  If you change your mind about running the command  that
is  waiting for input, you can type ^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 pa‐
rameters 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 User Manual                       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®  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 al‐
phabet 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 User Manual


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 ex‐
     cept 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 User Manual                       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 ig‐
nore 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 al‐
ways use the same terminal.  See the section on Customization for
more details.









8                        JOVE User Manual


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 se‐
quence  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 re‐
member a value.  JOVE contains variables which are there so  that
you  can  change  them  if you want to customize.  The variable’s
value may be examined by some command, and  changing  that  value
makes  the  command  behave differently.  However, the facilities
provided are pretty limited: you cannot invent new variables,  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 User Manual                       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 User Manual


[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 User Manual                      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 ↓     [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 (→, ←, ↓ and ↑) as alternatives
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 keyboard
to some of these commands, especially if those keys already  have
appropriate  engravings  on them.  See the section on Customizing
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  “un‐
derneath”,  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 User Manual


[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 us‐
ing 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 ma‐
nipulate their output, while never leaving the editor (the inter‐
active 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 termi‐
nology  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 User Manual                      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  un‐
derlining.  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 up‐
per‐case,  you can use the [4mcase‐region‐upper[24m command, which oper‐
ates on the text in the region.  You can first go to  the  begin‐
ning  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).   Al‐
ternatively, 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 re‐
membering  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 User Manual


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  re‐
membered,  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 User Manual                      15


The  commonest  kill command is ^W ([4mkill‐region[24m), which kills ev‐
erything 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  be‐
cause it is too easy to hit ^W accidentally.









16                       JOVE User Manual


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  ar‐
gument, ^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  en‐
try 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 User Manual                      17


You can think of all the last few kills as living on a ring.  Af‐
ter  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  ro‐
tate  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 re‐
ally 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 ro‐
tated, 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 di‐
rectly 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 User Manual


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 im‐
mediately 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  de‐
pendent  on the variable [4mmatch‐regular‐expressions[24m and is subject
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  be‐
gins  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”.  Af‐
ter 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.

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









                         JOVE User Manual                      19


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 User Manual


[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 re‐
                     cursive editing level with ^X ^C ([4mexit‐jove[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 User Manual                      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‐ex‐[0m
[4mpressions[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‐ex‐
pression  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‐ex‐
pressions 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 User Manual


              [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  be‐
              tween  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 User Manual                      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  ex‐
              plained.   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  en‐
              tire 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 User Manual


[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  in‐
              dicated  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 User Manual                      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  re‐
quire 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 User Manual


[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 be‐
cause 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 User Manual                      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 User Manual


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 User Manual                      29


don’t catch it so quickly, you must move the cursor back  to  be‐
tween 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 User Manual


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<re‐
turn> reselects the previous buffer.  Repeated ^X B<return>’s al‐
ternate 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  ap‐
pears  at the beginning of a line in a ^X ^B listing is that buf‐
fer’s [4mbuffer[24m [4mnumber[24m.  You can select a buffer by typing its  num‐
ber  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 User Manual                      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 <re‐
turn> JOVE will kill the previously selected buffer.  If you  try
to  kill  a buffer that needs saving JOVE will ask you to confirm
it.

If you need to kill several buffers, use the  command  [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 User Manual


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 al‐
ready 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  re‐
gret.

^X ^I ([4minsert‐file[24m) followed by a filename reads the file and in‐
serts 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 be‐
haves 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 User Manual                      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 be‐
tween 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 User Manual


┌─────────────────────────────────────────────────────┐│
│#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 User Manual                      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  op‐
posite  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 nu‐
meric argument.  Use ESC X [4mshrink‐window[24m to make the active  win‐
dow 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  si‐
multaneously 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  an‐
other  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 User Manual


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  ap‐
proximately 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 interested
in seeing, but if the guess is wrong, you  can  use  the  display
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 User Manual                      37


portion so as to put point that many lines from the top.  An  ar‐
gument  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 re‐
stores 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 User Manual


            [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  de‐
scribed 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 be‐
fore 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 User Manual                      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 User Manual


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  ap‐
pear  in  another  window,  and point will be moved to that line.
Thus you may easily follow the progress of the program being  de‐
bugged.

[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 an‐
swer.  Remember that JOVE (not the process in the window) is lis‐
tening  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><re‐
turn>.  For example, to get a list of all the users on  the  sys‐
tem, 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 User Manual                      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 au‐
tomatically 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  particular  from
[4mcc[24m, [4mgrep[24m [4m‐n[24m and [4mlint[24m).  [4mParse‐errors[24m then does a [4mfind‐file[24m on the









42                       JOVE User Manual


first such filename and a [4mgoto‐line[24m on its linenumber.  When  you
have  dealt  with  the  error on that line (perhaps editing lines
elsewhere in your program in the  process)  you  can  type  ^X ^N
([4mnext‐error[24m)  to  move  to the next error (perhaps in a different
file).  Or you can type ^X ^P ([4mprevious‐error[24m) or ESC X  [4mcurrent‐[0m
[4merror[24m.   The rules JOVE uses to interpret error message in a buf‐
fer 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 User Manual                      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 User Manual


[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 User Manual                      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 User Manual


[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 User Manual                      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 ef‐
fective 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  en‐
ters a recursive edit on a buffer containing the list — use ^X ^C
([4mexit[24m [4mjove[24m) when you are finished).   Use  [4mwrite‐word‐abbrev‐file[0m
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 [22mfile) .

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.
            [4mbind‐macro‐to‐word‐abbrev[24m  Bind named macro to an abbrev.










48                       JOVE User Manual


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 in‐
clude 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 ex‐
ecuted upon typing the abbrev word you have specified —  it  will
get expanded as well unless it was an abbreviation for nothing).

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









                         JOVE User Manual                      49


[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  to‐
gether  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 in‐
dividual 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 the regular expression <pattern>  (an  anchored
match from the beginning of the variable value).  There is a sim‐
ilar variant [4mifvar[24m <jove‐variable> <pattern>, which  succeeds  if
the specified JOVE variable exists and if its value matches <pat‐
tern>. These conditional commands can be nested in the usual way;
also  indentation  and  empty lines have no effect.  Finally, any
line that starts with a “#”  is  treated  as  a  comment  and  is









50                       JOVE User Manual


ignored by JOVE.

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 in‐
scribed “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.

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









                         JOVE User Manual                      51


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  se‐
                                        lected buffer only.

            [4mprocess‐bind‐to‐key[24m         Bind interactive process command to a key‐se‐
                                        quence.
            [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 ex‐
amples 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 com‐
mands) and ESC [ ... (or ^[ [ ...).  Internally, JOVE creates ta‐
bles for each prefix encountered, but it cannot create a new pre‐
fix 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









52                       JOVE User Manual


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‐se‐
quence>.   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.

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










                         JOVE User Manual                      53


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.

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









54                       JOVE User Manual


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‐re‐[0m
[4mgion[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 win‐
dows 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
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









                         JOVE User Manual                      55


“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  to‐
gether, 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 re‐
leasing  MIDDLE.   Likewise, if you do the same thing holding the
Cut key down, the text will also be killed from its original  po‐
sition.

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 in‐
formation, 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.

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~”.











56                       JOVE User Manual


[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  (un‐
less  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 in‐
dentation 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










                         JOVE User Manual                      57


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












58                       JOVE User Manual


[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 ar‐
gument, the mode is turned on.  When JOVE is in Auto Indent mode,
the [4mnewline[24m command (which is  normally  bound  to  Return)  acts
identically  to  [4mnewline‐and‐indent[24m:  the new line is indented to
the same position as the line you were just on.  This  is  useful
for  lining  up  C  code (or any other language (but what else is
there besides C?)).  Furthermore, if a line is broken because  of
Auto  Fill mode, and Auto Indent mode is on, the new line will be
indented as the old line was.

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

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

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

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

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

This moves point backward to the beginning of the current or pre‐
vious paragraph.  Paragraphs are  bounded  by  lines  that  match
[4mparagraph‐delimiter‐pattern[24m  (by default, those that are empty or
look like troff or TeX commands).  A change  in  indentation  may
also  signal  a break between paragraphs, except that JOVE allows
the first line of a paragraph to be indented differently from the
other  lines.   Arguments  are  accepted,  and negative arguments
search forwards.













                         JOVE User Manual                      59


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













60                       JOVE User Manual


[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 se‐
quence 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  [4mex‐[0m
[4mchange‐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  se‐
quence  is discarded.  For example, to make “^W” erase the previ‐
ous 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,









                         JOVE User Manual                      61


when the [4mbind‐to‐key[24m command is issued interactively, the key se‐
quence 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 in‐
dent 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.









62                       JOVE User Manual


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












                         JOVE User Manual                      63


[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 an‐
other 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  de‐
tails.

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









64                       JOVE User Manual


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









                         JOVE User Manual                      65


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.









66                       JOVE User Manual


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













                         JOVE User Manual                      67


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









68                       JOVE User Manual


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 en‐
ables 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  indis‐
criminate  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  pro‐
vide  the biff facility.  Note that the variable [4mmode‐line[24m 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.

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









                         JOVE User Manual                      69


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 se‐
lected buffer when next it tries to read input.  This is  equiva‐
lent to sending the “dsusp” character (which most people have set
to ^Y) to the process.  This only works if you are  in  a  buffer
bound to an interactive process.

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

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

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

This  stops  the  definition of the keyboard macro.  Because of a
bug in JOVE, this must be bound to “^X )”, or some  key  sequence
which is one or two characters long.  Anything else will not work
properly.  See [4mbegin‐kbd‐macro[24m for more details.

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

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

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

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

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

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

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









70                       JOVE User Manual


contains function keys and key combinations  that  are  not  sup‐
ported on the original IBM PCs and XTs.  The default value is de‐
termined 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  us‐
ing 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 mes‐
sage.  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
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.










                         JOVE User Manual                      71


[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, [4mer‐[0m
[4mror‐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
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









72                       JOVE User Manual


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  de‐
fault 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 [4mcomment‐format[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 re‐
formatted.  The original text is saved in the kill ring; a  [4myank‐[0m
[4mpop[24m command will undo the formatting.

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









                         JOVE User Manual                      73


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  al‐
tered.

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.

Filling a paragraph can do something that you didn’t intend.  For
that reason the original text is saved on the kill ring  and  can
be yanked back.  Deleting the rubble is up to you.

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

This  is  like [4mfill‐paragraph[24m, except it operates on a region in‐
stead 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).

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









74                       JOVE User Manual


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 be‐
ginning 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‐de‐[0m
[4mlimiter‐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.













                         JOVE User Manual                      75


[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 ex‐
pression.

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













76                       JOVE User Manual


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













                         JOVE User Manual                      77


[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.  insert‐variable (Not Bound)[0m

This  inserts  the value of the specified variable at the current
point in the current buffer.

[1m19.129.  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.130.  iproc‐env‐export (Not Bound)[0m

This takes an argument of the form VARNAME=VALUE and replaces  or
sets  VARNAME  to that VALUE in the list of environment variables
that are passed to interactive shell commands i.e.  [4mshell[24m and  [4mi‐[0m
[4mshell‐command[24m.

[1m19.131.  iproc‐env‐show (Not Bound)[0m

This  shows (as temporary screen output or in a buffer, depending
on the variable [4msend‐typeout‐to‐buffer[24m) the environment that will
be exported to interactive processes.

[1m19.132.  iproc‐env‐unset (Not Bound)[0m

This  takes  an argument that is the name of an environment vari‐
able and removes it from the list of environment  variables  that
will be passed to interactive processes.

[1m19.133.  jove‐compiled‐with (variable)[0m

This  is  a special, read‐only variable, containing the compiler,
flags and options used to build Jove (on Unix‐style machines)

[1m19.134.  jove‐features (variable)[0m

This is a special, read‐only variable, set with a colon‐delimited
list  of  all  the optional capabilities compiled into JOVE.  The
value will be something like
[4m:unix:abbr:bak:biff:cmtfmt:fcomp:iproc:pty:lisp:proc:spell:rec:job:id‐[0m
[4mchar:hl:tcap:ctype:[0m









78                       JOVE User Manual


[4munix[24m  specifies  a variety of traditional UNIX/POSIX capabilities
(case‐sensitive filenames, a Unix‐style filesystem),  as  opposed
to
[4mmsdos[24m or [4mwin32[24m which have case‐insensitive filesystems, for exam‐
ple.  The platform [4mibmpcdos[24m indicates specialization for the IBM‐
PC  platform, which in reality, is the only MS‐DOS form remaining
in existence (other non‐IBM‐PC platforms, like Heath/Zenith,  DEC
Rainbow,  etc  probably  do not exist anymore, as is probably the
case for the pre‐OSX classic [4mmac[24m platform).  Other tokens are
[4mabbr[24m (abbrev‐mode exists),
[4mbak[24m (backup‐files can be created),
[4mbiff[24m (ability to disable screen‐disruptions from  old  Unix‐style
mail notification),
[4mcmtfmt[24m (format C comments),
[4mfcomp[24m (filename completion),
[4miproc[24m (interactive shell processes),
[4mpipe[24m  (indicating  that  [4miproc[24m is implemented using pipes and the
[4mportsrv[24m helper program ), or
[4mpty[24m (indicating that [4miproc[24m is implemented using pseudo‐terminals,
available on any modern post‐4.2BSD platform),
[4mlisp[24m (lisp mode is available),
[4mproc[24m  (the ability to run non‐interactive subshell processes with
output to buffers, or switch entirely from JOVE to a child  shell
via  [4mpush‐shell[24m and then return to JOVE when that child shell ex‐
its),
[4mspell[24m (the ability to run a spell checker on the  contents  of  a
buffer, parse and modify the checker output and then step through
any misspelled words in the original buffer with ^X^N and ^X^P)
[4mrec[24m (periodically generate a recovery file so that  one  can  re‐
store  unsaved  changes from JOVE editors after a machine or pro‐
gram crash)
[4mjob[24m (BSD job control is supported, so one can suspend  JOVE  with
the  pause‐jove  command  and  return  to the shell that JOVE was
started from, and later resume JOVE using a  shell  command  like
[4mfg[24m),
[4mjsmall[24m (JOVE was built with smaller limits on the number of lines
it can support, probably only 32000)
[4midchar[24m (JOVE will attempt to optimize screen  display  using  in‐
sert/delete  character  modes and terminal control sequences), [4mhl[0m
(enable highlight‐mark capabiltiy to display a  small  underscore
for  the position of the mark, and enable the scroll‐bar capabil‐
ity in the buffer mode line),
[4mjtc[24m (uses  builtin  ANSI/VT1xx/XTERM  driver  rather  than  [4mterm‐[0m
[4mcap/terminfo/curses[24m),
[4mtcap[24m (termcap database code is enabled)
[4mtinfo[24m  (uses SystemV‐style terminfo rather than BSD‐style termcap
calls),
[4mctype[24m (uses the system ctype character classification rather than
JOVE builtin capability)
[4miso88591[24m (uses builtin JOVE tables for ISO‐8859‐1 character clas‐
sification rather than the system ctype capability).












                         JOVE User Manual                      79


[1m19.135.  jove‐linked‐with (variable)[0m

This is a special, read‐only  variable,  containing  the  linker,
flags and libraries used to build Jove (on Unix‐style machines)

[1m19.136.  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.137.  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.138.  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.139.  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.140.  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.141.  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
command.

[1m19.142.  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.143.  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‐









80                       JOVE User Manual


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.144.  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.145.  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.146.  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.

[1m19.147.  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.148.  lib‐dir‐pathname (variable)[0m

This  tells  JOVE where to find the machine‐dependent helper pro‐
grams: the [4mrecover[24m program, run when [4mjove[24m [4m‐r[24m is run after a crash
to try to recover unsaved files, and on some older machines with‐
out pseudo‐terminal support, the [4mportsrv[24m program,  which  handles
multiplexed  communication  with  the  keyboard  and  interactive
shells (if JOVE is compiled with SUBSHELL and  PIPEPROCS  config‐
ured)









                         JOVE User Manual                      81


[1m19.149.  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.150.  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.151.  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
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.











82                       JOVE User Manual


[1m19.152.  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.153.  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.154.  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.155.  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.156.  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.157.  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 de‐
faults to [1m/usr/spool/mail/$USER[22m, where “$USER” is set to your lo‐
gin name.

[1m19.158.  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 ac‐
cident.  The default value of this variable is [4moff[24m.

[1m19.159.  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.











                         JOVE User Manual                      83


[1m19.160.  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.  Or‐
dinarily,  when a command in a macro definition requires a trail‐
ing 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‐[0m
[4mmacro‐interactive[24m command just before typing the  argument  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.161.  mark‐threshold (variable)[0m

This  variable contains the number of lines point may move by be‐
fore 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‐file[0m
and [4mend‐of‐file[24m.

[1m19.162.  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.163.  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.164.  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
marked as “%x”.  Digits may be used between the ’%’ and  the  ’x’
to mean repeat that many times.  ’x’ may be:














84                       JOVE User Manual


          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.165.  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.166.  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.167.  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.

[1m19.168.  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.









                         JOVE User Manual                      85


[1m19.169.  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.170.  newline‐and‐indent (Linefeed)[0m

This behaves in any mode the same way as [4mnewline[24m does in Auto In‐
dent mode.

[1m19.171.  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.172.  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.173.  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.174.  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.

[1m19.175.  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.













86                       JOVE User Manual


[1m19.176.  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.177.  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.178.  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.179.  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.180.  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 \.

[1m19.181.  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.182.  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









                         JOVE User Manual                      87


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.183.  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.184.  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 re‐
turn to JOVE you type “fg” to the shell.

[1m19.185.  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  nu‐
meric argument.

[1m19.186.  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.187.  previous‐error (^X ^P)[0m

This is the same as [4mnext‐error[24m except it goes to the previous er‐
ror.  See [4mnext‐error[24m for documentation.

[1m19.188.  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.189.  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









88                       JOVE User Manual


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.190.  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.191.  print (Not Bound)[0m

This displays the value of a JOVE variable in the message line.

[1m19.192.  proc‐env‐export (Not Bound)[0m

This takes an argument of the form VARNAME=VALUE and replaces  or
sets  VARNAME  to that VALUE in the list of environment variables
that are passed to subshell commands  i.e.   [4mshell‐command[24m,  [4mcom‐[0m
[4mpile‐it[24m, [4mspell‐buffer[24m, etc.

[1m19.193.  proc‐env‐show (Not Bound)[0m

This  shows (as temporary screen output or in a buffer, depending
on the variable [4msend‐typeout‐to‐buffer[24m) the environment that will
be exported to subshell commands.

[1m19.194.  proc‐env‐unset (Not Bound)[0m

This  takes  an argument that is the name of an environment vari‐
able and removes it from the list of environment  variables  that
will be passed to subshell commands.

[1m19.195.  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.196.  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.197.  process‐bind‐to‐key (Not Bound)[0m

This command is identical to [4mbind‐to‐key[24m, except that it only af‐
fects your bindings when you are in a buffer attached to  an  in‐
teractive  process.   When you enter the process buffer, any keys
bound with this command will automatically take their new values.









                         JOVE User Manual                      89


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 win‐
dows are shown with a “Proc:” prefix in this manual  and  by  the
[4mapropos[24m and [4mdescribe‐bindings[24m commands.

[1m19.198.  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.199.  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.200.  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  Re‐
turn.   This  command  just  provides  a  way to send data to the
process without having to send a newline as well.

[1m19.201.  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









90                       JOVE User Manual


return to JOVE, simply exit the shell.

[1m19.202.  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 be‐
haves the same as C‐shell’s [4mpushd[24m.

[1m19.203.  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.204.  pwd (Not Bound)[0m

This prints the pathname of the working directory, as in the UNIX
[4mpwd[24m command.

[1m19.205.  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









                         JOVE User Manual                      91


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 af‐
ter  the  previous  match;  if  the  previous  match was an empty
string, the search is first advanced one character to prevent un‐
bounded repetition.

[1m19.206.  quit‐process (Proc: ^C ^\)[0m

Send  the  signal  SIGQUIT  to the interactive process in the se‐
lected buffer.  This is equivalent to sending the “quit”  charac‐
ter  (which  most  people have bound to ^\) to the process.  This
only works if you  are  in  a  buffer  bound  to  an  interactive
process.

[1m19.207.  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.208.  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.209.  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.210.  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.










92                       JOVE User Manual


[1m19.211.  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).

[1m19.212.  rename‐buffer (Not Bound)[0m

This lets you rename the selected buffer.

[1m19.213.  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.214.  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.215.  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.216.  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.217.  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[24m re‐
fuses  to  do  the save.  If you really do want to write the file
you must use [4mwrite‐file[24m.

[1m19.218.  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.219.  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









                         JOVE User Manual                      93


scrolling will affect the whole window.   See  also  the  [4mscroll‐[0m
[4mwidth[24m variable.

[1m19.220.  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,
the whole mode line remains inverted).

[1m19.221.  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.222.  scroll‐left (Not Bound)[0m

This scrolls the text in the active window to the left.  If a nu‐
meric argument is specified then the text is scrolled that number
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.223.  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.224.  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.










94                       JOVE User Manual


[1m19.225.  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.

[1m19.226.  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.227.  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.228.  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.229.  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.230.  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.












                         JOVE User Manual                      95


[1m19.231.  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.

[1m19.232.  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  in‐
stead of Space, and a new empty buffer will be created.

[1m19.233.  select‐buffer‐1 (Not Bound)[0m

This selects buffer number 1, if it exists.

[1m19.234.  select‐buffer‐10 (Not Bound)[0m

This selects buffer number 10, if it exists.

[1m19.235.  select‐buffer‐2 (Not Bound)[0m

This selects buffer number 2, if it exists.

[1m19.236.  select‐buffer‐3 (Not Bound)[0m

This selects buffer number 3, if it exists.

[1m19.237.  select‐buffer‐4 (Not Bound)[0m

This selects buffer number 4, if it exists.

[1m19.238.  select‐buffer‐5 (Not Bound)[0m

This selects buffer number 5, if it exists.

[1m19.239.  select‐buffer‐6 (Not Bound)[0m

This selects buffer number 6, if it exists.

[1m19.240.  select‐buffer‐7 (Not Bound)[0m

This selects buffer number 7, if it exists.

[1m19.241.  select‐buffer‐8 (Not Bound)[0m

This selects buffer number 8, if it exists.











96                       JOVE User Manual


[1m19.242.  select‐buffer‐9 (Not Bound)[0m

This selects buffer number 9, if it exists.

[1m19.243.  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.

[1m19.244.  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.245.  set (Not Bound)[0m

This sets a specified variable to a new value.

[1m19.246.  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.247.  share‐dir‐pathname (variable)[0m

This tells JOVE where to find the machine‐independent  configura‐
tion  files that it uses, typically some system‐wide [4mjove.rc[24m con‐
figuration files read on startup, the formatted help  information
for the [4mdescribe‐*[24m commands and the tutorial.  There is usually a
compiled‐in path that should be correct if Jove was properly  in‐
stalled.   This  path can also be overridden with the [4m‐s[24m command‐
line option.

[1m19.248.  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.













                         JOVE User Manual                      97


[1m19.249.  shell (Not Bound)[0m

This starts up an interactive shell in a window; if there is  al‐
ready  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.250.  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 at‐
taches that buffer to a window.  So, when you have only one  win‐
dow 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 in‐
stead.  If the buffer already exists it is first emptied  (unless
a  numeric  argument  is  specified).   If it’s already holding a
file, not some output from a previous command, JOVE asks  permis‐
sion  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.251.  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.252.  shell‐command‐to‐buffer (Not Bound)[0m

This  is  just  like [4mshell‐command[24m except it lets you specify the
buffer to use.

[1m19.253.  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.  Ac‐
tually,  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.













98                       JOVE User Manual


[1m19.254.  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.255.  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.256.  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.

[1m19.257.  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.258.  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.259.  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









                         JOVE User Manual                      99


responding  to an [4mexecute‐named‐command[24m command while in JOVE.  A
command can be optionally preceded by a numeric argument.   Lines
commencing  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  three  conditional
commands: [4mif[24m, [4mifenv[24m, and [4mifvar[24m.  The [4mif[24m command takes as an oper‐
and a shell command, which it runs.  If the command succeeds, the
commands 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.   Note  that  patterns  are anchored
matches from the left.  The [4mifvar[24m command takes as  operands  the
name  of  a JOVE variable and a pattern.  If the JOVE variable is
defined and its value matches the pattern, the [4mifvar[24m succeeds.

For example, here are some lines from the file [1mjove.rc[22m.

     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
     ifvar jove‐features .*:iproc:
       process‐bind‐to‐key interrupt‐process ^C^C
     endif

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 nu‐
meric  argument 1, there will be no complaint if this file cannot
be found.  If JOVE was compiled  with  interactive‐processes  en‐
abled (in which case the string [4m:iproc:[24m will be part of the read‐
only JOVE variable [4mjove‐features[24m), the command binds the key  se‐
quence  Control‐C  Control‐C  to  the  [4minterrupt‐process[24m command,
which sends the SIGINT signal to interactive shell.

[1m19.260.  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 de‐
fault is [4mon[24m.

[1m19.261.  spell‐command‐format (variable)[0m

This is the format specification string for a command which  will
run  a  spell  checker  on a specified file and produce a list of
misspelled words on the output. This variable (and related [4mspell‐[0m
[4mbuffer[24m  capability)  is  only  available  if  Jove  is built with









100                      JOVE User Manual


support for subshells.  The string must contain one  instance  of
the  specifier %s which will be replaced with the pathname of the
file to be checked.

[1m19.262.  spell‐buffer (Not Bound)[0m

This saves the current buffer and runs it through the UNIX  [4mspell[0m
command  (specified  by  the  variable [4mspell‐command‐format[24m ) 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.263.  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.264.  start‐remembering (Not Bound)[0m

This is just another name for the [4mbegin‐kbd‐macro[24m command.  It is
included for backward compatibility.

[1m19.265.  stop‐process (Not Bound)[0m

Send  the  signal  SIGTSTP  to the interactive process in the se‐
lected buffer.  This is equivalent to sending the “stop”  charac‐
ter  (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.266.  stop‐remembering (Not Bound)[0m

This  is  just another name for the [4mend‐kbd‐macro[24m command.  It is
included for backward compatibility.

[1m19.267.  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.268.  suspend‐jove (Not Bound)[0m

This is a synonym for [4mpause‐jove[24m.










                         JOVE User Manual                     101


[1m19.269.  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.270.  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.271.  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.272.  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.273.  teach‐jove (Not Bound)[0m

This  loads  the Jove tutorial from from the [1m~/teach‐jove [22mfile if
it was already saved there, else it loads the reference copy from
[1mSHAREDIR/teach‐jove [22minto a buffer that will save to [1m~/teach‐jove,[0m
replacing the old standalone [4mteachjove[24m command.  The  [4m‐T[24m  option,
if given to JOVE on the command line, will start JOVE up with the
tutorial loaded.

[1m19.274.  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.275.  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  re‐
cover 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
[1m.joverc  [22m(the  closer to the beginning the better), or as soon as
you start up JOVE before you read any files.










102                      JOVE User Manual


[1m19.276.  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 be‐
ginning 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.277.  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.278.  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.279.  update‐time‐frequency (variable)[0m

How  often the mode line is updated (and thus the time).  The de‐
fault is 30 seconds.

[1m19.280.  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.281.  version (Not Bound)[0m

Displays the version number of this JOVE.

[1m19.282.  visible‐bell (variable)[0m

If the terminal has a visible bell, use it instead of beeping.

[1m19.283.  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
you run the command again; it toggles.











                         JOVE User Manual                     103


[1m19.284.  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.285.  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.286.  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 ar‐
gument, the mode is turned on.  Word Abbrev mode lets you specify
a word (an abbreviation) and a phrase with which JOVE should sub‐
stitute  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 ex‐
pand 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  ma‐
jor  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 ex‐
pansion.  If it doesn’t find the word it is left untouched.  JOVE
tries  to  expand  words when you type a punctuation character or
Space or Return.  If you are in Auto Fill mode the expansion will
be filled as if you typed it yourself.









104                      JOVE User Manual


[1m19.287.  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.288.  wrap‐search (variable)[0m

If set, searches will “wrap around” the ends of  the  buffer  in‐
stead of stopping at the bottom or top.  The default is [4moff[24m.

[1m19.289.  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.290.  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.291.  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.292.  write‐modified‐files (^X ^M)[0m

This saves all the buffers that need saving.  If you supply a nu‐
meric argument it asks, for each buffer, whether you really  want
to save it.

[1m19.293.  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.294.  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
[4mread‐word‐abbrev‐file[24m.











                         JOVE User Manual                     105


[1m19.295.  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.296.  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.297.  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 un‐
done.

[1m19.298.  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.299.  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.300.  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.301.  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.302.  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 be‐
yond column 95 or row 95 will  be  misunderstood;  in  any  case,
mouse actions beyond column 223 or row 223 will be misunderstood.









106                      JOVE User Manual


[1m19.303.  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.304.  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.305.  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.306.  xt‐mouse‐up (^X m6)[0m

As the name implies, this command is normally bound  to  the  re‐
lease  of any button (XTerm does not specify which button was re‐
leased).  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 button  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‐region[24m.
If the most recently pressed button was button 2 and the CTRL and
SHIFT keys were down, this command performs a [4mkill‐region[24m.

[1m19.307.  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.308.  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  ro‐
tated  the  other way.  If you use this command enough times in a
row you will eventually get back to where you started.








