Geek Gadgets 1/ADE-1.bin/ade-dist/jove-4.16-bin.lha/man/cat1/jove.0

Text File | 1996-09-15 | 15KB | 397 lines

JOVE(1)                                                   JOVE(1)


NNAAMMEE
       jove - an interactive display-oriented text editor

SSYYNNOOPPSSIISS
       jove [-d directory] [-w] [-t tag] [+[n] file] [-p file] [files]
       jove -r

DDEESSCCRRIIPPTTIIOONN
       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  _t_e_r_m_c_a_p  file (see TERMCAP(5) for more
       details).  When you  start  up  JOVE,  it  checks  to  see
       whether  you  have your _T_E_R_M 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 _T_E_R_M 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 _t_y_p_e

       and with the Bourne Shell, you type

            $ TERM= _t_y_p_e ; export TERM

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

IINNVVOOKKIINNGG JJOOVVEE
       If you run JOVE with no arguments you will be placed in an
       empty  buffer,  called _M_a_i_n_.  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 _*_m_i_n_i_b_u_f_*_.  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 C-N (that's



                         12 February 1986                       1





JOVE(1)                                                   JOVE(1)


       Control-N) and C-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     The  following  argument 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 _C_W_D 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 VERY 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'

       _+_n     Reads  the  file,  designated  by   the   following
              argument,  and  positions  point  at  the _n_'_t_h line
              instead of the (default) 1'st 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.

       _-_p     Parses the error messages in the file designated by
              the following argument.   The  error  messages  are
              assumed  to  be  in  a  format  similar  to  the  C
              compiler, LINT, or GREP output.

       _-_t     Runs  the  _f_i_n_d_-_t_a_g  command  on  the   string   of
              characters immediately following the -t if there is
              one (as in -tTagname), or on the following argument
              (as in -t Tagname) otherwise (see ctags(1)).

       _-_w     Divides  the  window  in  two.   When this happens,
              either the same file is displayed in both  windows,
              or  the  second  file  in  the  list is read in and
              displayed in its window.

RREECCOOVVEERRIINNGG BBUUFFFFEERRSS AAFFTTEERR AA CCRRAASSHH
       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'



                         12 February 1986                       2





JOVE(1)                                                   JOVE(1)


       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
       _l_i_s_t 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  _g_e_t  command.  The syntax is _g_e_t _b_u_f_f_e_r
       _f_i_l_e_n_a_m_e where _b_u_f_f_e_r 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 _r_e_c_o_v_e_r 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 _p_r_i_n_t command.  The syntax for this  is  _p_r_i_n_t
       _b_u_f_f_e_r  where  _b_u_f_f_e_r  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 _q_u_i_t 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 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.

GGEETTTTIINNGG HHEELLPP
       Once  in JOVE, there are several commands available to get



                         12 February 1986                       3





JOVE(1)                                                   JOVE(1)


       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
       _d_e_s_c_r_i_b_e_-_b_i_n_d_i_n_g_s  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 _s_e_n_d_-_t_y_p_e_o_u_t_-_t_o_-_b_u_f_f_e_r to ON (using the _s_e_t
       command), and then execute the _d_e_s_c_r_i_b_e_-_b_i_n_d_i_n_g_s  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 _d_e_s_c_r_i_b_e_-_c_o_m_m_a_n_d command, which you can
       invoke quickly by typing "ESC  ?".   The  _a_p_r_o_p_o_s  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 _w_i_n_d_o_w_.

       If you're not familar 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.

KKEEYY BBIINNDDIINNGGSS aanndd VVAARRIIAABBLLEESS
       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 C-N
       key is bound to the command _n_e_x_t_-_l_i_n_e 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  _b_i_n_d_-_t_o_-_k_e_y  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 _s_e_t 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.

IINNIITTIIAALLIIZZAATTIIOONN
       JOVE automatically reads commands from  an  initialization
       file  in  your  HOME directory, called ".joverc".  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



                         12 February 1986                       4





JOVE(1)                                                   JOVE(1)


       few lines from mine:
            set match-regular-expressions on
            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^").

SSOOMMEE MMIINNOORR DDEETTAAIILLSS
       You should type C-\ instead of C-S in many instances.  For
       example,  the  way to search for a string is documented as
       being "C-S" but in reality you should type "C-\".  This is
       because C-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  "C-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 "C-^" (typed
       as "C-`" on vt100's and its look-alikes).  If you want  to
       enable  C-S  and  C-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, JOVE will use  it  if  you
       turn  on the "meta-key" variable.  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.

FFIILLEESS
       /ade/lib/jove/jove.rc - system wide initialization file
       ~/.joverc - personal initialization file
       /tmp - where temporary files are stored
       /ade/lib/jove/teach-jove - the interactive tutorial
       /ade/lib/jove/portsrv  -  for  running  shells  in windows
       (pdp11 only)

SSEEEE AALLSSOO
       ed(1) - for a description of regular expressions
       teachjove(1) - for an interactive JOVE tutorial.

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



                         12 February 1986                       5





JOVE(1)                                                   JOVE(1)


BBUUGGSS
       Lines can't be more than 1024 characters long.

       Searches can't cross line boundaries.

AAUUTTHHOORR
       Jonathan Payne


















































                         12 February 1986                       6