JOVE Manual for UNIX Users

     Jonathan Payne (revised for 4.3BSD by Doug Kingston and Mark Seiden)


   1.  Introduction

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

   JOVE is considered a display editor  because  normally  the  text  being
   edited is visible on the screen and is updated automatically as you type
   your commands.

   It's considered a real-time editor because the display is  updated  very
   frequently, usually after each character or pair of characters you type.
   This minimizes the amount of information you must keep in your  head  as
   you edit.

   JOVE is advanced because it provides facilities that  go  beyond  simple
   insertion and deletion:  filling of text; automatic indentations of pro-
   grams; view more than one file at once; and dealing in terms of  charac-
   ters, words, lines, sentences and paragraphs.  It is much easier to type
   one command meaning ``go to the end of the paragraph'' than to find  the
   desired spot with repetition of simpler commands.

   Self-documenting means that at almost any time you can easily  find  out
   what  a  command  does,  or  to  find all the commands that pertain to a
   topic.

   Customizable means that you can change the definition of  JOVE  commands
   in  little ways.  For example, you can rearrange the command set; if you
   prefer to use arrow keys for the four basic cursor motion commands  (up,
   down,  left and right), you can.  Another sort of customization is writ-
   ing new commands by combining built in commands.

   2.  The Organization of the Screen

   JOVE divides the screen up into several sections.  The biggest of  these
   sections  is  used  to display the text you are editing.  The terminal's
   cursor shows the position of point, the location at which editing  takes
   place.   While  the cursor appears to point at a character, point should
   be thought of as between characters; it points before the character that
   the  cursor appears on top of.  Terminals have only one cursor, and when
   output is in progress it must appear where the  typing  is  being  done.
   This  doesn't mean that point is moving; it is only that JOVE has no way
   _________________________
   *JOVE stands for Jonathan's Own Version of Emacs.
   +Although JOVE is meant to be compatible with EMACS, and  indeed  many
   of  the  basic  commands  are  very  similar,  there  are  some  major
   differences between the two editors, and you should not rely on  their
   behaving identically.










   USD:17-2                                      JOVE Manual for UNIX Users


   of showing you the location of point except when the terminal is idle.

   The lines of the screen are usually available for  displaying  text  but
   sometimes  are  pre-empted  by  typeout from certain commands (such as a
   listing of all the editor commands).  Most of the time, output from com-
   mands  like  these  is  only desired for a short period of time, usually
   just long enough to glance at it.  When you have finished looking at the
   output, you can type Space to make your text reappear.  (Usually a Space
   that you type inserts itself, but when there is typeout on  the  screen,
   it  does  nothing but get rid of that).  Any other command executes nor-
   mally, after redrawing your text.

   2.1.  The Message Line

   The bottom line on the screen, called the message line, is reserved  for
   printing  messages  and  for  accepting  input  from  the  user, such as
   filenames or search strings.  When JOVE prompts for  input,  the  cursor
   will  temporarily  appear  on the bottom line, waiting for you to type a
   string.  When you have finished typing your input, you can type a Return
   to  send  it to JOVE.  If you change your mind about running the command
   that is waiting for input, you can type Control-G to abort, and you  can
   continue with your editing.

   When JOVE is prompting for a filename, all the usual editing  facilities
   can  be  used to fix typos and such; in addition, JOVE has the following
   extra functions:

   ^N   Insert the next filename from the argument list.

   ^P   Insert the previous filename from the argument list.

   ^R   Insert the full pathname of the file in the current buffer.

   Sometimes you will see --more-- on the message line.  This happens  when
   typeout  from a command is too long to fit in the screen.  It means that
   if you type a Space the next screenful of typeout will be  printed.   If
   you  are not interested, typing anything but a Space will cause the rest
   of the output to be discarded.  Typing ^G will discard  the  output  and
   print  Aborted  where  the  --more-- was.  Typing any other command will
   discard the rest of the output and also execute the command.

   The message line and the list of filenames from the shell  command  that
   invoked  JOVE  are  kept  in a special buffer called Minibuf that can be
   edited like any other buffer.

   2.2.  The Mode Line

   At the bottom of the screen, but above the message  line,  is  the  mode
   line.  The mode line format looks like this:

           JOVE (major minor)   Buffer: bufr  "file" *

   major is the name of the current major mode.  At any time, JOVE  can  be
   in  only  one major mode at a time.  Currently there are only four major









   JOVE Manual for UNIX Users                                      USD:17-3


   modes: Fundamental, Text, Lisp and C.

   minor is a list of the minor modes that are  turned  on.   Abbrev  means
   that  Word Abbrev mode is on; AI means that Auto Indent mode is on; Fill
   means that Auto Fill mode is on; OvrWt means that Over Write mode is on.
   Def  means  that  you  are  in the process of defining a keyboard macro.
   This is not really a mode, but it's useful to be reminded about it.  The
   meanings of these modes are described later in this document.

   bufr is the name of the currently selected buffer.  Each buffer has  its
   own  name  and  holds  a  file  being  edited; this is how JOVE can hold
   several files at once.  But at any given time you are editing  only  one
   of  them,  the selected buffer.  When we speak of what some command does
   to ``the buffer,'' we are talking about the currently  selected  buffer.
   Multiple  buffers  makes it easy to switch around between several files,
   and then it is very useful that the mode line tells you  which  one  you
   are  editing  at  any  time.  (You will see later that it is possible to
   divide the screen  into  multiple  windows,  each  showing  a  different
   buffer.  If you do this, there is a mode line beneath each window.)

   file is the name of the file that you are editing.  This is the  default
   filename for commands that expect a filename as input.

   The asterisk at the end of the mode line means that there are changes in
   the  buffer  that  have not been saved in the file.  If the file has not
   been changed since it was read in or saved, there is no asterisk.

   3.  Command Input Conventions


   3.1.  Notational Conventions for ASCII Characters

   In this manual, ``Control'' characters (that  is,  characters  that  are
   typed  with  the  Control  key  and some other key at the same time) are
   represented by ``^'' (caret) followed by another character.  Thus, ^A is
   the  character  you  get when you type A with the Control key (sometimes
   labeled CTRL) down.  Most control characters when present  in  the  JOVE
   buffer  are  displayed  this  way.   Rubout (or DEL) is displayed as ^?,
   escape as ^[.

   3.2.  Command and Filename Completion

   When you are typing the name of a  JOVE  command,  you  need  type  only
   enough letters to make the name unambiguous.  At any point in the course
   of typing the name, you can type question mark (?) to see a list of  all
   the commands whose names begin with the characters you've already typed;
   you can type Space to have JOVE supply as many characters as it can;  or
   you  can type Return to complete the command if there is only one possi-
   bility.  For example, if you have typed the letters ``au'' and you  then
   type a question mark, you will see the list













   USD:17-4                                      JOVE Manual for UNIX Users



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

   If you type a Return at this point, JOVE will complain  by  ringing  the
   bell,  because  the  letters you've typed do not unambiguously specify a
   single command.  But if you type Space, JOVE will supply the  characters
   ``to-''  because  all  commands  that begin ``au'' also begin ``auto-.''
   You could then type the letter ``f'' followed by either Space or Return,
   and JOVE would complete the entire command.

   Whenever JOVE is prompting you for a filename, say in the find-file com-
   mand,  you also need only type enough of the name to make it unambiguous
   with respect to files that already exist.  In this case,  question  mark
   and  Space work just as they do in command completion, but Return always
   accepts the name just as you've typed it,  because  you  might  want  to
   create  a new file with a name similar to that of an existing file.  The
   variable bad-filename-extensions contains a list of words  separated  by
   spaces  which  are to be considered bad filename extensions, and so will
   not be counted in filename completion.  The default is ``.o'' so if  you
   have  jove.c  and  jove.o in the same directory, the filename completion
   will not complain of an ambiguity because it will ignore jove.o.


   4.  Commands and Variables

   JOVE is composed of commands which have long names  such  as  next-line.
   Then  keys  such  as  ^N  are  connected to commands through the command
   dispatch table.  When we say that ^N moves the cursor down  a  line,  we
   are  glossing  over a distinction which is unimportant for ordinary use,
   but essential for simple customization:  it  is  the  command  next-line
   which knows how to move a down line, and ^N moves down a line because it
   is connected to that command.  The name for this connection is  a  bind-
   ing; we say that the key ^N is bound to the command next-line.

   Not all commands are bound to keys.  To  invoke  a  command  that  isn't
   bound  to  a key, you can type the sequence ESC X, which is bound to the
   command execute-named-command.  You will then be able to type  the  name
   of whatever command you want to execute on the message line.

   Sometimes the description of a command will say ``to  change  this,  set
   the  variable  mumble-foo.''   A  variable  is a name used to remember a
   value.  JOVE contains variables which are there so that you  can  change
   them if you want to customize.  The variable's value is examined by some
   command, and changing that value makes the command  behave  differently.
   Until  you  are  interesting  in  customizing  JOVE, you can ignore this
   information.

   4.1.  Prefix Characters

   Because there are more command names than  keys,  JOVE  provides  prefix
   characters  to  increase  the  number  of  commands  that can be invoked









   JOVE Manual for UNIX Users                                      USD:17-5


   quickly and easily.  When you type a prefix character JOVE will wait for
   another  character  before deciding what to do.  If you wait more than a
   second or so, JOVE will print the prefix character on the  message  line
   as  a  reminder and leave the cursor down there until you type your next
   character.  There are two prefix characters built into JOVE:  Escape and
   Control-X.   How the next character is interpreted depends on which pre-
   fix character you typed.  For example, if you type Escape followed by  B
   you'll run backward-word, but if you type Control-X followed by B you'll
   run select-buffer.  Elsewhere in this manual, the Escape  key  is  indi-
   cated  as  ``ESC,'' which is also what JOVE displays on the message line
   for Escape.

   4.2.  Help

   To get a list of keys and their associated  commands,  you  type  ESC  X
   describe-bindings.    If  you  want  to  describe  a  single  key,  ^X-?
   (describe-key) will work.  A description of  an  individual  command  is
   available  by  using ESC ? (describe-command), and descriptions of vari-
   ables by using  ESC X describe-variable.  If you can't remember the name
   of  the thing you want to know about, ESC H (apropos) will tell you if a
   command or variable has a given string in its name.  For example, ESC  H
   describe  will  list  the  names of the four describe commands mentioned
   briefly in this section.

   5.  Basic Editing Commands


   5.1.  Inserting Text

   To insert printing characters into the text you are editing,  just  type
   them.   All  printing  characters you type are inserted into the text at
   the cursor (that is, at point), and the cursor moves forward.  Any char-
   acters  after the cursor move forward too.  If the text in the buffer is
   FOOBAR, with the cursor before the B, then  if  you  type  XX,  you  get
   FOOXXBAR, with the cursor still before the B.

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

   To end a line and start typing a new one, type Return.  Return  operates
   by  inserting a line-separator, so if you type Return in the middle of a
   line, you break the line in two.  Because a  line-separator  is  just  a
   single  character,  you can type ^H at the beginning of a line to delete
   the line-separator and join it with the preceding line.

   As a special case, if you type Return at the end of a line and there are
   two  or  more  empty  lines  just below it, JOVE does not insert a line-
   separator but instead merely moves  to  the  next  (empty)  line.   This
   behavior is convenient when you want to add several lines of text in the
   middle of a buffer.  You can use the ^O (newline-and-backup) command  to
   ``open''  several empty lines at once; then you can insert the new text,









   USD:17-6                                      JOVE Manual for UNIX Users


   filling up these empty lines.  The advantage is that JOVE does not  have
   to  redraw the bottom part of the screen for each Return you type, as it
   would ordinarily.  That ``redisplay'' can be both slow and distracting.

   If you add too many characters to one line,  without  breaking  it  with
   Return, the line will grow too long to display on one screen line.  When
   this happens, JOVE puts an  ``!''  at  the  extreme  right  margin,  and
   doesn't bother to display the rest of the line unless the cursor happens
   to be in it.  The ``!'' is not  part  of  your  text;  conversely,  even
   though you can't see the rest of your line, it's still there, and if you
   break the line, the ``!'' will go away.

   Direct insertion works for printing  characters  and  space,  but  other
   characters act as editing commands and do not insert themselves.  If you
   need to insert a control character, Escape, or ^H, you must first  quote
   it by typing the ^ ~ (quoted-insert) command first.

   5.2.  Moving the Cursor

   To do more than insert characters, you have to know how to move the cur-
   sor.  Here are a few of the commands for doing that.

   ^A             Move to the beginning of the line.

   ^E             Move to the end of the line.

   ^F             Move forward over one character.

   ^B             Move backward over one character.

   ^N             Move down one line, vertically.  If you start in the mid-
                  dle of one line, you end in the middle of the next.

   ^P             Move up one line, vertically.

   ESC <          Move to the beginning of the entire buffer.

   ESC >          Move to the end of the entire buffer.

   ESC ,          Move to the beginning of the visible window.

   ESC .          Move to the end of the visible window.

   5.3.  Erasing Text


   ^H             Delete the character before the cursor.

   ^D             Delete the character after the cursor.

   ^K             Kill to the end of the line.

   You already know about the ^H command which deletes the character before
   the  cursor.   Another  command,  ^D,  deletes  the  character after the









   JOVE Manual for UNIX Users                                      USD:17-7


   cursor, causing the rest of the text on the line to shift left.   If  ^D
   is  typed  at  the end of a line, that line and the next line are joined
   together.

   To erase a larger amount of text, use the ^K command, which kills a line
   at a time.  If ^K is done at the beginning or middle of a line, it kills
   all the text up to the end of the line.  If ^K is done at the end  of  a
   line,  it  joins  that  line and the next line.  If ^K is done twice, it
   kills the rest of the line and the line separator also.

   5.4.  Files - Saving Your Work

   The commands above are sufficient for creating text in the JOVE  buffer.
   The  more  advanced  JOVE commands just make things easier.  But to keep
   any text permanently you must put it in a file.  Files are  the  objects
   which UNIX- uses for storing data for a length of time.  To tell JOVE to
   read  text into a file, choose a filename, such as foo.bar, and type ^X-
   ^R foo.bar<return>.  This reads the file foo.bar so  that  its  contents
   appear  on  the screen for editing.  You can make changes, and then save
   the file by typing ^X-S (save-file).  This makes the  changes  permanent
   and actually changes the file foo.bar.  Until then, the changes are only
   inside JOVE, and the file foo.bar is not really changed.   If  the  file
   foo.bar  doesn't  exist, and you want to create it, read it as if it did
   exist.  When you save your text with ^X-S the file will be created.

   5.5.  Exiting and Pausing - Leaving JOVE

   The command ^X-^C (exit-jove) will terminate the JOVE session and return
   to  the shell.  If there are modified but unsaved buffers, JOVE will ask
   you for confirmation, and you  can  abort  the  command,  look  at  what
   buffers  are  modified  but unsaved using ^X-^B (list-buffers), save the
   valuable ones, and then exit.  If what you want  to  do,  on  the  other
   hand,  is  preserve  the  editing  session  but return to the shell tem-
   porarily you can (under Berkeley UNIX only)  issue  the  command  ESC  P
   (pause-jove),  do your UNIX work within the c-shell, then return to JOVE
   using the fg command to resume editing at the point  where  you  paused.
   For this sort of situation you might consider using an interactive shell
   (that is, a shell in a JOVE window) which lets you use  editor  commands
   to  manipulate your UNIX commands (and their output) while never leaving
   the editor.  (The interactive shell feature is described below.)

   5.6.  Giving Numeric Arguments to JOVE Commands

   Any JOVE command can be given a numeric argument.  Some commands  inter-
   pret  the  argument as a repetition count.  For example, giving an argu-
   ment of ten to the ^F  command  (forward-character)  moves  forward  ten
   characters.   With these commands, no argument is equivalent to an argu-
   ment of 1.

   Some commands use the value of the argument, but do  something  peculiar
   (or  nothing) when there is no argument.  For example, ESC G (goto-line)
   _________________________
   - UNIX is a trademark of Bell Laboratories.










   USD:17-8                                      JOVE Manual for UNIX Users


   with an argument n goes to the beginning of the n'th line.   But  ESC  G
   with  no  argument  prompts  for the line number.  Similarly, ^K with an
   argument  kills  that  many  lines,  including  their  line  separators.
   Without  an  argument, ^K when there is text on the line to the right of
   the cursor kills that text; when there is no text after the  cursor,  ^K
   deletes the line separator.

   The fundamental way of specifying an argument is to use ESC followed  by
   the  digits  of  the  argument, for example, ESC 123 ESC G to go to line
   123. Negative arguments are allowed, although not all  of  the  commands
   know what to do with one.

   Typing ^U means do the next command four times.  Two such ^U's  multiply
   the next command by sixteen.  Thus, ^U ^U ^F moves forward sixteen char-
   acters.  This is a good way to move  forward  quickly,  since  it  moves
   about  1/4  of a line on most terminals.  Other useful combinations are:
   ^U ^U ^N (move down a good fraction of the screen), ^U ^U ^O  (make  ``a
   lot''  of blank lines), and ^U ^K (kill four lines - note that typing ^K
   four times would kill 2 lines).

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

   5.7.  The Mark and the Region

   In general, a command that processes an arbitrary  part  of  the  buffer
   must know where to start and where to stop.  In JOVE, such commands usu-
   ally operate on the text between point and the mark.  This body of  text
   is  called the region.  To specify a region, you set point to one end of
   it and mark at the other.  It doesn't matter which one comes earlier  in
   the text.

   ^@             Set the mark where point is.

   ^X ^X          Interchange mark and point.

   For example, if you wish to convert part of the  buffer  to  all  upper-
   case,  you  can use the ^X ^U command, which operates on the text in the
   region.  You can first go to the beginning of the text  to  be  capital-
   ized, put the mark there, move to the end, and then type ^X ^U.  Or, you
   can set the mark at the end of the text, move to the beginning, and then
   type ^X ^U.  ^X ^U runs the command case-region-upper, whose name signi-
   fies that the region, or everything between point and  mark,  is  to  be
   capitalized.

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

   Since terminals have only one cursor, there is no way for JOVE  to  show









   JOVE Manual for UNIX Users                                      USD:17-9


   you  where  the mark is located.  You have to remember.  The usual solu-
   tion to this problem is to set the mark and then use it soon, before you
   forget  where it is.  But you can see where the mark is with the command
   ^X ^X which puts the mark where point was and point where mark was.  The
   extent  of  the region is unchanged, but the cursor and point are now at
   the previous location of the mark.

   5.8.  The Ring of Marks

   Aside from delimiting the region, the mark is also useful for  remember-
   ing  a  spot that you may want to go back to.  To make this feature more
   useful, JOVE remembers 16 previous locations of the mark.  Most commands
   that  set  the  mark  push the old mark onto this stack.  To return to a
   marked location, use ^U ^@.  This moves point to where the mark was, and
   restores  the  mark  from the stack of former marks.  So repeated use of
   this command moves point to all of the old marks on the  stack,  one  by
   one.   Since  the  stack  is actually a ring, enough uses of ^U ^@ bring
   point back to where it was originally.

   Some commands whose primary purpose is to move point  a  great  distance
   take  advantage of the stack of marks to give you a way to undo the com-
   mand.  The best example is ESC <, which moves to the  beginning  of  the
   buffer.   If  there  are more than 22 lines between the beginning of the
   buffer and point, ESC < sets the mark first, so that you can use  ^U  ^@
   or  ^X  ^X  to  go back to where you were.  You can change the number of
   lines from 22 since it is kept in the variable mark-threshold.  By  set-
   ting  it to 0, you can make these commands always set the mark.  By set-
   ting it to a very large number you can prevent these commands from  ever
   setting  the  mark.  If a command decides to set the mark, it prints the
   message [Point pushed].

   5.9.  Killing and Moving Text

   The most common way of moving or copying text with JOVE is to  kill  it,
   and  get it back again in one or more places.  This is very safe because
   the last several pieces of killed text are all  remembered,  and  it  is
   versatile,  because  the  many  commands for killing syntactic units can
   also be used for moving those units.  There are also other ways of  mov-
   ing text for special purposes.

   5.10.  Deletion and Killing

   Most commands which erase text from the buffer save it so that  you  can
   get  it  back if you change your mind, or move or copy it to other parts
   of the buffer.  These commands are known as kill commands.  The rest  of
   the  commands  that  erase text do not save it; they are known as delete
   commands.  The delete commands include ^D and ^H, which delete only  one
   character  at a time, and those commands that delete only spaces or line
   separators.  Commands that can destroy significant amounts of nontrivial
   data  generally  kill.   A  command's  name and description will use the
   words kill or delete to say which one it does.

   ^D                  Delete next character.










   USD:17-10                                     JOVE Manual for UNIX Users


   ^H                  Delete previous character.

   ESC \               Delete spaces and tabs around point.

   ^X ^O               Delete blank lines around the current line.

   ^K                  Kill rest of line or one or more lines.

   ^W                  Kill region (from point to the mark).

   ESC D               Kill word.

   ESC ^H              Kill word backwards.

   ESC K               Kill to end of sentence.

   ^X-^H               Kill to beginning of sentence.

   5.11.  Deletion

   The most basic delete commands are ^D and ^H.  ^D deletes the  character
   after  the  cursor,  the  one the cursor is "on top of" or "underneath".
   The cursor doesn't move.  ^H deletes the character  before  the  cursor,
   and  moves  the cursor back.  Line separators act like normal characters
   when deleted.  Actually, ^D and ^H aren't always delete commands; if you
   give  an  argument,  they kill instead.  This prevents you from losing a
   great deal of text by typing a large argument to a ^D or ^H.

   The other delete commands are those which delete only formatting charac-
   ters:   spaces,  tabs,  and line separators.  ESC \ (delete-white-space)
   deletes all the spaces and tab characters before and after point.  ^X-^O
   (delete-blank-lines) deletes all blank lines after the current line, and
   if the current line is blank deletes all the blank lines  preceding  the
   current line as well (leaving one blank line, the current line).

   5.12.  Killing by Lines

   The simplest kill command is the ^K command.  If issued at the beginning
   of  a  line,  it  kills  all the text on the line, leaving it blank.  If
   given on a line containing only white space (blanks and tabs)  the  line
   disappears.   As  a  consequence,  if you go to the front of a non-blank
   line and type two ^K's, the line disappears completely.

   More generally, ^K kills from point up to the end of the line, unless it
   is at the end of a line.  In that case, it kills the line separator fol-
   lowing the line, thus merging  the  next  line  into  the  current  one.
   Invisible spaces and tabs at the end of the line are ignored when decid-
   ing which case applies, so if point appears to be  at  the  end  of  the
   line, you can be sure the line separator will be killed.

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











   JOVE Manual for UNIX Users                                     USD:17-11


   5.13.  Other Kill Commands

   A kill command which is very general is ^W  (kill-region),  which  kills
   everything between point and the mark.*  With this command, you can kill
   and  save contiguous characters, if you first set the mark at one end of
   them and go to the other end.

   Other syntactic units can be killed, too; words, with ESC ^H and ESC  D;
   and, sentences, with ESC K and ^X-^H.

   5.14.  Un-killing

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

   ^Y        Yank (re-insert) last killed text.

   ESC Y     Replace re-inserted killed text  with  the  previously  killed
             text.

   ESC W     Save region as last killed text without killing.

   Killed text is pushed onto a ring  buffer  called  the  kill  ring  that
   remembers  the  last  10  blocks  of  text that were killed.  (Why it is
   called a ring buffer will be explained below).  The  command  ^Y  (yank)
   reinserts the text of the most recent kill.  It leaves the cursor at the
   end of the text, and puts the mark at the beginning.  Thus, a single  ^Y
   undoes the ^W.

   If you wish to copy a block of text, you might want to use ESC W  (copy-
   region),  which copies the region into the kill ring without removing it
   from the buffer.  This is approximately equivalent to ^W followed by ^Y,
   except  that  ESC W does not mark the buffer as ``changed'' and does not
   cause the screen to be rewritten.

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

   5.15.  Appending Kills

   Normally, each kill command pushes a new block onto the kill ring.  How-
   ever,  two or more kill commands immediately in a row (without any other
   intervening commands) combine their text into  a  single  entry  on  the
   ring,  so  that a single ^Y command gets it all back as it was before it
   was killed.  This means that you don't have to kill all the text in  one
   command; you can keep killing line after line, or word after word, until
   you have killed it all, and you can still get it all back at once.
   _________________________
   *Often users switch this binding from ^W to ^X-^K because  it  is  too
   easy to hit ^W accidentally.










   USD:17-12                                     JOVE Manual for UNIX Users


   Commands that kill forward from point add onto the end of  the  previous
   killed text.  Commands that kill backward from point add onto the begin-
   ning.  This way, any sequence of mixed forward and  backward  kill  com-
   mands puts all the killed text into one entry without needing rearrange-
   ment.

   5.16.  Un-killing Earlier Kills

   To recover killed text that is no longer the most recent kill, you  need
   the  ESC Y (yank-pop) command.  The ESC Y command can be used only after
   a ^Y (yank) command or another ESC  Y.   It  takes  the  un-killed  text
   inserted  by  the ^Y and replaces it with the text from an earlier kill.
   So, to recover the text of the next-to-the-last kill, you first  use  ^Y
   to  recover  the  last kill, and then discard it by use of ESC Y to move
   back to the previous kill.

   You can think of all the last few kills as living on a ring.  After a ^Y
   command,  the  text  at  the  front  of  the ring is also present in the
   buffer.  ESC Y ``rotates'' the ring bringing the previous string of text
   to  the  front  and  this  text replaces the other text in the buffer as
   well.  Enough ESC Y commands can rotate any part  of  the  ring  to  the
   front,  so you can get at any killed text so long as it is recent enough
   to be still in the ring.  Eventually the ring rotates all the way around
   and  the  most  recently  killed  text  comes to the front (and into the
   buffer) again.  ESC Y with a negative argument rotates  the  ring  back-
   wards.

   When the text you are looking for is brought into the  buffer,  you  can
   stop  doing  ESC  Y's  and the text will stay there.  It's really just a
   copy of what's at the front of the ring, so editing it does  not  change
   what's  in the ring.  And the ring, once rotated, stays rotated, so that
   doing another ^Y gets another copy of what you rotated to the front with
   ESC Y.

   If you change your mind about un-killing, ^W gets rid of  the  un-killed
   text, even after any number of ESC Y's.

   6.  Searching

   The search commands are useful for finding and moving to arbitrary posi-
   tions  in  the buffer in one swift motion.  For example, if you just ran
   the spell program on a paper and you want to correct some word, you  can
   use  the  search  commands to move directly to that word.  There are two
   flavors of search: string search and incremental search.  The former  is
   the  default flavor-if you want to use incremental search you must rear-
   range the key bindings (see below).

   6.1.  Conventional Search


   ESC S          Search forward.

   ESC R          Search backward.










   JOVE Manual for UNIX Users                                     USD:17-13


   To search for the string ``FOO'' you type  ``ESC  S  FOO<return>.''   If
   JOVE finds FOO it moves point to the end of it; otherwise JOVE prints an
   error message and leaves point unchanged.  ESC S searches  forward  from
   point  so  only  occurrences of FOO after point are found.  To search in
   the other direction use ESC R.  It is exactly the same as ESC  S  except
   it  searches  in  the opposite direction, and if it finds the string, it
   leaves point at the beginning of it, not at the end as in ESC S.

   While JOVE is searching it prints the search string on the message line.
   This  is  so  you  know  what JOVE is doing.  When the system is heavily
   loaded and editing in exceptionally large  buffers,  searches  can  take
   several (sometimes many) seconds.

   JOVE remembers the last search string you used, so if you want to search
   for  the  same  string you can type ``ESC S <return>.''  If you mistyped
   the last search string, you can type ESC S followed by ESC R. ESC R,  as
   usual,  inserts  the default search string into the minibuffer, and then
   you can fix it up.

   6.2.  Incremental Search

   This search command is unusual in that is is incremental; it  begins  to
   search before you have typed the complete search string.  As you type in
   the search string, JOVE shows you where it would  be  found.   When  you
   have  typed  enough  characters  to identify the place you want, you can
   stop.  Depending on what you will do next, you may or may  not  need  to
   terminate the search explicitly with a Return first.

   The command to search is ESC X i-search-forward.  This command reads  in
   characters and positions the cursor at the first occurrence of the char-
   acters that you have typed so far.  If you type ESC  X  i-search-forward
   and  then  F,  the  cursor  moves in the text just after the next ``F.''
   Type an ``O,'' and see the cursor move to after the next ``FO.''   After
   another  ``O,'' the cursor is after the next ``FOO.''  At the same time,
   the ``FOO'' has echoed on the message line.

   If you type a mistaken character, you can erase it out.  After the  FOO,
   typing  a  ^H  makes  the ``O'' disappear from the message line, leaving
   only ``FO.''  The cursor moves back in the buffer to the ``FO.''   Eras-
   ing  the  ``O'' and ``F'' moves the cursor back to where you started the
   search.

   When you are satisfied with the place you have reached, you can  type  a
   Return,  which  stops  searching,  leaving  the  cursor where the search
   brought it.  Also, any command  not  specially  meaningful  in  searches
   stops  the  searching  and is then executed.  Thus, typing ^A would exit
   the search and then move to the beginning of the line.  Return is neces-
   sary  only  if the next character you want to type is a printing charac-
   ter, ^H, Return, or another search command, since those are the  charac-
   ters that have special meanings inside the search.

   Sometimes you search for ``FOO'' and find it, but not the one you  hoped
   to find.  Perhaps there is a second FOO that you forgot about, after the
   one you just found.  Then type ESC S <return> and the cursor  will  find









   USD:17-14                                     JOVE Manual for UNIX Users


   the  next FOO.  This can be done any number of times.  If you overshoot,
   you can return to previous finds with the search-backward command ESC R.

   After you exit a search, you can search for the  same  string  again  by
   typing just ESC S <return>.

   If your string is not found at all, the message  line  says  Failing  I-
   search.   The cursor is after the place where JOVE found as much of your
   string as it could.  Thus, if you search for FOOT and there is no  FOOT,
   you might see the cursor after the FOO in FOOL.  At this point there are
   several things you can do.  If your string was  mistyped,  you  can  rub
   some  of  it  out and correct it.  If you like the place you have found,
   you can type Return or some other JOVE  command  to  ``accept  what  the
   search  offered.''   Or  you  can type ^G, which undoes the search alto-
   gether and positions you back where you started the search.

   You can also type ESC R at any time to start searching backwards.  If  a
   search fails because the place you started was too late in the file, you
   should do this.   Repeated  ESC  R's  keep  looking  backward  for  more
   occurrences  of  the  last  search string.  A ESC S starts going forward
   again.

   6.3.  Searching with Regular Expressions

   In addition to the searching facilities described above, JOVE can search
   for patterns using regular expressions.  The handling of regular expres-
   sions in JOVE is like that of ed(1) or  vi(1),  but  with  some  notable
   additions.   The  extra metacharacters understood by JOVE are \<, \>, \|
   and \{.  The first two of these match  the  beginnings  and  endings  of
   words;  Thus the search pattern, ``\<Exec'' would match all words begin-
   ning with the letters ``Exec.''

   An \| signals the beginning of an alternative -  that  is,  the  pattern
   ``foo\|bar'' would match either ``foo'' or ``bar.''  The ``curly brace''
   is a way of introducing several sub-alternatives  into  a  pattern.   It
   parallels the [] construct of regular expressions, except it specifies a
   list of alternative words instead of just  alternative  characters.   So
   the  pattern  ``foo\{bar,baz\}bie''  matches  ``foobarbie'' or ``foobaz-
   bie.''

   JOVE only regards metacharacters  as  special  if  the  variable  match-
   regular-expressions  is  set to ``on.''  The ability to have JOVE ignore
   these characters is useful if you're editing a document  about  patterns
   and regular expressions or when a novice is learning JOVE.

   Another variable that affects searching is case-ignore-search.  If  this
   variable  is  set  to  ``on'' then upper case and lower case letters are
   considered equal.

   7.  Replacement Commands

   Global search-and-replace operations are not needed as often in JOVE  as
   they  are  in other editors, but they are available.  In addition to the
   simple Replace operation which is like that found in most editors, there









   JOVE Manual for UNIX Users                                     USD:17-15


   is a Query Replace operation which asks, for each occurrence of the pat-
   tern, whether to replace it.

   7.1.  Global replacement

   To replace every occurrence of FOO after point with  BAR,  you  can  do,
   e.g.,  ``ESC  ^E FOO<return>BAR'' as the replace-string command is bound
   to the ESC ^E.  Replacement takes place only between point and  the  end
   of  the  buffer  so if you want to cover the whole buffer you must go to
   the beginning first.

   7.2.  Query Replace

   If you want to change only some of the occurrences of FOO, not all, then
   the  global replace-string is inappropriate; Instead, use, e.g., ``ESC Q
   FOO<return>BAR,''  to  run  the  command   query-replace-string.    This
   displays  each  occurrence  of  FOO  and waits for you to say whether to
   replace it with a BAR.  The things you can type when you  are  shown  an
   occurrence of FOO are:

   Space          to replace the FOO.

   ^H or N        to skip to the next FOO without replacing this one.

   Return         to stop without doing any more replacements.

   Period         to replace this FOO and then stop.

   ! or P         to replace all remaining FOO's without asking.

   ^R or R        to enter a recursive editing level, in case the FOO needs
                  to  be edited rather than just replaced with a BAR.  When
                  you are done, exit the recursive editing level with ^X-^C
                  and the next FOO will be displayed.

   ^W             to delete the FOO, and then  start  editing  the  buffer.
                  When  you are finished editing whatever is to replace the
                  FOO, exit the recursive editing level with ^X-^C and  the
                  next FOO will be displayed.

   ^U or U        move to the last replacement and  undo  changes  to  this
                  line.

   Another alternative  is  using  replace-in-region  which  is  just  like
   replace-string except it searches only within the region.


   8.  Commands for English Text

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












   USD:17-16                                     JOVE Manual for UNIX Users


   8.1.  Word Commands

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

   ESC F               Move Forward over a word.

   ESC B               Move Backward over a word.

   ESC D               Kill forward to the end of a word.

   ESC ^H              Kill backward to the beginning of a word.

   Notice how these commands form a group  that  parallels  the  character-
   based commands, ^F, ^B, ^D, and ^H.

   The commands ESC F and ESC B move forward and backward over words.  They
   are  thus  analogous  to  ^F  and ^B, which move over single characters.
   Like their Control- analogues, ESC F and ESC B  move  several  words  if
   given  an  argument.  ESC F with a negative argument moves backward like
   ESC B, and ESC B with a negative argument moves forward.  Forward motion
   stops  right  after  the  last letter of the word, while backward motion
   stops right before the first letter.

   It is easy to kill a word at a time.  ESC D kills the word after  point.
   To  be  precise, it kills everything from point to the place ESC F would
   move to.  Thus, if point is in the middle of a word, only the part after
   point  is killed.  If some punctuation comes after point, and before the
   next word, it is killed along with the word.  If you wish to  kill  only
   the  next  word  but  not the punctuation, simply do ESC F to get to the
   end, and kill the word backwards with ESC ^H.   ESC  D  takes  arguments
   just like ESC F.

   ESC ^H kills the word before point.  It kills everything from point back
   to  where  ESC  B  would move to.  If point is after the space in ``FOO,
   BAR,'' then ``FOO, '' is killed.  If you wish to kill just ``FOO,'' then
   do a ESC B and a ESC D instead of a ESC-^H.

   8.2.  Sentence Commands

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

   ESC A               Move back to the beginning of the sentence.

   ESC E               Move forward to the end of the sentence.

   ESC K               Kill forward to the end of the sentence.

   ^X-^H               Kill back to the beginning of the sentence.

   The commands ESC A and ESC E move  to  the  beginning  and  end  of  the
   current sentence, respectively.  They were chosen to resemble ^A and ^E,
   which move to the beginning and end of a line.  Unlike them, ESC  A  and









   JOVE Manual for UNIX Users                                     USD:17-17


   ESC  E  if repeated or given numeric arguments move over successive sen-
   tences.  JOVE considers a sentence to end wherever  there  is  a  ``.,''
   ``?,''  or ``!'' followed by the end of a line or by one or more spaces.
   Neither ESC A nor ESC E moves past the end of the line or  spaces  which
   delimit the sentence.

   Just as ^A and ^E have a kill command, ^K, to go with them, so ESC A and
   ESC  E have a corresponding kill command ESC K which kills from point to
   the end of the sentence.  With minus one as an argument it kills back to
   the  beginning  of  the  sentence.  Positive arguments serve as a repeat
   count.

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

   8.3.  Paragraph Commands

   The JOVE commands for handling paragraphs are

   ESC X backward-paragraph
                       Move back to previous paragraph beginning.

   ESC ]               Move forward to next paragraph end.

   ESC X backward-paragraph moves to the beginning of the current or previ-
   ous paragraph, while ESC ] moves to the end of the current or next para-
   graph.  Paragraphs are delimited by lines of differing indent, or  lines
   with  text  formatter  commands, or blank lines.  JOVE knows how to deal
   with most indented paragraphs correctly, although it can get confused by
   one- or two-line paragraphs delimited only by indentation.

   8.4.  Text Indentation Commands


   Tab                 Indent "appropriately" in a mode-dependent fashion.

   ^J                  Is the same as Return, except it copies  the  indent
                       of the line you just left.

   ESC M               Moves to the line's first non-blank character.


   The way to request indentation is with the  Tab  command.   Its  precise
   effect  depends on the major mode.  In Text mode, it indents to the next
   tab stop.  In C mode, it indents to the ``right'' position  for  C  pro-
   grams.

   To move over the indentation on a  line,  do  ESC  M  (first-non-blank).
   This  command,  given  anywhere  on  a line, positions the cursor at the
   first non-blank, non-tab character on the line.












   USD:17-18                                     JOVE Manual for UNIX Users


   8.5.  Text Filling

   Auto Fill mode causes text to be filled (broken up into lines  that  fit
   in  a  specified  width)  automatically as you type it in.  If you alter
   existing text so that it is no longer properly filled, JOVE can fill  it
   again if you ask.

   Entering Auto Fill mode is done with ESC X  auto-fill-mode.   From  then
   on,  lines  are broken automatically at spaces when they get longer than
   the desired width.  To leave Auto Fill mode, once again  execute  ESC  X
   auto-fill-mode.  When Auto Fill mode is in effect, the word Fill appears
   in the mode line.

   If you edit the middle of a paragraph, it may  no  longer  correctly  be
   filled.   To refill a paragraph, use the command ESC J (fill-paragraph).
   It causes the paragraph that point is inside to be filled.  All the line
   breaks are removed and new ones inserted where necessary.

   The maximum line width for filling  is  in  the  variable  right-margin.
   Both ESC J and auto-fill make sure that no line exceeds this width.  The
   value of right-margin is initially 72.

   Normally ESC J figures out the indent of the  paragraph  and  uses  that
   same  indent  when filling.  If you want to change the indent of a para-
   graph you set left-margin to the new position and type ^U ESC J.   fill-
   paragraph,  when  supplied  a  numeric argument, uses the value of left-
   margin.

   If you know where you want to set the right margin but  you  don't  know
   the  actual  value,  move to where you want to set the value and use the
   right-margin-here command.   left-margin-here  does  the  same  for  the
   left-margin variable.

   8.6.  Case Conversion Commands


   ESC L          Convert following word to lower case.

   ESC U          Convert following word to upper case.

   ESC C          Capitalize the following word.


   The word conversion commands are most useful.  ESC L converts  the  word
   after  point  to  lower  case, moving past it.  Thus, successive ESC L's
   convert successive words.  ESC U converts to all capitals instead, while
   ESC  C  puts  the  first letter of the word into upper case and the rest
   into lower case.  All these commands convert several words  at  once  if
   given  an  argument.   They  are  especially convenient for converting a
   large amount of text from all upper case to mixed case, because you  can
   move  through  the  test  using  ESC  L,  ESC U or ESC C on each word as
   appropriate.

   When given a negative argument, the word case conversion commands  apply









   JOVE Manual for UNIX Users                                     USD:17-19


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

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

   The other case conversion  functions  are  case-region-upper  and  case-
   region-lower,  which  convert  everything  between point and mark to the
   specified case.  Point and mark remain unchanged.

   8.7.  Commands for Fixing Typos

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

   ^H                       Delete last character.

   ESC ^H                   Kill last word.

   ^X-^H                    Kill to beginning of sentence.

   ^T                       Transpose two characters.

   ^X-^T                    Transpose two lines.

   ESC Minus ESC L          Convert last word to lower case.

   ESC Minus ESC U          Convert last word to upper case.

   ESC Minus ESC C          Convert last word to lower  case  with  capital
                            initial.


   8.8.  Killing Your Mistakes

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

   When your mistake is longer than a couple of  characters,  it  might  be
   more  convenient to use ESC ^H or ^X-^H.  ESC ^H kills back to the start
   of the last word, and ^X-^H kills back to the start  of  the  last  sen-
   tence.   ^X-^H  is  particularly useful when you are thinking of what to
   write as you type it, in case you change your mind about phrasing.   ESC
   ^H and ^X-^H save the killed text for ^Y and ESC Y to retrieve.

   ESC ^H is often useful even when you have typed only  a  few  characters
   wrong,  if you know you are confused in your typing and aren't sure what
   you typed.  At such a time, you cannot correct with ^H except by looking
   at the screen to see what you did.  It requires less thought to kill the
   whole word and start over again, especially if  the  system  is  heavily









   USD:17-20                                     JOVE Manual for UNIX Users


   loaded.

   If you were typing a command or command parameters, ^G  will  abort  the
   command with no further processing.

   8.9.  Transposition

   The common error of transposing two characters can be fixed with the  ^T
   (transpose-characters) command.  Normally, ^T transposes the two charac-
   ters on either side of the cursor and moves the cursor forward one char-
   acter.  Repeating the command several times ``drags'' a character to the
   right.  (Remember that point is considered to be between two characters,
   even though the visible cursor in your terminal is on only one of them.)
   When given at the end of a line, rather than switching the last  charac-
   ter  of  the  line  with  the line separator, which would be useless, ^T
   transposes the last two characters on the line.  So, if you  catch  your
   transposition  error  right away, you can fix it with just a ^T.  If you
   don't catch it so fast, you must move the cursor back to between the two
   characters.

   To transpose two lines, use the ESC X transpose-lines command.  The line
   containing the cursor is exchanged with the line above it; the cursor is
   left at the beginning of the line following its original position.

   8.10.  Checking and Correcting Spelling

   When you write a paper, you should correct its spelling  at  some  point
   close  to  finishing  it.  To correct the entire buffer, do ESC X spell-
   buffer.  This invokes the UNIX spell program, which prints a list of all
   the  misspelled  words.   JOVE  catches the list and places it in a JOVE
   buffer called Spell.  You are given an opportunity to delete  from  that
   buffer  any  words  that  aren't  really errors; then JOVE looks up each
   misspelled word and remembers where it is in the buffer being corrected.
   Then  you can go forward to each misspelled word with ^X-^N (next-error)
   and backward with ^X-^P  (previous-error).   See  the  section  entitled
   Error Message Parsing.

   9.  File Handling

   The basic unit of stored data is the file.  Each  program,  each  paper,
   lives  usually  in its own file.  To edit a program or paper, the editor
   must be told the name of the file that  contains  it.   This  is  called
   visiting  a  file.   To make your changes to the file permanent on disk,
   you must save the file.

   9.1.  Visiting Files


   ^X-^V          Visit a file.

   ^X-^R          Same as ^X-^V.

   ^X-^S          Save the visited file.










   JOVE Manual for UNIX Users                                     USD:17-21


   ESC ~          Tell JOVE to forget that the buffer has been changed.


   Visiting a file means copying its contents into JOVE where you can  edit
   them.   JOVE remembers the name of the file you visited.  Unless you use
   the multiple buffer feature of JOVE, you can only be visiting  one  file
   at  a  time.   The name of the current selected buffer is visible in the
   mode line.

   The changes you make with JOVE are made in a copy inside JOVE.  The file
   itself is not changed.  The changed text is not permanent until you save
   it in a file.  The first time you change the text, an  asterisk  appears
   at the end of the mode line; this indicates that the text contains fresh
   changes which will be lost unless you save them.

   To visit a file, use the command ^X-^V.  Follow  the  command  with  the
   name  of  the  file  you wish to visit, terminated by a Return.  You can
   abort the command by typing ^G, or edit the filename with  many  of  the
   standard  JOVE  commands  (e.g.,  ^A,  ^E,  ^F,  ESC F, ESC ^H).  If the
   filename you wish to visit is similar to the filename in the  mode  line
   (the  default  filename), you can type ^R to insert the default and then
   edit it.  If you do type a Return to finish the command, the new  file's
   text  appears  on the screen, and its name appears in the mode line.  In
   addition, its name becomes the new default filename.

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

   What if you want to create a file?  Just visit  it.   JOVE  prints  (New
   file)  but  aside  from  that  behaves as if you had visited an existing
   empty file.  If you make any changes and save them, the file is created.
   If  you  visit a nonexistent file unintentionally (because you typed the
   wrong filename), go ahead and visit the file you meant.   If  you  don't
   save the unwanted file, it is not created.

   If you alter one file and then visit another in the  same  buffer,  JOVE
   offers  to  save the old one.  If you answer YES, the old file is saved;
   if you answer NO, all the changes you have made to  it  since  the  last
   save are lost.  You should not type ahead after a file visiting command,
   because your type-ahead might answer an unexpected  question  in  a  way
   that you would regret.

   Sometimes you will change a buffer by accident.  Even if  you  undo  the
   effect  of the change by editing, JOVE still knows that ``the buffer has
   been changed.''  You can tell JOVE to pretend that there  have  been  no
   changes  with  the ESC ~ command (make-buffer-unmodified).  This command
   simply clears the ``modified'' flag which says that the buffer  contains
   changes  which  need  to be saved.  Even if the buffer really is changed
   JOVE will still act as if it were not.










   USD:17-22                                     JOVE Manual for UNIX Users


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

   9.2.  How to Undo Drastic Changes to a File

   If you have made several extensive changes to a  file  and  then  change
   your mind about them, and you haven't yet saved them, you can get rid of
   them by reading in the previous version of the file.  You  can  do  this
   with the ^X ^V command, to visit the unsaved version of the file.

   9.3.  Recovering from system/editor crashes

   JOVE does not have Auto Save mode, but it does provide a way to  recover
   your work in the event of a system or editor crash.  JOVE saves informa-
   tion about the files you're editing every so many changes to a buffer to
   make  recovery possible.  Since a relatively small amount of information
   is involved it's hardly even noticeable when JOVE does this.  The  vari-
   able  ``sync-frequency''  says  how often to save the necessary informa-
   tion, and the default is every 50 changes.   50  is  a  very  reasonable
   number:  if you are writing a paper you will not lose more than the last
   50 characters you typed, which is less than  the  average  length  of  a
   line.

   9.4.  Miscellaneous File Operations


   ESC X write-file <file><return> writes the contents of the  buffer  into
   the  file  <file>, and then visits that file.  It can be thought of as a
   way of ``changing the name'' of the file you are visiting.  Unlike ^X-S,
   write-file  saves  even  if  the  buffer has not been changed.  ^X-^W is
   another way of getting this command.

   ESC X insert-file <file><return> inserts the contents of <file> into the
   buffer  at  point, leaving point unchanged before the contents.  You can
   also use ^X-^I to get this command.

   ESC X write-region <file><return> writes the region  (the  text  between
   point  and  mark)  to  the  specified file.  It does not set the visited
   filename.  The buffer is not changed.

   ESC X append-region <file><return> appends the region  to  <file>.   The
   text is added to the end of <file>.











   JOVE Manual for UNIX Users                                     USD:17-23


   10.  Using Multiple Buffers

   When we speak of ``the buffer,'' which contains the text you  are  edit-
   ing,  we  have  given  the  impression that there is only one.  In fact,
   there may be many of them, each with its own body of text.  At any  time
   only  one buffer can be selected and available for editing, but it isn't
   hard to switch to a different one.  Each buffer  individually  remembers
   which  file  it is visiting, what modes are in effect, and whether there
   are any changes that need saving.

   ^X-B           Select or create a buffer.

   ^X-^F          Visit a file in its own buffer.

   ^X-^B          List the existing buffers.

   ^X-K           Kill a buffer.

   Each buffer in JOVE has a single name, which normally doesn't change.  A
   buffer's  name  can  be  any length.  The name of the currently selected
   buffer and the name of the file visited in it are visible  in  the  mode
   line  when  you  are  at  top  level.  A newly started JOVE has only one
   buffer, named Main, unless you specified files to edit in the shell com-
   mand that started JOVE.

   10.1.  Creating and Selecting Buffers

   To create a new buffer, you need only think of a name for it (say,  FOO)
   and  then do ^X-B FOO<return>, which is the command ^X-B (select-buffer)
   followed by the name.  This makes a new, empty buffer (if  one  by  that
   name  didn't  previously  exist)  and  selects  it for editing.  The new
   buffer is not visiting any file, so if you try to save it  you  will  be
   asked  for the filename to use.  Each buffer has its own major mode; the
   new buffer's major mode is Text mode by default.

   To return to buffer FOO later after having switched to another, the same
   command  ^X-B  FOO<return> is used, since ^X-B can tell whether a buffer
   named FOO exists already or not.  ^X-B Main<return> reselects the buffer
   Main that JOVE started out with.  Just ^X-B<return> reselects the previ-
   ous buffer.  Repeated ^X-B<return>'s  alternate  between  the  last  two
   buffers selected.

   You can also read a file into its own newly created buffer, all with one
   command:  ^X-^F  (find-file), followed by the filename.  The name of the
   buffer is the last element  of  the  file's  pathname.   ^F  stands  for
   ``Find,''  because  if the specified file already resides in a buffer in
   your JOVE, that buffer is reselected.  So you need not remember  whether
   you  have brought the file in already or not.  A buffer created by ^X-^F
   can be reselected later with ^X-B or ^X-^F, whichever you find more con-
   venient.   Nonexistent  files can be created with ^X-^F just as they can
   with ^X-^V.












   USD:17-24                                     JOVE Manual for UNIX Users


   10.2.  Using Existing Buffers

   To get a list of all the buffers that exist,  do  ^X-^B  (list-buffers).
   Each  buffer's type, name, and visited filename is printed.  An asterisk
   before the buffer name indicates a buffer which  contains  changes  that
   have  not been saved. The number that appears at the beginning of a line
   in a ^X-^B listing is that buffer's buffer number.   You  can  select  a
   buffer by typing its number in place of its name.  If a buffer with that
   number doesn't already exist, a new buffer is created with  that  number
   as its name.

   If several buffers have modified text in them, you should save  some  of
   them with ^X-^M (write-modified-files).  This finds all the buffers that
   need saving and then saves them.  Saving the buffers this  way  is  much
   easier  and  more efficient (but more dangerous) than selecting each one
   and typing ^X-S.  If you give ^X-^M an argument, JOVE will ask for  con-
   firmation before saving each buffer.

   ESC X rename-buffer <new name><return> changes the name of the currently
   selected buffer.

   ESC X erase-buffer <buffer name><return>  erases  the  contents  of  the
   <buffer name> without deleting the buffer entirely.

   10.3.  Killing Buffers

   After you use a JOVE for a while, it may fill up with buffers which  you
   no longer need.  Eventually you can reach a point where trying to create
   any more results in an ``out of memory''  or  ``out  of  lines''  error.
   When  this  happens  you  will  want  to kill some buffers with the ^X-K
   (delete-buffer) command.  You can kill the buffer FOO  by  doing  ^X-  K
   FOO<return>.   If  you  type ^X-K <return> JOVE will kill the previously
   selected buffer.  If you try to kill a buffer  that  needs  saving  JOVE
   will ask you to confirm it.

   If you need to kill several buffers, use the command  kill-some-buffers.
   This  prompts you with the name of each buffer and asks for confirmation
   before killing that buffer.

   11.  Controlling the Display

   Since only part of a large file will fit on the screen,  JOVE  tries  to
   show  the  part  that  is likely to be interesting.  The display control
   commands allow you to see a different part of the file.

   ESC ^L         Reposition point at a  specified  vertical  position,  OR
                  clear and redraw the screen with point in the same place.

   ^V             Scroll forwards (a screen or a few lines).

   ESC V          Scroll backwards.

   ^Z             Scroll forward some lines.










   JOVE Manual for UNIX Users                                     USD:17-25


   ESC Z          Scroll backwards some lines.


   The terminal screen is rarely large enough to display all of your  file.
   If  the  whole buffer doesn't fit on the screen, JOVE shows a contiguous
   portion of it, containing point.  It continues to show approximately the
   same  portion  until point moves outside of what is displayed; then JOVE
   chooses a new portion centered around the new  point.   This  is  JOVE's
   guess  as to what you are most interested in seeing, but if the guess is
   wrong, you can use the display control commands to see a different  por-
   tion.   The  available screen area through which you can see part of the
   buffer is called the window, and the choice of where in  the  buffer  to
   start  displaying  is  also  called the window.  (When there is only one
   window, it plus the mode line and the  input  line  take  up  the  whole
   screen).

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

   The basic display control command is ESC ^L  (redraw-display).   In  its
   simplest  form,  with  no argument, it tells JOVE to choose a new window
   position, centering point half way from the top as usual.

   ESC ^L with a positive argument chooses a new window so as to put  point
   that  many  lines  from  the top.  An argument of zero puts point on the
   very top line.  Point does not move with respect to  the  text;  rather,
   the text and point move rigidly on the screen.

   If point stays on the same line, the window is first  cleared  and  then
   redrawn.   Thus,  two  ESC  ^L's  in  a  row are guaranteed to clear the
   current window.  ^L will clear and redraw the entire screen.

   The scrolling commands ^V, ESC V, ^Z, and ESC Z, let you move the  whole
   display  up  or down a few lines.  ^V (next-page) with an argument shows
   you that many more lines at the bottom of the screen,  moving  the  text
   and  point  up  together  as  ESC ^L might.  ^V with a negative argument
   shows you more lines at the top of the screen, as does ESC V  (previous-
   page) with a positive argument.

   To read the buffer a window at a time, use the ^V command with no  argu-
   ment.  It takes the last line at the bottom of the window and puts it at
   the top, followed by nearly a whole window of lines not visible  before.
   Point  is  put at the top of the window.  Thus, each ^V shows the ``next
   page of text,'' except for one line of overlap to provide  context.   To
   move backward, use ESC V without an argument, which moves a whole window
   backwards (again with a line of overlap).

   ^Z and ESC Z scroll one line forward  and  one  line  backward,  respec-
   tively.   These are convenient for moving in units of lines without hav-
   ing to type a numeric argument.









   USD:17-26                                     JOVE Manual for UNIX Users


   11.1.  Multiple Windows

   JOVE allows you to split the screen into two or  more  windows  and  use
   them to display parts of different files, or different parts of the same
   file.

   ^X 2           Divide the current window into two smaller ones.

   ^X-1           Delete all windows but the current one.

   ^X-D           Delete current window.

   ^X-N           Switch to the next window.

   ^X-P           Switch to the previous window.

   ^X-O           Same as ^X-P.

   ^X-^           Make this window bigger.

   ESC ^V         Scroll the other window.


   When using multiple window mode, the  text  portion  of  the  screen  is
   divided  into separate parts called windows, which can display different
   pieces of text.  Each window can display different files,  or  parts  of
   the  same  file.   Only one of the windows is active; that is the window
   which the cursor is in.  Editing normally takes  place  in  that  window
   alone.   To edit in another window, you would give a command to move the
   cursor to the other window, and then edit there.

   Each window displays a mode line for the buffer it's  displaying.   This
   is useful to keep track of which window corresponds with which file.  In
   addition, the mode line serves as a separator between windows.  By  set-
   ting  the variable mode-line-should-standout to ``on'' you can have JOVE
   display the mode-line in reverse video (assuming your particular  termi-
   nal has the reverse video capability).

   The command ^X-2 (split-current-window) enters multiple window mode.   A
   new mode line appears across the middle of the screen, dividing the text
   display area into two halves.  Both windows contain the same buffer  and
   display  the same position in it, namely where point was at the time you
   issued the command.  The cursor moves to the second window.

   To return to viewing only one window,  use  the  command  ^X-1  (delete-
   other-windows).   The  current  window expands to fill the whole screen,
   and the other windows disappear until the next ^X-2.  (The  buffers  and
   their contents are unaffected by any of the window operations).

   While there is more than one window, you can use ^X-N  (next-window)  to
   switch  to  the next window, and ^X-P (previous-window) to switch to the
   previous one.  If you are in the bottom window and you  type  ^X-N,  you
   will  be  placed  in  the top window, and the same kind of thing happens
   when you type ^X-P in the top window, namely you will be placed  in  the









   JOVE Manual for UNIX Users                                     USD:17-27


   bottom  window.   ^X-O  is the same as ^X-P.  It stands for ``other win-
   dow'' because when there are only two windows, repeated use of this com-
   mand will switch between the two windows.

   Often you will be editing one window while  using  the  other  just  for
   reference.   Then, the command ESC-^V (page-next-window) is very useful.
   It scrolls the next window, as if you switched to the next window, typed
   ^V, and switched back, without your having to do all that.  With a nega-
   tive argument, ESC-^V will do an ESC V in the next window.

   When a window splits, both halves are approximately the same size.   You
   can  redistribute  the  screen  space  between the windows with the ^X-^
   (grow-window) command.  It makes the currently selected window grow  one
   line  bigger,  or as many lines as is specified with a numeric argument.
   Use ESC X shrink-window to make the current window smaller.

   11.2.  Multiple Windows and Multiple Buffers

   Buffers can be selected independently in each window.  The ^X-B  command
   selects  a  new  buffer  in whichever window contains the cursor.  Other
   windows' buffers do not change.

   You can view the same buffer in more than one window.  Although the same
   buffer  appears in both windows, they have different values of point, so
   you can move around in one window while the other  window  continues  to
   show  the same text.  Then, having found one place you wish to refer to,
   you can go back into the other window with ^X-O or  ^X-P  to  make  your
   changes.

   If you have the same buffer in both windows, you must beware  of  trying
   to  visit  a different file in one of the windows with ^X-^V, because if
   you bring a new file into this buffer, it will replaced the old file  in
   both  windows.   To  view different files in different windows, you must
   switch buffers in  one  of  the  windows  first  (with  ^X-B  or  ^X-^F,
   perhaps).

   A convenient ``combination'' command for viewing  something  in  another
   window  is ^X-4 (window-find).  With this command you can ask to see any
   specified buffer, file or tag in the other window.  Follow the ^X-4 with
   either B and a buffer name, F and a filename, or T and a tag name.  This
   switches to the other window and finds there what you specified.  If you
   were  previously  in  one-window  mode, multiple-window mode is entered.
   ^X- B is similar to ^X-2 ^X-B.  ^X-4 F is similar to ^X-2 ^X-^F.  ^X-4 T
   is  similar to ^X-2 ^X T.  The difference is one of efficiency, and also
   that ^X-4 works equally well if you are already using two windows.

   12.  Processes Under JOVE

   Another feature in JOVE is its ability to interact with UNIX in a useful
   way.   You  can run other UNIX commands from JOVE and catch their output
   in JOVE buffers.  In this chapter we will discuss the different ways  to
   run and interact with UNIX commands.











   USD:17-28                                     JOVE Manual for UNIX Users


   12.1.  Non-interactive UNIX commands

   To run a UNIX command from JOVE just type ^X-! followed by the  name  of
   the  command  terminated with Return.  For example, to get a list of all
   the users on the system, you do:

           ^X-! who<return>

   Then JOVE picks a reasonable buffer in which the output from the command
   will be placed.  E.g., ``who'' uses a buffer called who; ``ps alx'' uses
   ps; and ``fgrep -n foo *.c'' uses fgrep.  If JOVE wants to use a  buffer
   that  already exists it first erases the old contents.  If the buffer it
   selects holds a file, not output from a previous shell command, you must
   first delete that buffer with ^X-K.

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

   It's not a good idea to type anything  while  the  command  is  running.
   There are two reasons for this:

   (i)  JOVE won't see the characters (thus won't execute them)  until  the
        command finishes, so you may forget what you've typed.

   (ii) Although JOVE won't know what  you've  typed,  it  will  know  that
        you've  typed  something,  and then it will try to be ``smart'' and
        not update the display until it's interpreted  what  you've  typed.
        But,  of  course, JOVE won't interpret what you type until the UNIX
        command completes, so you're left with the uneasy feeling  you  get
        when you don't know what the hell the computer is doing*.

   If you want to interrupt the command for some reason (perhaps  you  mis-
   typed it, or you changed your mind) you can type ^].  Typing this inside
   JOVE while a process is running is the same as typing ^C  when  you  are
   outside JOVE, namely the process stops in a hurry.

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


   12.2.  Limitations of Non-Interactive Processes

   The reason these are called non-interactive processes is that you  can't
   type any input to them; you can't interact with them; they can't ask you
   questions because there is no way for you to answer.  For  example,  you
   can't  run  a  command interpreter (a shell), or mail or crypt with ^X-!
   _________________________
   *This is a bug and should be fixed, but probably won't be for a while.










   JOVE Manual for UNIX Users                                     USD:17-29


   because there is no way to provide it with input.   Remember  that  JOVE
   (not  the process in the window) is listening to your keyboard, and JOVE
   waits until the process dies before it looks at what you type.

   ^X-! is useful for running commands that do some output and  then  exit.
   For example, it's very useful to use with the C compiler to catch compi-
   lation error messages (see Compiling C Programs), or with the grep  com-
   mands.

   12.3.  Interactive Processes - Run a Shell in a Window

   Some versions of  JOVE-  have  the  capability  of  running  interactive
   processes.   This is more useful than non-interactive processes for cer-
   tain types of jobs:

   (i)  You can go off and do some editing while the  command  is  running.
        This  is  useful  for  commands that do sporadic output and run for
        fairly long periods of time.

   (ii) Unlike non-interactive processes, you can type input to these.   In
        addition, you can edit what you type with the power of all the JOVE
        commands before you send the input  to  the  process.   This  is  a
        really  important  feature,  and is especially useful for running a
        shell in a window.

   (iii)Because you can continue with  normal  editing  while  one  of  the
        processes is running, you can create a bunch of contexts and manage
        them (select them, delete them, or temporarily put them aside) with
        JOVE's window and buffer mechanisms.

   Although we may have given an image of processes being attached to  win-
   dows,  in  fact  they  are  attached  to buffers.  Therefore, once an i-
   process is running you can select another buffer into that window, or if
   you  wish  you  can  delete the window altogether.  If you reselect that
   buffer later it will be up to date.  That is,  even  though  the  buffer
   wasn't  visible  it  was  still  receiving output from the process.  You
   don't have to worry about missing anything when the buffer  isn't  visi-
   ble.

   12.4.  Advantages of Running Processes in JOVE Windows.

   There are several advantages to running a shell in a window.   What  you
   type isn't seen immediately by the process; instead JOVE waits until you
   type an entire line before passing it on to the process to  read.   This
   means  that  before you type <return> all of JOVE's editing capabilities
   are available for fixing errors on your input line.  If you discover  an
   error  at  the beginning of the line, rather than erasing the whole line
   and starting over, you can simply move to the error,  correct  it,  move
   back and continue typing.

   Another feature is that you have the entire history of your session in a
   _________________________
   - For example, the version provided with 4.3BSD.










   USD:17-30                                     JOVE Manual for UNIX Users


   JOVE buffer.  You don't have to worry about output from a command moving
   past the top of the screen.  If you missed some output you can move back
   through it with ESC V and other commands.  In  addition,  you  can  save
   yourself  retyping  a  command (or a similar one) by sending edited ver-
   sions of previous commands, or edit the output of one command to  become
   a list of commands to be executed (``immediate shell scripts'').

   12.5.  Differences between Normal and I-process Buffers

   JOVE behaves differently in several ways when you are  in  an  i-process
   buffer.   Most  obviously,  <return>  does different things depending on
   both your position in the buffer and on the state of  the  process.   In
   the  normal  case,  when  point is at the end of the buffer, Return does
   what you'd expect: it inserts a line-separator and then sends  the  line
   to the process.  If you are somewhere else in the buffer, possibly posi-
   tioned at a previous command that you want to edit, Return will place  a
   copy of that line (with the prompt discarded if there is one) at the end
   of the buffer and move you there.  Then you can edit the line  and  type
   Return  as in the normal case.  If the process has died for some reason,
   Return does nothing.  It doesn't even insert itself.   If  that  happens
   unexpectedly, you should type ESC X list-processes<return> to get a list
   of each process and its state.  If your process died  abnormally,  list-
   processes may help you figure out why.

   12.6.  How to Run a Shell in a Window

   Type ESC X shell<return> to start up a shell.  As with ^X-!,  JOVE  will
   create  a  buffer,  called  *shell*-1,  and select a window for this new
   buffer.  But unlike ^X-! you will be left in the new window.   Now,  the
   shell process is said to be attached to shell-1.

   13.  Directory Handling

   To save having to use absolute pathnames when you want to edit a  nearby
   file  JOVE  allows you to move around the UNIX filesystem just as the c-
   shell does.  These commands are:

   cd dir         Change to the specified directory.

   pushd [dir]    Like cd, but save the  old  directory  on  the  directory
                  stack.   With  no directory argument, simply exchange the
                  top two directories on the stack and cd to the new top.

   popd           Take the current directory off the stack and  cd  to  the
                  directory now at the top.

   dirs           Display the contents of the directory stack.

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

   14.  Editing C Programs

   This section details the support provided  by  JOVE  for  working  on  C









   JOVE Manual for UNIX Users                                     USD:17-31


   programs.

   14.1.  Indentation Commands

   To save having to lay out C programs ``by hand,'' JOVE has  an  idea  of
   the  correct  indentation  of  a line, based on the surrounding context.
   When you are in C Mode, JOVE treats tabs specially - typing a tab at the
   beginning  of  a  new line means ``indent to the right place.''  Closing
   braces are also  handled  specially,  and  are  indented  to  match  the
   corresponding open brace.

   14.2.  Parenthesis and Brace Matching

   To check that parentheses and braces match the way you  think  they  do,
   turn  on  Show  Match  mode (ESC X show-match-mode).  Then, whenever you
   type a close brace or parenthesis, the cursor moves momentarily  to  the
   matching  opener,  if it's currently visible.  If it's not visible, JOVE
   displays the line containing the matching opener on the message line.

   14.3.  C Tags

   Often when you are editing a C program, especially someone else's  code,
   you  see  a  function call and wonder what that function does.  You then
   search for the function within the current file and if you're lucky find
   the  definition,  finally  returning  to  the original spot when you are
   done.  However, if are unlucky, the function turns out  to  be  external
   (defined in another file) and you have to suspend the edit, grep for the
   function name in every .c that might contain it, and finally  visit  the
   appropriate file.

   To avoid this diversion or  the  need  to  remember  which  function  is
   defined  in  which  file,  Berkeley  UNIX has a program called ctags(1),
   which takes a set of source files and looks  for  function  definitions,
   producing a file called tags as its output.

   JOVE has a command called ^X-T (find-tag) that prompts you for the  name
   of a function (a tag), looks up the tag reference in the previously con-
   structed tags file, then visits the file containing that tag  in  a  new
   buffer,  with point positioned at the definition of the function.  There
   is another version of this command, namely find-tag-at-point, that  uses
   the identifier at point.

   So, when you've added new functions to a module, or moved some old  ones
   around,  run  the ctags program to regenerate the tags file.  JOVE looks
   in the  file  specified  in  the  tag-file  variable.   The  default  is
   ``./tags,'' that is, the tag file in the current directory.  If you wish
   to use an alternate tag file, you use ^U ^X-T, and JOVE will prompt  for
   a  file  name.   If you find yourself specifying the same file again and
   again, you can set tag-file to that  file,  and  run  find-tag  with  no
   numeric argument.

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









   USD:17-32                                     JOVE Manual for UNIX Users



           % jove -t SkipChar


   14.4.  Compiling Your Program

   You've typed in a program or altered an existing one and now you want to
   run  it  through  the  compiler  to check for errors.  To save having to
   suspend the edit, run the compiler, scribble down  error  messages,  and
   then  resume the edit, JOVE allows you to compile your code while in the
   editor.  This is done with the ^X-^E (compile-it) command.  If  you  run
   compile-it with no argument it runs the UNIX make program into a buffer;
   If you need a special command or want to pass  arguments  to  make,  run
   compile-it  with  any  argument  (^U  is  good  enough)  and you will be
   prompted for the command to execute.

   If any error messages are produced, they are treated specially by  JOVE.
   That treatment is the subject of the next section.

   14.5.  Error Message Parsing and Spelling Checking

   JOVE knows how to interpret the error messages from many UNIX  commands;
   In  particular,  the  messages from cc, grep and lint can be understood.
   After running  the  compile-it  command,  the  parse-errors  command  is
   automatically  executed,  and  any  errors  found are displayed in a new
   buffer.  The files whose names are found in parsing the  error  messages
   are  each  brought  into JOVE buffers and the point is positioned at the
   first error in  the  first  file.   The  commands  current-error,  ^X-^N
   (next-error),  and  ^X-^P  (previous-error)  can be used to traverse the
   list of errors.

   If you already have a file called errs containing, say, c compiler  mes-
   sages then you can get JOVE to interpret the messages by invoking it as:

           % jove -p errs


   JOVE has a special mechanism for checking the the spelling  of  a  docu-
   ment;  It  runs  the  UNIX spell program into a buffer.  You then delete
   from this buffer all those words that are not spelling errors  and  then
   JOVE  runs  the  parse-spelling-errors command to yield a list of errors
   just as in the last section.

   15.  Simple Customization


   15.1.  Major Modes

   To help with editing particular types of file, say a paper or a  C  pro-
   gram, JOVE has several major modes.  These are as follows:

   15.1.1.  Text mode

   This is the default major mode.  Nothing special is done.









   JOVE Manual for UNIX Users                                     USD:17-33


   15.1.2.  C mode

   This mode affects the behavior of the tab  and  parentheses  characters.
   Instead  of  just  inserting  the  tab,  JOVE  determines where the text
   ``ought'' to line up for the  C  language  and  tabs  to  that  position
   instead.   The  same  thing  happens  with  the  close  brace  and close
   parenthesis; they are tabbed to the ``right'' place and  then  inserted.
   Using  the  auto-execute-command command, you can make JOVE enter C Mode
   whenever you edit a file whose name ends in .c.

   15.1.3.  Lisp mode

   This mode is analogous to C Mode, but performs the indentation needed to
   lay out Lisp programs properly.  Note also the grind-s-expr command that
   prettyprints an s-expression and the kill-mode-expression command.

   15.2.  Minor Modes

   In addition to the major modes, JOVE has a set of  minor  modes.   These
   are as follows:

   15.2.1.  Auto Indent

   In this mode, JOVE indents each line the same  way  as  that  above  it.
   That is, the Return key in this mode acts as the Linefeed key ordinarily
   does.

   15.2.2.  Show Match

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

   15.2.3.  Auto Fill

   In Auto Fill mode, a newline is automatically  inserted  when  the  line
   length  exceeds  the right margin.  This way, you can type a whole paper
   without having to use the Return key.

   15.2.4.  Over Write

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

   15.2.5.  Word Abbrev

   In this mode, every word you type is compared to a list of word abbrevi-
   ations;  whenever  you  type an abbreviation, it is replaced by the text
   that it abbreviates.  This can save  typing  if  a  particular  word  or
   phrase  must  be entered many times.  The abbreviations and their expan-
   sions are held in a file that looks like:










   USD:17-34                                     JOVE Manual for UNIX Users



           abbrev:phrase

   This file can be set up in your ~/.joverc with the read-word-abbrev-file
   command.   Then,  whenever you are editing a buffer in Word Abbrev mode,
   JOVE checks for the abbreviations you've given.  See also  the  commands
   read-word-abbrev-file,     write-word-abbrev-file,    edit-word-abbrevs,
   define-global-word-abbrev, define-mode-word-abbrev,  and  bind-macro-to-
   word-abbrev, and the variable auto-case-abbrev.

   15.3.  Variables

   JOVE can be tailored to suit your needs by changing the values of  vari-
   ables.   A  JOVE variable can be given a value with the set command, and
   its value displayed with the print command.

   The variables JOVE understands are listed along with the commands in the
   alphabetical list at the end of this document.

   15.4.  Key Re-binding

   Many of the commands built into JOVE are not  bound  to  specific  keys.
   The  command  handler  in  JOVE  is used to invoke these commands and is
   activated by the execute-extended-command command  (ESC  X).   When  the
   name  of  a  command  typed in is unambiguous, that command will be exe-
   cuted.  Since it is very slow to have to type in the name of  each  com-
   mand every time it is needed, JOVE makes it possible to bind commands to
   keys.  When a command is bound to a key any future hits on that key will
   invoke that command.  All the printing characters are initially bound to
   the command self-insert.  Thus, typing any printing character causes  it
   to be inserted into the text.  Any of the existing commands can be bound
   to any key.  (A key may actually be a control  character  or  an  escape
   sequence as explained previously under Command Input Conventions).

   Since there are more commands than there are keys, two keys are  treated
   as  prefix  commands.  When a key bound to one of the prefix commands is
   typed, the next character typed is interpreted on the basis that it  was
   preceded by one of the prefix keys.  Initially ^X and ESC are the prefix
   keys and many of the built in commands  are  initially  bound  to  these
   ``two  stroke''  keys.  (For historical reasons, the Escape key is often
   referred to as ``Meta'').

   15.5.  Keyboard Macros

   Although JOVE has many powerful commands, you often find that you have a
   task  that no individual command can do.  JOVE allows you to define your
   own commands from sequences of existing  ones  ``by  example;''  Such  a
   sequence  is  termed  a  macro.  The procedure is as follows:  First you
   type the start-remembering command, usually bound  to  ^X-(.   Next  you
   ``perform''  the  commands  which  as  they  are being executed are also
   remembered, which will constitute the body of the macro.  Then you  give
   the  stop-remembering  command,  usually  bound to ^X-).  You now have a
   keyboard macro.  To run this command sequence  again,  use  the  command
   execute-keyboard-macro,  usually  bound  to  ^X-E.   You  may  find this









   JOVE Manual for UNIX Users                                     USD:17-35


   bothersome to type and re-type, so there is a way to bind the macro to a
   key.   First,  you  must  give the keyboard macro a name using the name-
   keyboard-macro command.  Then the binding is made with  the  bind-macro-
   to-key  command.   We're  still  not finished because all this hard work
   will be lost if you leave JOVE.  What you do is to save your macros into
   a  file  with the write-macros-to-file command.  To retrieve your macros
   in the next editing session (but not their  bindings),  you  can  simply
   execute the source command on that file.

   15.6.  Initialization Files

   Users will likely want to modify the default key bindings to their  lik-
   ing.   Since  it  would be quite annoying to have to set up the bindings
   each time JOVE is started  up,  JOVE  has  the  ability  to  read  in  a
   ``startup''  file.  Whenever JOVE is started, it reads commands from the
   file .joverc in the user's home directory.  These commands are  read  as
   if they were typed to the command handler (ESC X) during an edit.  There
   can be only one command per line in the startup file.   If  there  is  a
   file /usr/lib/jove/joverc, then this file will be read before the user's
   .joverc file.  This can be used to set up a system-wide default  startup
   mode for JOVE that is tailored to the needs of that system.

   The source command can be used to read commands from a specified file at
   any  time  during an editing session, even from inside the .joverc file.
   This means that a macro can be used to change the key bindings, e.g., to
   enter  a  mode,  by reading from a specified file which contains all the
   necessary bindings.




































   USD:17-36                                     JOVE Manual for UNIX Users


   16.  Alphabetical List of Commands and Variables

   16.1.  abort-char                                        (variable)

   This variable defines JOVE'S abort characer.  When the  abort  character
   is typed, the current JOVE command is aborted.  The default value is ^G.

   16.2.  add-lisp-special                                  [Unbound]

   This command is to tell JOVE what identifiers require  special  indenta-
   tion  in  lisp  mode.   Lisp functions like defun and let are two of the
   default functions that get treated specially.  This is just a kludge  to
   define some of your own.  It prompts for the function name.

   16.3.  allow-^S-and-^Q                                   (variable)

   This variable, when set, tells JOVE that your terminal does not need  to
   use  the  characters  ^S and ^Q for flow control, and that it is okay to
   bind things to them.  This variable should be set  depending  upon  what
   kind of terminal you have.

   16.4.  allow-bad-filenames                               (variable)

   If set, this variable permits filenames to  contain  ``bad''  characters
   such  as  those from the set *&%!"`[]{}.  These files are harder to deal
   with, because the characters mean something to the shell.   The  default
   value is ``off.''

   16.5.  append-region                                     [Unbound]

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

   16.6.  apropos                                           ESC-h

   This types out all the commands, variables and macros with the  specific
   keyword  in  their  names.  For each command and macro that contains the
   string, the key sequence that can be used  to  execute  the  command  or
   macro  is printed; with variables, the current value is printed.  So, to
   find all the commands that are related to windows, you type

           ESC-h window<Return>


   16.7.  auto-case-abbrev                                  variable

   When this variable is on (the default), word abbreviations are  adjusted
   for  case automatically.  For example, if ``jove'' were the abbreviation
   for ``jonathan's own version of emacs,'' then typing ``jove'' would give
   you  ``jonathan's own version of emacs,'' typing ``Jove'' would give you
   ``Jonathan's own version of emacs,'' and typing ``JOVE'' would give  you
   ``Jonathan's  Own  Version  of  Emacs.''  When this variable is ``off,''
   upper and lower case are distinguished when looking  for  the  abbrevia-
   tion,  i.e.,  in  the  example above, ``JOVE'' and ``Jove'' would not be









   JOVE Manual for UNIX Users                                     USD:17-37


   expanded unless they were defined separately.

   16.8.  auto-execute-command                              [Unbound]

   This tells JOVE to execute a command automatically  when  a  file  whose
   name  matches a specified pattern is visited.  The first argument is the
   command you want executed and the second is a regular expression pattern
   that  specifies the files that apply.  For example, if you want to be in
   show-match-mode when you edit C source files (that is,  files  that  end
   with ``.c'' or ``.h'') you can type

           ESC X auto-execute-command show-match-mode .*.[ch]$


   16.9.  auto-execute-macro                                [Unbound]

   This is like auto-execute-command except you use it  to  execute  macros
   automatically instead of built-in commands.

   16.10.  auto-fill-mode                                    [Unbound]

   This turns on Auto Fill mode (or  off  if  it's  currently  on)  in  the
   selected buffer.  When JOVE is in Auto Fill mode it automatically breaks
   lines for you when you reach the right  margin  so  you  don't  have  to
   remember  to  hit  Return.  JOVE uses 72 as the right margin but you can
   change that by setting the variable right-margin to another value.   See
   the set command to learn how to do this.

   16.11.  auto-indent-mode                                  [Unbound]

   This turns on Auto Indent mode (or off if  it's  currently  on)  in  the
   selected  buffer.   When JOVE is in Auto Indent mode, Return indents the
   new line to the same position as the line you were  just  on.   This  is
   useful  for  lining  up  C code (or any other language (but what else is
   there besides C?)).  This is out of date  because  of  the  new  command
   called newline-and-indent but it remains because of several ``requests''
   on the part of, uh, enthusiastic and excitable users, that it be left as
   it is.

   16.12.  backward-character                                ^B

   This moves point backward over a single character.  If point is  at  the
   beginning of the line it moves to the end of the previous line.

   16.13.  backward-list                                     ESC-^P

   This moves backward over a list as  opposed  to  an  s-expression.   The
   difference  between  this  and  backward-s-expression is that this first
   searchs for a ``)'' and then moves to the matching ``(.''  This is  use-
   ful when you're trying to find unmatched parens in a program.

   16.14.  backward-paragraph                                [Unbound]

   This moves point backward to the beginning of the  current  or  previous









   USD:17-38                                     JOVE Manual for UNIX Users


   paragraph.   Paragraphs are bounded by lines that begin with a Period or
   Tab, or by blank lines; a change in indentation may also signal a  break
   between  paragraphs,  except  that JOVE allows the first line of a para-
   graph to be indented differently from the other lines.

   16.15.  backward-s-expression                             ESC-^B

   This moves  point  backward  over  a  s-expression.   It  is  just  like
   forward-s-expression with a negative argument.

   16.16.  backward-sentence                                 ESC-a

   This moves point backward to the beginning of the  current  or  previous
   sentence.   JOVE  considers  the  end of a sentence to be the characters
   ``.'', ``!'' or ``?'' followed by a Return or by one or more spaces.

   16.17.  backward-up-list                                  ESC-^U

   This is similar to backward-s-expression except it backs up and  OUT  of
   the  enclosing  s-expression.   In other words, it moves backward to the
   ``('' that would match a ``)'' if you were to type it right then.

   16.18.  backward-word                                     ESC-b

   This moves point backward to the beginning of the  current  or  previous
   word.

   16.19.  bad-filename-extensions                           (variable)

   This contains a list of words separated by spaces which are to  be  con-
   sidered  bad filename extensions, and so will not be counted in filename
   completion.  The default is ``.o'' so if you have jove.c and  jove.o  in
   the  same  directory,  the  filename  completion will not complain of an
   ambiguity because it will ignore jove.o.

   16.20.  begin-kbd-macro                                   ^X-(

   This starts defining the keyboard macro  by  remembering  all  your  key
   strokes  until  you execute end-kbd-macro, by typing ^X ).  Because of a
   bug in JOVE you shouldn't terminate the macro by  typing  ``ESC  X  end-
   kbd-macro;'' end-kbd-macro must be bound to ^X ) in order to make things
   work correctly.  To execute the remembered key  strokes  you  type  ^X-E
   which  runs  the  execute-kbd-macro  command.   Sometimes you may want a
   macro to accept different input each time it runs.  To  see  how  to  do
   this, see the make-macro-interactive command.

   16.21.  beginning-of-file                                 ESC-<

   This moves point backward to the beginning of the  buffer.   This  some-
   times  prints  the Point Pushed message.  If the top of the buffer isn't
   on the screen JOVE will set the mark so you can go  back  to  where  you
   were if you want.











   JOVE Manual for UNIX Users                                     USD:17-39


   16.22.  beginning-of-line                                 ^A

   This moves point to the beginning of the current line.

   16.23.  beginning-of-window                               ESC-,

   This moves point to the beginning of the current window.   The  sequence
   ESC-,  is the same as ESC-< (beginning-of-file) except without the shift
   key on the ``<,'' and can thus can easily be remembered.

   16.24.  bind-keymap-to-key                                [Unbound]

   This is the way to build nested keymaps.  For example, when JOVE  starts
   up, internally it does a

           bind-keymap-to-key ES^map ^[

   To make the arrow keys on vt100's work, you would do the following.

           make-keymap vt100-map
           bind-keymap-to-key vt100-map ^[[
           bind-to-key next-line ^[[A
           bind-to-key previous-line ^[[B
           bind-to-key forward-character ^[[C
           bind-to-key backward-character ^[[D

   I may have gotten the escape sequences wrong, but you  get  the  general
   idea.   Theoretically you can use these keymaps to bind arbitrarily long
   key sequences, like those generated by the SUN keyboards, but that is  a
   bit  of  a  pain because you will have to generate a bunch of keymaps by
   hand, almost one per key, because of  the  way  the  key  sequences  are
   organized.   Eventually  there  will be a more general way to have these
   keymaps built for you.

   16.25.  bind-macro-to-key                                 [Unbound]

   This is like bind-to-key except you use it to attach keys to named  mac-
   ros.

   16.26.  bind-macro-to-word-abbrev                         [Unbound]

   This command allows you to bind a macro to  a  previously  defined  word
   abbreviation.   Whenever  you  type  the  abbreviation, it will first be
   expanded as an abbreviation, and then the macro will be executed.   Note
   that  if  the macro moves around, you should set the mark first (^@) and
   then exchange the point and mark last (^X-^X).

   16.27.  bind-to-key                                       [Unbound]

   This attaches a key to an internal JOVE command so that future  hits  on
   that  key  invoke  that  command.  For example, to make ``^W'' erase the
   previous word, you type ``ESC X bind-to-key kill-previous-word ^W.''











   USD:17-40                                     JOVE Manual for UNIX Users


   16.28.  buffer-position                                   [Unbound]

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

   16.29.  c-argument-indentation                            (variable)

   This variable describes how to indent lines which  are  part  of  nested
   expressions  in C.  The default is -1, which means to indent a continued
   line by lining it up with the first argument of the current  expression.
   Otherwise,  the  line will be indented by c-argument-indentation charac-
   ters past the indent of the first line of the expression.  For  example,
   the default value produces:
                   Typeout(fmt, itoa(bcount++), line_cnt(b, nbuf),
                           TypeNames[b->b_type],
                           IsModified(b) ? "*" : b->b_ntbf ? "+" : NullStr,
                           buf_width, b->b_name, filename(b));

   16.30.  c-indentation-increment                           (variable)

   This defines a set of tabstops independent of  the  value  of  internal-
   tabstops  and physical-tabstops.  This value will be used in C mode, and
   JOVE will insert the correct number of spaces and Tabs to get the  right
   behavior.   For  programmers that like to indent with 4 spaces, set this
   value to 4.  Don't set internal-tabstops to 4 because that will not work
   anymore.   Setting  internal-tabstops to 4 tells JOVE to display Tabs as
   every 4 spaces.  This will cause your programs  to  look  terrible  with
   anyone  else who displays the file with normal tabstops at every 8 char-
   acters.  Not to mention printing your program won't look right.  But all
   that  aside,  if you set c-indentation-increment to 8 (the default), and
   then set internal-tabstops to 4 as well, JOVE will insert  TWO  Tabs  to
   get the indentation to 8, which is clearly not what you want.

   16.31.  c-mode                                            [Unbound]

   This turns on C mode in the currently selected buffer.  This is  one  of
   currently  four possible major modes:  Fundamental, Text, C, Lisp.  When
   in C or Lisp mode, Tab, ``}'', and ``)''  behave  a  little  differently
   from  usual:  They  are  indented to the ``right'' place for C (or Lisp)
   programs.  In JOVE, the ``right'' place is simply  the  way  the  author
   likes it (but I've got good taste).

   16.32.  case-character-capitalize                         [Unbound]

   This capitalizes the character after point, i.e.,  the  character  under
   the  cursor.   If  a  negative argument is supplied that many characters
   before point are upper cased.

   16.33.  case-ignore-search                                (variable)

   This variable, when set, tells JOVE to treat upper and lower case as the
   same  when  searching.   Thus  ``jove''  and  ``JOVE''  would match, and
   ``JoVe'' would match either.  The default  value  of  this  variable  is









   JOVE Manual for UNIX Users                                     USD:17-41


   ``off.''

   16.34.  case-region-lower                                 ^X-^L

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

   16.35.  case-region-upper                                 ^X-^U

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

   16.36.  case-word-capitalize                              ESC-c

   This capitalizes the current word by making  the  current  letter  upper
   case  and making the rest of the word lower case.  Point is moved to the
   end of the word.  If point is not positioned on a word it is first moved
   forward  to  the  beginning of the next word.  If a negative argument is
   supplied that many words before point are capitalized.  This  is  useful
   for  correcting  the word just typed without having to move point to the
   beginning of the word yourself.

   16.37.  case-word-lower                                   ESC-l

   This lower-cases the current word and leaves point at the end of it.  If
   point  is in the middle of a word the rest of the word is converted.  If
   point is not in a word it is first moved forward to the beginning of the
   next  word.   If  a negative argument is supplied that many words before
   point are converted to lower case.  This is useful  for  correcting  the
   word  just  typed  without  having to move point to the beginning of the
   word yourself.

   16.38.  case-word-upper                                   ESC-u

   This upper-cases the current word and leaves point at the end of it.  If
   point  is in the middle of a word the rest of the word is converted.  If
   point is not in a word it is first moved forward to the beginning of the
   next  word.   If  a negative argument is supplied that many words before
   point are converted to upper case.  This is useful  for  correcting  the
   word  just  typed  without  having to move point to the beginning of the
   word yourself.

   16.39.  cd                                                [Unbound]

   This changes the current directory.

   16.40.  character-to-octal-insert                         [Unbound]

   This inserts a Back-slash followed by the ascii value of the next  char-
   acter typed.  For example, ^G inserts the string ``\007.''

   16.41.  clear-and-redraw                                  ^L

   This clears the entire screen and redraws all  the  windows.   Use  this









   USD:17-42                                     JOVE Manual for UNIX Users


   when  JOVE  gets confused about what's on the screen, or when the screen
   gets filled with garbage characters or output from another program.

   16.42.  comment-format                                    (variable)

   This variable tells JOVE how to format your comments when  you  run  the
   command fill-comment.  Its format is this:

           <open pattern>%!<line header>%c<line trailer>%!<close pattern>

   The %!, %c, and %!  must  appear  in  the  format;  everything  else  is
   optional.  A newline (represented by %n) may appear in the open or close
   patterns.  %% is the representation for %.  The default  comment  format
   is for C comments.  See fill-comment for more.

   16.43.  compile-it                                        ^X-^E

   This compiles your program by running the UNIX command ``make''  into  a
   buffer,  and  automatically  parsing the error messages that are created
   (if any).  See the parse-errors command.  To compile a C program without
   ``make,'' use ^U ^X-^E and JOVE will prompt for a command to run instead
   of make.  (And then the command you type will become  the  default  com-
   mand.)   You can use this to parse the output from the C compiler or the
   ``grep'' or ``lint'' programs.  See also error-format-string to make  it
   possible to parse errors of a different format.

   16.44.  continue-process                                  [Unbound]

   This sends SIGCONT to the current interactive process, if the process is
   currently stopped.

   16.45.  copy-region                                       ESC-w

   This takes all the text in the region and copies it onto the  kill  ring
   buffer.  This is just like running kill-region followed by the yank com-
   mand.  See the kill-region and yank commands.

   16.46.  current-error                                     [Unbound]

   This moves to the current error in the list of parsed errors.   See  the
   next-error and previous-error commands for more detailed information.

   16.47.  date                                              [Unbound]

   This prints the date on the message line.

   16.48.  dbx-format-string                                 (variable)

   This is the default regular-expression search string  used  by  JOVE  to
   parse  output  from  dbx running in a shell process.  The default format
   string works when you type ``where'' or while you're stepping through  a
   program,  or  when you reach a breakpoint.  You shouldn't have to change
   this unless you are using gdb or some other symbolic debugger.










   JOVE Manual for UNIX Users                                     USD:17-43


   16.49.  define-global-word-abbrev                         [Unbound]

   This defines a global abbreviation.

   16.50.  define-macro                                      [Unbound]

   This provides  a  different  mechanism  for  defining  keyboard  macros.
   Instead  of  gathering  keystrokes and storing them into the ``keyboard-
   macro'' (which is how start-kbd-macro works), define-macro prompts for a
   macro  name  (terminated with Space, or Newline) and then for the actual
   macro body.  If you wish to specify control characters in the macro, you
   may simply insert them (using the quoted-insert command) or by inserting
   the character '^' followed by the appropriate letter for that  character
   (e.g., ^A would be the two characters '^' followed by 'A').  You may use
   Back-slash to prevent the '^' from being interpreted as part of  a  con-
   trol  character  when  you really wish to insert one (e.g., a macro body
   ``\^foo'' would insert the string ``^foo'' into the buffer, whereas  the
   body  ``^foo''  would  be  the  same as typing ^F and then inserting the
   string `oo'').  See write-macros-to-file to see how to save macros.

   16.51.  define-mode-word-abbrev                           [Unbound]

   This defines a mode-specific abbreviation.

   16.52.  delete-blank-lines                                ^X-^O

   This deletes all the blank lines around point.  This is useful when  you
   previously  opened  many lines with ^O and now wish to delete the unused
   ones.

   16.53.  delete-buffer                                     ^X-k

   This deletes a buffer and frees up all the memory  associated  with  it.
   Be careful(!) - once a buffer has been deleted it is gone forever.  JOVE
   will ask you to confirm if you try to delete a buffer that needs saving.
   This  command  is  useful  for  when JOVE runs out of space to store new
   buffers.

   16.54.  delete-current-window                             ^X-d

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

   16.55.  delete-macro                                      [Unbound]

   This deletes a macro from the list of named macros.  It is an  error  to
   delete  the  keyboard-macro.   Once the macro is deleted it is gone for-
   ever.  If you are about to save macros to a file and  decide  you  don't
   want to save a particular one, delete it.

   16.56.  delete-next-character                             ^D

   This deletes the character that's just after point (that is, the charac-
   ter  under  the  cursor).   If  point  is at the end of a line, the line









   USD:17-44                                     JOVE Manual for UNIX Users


   separator is deleted and the next line is joined with the current one.

   16.57.  delete-other-windows                              ^X-1

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

   16.58.  delete-previous-character                    Backspace, or ^H

   This deletes the character that's just before point (that is, the  char-
   acter before the cursor).  If point is at the beginning of the line, the
   line separator is deleted and that line is joined with the previous one.

   16.59.  delete-white-space                                ESC-\

   This deletes all the Tabs and Spaces around point.

   16.60.  describe-bindings                                 [Unbound]

   This types out a list containing each bound key  and  the  command  that
   gets invoked every time that key is typed.  To make a wall chart of JOVE
   commands, set send-typeout-to-buffer to ``on'' and JOVE will  store  the
   key bindings in a buffer which you can save to a file and then print.

   16.61.  describe-command                                  ESC-?

   This prints some info on a specified command.

   16.62.  describe-key                                      ^X-?

   This waits for you to type a key and then tells the name of the  command
   that gets invoked every time that key is hit.  Once you have the name of
   the command you can use ESC-?  describe-command to find out exactly what
   it does.

   16.63.  describe-variable                                 [Unbound]

   This prints some info on a specified variable.

   16.64.  digit                                             ESC [0-9]

   This reads a numeric argument.  When you  type  ``ESC''  followed  by  a
   number,  ``digit''  keeps reading numbers until you type some other com-
   mand.  Then that command is  executes  with  the  numeric  argument  you
   specified.

   16.65.  digit-1                                           [Unbound]

   This pretends you typed ``ESC 1.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having
   type ``ESC'' when you want to specify an argument.











   JOVE Manual for UNIX Users                                     USD:17-45


   16.66.  digit-2                                           [Unbound]

   This pretends you typed ``ESC 2.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having
   type ``ESC'' when you want to specify an argument.

   16.67.  digit-3                                           [Unbound]

   This pretends you typed ``ESC 3.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having
   type ``ESC'' when you want to specify an argument.

   16.68.  digit-4                                           [Unbound]

   This pretends you typed ``ESC 4.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having
   type ``ESC'' when you want to specify an argument.

   16.69.  digit-5                                           [Unbound]

   This pretends you typed ``ESC 5.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having
   type ``ESC'' when you want to specify an argument.

   16.70.  digit-6                                           [Unbound]

   This pretends you typed ``ESC 6.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having
   type ``ESC'' when you want to specify an argument.

   16.71.  digit-7                                           [Unbound]

   This pretends you typed ``ESC 7.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having
   type ``ESC'' when you want to specify an argument.

   16.72.  digit-8                                           [Unbound]

   This pretends you typed ``ESC 8.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having
   type ``ESC'' when you want to specify an argument.

   16.73.  digit-9                                           [Unbound]

   This pretends you typed ``ESC 9.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having









   USD:17-46                                     JOVE Manual for UNIX Users


   type ``ESC'' when you want to specify an argument.

   16.74.  digit-0                                           [Unbound]

   This pretends you typed ``ESC 0.''  This is useful  for  terminals  that
   have keypads that send special sequences for numbers typed on the keypad
   as opposed to numbers typed from the keyboard.   This  can  save  having
   type ``ESC'' when you want to specify an argument.

   16.75.  dirs                                              [Unbound]

   This prints out the directory stack.  See the cd, pushd,  popd  commands
   for more info.

   16.76.  disable-biff                                      (variable)

   When this is set, JOVE disables biff when you're editing and enables  it
   again when you get out of JOVE, or when you pause to the parent shell or
   push to a new shell. (This means arrival of new mail will not be immedi-
   ately  apparent  but  will  not  cause  indiscriminate  writing  on  the
   display). The default is ``off.''

   16.77.  display-bad-filenames                             (variable)

   This variable affects only filename completion, in particular, what hap-
   pens when ``?'' is typed while prompting for a file.  When this variable
   is ON, any files that end with one of  the  extensions  defined  by  the
   variable  bad-filename-extensions  will  be  displayed  with an ``!'' in
   front of their names.  When display-bad-filenames is OFF the files  will
   not be displayed at all.  The default value is on.

   16.78.  down-list                                         ESC-^D

   This is the opposite of backward-up-list.  It's not  clear  to  me  that
   this  command serves any useful purpose in life.  Try it out, and let me
   know what you think.

   16.79.  dstop-process                                     [Unbound]

   Send the ``dsusp'' character to the current process.  This is the  char-
   acter  that suspends a process on the next read from the terminal.  Most
   people have it set to ^Y.  This only works if you have  the  interactive
   process feature, and if you are in a buffer bound to a process.

   16.80.  edit-word-abbrevs                                 [Unbound]

   This creates a buffer with a list of each abbreviation and the phrase it
   expands into, and enters a recursive edit to let you change the abbrevi-
   ations   or   add   some   more.    The   format   of   this   list   is
   ``abbreviation:phrase''  so  if you add some more you should follow that
   format.  It's probably simplest  just  to  copy  some  already  existing
   abbreviations  and  edit them.  When you are done you type ^X-^C to exit
   the recursive edit.










   JOVE Manual for UNIX Users                                     USD:17-47


   16.81.  end-kbd-macro                                     ^X-)

   This stops the definition of the keyboard macro.  Because of  a  bug  in
   JOVE,  this  must be bound to ^X-), or some key sequence which is one or
   two characters long.  Anything else will not work properly.

   16.82.  end-of-file                                       ESC->

   This moves point forward to the  end  of  the  buffer.   This  sometimes
   prints  the Point Pushed message.  If the end of the buffer isn't on the
   screen JOVE will set the mark so you can go back to where  you  were  if
   you want.

   16.83.  end-of-line                                       ^E

   This moves point to the end of the current line.  If  the  line  is  too
   long  to fit on the screen JOVE will scroll the line to the left to make
   the end of the line visible.  The line will slide  back  to  its  normal
   position  when  you move backward past the leftmost visible character or
   when you move off the line altogether.

   16.84.  end-of-window                                     ESC-.

   This moves point to the last character in the window.

   16.85.  eof-process                                       [Unbound]

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

   16.86.  erase-buffer                                      [Unbound]

   This erases the contents of the specified buffer.  This is like  delete-
   buffer  except it only erases the contents of the buffer, not the buffer
   itself.  If you try to erase a buffer that  needs  saving  you  will  be
   asked to confirm it.

   16.87.  error-format-string                               (variable)

   This is the error format string that is used by parse-errors to find the
   error messages in a buffer.  The way it works is by using this string as
   a JOVE regular expression search string, where the \('s and \)'s regular
   expression  operators are used to pick out the file name and line number
   from the line containing an error  message.   For  instance,  a  typical
   error message might look like this:

           "file.c", line 540: missing semi-colon

   For strings of this format, an appropriate value for error-format-string
   would be something like this:

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

   What this means is,  to  find  an  error  message,  search  for  a  line









   USD:17-48                                     JOVE Manual for UNIX Users


   beginning  with  a  double-quote.   Then  it says that all the following
   characters up to another double-quote should be remembered as one  unit,
   namely  the  filename  that the error is in (that's why the first set of
   parens are surrounding it).  Then it says that after the filename  there
   will  be  the string ``, line '' followed by a line number, which should
   be remembered as a single unit (which is why the second set of parens is
   around  that).   The  only constraints on the error messages is that the
   file name and line number appear on the same line,  and  that  the  file
   name  appears  before  the  line number.  Most compilers seem to do this
   anyway, so this is not an unreasonable restriction.

   If you do not know how to use regular  expressions  then  this  variable
   will be hard for you to use.  Also note that you can look at the default
   value of this variable by printing it out, but it is  a  really  compli-
   cated  string  because  it  is trying to accommodate the outputs of more
   than one compiler at a time.

   16.88.  error-window-size                                 (variable)

   This is the percentage of the screen to use for the error-window on  the
   screen.   When  you execute compile-it, error-window-size percent of the
   screen will go to the error window.  If the window already exists and is
   a different size, it is made to be this size.  The default value is 20%.

   16.89.  exchange-point-and-mark                           ^X-^X

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

   16.90.  execute-kbd-macro                                 ^X-e

   This executes the keyboard macro.  If you supply a numeric argument  the
   macro is executed that many times.

   16.91.  execute-macro                                     [Unbound]

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

   16.92.  execute-named-command                             ESC-X

   This is the way to execute a command that isn't bound to any key.   When
   you  are prompted with ``: '' you can type the name of the command.  You
   don't have to type the entire name.  Once the command is unambiguous you
   can  type  Space and JOVE will fill in the rest for you.  If you are not
   sure of the name of the command, type ``?'' and JOVE will print  a  list
   of  all  the  commands  that  you could possibly match given what you've
   already typed.  If you find yourself constantly executing the same  com-
   mands  this  way  you probably want to bind them to keys so that you can
   execute them more quickly.  See the bind-to-key command.

   16.93.  exit-jove                                         ^X-^C

   This exits JOVE.  If any buffers need saving JOVE will print  a  warning









   JOVE Manual for UNIX Users                                     USD:17-49


   message  and  ask  for  confirmation.   If you leave without saving your
   buffers all your work will be lost.  If you made a mistake and really do
   want  to  exit  then  you  can.  If you are in a recursive editing level
   exit-jove will return you from that.

   16.94.  expand-environment-variables                      (variable)

   When this variable is on JOVE will try to expand any strings of the form
   ``$var''  into the value of the environment variable ``var'' when in the
   minibuffer.  For example, if you type $HOME/.joverc, ``$HOME''  will  be
   replaced with you home directory.  The default value is off.

   16.95.  file-creation-mode                                (variable)

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

   16.96.  files-should-end-with-newline                     (variable)

   This variable indicates that all files should always have a  newline  at
   the  end.  This is often necessary for line printers and the like.  When
   set, if JOVE is writing a file whose last character is not a newline, it
   will add one automatically.

   16.97.  fill-comment                                      [Unbound]

   This command fills in your C comments to make them pretty and  readable.
   This filling is done according the variable comment-format.

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

   This can be changed by changing the format  variable.   Other  languages
   may  be  supported  by  changing the format variable appropriately.  The
   formatter looks backwards from dot  for  an  open  comment  symbol.   If
   found,  all indentation is done relative the position of the first char-
   acter of the open symbol.  If there is  a  matching  close  symbol,  the
   entire  comment  is  formatted.   If not, the region between dot and the
   open symbol is reformatted.

   16.98.  fill-paragraph                                    ESC-j

   This rearranges words between lines so that all the lines in the current
   paragraph extend as close to the right margin as possible, ensuring that
   none of the lines will be greater than the right  margin.   The  default
   value  for  right-margin  is  72,  but  can  be changed with the set and
   right-margin-here commands.  JOVE has a complicated algorithm for deter-
   mining  the beginning and end of the paragraph.  In the normal case JOVE
   will give all the lines the same indent as they currently have,  but  if
   you  wish  to  force  a  new indent you can supply a numeric argument to
   fill-paragraph (e.g., by typing ^U ESC-j) and JOVE will indent each line









   USD:17-50                                     JOVE Manual for UNIX Users


   to  the  column  specified  by  the  left-margin variable.  See also the
   left-margin variable and left-margin-here command.

   16.99.  fill-region                                       [Unbound]

   This is like fill-paragraph, except it operates on a region  instead  of
   just a paragraph.

   16.100.  filter-region                                     [Unbound]

   This sends the text in the region to a UNIX command,  and  replaces  the
   region  with the output from that command.  For example, if you are lazy
   and don't like to take the time to write properly indented C  code,  you
   can  put  the region around your C file and filter-region it through cb,
   the UNIX C beautifier.  If you have a file  that  contains  a  bunch  of
   lines  that  need  to be sorted you can do that from inside JOVE too, by
   filtering the region through the sort UNIX command.  Before output  from
   the  command  replaces  the  region JOVE stores the old text in the kill
   ring, so if you are unhappy with the results you can easily get back the
   old text with ^Y.

   16.101.  find-file                                         ^X-^F

   This visits a file into its own buffer and then selects that buffer.  If
   you've  already  visited  this  file  in  another buffer, that buffer is
   selected.  If the file doesn't yet exist, JOVE will print (New file)  so
   that you know.

   16.102.  find-tag                                       ^X-t or ^X-^T

   This finds the file that contains the specified tag.  JOVE looks up tags
   by  default  in  the  ``tags''  file  in the current directory.  You can
   change the default tag name by setting the tag-file variable to  another
   name.   If  you  specify a numeric argument to this command, you will be
   prompted for a tag file.  This is a good way to specify another tag file
   without  changing  the default.  If the tag cannot be found the error is
   reported and point stays where it is.

   16.103.  find-tag-at-point                                 [Unbound]

   This finds the file that contains the tag that point  is  currently  on.
   See find-tag.

   16.104.  first-non-blank                                   ESC-m

   This moves point back to the indent of the current line.

   16.105.  forward-character                                 ^F

   This moves forward over a single character.  If point is at the  end  of
   the line it moves to the beginning of the next one.












   JOVE Manual for UNIX Users                                     USD:17-51


   16.106.  forward-list                                      ESC-^N

   This is like forward-s-expression except it moves over lists ONLY.  What
   this  does  is  search  for the next ``('' and then move to the matching
   ``).''  This is useful for  when  you  are  trying  to  find  mismatched
   parentheses in a program.

   16.107.  forward-paragraph                                 ESC-]

   This moves point forward to the end of the current  or  next  paragraph.
   Paragraphs  are  bounded by lines that begin with a Period or Tab, or by
   blank lines; a change in indentation may also  signal  a  break  between
   paragraphs,  except that JOVE allows the first line of a paragraph to be
   indented differently from the other lines.

   16.108.  forward-s-expression                              ESC-^F

   This moves point forward over a s-expression.  If the first  significant
   character  after point is ``(,'' this moves past the matching ``).''  If
   the character begins an identifier, this moves just past  it.   This  is
   mode dependent, so this will move over atoms in LISP mode and C identif-
   iers in C mode.  JOVE also matches ``{.''

   16.109.  forward-sentence                                  ESC-e

   This moves point forward to the end of the  current  or  next  sentence.
   JOVE  considers  the end of a sentence to be the characters ``.'', ``!''
   or ``?'' followed by a Return, or one or more spaces.

   16.110.  forward-word                                      ESC-f

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

   16.111.  fundamental-mode                                  [Unbound]

   This sets the major mode to Fundamental.  This affects what JOVE consid-
   ers as characters that make up words.  For instance, Single-quote is not
   part of a word in Fundamental mode, but is in Text mode.

   16.112.  gather-numeric-argument                           ^U

   This command is one of two ways to specify a numeric argument to a  com-
   mand.  It's usually bound to ^U.  Typing ^U once means, Do the next com-
   mand 4 times.  Typing ^U twice will do the next command 16 times, and so
   on.   If  at  any point you type a number, then that number will be used
   instead of 4.  For instance, ^U 3 5 means do the next command 35 times.

   16.113.  goto-line                                         ESC-g

   If a numeric argument is supplied point moves to the beginning  of  that
   line.  If no argument is supplied one is prompted for.












   USD:17-52                                     JOVE Manual for UNIX Users


   16.114.  goto-window-with-buffer                           [Unbound]

   This command prompts for a buffer name and then selects that buffer.  If
   the buffer is currently being displayed in one of the windows, that win-
   dow is selected instead.

   16.115.  grind-s-expr                                      [Unbound]

   When point is positioned on a ``(,'' this re-indents that  LISP  expres-
   sion.

   16.116.  grow-window                                       ^X-^

   This makes the current window one line bigger.   This  only  works  when
   there  is  more than one window and provided there is room to change the
   size.

   16.117.  handle-tab                                        ^I

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

   16.118.  i-search-forward                                  [Unbound]

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

   16.119.  i-search-reverse                                  ^R

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

   16.120.  i-shell-command                                   [Unbound]

   This is like shell-command except it lets you continue with your editing
   while  the  command  is running.  This is really useful for long running
   commands with sporadic output.  See the manual for information on how to
   use interactive processes.

   16.121.  insert-file                                       ^X-^I

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










   JOVE Manual for UNIX Users                                     USD:17-53


   16.122.  internal-tabstop                                  (variable)

   The number of spaces JOVE should print when it displays a tab character.
   The default value is 8.

   16.123.  interrupt-character                               (variable)

   This is set to the character that interrupts JOVE  (with  a  signal)  no
   matter  what  JOVE  is  doing.   It's  main use is for interrupting non-
   interactive processes, but it  also  has  uses  for  debugging.   Unfor-
   tunately there is no way to turn off the interrupt character.

   16.124.  interrupt-process                                 [Unbound]

   This sends the interrupt character (usually ^C) to the interactive  pro-
   cess in the current buffer.  This is only for versions of JOVE that have
   the interactive processes feature.  This only works when you are  inside
   a buffer that's attached to a process.

   16.125.  kill-next-word                                    ESC-d

   This kills the text from point to the end of the current or next word.

   16.126.    kill-previous-word                         ESC-^H   or   ESC-
   Backspace

   This kills the text from point to the beginning of the current or previ-
   ous word.

   16.127.  kill-process                                      [Unbound]

   This command prompts for  a  buffer  name  or  buffer  number  (just  as
   select-buffer  does)  and  then  sends the process in that buffer a kill
   signal (9).

   16.128.  kill-region                                       ^W

   This deletes the text in the region and saves it on the kill ring.  Com-
   mands  that  delete  text but save it on the kill ring all have the word
   ``kill'' in their names.  Type ^Y to yank back the most recent kill.

   16.129.  kill-s-expression                                 ESC-^K

   This kills the text from point to the end of  the  current  or  next  s-
   expression.

   16.130.  kill-some-buffers[Unbound]

   This goes through all the existing buffers and asks whether  or  not  to
   kill  them.   If  you decide to kill a buffer, and it turns out that the
   buffer is modified, JOVE will offer to save it first.   This  is  useful
   for  when  JOVE  runs out of memory to store lines (this only happens on
   PDP-11's) and you have lots of buffers that you are no longer using.










   USD:17-54                                     JOVE Manual for UNIX Users


   16.131.    kill-to-beginning-of-sentence                ^X-^H   or   ^X-
   Backspace

   This kills from point to the beginning of the current or  previous  sen-
   tence.

   16.132.  kill-to-end-of-line                               ^K

   This kills from point to the end of the current line.  When point is  at
   the  end  of the line the line separator is deleted and the next line is
   joined with current one.  If a numeric argument is  supplied  that  many
   lines  are  killed;  if  the argument is negative that many lines before
   point are killed; if the argument is zero the text  from  point  to  the
   beginning of the line is killed.

   16.133.  kill-to-end-of-sentence                           ESC-k

   This kills from point to the end of the current or next sentence.  If  a
   negative  numeric argument is supplied it kills from point to the begin-
   ning of the current or previous sentence.

   16.134.  left-margin                                       (variable)

   This is how far lines should be indented when auto-indent mode is on, or
   when  the  newline-and-indent command is run (usually by typing ^J).  It
   is also used by fill-paragraph and auto-fill mode.  If the value is zero
   (the  default)  then  the left margin is determined from the surrounding
   lines.

   16.135.  left-margin-here                                  [Unbound]

   This sets the left-margin variable to the  current  position  of  point.
   This is an easy way to say, ``Make the left margin begin here,'' without
   having to count the number of spaces over it actually is.

   16.136.  lisp-mode                                         [Unbound]

   This turns on Lisp mode.  Lisp mode is one of  four  mutually  exclusive
   major  modes: Fundamental, Text, C, and Lisp.  In Lisp mode, the charac-
   ters Tab and ) are treated  specially,  similar  to  the  way  they  are
   treated in C mode.  Also, Auto Indent mode is affected, and handled spe-
   cially.

   16.137.  list-buffers                                      ^X-^B

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

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









   JOVE Manual for UNIX Users                                     USD:17-55


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

   16.138.  list-processes                                    [Unbound]

   This makes a list somewhat like list-buffers does, except its list  con-
   sists  of  the  current interactive processes.  Right now the list looks
   like this:

            Buffer           Status           Pid    Command
            ------           ------           ---    -------
            *shell*          Running          18415shell
            fgrep            Done             18512   fgrep -n Buffer *.c

   The first column has the name of the buffer  to  which  the  process  is
   attached.   The  second  has the status of the process; if a process has
   exited normally the status is ``Done''  as  in  fgrep;  if  the  process
   exited  with  an  error the status is ``Exit N'' where N is the value of
   the exit code; if the process was killed by some signal  the  status  is
   the  name of the signal that was used; otherwise the process is running.
   The last column is the name of the command that is being run.

   16.139.  mail-check-frequency                              (variable)

   This is how often (in seconds) JOVE should check your mailbox for incom-
   ing  mail.   If you set this to ZERO JOVE won't check for new mail.  See
   also the mailbox and disable-biff variables.

   16.140.  mailbox                                           (variable)

   Set this to the full pathname of your mailbox.  JOVE will look  here  to
   decide  whether  or  not  you  have  any  unread mail.  This defaults to
   /usr/spool/mail/$USER, where $USER is set to your login name.

   16.141.  make-backup-files                                 (variable)

   If this variable is set, then whenever JOVE writes out a file,  it  will
   move   the   previous  version  of  the  file  (if  there  was  one)  to
   ``filename.''  This is often convenient if you save a file by  accident.
   The  default  value  of  this  variable  is  ``off.''  Note:  this is an
   optional part of JOVE, and your guru may not have it enabled, so it  may
   not work.










   USD:17-56                                     JOVE Manual for UNIX Users


   16.142.  make-buffer-unmodified                            ESC-~

   This makes JOVE think the selected buffer hasn't been changed even if it
   has.  Use this when you accidentally change the buffer but don't want it
   considered changed.  Watch the mode line to see the * disappear when you
   use this command.

   16.143.  make-keymap                                       [Unbound]

   This creates an empty keymap with a name you supply.  That name  can  be
   used  to reference the keymap in other commands, such as bind-keymap-to-
   key.

   16.144.  make-macro-interactive                            ESC-i

   This command is meaningful only while you are defining a keyboard macro,
   and  when  you  are  in the minibuffer.  Ordinarily, when a command in a
   macro definition requires a trailing text argument  (file  name,  search
   string, etc.), the argument you supply becomes part of the macro defini-
   tion.  If you want to be able to supply a different argument  each  time
   the  macro  is used, then while you are defining it, you should give the
   make-macro-interactive command just before  typing  the  argument  which
   will be used during the definition process.

   16.145.  mark-threshold                                    (variable)

   This variable contains the number of lines point may move by before  the
   mark  is  set.   If,  in a search or something, point moves by more than
   this many lines, the mark is set so that you  may  return  easily.   The
   default value of this variable is 22 (one screenful, on most terminals).

   16.146.  marks-should-float                                (variable)

   When this variable is ``off,'' the position of a mark is remembered as a
   line  number  within  the buffer and a character number within the line.
   If you add or delete text before the mark, it will no  longer  point  to
   the  text  you  marked  originally because that text is no longer at the
   same line and character number.  When this variable is ``on,'' the posi-
   tion  of  a  mark is adjusted to compensate for each insertion and dele-
   tion.  This makes marks much more sensible to use, at the cost of  slow-
   ing down insertion and deletion somewhat.  The default value is ``on.''

   16.147.  match-regular-expressions                         (variable)

   When set, JOVE will match regular expressions in search patterns.   This
   makes special the characters ., *, [, ], ^, and $, and the two-character
   sequences \<, \>, \{, \}  and  \|.   See  the  ed(1)  manual  page,  the
   tutorial  ``Advanced Editing in UNIX ,'' and the section above ``Search-
   ing with Regular Expressions'' for more information.

   16.148.  meta-key                                          (variable)

   You should set this variable to ``on'' if your terminal has a real  Meta
   key.   If  your  terminal has such a key, then a key sequence like ESC Y









   JOVE Manual for UNIX Users                                     USD:17-57


   can be entered by holding down Meta and typing Y.  NOTE:  In  some  sys-
   tems, this disables interrupting noninteractive shell commands.

   16.149.  mode-line                                         (variable)

   The format of the mode line can be determined by setting this  variable.
   The  items in the line are specified using a format similar to that used
   by printf(3), with the special things being marked  as  ``%x.''   Digits
   may be used between the 'x' may be:

                C    check for new mail, and displays [New mail] if there
                     is any (see also the mail-check-interval and disable-biff
                     variables)
                F    the current file name, with leading path stripped
                M    the current list of major and minor modes
                b    the current buffer name
                c    the fill character (-)
                d    the current directory
                e    extra space in modeline is distributed evenly
                     among the place %e is used (used for justifying,
                     separating, or centering parts of the modeline)
                f    the current file name
                l    the current load average (updated automatically)
                mxy  x, when the buffer is modified or y, when not
                n    the current buffer number
                p    interactive process status for process windows
                s    space, but only if previous character is not a space
                t    the current time (updated automatically)
                w    a '>' for windows which are scrolled left
                [ ]  the square brackets printed when in a recursive edit
                ( )  items enclosed in %( ... %) will only be printed on
                     the bottom mode line, rather than copied when the
                     window is split

   In addition, any other character is simply copied into  the  mode  line.
   Characters may be escaped with a backslash.  To get a feel for all this,
   try typing ``ESC X print mode-line'' and compare the  result  with  your
   current mode line.

   16.150.  mode-line-should-standout                         (variable)

   If set, the mode line will be printed in reverse video, if your terminal
   supports it.  The default for this variable is ``off.''

   16.151.  name-kbd-macro                                    [Unbound]

   This copies the keyboard macro and gives it a name freeing up  the  key-
   board macro so you can define some more.  Keyboard macros with their own
   names can be bound to keys just like built in  commands  can.   See  the
   define-macro, source and write-macros-to-file commands.

   16.152.  newline                                           Return or ^M

   This divides the current line at point moving all the text to the  right









   USD:17-58                                     JOVE Manual for UNIX Users


   of  point  down  onto  the  newly created line.  Point moves down to the
   beginning of the new line.

   16.153.  newline-and-backup                                ^O

   This divides the current line at point moving all the text to the  right
   of  point down onto the newly created line.  The difference between this
   and ``newline'' is that point does not move down to the beginning of the
   new line.

   16.154.  newline-and-indent                                ^J

   This behaves the same was as Return does when in Auto Indent mode.  This
   makes  Auto  Indent mode obsolete but it remains in the name of backward
   compatibility.

   16.155.  next-error                                        ^X-^N

   This moves to the next error in the list of errors that were parsed with
   parse-errors.   In  one  window  the  list  of  errors is shown with the
   current one always at the top.  In another window is the file that  con-
   tains  the  error.  Point is positioned in this window on the line where
   the error occurred.

   16.156.  next-line                                         ^N

   This moves down to the next line.

   16.157.  next-page                                         ^V

   This displays the next page of the buffer by taking the bottom  line  of
   the  window and redrawing the window with it at the top.  If there isn't
   another page in the buffer JOVE rings the bell.  If a  numeric  argument
   is  supplied  the screen is scrolled up that many lines; if the argument
   is negative the screen is scrolled down.

   16.158.  next-window                                       ^X-n

   This moves into the next window.  Windows live in  a  circular  list  so
   when you're in the bottom window and you try to move to the next one you
   are moved to the top window.  It is an error to use  this  command  with
   only one window.

   16.159.  number-lines-in-window                            [Unbound]

   This displays the line  numbers  for  each  line  in  the  buffer  being
   displayed.   The  number  isn't  actually  part  of  the text; it's just
   printed before the actual buffer line is.  To turn this off you run  the
   command again; it toggles.

   16.160.  over-write-mode                                   [Unbound]

   This turns Over Write mode on (or off  if  it's  currently  on)  in  the
   selected  buffer.  When on, this mode changes the way the self-inserting









   JOVE Manual for UNIX Users                                     USD:17-59


   characters work.  Instead of inserting themselves and pushing  the  rest
   of  the  line over to the right, they replace or over-write the existing
   character.  Also, ^H replaces the character before point  with  a  space
   instead  of  deleting  it.   When  Over  Write  mode  is on ``OvrWt'' is
   displayed on the mode line.

   16.161.  page-next-window                                  ESC-^V

   This displays the next page in the next window.   This  is  exactly  the
   same as ^X-n ^V ^X-p.

   16.162.  paren-flash                                       ) } ]

   This handles the C mode curly brace indentation,  the  Lisp  mode  paren
   indentation,  and  the  Show Match mode paren/curly brace/square bracket
   flashing.

   16.163.  paren-flash-delay                                 (variable)

   How long, in  tenths  of  seconds,  JOVE  should  pause  on  a  matching
   parenthesis in Show mode.  The default is 5.

   16.164.  parse-errors                                      [Unbound]

   This takes the list of C compilation errors (or output from another pro-
   gram  in  the same format) in the current buffer and parses them for use
   with the next-error and previous-error and current-error commands.  This
   is  a very useful tool and helps with compiling C programs and when used
   in conjunction with the ``grep'' UNIX command  very  helpful  in  making
   changes  to  a bunch of files.  This command understands errors produced
   by cc, cpp, and lint; plus any other program with the same format (e.g.,
   ``grep  -n'').   JOVE  visits  each file that has an error and remembers
   each line that contains an error.  It doesn't matter if later you insert
   or  delete  some  lines in the buffers containing errors; JOVE remembers
   where they are  regardless.   current-error  is  automatically  executed
   after  one of the parse commands, so you end up at the first error.  See
   also error-format-string to make it possible to parse errors of  a  dif-
   ferent format.

   16.165.  parse-spelling-errors-in-buffer                   [Unbound]

   This parses a list of words in the current buffer and looks them  up  in
   another buffer that you specify.  This will probably go away soon.

   16.166.  pause-jove                                        ESC-p

   This stops JOVE and returns control to  the  parent  shell.   This  only
   works for users using the C-shell, and on systems that have the job con-
   trol facility.  To return to JOVE you type fg to the shell.

   16.167.  physical-tabstop                                  (variable)

   How many spaces your terminal prints when it prints a tab character.










   USD:17-60                                     JOVE Manual for UNIX Users


   16.168.  pop-mark                                          [Unbound]

   This gets executed when you run set-mark with a numeric argument.   JOVE
   remembers  the last 16 marks and you use pop-mark to go backward through
   the ring of marks.  If you execute pop-mark enough times you will  even-
   tually get back to where you started.

   16.169.  popd                                              [Unbound]

   This pops one entry off the directory stack.  Entries  are  pushed  with
   the  pushd  command.   The  names  were  stolen from the C-shell and the
   behavior is the same.

   16.170.  previous-error                                    ^X-^P

   This is the same as next-error except it goes  to  the  previous  error.
   See next-error for documentation.

   16.171.  previous-line                                     ^P or ^P-^P

   This moves up to the previous line.

   16.172.  previous-page                                     ESC-v

   This displays the previous page of the current buffer by taking the  top
   line and redrawing the window with it at the bottom.  If a numeric argu-
   ment is supplied the screen is scrolled down that  many  lines;  if  the
   argument is negative the screen is scrolled up.

   16.173.  previous-window                                   ^X-p or ^X-o

   This moves into the next window.  Windows live in  a  circular  list  so
   when  you're  in  the top window and you try to move to the previous one
   you are moved to the bottom window.  It is an error to use this  command
   with only one window.

   16.174.  print                                             [Unbound]

   This prints the value of a JOVE variable.

   16.175.  process-bind-keymap-to-key                        [Unbound]

   This is just like bind-to-key except that  it  starts  at  the  process-
   keymap map, instead of the default mainmap.

   16.176.  process-bind-to-key                               [Unbound]

   This command is identical to bind-to-key, except that  it  only  affects
   your  bindings when you are in a buffer attached to a process.  When you
   enter the process buffer, any keys bound with this command will automat-
   ically  take their new values.  When you switch to a non-process buffer,
   the old bindings for those keys will  be  restored.   For  example,  you
   might want to execute










   JOVE Manual for UNIX Users                                     USD:17-61



           process-bind-to-key stop-process ^Z
           process-bind-to-key interrupt-process ^C

   Then, when you start up an interactive  process  and  switch  into  that
   buffer, ^Z will execute stop-process and ^C will execute interrupt- pro-
   cess.  When you switch back to a non-process buffer, ^Z will go back  to
   executing scroll-up (or whatever you have it bound to).

   16.177.  process-dbx-output                                [Unbound]

   This command only makes sense in a buffer running a shell  process.   If
   you  are  running dbx in a window, JOVE will automatically find the file
   you are currently stepping through and display  it  in  another  window.
   The  string  DBX  will appear in the modeline along with the other minor
   modes when this feature is enabled.

   16.178.  process-newline                                   [Unbound]

   This only gets executed  when  in  a  buffer  that  is  attached  to  an
   interactive-process.   JOVE does two different things depending on where
   you are when you hit Return.  When you're at the end  of  the  I-Process
   buffer  this  does  what  Return normally does, except it also makes the
   line available to the process.  When point is positioned at  some  other
   position  that  line is copied to the end of the buffer (with the prompt
   stripped) and point is moved there with it, so you can  then  edit  that
   line  before  sending  it to the process.  This command must be bound to
   the key you usually use to enter shell commands (Return),  or  else  you
   won't be able to enter any.

   16.179.  process-prompt                                    (variable)

   What a prompt looks like from the shell and  i-shell-command  processes.
   The  default  is  ``% ,'' the default C-hell prompt.  This is actually a
   regular expression search string.  So you can set it to be more than one
   thing  at  once  using the \| operator.  For instance, for LISP hackers,
   the prompt can be

           ``% \|-> \|<[0-9]>:''.


   16.180.  process-send-data-no-return                       [Unbound]

   This is like process-newline except it sends everything to  the  process
   without the newline.  Normally, when you type return in a process buffer
   it sends everything you typed including the Return.  This  command  just
   provides a way to send data to the process without having to send a new-
   line as well.

   16.181.  push-shell                                        [Unbound]

   This spawns a child shell and relinquishes control to it.  This works on
   any  version  of  UNIX,  but this isn't as good as pause-jove because it
   takes time to start up the new shell and you get a brand new environment









   USD:17-62                                     JOVE Manual for UNIX Users


   every time.  To return to JOVE you type ^D.

   16.182.  pushd                                             [Unbound]

   This pushes a directory onto the directory stack and cd's into  it.   It
   asks for the directory name but if you don't specify one it switches the
   top two entries no the stack.  It  purposely  behaves  the  same  as  C-
   shell's pushd.

   16.183.  pwd                                               [Unbound]

   This prints the working directory.

   16.184.  query-replace-string                              ESC-q

   This replaces the occurrences of a specified  string  with  a  specified
   replacement  string.   When  an occurrence is found point is moved to it
   and then JOVE asks what to do.  The options are:

           Spaceto replace this occurrence and go on to the next one.
           Periodto replace this occurrence and then stop.
           ^H   to skip this occurrence and go on to the next one.
           ^R   to enter a recursive edit.  This lets you temporarily
                suspend the replace, do some editing, and then return
                to continue where you left off.  To continue with the
                Query Replace type ^X-^C as if you were trying to
                exit JOVE.  Normally you would but when you are in a
                recursive edit all it does is exit that recursive
                editing level.
           ^W   to delete the matched string and then enter a recursive
                edit.
           U    to undo all changes to the last modified line.
           P or !to go ahead and replace the remaining occurrences without
                asking.
           Returnto stop the Query Replace.

   The search for occurrences starts at point and goes to the  end  of  the
   buffer,  so  to  replace  in  the entire buffer you must first go to the
   beginning.

   16.185.  quit-process                                      [Unbound]

   This is the same as typing ``^\'' (the Quit character) to a normal  UNIX
   process,  except  it  sends  it to the current process in JOVE.  This is
   only for versions of JOVE that have the interactive  processes  feature.
   This  only  works when you are inside a buffer that's attached to a pro-
   cess.

   16.186.  quoted-insert                           ^~ or ^_ or ^/ or ^.

   This lets you insert characters that normally would be executed as other
   JOVE commands.  For example, to insert ``^F'' you type ^~ ^F.











   JOVE Manual for UNIX Users                                     USD:17-63


   16.187.  read-only-mode                                    [Unbound]

   Read-only-mode is a minor mode.  It puts a buffer in read-only mode,  so
   that  any attempts to modify the buffer fail.  When a file is found, and
   it's not got write permission, JOVE automatically  puts  the  buffer  in
   read-only mode.  This is very helpful when you are in environments which
   use source control programs like RCS and SCCS.   It  prevents  accidents
   like  making  a  bunch  of  changes  and  only THEN discovering that you
   haven't checked the file out for making changes.  This, like other minor
   modes, toggles.

   16.188.  read-word-abbrev-file                             [Unbound]

   This reads a specified file that contains a bunch of abbreviation defin-
   itions, and makes those abbreviations available.  If the selected buffer
   is not already in Word Abbrev mode this command puts it in that mode.

   16.189.  recursive-edit                                    [Unbound]

   This enters a recursive editing level.  This isn't really  very  useful.
   I  don't know why it's available for public use.  I think I'll delete it
   some day.

   16.190.  redraw-display                                    ESC-^L

   This centers the line containing point in the window.  If that  line  is
   already  in the middle the window is first cleared and then redrawn.  If
   a numeric argument is supplied, the line is positioned  at  that  offset
   from  the  top  of  the window.  For example, ESC-0 ESC-^L positions the
   line containing point at the top of the window.

   16.191.  rename-buffer                                     [Unbound]

   This lets you rename the current buffer.

   16.192.  replace-in-region                                 [Unbound]

   This is the same as replace-string  except  that  it  is  restricted  to
   occurrences between Point and Mark.

   16.193.  replace-string                                    ESC-^E

   This replaces all occurrences of a specified  string  with  a  specified
   replacement  string.   This  is just like query-replace-string except it
   replaces without asking.

   16.194.  right-margin                                      (variable)

   Where the right margin is for ``Auto mode and the justify-paragraph  and
   justify-region commands.  The default is 72.

   16.195.  right-margin-here                                 [Unbound]

   This sets the right-margin variable to the current  position  of  point.









   USD:17-64                                     JOVE Manual for UNIX Users


   This  is  an  easy  way  to  say,  ``Make the right margin begin here,''
   without having to count the number of spaces over it actually is.

   16.196.  save-file                                         ^X-s

   This saves the current buffer to the associated file.  This  makes  your
   changes  permanent  so  you  should  be sure you really want to.  If the
   buffer has not been modified save-file refuses to do the save.   If  you
   really  do  want  to  write  the  file  you can use ^X-^W which executes
   write-file.

   16.197.  scroll-all-lines                                  (variable)

   When this is turned on, the entire window will be scrolled left or right
   when  the  current  line  scrolls.  The default value is OFF, which will
   cause JOVE to behave in the familiar way,  namely  to  scroll  only  the
   current line.

   16.198.  scroll-down                                       ESC-z

   This scrolls the screen one line down.  If  the  line  containing  point
   moves  past  the bottom of the window point is moved up to the center of
   the window.  If a numeric argument  is  supplied  that  many  lines  are
   scrolled; if the argument is negative the screen is scrolled up instead.

   16.199.  scroll-left                                       [Unbound]

   This scrolls the text in the current window 10  character  positions  to
   the  left.  If a numeric argument is specified then the text is scrolled
   that number of character positions.  If the variable scroll-all-lines is
   ON then scroll-left may actually do nothing if the scrolling would cause
   Point not to be visible.

   16.200.  scroll-right                                      [Unbound]

   This scrolls the text in the current window 10  character  positions  to
   the right.  If a numeric argument is specified then the text is scrolled
   that number of character positions.  If the variable scroll-all-lines is
   ON  then  scroll-right  may  actually  do nothing if the scrolling would
   cause Point not to be visible.

   16.201.  scroll-step                                       (variable)

   How many lines should be scrolled if the previous-line or next-line com-
   mands  move  you  off  the top or bottom of the screen.  You may wish to
   decrease this variable if you are on a slow terminal.  The default value
   is  0,  which  means  to  center the current line in the window.  If the
   value is negative, the behavior is slightly different.  If you move  off
   the  top  of  the  window, and scroll-step is, say, -5 then the new line
   will be displayed 5 lines from the bottom of the window.   If  you  move
   off  the  bottom  of the window, the new line will be positioned 5 lines
   from the top of the window.











   JOVE Manual for UNIX Users                                     USD:17-65


   16.202.  scroll-up                                         ^Z

   This scrolls the screen one line up.  If the line containing point moves
   past the top of the window point is moved down to the center of the win-
   dow.  If a numeric argument is supplied that many lines are scrolled; if
   the argument is negative the screen is scrolled down instead.

   16.203.  search-exit-char                                  (variable)

   Set this to the character you want to use to  exit  incremental  search.
   The  default  is  Newline,  which  makes i-search compatible with normal
   string search.

   16.204.  search-forward                                    ESC-s

   This searches forward for a specified search string and positions  point
   at  the  end  of  the  string if it's found.  If the string is not found
   point remains unchanged.  This searches from point to  the  end  of  the
   buffer, so any matches before point will be missed.

   16.205.  search-forward-nd                                 [Unbound]

   This is just like search-forward except that it doesn't assume a default
   search  string,  and  it doesn't set the default search string.  This is
   useful for defining macros, when you want to search for  something,  but
   you don't want it to affect the current default search string.

   16.206.  search-reverse                                    ESC-r

   This searches backward for a specified search string and positions point
   at  the  beginning  if  the  string if it's found.  If the string is not
   found point remains unchanged.  This searches from point to  the  begin-
   ning of the buffer, so any matches after point will be missed.

   16.207.  search-reverse-nd                                 [Unbound]

   This is just like search-reverse except that it doesn't assume a default
   search  string,  and  it doesn't set the default search string.  This is
   useful for defining macros, when you want to search for  something,  but
   you don't want it to affect the current default search string.

   16.208.  select-buffer                                     ^X-b

   This selects a new or already existing buffer making it the current one.
   You  can type either the buffer name or number.  If you type in the name
   you need only type the name until it is unambiguous, at which point typ-
   ing  Escape  or Space will complete it for you.  If you want to create a
   new buffer you can type Return instead of Space, and a new empty  buffer
   will be created.

   16.209.  self-insert                             (Most Printing  Charac-
   ters)

   This inserts the character that invoked it into  the  buffer  at  point.









   USD:17-66                                     JOVE Manual for UNIX Users


   Initially  all  but  a few of the printing characters are bound to self-
   insert.

   16.210.  send-typeout-to-buffer                            (variable)

   When this is set JOVE will send  output  that  normally  overwrites  the
   screen  (temporarily)  to  a buffer instead.  This affects commands like
   list-buffers, list-processes, and commands  that  use  completion.   The
   default value is ``off.''

   16.211.  set                                               [Unbound]

   This gives a specified variable a new value.   Occasionally  you'll  see
   lines  like  ``set  this variable to that value to do this.''  Well, you
   use the set command to do that.

   16.212.  set-mark                                       ^@ or ^SPACE

   This sets the mark at the current position in the buffer.  It prints the
   message  Point pushed on the message line.  It says that instead of Mark
   set because when you set the mark the previous mark is still  remembered
   on  a  ring of 16 marks.  So Point pushed means point is pushed onto the
   ring of marks and becomes the value of ``the mark.''  To go through  the
   ring  of  marks you type ^U ^@, or execute the pop-mark command.  If you
   type this enough times you will get back to where you started.

   16.213.  shell                                             (variable)

   The shell to be used with all the shell commands command.  If your SHELL
   environment variable is set, it is used as the value of shell; otherwise
   ``/bin/csh'' is the default.

   16.214.  shell                                             [Unbound]

   This starts up an interactive shell in a window.  JOVE uses  ``*shell*''
   as the name of the buffer in which the interacting takes place.  See the
   manual for information on how to use interactive processes.

   16.215.  shell-command                                     ^X-!

   This runs a UNIX command and places the output from that  command  in  a
   buffer.   JOVE creates a buffer that matches the name of the command you
   specify and then attaches that buffer to a window.  So,  when  you  have
   only one window running this command will cause JOVE to split the window
   and attach the new buffer to that window.   Otherwise,  JOVE  finds  the
   most  convenient of the available windows and uses that one instead.  If
   the buffer already exists it is first emptied, except that if it's hold-
   ing  a  file,  not  some  output from a previous command, JOVE prints an
   error message and refuses to execute the command.  If you really want to
   execute  the  command you should delete that buffer (saving it first, if
   you like) or use shell-command-to-buffer, and try again.












   JOVE Manual for UNIX Users                                     USD:17-67


   16.216.  shell-command-no-buffer                           [Unbound]

   This is just like shell-command except it just runs the command  without
   saving the output to any buffer.  It will report the success of the com-
   mand in the usual way.

   16.217.  shell-command-to-buffer                           [Unbound]

   This is just like shell-command except it lets you specify the buffer to
   use instead of JOVE.

   16.218.  shell-command-with-typeout                        [Unbound]

   This is just like shell-command except that instead of saving the output
   to a buffer, and displaying it in a window, this just types out the out-
   put in the same way that list-buffers does.  Actually, how this  behaves
   depends  on  the value of the variable send-typeout-to-buffer.  If it is
   on then shell-command-with-typeout will behave just like shell-command.

   16.219.  shell-flags                                       (variable)

   This defines the flags that are passed to shell commands.   The  default
   is ``-c.''  See the shell variable to change the default shell.

   16.220.  shift-region-left                                 [Unbound]

   This shifts the region left by c-indentation-increment OR by the numeric
   argument,  if  one  is supplied.  If a negative argument is supplied the
   region is shifted the other way.

   16.221.  shift-region-right                                [Unbound]

   This shifts the region left by c-indentation-increment OR by the numeric
   argument,  if  one  is supplied.  If a negative argument is supplied the
   region is shifted the other way.

   16.222.  show-match-mode                                   [Unbound]

   This turns on Show Match mode (or off  if  it's  currently  on)  in  the
   selected  buffer.  This changes ``}'', ``)'' and ``]'' so that when they
   are typed the are inserted as usual, and then the cursor flashes back to
   the  matching  ``{'',  ``(''  or ``['' (depending on what was typed) for
   about half a second, and then goes back to just after the  ``}'',  ``)''
   or ``]'' that invoked the command.  This is useful for typing in compli-
   cated expressions in a program.  You can change how long the cursor sits
   on  the  matching  paren  by  setting  the paren-flash-delay variable in
   tenths of a second.  If the matching ``{'', ``('' or ``[''  isn't  visi-
   ble,  the  line  containing  the match is displayed at the bottom of the
   screen.

   16.223.  shrink-window                                     [Unbound]

   This makes the current window one line shorter,  if  possible.   Windows
   must  be  at  least 2 lines high, one for the text and the other for the









   USD:17-68                                     JOVE Manual for UNIX Users


   mode line.

   16.224.  source                                            [Unbound]

   This reads a bunch of JOVE commands from a file.  The format of the file
   is  the  same  as that in your initialization file (your ``.joverc'') in
   your main directory.  There should be one command per line and it should
   be as though you typed ESC X while in JOVE.  For example, here's part of
   my initialization file:

           bind-to-key i-search-reverse ^R
           bind-to-key i-search-forward ^S
           bind-to-key pause-jove ^[S

   What they do is make ^R call the i-search-reverse command  and  ^S  call
   i-search-forward and ESC S call pause-jove.

   16.225.  spell-buffer                                      [Unbound]

   This runs the current buffer through the UNIX spell program  and  places
   the  output  in  buffer  ``Spell.''  Then JOVE lets you edit the list of
   words, expecting you to delete the ones that you don't care about, i.e.,
   the  ones  you  know  are  spelled  correctly.  Then the parse-spelling-
   errors-in-buffer command comes along and finds all the misspelled  words
   and sets things up so the error commands work.

   16.226.  split-current-window                              ^X-2

   This splits the current window  into  two  equal  parts  (providing  the
   resulting  windows would be big enough) and displays the selected buffer
   in both windows.  Use ^X-1 to go back to 1 window mode.   If  a  numeric
   argument  is  supplied,  the  window is split ``evenly'' that many times
   (when possible).

   16.227.  start-remembering                                 ^X-(

   This is just another name for the begin-kbd-macro name.  It is  included
   for backward compatibility.

   16.228.  stop-process                                      [Unbound]

   This sends a stop signal (^Z, for most people) to the  current  process.
   It  only  works if you have the interactive process feature, and you are
   in a buffer attached to a process.

   16.229.  stop-remembering                                  ^X-)

   This is just another name for the end-kbd-macro command.  It is included
   for backward compatibility.

   16.230.  string-length                                     ^X-c

   This prints the number of characters in the string that point  sits  in.
   Strings  are  surrounded  by double quotes.  JOVE knows that ``\007'' is









   JOVE Manual for UNIX Users                                     USD:17-69


   considered a single character, namely ^G, and  also  knows  about  other
   common ones, like ``\r'' (Return) and ``\n'' (LineFeed).  This is mostly
   useful only for C programmers.

   16.231.  suspend-jove                                      ESC-p

   This is a synonym for pause-jove.

   16.232.  sync-frequency                                    (variable)

   The temporary files used by JOVE are forced  out  to  disk  every  sync-
   frequency  modifications.   The  default  is 50, which really makes good
   sense.  Unless your system is very unstable, you probably shouldn't fool
   with this.

   16.233.  tag-file                                          (variable)

   This the name of the file in which JOVE should look up tag  definitions.
   The default value is ``./tags.''

   16.234.  text-mode                                         [Unbound]

   This sets the major mode to Text.  Currently the other modes are  Funda-
   mental, C and Lisp mode.

   16.235.  tmp-file-pathname                                 (variable)

   This tells JOVE where to put the tmp files, which is where  JOVE  stores
   buffers  internally.  The default is usually in /tmp, but if you want to
   store them somewhere else, you can set this variable.   If  your  system
   crashes  a lot it might be a good idea to set this variable to somewhere
   other than /tmp because the system removes all the files  in  /tmp  upon
   reboot, and so you would not be able to recover editor buffers using the
   ``jove -r'' command.

   NOTE: In order for this to work correctly you  must  set  this  variable
   BEFORE JOVE creates the tmp file.  You can set this in your .joverc (the
   closer to tbe beginning the better), or as soon as  you  start  up  JOVE
   before you visit any files.

   16.236.  transpose-characters                              ^T

   This switches the character before point with the one after  point,  and
   then moves forward one.  This doesn't work at the beginning of the line,
   and at the end of the line it switches the two characters before  point.
   Since  point  is  moved  forward,  so that the character that was before
   point is still before point, you can use ^T to drag a character down the
   length of a line.  This command pretty quickly becomes very useful.

   16.237.  transpose-lines                                   [Unbound]

   This switches the current line with the one above  it,  and  then  moves
   down  one  so  that  the line that was above point is still above point.
   This, like transpose-characters, can be used to drag a line down a page.









   USD:17-70                                     JOVE Manual for UNIX Users


   16.238.  unbind-key                                        [Unbound]

   Use this to unbind any key sequence.  You can use this to unbind even  a
   prefix  command, since this command does not use ``key-map completion.''
   For example, ``ESC X unbind-key ESC ['' unbinds the sequence ``ESC  [.''
   This  is  useful  for  ``turning  off'' something set in the system-wide
   ``.joverc'' file.

   16.239.  update-time-frequency                             (variable)

   How often the mode line is updated (and thus the time and load  average,
   if you display them).  The default is 30 seconds.

   16.240.  use-i/d-char                                      (variable)

   If your terminal has insert/delete character  capability  you  can  tell
   JOVE not to use it by setting this to ``off.''  In my opinion it is only
   worth using insert/delete character at low baud rates.  WARNING: if  you
   set this to ``on'' when your terminal doesn't have insert/delete charac-
   ter capability, you will get weird (perhaps fatal) results.

   16.241.  version                                           [Unbound]

   Displays the version number of this JOVE.

   16.242.  visible-bell                                      (variable)

   Use the terminal's  visible  bell  instead  of  beeping.   This  is  set
   automatically if your terminal has the capability.

   16.243.  visible-spaces-in-window                          [Unbound]

   This displays an underscore character instead of each space in the  win-
   dow  and  displays a greater-than followed by spaces for each tab in the
   window.  The actual text in the buffer is not changed; only  the  screen
   display  is  affected.   To  turn this off you run the command again; it
   toggles.

   16.244.  visit-file                                        ^X-^V

   This reads a specified file into the current buffer  replacing  the  old
   text.   If  the  buffer needs saving JOVE will offer to save it for you.
   Sometimes you use this to start over, say if you make  lots  of  changes
   and  then  change  your mind.  If that's the case you don't want JOVE to
   save your buffer and you answer ``NO'' to the question.

   16.245.  window-find                                       ^X-4

   This lets you select another buffer in another  window  three  different
   ways.   This waits for another character which can be one of the follow-
   ing:












   JOVE Manual for UNIX Users                                     USD:17-71



           T    Finds a tag in the other window.
           ^T   Finds the tag at point in the other window
           F    Finds a file in the other window.
           B    Selects a buffer in the other window.

   This is just a convenient short hand for ^X-2  (or  ^X-o  if  there  are
   already  two  windows) followed by the appropriate sequence for invoking
   each command.  With this, though, there isn't the extra overhead of hav-
   ing to redisplay.  In addition, you don't have to decide whether to type
   ^X-2 or ^X-o since ^X-O ^X-4 does the right thing.

   16.246.  word-abbrev-mode                                  [Unbound]

   This turns on Word Abbrev mode (or off if  it's  currently  on)  in  the
   selected buffer.  Word Abbrev mode lets you specify a word (an abbrevia-
   tion) and a phrase with which JOVE should substitute  the  abbreviation.
   You  can  use  this  to  define words to expand into long phrases, e.g.,
   ``jove'' can expand into ``Jonathan's Own Version  of  Emacs;''  another
   common  use  is  defining words that you often misspell in the same way,
   e.g., ``thier'' => ``their'' or ``teh'' => ``the.''  See the information
   on the auto-case-abbrev variable.

   There are two kinds of abbreviations: mode specific and global.  If  you
   define  a  Mode  specific abbreviation in C mode, it will expand only in
   buffers that are in C mode.  This is so you can have the same  abbrevia-
   tion  expand  to  different  things  depending  on your context.  Global
   abbreviations expand regardless of the major mode of  the  buffer.   The
   way  it  works is this: JOVE looks first in the mode specific table, and
   then in the global table.  Whichever it finds it in  first  is  the  one
   that's  used  in  the expansion.  If it doesn't find the word it is left
   untouched. JOVE tries to expand words as they are typed, when you type a
   punctuation  character or Space or Return.  If you are in Auto Fill mode
   the expansion will be filled as if you typed it yourself.

   16.247.  wrap-search                                       (variable)

   If set, searches will ``wrap around'' the ends of the buffer instead  of
   stopping at the bottom or top.  The default is ``off.''

   16.248.  write-file                                        ^X-^W

   This saves the current buffer to a specified file, and then  makes  that
   file  the default file name for this buffer.  If you specify a file that
   already exists you are asked to confirm over-writing it.

   16.249.  write-files-on-make                               (variable)

   When set, all modified files will be written  out  before  calling  make
   when the compile-it command is executed.  The default is ``on.''

   16.250.  write-macros-to-file                              [Unbound]

   This writes the currently defined macros to a specified file in a format









   USD:17-72                                     JOVE Manual for UNIX Users


   appropriate  for reading them back in with the source command.  The pur-
   pose of this command is to allow you to define macros once and use  them
   in other instances of JOVE.

   16.251.  write-modified-files                       ^X-^M or ^X-RETURN

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

   16.252.  write-region                                      [Unbound]

   This writes the text in the region to a specified  file.   If  the  file
   already exists you are asked to confirm over-writing it.

   16.253.  write-word-abbrev-file                            [Unbound]

   This writes the currently defined abbreviations  to  a  specified  file.
   They  can  be  read  back  in  and automatically defined with read-word-
   abbrev-file.

   16.254.  yank                                              ^Y

   This undoes the last kill command.  That is, it inserts the killed  text
   at  point.  When you do multiple kill commands in a row, they are merged
   so that yanking them back with ^Y yanks back all of them.

   16.255.  yank-pop                                          ESC-y

   This yanks back previous killed text.  JOVE has a kill ring on which the
   last 10 kills are stored.  yank yanks a copy of the text at the front of
   the ring.  If you want one of the last ten kills  you  use  ESC-y  which
   rotates  the  ring  so another different entry is now at the front.  You
   can use ESC-y only immediately following a ^Y or another ESC-y.  If  you
   supply  a  negative  numeric argument the ring is rotated the other way.
   If you use this command enough times in a row you  will  eventually  get
   back  to  where you started.  Experiment with this.  It's extremely use-
   ful.


WE REALLY WANT TO KNOW...
Have you found this publication useful? Are there ways we might improve or supplement it or other ITC publications? Did you find this document in Web or in hard copy? We really want your opinion. Send e-mail to:  newsdesk@virginia.edu

© 2009 by the Rector and Visitors of the University of Virginia.

The information contained on the University of Virginia’s Department of Information Technology and Communication (ITC) website is provided as a public service with the understanding that ITC makes no representations or warranties, either expressed or implied, concerning the accuracy, completeness, reliability or suitability of the information, including warrantees of title, non-infringement of copyright or patent rights of others. These pages are expected to represent the University of Virginia community and the State of Virginia in a professional manner in accordance with the University of Virginia’s Computing Policies.