xenial (1) jove.1.gz

Provided by: jove_4.16.0.73-4build1_amd64 bug

NAME

       jove - an interactive display-oriented text editor

SYNOPSIS

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

DESCRIPTION

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

       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.

INVOKING JOVE

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

       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'

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

       +/pattern
              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.

RECOVERING BUFFERS AFTER A CRASH

       The -r option of jove runs the JOVE recover program.  Use this when the system crashes, or JOVE  crashes,
       or you accidently 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 command.

       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.

GETTING HELP

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

       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.

KEY BINDINGS and VARIABLES

       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.

INITIALIZATION

       JOVE  first  reads  the system-wide initialization file (/usr/lib/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^'').

ENVIRONMENT

       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.

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

SOME MINOR DETAILS

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

FILES

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

ENVIRONMENT VARIABLES

       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/lib/jove unless overridden by -s
       TMPDIR — overrides /var/tmp as directory for temporary files
       LC_ALL, LC_CTYPE, LANG — to set the locale

SEE ALSO

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

DIAGNOSTICS

       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.

BUGS

       Lines can't be more than 1024 characters long.

       Searches can't cross line boundaries.

AUTHOR

       Jonathan Payne

                                                  24 June 1993                                           JOVE(1)