








                        [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 in‐
deed many of the basic commands are very similar, there  are
some  major  differences  between  the  two editors, and you
should not rely on their behaving identically.









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 system supports the [4mLo‐[0m
[4mcale[24m facility (as most modern ones do), you may set the  variable
[4mlc‐ctype[24m  to  “C” (the default, which corresponds to pure ASCII),
or to “iso_8859_1” (which corresponds  to  the  Latin‐1  alphabet
with a total of 192 printing characters, all of which JOVE should
be  able  to  display),  or to any other [4mLocale[24m available on your
system.  The  initial  value  of  [4mlc‐ctype[24m  is  taken  from  your
LC_CTYPE  environment  variable,  and  otherwise defaults to “C”.
With each [4mLocale[24m JOVE will know which of the extra characters are
upper‐case letters, lower‐case letters, etc.

[1m3.3.  Name Completion[0m

JOVE knows the names of all sorts of objects, such as  JOVE  Com‐
mands,  JOVE  Variables,  Macros, Keymaps, Buffers and even (with
some help from the directories) Files.  Since names must  be  en‐
tered 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 cus‐
tomized binding.  Throughout this manual, we shall always use the
standard bindings, followed by the full name (in  italics).   The
standard bindings are designed to work on any ASCII keyboard, and
can  always be used so long as you (or your system administrator)
have not actually changed them.  But they are hard  to  remember,
so  you  may well prefer to use your own, particularly if you 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 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‐file[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 exist‐
ing buffer.  You can make changes, and then save the file by typ‐
ing ˆX ˆS ([4msave‐file[24m).  This makes the changes permanent and  ac‐
tually  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 issue the command ESC S ([4mpause‐jove[24m), do  your
work within your shell, and then return to JOVE using the [4mfg[24m com‐
mand  to  resume editing at the point where you paused.  Alterna‐
tively, for this sort of situation, you might consider  using  an
[4minteractive[24m  [4mshell[24m (that is, a shell in a JOVE window) which lets
you use the editor to issue your commands  and  manipulate  their
output,  while  never  leaving  the editor (the interactive shell
feature is described later).

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

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













                         JOVE 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,
ESC < sets the mark first, so that you can use ˆU ˆ@ or ˆX ˆX  to









14                       JOVE User Manual


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
spaces or line‐separators.  Commands that can destroy significant
amounts  of nontrivial data generally kill.  A command’s name and
description will use the words [4mkill[24m or [4mdelete[24m  to  say  which  it
does.

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

[1m6.3.2.  Deletion[0m

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

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

The  commonest  kill  command  is  ˆW  ([4mkill‐region[24m), which kills











                         JOVE User Manual                      15


everything between point and the mark*.  With this  command,  you
can  kill  and  save  contiguous characters, if you first set the
mark at one end of them and then go to the other end.

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

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

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

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

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

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

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

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

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

Another kill command is the ˆK command ([4mkill‐to‐end‐of‐line[24m).  If
issued at the beginning of a line, it kills all the text  on  the
line,  leaving  it  blank.   If given in the middle of a line, it
kills all the text up to the end of the line.  If given on a line
that is empty or contains only white space (blanks and tabs)  the
line  disappears.   If  ˆK is done at the end of a line, it joins
that line and the next line.  As a consequence, if you go to  the
front  of a non‐blank line and type two ˆK’s, the line disappears
completely (but be careful, because one ˆK is sufficient  to  re‐
move an empty line).


───────────
*Often users switch this binding from ˆW to ˆX ˆK because it
is too easy to hit ˆW accidentally.









16                       JOVE User Manual


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.

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









                         JOVE User Manual                      17


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
buffers, searches can take several (sometimes many) seconds.

JOVE remembers the last search string you used, so if you want to
search for the same string again you can  type  ˆS <return>.   If
you  mistyped  the  last  search string, you can type ˆS followed









18                       JOVE User Manual


immediately by ˆR (which is [4mnot[24m  the  [4msearch‐reverse[24m  command  in
this  context)  which inserts the default search string, and then
you can fix it up.

Note that the precise interpretation of the search string is  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
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.









                         JOVE User Manual                      19


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.

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









20                       JOVE User Manual


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

ˆW
to  delete  the FOO, and then start editing the buffer.  When you
are finished editing whatever is to replace the FOO, exit the re‐
cursive editing level with ˆX ˆC ([4mexit‐jove[24m)  and  the  [4mquery‐re‐[0m
[4mplace[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  asking,  as  in  [4mreplace‐[0m
[4mstring[24m.

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

ˆL
redraw the screen.

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

When  we  use  the searching and replacement facilities described
above, JOVE can search for  patterns  using  [4mregular‐expressions[24m.
The handling of regular‐expressions in JOVE is somewhat like that
of  [4med(1)[24m or [4mvi(1)[24m, but with some notable additions.  The precise
behavior depends on the setting of  the  variable  [4mmatch‐regular‐[0m









                         JOVE User Manual                      21


[4mexpressions[24m.  If this variable is [4mon[24m, we use true [4mregular‐expres‐[0m
[4msions[24m.   If  it is [4moff[24m, we have just [4msimple‐expressions[24m.  In what
follows, the term [4mexpression[24m should be interpreted as  simple‐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:

              [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









22                       JOVE User Manual


              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$”
              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









                         JOVE User Manual                      23


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

[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









24                       JOVE User Manual


              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.

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









                         JOVE User Manual                      25


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.

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











26                       JOVE User Manual


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

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









                         JOVE User Manual                      27


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











28                       JOVE User Manual


[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
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 [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[0m
buffer  (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  recursive  edit,
and  JOVE  now  positions you at the first misspelled word in the
original buffer.  Correct that mistake with the usual editor com‐
mands.  Then you can go forward to  each  other  misspelled  word
with  ˆX ˆN ([4mnext‐error[24m) or backward with ˆX ˆP ([4mprevious‐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









                         JOVE User Manual                      29


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









30                       JOVE User Manual


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
buffer’s [4mbuffer[24m [4mnumber[24m.  You can select a buffer  by  typing  its
number  in  place  of  its  name.   If  a buffer with that number
doesn’t already exist, a new buffer is created with  that  number
as its name.

If  several buffers have modified text in them, you can save them
with ˆX ˆM ([4mwrite‐modified‐files[24m).  This finds  all  the  buffers
that  need  saving  and then saves them.  Saving the buffers this
way is much easier and more efficient (but more  dangerous)  than
selecting  each  one  and  typing ˆX ˆS ([4msave‐file[24m).  If you give
ˆX ˆM an argument, JOVE will ask for confirmation  before  saving
each buffer.

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

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

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

Sometimes you will change a buffer by accident.  Even if you undo
the  effect  of the change by editing, JOVE still knows that “the
buffer has been changed”.  You can  tell  JOVE  to  pretend  that
there  have  been no changes with the ESC ˜ command ([4mmake‐buffer‐[0m
[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









                         JOVE User Manual                      31


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
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
buffer  so that you can edit them.  To visit a file, use the com‐
mand ˆX ˆV or ˆX ˆR ([4mvisit‐file[24m), followed by the filename.   The
name of the new file will appear in the mode line but the name of
the buffer will be unchanged.

If  you alter one file and then visit another in the same buffer,
JOVE offers to save the old one.  If you answer YES (or  y),  the
old  file  is saved; if you answer NO (or n), all the changes you
have made to it since the last save are  lost.   You  should  not
type ahead after a file visiting command, because your type‐ahead
might  answer  an unexpected question in a way that you would 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.










32                       JOVE User Manual


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











                         JOVE User Manual                      33


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.


┌──────────────────────────────────────────────────────┐│
│ #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









34                       JOVE User Manual


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.

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’









                         JOVE User Manual                      35


buffers  do  not change.  Likewise, the ˆX ˆF ([4mfind‐file[24m) command
reads a new file into a new buffer in the active window.

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









36                       JOVE User Manual


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 por‐
tion so as to put point that many lines from the top.   An  argu‐
ment  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









                         JOVE User Manual                      37


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  You
can  run  commands  from  JOVE  and  catch  their  output in JOVE
buffers.  Two mechanisms are provided, [4minteractive[24m [4mprocesses[24m  and
[4mnon‐interactive[24m [4mprocesses[24m.

[1m12.1.  Interactive Processes[0m

With  most modern systems, JOVE has the capability of running in‐
teractive processes, accepting your input and capturing your out‐
put in a buffer.

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

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

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

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

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

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

To  run a command interactively from JOVE type ESC X [4mi‐shell‐com‐[0m
[4mmand[24m <command‐name><return>.  For example, to run the desk calcu‐
lator, you do:









38                       JOVE User Manual


     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.

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.










                         JOVE User Manual                      39


            [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  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
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 command from JOVE just type ˆX ! <command‐name><return>.
For  example,  to  get a list of all the users on the system, you
do:

     ˆX ! who<return>

Then JOVE picks a buffer in which the  output  from  the  command
will  be  placed,  named  after  the command.  E.g., “who” uses a
buffer called [1mwho[22m; “ps alx” uses [1mps[22m; and “egrep ‐n foo ∗.c”  uses
[1megrep[22m.   If  JOVE  wants  to  use a buffer that already exists it
first erases the old contents.  If the buffer it selects holds  a
file,  not  output  from a previous shell command, you must first
delete that buffer with ˆX K ([4mdelete‐buffer[24m).  There are variants









40                       JOVE User Manual


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.

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

When the command finishes, JOVE puts you back in  the  window  in
which  you  started.  Then it prints a message indicating whether
or not the command completed successfully in its (the  command’s)
opinion.   That is, if the command had what it considers an error
(or you interrupt it with ˆ]) JOVE will print an appropriate mes‐
sage.

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

ˆX ! ([4mshell‐command[24m) is useful for running commands that do  some
output  and  then  exit.  So you could type ˆX ! spell <filename>
and it would create a  buffer  “spell”,  fill  it  with  all  the
spelling mistakes in <filename> and display it in a window.  How‐
ever,  as  we have already seen, there is a built‐in JOVE command
to do this job (and more) which, behind the  scenes,  issues  ex‐
actly  that  [4mshell‐command[24m.  Thus, the built in usage of this fa‐
cility 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 [4mmake[24m program into a buffer.  If you need a
special command or want to pass arguments to [4mmake[24m, run [4mcompile‐it[0m
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  sub‐
ject of the next section.











                         JOVE User Manual                      41


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 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
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
buffer are specified in the variable [4merror‐format‐string[24m.

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

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

     [4m%[24m [4mjove[24m [4m−p[24m [4merrs[0m

[1m12.2.1.2.  Filtering[0m

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

Suppose your buffer contains a table.  You make  this  table  the
region  (put mark at the start of it and point at the end).  Type
ESC X [4mfilter‐region[24m [4msort[24m<return> (or any  other  command).   Your
table  will be passed through the [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









42                       JOVE User Manual


move around the 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.

[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









                         JOVE User Manual                      43


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

[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  systems  provide  a  program  called
[4mctags(1)[24m,  which  takes  a  set  of  source  files  and looks for









44                       JOVE User Manual


function 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 defin‐
ition of the function.  There is another version of this command,
[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
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










                         JOVE User Manual                      45


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

[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









46                       JOVE User Manual


customarily 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.
            [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‐[0m
[4mfile[24m to write the list to a  file  and  [4mread‐word‐abbrev‐file[24m  to
read  it  back  again (this command might be used in your [1m.joverc[0m
file) .

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

     jonathan’s own version of EMACS

but if you type “Jove” you will get

     Jonathan’s own version of EMACS

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

     Jonathan’s Own Version Of EMACS

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

[1m15.  Macros[0m

ˆX (        [4mbegin‐kbd‐macro[24m            Start recording your commands.
ˆX )        [4mend‐kbd‐macro[24m              Stop recording your commands.










                         JOVE User Manual                      47


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.

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









48                       JOVE User Manual


executed  upon  typing  the  abbrev word you have specified —— it
will get expanded as well unless it was an abbreviation for noth‐
ing).

[1m16.  Customizing Jove[0m

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

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

The JOVE distribution comes with a recommended [1mjove.rc  [22mfile  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









                         JOVE User Manual                      49


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  ig‐
nored 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.











50                       JOVE User Manual


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
which  commands [4mare[24m bound are hard to remember (although at least
compatible across all terminals) whilst all sorts of  interesting
keys  on  the  particular keyboard remain unused.  For both these
reasons, JOVE makes it possible to [4mbind[24m commands to keys.

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

            [4mlocal‐bind‐to‐key[24m           As  bind‐to‐key,  for  use  in  the  selected
                                        buffer only.
            [4mlocal‐bind‐macro‐to‐key[24m     As bind‐macro‐to‐key, for use in the selected
                                        buffer only.
            [4mlocal‐bind‐keymap‐to‐key[24m    As  bind‐keymap‐to‐key,  for  use  in the 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









                         JOVE User Manual                      51


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












52                       JOVE User Manual


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

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.










                         JOVE User Manual                      53


%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
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
windows and then change point).

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

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

When running under [4mxjove[24m there are  some  additional  facilities.
Firstly,  the  setting  when  pointing into the mode line is more









54                       JOVE User Manual


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










                         JOVE User Manual                      55


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
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 In‐
dent mode, the [4mnewline[24m command (which is normally  bound  to  Re‐
turn) acts identically to [4mnewline‐and‐indent[24m: the new line is in‐
dented  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 be‐
cause 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
whichever  of  “([{” would match one of “)]}” if you were to type
it right then.  Arguments are accepted,  and  negative  arguments
search forwards as in [4mdown‐list[24m.

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

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

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

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

[1m19.20.  begin‐kbd‐macro (ˆX ()[0m

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













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 [1mUNIX [22mcommand [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‐[0m
[4mbuffer[24m command and the [4mkill‐some‐buffers[24m command.

[1m19.55.  delete‐current‐window (ˆX D))[0m

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

[1m19.56.  delete‐next‐character (ˆD)[0m

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

[1m19.57.  delete‐other‐windows (ˆX 1)[0m

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

[1m19.58.  delete‐previous‐character (DEL and ˆH)[0m

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









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 [1mUNIX [22mwith 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 [1mUNIX [22mcommand, 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 [1mUNIX [22mC 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 [1mUNIX [4m[22msort[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 [1mUNIX [22mcommand [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
buffer.  If the buffer is currently being displayed in one of the
windows, that window is selected instead.

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

When  point is positioned on a “(”, this re‐indents that LISP 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
buffers 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
buffer.   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 [1mUNIX [22mcommand; “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 [1mUNIX [22msys‐
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
[1mUNIX [4m[22mgrep[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[0m
processes.   The  default  is  “%  ”, the default C‐shell prompt.
This is actually a regular expression search string.  So you  can
set  it  to be more than one thing at once using the \| operator.
For instance, for LISP hackers, the prompt can be

     "% \|‐> \|<[0‐9]>: ".

[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 [1mUNIX[22m, 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 re‐
turn to JOVE, simply exit the shell.









90                       JOVE User Manual


[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 [1mUNIX[0m
[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
will reverse pairs of comma‐separated numbers:










                         JOVE User Manual                      91


     : 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 [1mUNIX [22mcommand 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 [1mUNIX [22mshells).  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
operand 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
commands after any [4melse[24m, up until an [4mendif[24m, are executed.  Condi‐
tionals  nest  in  the  normal  way.   The [4mifenv[24m command takes as
operands the name of an environment variable and a  pattern.   If
the  environment  variable  is  defined and its value matches the
pattern, the [4mifenv[24m succeeds.  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 [1mUNIX  [4m[22mspell[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 de‐
finitions.  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
buffer.  Without a numeric  argument,  the  command  toggles  the
mode;  with  a zero argument, the mode is turned off; with a non‐
zero argument, the mode is turned on.  Word Abbrev mode lets  you
specify  a  word  (an  abbreviation) and a phrase with which JOVE
should substitute the abbreviation.  You can use this  to  define
words  to  expand into long phrases, e.g., “jove” can expand into
“Jonathan’s Own Version of Emacs”; another common use is defining
words that you often misspell in the same way, e.g.,  “thier”  =>
“their” or “teh” => “the”.  See the information on the [4mauto‐case‐[0m
[4mabbrev[24m variable.

There  are  two kinds of abbreviations: mode specific and global.
If you define a Mode specific abbreviation in C mode, it will 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.








