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/local/packages/jove-4.16/lib/jove).
-s sharedir
Allows the user to specify the directory in which
initialization files required by JOVE can be found
(default /usr/local/packages/jove-4.16/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/local/packages/jove-4.16/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 ommitted, 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 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.
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/local/packages/jove-4.16/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 (see environ(5)) is not set in the
environment, the operational behavior of JOVE for the locale
category is determined by the value of the environment
variable. If is set, its contents are used to override both
the and the 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
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/local/packages/jove-4.16/lib/jove/jove.rc - system-wide initialization file
/usr/local/packages/jove-4.16/lib/jove/jove.rc.$TERM - terminal-specific initialization file
/usr/local/packages/jove-4.16/lib/jove/keychart.$TERM - terminal-specific help file
/usr/local/packages/jove-4.16/lib/jove/macros - standard macros file
~/.joverc - personal initialization file
/usr/tmp - where temporary files are stored
/usr/local/packages/jove-4.16/lib/jove/teach-jove - the interactive tutorial
/usr/local/packages/jove-4.16/lib/jove/recover - the recovery program
/usr/local/packages/jove-4.16/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/local/packages/jove-4.16/lib/jove unless overridden by -l
JOVESHARE - overrides /usr/local/packages/jove-4.16/lib/jove unless overridden by -s
TMPDIR - overrides /usr/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