Provided by: jove_4.17.2.7-1_amd64 bug


       jove - an interactive display-oriented text editor


       jove  [ -d directory ] [ -D debugfile ] [ -l libdir ] [ -s sharedir ] [ -ls bothdir ] [ -J
       ] [ -j ] [ -wn ] [ -t tag ] [ +n file ] [ +/pattern file ] [ -p file ] [ file...  ]
       jove -r


       JOVE is Jonathan's Own Version of Emacs.  It is based on the original EMACS editor written
       at MIT by Richard Stallman.  Although JOVE is meant to be compatible with EMACS, there are
       some major differences between the two editors and you shouldn't rely  on  their  behaving

       JOVE  works  on any reasonable display terminal that is described in the termcap file (see
       TERMCAP(5) for more details).  When you start up JOVE, it checks to see whether  you  have
       your TERM environment variable set.  On most systems that will automatically be set up for
       you, but if it's not JOVE will ask you what kind of terminal  you  are  using.   To  avoid
       having  to  type  this  every time you run JOVE you can set your TERM environment variable
       yourself.  How you do this depends on which shell you are running.  If you are running the
       C Shell, as most of you are, you type

            % setenv TERM type

       and with the Bourne Shell, you type

            $ TERM= type ; export TERM

       where type is the name of the kind of terminal you are using (e.g., vt100).  If neither of
       these works get somebody to help you.


       If you run JOVE with no arguments you will be placed in  an  empty  buffer,  called  Main.
       Otherwise,  any  arguments  you supply are considered file names and each is ``given'' its
       own buffer.  Only the first file is actually read in — reading  other  files  is  deferred
       until  you actually try to use the buffers they are attached to.  This is for efficiency's
       sake: most of the time, when you run JOVE on a big list of files, you end up editing  only
       a few of them.

       The  names of all of the files specified on the command line are saved in a buffer, called
       *minibuf*.  The mini-buffer is a special JOVE buffer that is used when JOVE  is  prompting
       for  some  input  to  many commands (for example, when JOVE is prompting for a file name).
       When you are being prompted for a file name, you can type ^N (that's Control-N) and ^P  to
       cycle  through  the  list of files that were specified on the command line.  The file name
       will be inserted where you are typing and then you can edit it  as  if  you  typed  it  in

       JOVE recognizes the following switches:

       -d dirname
              dirname is taken to be the name of the current directory.  This is for systems that
              don't have a version of C shell that automatically maintains  the  CWD  environment
              variable.  If -d is not specified on a system without a modified C shell, JOVE will
              have to figure out the current directory itself, and that can  be  slow.   You  can
              simulate  the  modified  C  shell  by  putting  the following lines in your C shell
              initialization file (.cshrc):

                   alias cd        'cd \!*; setenv CWD $cwd'
                   alias popd      'popd \!*; setenv CWD $cwd'
                   alias pushd     'pushd \!*; setenv CWD $cwd'
              -D debugfile debugfile is created if missing, and some  internal  debug  output  is
              written  to  it.   Only  for developers (or filing with bug reports on interactive-
              shell misbehaviour)

       -l libdir
              Allows the user to specify the directory in which binary files required by JOVE can
              be found (default /usr/lib/jove).

       -s sharedir
              Allows  the user to specify the directory in which initialization files required by
              JOVE can be found (default /usr/share/jove).

       -ls bothdir
              Allows the user to specify the directory in which binary files  and  initialization
              files required by JOVE can be found.

       -J     Inhibits reading of the system-wide initialization file (/usr/share/jove/jove.rc).

       -j     Inhibits reading of the user's initialization file (~/.joverc).

       +n     Reads  the  file  designated  by the following argument, and positions point at the
              n'th line instead of the (default) first line.  This can  be  specified  more  than
              once  but  it doesn't make sense to use it twice on the same file; in that case the
              second one wins.  If no numeric argument  is  given  after  the  +,  the  point  is
              positioned at the end of the file.

              Reads  the  file  designated  by the following argument, and positions point at the
              first match of the pattern.

       -p file
              Parses the error messages in file.  The error messages  are  assumed  to  be  in  a
              format similar to the C compiler, LINT, or GREP output.

       -t tag Runs the find-tag command on tag (see ctags(1)).

       -wn    Divides  the  window  into  n  windows  (if  n  is  omitted,  it is taken to be 2).
              Subsequent files in the list are read in and displayed in succeeding windows.


       The -r option of jove runs the JOVE recover program.  Use this when the system crashes, or
       JOVE  crashes, or you accidentally get logged out while in JOVE.  If there are any buffers
       to be recovered, this will find them.

       Recover looks for JOVE buffers that are left around and are owned  by  you.   (You  cannot
       recover  other  peoples' buffers, obviously.)  If there were no buffers that were modified
       at the time of the crash or there were but recover can't get its hands on them,  you  will
       be  informed with the message, ``There is nothing to recover.''  Otherwise, recover prints
       the date and time of the version of the buffers it has, and then  waits  for  you  type  a

       To  get  a  list of the buffers recover knows about, use the list command.  This will list
       all the buffers and the files and the number of lines associated with them.  Next to  each
       buffer  is  a number.  When you want to recover a buffer, use the get command.  The syntax
       is get buffer filename where buffer is either the buffer's  name  or  the  number  at  the
       beginning  of  the  line.  If you don't type the buffer name or the filename, recover will
       prompt you for them.

       If there are a lot of buffers and you want  to  recover  all  of  them,  use  the  recover
       command.  This will recover each buffer to the name of the buffer with ``.#'' prepended to
       the name (so that the original isn't over-written).  It asks for each file and if you want
       to restore that buffer to that name you type ``yes''.  If you want to recover the file but
       to a different name, just type the new name in.  If you type ``no'' recover will skip that
       file and go on to the next one.

       If you want to look at a buffer before deciding to recover it, use the print command.  The
       syntax for this is print buffer where buffer again is either its name or the number.   You
       can  type  ^C  if  you  want  to abort printing the file to the terminal, and recover will
       respond with an appropriate message.

       When you're done and have all the buffers you want, type the quit command to  leave.   You
       will  then  be  asked  whether it's okay to delete the tmp files.  Most of the time that's
       okay and you should type ``yes''.  When you say that, JOVE removes  all  traces  of  those
       buffers  and you won't be able to look at them again.  (If you recovered some buffers they
       will still be around, so don't worry.)  So, if you're not sure whether you've  gotten  all
       the  buffers,  you  should  answer ``no'' so that you'll be able to run recover again at a
       later time (presumably after you've figured out which ones you want to  save).   If  there
       were  more  than  one crashed JOVE session, quit will move you on to dealing with the next
       one instead of exiting.

       If you type ^C at any time other than when you're printing a file to the terminal, recover
       will  exit  without  a word.  If you do this but wish you hadn't, just type ``jove -r'' to
       the shell again, and you will be put back with no loss.


       Once in JOVE, there are several commands available to  get  help.   To  execute  any  JOVE
       command, you type ``<ESC> X command-name'' followed by <Return>.  To get a list of all the
       JOVE commands you type ``<ESC> X'' followed by ``?''.  The describe-bindings  command  can
       be  used  to  get  a  list  containing  each key, and its associated command (that is, the
       command that gets executed when you type that key).  If you  want  to  save  the  list  of
       bindings,  you  can  set  the  jove  variable  send-typeout-to-buffer to ON (using the set
       command), and then execute the describe-bindings command.  This will create a  buffer  and
       put  in  it  the bindings list it normally would have printed on the screen.  Then you can
       save that buffer to a file and print it to use as a quick reference card.  (See  VARIABLES

       Once  you  know  the  name  of a command, you can find out what it does with the describe-
       command command, which you can invoke quickly by typing ``ESC ?''.   The  apropos  command
       will  give  you  a  list  of  all  the command with a specific string in their names.  For
       example, if you want to know the names  of  all  the  commands  that  are  concerned  with
       windows, you can run ``apropos'' with the keyword window.

       If  the initialization file has provided specific keybindings for your terminal, it should
       also be possible to view the keyboard layout with the keychart macro.

       If you're not familiar with the EMACS command set, it would be worth your while to use run
       TEACHJOVE.   Do  do  that, just type ``teachjove'' to your shell and you will be placed in
       JOVE in a file which contains directions.  I highly recommend this for beginners; you  may
       save yourself a lot of time and headaches.


       You  can  alter  the  key  bindings in JOVE to fit your personal tastes.  That is, you can
       change what a key does every time you strike it.  For example, by default the  ^N  key  is
       bound  to the command next-line and so when you type it you move down a line.  If you want
       to change a binding or add a new one, you use the  bind-to-key  command.   The  syntax  is
       ``bind-to-key <command> key''.

       You  can  also  change  the  way JOVE behaves in little ways by changing the value of some
       variables with the set command.  The syntax is ``set <variable> value'', where value is  a
       number  or  a string, or ``on'' or ``off'', depending on the context.  For example, if you
       want JOVE to make backup files, you set the ``make-backup-files'' variable to ``on''.   To
       see the value of a variable, use the ``print <variable>'' command.


       JOVE  first  reads  the  system-wide  initialization  file (/usr/share/jove/jove.rc) which
       provides reasonable defaults for your installation and loads  standard  macros.   It  will
       normally  observe your TERM environment variable in order to provide terminal-specific key
       bindings and a map of your keyboard (see the standard ``keychart'' macro).

       JOVE then automatically  reads  further  commands  from  the  initialization  file  called
       ``.joverc''  (``jove.rc'' under MSDOS) in your HOME directory.  In this file you can place
       commands that you would normally type in JOVE.  If you like to rearrange the key  bindings
       and  set  some  variables  every  time  you  get  into  JOVE,  you should put them in your
       initialization file.  Here are a few lines from mine:
            set match-regular-expressions on
            1 auto-execute-command auto-fill /tmp/Re\|.*drft
            bind-to-key i-search-forward ^\
            bind-to-key i-search-reverse ^R
            bind-to-key find-tag-at-point ^[^T
            bind-to-key scroll-down ^C
            bind-to-key grow-window ^Xg
            bind-to-key shrink-window ^Xs
       (Note that the Control Characters can be either two character  sequences  (e.g.  ^  and  C
       together  as  ^C)  or the actual control character.  If you want to use an ^ by itself you
       must BackSlash it (e.g., bind-to-key grow-window ^X\^ binds grow-window to ``^X^'').


       If the variable LC_CTYPE (see environ(5)) is not set in the environment,  the  operational
       behavior  of  JOVE for the LC_CTYPE locale category is determined by the value of the LANG
       environment variable.  If LC_ALL is set, its contents are used to override both  the  LANG
       and  the LC_CTYPE variable.  If none of the above variables is set in the environment, the
       "C" (U.S. style) locale determines how JOVE behaves.

              Determines how JOVE handles characters. When LC_CTYPE is set to a valid value, JOVE
              can  display  and  handle  text  and filenames containing valid characters for that
              locale. In particular, characters will be correctly recognised as  upper  or  lower
              case  and  displayed  if printable.  However JOVE cannot display or handle Extended
              Unix Code (EUC) characters which are more than 1 byte wide.   In  the  "C"  locale,
              only  characters from 7-bit ASCII are valid (all characters with the eighth bit set
              being displayed in octal). In the "iso_8859_1" locale (if supported by the OS), the
              full  Latin-1  alphabet is available. The JOVE variable ``lc-ctype'' can be used to
              change the locale while JOVE is running.


       You should type ^\ instead of ^S in many instances.  For example, the way to search for  a
       string  is  documented  as  being  ``^S''  but in reality you should type ``^\''.  This is
       because ^S is the XOFF character (what gets sent when you type the  NO  SCROLL  key),  and
       clearly  that  won't  work.   The XON character is ``^Q'' (what gets sent when you type NO
       SCROLL again) which is documented as the way to do a quoted-insert.  The alternate key for
       this is ``^^'' (typed as ``^`'' on vt100's and its look-alikes).  If you want to enable ^S
       and ^Q and you know what you are doing, you can put the line:
            set allow-^S-and-^Q on
       in your initialization file.

       If your terminal has a metakey and you turn on the ``meta-key'' variable, JOVE will use it
       to  generate  commands  which  would otherwise start with an ESC.  JOVE will automatically
       turn on ``meta-key'' if the METAKEY environment variable exists.  This is  useful  for  if
       you have different terminals (e.g., one at home and one at work) and one has a metakey and
       the other doesn't.  However, if a locale which recognises 8-bit characters is in force,  a
       metakey  may  be  better  used to generate the extra characters (so leave the ``meta-key''
       variable off).


       /usr/share/jove/jove.rc — system-wide initialization file
       /usr/share/jove/jove.rc.$TERM — terminal-specific initialization file
       /usr/share/jove/keychart.$TERM — terminal-specific help file
       /usr/share/jove/macros — standard macros file
       ~/.joverc — personal initialization file
       /var/tmp — where temporary files are stored
       /usr/share/jove/teach-jove — the interactive tutorial
       /usr/lib/jove/recover — the recovery program
       /usr/lib/jove/portsrv — for running shells in windows (pdp11 only)


       TERM — your terminal type
       METAKEY — if defined, sets the ``meta-key'' variable
       SHELL — the shell to be used by the ``shell'' and other commands
       COMSPEC — (on MSDOS) used if SHELL is not defined
       MAIL — to initialize the ``mailbox'' variable
       JOVELIB — overrides /usr/lib/jove unless overridden by -l
       JOVESHARE — overrides /usr/share/jove unless overridden by -s
       TMPDIR — overrides /var/tmp as directory for temporary files
       LC_ALL, LC_CTYPE, LANG — to set the locale


       ctags(1) — to generate tags for the find-tag command and the -t command-line
       ed(1) — for a description of regular expressions
       teachjove(1) — for an interactive JOVE tutorial.


       JOVE diagnostics are meant to be self-explanatory,  but  you  are  advised  to  seek  help
       whenever  you  are  confused.  You can easily lose a lot of work if you don't know EXACTLY
       what you are doing.


       Lines can't be more than 1024 characters long.

       Searches can't cross line boundaries.


       Jonathan Payne

                                           24 June 1993                                   JOVE(1)