1JOVE(1)                     General Commands Manual                    JOVE(1)
2
3
4

NAME

6       jove - an interactive display-oriented text editor
7

SYNOPSIS

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

DESCRIPTION

15       JOVE  is  Jonathan's Own Version of Emacs.  It is based on the original
16       EMACS editor written at MIT by  Richard  Stallman.   Although  JOVE  is
17       meant  to  be  compatible  with EMACS, there are some major differences
18       between the two editors  and  you  shouldn't  rely  on  their  behaving
19       identically.
20
21       JOVE  works on any reasonable display terminal that is described in the
22       termcap file (see TERMCAP(5) for more  details).   When  you  start  up
23       JOVE,  it checks to see whether you have your TERM environment variable
24       set.  On most systems that will automatically be set up for you, but if
25       it's  not  JOVE  will  ask you what kind of terminal you are using.  To
26       avoid having to type this every time you run JOVE you can set your TERM
27       environment  variable yourself.  How you do this depends on which shell
28       you are running.  If you are running the C Shell, as most of  you  are,
29       you type
30
31            % setenv TERM type
32
33       and with the Bourne Shell, you type
34
35            $ TERM= type ; export TERM
36
37       where  type  is  the  name of the kind of terminal you are using (e.g.,
38       vt100).  If neither of these works get somebody to help you.
39

INVOKING JOVE

41       If you run JOVE with no arguments  you  will  be  placed  in  an  empty
42       buffer,   called   Main.   Otherwise,  any  arguments  you  supply  are
43       considered file names and each is ``given'' its own buffer.   Only  the
44       first  file is actually read in — reading other files is deferred until
45       you actually try to use the buffers they are attached to.  This is  for
46       efficiency's sake: most of the time, when you run JOVE on a big list of
47       files, you end up editing only a few of them.
48
49       The names of all of the files specified on the command line  are  saved
50       in  a  buffer,  called  *minibuf*.   The  mini-buffer is a special JOVE
51       buffer that is used when JOVE is  prompting  for  some  input  to  many
52       commands  (for  example, when JOVE is prompting for a file name).  When
53       you are being prompted for  a  file  name,  you  can  type  ^N  (that's
54       Control-N)  and  ^P  to  cycle  through  the  list  of  files that were
55       specified on the command line.  The file name will  be  inserted  where
56       you are typing and then you can edit it as if you typed it in yourself.
57
58       JOVE recognizes the following switches:
59
60       -d dirname
61              dirname  is taken to be the name of the current directory.  This
62              is for systems that  don't  have  a  version  of  C  shell  that
63              automatically  maintains the CWD environment variable.  If -d is
64              not specified on a system without a modified C shell, JOVE  will
65              have to figure out the current directory itself, and that can be
66              slow.  You can simulate the modified  C  shell  by  putting  the
67              following lines in your C shell initialization file (.cshrc):
68
69                   alias cd        'cd \!*; setenv CWD $cwd'
70                   alias popd      'popd \!*; setenv CWD $cwd'
71                   alias pushd     'pushd \!*; setenv CWD $cwd'
72
73       -l libdir
74              Allows  the  user to specify the directory in which binary files
75              required by JOVE can be found (default /usr/lib64/jove).
76
77       -s sharedir
78              Allows the user to specify the directory in which initialization
79              files required by JOVE can be found (default /usr/share/jove).
80
81       -ls bothdir
82              Allows  the  user to specify the directory in which binary files
83              and initialization files required by JOVE can be found.
84
85       -J     Inhibits  reading  of  the   system-wide   initialization   file
86              (/usr/share/jove/jove.rc).
87
88       -j     Inhibits reading of the user's initialization file (~/.joverc).
89
90       +n     Reads  the  file  designated  by  the  following  argument,  and
91              positions point at the n'th line instead of the (default)  first
92              line.   This can be specified more than once but it doesn't make
93              sense to use it twice on the same file; in that case the  second
94              one  wins.   If  no  numeric  argument is given after the +, the
95              point is positioned at the end of the file.
96
97       +/pattern
98              Reads  the  file  designated  by  the  following  argument,  and
99              positions point at the first match of the pattern.
100
101       -p file
102              Parses  the  error  messages  in  file.   The error messages are
103              assumed to be in a format similar to the C  compiler,  LINT,  or
104              GREP output.
105
106       -t tag Runs the find-tag command on tag (see ctags(1)).
107
108       -wn    Divides  the window into n windows (if n is omitted, it is taken
109              to be 2).   Subsequent  files  in  the  list  are  read  in  and
110              displayed in succeeding windows.
111

RECOVERING BUFFERS AFTER A CRASH

113       The -r option of jove runs the JOVE recover program.  Use this when the
114       system crashes, or JOVE crashes, or you accidently get logged out while
115       in  JOVE.   If  there  are  any buffers to be recovered, this will find
116       them.
117
118       Recover looks for JOVE buffers that are left around and  are  owned  by
119       you.  (You cannot recover other peoples' buffers, obviously.)  If there
120       were no buffers that were modified at the time of the  crash  or  there
121       were but recover can't get its hands on them, you will be informed with
122       the message, ``There  is  nothing  to  recover.''   Otherwise,  recover
123       prints the date and time of the version of the buffers it has, and then
124       waits for you type a command.
125
126       To get a list of the buffers recover knows about, use the list command.
127       This  will  list  all the buffers and the files and the number of lines
128       associated with them.  Next to each buffer is a number.  When you  want
129       to  recover  a  buffer,  use the get command.  The syntax is get buffer
130       filename where buffer is either the buffer's name or the number at  the
131       beginning  of  the  line.   If  you  don't  type the buffer name or the
132       filename, recover will prompt you for them.
133
134       If there are a lot of buffers and you want to recover all of them,  use
135       the  recover command.  This will recover each buffer to the name of the
136       buffer with ``.#'' prepended to the name (so that  the  original  isn't
137       over-written).   It  asks for each file and if you want to restore that
138       buffer to that name you type ``yes''.  If you want to recover the  file
139       but to a different name, just type the new name in.  If you type ``no''
140       recover will skip that file and go on to the next one.
141
142       If you want to look at a buffer before deciding to recover it, use  the
143       print  command.  The syntax for this is print buffer where buffer again
144       is either its name or the number.  You can type ^C if you want to abort
145       printing  the  file  to  the terminal, and recover will respond with an
146       appropriate message.
147
148       When you're done and have all the  buffers  you  want,  type  the  quit
149       command  to  leave.  You will then be asked whether it's okay to delete
150       the tmp files.  Most of the  time  that's  okay  and  you  should  type
151       ``yes''.   When  you say that, JOVE removes all traces of those buffers
152       and you won't be able to look at them again.  (If  you  recovered  some
153       buffers  they will still be around, so don't worry.)  So, if you're not
154       sure whether you've gotten all the buffers, you should answer ``no'' so
155       that  you'll  be  able to run recover again at a later time (presumably
156       after you've figured out which ones you want to save).  If  there  were
157       more  than  one  crashed JOVE session, quit will move you on to dealing
158       with the next one instead of exiting.
159
160       If you type ^C at any time other than when you're printing  a  file  to
161       the  terminal,  recover  will  exit without a word.  If you do this but
162       wish you hadn't, just type ``jove -r'' to the shell again, and you will
163       be put back with no loss.
164

GETTING HELP

166       Once  in  JOVE,  there  are several commands available to get help.  To
167       execute any JOVE command, you type ``<ESC> X command-name'' followed by
168       <Return>.   To get a list of all the JOVE commands you type ``<ESC> X''
169       followed by ``?''.  The describe-bindings command can be used to get  a
170       list  containing  each  key,  and  its associated command (that is, the
171       command that gets executed when you type that key).   If  you  want  to
172       save  the list of bindings, you can set the jove variable send-typeout-
173       to-buffer to ON (using the set command), and then execute the describe-
174       bindings command.  This will create a buffer and put in it the bindings
175       list it normally would have printed on the screen.  Then you  can  save
176       that  buffer  to  a file and print it to use as a quick reference card.
177       (See VARIABLES below.)
178
179       Once you know the name of a command, you can find out what it does with
180       the  describe-command  command,  which you can invoke quickly by typing
181       ``ESC ?''.  The apropos command will give you a list of all the command
182       with  a  specific  string  in their names.  For example, if you want to
183       know the names of all the commands that are concerned with windows, you
184       can run ``apropos'' with the keyword window.
185
186       If  the  initialization file has provided specific keybindings for your
187       terminal, it should also be possible to view the keyboard  layout  with
188       the keychart macro.
189
190       If  you're  not  familiar with the EMACS command set, it would be worth
191       your while to use run TEACHJOVE.  Do do that, just  type  ``teachjove''
192       to  your  shell and you will be placed in JOVE in a file which contains
193       directions.  I highly  recommend  this  for  beginners;  you  may  save
194       yourself a lot of time and headaches.
195

KEY BINDINGS and VARIABLES

197       You  can  alter  the  key bindings in JOVE to fit your personal tastes.
198       That is, you can change what a key does every time you strike it.   For
199       example, by default the ^N key is bound to the command next-line and so
200       when you type it you move down a line.  If you want to change a binding
201       or  add  a  new  one,  you  use the bind-to-key command.  The syntax is
202       ``bind-to-key <command> key''.
203
204       You can also change the way JOVE behaves in little ways by changing the
205       value  of  some  variables  with  the set command.  The syntax is ``set
206       <variable> value'', where value is a number or a string, or  ``on''  or
207       ``off'',  depending  on  the context.  For example, if you want JOVE to
208       make backup  files,  you  set  the  ``make-backup-files''  variable  to
209       ``on''.   To  see the value of a variable, use the ``print <variable>''
210       command.
211

INITIALIZATION

213       JOVE    first    reads    the    system-wide    initialization     file
214       (/usr/share/jove/jove.rc)  which  provides reasonable defaults for your
215       installation and loads standard macros.  It will normally observe  your
216       TERM  environment  variable  in  order to provide terminal-specific key
217       bindings and a map of your  keyboard  (see  the  standard  ``keychart''
218       macro).
219
220       JOVE  then automatically reads further commands from the initialization
221       file  called  ``.joverc''  (``jove.rc''  under  MSDOS)  in  your   HOME
222       directory.  In this file you can place commands that you would normally
223       type in JOVE.  If you like to rearrange the key bindings and  set  some
224       variables  every  time  you  get into JOVE, you should put them in your
225       initialization file.  Here are a few lines from mine:
226            set match-regular-expressions on
227            1 auto-execute-command auto-fill /tmp/Re\|.*drft
228            bind-to-key i-search-forward ^\
229            bind-to-key i-search-reverse ^R
230            bind-to-key find-tag-at-point ^[^T
231            bind-to-key scroll-down ^C
232            bind-to-key grow-window ^Xg
233            bind-to-key shrink-window ^Xs
234       (Note that the Control Characters can be either two character sequences
235       (e.g.  ^ and C together as ^C) or the actual control character.  If you
236       want to use an ^ by itself you must  BackSlash  it  (e.g.,  bind-to-key
237       grow-window ^X\^ binds grow-window to ``^X^'').
238

ENVIRONMENT

240       If   the   variable  LC_CTYPE  (see  environ(5))  is  not  set  in  the
241       environment, the operational behavior of JOVE for the  LC_CTYPE  locale
242       category  is  determined by the value of the LANG environment variable.
243       If LC_ALL is set, its contents are used to override both the  LANG  and
244       the  LC_CTYPE  variable.   If none of the above variables is set in the
245       environment, the "C" (U.S. style) locale determines how JOVE behaves.
246
247       LC_CTYPE
248              Determines how JOVE handles characters. When LC_CTYPE is set  to
249              a  valid  value,  JOVE can display and handle text and filenames
250              containing valid characters  for  that  locale.  In  particular,
251              characters  will  be correctly recognised as upper or lower case
252              and displayed if printable.   However  JOVE  cannot  display  or
253              handle Extended Unix Code (EUC) characters which are more than 1
254              byte wide.  In the "C" locale, only characters from 7-bit  ASCII
255              are  valid  (all  characters  with  the  eighth  bit  set  being
256              displayed in octal). In the "iso_8859_1" locale (if supported by
257              the  OS),  the  full  Latin-1  alphabet  is  available. The JOVE
258              variable ``lc-ctype'' can be used to  change  the  locale  while
259              JOVE is running.
260

SOME MINOR DETAILS

262       You  should  type ^\ instead of ^S in many instances.  For example, the
263       way to search for a string is documented as being ``^S'' but in reality
264       you should type ``^\''.  This is because ^S is the XOFF character (what
265       gets sent when you type the NO SCROLL  key),  and  clearly  that  won't
266       work.   The  XON  character  is ``^Q'' (what gets sent when you type NO
267       SCROLL again) which is documented as the way  to  do  a  quoted-insert.
268       The  alternate  key  for this is ``^^'' (typed as ``^`'' on vt100's and
269       its look-alikes).  If you want to enable ^S and ^Q and  you  know  what
270       you are doing, you can put the line:
271            set allow-^S-and-^Q on
272       in your initialization file.
273
274       If  your  terminal  has  a  metakey  and  you  turn on the ``meta-key''
275       variable, JOVE will use it to generate commands which  would  otherwise
276       start with an ESC.  JOVE will automatically turn on ``meta-key'' if the
277       METAKEY environment variable exists.  This is useful for  if  you  have
278       different  terminals  (e.g., one at home and one at work) and one has a
279       metakey and the other doesn't.  However, if a locale  which  recognises
280       8-bit  characters is in force, a metakey may be better used to generate
281       the extra characters (so leave the ``meta-key'' variable off).
282

FILES

284       /usr/share/jove/jove.rc — system-wide initialization file
285       /usr/share/jove/jove.rc.$TERM — terminal-specific initialization file
286       /usr/share/jove/keychart.$TERM — terminal-specific help file
287       /usr/share/jove/macros — standard macros file
288       ~/.joverc — personal initialization file
289       /tmp — where temporary files are stored
290       /usr/share/jove/teach-jove — the interactive tutorial
291       /usr/lib64/jove/recover — the recovery program
292       /usr/lib64/jove/portsrv — for running shells in windows (pdp11 only)
293

ENVIRONMENT VARIABLES

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

SEE ALSO

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

DIAGNOSTICS

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

BUGS

317       Lines can't be more than 1024 characters long.
318
319       Searches can't cross line boundaries.
320

AUTHOR

322       Jonathan Payne
323
324
325
326                                 24 June 1993                          JOVE(1)
Impressum