%
% input file: jove.cmds
%
\RCS $Id: jovecmds.tex,v 14.32.0.11 1994/06/13 01:45:07 tom Exp tom $

\appendix
\section{Alphabetical List of Commands and Variables}
This is the most definitive reference for \jove{} commands.  If there
are any inconsistencies between this list and the rest of the manual,
you should believe this list.

\dc{\#-indentation-increment}{variable}
This defines the indentation step in preprocessor commands.  It is
analogous to the \cmd{c-indentation-increment} variable.
See also \cmd{hash-insert}.

\dc{+}{ESC +}
This macro pretends you typed \key{ESC - -}, which is usually a no-op
but sometimes useful.

\dc{$-$}{Not Bound}
This pretends you typed \key{ESC -}.
\NOTE{
This is useful for terminals that have keypads that send a special
sequence for a minus sign typed on the keypad as opposed to a minus sign
typed from the keyboard.  This can save having type \key{ESC} when you
want to specify an argument.
\manual{
(This also pertains to number keypad keys in relation to the
commands \cmd{0}--\cmd{9} below)
}
}

\dc{0}{Not Bound}
This pretends you typed \key{ESC 0}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

\dc{1}{Not Bound}
This pretends you typed \key{ESC 1}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

\dc{2}{Not Bound}
This pretends you typed \key{ESC 2}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

\dc{3}{Not Bound}
This pretends you typed \key{ESC 3}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

\dc{4}{Not Bound}
This pretends you typed \key{ESC 4}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

\dc{5}{Not Bound}
This pretends you typed \key{ESC 5}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

\dc{6}{Not Bound}
This pretends you typed \key{ESC 6}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

\dc{7}{Not Bound}
This pretends you typed \key{ESC 7}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

\dc{8}{Not Bound}
This pretends you typed \key{ESC 8}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

\dc{9}{Not Bound}
This pretends you typed \key{ESC 9}.
\onlinehelp{\NOTE{
This is useful for terminals that have keypads that send special
sequences for numbers typed on the keypad as opposed to numbers typed
from the keyboard.  This can save having to type \key{ESC} when you want
to specify an argument.
}}

%[911007:new:14.15]
\dc{abort-char}{variable}
This variable defines \jove{}'s abort character.  When the abort
character is typed, the current \jove{} command is aborted.  The
default value is \key{C-G}.

\dc{accent}{ESC \{\% ' * / = \carat{} \_ ` " \# : ; $|$\}}
This command allows you to insert accented characters like `\c C' or
`\'a'. If you invoke it from the command line (\key{ESC~X}), it waits
for you to type an \Def{accent} then a \Def{base} character, which are
combined to form an accented character (if at all possible). If you
invoke it through an (eventually prefixed) \Def{accent} key, it expects
the \Def{base} character right away.  Valid \Def{accents} are:
\begin{center}\begin{tabular}{|*{2}{@{\tt\hspace{2\tabcolsep}}p{2.2em}p{11em}|}} \hline
%%.ta \w'a1111'u +\w'accent_circonflex11111'u +\w'a1111'u +\w'accent_circonflex11111'u
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
`    &accent grave (\`o)         &,    &cedille (\c c) \\
"    &umlaut (\"o)               &*    &scand.\ a, degree (\aa\ \AA\ $^{\circ}$) \\
'    &accent aigu (\'o)          &/    &scand.\ o, various (\o\ \O) \\
\carat{}    &accent circonflex (\^o)    &:\,\_   &various \\
\tilde{}    &tilde (\~n)                &;    &greek \\
$|$\,\#\,=\,\% &(line-draw)              &.    &(block) \\ \hline
\end{tabular}\end{center}
Typing `\key{?}' as the \Def{accent} character produces a help screen
with an overview of all available accent/base pairs and their translation.
\note{
This command is available only if \jove{}s optional extended
character set support is installed.
}

\dc{add-lisp-special}{Not Bound}
This command is to tell \jove{} what identifiers require special
indentation in lisp mode.  Lisp functions like \eg{defun} and \eg{let}
are two of the default functions that get treated specially.  This is
just a kludge to define some of your own.  It prompts for the function
name.

\dc{allow-\carat{}S-and-\carat{}Q}{variable}
This variable, when set, tells \jove{} that your terminal does not need
to use the characters \key{C-S} and \key{C-Q} for flow control, and that
it is okay to bind things to them.  This variable should be set
depending upon what kind of terminal you have (it defaults to ``off'').
\par\noindent
For your convenience \jove{} treats \key{C-Q} and \key{C-\carat{}} as
synonyms, and likewise \key{C-S} and \key{C-\bs{}}.

\dc{allow-bad-filenames}{variable}
If set, this variable permits filenames to contain ``bad'' characters
such as those from the set {\tt *\&\$\carat{}\tilde{}()?!"'`|<>[]\{\Rbrace()}.
These files are harder to deal with, because the characters mean
something to the shell.  The default value is ``off''.

\dc{ansi-codes}{Not Bound}
This handles some ANSI escape codes. It should be bound to \key{ESC~[}
in order to be useful (which it is only if your terminal generates ANSI
escape codes anyway).
\note{
This is an optional part of \jove{} and in my [TRH] humble opinion
pretty obsolete now \jove{} has a more general way to handle function
keys.
}

%[930206:new:14.30]
\dc{append-buffer}{Not Bound}
This appends the contents of the current buffer to a specified file.  If
the file does not already exist it is created.

%[920826:new:14.26]
\dc{append-next-kill}{Not Bound}
Make the next command, if it is a kill command, append to the current
entry on the kill ring, instead of creating a new entry.

\dc{append-region}{Not Bound}
This appends the region to a specified file.  If the file does not
already exist it is created.

\dc{apropos}{ESC \{H,h\}}
This types out all the commands, variables and macros with the specific
keyword in their names.  For each command and macro that contains the
string, the key sequence that can be used to execute the command or
macro is printed; with variables, the current value is printed.  So, to
find all the commands that are related to windows, you type
\begin{quote}\begin{verbatim}
ESC X apropos window<Return>
\end{verbatim}\end{quote}
If you supply an empty keyword, all variables, commands and macros are
listed.

\dc{auto-case-abbrev}{variable}
When this variable is on (the default), word abbreviations are adjusted
for case automatically.  For example, if ``jove'' were the abbreviation
for ``jonathan's own version of emacs'', then typing ``jove'' would give
you ``jonathan's own version of emacs'', typing ``Jove'' would give you
``Jonathan's own version of emacs'', and typing ``JOVE'' would give you
``Jonathan's Own Version Of Emacs''.  When this variable is ``off'',
upper and lower case are distinguished when looking for the
abbreviation, i.e., in the example above, ``JOVE'' and ``Jove'' would
not be expanded unless they were defined separately.
\par\noindent
Note that word abbreviations that contain Capitals are always expanded
literally.

\dc{auto-execute-command}{Not Bound}
This tells \jove{} to execute a command automatically when a file whose
name matches a specified pattern is visited.  The first argument is the
command you want executed and the second is a regular expression pattern
that specifies the files that apply.  For example, if you want to be in
\cmd{show-match-mode} when you edit C source files (that is, files that
end with \file{.c} or \file{.h}) you can type
\begin{quote}\begin{verbatim}
ESC X auto-execute-command show-match-mode .*\.[ch]$
\end{verbatim}\end{quote}
\par\noindent
This is mostly useful in your startup \file{.\,joverc}, in order for \jove{}
to recognize the types of files passed on the command line.
\par\noindent
If you specify a prefix argument, the list of currently defined
auto-execs is displayed.

\dc{auto-execute-macro}{Not Bound}
This is like \cmd{auto-execute-command} except you use it to execute
macros automatically instead of built-in commands.

\dc{auto-fill-mode}{C-X \{F,f\}}
This turns on \Def{Auto Fill} mode (or off if it's currently on) in the
selected buffer.  When \jove{} is in \Def{Auto Fill} mode it
automatically breaks lines for you when you reach the right margin so
you don't have to remember to hit \key{Return}.  \Jove{} uses 78 as the
right margin but you can change that by setting the variable
\cmd{right-margin} to another value.  See the \cmd{set} command to learn
how to do this.

\dc{auto-indent-mode}{C-X \{I,i\}}
This turns on \Def{Auto Indent} mode (or off if it's currently on) in
the selected buffer.  When \jove{} is in \Def{Auto Indent} mode,
\key{Return} indents the new line to the same position as the line you
were just on.  This is useful for lining up C code (or any other
language (but what else is there besides C?)).  This is out of date
because of the new command called \cmd{newline-and-indent} but it
remains because of several ``requests'' on the part of, uh, enthusiastic
and excitable users, that it be left as it is.

\dc{auto-save-region}{variable}
This variable, when set, tells \jove{} to save the region on the kill
ring for commands that do massive changes like \cmd{case-region-upper},
\cmd{fill-region}, \cmd{fill-comment} and \cmd{replace-in-region}, so
that you can easily undo the change.  The default value of this variable
is ``off''.

%[900723:new]
\dc{auto-scroll-margin}{variable}
This variable, when set to a non-zero value, tells \jove{} to scroll
whenever the cursor would end up in a `forbidden' region near the top
and bottom of the window.  \cmd{auto-scroll-margin} gives the size of
these regions as a percentage of the total window size.

\dc{backup-file-prefix}{variable}
This string is used to build the name of the backup file (see
\cmd{make-backup-files}); it is prepended to the name of the original
file. The default value of this variable is \file{\#}.

%[900719:changed]
\dc{backward-character}{C-B, $\leftarrow$}
This moves point backward over a single character.  If point is at the
beginning of the line it moves to the end of the previous line, unless
\cmd{over-write-mode} is enabled.

\dc{backward-line}{F9, Keypad 4}
This macro moves point backward to the beginning of the current line, or
to the beginning of the previous line if point was already at the
beginning of the line.

\dc{backward-list}{ESC C-P, ESC Keypad 4}
This moves point backward over a list.  It searches the first occurrence
of `)' before point and then moves to the matching `('.  This is
mode dependent, in C mode `\}' and `]' are also matched.  If you
supply a negative argument, it behaves just like \cmd{forward-list}.

\dc{backward-paragraph}{ESC [}
This moves point backward to the beginning of the current or previous
paragraph.  Paragraphs are bounded by lines that begin with a Period
(i.e., a \file{nroff\,(1)} directive) or Back-slash (i.e., a \TeX{}
directive), or by blank lines; a change in indentation may also signal a
break between paragraphs, except that \jove{} allows the first line of a
paragraph to be indented differently from the other lines.

%[900716:changed]
\dc{backward-s-expression}{ESC C-B, ESC (Keypad 1 or $\swarrow$)}
This moves point backward over a s-expression.  If the first significant
character before point is `)', this moves to the matching `('.  If the
character is a `{\tt"}' it will move past the quoted string.  If the
character begins an identifier, this moves just before it.  This is mode
dependent, so this will move over atoms in Lisp mode and C identifiers
in C mode.  \Jove{} also matches `\}' and `]' in C mode, and ignores
comments.  If you supply a negative argument, it behaves just like
\cmd{forward-s-expression}.

\dc{backward-sentence}{ESC \{A,a\}}
This moves point backward to the beginning of the current or previous
sentence.  \Jove{} considers the end of a sentence to be the characters
`.', `!' or `?' followed by a Newline or by one or more spaces.

\dc{backward-up-list}{ESC C-U, ESC (Keypad 7 or $\nwarrow$)}
This moves backward to the open parenthesis of the enclosing block. This
is mode dependent, in C mode `\{' is searched for, and in other modes
`(' is used.

\dc{backward-word}{ESC $\leftarrow$, ESC \{B,b\}, (Keypad 1 or $\swarrow$), F7}
This moves point backward to the beginning of the current or previous
word.

\dc{bad-filename-extensions}{variable}
This contains a list of words separated by spaces which are to be
considered bad filename extensions, and so will not be counted in
filename completion.  The default is \file{.o} so if you have
\file{jove.c} and \file{jove.o} in the same directory, the filename
completion will not complain of an ambiguity because it will ignore
\file{jove.o}.

\dc{beginning-of-file}{ESC <, (Keypad 7 or $\nwarrow$), Home}
This moves point backward to the beginning of the buffer.  This
sometimes prints the \out{[Point Pushed]} message.  If the top of the
buffer isn't on the screen \jove{} will set the mark so you can go back
to where you were if you want.

%[940522:new:14.32#10]
\dc{beginning-of-file-next-window}{C-X (Keypad 7 or $\nwarrow$), ESC Home}
This macro moves point backwards to the beginning of the buffer in the next
window.  This is exactly the same as \linebreak[3] \key{C-X~N~ESC~<~C-X~P}.

\dc{beginning-of-line}{C-A}
This moves point to the beginning of the current line.

\dc{beginning-of-next-line}{Keypad 0 or F0}
This macro moves point to the beginning of the next line.

\dc{beginning-of-window}{ESC ,}
This moves point to the beginning of the current window.  The sequence
\key{ESC~,} is the same as \key{ESC~<} (beginning of file) except
without the shift key on the \key{<}, and can thus can easily be
remembered. (on US keyboards at least\ldots)

%[910110:new]
\dc{binary-read-files}{variable}
This variable, when set, inhibits the newline conversion that is usually
done when \jove{} reads a file into a buffer.  This allows you to edit
pure binary files.  See also \cmd{binary-write-files}.
\note{
This is normally not available (or needed for that matter) on \UNIX{} versions
of \jove{}, unless it has been installed with the {\tt CRLF} option to
provide read-compatibility with MS-DOS files.
}

%[910110:new]
\dc{binary-write-files}{variable}
This variable, when set, inhibits the newline conversion that is usually
done when \jove{} writes a buffer to a file.  This allows you to edit
pure binary files.  See also \cmd{binary-read-files}.
\note{
This is normally not available (or needed for that matter) on \UNIX{} versions
of \jove{}, unless it has been installed with the {\tt CRLF} option to
provide write-compatibility with MS-DOS files.
}

%[920812:new:14.25]
\dc{bind-keymap-to-buffer}{Not Bound}
This associates a keymap with the current buffer.  If a buffer has a
keymap bound to it in this way, any bindings defined in it will
automatically replace their standard values.  Any key that is not bound
in the keymap remains its old happy self.  Incidentally, if you bind or
unbind a key while you're in a buffer with a keymap bound to it, you
will change the binding in {\em that} keymap (instead of the main
keymap) --- this will affect the meaning of a key in other buffers that
are bound to that keymap too, so a keymap bound to a buffer this way is
not really local to that buffer).
.br
To dissociate a keymap from a buffer, bind \cmd{mainmap} to it.
.br
You can use this to implement special command modes, for example, a file
viewer like \file{more\,(1)} (or \file{less\,(1)}).
\NOTE{
dynamic keymap support is an optional part of \jove{}.
}

%[920812:new:14.25]
\dc{bind-keymap-to-key}{Not Bound}
This is the way to build nested keymaps.  It is like \cmd{bind-to-key}
except you use it to attach a key to a keymap.  For example,
to make the arrow keys on vt100's work, you could do the following: (but
you shouldn't, really, now that \jove{} supports function keys in a
terminal-independent way through \file{termcap\,(5)})
\begin{quote}\begin{verbatim}
make-keymap vt100-map
bind-keymap-to-key vt100-map ^[[
bind-to-key next-line ^[[A
bind-to-key previous-line ^[[B
bind-to-key forward-character ^[[C
bind-to-key backward-character ^[[D
\end{verbatim}
etc\ldots
\end{quote}
I may have gotten the escape sequences wrong, but you get the general
idea.  Theoretically you can use these keymaps to bind arbitrarily long
key sequences, like those generated by the SUN keyboards, but that is a
bit of a pain because you will have to generate a bunch of keymaps by
hand, almost one per key, because of the way the key sequences are
organized.
\NOTE{
dynamic keymap support is an optional part of \jove{}.
}

\dc{bind-macro-to-key}{C-X \{M,m\}}
This is like \cmd{bind-to-key} except you use it to attach keys to named
macros.

\dc{bind-macro-to-word-abbrev}{Not Bound}
This command allows you to bind a macro to a previously defined word
abbreviation.  Whenever you type the abbreviation, it will first be
expanded as an abbreviation, and then the macro will be executed.  Note
that if the macro moves around, you should set the mark first
(\key{C-@}) and then exchange the point and mark last (\key{C-X~C-X}).

%[920812:changed:14.25]
\dc{bind-to-key}{C-X C-K}
This attaches a key to an internal \jove{} command so that future hits
on that key invoke that command.  For example, to make \key{C-W} erase
the previous word, you type \key{ESC~X bind-to-key kill-previous-word C-W}.

If you precede \cmd{bind-to-key} with a positive numeric argument you
must first give the name of the keymap you wish to define the binding
in, if you give a negative argument \cmd{mainmap} is used, otherwise the
\Def{active keymap} is used.  The active keymap is the first map of the
following list that exists:
\begin{itemize}
\item
the keymap bound to the current buffer, if any;
\item
\cmd{process-map}, if the current buffer has an attached process;
\item
\cmd{mainmap}.
\end{itemize}
Note that a keybinding usually ends up in the topmost map; underlying
maps are examined, if necessary, for keymap completion.

\dc{bind-variable-to-key}{Not Bound}
This is like \cmd{bind-to-key} except you use it to attach variables to
keys.  It is a shortcut for ``\cmd{set} variable''.

\dc{buffer-position}{C-X =, ESC Keypad .}
This displays the current file name, current line number, total number
of lines, percentage of the way through the file, the position of Point
in the current line, and the decimal ascii code of the character at
Point.

%[900610:new]
\dc{c-argument-indentation}{variable}
This variable describes how to indent lines which are part of nested
expressions in C.  The default is 0, which means to indent a continued line
by lining it up with the first argument of the current expression.
Otherwise, the line will be indented by \cmd{c-argument-indentation}
characters past the indent of the first line of the expression.  For
example, the default value produces:
\begin{quote}\begin{verbatim}
if (BufMinorMode(cb, Fill) &&
    !isword(c) && (cb->b_char >= RMargin ||
                   calc_pos(linebuf, cb->b_char) >= RMargin)
    ) {
        DoJustify(cb->b_dot, 0, cb->b_dot, strlen(linebuf), YES,
                  BufMinorMode(cb, Indent) ?
                  get_indent(cb->b_dot) : LMargin);
}
\end{verbatim}\end{quote}

%[900716:changed]
\dc{c-indentation-increment}{variable}
This defines a set of tabstops independent of the value of
\cmd{internal-tabstops} and \cmd{physical-tabstops}.  This value will be
used in C and Perl mode instead of \cmd{indentation-increment} which is
used in all other modes, and \jove{} will insert the correct number of
spaces and tabs to get the right behavior.  For programmers that like to
indent with 4 spaces, set this value to 4.  Don't set internal-tabstops
to 4 because that will not work anymore.  Setting internal-tabstops to 4
tells \jove{} to display tabs as every 4 spaces.  This will cause your
programs to look terrible with anyone else who displays the file with
normal tabstops at every 8 characters.  Not to mention printing your
program won't look right.
\par\noindent
But all that aside, if you set \cmd{c-indentation-increment} to 8, and
then set internal-tabstops to 4 as well, \jove{} will insert {\em two\/}
tabs to get the indentation to 8, which is clearly not what you want.
If you set \cmd{c-indentation-increment} to 0 (the default) it
automatically takes the value of \cmd{internal-tabstop}, i.e., only real
tabs are used to indent.
\par\noindent
See also the variable \cmd{c-argument-indentation}.
 
\dc{c-mode}{Not Bound}
This turns on \Def{C} mode in the currently selected buffer.  This is
one of currently five possible major modes:  Fundamental, Text, C,
Lisp, Perl.
When in \Def{C} mode, `\key{Tab}', `\key{\#}', `\key{\Rbrace}', `\key{]}' and
`\key{)}'
behave a little differently from usual: They are indented to the
``right'' place for C programs.  In \jove{} the ``right'' place is
simply the way the author likes it (but I've got good taste).

\dc{case-character-capitalize}{Not Bound}
This capitalizes the character after point, i.e., the character under the
cursor.  If a negative argument is supplied that many characters
{\em before\/} point are upper cased.

\dc{case-ignore-search}{variable, C-\_ C-C}
This variable, when set, tells \jove{} to treat upper and lower case as
the same when searching.  Thus ``jove'' and ``JOVE'' would match, and
``JoVe'' would match too.  The default value of this variable is
``off''.  Note that only the lower case characters in the search string
are matched case-independently; upper case characters must still match
exactly.
\NOTE{
If \jove{}s optional extended character set support is installed,
accented characters are mapped to their equivalent lower case base
character if this variable is ``on''.
}

%[940522:new:14.32#10]
\dc{case-region-capitalize}{Not Bound}
This capitalizes all words in the region by making the first letter
of each word upper case and the rest of each word lower case.

\dc{case-region-lower}{C-X C-L}
This changes all the upper case letters in the region to their lower
case equivalent.  With a negative argument this has the same effect as
\cmd{case-region-upper}; when prefixed with 0 the
\cmd{case-region-capitalize} command is executed.

\dc{case-region-upper}{C-X C-U}
This changes all the lower case letters in the region to their upper
case equivalent.  With a negative argument this has the same effect as
\cmd{case-region-lower}; when prefixed with 0 the
\cmd{case-region-capitalize} command is executed.

\dc{case-word-capitalize}{ESC \{C,c\}}
This capitalizes the current word by making the current letter upper
case and making the rest of the word lower case.  Point is moved to the
end of the word.  If point is not positioned on a word it is first moved
forward to the beginning of the next word.  If a negative argument is
supplied that many words {\em before\/} point are capitalized.  This is
useful for correcting the word just typed without having to move point
to the beginning of the word yourself.

\dc{case-word-lower}{ESC \{L,l\}}
This lower-cases the current word and leaves point at the end of it.  If
point is in the middle of a word the rest of the word is converted.  If
point is not in a word it is first moved forward to the beginning of the
next word.  If a negative argument is supplied that many words
{\em before\/} point are converted to lower case.  This is useful for
correcting the word just typed without having to move point to the
beginning of the word yourself.

\dc{case-word-upper}{ESC \{U,u\}}
This upper-cases the current word and leaves point at the end of it.  If
point is in the middle of a word the rest of the word is converted.  If
point is not in a word it is first moved forward to the beginning of the
next word.  If a negative argument is supplied that many words
{\em before\/} point are converted to upper case.  This is useful for
correcting the word just typed without having to move point to the
beginning of the word yourself.

\dc{cd}{Not Bound}
This changes the current directory.

%[920329:new:14.22]
\dc{character-set}{variable}
This constant gives the name of the character set as implemented by this
version of \jove{}.

%[910115:changed]
\dc{character-to-octal-insert}{Not Bound}
This inserts a Back-slash followed by the octal ascii value of the next
character typed.  For example, \key{C-G} inserts the string
``\bs{}007''.  If you supply a numeric argument the hexadecimal
equivalent of the character is inserted.
\par\noindent
For example,
\key{C-U~ESC~X character-to-octal-insert C-G} inserts the string
``\bs{}x07''.  You can also quote the character with \key{C-Q}.  (this
is used by versions of \jove{} that support both a full 8-bit character
set and function keys.)  If the argument is negative, the character
{\em at\/} Point is replaced by its octal (if~`$-$') or hex
(if~`$-1$') equivalent.
This command is primarily intended for C programmers.

\dc{clear-and-redraw}{ESC C-L}
This clears the entire screen and redraws all the windows.  Use this
when \jove{} gets confused about what's on the screen, or when the
screen gets filled with garbage characters or output from another
program.

\dc{color}{C-\_ C}
This sets the text- and background-color of the currently selected
buffer.  Normally it asks first for the text-color, then for the
background-color.  You can also select a color directly using numeric
arguments: a positive value defines the text color, and a negative value
defines the background color.  Finally, if you prefix the command with
\key{ESC~+} you are asked for the text-color only,
and likewise for the background-color if you prefix it with \key{ESC~-}.
The choices are: black (1), red (2), green (3), yellow (4), blue (5),
magenta (6), cyan (7) and white (8).  If you have a
monochrome system or a system that does not support all of these colors,
some or all settings are ignored.
\note{
This is an optional (and experimental) part of \jove{}.  Use of
the `argumented' form in macros is safe.
}

%[930623:new:14.32]
\dc{color-erase-glitch}{variable}
Set this variable when your terminal erases with a fixed background
color, as opposed to the background color currently in effect.  For some
terminals its value is determined at startup from \file{termcap\,(5)};
others lack its description so if necessary you can set it by hand.

\dc{color-of-file-buffers}{variable}
This sets the default text- and background-color for File buffers. See
the \cmd{color} command for more details.

\dc{color-of-i-process-buffers}{variable}
This sets the default text- and background-color for interactive-process buffers.
See the \cmd{color} command for more details.

\dc{color-of-message-line}{variable}
This sets the text- and background-color of the message line. See the
\cmd{color} command for more details.

\dc{color-of-process-buffers}{variable}
This sets the default text- and background-color for Process buffers.
See the \cmd{color} command for more details.

\dc{color-of-scratch-buffers}{variable}
This sets the default text- and background-color for Scratch buffers.
(e.g. Completion, Help, Edit-Macros/Abbrev buffers) See the \cmd{color}
command for more details.

%[930623:new:14.32]
\dc{color-standout-glitch}{variable}
Set this variable if terminal attributes affect the current color in an
unpredictable way.  Ideally this should be determined from the terminal's
\file{termcap\,(5)} entry, but most lack this description so if necessary
you can set it by hand.

%[920705:new:14.24]
\dc{column-format}{variable}
This defines how a column looks like.  It is a regular expression used
by \cmd{tab-to-next-column} to find the start of the next column.  The
default value of this variable defines columns simply as words separated
by whitespace.

%[920705:new:14.24]
\dc{column-tabstop}{variable}
This defines the width of a column in \cmd{tab-to-next-column} if it
cannot be determined from the previous line.  The default value of this
variable is 8.

%[920329:new:14.22]
\dc{columns}{variable}
This constant contains the current screen width, in character columns.

%[910116:changed]
%[910605:changed]
\dc{command-line-option}{Not Bound}
Here is a list of the command-line options that \jove{} currently knows.
Builtin options are marked with `{\tt=}', the others are defined in the
system \file{.\,joverc} with this command.
\begin{description}
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
\item[{$+N$}]             {\tt=}\ move to line $N$ in the next file.
\item[{$-N$}]             {\tt=}\ move to line $(EOF - N)$ in the next file.
\item[{$-$}]              {\tt=}\ move to $EOF$ in the next file.
\item[{$-$b}]             {\tt\ }\ turn \cmd{make-backup-files} off.
\item[{$+$b}]             {\tt\ }\ turn \cmd{make-backup-files} on.
\item[{$-$d \file{directory}}] {\tt=}\ set current directory to \file{directory}.
\item[{$-$j}]             {\tt=}\ ignore the .joverc in \file{\$HOME} and current directory.
\item[{$+$j \file{.\,joverc}}]   {\tt\ }\ execute the commands in \file{.\,joverc}.
\item[{$-$p \file{errfile}}]   {\tt\ }\ run \cmd{parse-errors} on \file{errfile}.
\item[{$-$r}]             {\tt=}\ recover changed buffers after a system or \jove{} crash.
\item[{$-$s \file{pattern}}]   {\tt\ }\ search \file{pattern} in current buffer.
\item[{$-$t \file{tag}}]       {\tt\ }\ run \cmd{find-tag} to find \file{tag}.
\item[{$+$t \file{tag} \file{file}}]{\tt\ }\ same as {\bf -t}, but use \file{file} as tag-file.
\item[{$-$v}]             {\tt=}\ set the next file to \file{view-mode}.
\item[{$+$v}]             {\tt=}\ set all files following to \file{view-mode}.
\item[{$-$w$[N]$}]          {\tt=}\ split the window in two (or $N$) subwindows.
\item[{$-$x \cmd{command}}]   {\tt\ }\ execute an arbitrary \jove{} \cmd{command}.
\item[{$-$set \cmd{var} \file{to}}]{\tt\ }\ set \cmd{var} to \file{to}.
\item[{$-${$-$} \cmd{var}}]       {\tt\ }\ set \cmd{var} ``off''.
\item[{$++$ \cmd{var}}]       {\tt\ }\ set \cmd{var} ``on''.
\item[{$-$teach}]         {\tt\ }\ run \jove{}s tutorial (see \cmd{tutorial}).
\end{description}
This command defines a new command-line option.  This is useful only in your
\file{.\,joverc} initialisation file since the command line is interpreted
very early in your \jove{} session.
Its format is
\begin{quote}\begin{verbatim}
command-line-option <option> <command-string>
\end{verbatim}\end{quote}
where {\em $<$option$>$\/} is the command-line option to match (it should
start with a `$-$' or `$+$' or else it will not be recognized),
{\em $<$command-string$>$\/} is a command string that will be interpreted
when {\em $<$option$>$\/} is present on the command line.  Key-escape
sequences like \key{\carat{}M} are recognized in the command-string (see
\cmd{edit-macros} for more information); occurrences of `\$$N$' ($N$~in~[1--9])
are replaced with the $N$th next command-line argument; use `\$\$' to get a
single literal dollar sign.  You can supply a numeric argument to force a
read of the previous file-argument.  Examples:
\begin{quote}
\# ``--o'' --- set current buffer in overwrite mode \\
{\tt command-line-option -o over-write-mode} \\
\# ``-s $<$pattern$>$'' --- search $<$pattern$>$ in current buffer \\
{\tt 1 command-line-option -s search-forward \$1} \\
\# ``--p $<$errfile$>$'' --- parse errors in $<$errfile$>$ \\
{\tt command-line-option -p find-file \$1\carat{}Mparse-error}
\end{quote}
Error messages end up in the buffer \out{CLI errors}.
\par\noindent
{\em
Warning: you can override `builtin' command line options with this
command.
}

\dc{comment-format}{variable}
This variable tells \jove{} how to format your comments when you run the
command \cmd{fill-comment}.  Its format is this:
\begin{center}
\tt <open pattern>\%!<line header>\%c<line trailer>\%!<close pattern>
\end{center}
The \%!, \%c, and \%!\ must appear in the format; everything else is
optional.  A newline (represented by \%n) may appear in the open or
close patterns.  \%\% is the representation for \%.  The default comment
format is for C comments.  See \cmd{fill-comment} for more.

%[911210:changed:14.19] renamed from "make"
\dc{compile-command}{variable}
This is the command that is executed when you invoke \cmd{compile-it}.
It is a \jove{} variable now so that you can provide your own default
in your \file{.\,joverc}.

\dc{compile-it}{C-X C-E}
This compiles your program by running the \UNIX{} command \file{make -k}
into a buffer, and automatically parsing the error messages that are
created (if any).  See the \cmd{parse-errors} command.  To compile a C
program without \file{make}, use \key{C-U~C-X~C-E} and \jove{} will
prompt for a command to run instead of \file{make}.  (And then the
command you type will become the default command for \cmd{compile-it}.)
You can use this to parse the output from the C compiler or the
\file{grep} or \file{lint} programs.  See also \cmd{error-format-string}
to make it possible to parse errors of a different format.
\NOTE{
It is now possible to run this as an interactive process on versions
that support this.  See the variable \cmd{i-process-parse}.
}

%[920826:new:14.26]
\dc{completion-auto-help}{variable}
This variable, when set, enables automatic help for ambiguous
completions.

\dc{continue-process}{Not Bound}
This sends \file{SIGCONT} to the current interactive process, {\em if\/}
the process is currently stopped.
\note{
This is only for versions of \jove{} that have the interactive processes
feature, and only on \UNIX{} systems that have job-control.
}

\dc{copy-region}{ESC \{W,w\}}
This takes all the text in the region and copies it onto the kill ring
buffer.  This is just like running \cmd{kill-region} followed by the
\cmd{yank} command.

%[920329:new:14.22]
\dc{cps}{variable}
This constant contains the estimated output speed of the terminal,  in
characters per second.

\dc{current-error}{C-X .}
This moves to the current error in the list of parsed errors.  See the
\cmd{next-error} and \cmd{previous-error} commands for more detailed
information.

\dc{date}{Not Bound}
This prints the date on the message line, or if you supply a negative
numeric argument, inserts the date at Point.  The date string has the
familiar \UNIX{} format, i.e., ``\mbox{\tt Day Mmm DD HH:MM:SS YEAR}''.

%[900716:new]
\dc{dbx-format-string}{variable}
This is the default regular-expression search string used by \jove{} to
parse output from \file{dbx} running in a shell process.  The default format
string works when you type `\eg{where}' or while you're stepping through a
program, or when you reach a breakpoint.  You shouldn't have to change
this unless you are using \file{gdb} or some other symbolic debugger.
\NOTE{
DBX mode is a misnomer now that other debuggers are supported.
}
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

%[940201:14.32#9:new]
\dc{dbx-program-pattern}{variable}
This is a regular expression that lists the programs for which
DBX mode should be enabled automagically.

%[910116:new]
\dc{dd-mmm-yy}{C-X C-D}
This macro inserts the current date in the format ``{\tt DD-Mmm-YY}'',
for example ``{\tt 16-Jan-91}''.  It is provided as an example of how you can
build your own date formats based on the standard string inserted by \cmd{date}.

%[921002:new:14.28]
\dc{default-color}{variable}
This defines the color which is to be used as the default screen color,
and when other colors are set for the first time.  A suitable value is
supposed to be chosen at startup, so normally you shouldn't have to
change it.
\note{
The ``suitable value'' is either hardwired, or determined from the
terminal's termcap entry (using a non-standard termcap extension, see
the note at \cmd{use-color} for the nitty-gritty details).
}

\dc{define-global-word-abbrev}{Not Bound}
This defines a global abbreviation, i.e., an abbreviation that is
recognized in all major modes.

%[900719:new;was name-keyboard-macro]
%[910705:changed:14.12]
\dc{define-macro}{Not Bound}
This provides a different mechanism for defining keyboard macros.
Instead of gathering keystrokes and storing them into the
\Def{keyboard-macro} (which is how \cmd{start-remembering} works),
\cmd{define-macro} prompts for a macro name, and then for the actual
macro body.  If you wish to specify control characters in the macro, you
may simply insert them using the \key{C-Q} (\cmd{quoted-insert})
command, or by inserting the character `\carat{}' followed by the
appropriate letter for that character (e.g., \key{\carat{}A} would be
the two characters `\carat{}' followed by `A'.  Similarly,
\key{\carat{}[} (Escape), \key{\carat{}?} (Delete)).  As a special case,
\key{\carat{}:} followed by two more characters represents a function
key (e.g., the sequence \key{\carat{}:ku} stands for the ($\uparrow$)
cursor key; key names are based on those found in \file{termcap\,(5)},
but see also \cmd{special-keys}).  You may use `\bs{}' to prevent the `\carat{}' from
being
interpreted as part of a control character when you really wish to
insert one (e.g., a macro body `\eg{\bs{}\carat{}foo}' would insert the
string `\eg{\carat{}foo}' into the buffer, whereas the body
`\eg{\carat{}foo}' would be the same as typing \key{\carat{}F} and then
inserting the string `\eg{oo}').  Use \key{\bs{}\bs{}} to insert a
single Back-slash.  See \cmd{write-macros-to-file} to see how to save
macros.  In~a \file{.\,joverc} you can bind the macro directly to a
key if you give a numeric argument, for example:
\begin{quote}\begin{verbatim}
1 define-macro fuzzball ^X* (hairy bulbous object)
\end{verbatim}\end{quote}
defines the macro \eg{fuzzball} and binds it to \key{C-X *}.

\dc{define-mode-word-abbrev}{Not Bound}
This defines a mode-specific abbreviation, i.e., an abbreviation that is
recognized only in the current major mode.

\dc{delete-blank-lines}{C-X C-O}
This deletes all the blank lines around point.  This is useful when you
previously opened many lines with \key{C-O} and now wish to delete the
unused ones.

\dc{delete-blank-tail}{variable}
This variable tells \jove{} whether it should remove trailing whitespace
from the line when you type \key{Return}. The default value of this
variable is ``on''.

\dc{delete-buffer}{C-X \{K,k\}}
This deletes a buffer and frees up all the memory associated with it.
Be careful!  Once a buffer has been deleted it is gone forever.  \Jove{}
will ask you to confirm if you try to delete a buffer that needs saving.
This command is useful for when \jove{} runs out of space to store new
buffers.

\dc{delete-current-window}{C-X 0, C-X \{D,d\}}
This deletes the current window and moves point into one of the
remaining ones.  It is an error to try to delete the only remaining
window. If you supply a numeric argument it deletes the next window (or
the previous window if the argument is negative).

%[920812:new:14.25]
\dc{delete-keymap}{Not Bound}
This deletes a keymap (and all references to it).  It does not
automatically delete nested keymaps.  Some keymaps (like \cmd{mainmap})
are builtin permanently; these cannot be deleted.
See also \cmd{make-keymap}, \cmd{bind-keymap-to-key} and
\cmd{bind-keymap-to-buffer}.
\NOTE{
dynamic keymap support is an optional part of \jove{}.
}

%[900719:changed]
\dc{delete-macro}{Not Bound}
This deletes a macro from the list of named macros.  Once the macro is
deleted it is gone forever (except for the keyboard-macro, which is just
cleared).  If you are about to save macros to a file and decide you
don't want to save a particular one, delete it.

\dc{delete-next-character}{C-D}
This deletes the character that's just after point (that is, the
character under the cursor).  If point is at the end of a line, the line
separator is deleted and the next line is joined with the current one.

\dc{delete-other-windows}{C-X 1}
This deletes all the other windows except the current one.  This can be
thought of as going back into One Window mode.

\dc{delete-previous-character}{Delete, {C-H,Backspace}}
This deletes the character that's just before point (that is, the
character before the cursor).  If point is at the beginning of the line,
the line separator is deleted and that line is joined with the previous
one.

\dc{delete-white-space}{ESC \bs{}}
This deletes all the Tabs and Spaces around point.  If you supply a
numeric argument, it deletes all whitespace {\em after\/} point if the
argument is positive, and all whitespace {\em before\/} point if it
is negative.

\dc{describe-bindings}{Not Bound}
This types out a list containing each bound key and the command that
gets invoked every time that key is typed.  To make a wall chart of
\jove{} commands, set \cmd{send-typeout-to-buffer} to ``on'' and \jove{}
will store the key bindings in a buffer which you can save to a file and
then print.

\dc{describe-command}{ESC ?}
This prints some info on a specified command.

\dc{describe-key}{C-X ?}
This waits for you to type a key and then tells the name of the command
that gets invoked every time that key is hit.  Once you have the name of
the command you can use the \cmd{describe-command} command to find out
exactly what it does.  You can also supply a numeric argument to
\cmd{describe-key} or use the macro \cmd{verbose-describe-key} to get
this description directly.

%[910626:changed:14.11]
\dc{describe-macro}{Not Bound}
This prints some info on a specified ``builtin'' macro. (i.e., a macro
that is defined in the system-wide \file{.\,joverc} and that I bothered to
describe in \jove{}s help file.)
\NOTE{
If a file \file{.\,jovehelp} (or \file{jove.hlp} on Atari~ST and MS-DOS
systems) exists in your home directory, it is scanned before the
system's help file.  Thus you can add descriptions of your own macros to
that file.  Descriptions look like this:
\begin{quote}
{\tt :entry "<macro-name>" "Command"} \\
\ldots{} (description follows here)
\end{quote}
and should be in alphabetical order (character case matters!).
}

\dc{describe-variable}{C-X \{H,h\}}
This prints some info on a specified variable.

%[930119:changed:14.30]
\dc{digit}{ESC -, ESC [0-9]}
This reads a numeric argument.  When you type \key{ESC} followed by a
number, \cmd{digit} keeps reading digits until you type some other
command.  Then that command is executed with the numeric argument you
specified. It actually behaves as a very simple calculator:  you can use
\key{-} to toggle the sign of the argument, \key{C-U} to multiply by 4
and \key{/} to remove the last digit (think of this as division).
If the first digit typed is \key{0} input mode is switched from decimal
to octal.
Also note that there is a small difference between `$-$' and `$-1$'
(and likewise `$+$' and `$+1$'). However this is so subtle that most
commands will treat it the same, but for instance \cmd{next-page}
discriminates, displaying the previous page on `$-$' and scrolling down
a single line on `$-1$'.

\dc{dirs}{Not Bound}
This prints out the directory stack.  If you give it a numeric argument
a verbose list is printed out.  See the \cmd{cd}, \cmd{pushd},
\cmd{popd} commands for more info.

%[930119:new:14.30]
\dc{dirs-extract}{variable}
This affects the behaviour of \cmd{pushd} with a numeric argument $N$.
Normally the directory stack is rotated around $N$ places to make the
directory found there the new working directory.  If this
variable is set, however, the $N$th directory is extracted from the
directory stack and pushed on top.  Its default value is ``off''.

%[930119:new:14.30]
\dc{dirs-unique}{variable}
This affects the behaviour of \cmd{pushd}.  If this variable is set,
and you \cmd{pushd} a directory which is already present in the
directory stack, the existing entry will be removed, thus keeping the
stack clean.  If this variable is ``off'', directories are pushed
unconditionally.  Its default value is ``off''.

\dc{disable-biff}{variable}
When this is set, \jove{} disables \file{biff} when you're editing and
enables it again, if necessary, when you set this to ``off'' or when you
get out of \jove{} or when you pause to the parent shell or push to a
new shell. (This means arrival of new mail will not be immediately
apparent but will not cause indiscriminate writing on the display.  Note
that \jove{} does check your mailbox regularly for arrival of new mail,
see \cmd{mail-check-interval} and \cmd{mode-line}'s \%C). The default is
``off''.
\note{
This is only available on \UNIX{} systems that run \file{biff}.
}

%[900610:new]
\dc{display-bad-filenames}{variable}
This variable affects only filename completion, in particular, what happens
when `\key{?}' is typed while prompting for a file.  When this variable is
``on'', any files that end with one of the extensions defined by the
variable \cmd{bad-filename-extensions} will be displayed with an `!' in
front of their names.  When \cmd{display-bad-filenames} is ``off'' these
files will not be displayed at all.  The default value is ``on''.

%[920705:new:14.24]
\dc{display-filetype}{variable}
This variable affects only filename completion, in particular, what
happens when `\key{?}' is typed while prompting for a file.  When this
variable is ``on'', the file types are flagged in a manner similar to
``\file{ls~-F}'', i.e., directories are flagged with a trailing `/', and
executable files with a trailing `{\tt*}'.  You can turn this ``off'' if
you are not interested in this information, or if you find it too slow
on your system.  The default value is ``on''.

\dc{down-list}{ESC C-D, ESC (Keypad 5)}
This moves point down into the next list. It searches the next
occurrence of `(' and leaves point just past it. An error occurs if `)'
is encountered first, i.e., if there is no expression nested more deeply.
This is mode dependent, in C mode `[' and `\{' are also matched.

\dc{dstop-process}{Not Bound}
Send the `dsusp' character to the current process.  This is the
character that suspends a process on the next read from the terminal.
Most people have it set to \key{C-Y}.
This only works if you are in a buffer bound to a process.
\note{
This is only for versions of \jove{} that have the interactive processes
feature, and only on \UNIX{} systems that have job-control.
}

%[900719:changed]
\dc{edit-macros}{Not Bound}
This creates a buffer with a list of each macro definition, and enters a
recursive edit to let you change, add or delete macro definitions.  The
format of a macro definition is ``{\tt macro-name~macro-body}'' so
if you add some more you should follow that format.  If you want to
delete a macro, just delete the \Def{macro-body} (but leave a space
after the name; this is a bug).  See the command \cmd{define-macro} on
how to enter control characters.  When you are done you type
\key{C-X~C-C} to exit the recursive edit and load the macro definitions.
If you supply a numeric argument, only the macros that
you created or modified in this \jove{} session are displayed.

\dc{edit-word-abbrevs}{Not Bound}
This creates a buffer with a list of each abbreviation and the phrase it
expands into, and enters a recursive edit to let you change the
abbreviations or add some more.  The format of this list is
``{\tt abbreviation:phrase}''
so if you add some more you should follow that
format.  It's probably simplest just to copy some already existing
abbreviations and edit them.  When you are done you type \key{C-X~C-C}
to exit the recursive edit and load the abbreviations.

\dc{end-of-file}{ESC >, (Keypad 9 or $\nearrow$)}
This moves point forward to the end of the buffer.  This sometimes
prints the \linebreak[3] \out{[Point Pushed]} message.  If the end of the
buffer isn't on the screen \jove{} will set the mark so you can go back
to where you were if you want.

%[940522:new:14.32#10]
\dc{end-of-file-next-window}{C-X (Keypad 9 or $\nearrow$), ESC End}
This macro moves point forwards to the end of the buffer in the next
window.  This is exactly the same as \linebreak[3] \key{C-X~N~ESC~>~C-X~P}.

\dc{end-of-line}{C-E}
This moves point to the end of the current line.  If the line is too
long to fit on the screen \jove{} will scroll the line to the left to
make the end of the line visible.  The line will slide back to its
normal position when you move backward past the leftmost visible
character or when you move off the line altogether.

\dc{end-of-window}{ESC .}
This moves point to the last character in the window.

%[910115:changed]
\dc{eof-process}{Not Bound}
Sends \file{EOF} to the current interactive process.
\NOTE{
This only works well on versions of \jove{} which use pseudo-ttys to
communicate with i-processes, like the version under 4.2-3 BSD
\UNIX{} or HP-UX.  On versions that use pipes, you can only send EOF
to a process {\em once}; after that the connection to the process is
lost.
}

\dc{erase-buffer}{C-\_ E}
This erases the contents of the specified buffer.  This is like
\cmd{delete-buffer} except it only erases the contents of the buffer,
not the buffer itself.  If you try to erase a buffer that needs saving
you will be asked to confirm it.

%[920826:new:14.26]
\dc{erase-char}{variable}
This constant is set to the erase character as defined by
``\file{stty erase}''.  Its value is used in the system \file{.\,joverc}
to decide whether \key{Rubout} should delete forward or backward.

%[911024:new:14.15]
\dc{error-buffer-color}{variable}
This defines the text- and background-color that \cmd{parse-errors} (or
\cmd{compile-it}) assigns to the buffer, if and only if any error
messages are found in that buffer.  See the \cmd{color} command for more
details.

%[900716:new]
%[911210:changed:14.19]
\dc{error-format-string}{variable}
This is the error format string that is used by \cmd{parse-errors} to
find the error messages in a buffer.  The way it works is by using this
string as a \jove{} regular expression search string, where the \bs{}(~\bs{})
regular expression operators are used to pick out the
file name and line number from the line containing an error message.
For instance, a typical error message might look like this:
\begin{quote}\begin{verbatim}
"file.c", line 540: missing semi-colon
\end{verbatim}\end{quote}
For strings of this format, an appropriate value for
\cmd{error-format-string} would be something like this:
\begin{quote}\begin{verbatim}
^"\([^"]*\)", line \([0-9]*\):
\end{verbatim}\end{quote}
What this means is, to find an error message, search for a line
beginning with a double-quote.  Then it says that all the following
characters up to another double-quote should be remembered as one unit,
namely the filename that the error is in (that's why the first set of
parens are surrounding it).  Then it says that after the filename there
will be the string ``{\tt ,~line~}'' followed by a line number, which
should be remembered as a single unit (which is why the second set of
parens is around that).
\par\noindent
Now this can also handle error message formats where the file name does not
appear in each error message, but is mentioned only once before the
actual error messages.  For instance,
\begin{quote}\begin{verbatim}
*** file.c ***
540: missing semi-colon
\end{verbatim}\end{quote}
would be matched by something like this:
\begin{quote}\begin{verbatim}
^\*\*\* \(.*\) \*\*\*$\|^\([0-9]*\):
\end{verbatim}\end{quote}
\par\noindent
If you do not know how to use regular expressions then this variable will
be hard for you to use.  Also note that you can look at the default value
of this variable by printing it out, but it is a really complicated string
because it is trying to accommodate the outputs of more than one compiler
at a time.

\dc{error-window-size}{variable}
This is the percentage of the screen to use for the error-window on the
screen.  When you execute \cmd{compile-it}, \cmd{error-window-size}
percent of the screen will go to the error window.  If the window
already exists and is a different size, it is made to be this size.  The
default value is 20\%.

\dc{exchange-point-and-mark}{C-X C-X}
This moves point to mark and makes mark the old point.  This is for
quickly moving from one end of the region to another.

\dc{execute-keyboard-macro}{C-X \{E,e\}, Keypad 5, F5}
This executes the keyboard macro.  If you supply a numeric argument the
macro is executed that many times.

\dc{execute-macro}{C-X \$}
This executes a specified macro.  If you supply a numeric argument the
macro is executed that many times. An argument value of 0 means
``infinite'' i.e., until the macro fails. A negative argument value makes
sense only if you execute the macro from within another macro. In that
case its absolute value is used as the repeat count, and
\Def{error-catching} is enabled. That is, when an error occurs while the
macro is executing, the remainder of the calling macro will still be
executed. Normally you return directly to keyboard-input mode when an
error occurs while macros are executing.

\dc{execute-named-command}{ESC \{X,x\}}
This is the way to execute a command that isn't bound to any key.  When
you are prompted with ``\out{:~}'' you can type the name of the command.
You don't have to type the entire name.  Once the command is unambiguous
you can type \key{Space} and \jove{} will fill in the rest for you.  If
you are not sure of the name of the command, type \key{?} and \jove{}
will print a list of all the commands that you could possibly match
given what you've already typed.  If you don't have any idea what the
command's name is but you know it has something to do with windows (for
example), you can do \key{ESC~X apropos window} and \jove{} will print a
list of all the commands that are related to windows.  If you find
yourself constantly executing the same commands this way you probably
want to bind them to keys so that you can execute them more quickly.
See the \cmd{bind-to-key} command.

\dc{exit-color}{variable}
This selects the text- and background-color which are to be set when you
exit \jove{}.  See the \cmd{color} command for more details.

\dc{exit-jove}{C-X C-C}
This exits \jove{}.  If any buffers need saving \jove{} will print a
warning message and ask for confirmation.  If you leave without saving
your buffers all your work will be lost.  If you made a mistake and
really do want to exit then you can.  If you are in a recursive editing
level \cmd{exit-jove} will return you from that.

%[920826:new:14.26]
\dc{expand-abbrev}{C-X '}
Expand the word (or partial word) before point, if it is an abbreviation.

%[910705:new:14.12]
\dc{expand-command-line-arguments}{variable}
This tells \jove{} to apply a UNIX-like expansion to any filename you
supply on the command line.  That is, it does the job that the shell
would do on a decent system.  It recognizes the usual `{\tt*}', `?' and
`[\ldots]' meta-characters, and also `[\carat{}\ldots]', `[!\ldots]' or
`[\tilde{}\ldots]' for any character not in the set, and
`\{\ldots,\ldots\}' to match any of the alternatives.  This variable is
used very early in your \jove{} session, so to use it you should set it
in your \file{.\,joverc} or from the command line.  Its default value is
``on''.
\NOTE{
For now, meta-characters are expanded in the file's basename only, not
in the directory path leading up to it.
}
\note{
This is an optional part of \jove{}, which is not available (or needed
for that matter) on \UNIX{} systems.
}

\dc{extra-help-file}{Not Bound}
This macro holds the name of the file that contains the information
for the \cmd{help-xxxxx} macros.  Normally this is set to \file{extra.hlp} in
\jove{}s library directory.  If you wish to use a customized version of this
file, you can redefine this macro to reflect this.

%[920330:new:14.22]
\dc{file-buffer}{Not Bound}
This changes the type of the current buffer to \cmd{File}, which means
that JOVE takes notice of modifications to the buffer.

\dc{file-creation-mode}{variable}
This variable has an octal value.  It contains the mode (see
\file{chmod\,(1)}) with which files should be created.  This mode gets
modified by your current umask setting (see \file{umask\,(1)}).  The
default value is usually 0666 or 0644.

%[910618:new]
\dc{file-selector}{variable}
This tells \jove{} to use the system's \Def{File~Selector} box instead of
prompting on the message line for a filename.  It it there for those of
you who are addicted to such a thingie.
\note{
This is an optional (and experimental) part of \jove{}, currently only
available for the Atari~ST version.
}

\dc{files-should-end-with-newline}{variable}
This variable indicates that all files should always have a newline
at the end.  This is often necessary for line printers and the like.
When set, if \jove{} is writing a file whose last character is not a
newline, it will add one automatically.

\dc{fill-comment}{C-X {C-J,Linefeed}}
This command fills in your C comments to make them pretty and readable.
This filling is done according the variable \cmd{comment-format}.
\begin{quote}\begin{verbatim}
/*
 * the default format makes comments like this.
 */
\end{verbatim}\end{quote}
This can be changed by changing the \cmd{comment-format} variable.
Other languages may be supported by changing the format variable
appropriately.  The formatter looks backwards from point for an open
comment symbol.  If found, all indentation is done relative the position
of the first character of the open symbol.  If there is a matching close
symbol, the entire comment is formatted.  If not, the region between dot
and the open symbol is reformatted.
\note{
This is an optional part of \jove{} that may not be
available on smaller systems (like a PDP-11).
}

\dc{fill-paragraph}{ESC \{J,j\}}
This rearranges words between lines so that all the lines in the current
paragraph extend as close to the right margin as possible, ensuring that
none of the lines will exceed the right margin.  The default value for
\cmd{right-margin} is 78, but can be changed with the \cmd{set} and
\cmd{right-margin-here} commands.  \Jove{} has a complicated algorithm
for determining the beginning and end of the paragraph (see
\cmd{forward-paragraph}).
\par\noindent
Whitespace is adjusted as follows: Tabs are left alone.  Multiple spaces
between words are collapsed to a single space.  Multiple spaces at the
end of a sentence are collapsed to a single space if \cmd{sentence-sep}
matches a single space, and to two spaces otherwise.
\par\noindent
In the normal case \jove{} will give all the lines the same indent as
they currently have, but if you wish to force a new indent you can
supply a numeric argument to \cmd{fill-paragraph} (e.g., by typing
\key{C-U~ESC~J}) and \jove{} will indent each line to the column
specified by the \cmd{left-margin} variable.
See also the \cmd{left-margin} variable and \cmd{left-margin-here} command.

\dc{fill-region}{C-X \{J,j\}}
This is like \cmd{fill-paragraph}, except it operates on all paragraphs
in a region instead of just a single paragraph.

\dc{filter-region}{C-X \#}
This sends the text in the region to a \UNIX{} command, and replaces the
region with the output from that command.  For example, if you are lazy
and don't like to take the time to write properly indented C code, you
can put the region around your C file and \cmd{filter-region} it through
\file{cb}, the \UNIX{} C beautifier.  If you have a file that contains a
bunch of lines that need to be sorted you can do that from inside
\jove{} too, by filtering the region through the \file{sort} \UNIX{}
command.  Before output from the command replaces the region \jove{}
stores the old text in the kill ring, so if you are unhappy with the
results you can easily get back the old text with \key{C-Y}.

\dc{find-file}{C-X C-F}
This visits a file into its own buffer and then selects that buffer.  If
you've already visited this file in another buffer, that buffer is
selected.  If the file doesn't yet exist, \jove{} will print
\out{(new file)} so that you know.  If you have no write permission for
the file, \jove{} will print \out{[Read only]} and puts the buffer in
\Def{View mode}.  If you specify a numeric argument N
point moves to the beginning of the Nth line; a negative argument counts
relative to the end of the file.
\par\noindent
Note that most versions of \jove{} support \Def{file name completion},
that is, you can use \key{Space} or \key{Tab} to complete a partial
filename, and \key{?} to display a list of files matching the partial
name.  You can set \cmd{completion-auto-help} to ``on'' to have this
list displayed when you try to complete an ambiguous filename.
\par\noindent
Most versions of \jove{} also support \Def{username expansion} a la
\file{csh\,(1)}, i.e., a leading ``{\tt\tilde{}user}'' is replaced with
the named {\tt user}'s home directory (a single ``{\tt\tilde{}}'' is
replaced with your own home directory.)  \Def{Directory stack expansion}
a la \file{tcsh\,(1)} is also supported, i.e., a leading ``{\tt=$N$}''
is replaced with the $N$th entry of the directory stack (with the
current directory counting as entry 0), and ``{\tt=-}'' is replaced with
the previous current directory, i.e., the directory that was current
before your last \cmd{cd}, \cmd{pushd} or \cmd{popd} command.
\par\noindent
If the file doesn't yet exist, and a macro is bound to
\cmd{prefix-3}~\key{R}, \jove{} executes that macro and then tries to
visit the file again.  You can use this, for instance, to automatically
check out a file from its RCS archive.

%[910116:new]
\dc{find-next}{F3}
This macro searches the next occurrence of the current search string.

%[910116:new]
\dc{find-previous}{F4}
This macro searches the previous occurrence of the current search string.

\dc{find-tag}{C-X \{T,t\}}
This finds the file that contains the specified tag.  \Jove{} looks up
tags by default in the \file{tags} file (see \file{ctags\,(1)}) in the
current directory.  You can change the default tag name by setting the
\cmd{tag-file} variable to another name.  If you specify a numeric
argument to this command, you will be prompted for a tag file.  This is
a good way to specify another tag file without changing the default.  If
the tag cannot be found the error is reported and point stays where it
is.

\dc{find-tag-at-point}{ESC \{T,t\}}
This finds the file that contains the tag that point is currently on.
See \cmd{find-tag}.

\dc{first-non-blank}{ESC \{M,m\}}
This moves point back (or forth) to the indent of the current line.

%[900719:changed]
\dc{forward-character}{C-F, $\rightarrow$}
This moves forward over a single character.  If point is at the end of
the line it moves to the beginning of the next one, unless
\cmd{over-write-mode} is enabled.  Then it moves ``beyond'' the
end of the line.

\dc{forward-line}{F8, Keypad 6}
This macro moves point forward to the end of the current line, or to the
end of the next line if point was already at the end of the line.

\dc{forward-list}{ESC C-N, ESC Keypad 6}
This moves point forward over a list.  It searches the first occurrence
of `(' after point and then moves just past the matching `)'.  This is
mode dependent, in C mode `\{' and `[' are also matched.  If you supply
a negative argument, it behaves just like \cmd{backward-list}.

\dc{forward-paragraph}{ESC ]}
This moves point forward to the end of the current or next paragraph.
Paragraphs are bounded by lines that begin with a Period (i.e., a
\file{nroff\,(1)} directive) or Back-slash (i.e., a \TeX{}
directive), or by blank lines; a change in indentation may also signal a
break between paragraphs, except that \jove{} allows the first line of a
paragraph to be indented differently from the other lines.

\dc{forward-s-expression}{ESC C-F, ESC (Keypad 3 or $\searrow$)}
This moves point forward over a s-expression.  If the first significant
character after point is `(', this moves past the matching `)'.  If the
character is a `{\tt"}' it will move past the quoted string.  If the
character begins an identifier, this moves just past it.  This is mode
dependent, so this will move over atoms in Lisp mode and C identifiers in C
mode.  \Jove{} also matches `\{' and `[' in C mode, and ignores comments.
If you supply a negative argument, it behaves just like
\cmd{backward-s-expression}.

\dc{forward-sentence}{ESC \{E,e\}}
This moves point forward to the end of the current or next sentence.
\jove{} considers the end of a sentence to be the characters `.', `!' or
`?' followed by a Newline, or one or more spaces.

\dc{forward-word}{ESC $\rightarrow$, ESC \{F,f\}, (Keypad 3 or $\searrow$), F6}
This moves point forward to the end of the current or next word.

\dc{fundamental-mode}{Not Bound}
This sets the major mode to \Def{Fundamental}.  This affects what \jove{}
considers as characters that make up words.  In \Def{Fundamental} mode all
printing (non-blank) characters are considered part of a word.

%[911007:new:14.15]
\dc{goto-character}{Not Bound}
If a numeric argument is supplied point moves to that character position
in the file.  If no argument is supplied one is prompted for.

%[910116:changed]
\dc{goto-line}{ESC \{G,g\}, Keypad .}
If a numeric argument is supplied point moves to the beginning of that
line.  A negative numeric argument means the line number relative
to the end of the buffer.  If no argument is supplied, it asks for the
line number. In that case, by supplying an explicit sign to the argument,
you can specify a move relative to the current line.

%[900719:new]
\dc{goto-window-with-buffer}{C-X 3}
This command prompts for a buffer name and then selects that buffer.  If
the buffer is currently being displayed in one of the windows, that
window is selected instead.

%[940424:new:14.32#10]
\dc{grep}{C-X G}
This macro prompts for arguments to the \UNIX{} command \file{grep\,(1)},
then runs it, and parses its output to find all occurrences of the
search string (see \cmd{parse-errors}).  The command used to invoke grep
is remembered in the macro (sic) \cmd{grep-command} for later use.

\dc{grep-command}{Not Bound}
This macro stores the command-line used in a previous \cmd{grep}
command.

\dc{grind-s-expr}{Not Bound}
When point is positioned on a `(', this re-indents that Lisp expression.

\dc{grow-window}{C-X \carat{}, C-X \{Z,z\}}
This makes the current window one line bigger.  This only works when
there is more than one window and provided there is room to change the
size.

\dc{handle-mouse}{Not Bound}
This command handles input from the mouse.  The mouse cursor is normally
hidden when you type text, but it reappears as soon as you move the
mouse.
\par\noindent
When you \Def{click} on a mode line using the \{left, right\} button, the
contents of the window pages \{up, down\}.  This auto-repeats while you
keep the button depressed.  If you hold the \key{Alternate} key
depressed you can resize the window by dragging its mode line up or
down.
\par\noindent
When you \Def{click} inside a window using the \{left, right\} button,
\{point, mark\} is set to the location of the mouse cursor.  You can
also select a region by \Def{dragging}, i.e., moving the mouse while
keeping the button depressed.  If you depress the second button while
dragging the start of the region is indicated for a short time.  This
also works on the message line when \out{*minibuf*} is active.
\par\noindent
You can associate a command (or macro) to the \Def{mouse click} by
binding it to \linebreak[3] \key{ESC} \{left,right\} button.  Whenever
you click the mouse, point is positioned to the location of the mouse
cursor (point is pushed if you use the right button), and the command
is executed.  Similarly you can associate a command (or macro) to the
\Def{mouse select} by binding it to \linebreak[3] \key{C-X}
\{left,right\} button.  Finally you can associate a command (or macro)
with a \Def{click} in the (inactive) message line area by binding it to
\linebreak[3] \cmd{prefix-3} \{left,right\} button.
\note{
This command is available only for the Atari~ST and MS-DOS versions
of \jove{}.
}

%[940612:changed:14.32#11]
\dc{handle-tab}{{C-I,Tab}}
This handles indenting to the ``right'' place.
In C and Perl mode, it uses the value of \cmd{c-indentation-increment},
and in other modes it uses the value of \cmd{indentation-increment} to
determine the tab stops.
\par\noindent
Tabs are handled specially when point is at the beginning of the line.
In C and Perl mode the indent is adjusted according to the current
``brace level'' if point is inside a function body or argument list; in
Lisp mode the list is reformatted if point is inside a list.  In all
other circumstances it lines up with the indent of the previous line.
Unless the previous line is not indented, then it indents to the value
of \cmd{left-margin}, and if that turns out to be zero, it uses the
current indentation value.
\par\noindent
To aid in proper indentation of `case'
and `default' labels in C mode, the macro \cmd{case-hack} is available,
which is bound to word-abbrevs for these keywords.  Abbrev mode should
be active for this to work properly.  You can, of course, redefine this
macro if you don't like its result.

%[900610:changed]
%[910705:changed:14.12]
\dc{hash-insert}{\#}
This handles the C mode insertion of the hash sign (\#). If you type it
as the first non-blank character on the line, it is considered the start
of a preprocessor command, and inserted at the first column. The amount
of whitespace following it is adjusted to line up with the previous
preprocessor command. Type \key{ESC~+~\#} to increase the indent level
with the amount of \cmd{\#-indentation-increment} and \key{ESC~-~\#} to
decrease it, if possible, with this amount.  If the previous preprocessor
command starts with `if', `else' or `elif' the indent level is incremented
automatically.  To undo this extra indentation the macro \cmd{\#-hack} is
available, which is normally bound to the word-abbrevs `else',
`elif' and `endif' --- so Abbrev mode should be active for this to
work.  As a special feature, if you type a semicolon `;' directly after
one of these words, the indentation will be adjusted, but
the semicolon itself is discarded.

%[911007:new:14.15]
\dc{help}{ESC ESC}
Trivial help function.
This waits for another character which can be one of the
following:
\begin{description}
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
\item[A]    \cmd{apropos}.
\item[B]    \cmd{describe-bindings}.
\item[C]    \cmd{describe-command}.
\item[K]    \cmd{describe-key}.
\item[M]    \cmd{describe-macro}.
\item[V]    \cmd{describe-variable}.
\end{description}
\NOTE{
Most versions of \jove{} may have additional bindings.  In taht case you
can see the actual bindings by typing a question mark (\key{?}).
}

\dc{help-function-keys}{ESC F5}
This macro shows the ``factory'' key bindings for the function keys.

\dc{help-keypad}{ESC F1}
This macro shows the ``factory'' key bindings for a vt100-like keypad.

\dc{help-layout-keyboard}{ESC F4}
This macro shows the keyboard layout, especially the location of
``exotic'' keys.

\dc{help-prefix-1-keypad}{ESC F2}
This macro shows the ``factory'' key bindings for a vt100-like keypad,
prefixed with \key{ESC}.

\dc{help-prefix-2-keypad}{ESC F3}
This macro shows the ``factory'' key bindings for a vt100-like keypad,
prefixed with \key{C-X}.

%[920330:new:14.22]
\dc{highlight}{variable}
If this variable is set, some commands (like \cmd{parse-errors} and
\cmd{find-tag}) visually highlight their matches---if the terminal is
capable of highlighting, of course.

%[910115:new]
\dc{i-process-parse}{variable}
If this variable is set, \jove{} runs commands like \cmd{compile-it}
and \cmd{spell-buffer} as interactive processes.  This allows you to continue
editing (presumably something else) while the make or spelling check is
grinding along.
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

%[910706:changed]
\dc{i-search-forward}{ESC C-S, ESC C-\bs{}}
Incremental search.  Like \cmd{search-forward} except that instead of
prompting for a string and searching for that string all at once, it
accepts the string one character at a time.  After each character you
type as part of the search string, it searches for the entire string so
far.  When you like what it found, type the \cmd{search-exit-char} key
(usually \key{Return}) to finish
the search.  You can take back a character with \key{Rubout} and the
search will back up to the position before that character was typed.
\key{C-S} finds the next occurrence of the search string;
\key{C-R} reverses the search direction;
\key{C-G} aborts the search;
\key{C-W} copies the remainder of the current word to the search string;
\key{C-Y} copies the remainder of the current line to the search string.

%[910706:changed]
\dc{i-search-reverse}{ESC C-R}
Incremental search.  Like \cmd{search-reverse} except that instead of
prompting for a string and searching for that string all at once, it
accepts the string one character at a time.  After each character you
type as part of the search string, it searches for the entire string so
far.  When you like what it found, type the \cmd{search-exit-char} key
(usually \key{Return}) to finish
the search.  You can take back a character with \key{Rubout} and the
search will back up to the position before that character was typed.
\key{C-R} finds the next occurrence of the search string;
\key{C-S} reverses the search direction;
\key{C-G} aborts the search;
\key{C-W} copies the remainder of the current word to the search string;
\key{C-Y} copies the remainder of the current line to the search string.

%[920826:new:14.26]
\dc{i-shell}{variable}
The shell to be used as the interactive command interpreter with the
\cmd{push-shell} and \cmd{shell} commands.  If your \file{ESHELL}
(sic) environment variable is set, it is used as the default value of
\cmd{i-shell}; otherwise the value of \cmd{shell} is used.

\dc{i-shell-command}{Not Bound}
This is like \cmd{shell-command} except it lets you continue with your
editing while the command is running.  This is really useful for long
running commands with sporadic output.  See the manual for information
on how to use interactive processes.
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

%[920826:new:14.26]
\dc{i-shell-flags}{variable}
This defines the flags that are passed to interactive shells.  The
default is \file{--i}.  See the \cmd{i-shell} variable to change the
default interactive shell.

%[910620:new:14.11]
\dc{ignore-bad-file-args}{variable}
This variable, when set, tells \jove{} to ignore any file arguments on
the command line that end with one of the extensions defined by the
\cmd{bad-filename-extensions} variable, or that is a directory.  Its
default value is ``off'' which means all files from the command line are
accepted.  This variable is used very early in your \jove{} session, so
to use it you should set it in your \file{.\,joverc} or from the command
line.

\dc{indentation-increment}{variable}
This defines a set of tabstops independent of the value of
\cmd{internal-tabstops} and \cmd{physical-tabstops}.  This value will be
used in all modes except C and Perl mode which use the value of
\cmd{c-indentation-increment} instead, and \jove{} will insert the
correct number of spaces and tabs to get the right behavior.  If you
like to indent with 4 spaces, set this value to 4.  Don't set
internal-tabstops to 4 because that will not work anymore.  Setting
internal-tabstops to 4 tells \jove{} to display tabs as every 4 spaces.
This will cause your text to look terrible with anyone else who displays
the file with normal tabstops at every 8 characters.  Not to mention
printing your text won't look right.
\par\noindent
But all that aside, if you set \cmd{indentation-increment} to 8, and
then set internal-tabstops to 4 as well, \jove{} will insert {\em two\/}
tabs to get the indentation to 8, which is clearly not what you want.
If you set \cmd{indentation-increment} to 0 (the default) it
automatically takes the value of \cmd{internal-tabstop}, i.e., only real
tabs are used to indent.

%[910116:new]
\dc{insert-character}{C-C}
This macro inserts a blank character at Point.  It is especially useful
in OverWrite mode.

\dc{insert-file}{C-X {C-I,Tab}}
This inserts a specified file into the current buffer at point.  Point
is positioned at the beginning of the inserted file. Mark is set at its
end.

\dc{internal-tabstop}{variable}
The number of spaces \jove{} should print when it displays a tab
character.  The default value is 8.

\dc{interrupt-character}{variable}
This is set to the character that interrupts \jove{} (with a signal) no
matter what \jove{} is doing.  Its main use is for interrupting
non-interactive processes, but it also has uses for debugging.  After you
interrupted \jove{}, you can choose to abort \jove{} altogether
(\key{A} or \key{Y}), to interrupt the current command (\key{I}), or
to continue as if nothing has happened (any other key).
Unfortunately there is no way to turn off the interrupt character.
\NOTE{
On some \UNIX{} systems it is not possible to interrupt \jove{} when
\cmd{allow-\carat{}S-and-\carat{}Q} or \cmd{meta-key} are set.
On Atari~ST and MS-DOS systems it is not possible to interrupt \jove{}
at all --- but its sub-processes can still be interrupted the usual way.
}

\dc{interrupt-process}{Not Bound}
This sends the interrupt character (usually \key{C-C}) to the
interactive process in the current buffer. This only works
when you are inside a buffer that's attached to a process.
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

%[930119:new:14.30]
\dc{join-next-line}{ESC \$}
This macro joins the current line with the next one, with a single
space inbetween.

%[930119:new:14.30]
\dc{join-previous-line}{ESC \&}
This macro joins the current line with the previous one, with a single
space inbetween.

\dc{jove-lib}{Not Bound}
This macro holds the name of \jove{}s library directory.

%[910116:new]
\dc{just-one-space}{C-X \tilde{}}
This macro replaces arbitrary whitespace with one single blank.

%[920610:new:14.23]
\dc{key-bindings-in-minibuf}{Not Bound}
The following key bindings are active when you are prompted for input
at the message line:
\begin{description}
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
\item[\carat{}C]   Copy word at point in the current window.
\item[\carat{}R]   Recall default value.
\item[\carat{}S]   Insert the file name of the buffer displayed in the
\onlinehelp{     }current window.  If a numeric argument $N$ is given,
\onlinehelp{     }insert the file name of the buffer numbered $N$.
\item[\carat{}\bs{}]   (same as \key{\carat{}S})
\end{description}

%[910215:new]
\dc{keypad}{variable}
This selects the keypad mode of your terminal, if that has a keypad
that can be switched between numeric and application mode (like a
vt100).  Its default value is ``on'', that means the keypad keys behave
like function keys.
\NOTE{
some terminals go into ``local function key'' mode when you turn
this variable off, that is, the function key codes are not transmitted
to \jove{}.  This is not very useful, so you better leave \cmd{keypad}
``on'' for these terminals.
}
\NOTE{
In the MS-DOS version of \jove{}, this variable, in combination with the
\key{NumLock} key, determines the keypad layout.  If \key{NumLock} is
off the standard PC's keypad is used, else it mimics the vt100 keypad's
behaviour.  (Try \key{Alt-F1}\ldots\key{Alt-F4})
}

%[940522:new:14.32#10]
\dc{keyseq-timeout-in-ms}{variable}
This variable determines how long to wait for the next input character
to arrive while \jove{} is looking for possible function key sequences.
For example, if the \key{$uparrow$} key is defined as the sequence
\key{ESC~[~A}, after it has seen the \key{ESC} character \jove{} waits
up to \cmd{keyseq-timeout-in-ms} milliseconds.  When the next input
character arrives in time, it is checked to see if it matches the next
character in any of the function key sequences that start with
\key{ESC}.  If it does match, as in our example `\key{[}' would, the state
of the function key recognizer is advanced, and the process is repeated
until a complete key sequence has been recognized (e.g.\ `\key{A}'), in
which case the code of the function key (`\key{\carat{}:ku}' in our
example) is passed to the higher levels of \jove{}s input handling.  If
the input character does not match any of the defined key sequences, or
a character does not arrive within the allotted time, the input
characters that make up the partial key sequence are passed verbatim.
Thus the recognition of function key sequences does not interfere with
\jove{}s normal key bindings (or at least as little as possible.)
\NOTE{
This is system-dependent.  It is set to a value that should work most
of the time, but if your system or network is usually under a high load
you may want to set it to a higher value.
}

\dc{kill-next-word}{ESC \{D,d\}}
This kills the text from point to the end of the current or next word.

\dc{kill-previous-word}{ESC Delete, ESC {C-H,Backspace}}
This kills the text from point to the beginning of the current or
previous word.

\dc{kill-process}{Not Bound}
This command prompts for a buffer name or buffer number (just as
\cmd{select-buffer} does) and then sends the process in that buffer a
kill signal (9).
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

\dc{kill-region}{C-W}
This deletes the text in the region and saves it on the kill ring.
Commands that delete text but save it on the kill ring all have the word
\cmd{kill} in their names.  Type \key{C-Y} to yank back the most recent
kill.

\dc{kill-s-expression}{ESC C-K}
This kills the text from point to the end of the current or next
s-expression.

\dc{kill-some-buffers}{Not Bound}
This goes through all the existing buffers and asks whether or not to
kill them.  If you decide to kill a buffer, and it turns out that the
buffer is modified, \jove{} will offer to save it first.  This is useful
for when \jove{} runs out of memory to store lines (this only happens on
small systems) and you have lots of buffers that you are no longer using.

\dc{kill-to-beginning-of-sentence}{C-X Delete, C-X {C-H,Backspace}}
This kills from point to the beginning of the current or previous
sentence.

\dc{kill-to-end-of-line}{C-K}
This kills from point to the end of the current line.  When point is at
the end of the line the line separator is deleted and the next line is
joined with current one.  If a numeric argument is supplied that many
lines are killed; if the argument is negative that many lines
{\em before\/} point are killed; if the argument is zero the text from
point to the beginning of the line is killed.

\dc{kill-to-end-of-sentence}{ESC \{K,k\}}
This kills from point to the end of the current or next sentence.  If a
negative numeric argument is supplied it kills from point to the
beginning of the current or previous sentence.

\dc{left-margin}{variable, C-X \{}
This is how far lines should be indented when \Def{Auto Indent} mode is
on, or when the \cmd{newline-and-indent} command is run (usually by
typing \key{LineFeed}).  It is also used by \cmd{fill-paragraph} and
\Def{Auto Fill} mode.  If the value is zero (the default) then the left
margin is determined from the surrounding lines.

\dc{left-margin-here}{C-X [}
This sets the \cmd{left-margin} variable to the current position of
point.  This is an easy way to say, ``Make the left margin begin here,''
without having to count the number of spaces over it actually is.

%[920329:new:14.22]
\dc{lines}{variable}
This constant contains the current screen height, in lines.

\dc{lisp-mode}{Not Bound}
This turns on \Def{Lisp} mode.  Lisp mode is one of five mutually
exclusive major modes: Fundamental, Text, C, Perl and Lisp.  In Lisp mode,
the characters Tab and `)' are treated specially, similar to the way
they are treated in C mode.  Also, \Def{Auto Indent} mode is affected,
and handled specially.

%[900610:changed]
%[910116:changed]
%[910705:changed:14.12]
\dc{list-buffers}{C-X C-B}
This types out a list containing various information about each buffer.
Right now that list looks like this:
\begin{quote}\begin{verbatim}
(* means buffer needs saving)
(+ means file hasn't been read yet)

NO Lines Type      Mode      Name          File
-- ----- ----      ----      ----          ----
1  1     File      T         Main          [No file]
2  2     Scratch   T       * *minibuf*     [No file]
3  2238  File      Tmfa    * jovecmds.tex  jovecmds.tex
4  1     Process   T         [grep]        [No file]
5  10    Scratch   T       * Buffer list   [No file]
\end{verbatim}\end{quote}
The first column lists the buffer's number.  When \jove{} prompts for a
buffer name you can either type in the full name, or you can simply type
the buffer's number.  The second column is the number of lines in the
buffer.  The third says what type of buffer.  There are four types:
\cmd{File}, \cmd{Scratch}, \cmd{Process} and \cmd{I-Process}.  \cmd{File}
is simply a buffer
that holds a file; \cmd{Scratch} is for buffers that \jove{} uses
internally---these are only shown if you supply a numeric argument;
\cmd{Process} is one that holds the output from a \UNIX{} command,
and \cmd{I-Process} has an interactive process attached to it.  The fourth shows
the buffer's major and minor modes.  The next column contains the name
of the buffer.  And the last column is the name of the file that's
attached to the buffer.  In this case, both \out{*minibuf*} and
\file{jovecmds.tex} have been changed but not yet saved.  In fact
\out{*minibuf*} won't be saved since it's an internal \jove{} buffer
that I don't even care about.
If you supply a negative numeric argument, only modified buffers are shown.

%[900716:changed]
\dc{list-processes}{Not Bound}
This makes a list somewhat like \cmd{list-buffers} does, except its list
consists of the current interactive processes.  Right now the list
looks like this:
\begin{quote}\begin{verbatim}
Buffer           Status           Pid      Command
------           ------           ---      -------
*shell*          Running          10195    /bin/sh -i
[fgrep]          Done             10193    fgrep -n Buffer *.c
[cdb]            DBX Running      10156    cdb xjove
\end{verbatim}\end{quote}
The first column has the name of the buffer to which the process is
attached.  The second has the status of the process; if a process has
exited normally the status is \out{Done} as in fgrep; if the process
exited with an error the status is \out{Exit N} where N is the value of
the exit code; if the process was killed by some signal the status is
\out{Killed N} where N is the signal that was used; otherwise the
process is running.  The status also shows whether DBX mode is enabled
(see the command \cmd{process-dbx-output} and the variable
\cmd{dbx-format-string}).  The last column is the name of the command
that is being run.
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

%[920812:new:14.25]
\dc{list-tags}{ESC \{L,l\}}
This macro lists all tags that match a given pattern.  For now, it just
uses \file{grep\,(1)} to find the tags in \cmd{tag-file}.

%[230991:changed:14.13:VMS support]
\dc{mail-check-frequency}{variable}
This is how often (in seconds) \jove{} should check your mailbox for
incoming mail.  If you set this to zero \jove{} won't check for new
mail.  See also the \cmd{mailbox} and \cmd{disable-biff} variables.
\note{
This is only available on \UNIX{} and VMS systems.
}
\note{
Under VMS, where instead of just checking for incoming mail, all
broadcast messages are intercepted and recorded in the buffer
\out{*message*}, this variable merely determines how long the \%C
message is displayed at the mode line.
}

\dc{mailbox}{variable}
Set this to the full pathname of your mailbox.  \Jove{} will look here
to decide whether or not you have any unread mail.  This defaults to
\file{\$MAIL}, or else to your default mailbox (as derived from your
login name).
\note{
This is only available on \UNIX{} systems.
}

\dc{make-backup-files}{variable, C-\_ C-B}
If this variable is set, then whenever \jove{} writes out a file, it
will move the previous version of the file (if there was one)
to \file{\$\{backup-file-prefix\Rbrace filename}.
This is often convenient if you save a file by accident.  The default
value of this variable is ``off''.
\note{
This is an optional part of \jove{} and your guru may not have it
enabled, so it may not work.
}

\dc{make-buffer-unmodified}{ESC \tilde{}}
This makes \jove{} think the selected buffer hasn't been changed even if
it has.  Use this when you accidentally change the buffer but don't want
it considered changed.  Watch the mode line to see the \out{*} disappear
when you use this command.

%[920812:new:14.25]
\dc{make-keymap}{Not Bound}
This creates an empty keymap with a name you supply.  That name can be
used to reference the keymap in other commands, such as
\cmd{bind-keymap-to-key}.  If you supply a numeric argument, a
\Def{sparse} keymap of that size is created instead of a full-size map.
A sparse map behaves just like a normal keymap, except that it takes up
less space, key lookup is slower and is always case-insensitive.
\note{
dynamic keymap support is an optional part of \jove{}.
}

%[910116:changed]
\dc{make-macro-interactive}{ESC \{I,i\}}
This command is meaningful only while you are defining a keyboard macro.
Ordinarily, when a command in a
macro definition requires a trailing text argument (file name, search
string, etc.), the argument you supply becomes part of the macro
definition.  If you want to be able to supply a different argument each
time the macro is used, then while you are defining it, you should give
this command just before typing the argument
which will be used during the definition process.
\par\noindent
You can also use this command at any other place, e.g., if you want to be
able to insert a different string at some point each time you invoke the
macro.  You return to definition/execution of the rest of the macro by
executing \cmd{make-macro-interactive} again; it toggles.
\par\noindent
Another use of this command is to propagate the repeat count of the macro
to another command inside that macro.
You do this by inserting \cmd{make-macro-interactive}
with a numeric argument before that command;
the macro repeat count is used as the actual numeric argument and is
replaced by 1, so the macro is always just executed once.  For example,
the \cmd{find-next} macro is defined as follows:
\begin{quote}\begin{verbatim}
define-macro find-next ^U^[I^S^R^M
\end{verbatim}\end{quote}
(\key{C-U~ESC~I} propagates the repeat count to \key{C-S}
(\cmd{search-forward}), \key{C-R} inserts the default search string
which is ended with \key{Return}.)
\par\noindent
Use \key{ESC~-~ESC~I} if you propagate to another macro and you want a
count of zero to mean `repeat 0 times' instead of `execute until failure'.

%[940424:new:14.32#10]
\dc{man}{C-X M}
This macro invokes the \UNIX{} command \file{man\,(1)}.

\dc{mark-flash}{C-X C-@, C-X Space}
This shows the location of the mark by moving the cursor to it for a
short time, in much the same fashion as \Def{Show Match} mode handles
paren-flashes.

\dc{mark-threshold}{variable}
This variable contains the number of lines point may move by before the
mark is set.  If, in a search or something, point moves by more than
this many lines, the mark is set so that you may return easily.  The
default value of this variable is 22 (one screenful, on most terminals).

\dc{marks-should-float}{variable}
When this variable is ``off'', the position of a mark is remembered as a
line number within the buffer and a character number within the line.
If you add or delete text before the mark, it will no longer point to
the text you marked originally because that text is no longer at the
same line and character number.  When this variable is ``on'', the
position of a mark is adjusted to compensate for each insertion and
deletion.  This makes marks much more sensible to use, at the cost of
slowing down insertion and deletion somewhat.  The default value is
``on''.

\dc{match-regular-expressions}{variable, C-\_ {C-M,Return}}
When this variable is set, \jove{} will match regular expressions in
search patterns.  To summarize:
\begin{center}\begin{tabular}{ll}
%%.ta \w'Token1111111'u
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
{\bf Token}       &{\bf Matches} \\
%%-----       -------
.           &any character. \\
\mbox{[\ldots]}       &any character in a set. You can use ranges like ``A--Z''. \\
\mbox{[\carat{}\ldots]}      &any character not in the set.  \\
\bs{}( x \bs{})     &sub-expression ``x'', remembering its location. \\
\bs{}1 .\,.\ \bs{}9    &the Nth \bs{}(~\mbox{\ldots}~\bs{}) match. \\
\bs{}\{ x, \mbox{\ldots}\,\bs{}\} &the first matching sub-alternate. \\
x{\tt*}          &zero or more occurrences of expression ``x''. \\
x+          &one or more occurrences of expression ``x''. \\
x?          &zero or one occurrence of expression ``x''. \\
x\bs{}!         &negate match status of ``x''. \\
\carat{}           &(when at start of pattern) start of line. \\
\$           &(when at end of pattern) end of line. \\
\bs{}$<$          &start of word. \\
\bs{}$>$          &end of word. \\
x \bs{}$|$ \mbox{\ldots}   & the first matching alternate. \\
\bs{}c          &(not in ``{\tt <>\{\Rbrace()1-9}'') the literal character `c'. \\
c           &(not in ``{\tt [].*+?\bs{}}'') the literal character `c'. \\
\end{tabular}\end{center}
See also the \file{ed\,(1)} manual page, the tutorial ``Advanced Editing
in \UNIX{}'', and the section above ``Searching with Regular Expressions''
for more information.

%[910116:new]
\dc{menu-extended-char}{Not Bound}
This macro brings up a menu of ``exotic'' characters in a window.  With
the Right mouse button you can pick characters from this menu; these are
inserted at Point in the next window.
\note{
This command is available only for the Atari~ST and MS-DOS versions
of \jove{}.
}

\dc{meta-key}{variable}
You should set this variable to a prefix-character like \key{ESC} if
your terminal has a real \key{Meta} key (sometimes called
\key{Alternate}). If your terminal has such a key, then a key sequence
like \key{ESC~Y} can be entered by holding down \key{Meta} and typing
\key{Y}. This variable is also set (to \key{ESC}) if the description of
the terminal indicates it has a meta key, or if the \UNIX{} environment
variable \file{METAKEY} exists.  You can disable the metakey feature by
setting this variable to \key{C-@}. On systems that support an extended
character set (like the Atari ST) you can then use \key{Meta} to insert
the ``exotic'' characters.

%[910116:new]
\dc{minibuf-newline}{ESC {C-M,Return}}
This macro is meaningful only when you are in the minibuffer.
It stores the string you're currently working on in \out{*minibuf*}
before doing a regular \cmd{newline}, so that you can recall it later on.

%[900716:changed]
\dc{mode-line}{variable}
The format of the mode line can be determined by setting this variable.
The items in the line are specified using a format a la
\file{printf\,(3)}, with the special things being marked as ``\%x'':
\begin{quote}\begin{tabular}{lp{4in}}
%%.ta 8n
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
\%b      &the current buffer name. \\
\%C      &check for new mail, display \out{[New mail]} if there is any.
        (see also \cmd{mail-check-interval} and \cmd{disable-biff}.) \\
\%c      &the fill character (`$-$', or Space if reverse video.) \\
\%d      &the current directory. \\
\%e      &stretchable space. Any leftover space is distributed
        evenly among the \%e's in the modeline. \\
\%F      &the current file name, with leading path stripped. \\
\%f      &the current file name. \\
\%L      &the current line number. \\
\%l      &the current load average (updated automatically.) \\
\%M      &the current list of major and minor modes. \\
\%mxy    &x, when the buffer is modified or y, when not. \\
\%n      &the current buffer number. \\
\%P      &estimate of relative position in the buffer. \\
\%p      &interactive process status for i-process windows. \\
\%s      &space, but only if previous character is not a space. \\
\%t      &the current time (updated automatically.) \\
\%V      &the version number of this \jove{}. \\
\%w      &a `$>$' for windows which are scrolled left. \\
\%[~\%]   &the square brackets printed when in a recursive edit. \\
\%(~\%)   &conditionally include items enclosed in \%(~\%).
        The condition is given by the repeat count (see below).
        \%(~\%)'s can be nested. \\
\%\%      &a literal \%. \\
\end{tabular}\end{quote}
In addition, any other character is simply copied into the mode line.
Digits may be used between the `\%' and the `x' to give a repeat count
(which is ignored most of the time except for \%c, \%e, \%( and~\%s.)
For \%(~\%) the repeat count ($N$) determines the condition, as follows:
\begin{quote}\begin{tabular}{rl}
%%.ta 8n
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
{\bf Value}   &{\bf Condition} \\
%%-----   --------
(none)  &display on the bottom mode line only. \\
    0   &(same as above) \\
    1   &display if a \cmd{Scratch} buffer is attached. \\
    2   &display if a \cmd{File} buffer is attached. \\
    3   &display if a \cmd{Process} buffer is attached. \\
    4   &display if a \cmd{I-process} buffer is attached. \\
    7   &(``not F'') display if the file name is known. \\
    8   &(``B=F'') display if buffer- and file-names differ. \\
10--19   &display if condition $N-10$ is {\em not\/} true. \\
$\geq$ 20   &display if the screen width is $\geq N$. \\
\end{tabular}\end{quote}
To get a feel for all this, try typing \key{ESC~X print mode-line} and
compare the result with your current mode line.
\NOTE{
\%L, \%l, \%P, \%p and \%t may not be available on your system; \%C is abused as
CapsLock indicator on Atari~ST and MS-DOS systems.
}

\dc{mode-line-should-standout}{variable}
If set, the mode line will be printed in reverse video, if your terminal
supports it.  The default for this variable is ``on''.

%[920402:new:14.22]
\dc{model}{variable}
This constant contains \jove{}s model, which is one of \out{TINY},
\out{SMALL} or \out{BIG}.  Its value is determined by a compile-time
option.  It is there so that \jove{}s startup script can test it and take
appropriate action.

\dc{name-keyboard-macro}{ESC \{N,n\}}
This copies the keyboard macro and gives it a name freeing up the
keyboard macro so you can define some more.  Keyboard macros with their
own names can be bound to keys just like built in commands can.  See
also the \cmd{edit-macros} and \cmd{read-macros-from-file} commands.
\par\noindent
In a \file{.\,joverc} file (see \cmd{source}) it behaves exactly the
same as \cmd{define-macro}, for the sake of backward compatibility.

%[910116:changed]
\dc{newline}{{C-M,Return}}
This divides the current line at point moving all the text to the right
of point down onto the newly created line.  Point moves down to the
beginning of the new line.  If \Def{Auto Indent} mode is enabled, proper
indentation is added.  The amount of indentation is determined by the
current Major mode.  In Text mode, it just lines up with the previous
line, while in C and Lisp mode the ``right'' indentation level is used.

%[910618:changed]
\dc{newline-and-backup}{C-O}
This divides the current line at point moving all the text to the right
of point down onto the newly created line.  The difference between this
and \cmd{newline} is that point does not move down to the beginning of
the new line.
\NOTE{
This now works correctly in combination with \Def{Auto Indent} mode.
}

\dc{newline-and-indent}{{C-J,Linefeed}, (Enter or InsertLine)}
This behaves the same as \key{Return} does when in \Def{Auto Indent}
mode.  This makes \Def{Auto Indent} mode obsolete but it remains in the
name of backward compatibility.

%[930119:new:14.30]
\dc{news}{Not Bound}
Summarize new \jove{} features.

\dc{next-buffer}{C-X (Keypad 2 or NextPage)}
This macro selects the next buffer.

\dc{next-error}{C-X C-N, C-X $\downarrow$}
This moves to the next error in the list of errors that were parsed with
\cmd{parse-errors}. In one window the list of errors is shown with the
current one always at the top, or highlighted and centered if the
\cmd{highlight} variable is set.
In another window is the file that contains the error.  Point is
positioned in this window on the line where the error occurred.  This
line is also highlighted, if possible.  If you supply a numeric argument
$N$ it moves to the $N$th next error (or the last error, whichever comes
first). If the argument is negative it behaves just like
\cmd{previous-error}; if the argument is zero it behaves just like
\cmd{current-error}.

\dc{next-line}{C-N, $\downarrow$}
This moves down to the next line.  If OverWrite mode is not active and
you are at the last line of the buffer, it moves to end-of-file, that is,
to the very last character in the buffer.
If you are already there, it fails and rings the bell.

%[940522:new:14.32#10]
\dc{next-line-first-non-blank}{ESC (Keypad 0 or F0)}
This macro moves down to the indent of the next line.

\dc{next-page}{C-V, (Keypad 2 or NextPage)}
This displays the next page of the buffer by taking the bottom line(s)
of the window and redrawing the window with it at the top.  The variable
\cmd{page-overlap} determines how many lines are taken.  If a numeric
argument is supplied the screen is scrolled up that many lines; if the
argument is negative the screen is scrolled down.  The argument is
remembered; future page commands scroll the same number of lines (until
you change it, of course; when you supply \key{ESC~+} (or \key{ESC~0})
the scroll step is forgotten).

\dc{next-window}{C-X \{N,n\}, ESC $\downarrow$}
This moves into the next window.  Windows live in a circular list so
when you're in the bottom window and you try to move to the next one you
are moved to the top window.  It is an error to use this command with
only one window.

\dc{number-lines-in-window}{Not Bound}
This displays the line numbers for each line in the buffer being
displayed.  The number isn't actually part of the text; it's just
printed before the actual buffer line is.  To turn this off you run the
command again; it toggles.

\dc{over-write-mode}{C-X \{O,o\}}
This turns \Def{Over Write} mode on (or off if it's currently on) in the
selected buffer.  When on, this mode changes the way the self-inserting
characters work.  Instead of inserting themselves and pushing the rest
of the line over to the right, they replace or over-write the existing
character.  Also, \key{Rubout} replaces the character before point with a
space instead of deleting it.  It also affects the behaviour of the
basic cursor movements.  When \Def{Over Write} mode is on \out{OvrWt} is
displayed on the mode line.

\dc{page-next-window}{ESC C-V, ESC (Keypad 2 or NextPage)}
This displays the next page in the next window.  This is exactly the
same as \linebreak[3] \key{C-X~N~C-V~C-X~P}.

%[911007:new:14.15]
\dc{page-overlap}{variable}
This variable gives the page overlap, in lines, for the \cmd{next-page}
and \cmd{previous-page} commands.  Its default value is 2.

%[910116:new]
\dc{page-up-next-window}{ESC (Keypad 8 or PrevPage)}
This macro displays the previous page in the next window.  This is exactly the
same as \linebreak[3] \key{ESC~-~ESC~C-V}.

\dc{paren-flash}{), ], \}}
This handles the C mode curly brace indentation, the Lisp mode paren
indentation, and the Show Match mode paren/curly brace/square bracket
flashing.

\dc{paren-flash-delay}{variable}
How long, in tenths of seconds, \jove{} should pause on a matching
parenthesis in \Def{Show Match} mode.  The default is 5.

%[900727:changed]
\dc{parse-errors}{ESC C-E}
This takes the list of C compilation errors (or output from another
program in the same format) in the current buffer and parses them for
use with the \cmd{next-error} and \cmd{previous-error} and
\cmd{current-error} commands.  This is a very useful tool and helps with
compiling C programs and when used in conjunction with the \file{grep}
\UNIX{} command very helpful in making changes to a bunch of files.
This command understands errors produced by \file{cc}, \file{cpp}, and
\file{lint}; plus any other program with the same format (e.g.,
\file{grep --n}).
\par\noindent
\Jove{} visits each file that has an error and remembers each line that
contains an error.  It doesn't matter if later you insert or delete
some lines in the buffers containing errors; \jove{} remembers where
they are regardless.  If some errors are found \cmd{current-error} is
automatically executed, so you end up at the first error.
\par\noindent
If you supply an argument you are prompted for an error-format string.
See also \cmd{error-format-string} if you want to parse errors
of a different format.


%[900727:deleted;parse-special-errors]

\dc{parse-spelling-errors-in-buffer}{Not Bound}
This parses a list of words in the current buffer and looks them up in
another buffer that you specify.  This will probably go away soon.

\dc{pause-jove}{ESC C-C}
This stops \jove{} and returns control to the parent shell.  To return
to \jove{} you type \file{fg} to the C-shell.
\NOTE{
This only works for users
using the C-shell, and on systems that have the job control facility.
For other systems it is equivalent to \cmd{push-shell}.
}

%[911024:new:14.15]
\dc{perl-mode}{Not Bound}
This turns on \Def{Perl} mode in the currently selected buffer.  This is
one of currently five possible major modes:  Fundamental, Text, C,
Lisp and Perl.  \Def{Perl} mode is much like \Def{C} mode, except for some
small but essential details (like C-style comments.)
\NOTE{
\file{perl} is a programming language designed by Larry Wall, which combines
many desirable features of C, sh, sed and awk.
}

\dc{physical-tabstop}{variable}
How many spaces your terminal prints when it prints a tab character.
You probably shouldn't want to change it.

\dc{pick-buffer}{C-\_ B}
This is like \cmd{select-buffer} except it refuses to create a new
buffer.

\dc{pop-mark}{Not Bound}
This gets executed when you run \cmd{set-mark} with a numeric argument.
\Jove{} remembers the last 16 marks and you use \cmd{pop-mark} to go
backward through the ring of marks.  If you execute \cmd{pop-mark}
enough times you will eventually get back to where you started.

\dc{popd}{Not Bound}
This pops one entry off the directory stack.  Entries are pushed with
the \cmd{pushd} command.  The names were stolen from the C-shell and the
behavior is the same, except that ``popd~$+N$'' (remove the $N$th entry,
counting from the top of the stack) and ``popd~$-N$'' (remove the $N$th
entry, counting the other way round, so $-1$ denotes the bottom entry in
the stack.) found in newer C-shell versions are mimicked by giving the
\cmd{popd} command a numeric argument.

\dc{prefix-1}{ESC}
This reads the next character and runs a command based on the character
typed.  If you wait for more than a second or so before typing the next
character, the message \key{ESC} will be printed on the message line to
remind you that \jove{} is waiting for another character.

\dc{prefix-2}{C-X}
This reads the next character and runs a command based on the character
typed.  If you wait for more than a second or so before typing another
character, the message \key{C-X} will be printed on the message line to
remind you that \jove{} is waiting for another character.

\dc{prefix-3}{C-\_}
This reads the next character and runs a command based on the character
typed.  If you wait for more than a second or so before typing the next
character, the character that invoked \cmd{prefix-3} will be printed on the
message line to remind you that \jove{} is waiting for another one.

%[930119:new:14.30]
\dc{previous-buffer}{C-X (Keypad 8 or PrevPage)}
This macro selects the previous buffer.

\dc{previous-error}{C-X C-P, C-X $\uparrow$}
This is the same as \cmd{next-error} except it goes to the previous
error.  See \cmd{next-error} for documentation.

\dc{previous-line}{C-P, $\uparrow$}
This moves up to the previous line.  If you are at the first line in the
buffer it moves to beginning-of-file, that is, the very first character in
the buffer.  If you are already there, it fails and rings the bell.

\dc{previous-page}{ESC \{V,v\}, (Keypad 8 or PrevPage)}
This displays the previous page of the current buffer by taking the top
line(s) and redrawing the window with it at the bottom.  The variable
\cmd{page-overlap} determines how many lines are taken.  If a numeric
argument is supplied the screen is scrolled down that many lines; if the
argument is negative the screen is scrolled up. The argument is
remembered; future page commands scroll the same number of lines (until
you change it, of course; when you supply \key{ESC~0} or \key{ESC~+}
the scroll step is forgotten).

\dc{previous-window}{C-X \{P,p\}, ESC $\uparrow$}
This moves into the previous window.  Windows live in a circular list so
when you're in the top window and you try to move to the previous one
you are moved to the bottom window.  It is an error to use this command
with only one window.

\dc{print}{ESC \{P,p\}}
This prints the value of a \jove{} variable, or inserts it at Point if
you supplied a negative numeric argument.

\dc{print-message}{C-\_ C-P}
This command prompts for a message, and then prints it on the bottom
line where \jove{} messages are printed, or inserts it at Point if you
supply a negative numeric argument.

%[920812:new:14.25]
\dc{process-bind-macro-to-key}{Not Bound}
This is like \cmd{process-bind-to-key}, except you use it to bind macros
to process-specific keys instead of commands.

\dc{process-bind-to-key}{Not Bound}
This command is identical to \key{bind-to-key}, except that it only
affects your bindings when you are in a buffer attached to a process.
When you enter the process buffer, any keys bound with this command will
automatically take their new values.  When you switch to a non-process
buffer, the old bindings for those keys will be restored.  For example,
you might want to execute
\begin{quote}\tt
process-bind-to-key stop-process \carat{}Z \\
process-bind-to-key interrupt-process \carat{}C
\end{quote}
Then, when you start up an interactive process and switch into that
buffer, \key{C-Z} will execute \cmd{stop-process} and \key{C-C} will
execute \cmd{interrupt-process}.  When you switch back to a non-process
buffer, \key{C-Z} will go back to executing \cmd{scroll-up} (or whatever
you have it bound to).
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

%[900716:new]
\dc{process-dbx-output}{Not Bound}
This command only makes sense in a buffer running an interactive
process.  If you are running \file{dbx} in a window, \jove{} will
automatically find the file you are currently stepping through and
display it in another window.  The string \out{DBX} will appear in the
modeline along with the process status when this feature is enabled. See
also the variable \cmd{dbx-format-string}.
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

\dc{process-newline}{Not Bound}
This this only gets executed when in a buffer that is attached to an
interactive-process.  \Jove{} does two different things depending on
where you are when you hit \key{Return}.  When you're at the end of the
I-Process buffer this does what \key{Return} normally does, except it
also makes the line available to the process.  When point is positioned
at some other position that line is copied to the end of the buffer
(with the prompt stripped) and point is moved there with it, so you can
then edit that line before sending it to the process.  This command
{\em must\/} be bound to the key you usually use to enter shell commands
(\key{Return}), or else you won't be able to enter any.
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

\dc{process-prompt}{variable}
What a prompt looks like from the shell and i-shell-command processes.
The default is ``\out{\%~}'', the default C-shell prompt.  This is
actually a regular expression search string.  So you can set it to be
more than one thing at once using the \bs{}$|$ operator.  For instance,
for Lisp hackers, the prompt can be
\begin{quote}\begin{verbatim}
% \|-> \|<[0-9]>:
\end{verbatim}\end{quote}
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

\dc{process-send-data-no-return}{Not Bound}
This is like \cmd{process-newline} except that it does not send the
return.
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

%[930208:new:14.30]
\dc{prompt-with-prefix-arg}{variable}
If set, the prefix numeric argument (if any) is shown in front of any
prompt on the message line.  Its default value is ``off''.

\dc{push-shell}{Not Bound}
This spawns a child shell and relinquishes control to it.  This works on
any version of \UNIX{}, but this isn't as good as \cmd{pause-jove}
because it takes time to start up the new shell and you get a brand new
environment every time.  To return to \jove{} you type \key{C-D}.

\dc{pushd}{Not Bound}
This pushes a directory onto the directory stack and cd's into it.  It
asks for the directory name but if you don't specify one it switches the
top two entries no the stack.  It purposely behaves the same as
C-shell's \cmd{pushd}, except that ``pushd~$+N$'' (make the $N$th entry,
counting from the top of the stack, the current directory) and
``pushd~$-N$'' (make the $N$th entry, counting the other way round, the
current directory, so $-1$ denotes the bottom entry in the stack.) found
in newer C-shell versions can also be mimicked by giving the \cmd{pushd}
command a numeric argument.  See also the variables \cmd{dirs-unique}
and \cmd{dirs-extract}.

\dc{pwd}{Not Bound}
This prints the working directory.

%[900716:changed]
\dc{quadruple-numeric-argument}{C-U}
This command is one of two ways to specify a numeric argument to a
command.  It's usually bound to \key{C-U}.  Typing \key{C-U} once means,
Do the next command 4 times.  Typing \key{C-U} twice will do the next
command 16 times, and so on.  At any point you can type \key{-} to
toggle the sign and \key{/} to undo one \key{C-U} (think of this as
division by 4).  If at any point you type a number, then that number
will be used instead.  For instance, \key{C-U~3~5}
means do the next command 35 times.

%[911126:new:14.18]
\dc{query-replace-in-region}{C-X \{Q,q\}}
This is the same as \cmd{query-replace-string} except that it is restricted to
occurrences between Point and Mark.

\dc{query-replace-string}{ESC \{Q,q\}}
This replaces the occurrences of a specified string with a specified
replacement string.  When an occurrence is found point is moved to it
and then \jove{} asks what to do.  The options are:
\begin{center}\begin{tabular}{lp{4.5in}}
%\begin{description}
%%.in-4
%%.ta \w'Rubout or N11'u
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
Space or Y   &to replace this occurrence and go on to the next one. \\
Period       &to replace this occurrence and then stop. \\
Rubout or N  &to skip this occurrence and go on to the next one. \\
C-R or R     &to enter a recursive edit.  This lets you temporarily
             suspend the replace, do some editing, and then return
             to continue where you left off.  To continue with the
             Query Replace type \key{C-X~C-C} as if you were trying to
             exit \jove{}.   Normally you would but when you are in a
             recursive edit all it does is exit that editing level. \\
C-D or D     &to delete this occurrence. \\
C-W or W     &to delete this occurrence and then enter a recursive edit. \\
C-U or U     &to undo the last replacement. \\
P or !       &to replace the remaining occurrences without asking. \\
Return or Q  &to stop the Query Replace. \\
%%.in+4
%\end{description}
\end{tabular}\end{center}
The search for occurrences starts at point and goes to the end of the
buffer, so to replace in the entire buffer you must first go to the
beginning. However, you can also play with the numeric argument: a negative
value replaces from the top of the buffer to point, and zero replaces in
the entire buffer.

\dc{quick-exit}{ESC \{Z,z\}}
This saves all the buffers that need saving, and then exits \jove{} even
if you are in a recursive edit.  See also \cmd{write-modified-files}.

\dc{quiet}{variable}
This variable, when set, silences the bell completely on errors.
\par\noindent
Within a \file{.\,joverc} (see the \cmd{source} command) its behaviour
is different; here it suppresses the generation of error messages to the
buffer \out{RC errors}.  This is useful, for example, if you bind something to
function keys that may not be supported on all terminal types that are
connected to your system;
if \cmd{quiet} is ``on'' while these bindings are defined, these are
silently ignored for terminals that don't support those function keys.
It is turned off at the start of the
execution of a new \file{.\,joverc}, and its original state is restored
afterwards (this means that the effect of setting this variable within a
\file{.\,joverc} is local to that file).

\dc{quit-process}{Not Bound}
This is the same as typing \key{C-\bs{}} (the Quit character) to a normal
\UNIX{} process, except it sends it to the current process in \jove{}.
This only works when you are inside a buffer that's attached to a
process.
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

%[920921:new:14.27]
\dc{quote-char}{variable}
This variable determines the character which is used whenever \jove{}
needs to ``quote'' a literal character, e.g., an accented character from
an extended character set.  Its default value is \key{C-Q}.
\par\noindent
Note that its binding should be the \cmd{quoted-insert} command for this
to work correctly.  Its value is {\em not\/} updated automatically if the
binding is changed.

\dc{quoted-insert}{C-Q, C-\carat{}}
This lets you insert characters that normally would be executed as other
\jove{} commands.
For example, to insert \key{C-F} you type \key{C-Q C-F}.  If you supply
a negative numeric argument, its absolute value is used as the ascii code
of the character to insert.

\dc{ragged-right-fill}{variable}
This variable controls the right-margin alignment in \Def{Auto fill}
mode and the fill commands.  When this is set to ``off'', \jove{} tries
to line up the right margin of the paragraphs by distributing excess
spaces evenly over the lines.  The default value is ``on'', which gives
you the traditional ragged-right margin.

\dc{read-word-abbrev-file}{Not Bound}
This reads a specified file that contains a bunch of abbreviation
definitions, and makes those abbreviations available.  If the selected
buffer is not already in \Def{Word Abbrev} mode this command puts it in
that mode.

%[910705:new:14.12]
\dc{recover}{Not Bound}
This recovers the buffers from an earlier \jove{} or system crash.
Since only modified buffers are saved, these are the only ones that can
be recovered.  See also \cmd{sync-frequency}, \cmd{tmp-file-pathname}
and \cmd{jove~$-$r}.
\note{
On some smaller systems the \file{jove~$-$r} service is implemented as a
separate \file{recover} program.
}

\dc{recursive-edit}{Not Bound}
This enters a recursive editing level.  This isn't really very
useful.  I don't know why it's available for public use.  I think I'll
delete it some day. (Well, sometimes it is useful within macros\ldots )

\dc{redraw-display}{C-L}
This centers the line containing point in the window.  If that line is
already in the middle the window is first cleared and then redrawn.  If
a numeric argument is supplied, the line is positioned at that offset
from the top of the window.  For example, \key{ESC~0~C-L} positions the
line containing point at the top of the window.

\dc{rename-buffer}{Not Bound}
This lets you rename the current buffer.

\dc{repaint-threshold}{variable}
This variable controls whether the screen is updated by scrolling or
repainting when some lines have moved upward or downward.  At higher baud
rates it is often faster to repaint three or four lines than scroll them
15 lines or more.  Furthermore on terminals that have no settable
scroll-region scrolling gives rise to ``dancing'' mode-lines (or worse
if you have multiple windows), which I find rather annoying.
\par\noindent
It is given as a percentage: if the distance to scroll compared to the
total size of the region affected by the scroll is larger than this
fraction, the screen is repainted instead of scrolled.  A suitable
default value is chosen at startup, so there is generally no need to
tamper with this variable.

\dc{replace-in-region}{C-X \{R,r\}}
This is the same as \cmd{replace-string} except that it is restricted to
occurrences between Point and Mark.

\dc{replace-string}{ESC \{R,r\}}
This replaces all occurrences of a specified string with a specified
replacement string.  If the variable \cmd{match-regular-expressions} is
set, occurrences of ``\bs{}1~\ldots~\bs{}9'' in the replacement string are
substituted by the string matched by the corresponding ``\bs{}( \bs{})''
in the search string (but only if that sub-expression exists); ``\bs{}0''
stands for the entire match.  Occurrences of \key{\carat{}M} (and
\key{\carat{}@}) in the
replacement string are changed to newlines when substituted.  If a
numeric argument is supplied, its behaviour is modified as follows:  its
absolute value gives the maximum number of occurrences to replace; if
its value is negative replacements are from the top of the buffer to
point (note that this is not quite the same as a real
\cmd{backward-replace}); if it is zero replacements are in the entire
buffer.

\dc{resize-window}{Not Bound}
This sets the size of the current window to the given number of lines
(not counting the mode line).

\dc{right-margin}{variable, C-X \}}
Where the right margin is for \Def{Auto~Fill} mode and the
\cmd{fill-paragraph} and \cmd{fill-region} commands.  The default
is 78.

\dc{right-margin-here}{C-X ]}
This sets the \cmd{right-margin} variable to the current position of
point.  This is an easy way to say, ``Make the right margin begin
here,'' without having to count the number of spaces over it actually
is.

%[910923:new:14.14]
\dc{rubout-backward}{C-\_ {C-H,Backspace}}
This macro associates the \key{Rubout} (\key{Delete}) key with backward
deletions.

%[910923:new:14.14]
\dc{rubout-forward}{C-\_ Delete}
This macro associates the \key{Rubout} (\key{Delete}) key with forward
deletions.

\dc{save-file}{C-X C-S, C-X C-\bs{}, C-X \{S,s\}}
This saves the current buffer to the associated file.  This makes your
changes permanent so you should be sure you really want to.  If the
buffer has not been modified \cmd{save-file} refuses to do the save.  If
you really do want to write the file you can use \key{C-X~C-W} which
executes \cmd{write-file}.  If the variable \cmd{make-backup-files} is
set a backup is made of your original file, unless you supply a negative
numeric argument to this command.

%[910110:new]
\dc{save-substituted-abbrevs}{variable}
This variable, when set, makes that words that are replaced with their
abbreviation are stored on the kill ring.  This tends to clutter the kill
ring with uninteresting objects, which I found undesirable.  The variable is
there so you can still have it the old way if you liked it.

%[920329:new:14.22]
\dc{scratch-buffer}{C-\_ S}
This changes the type of the current buffer to \cmd{Scratch}, which
means that JOVE ignores modifications to the buffer, and the buffer no
longer shows up in a normal \cmd{list-buffers} command.

%[910605:new]
\dc{screen-dense}{Not Bound}
This switches the screen into `dense' mode, if possible.  The exact
number of lines in `dense' mode depends on the terminal, but is
guaranteed to be more than in `normal' mode.  When used with a negative
argument it is completely equivalent to the \cmd{screen-normal} command.
With argument value 0 it restores the original screen size.
\note{
Do {\em not\/} use these commands when \jove{} runs in a windowing
environment like X-Windows.  \Jove{} is aware of window resizings on
such systems.
}
\note{
The Atari~ST version of \jove{} doesn't support `wide' mode.
The MS-DOS version supports `wide' mode on systems with a VGA video
controller.  Note that most (if not all) DOS mouse drivers do not
recognize wide mode yet, so don't expect to use the mouse in wide mode.
}
\note{
(for \file{termcap/terminfo} hackers) Not all terminals/systems support
this feature.  It is described by the non-standard termcap capabilities
\cmd{LI\#} alternate screen height, \cmd{zl=} set terminal to standard
screen height, \cmd{zL=} set terminal to alternate screen height; and
\cmd{CO\#} alternate screen width, \cmd{zc=} set terminal to standard
screen width, \cmd{zC=} set terminal to alternate screen width.
}

%[910801:new:14.13]
\dc{screen-narrow}{Not Bound}
This switches the screen into `narrow' mode, if possible.  See also
\cmd{screen-wide}.
\note{
See \cmd{screen-dense} for system-dependencies.
}

%[910605:new]
\dc{screen-normal}{Not Bound}
This switches the screen into `normal' mode, if possible.  See also
\cmd{screen-dense}.
\note{
See \cmd{screen-dense} for system-dependencies.
}

%[910801:new:14.13]
\dc{screen-wide}{Not Bound}
This switches the screen into `wide' mode, if possible.  The exact
number of columns in `wide' mode depends on the terminal, but is
guaranteed to be more than in `narrow' mode.  When used with a negative
argument it is completely equivalent to the \cmd{screen-narrow} command.
With argument value 0 it restores the original screen size.
\note{
See \cmd{screen-dense} for system-dependencies.
}

%[900723:new]
\dc{scroll-all-lines}{variable}
When this is turned on, the entire window will be scrolled left or right
when the current line scrolls.  The default value is ``off'', which will
cause \jove{} to behave in the familiar way, namely to scroll only
the current line.

\dc{scroll-down}{Keypad , or ScrollDown}
This scrolls the screen one line down.  If the line containing point
moves past the bottom of the window point is moved up to the center of
the window.  If a numeric argument is supplied that many lines are
scrolled; if the argument is negative the screen is scrolled up instead.

%[910116:new]
\dc{scroll-down-next-window}{ESC (Keypad , or ScrollDown)}
This macro scrolls the next window one line down.  This is exactly the
same as \key{C-X~N} \cmd{scroll-down} \key{C-X~P}.

%[900719:new;replaces horizontal-offset-in-window]
\dc{scroll-left}{ESC \{}
This scrolls the text in the current window 10 character positions to the
left.  If a numeric argument is specified then the text is scrolled that
number of character positions.  If the argument is zero, the window is
reset to its leftmost position.

%[900719:new;replaces horizontal-offset-in-window]
\dc{scroll-right}{ESC \}}
This scrolls the text in the current window 10 character positions to the
right.  If a numeric argument is specified then the text is scrolled that
number of character positions.  If the argument is zero, the window is
reset to its leftmost position.

\dc{scroll-step}{variable}
How many lines should be scrolled if the \cmd{previous-line} or
\cmd{next-line} commands move you off the top or bottom of the window.
You may wish to decrease this variable if you are on a slow terminal.

\dc{scroll-up}{C-Z, (Keypad - or ScrollUp)}
This scrolls the screen one line up.  If the line containing point moves
past the top of the window point is moved down to the center of the
window.  If a numeric argument is supplied that many lines are scrolled;
if the argument is negative the screen is scrolled down instead.

%[910116:new]
\dc{scroll-up-next-window}{ESC (Keypad - or ScrollUp)}
This macro scrolls the next window one line up.  This is exactly the
same as \key{C-X~N} \cmd{scroll-up} \key{C-X~P}.

\dc{search-exit-char}{variable}
Set this to the character you want to use to exit incremental search.
The default is \key{Return}, which makes i-search compatible with normal
string search.

\dc{search-forward}{C-S, C-\bs{}, F1}
This searches forward for a specified search string and positions point
at the end of the string if it's found.  If the string is not found
point remains unchanged.  This searches from point to the end of the
buffer, so any matches before point will be missed, unless the variable
\cmd{wrap-search} is set.  If a numeric argument (N) is supplied the N-th
occurrence of the string is searched, searching backward if the argument
is negative.  A zero argument temporarily enables \cmd{wrap-search}.
See also the variables \cmd{case-ignore-search} and
\cmd{match-regular-expressions} to find out how they influence the search.

%[940131:14.32#8:new]
\dc{search-forward-lit}{Not Bound}
This is just like \cmd{search-forward} except that it always searches
for a literal string, regardless of the value of the variable
\cmd{match-regular-expressions}.

%[940131:14.32#8:new]
\dc{search-forward-lit-nd}{Not Bound}
This is just like \cmd{search-forward} except that it always searches
for a literal string, regardless of the value of the variable
\cmd{match-regular-expressions}, and it doesn't set the default
string.

\dc{search-forward-nd}{C-\_ C-S}
This is just like \cmd{search-forward} except that it doesn't set
the default search string.  This is useful for defining macros, when you
want to search for something, but you don't want it to affect the current
default search string.

%[940131:14.32#8:new]
\dc{search-forward-re}{Not Bound}
This is just like \cmd{search-forward} except that it always searches
for a regular expression, regardless of the value of the variable
\cmd{match-regular-expressions}.

%[940131:14.32#8:new]
\dc{search-forward-re-nd}{Not Bound}
This is just like \cmd{search-forward} except that it always searches
for a regular expression, regardless of the value of the variable
\cmd{match-regular-expressions}, and it doesn't set the default
string.

\dc{search-reverse}{C-R, F2}
This searches backward for a specified search string and positions point
at the beginning if the string if it's found.  If the string is not
found point remains unchanged.  This searches from point to the
beginning of the buffer, so any matches after point will be missed,
unless the variable \cmd{wrap-search} is set. If a numeric argument (N)
is supplied the N-th occurrence of the string is searched, searching
forward if the argument is negative.  A zero argument temporarily
enables \cmd{wrap-search}.
See also the variables \cmd{case-ignore-search} and
\cmd{match-regular-expressions} to find out how they influence the search.

%[940131:14.32#8:new]
\dc{search-reverse-lit}{Not Bound}
This is just like \cmd{search-reverse} except that it always searches
for a literal string, regardless of the value of the variable
\cmd{match-regular-expressions}.

%[940131:14.32#8:new]
\dc{search-reverse-lit-nd}{Not Bound}
This is just like \cmd{search-reverse} except that it always searches
for a literal string, regardless of the value of the variable
\cmd{match-regular-expressions}, and it doesn't set the default
string.

\dc{search-reverse-nd}{C-\_ C-R}
This is just like \cmd{search-backward} except that it doesn't set
the default search string.  This is useful for defining macros, when you
want to search for something, but you don't want it to affect the current
default search string.

%[940131:14.32#8:new]
\dc{search-reverse-re}{Not Bound}
This is just like \cmd{search-reverse} except that it always searches
for a regular expression, regardless of the value of the variable
\cmd{match-regular-expressions}.

%[940131:14.32#8:new]
\dc{search-reverse-re-nd}{Not Bound}
This is just like \cmd{search-reverse} except that it always searches
for a regular expression, regardless of the value of the variable
\cmd{match-regular-expressions}, and it doesn't set the default
string.

\dc{select-buffer}{C-X \{B,b\}}
This selects a new or already existing buffer making it the current one.
You can type either the buffer name or number.  If you type in the name
you need only type the name until it is unambiguous, at which point
typing \key{Tab} or \key{Space} will complete it for you.  If you want
to create a new buffer you can type \key{Return} instead of \key{Space},
and a new empty buffer will be created.  If you supply a numeric
argument, point is moved to the beginning of that line in the newly
selected buffer; a negative argument moves to that line relative to the
end of the buffer.

\dc{self-insert}{Most Printing Characters}
This inserts the character that invoked it into the buffer at point.
Initially all but a few of the printing characters are bound to
\cmd{self-insert}.

\dc{send-typeout-to-buffer}{variable, C-\_ C-T}
When this is set \jove{} will send output that normally overwrites the
screen (temporarily) to a buffer instead.  This affects commands like
\cmd{list-buffers}, \cmd{list-processes}, and other commands that use
command completion.  The default value is ``off''.

%[940424:new:14.32#10]
\dc{sentence-end}{variable}
This is a regular expression search string that is used by the
\cmd{sentence} commands to find the beginning or end of a sentence.  A
string matching this expression qualifies as a sentence boundary if it
is either a match at the beginning of a line (so
probably---hopefully---a paragraph boundary), {\em or\/} if it is
followed by a string that matches \cmd{sentence-sep}.

%[940424:new:14.32#10]
\dc{sentence-sep}{variable}
This is another regular expression search string that is used by the
\cmd{sentence} commands to find the beginning or end of a sentence.  A
string matching \cmd{sentence-end} qualifies as a sentence
boundary if it is either a match at the beginning of a line, {\em or\/}
if it is followed by a string that matches this expression.

\dc{set}{ESC \{S,s\}}
This gives a specified variable a new value.  Occasionally you'll see
lines like ``set this variable to that value to do this'' in this
manual.  Well, you use the \cmd{set} command to do that.  Instead of
waiting for the prompt, you can also use the numeric argument to set
numeric, on-off and character variables directly.
\par\noindent
The following trick is sometimes useful in macros:
On-off variables can temporarily be enabled by \key{ESC~+ <set variable>}
and later restored to their original value by \key{ESC~- <set variable>}.

\dc{set-mark}{C-@, ESC C-@, ESC Space}
This sets the mark at the current position in the buffer.  It prints the
message \linebreak[3] \out{[Point pushed]} on the message line.  It says
that instead of \out{[Mark set]} because when you set the mark the
previous mark is still remembered on a ring of 16 marks.  So
\out{[Point pushed]} means point is pushed onto the ring of marks and
becomes the value of \Def{the mark}.  To go through the ring of marks
you type \key{C-U~C-@}, or execute the \cmd{pop-mark} command.  If you
type this enough times you will get back to where you started.

\dc{shell}{variable}
The shell to be used with all the shell commands.  If your \file{SHELL}
environment variable is set, it is used as the value of \cmd{shell};
otherwise \file{/bin/sh} is the default.

\dc{shell}{Not Bound}
This starts up an interactive shell in a window.  \Jove{} uses
\out{*shell*} as the name of the buffer in which the interacting takes
place.  See the manual for information on how to use interactive
processes.
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

\dc{shell-command}{C-X !}
This runs a \UNIX{} command and places the output from that command in a
buffer.  \Jove{} creates a buffer that matches the name of the command
you specify and then attaches that buffer to a window.  So, when you
have only one window running this command will cause \jove{} to split
the window and attach the new buffer to that window.  Otherwise, \jove{}
finds the most convenient of the available windows and uses that one
instead.  If the buffer already exists it is first emptied, unless you
supply a numeric argument (\key{C-U} is good enough). If it's holding a
file, not some output from a previous command, \jove{} prints an error
message and refuses to execute the command.  If you really want to
execute the command you should delete that buffer (saving it first, if
you like) or use \cmd{shell-command-to-buffer}, and try again.
\par\noindent
If you supply \key{ESC~-}, the output of the command is inserted at Point
in the current buffer.  If you supply any other negative argument the
output will be displayed using Typeout, in the same manner that \jove{}
displays help info.  If you supply zero as argument the output is
discarded completely.

%[911122:new:14.18]
\dc{shell-command-leaves-point-at-end}{variable}
When this variable is set, Point remains at the end of the
\cmd{shell-command} output after completion of the command and Mark is
set at the beginning of the command's output.  Its default value is ``off'',
which leaves Point at the beginning and Mark at the end.

%[910116:new]
\dc{shell-command-no-buffer}{Macro}
This macro is just like \cmd{shell-command} except it discards the
command's output. (in fact it is defined as ESC~0~C-X~!)

\dc{shell-command-to-buffer}{ESC !}
This is just like \cmd{shell-command} except it lets you specify the
buffer to use instead of \jove{}.

%[910116:new]
\dc{shell-command-with-typeout}{Macro}
This macro is just like \cmd{shell-command} except it displays the output
using Typeout instead of sending it to a buffer.  Of course it boils down
to the same thing if the variable \cmd{send-typeout-to-buffer} is set.

%[910216:new]
\dc{shell-cwd-sync}{variable}
This tells \jove{} whether it should try to keep its idea of the current
directory in sync with the interactive \cmd{shell}.  That is, if this
variable is set, \jove{} intercepts and executes the directory commands
you type to the shell.  Also \cmd{pushd} and \cmd{popd} are converted to
the actual \cmd{cd} command before presenting it to the shell, so that
shells that do not have these commands benefit from \jove{}s ability in
this respect.
\NOTE{
\Jove{} cannot as yet handle wildcard characters, so it will probably go
out of sync when you use them in the directory name.
}
\note{
This is only for versions of \jove{} that have the interactive processes
feature.
}

\dc{shell-flags}{variable}
This defines the flags that are passed to shell commands.  The default is
\file{--c}.  See the \cmd{shell} variable to change the default shell.

%[900719:new;replaces adjust-indent-in-region]
\dc{shift-region-left}{C-X <}
This shifts the region left by the amount of one tab stop (which is
\cmd{c-indentation-increment} in C mode) or by the numeric argument, if
one is supplied.  If a negative argument is supplied the region is
shifted the other way.

%[900719:new;replaces adjust-indent-in-region]
\dc{shift-region-right}{C-X >}
This shifts the region right by the amount of one tab stop (which is
\cmd{c-indentation-increment} in C mode) or by the numeric argument, if
one is supplied.  If a negative argument is supplied the region is
shifted the other way.

\dc{show-match-mode}{Not Bound}
This turns on \Def{Show Match} mode (or off if it's currently on) in the
selected buffer.  This changes `\}', `]' and `)' so that when they are
typed they are inserted as usual, and then the cursor flashes back to
the matching `\{', `[' or `(' (depending on what was typed) for about
half a second, and then goes back to just after the `\}', `]' or `)'
that invoked the command.  This is useful for typing in complicated
expressions in a program.  You can change how long the cursor sits on
the matching paren by setting the \cmd{paren-flash-delay} variable in
tenths of a second.  If the matching `\{', `[' or `(' isn't visible the
matching line is displayed on the message line.

\dc{shrink-window}{C-X C-Z}
This makes the current window one line shorter, if possible.  Windows
must be at least 2 lines high, one for the text and the other for the
mode line.

%[911007:new:14.15]
\dc{simulate-input}{Not Bound}
This prompts for a string which will be treated as input from the keyboard.

%[911210:new:14.19]
\dc{skip-partial-tabs}{variable}
This variable, when set, makes the \cmd{next-line} and \cmd{previous-line}
commands set Point beyond a Tab character when it would end up ``in the
middle'' of it.  The default is to set Point before the Tab in this situation.
\note{
This is an optional part of \jove{}, provided for backward compatibility.
}

\dc{source}{Not Bound}
This reads a bunch of \jove{} commands from a file.  The format of the
file is the same as that in your initialization file (your
\file{.\,joverc}) in your main directory.  There should be one command
per line and it should be as though you typed \key{ESC~X} while in
\jove{} with the following exceptions: whitespace at the beginning of
the line is ignored; empty lines and lines starting with `\#' are
ignored; commands can be preceded with a repeat count (followed by a
single space).
\par\noindent
Additionally a limited
\mbox{\tt if~\ldots~[~elif~\ldots~[~else~\ldots~]~]~endif} construct is
available. The following {\tt[el]if} conditions are allowed:
\begin{itemize}
\item
{\tt(}{\em $<$variable$>$} {\tt in} {\sl$<$regexp$>$}{\tt)} \\
true if value of $<$variable$>$ matches $<$regexp$>$.
\item
{\tt(}{\em $<$variable$>$ $<$relop$>$ $<$value$>$}{\tt)} \\
true if string comparison satisfies {\em $<$relop$>$}, where {\em $<$relop$>$}
is one of {\tt={}=}, {\tt!=}, {\tt<}, {\tt>}, {\tt<{}=}, or {\tt>{}=}.
\item
{\tt(}{\em $<$variable$>$}{\tt)} \\
test presence of environment variables,
{\em or\/} non-zeroness of numeric \jove{} variables,
{\em or\/} truth value of boolean \jove{} variables.
\item
{\tt term in} {\em $<$regexp$>$} \\
special case for backward compatibility.
\item
{\em $<$command$>$} [{\em $<$parameters$>$}] \\
test the exit status of an external command.
\item
{\tt!} {\em $<$any of the above$>$} \\
the logical NOT operator.
\end{itemize}
A {\em $<$variable$>$} that starts with a `\$' is considered an
environment variable; anything else is taken as an internal \jove{}
variable or -constant.
If statements can now be nested to a reasonable level.
Errors messages end up in the buffer
\out{RC errors}.
\par\noindent
For example, here's part of my initialization file:
\begin{quote}\tt
bind-to-key i-search-reverse \carat{}R \\
bind-to-key i-search-forward \carat{}S \\
bind-to-key pause-jove \carat{}[S
\end{quote}
What they do is make \key{C-R} call the \cmd{i-search-reverse} command
and \key{C-S} call \cmd{i-search-forward} and \key{ESC~S} call
\cmd{pause-jove}.

%[920610:new:1423]
\dc{special-keys}{Not Bound}
Some key names as recognized by \jove{} are different from the usual
\file{termcap\,(5)} names.  If that is the case the termcap name is
shown in [square brackets].  Furthermore, items shown in \{curly braces\}
indicate that the Shift-key defined by the termcap name will be mapped to
\file{MetaKey} + key.
% (now this is a horrible kludge...)
\begin{quote}\begin{quote}\begin{quote} \small \begin{tabbing} Key ID11 \= Full name11111111111111'u \= 1111111111111Remarks \= \kill
%%.ta +\w'Key ID11'u +\w'Full name11111111111111'u +\w'1111111111111'u
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
{\bf Key ID}  \>{\bf Full name}              \`             {\bf Remarks} \\
%%------  ---------             {}              -------
 k0--k9  \>function keys 0--9 \\
  k;    \>function key 10 \\
 F1--F9  \>function keys 11--19 \\
  F0    \>(alt.\ function key 20) \\
 FA--FZ  \>function keys 20--45 \\
 Fa--Fr  \>function keys 46--63 \\
  ka    \>clear-all-tabs         \`  (vt100 keypad Dot) \\
  kA    \>insert-line            \`(vt100 keypad Enter) \\
  kb    \>backspace              \`   (mapped to \key{C-H}) \\
  kB    \>back-tab \\
  kc    \>command                \`           [@4],\{*1\} \\
  kC    \>clear-screen,erase \\
  kd    \>down-arrow \\
  kD    \>delete-character       \`                \{*4\} \\
  ke    \>enter                  \`                [@8] \\
  kE    \>clear-to-end-of-line   \`                \{*8\} \\
  kf    \>find                   \`           [@0],\{*0\} \\
  kF    \>scroll-forward (-down) \`(vt100 keypad Minus) \\
  kg    \>resume                 \`      (Go) [\&5],\{\%j\} \\
  kG    \>suspend                \`(don't Go) [\&7],\{!2\} \\
  kh    \>home                   \`                \{\#2\}\\
  kH    \>end-home, end          \`  [=],[kw],[@7],\{*7\} \\
  ki    \>do, redo               \`           [\%0],\{\%g\} \\
  kI    \>insert-\{char,mode\}     \`                \{\#3\} \\
  kJ    \>action \\
  kk    \>mark                   \`                [\%2] \\
  kl    \>left-arrow \\
  kL    \>delete-line            \`                \{*5\} \\
  km    \>move                   \`           [\%4],\{\%b\} \\
  kM    \>end-insert-mode \\
  kn    \>newline                \`   (mapped to \key{C-J}) \\
  kN    \>next-page, page-down   \`    (vt100 keypad 2) \\
  ko    \>tab                    \`   (mapped to \key{C-I}) \\
  kO    \>open                   \`                [\%6] \\
  kp    \>previous-command \\
  kP    \>previous-page, page-up \`    (vt100 keypad 8) \\
  kq    \>help                   \`       [=],[\%1],\{\#1\} \\
  kQ    \>quit,exit              \`       [=],[@9],\{*9\} \\
  kr    \>right-arrow \\
  kR    \>scroll-backward (-up)  \`(vt100 keypad Comma) \\
  ks    \>save                   \`           [\&6],\{!1\} \\
  kS    \>clear-to-end-of-screen \\
  kt    \>clear-tab              \`    (vt100 keypad 4) \\
  kT    \>set-tab                \`    (vt100 keypad 6) \\
  ku    \>up-arrow \\
  kU    \>select                 \`            [=],[*6] \\
  kv    \>next-\{object,pane\}     \`       [=],[\%6],\{\%c\} \\
  kV    \>previous-\{object,pane\} \`       [=],[\%8],\{\%e\} \\
  kW    \>command-pane \\
  kx    \>close                  \`                [@3] \\
  kX    \>cancel                 \`           [@2],\{\&0\} \\
  kY    \>undo                   \`       [=],[\&8],\{!3\} \\
  kz    \>word-left              \`            [=],[\#4] \\
  kZ    \>word-right             \`            [=],[\%i] \\
  K1    \>keypad-upper-left      \`    (vt100 keypad 7) \\
  K2    \>keypad-center          \`    (vt100 keypad 5) \\
  K3    \>keypad-upper-right     \`    (vt100 keypad 9) \\
  K4    \>keypad-lower-left      \`    (vt100 keypad 1) \\
  K5    \>keypad-lower-right     \`    (vt100 keypad 3) \\
  KB    \>begin                  \`           [@1],\{\&9\} \\
  Kc    \>create                 \`           [@6],\{*3\} \\
  KC    \>copy                   \`           [@5],\{*2\} \\
  Kf    \>reference              \`                [\&1] \\
  KF    \>refresh                \`                [\&2] \\
  KM    \>message                \`           [\%3],\{\%a\} \\
  KO    \>options                \`           [\%7],\{\%d\} \\
  KP    \>print                  \`           [\%9],\{\%f\} \\
  Kr    \>restart                \`                [\&4] \\
  KR    \>replace                \`           [\&3],\{\%h\} \\
\end{tabbing}\end{quote}\end{quote}\end{quote}
\note{
This mapping is an effort to provide somewhat more meaningful key names
instead of the sometimes nonsensical termcap names.
But then, how meaningful can you get within two characters?
}

\dc{spell-buffer}{Not Bound}
This runs the current buffer through the \file{spell\,(1)} program
and places the output in buffer \out{Spell}.  Then \jove{} lets you edit
the list of words, expecting you to delete the ones that you don't care
about, i.e., the ones you know are spelled correctly.  Then the
\cmd{parse-spelling-errors-in-buffer} command comes along and finds all
the misspelled words and sets things up so the error commands work.
\NOTE{
It is now possible to run this as an interactive process on versions
that support this. See the variable \cmd{i-process-parse}.
}
\note{
This is an optional part of \jove{} that may not be available on
smaller systems.
}

\dc{split-current-window}{C-X 2}
This splits the current window into two equal parts (providing the
resulting windows would be big enough) and displays the selected
buffer in both windows.  Use \key{C-X~1} to go back to 1 window mode.

\dc{start-remembering}{C-X (}
This starts remembering your key strokes in the Keyboard macro.  To stop
remembering you execute \cmd{stop-remembering} (usually bound to
\key{C-X~)}.)  Yes, the bug in \jove{} that inhibited you to stop
remembering by typing \key{ESC~X stop-remembering} is repaired.  If you
supply a positive numeric argument your key strokes are appended to the
existing Keyboard macro.  If you supply a negative numeric argument a
new macro definition is started; this is useful if you change your mind
about a macro in the middle of a definition. (this is really just the
same as typing \key{C-X~) C-X~(})
\par\noindent
To execute the remembered key strokes you type \key{C-X~E} which runs
the \cmd{execute-keyboard-macro} command.  Sometimes you may want a
macro to accept different input each time it runs.  To see how to do
this, see the \cmd{make-macro-interactive} command.

\dc{stop-process}{Not Bound}
This sends a stop signal (\key{C-Z}, for most people) to the current
process.  It only works if you are in a buffer attached to a process.
\note{
This is only for versions of \jove{} that have the interactive processes
feature, and only on \UNIX{} systems that have job-control.
}

\dc{stop-remembering}{C-X )}
This stops the definition of the keyboard macro.  See
\cmd{start-remembering}.

\dc{string-length}{Not Bound}
This prints the number of characters in the string that point sits in.
Strings are surrounded by double quotes ({\tt"}), or, if you supply
a numeric argument, by single quotes (').  \Jove{} knows that
``\bs{}007'' is considered a single character, namely \key{C-G}, and
also knows about other common ones, like ``\bs{}r'' (\key{Return}) and
``\bs{}n'' (\key{LineFeed}), and even knows about end-of-line escapes.
This is mostly useful only for C programmers.

\dc{suspend-jove}{Not Bound}
This is a synonym for \cmd{pause-jove}.

\dc{sync-frequency}{variable}
The temporary files used by \jove{} are forced out to disk every
\cmd{sync-frequency} modifications.  The default is 50, which really
makes good sense.  Unless your system is very unstable, you probably
shouldn't fool with this.

%[920329:new:14.22]
\dc{system}{variable}
This constant contains the system type name, as show up in the \cmd{version}
command.

%[920705:new:14.24]
\dc{tab-to-next-column}{ESC {C-I,Tab}}
This inserts enough whitespace to line up with the start of the next
column in the previous (non-blank) line.  If point is beyond the end of
the previous line, advance to the next \cmd{column-tabstop} position.
The \cmd{column-format} variable defines how a column should look like.

\dc{tag-file}{variable}
This the name of the file in which \jove{} should look up tag
definitions.  The default value is \file{.\,/tags}.
\par\noindent
For those of you who want to know everything: \jove{} expects the
entries in the tag-file to have one of the formats:
\begin{quote}\tt
tag<tab>file<tab>/pattern-matching-tag-in-file/ \\
tag<tab>file<tab>?pattern-matching-tag-in-file? \\
tag<tab>file<tab>line number
\end{quote}
The program \file{ctags\,(1)} produces such a tag-file for a bunch of C
source files.

%[920329:new:14.22]
\dc{term}{variable}
This constant contains the current terminal name, (usually) determined
from the \file{TERM} environment variable.

\dc{tex-error-parse}{Not Bound}
This macro attempts to parse error messages as produced by \TeX{}, for
example in its log-file.  It handles `genuine' error messages (the ones
with a single line number) as well as messages like ``overfull \bs{}hbox''
(the ones that contain the location of a paragraph; in this case the start
of the paragraph is taken as the `error line').
\NOTE{
This is still somewhat experimental; in particular it easily gets confused
about the name of the file the error is in---\TeX{}'s error message scheme
just does not fit in too well.
}

\dc{text-mode}{Not Bound}
This sets the major mode to \Def{Text}.  Currently the other modes are
Fundamental, C, Lisp and Perl mode.

\dc{tmp-file-pathname}{variable}
This tells \jove{} where to put the tmp files, which is where \jove{}
stores buffers internally.  The default is usually in \file{/tmp}, but
if you want to store them somewhere else, you can set this variable.  If
your system crashes a lot it might be a good idea to set this variable
to somewhere other than \file{/tmp} because the system removes all the
files in \file{/tmp} upon reboot, and so you would not be able to
recover editor buffers using the \file{jove --r} command.
\par\noindent {\em
In order for this to work correctly you must set this variable
{\em before\/} \jove{} creates the tmp file.  You can set this in your
\file{.\,joverc} (the closer to the beginning the better), or as soon as
you start up \jove{} before you visit any files.
}

%[new:910801:14.12]
\dc{trace-macros}{variable}
This tells \jove{} to continuously update the screen during macro
execution.  This can be helpful for macro debugging.

\dc{transpose-characters}{C-T}
This switches the character before point with the one after point, and
then moves forward one.  This doesn't work at the beginning of the line,
and at the end of the line it switches the two characters before point.
Since point is moved forward, so that the character that was before
point is still before point, you can use \key{C-T} to drag a character
down the length of a line.  This command pretty quickly becomes very
useful.
\NOTE{
This command now knows how to deal with a (positive or negative)
numeric argument.
}

%[910116:changed]
\dc{transpose-lines}{C-X C-T}
This switches the current line with the one above it, and then moves
down one so that the line that was above point is still above point.
This can be used to drag a line down a
page.
\NOTE{
This command now knows how to deal with a (positive or negative)
numeric argument.
}

%[940424:new:14.32#10]
\dc{transpose-s-expressions}{Not Bound}
This switches the current (or previous) s-expression with the next one,
and then moves forward one s-expression, so that the one before point is
still before point.  Punctuation between s-expressions stays in place.
This can be used to drag an s-expression down the length of a line.
(See the \cmd{forward-s-expression} command for a definition of
s-expressions.)

%[940424:new:14.32#10]
\dc{transpose-words}{Not Bound}
This switches the current (or previous) word with the next one, and then
moves forward one word, so that the word before point is still before
point.  Punctuation between words stays in place.  This can be used to
drag a word down the length of a line.

%[920329:new:14.22]
\dc{ttyname}{variable}
This constant contains the name of the controlling terminal.

\dc{tutorial}{ESC C-T}
This macro visits a special file that is \jove{}s interactive tutorial.
All you have to do is follow the instructions and by doing so you will
learn enough about \jove{} to get you going.

%[920812:changed:14.25]
\dc{unbind-key}{C-X \{U,u\}}
Use this to unbind {\em any\/} key sequence.  You can use this to unbind
even a prefix command, since this command does not use ``key-map
completion''.  For example, \key{ESC~X unbind-key ESC~[} unbinds the
sequence \key{ESC~[}, and \key{ESC~X unbind-key ESC<cr>} unbinds the
\key{ESC} prefix (you are advised not to do this!).
This is useful for ``turning off'' something set
in the system-wide \file{.\,joverc} file.

If you precede \cmd{bind-to-key} with a positive numeric argument you
must first give the name of the keymap you wish to unbind the key in, if
you give a negative argument \cmd{mainmap} is used, otherwise the
currently active keymap is used.

\dc{undo-last-changed-line}{C-X C-Y}
This undoes all changes in the line you modified last. Thus you can undo
a changed line even after moving around. If you don't like the result of
the undo you can get the original line back with another undo.  If you
supply a numeric argument (\key{C-U} will do) the last saved version of
the line is restored, otherwise the the version of the line since you
first started modifying it is restored. (the difference is subtle, I
admit.)  Point is left at the same location, or at the first changed
character, whichever comes first.

%[900716:new]
\dc{unsorted-tags}{variable}
This variable tells \jove{} that your tag file is not in alphabetic
order.  When tags are unsorted \jove{}s fast method of tag-lookup is not
reliable.  If this variable is set, \jove{} will lookup a tag the slow
way (by a sequential scan through the tag file) when the fast attempt
fails.  Alternatively, you can give a negative numeric argument to one
of the tag-finding commands to achieve the same effect.  The default
value of this variable is ``off'', since \file{ctags\,(1)} usually
generates a sorted tag file.

%[920922:new:14.27]
\dc{up-list}{ESC (Keypad 9 or $\nearrow$)}
This moves forward to the close parenthesis of the enclosing block. This
is mode dependent, in C mode `\}' is searched for, and in other modes
`)' is used.

%[910801:new:14.12]
\dc{update-screen}{Not Bound}
This causes an unconditional screen update.  This is especially meant
for use in macros or \file{.\,joverc} files.

\dc{update-time-frequency}{variable}
How often the mode line is updated (and thus the time and load average,
if you display them).  The default is 30 seconds.

%[921002:changed:14.28]
\dc{use-color}{variable}
This controls whether color-related escape sequences are actually sent
to the terminal.  Default value is ``on'' when color is supported
according to the \file{termcap\,(5)} entry describing your terminal, and
``off'' otherwise.  This variable is there since \jove{} has color
support builtin for some terminals, but some bad clones of one of the
builtin types may barf on the color escape sequences (instead of
ignoring them).
\NOTE{
Builtin terminal types are \file{ANSI (vt2xx)} and \file{HP}.
The Atari~ST and MS-DOS versions also have builtin color support.
}
\note{
(for \file{termcap/terminfo} hackers) Since color-related capabilities
are not defined in the original termcap/terminfo specifications, I had
to invent (more or less) my own.  \Jove{} uses the (an?) ANSI color scheme
(see the command \cmd{color} for the order of the colors). \\
\Jove{} recognizes several kinds of color capabilities; the first stems from
IBM's \file{AIX} system and is given by the capabilities \cmd{c0--c7}
for text-colors, \cmd{d0-d7} for background-colors (terminfo:
\cmd{colf0--colf7}, \cmd{colb0--colb7}).  Alternatively the following
parametrized capabilities can be used (which stem from \file{SCO}
\UNIX{}): \cmd{Sf} and \cmd{Sb} (terminfo: \cmd{setf}, \cmd{setb}) to
set the text- and background colors respectively, or \cmd{sp} (terminfo:
\cmd{scp}) to set the color pair (for HP-like terminals that cannot be
described in terms of text- and background color capabilities.)  Finally
a capability of my own invention \cmd{Sc} (terminfo: \cmd{color}?) can be
used:  it expects two parameters, the text- and background-color
respectively, which are numbers in the range [0--7].  However, in
standard termcap, it is hard to write an acceptable parametrized color
capability, even for ANSI terminals; in term{\em info\/} it is quite
possible, but then of course your terminfo routine library and
\file{tic\,(1m)} should probably be modified to support it. \\
To alleviate this problem, I invented the \cmd{Mf} and \cmd{Mb}
capabilities to describe a text- and background \Def{color mapping}: it
consists of a sequence of one or more numbers separated by commas; an
empty entry implies the next higher number.  The resulting array is
indexed by the color number, and the result is passed to the \cmd{Sf}
and \cmd{Sb}, or \cmd{Sc} capabilities. \\
The default screen color is defined by the {\em numeric\/} capabilities
\cmd{Cf} (text) and \cmd{Cb} (background).  If these are omitted, white
text on a black background is assumed. \\
The following example may help you make sense of all this gunk:
\begin{quote}\begin{tabular}{ll}
                    &\# (description of an ANSI-color terminal) \\
\tt :Sf=\bs{}E[\%dm:Mf=30:\  &\# text: maps to \bs{}E[30m .. \bs{}E[37m \\
\tt :Sb=\bs{}E[\%dm:Mb=40:\  &\# bgr. (equiv.\ to ``Mb=40,41,42,43,44,45,46,47'') \\
\tt :Cf\#0:              &\# default: black text, implies white background.
\end{tabular}\end{quote}
}

%[920329:new:14.22]
\dc{use-direct-video}{Not Bound}
This determines whether screen output is done by writing directly to
video memory, or that the slower method using system calls is used.  Its
default value is ``on''.  You should turn it off if this gives problems
(like flicker) on your machine.
\note{
MS-DOS system specific.
}

\dc{use-function-keys}{variable}
This variable allows you to enable or disable the use of function keys
like the cursor or keypad keys.  It defaults to ``on''.  The
reason that you might want to disable it is that some (dumb) terminals
send ``common'' key sequences (like the tvi925:
\key{\carat{}K}~$\equiv$~$\uparrow$, \key{\carat{}L}~$\equiv$
$\rightarrow$). Since function key
sequences are recognized and filtered out before the ``keystroke'' is
presented to the key maps, these sequences wouldn't be bound to their
standard functions in such a case.

\dc{use-i/d-char}{variable}
If your terminal has insert/delete character capability you can tell
\jove{} not to use it by setting this to ``off''.  In my opinion it is
only worth using insert/delete character at low baud rates.
\NOTE{
If you set this to ``on'' when your terminal doesn't have insert/delete
character capability, you will get weird (perhaps fatal) results.
}

%[910116:new]
\dc{verbose-describe-key}{Not Bound}
This macro waits for you to type a key and then displays some info about
the command, variable or macro that is bound to that key.  It is exactly
the same as \key{C-U}~\cmd{describe-key}.

%[920329:new:14.22]
\dc{version}{variable}
This variable  contains  the  version  number,  as  shows  up  in  the
\cmd{version} command.

\dc{version}{variable}
Displays the version number of this \jove{}.

%[910116:new]
\dc{view-file}{C-X C-V}
This macro reads a file in View (or read-only) mode.  It is usually
bound to \key{C-X~C-V} instead of \cmd{visit-file} which can still be
invoked with \key{C-X~C-R}.

%[940612:changed:14.32#11]
\dc{view-mode}{C-\_ C-V}
This turns on \Def{View Mode} (or off if it's currently on) in the
selected buffer.  In \Def{View Mode} you cannot in any way modify the
buffer.  Buffers visiting read-only files are automatically set up in
this mode.  Note that most kill commands (with the exception of
\cmd{kill-region}) are still useful in this mode: instead of removing
the text they're supposed to kill they just copy it to the kill ring and
move point over the would-be killed text.

\dc{visible-bell}{variable}
Use the terminal's visual bell instead of beeping (ringing,
rattling, screeching\ldots).

\dc{visible-spaces-in-window}{C-X \{V,v\}}
This displays an underscore character instead of each space in the
window and displays a greater-than followed by spaces for each tab in
the window.  The actual text in the buffer is not changed; only the
screen display is affected.  To turn this off you run the command again;
it toggles.

\dc{visit-file}{C-X C-R}
This reads a specified file into the current buffer replacing the old
text.  If the buffer needs saving \jove{} will offer to save it for you.
Sometimes you use this to start over, say if you make lots of changes
and then change your mind.  If that's the case you don't want \jove{} to
save your buffer and you answer \key{NO} to the question.  If you supply
a numeric argument, point is moved to the beginning of that line in the
newly visited file.

%[900716:changed; added find-tag-at-point]
\dc{window-find}{C-X 4}
This lets you select another buffer in another window three different
ways.  This waits for another character which can be one of the
following:
\begin{description}
% !!DO NOT TOUCH THE SPACING IN THIS TABLE!! "make cmds.doc" DEPENDS ON IT!
\item[B]    Selects a buffer in the other window.
\item[F]    Finds a file in the other window.
\item[T]    Finds a tag in the other window.
\item[\carat{}T]   Finds the tag at point in the other window.
\end{description}
This is just a convenient short hand for \key{C-X~2} (or \key{C-X~O} if
there are already two windows) followed by the appropriate sequence for
invoking each command.  With this, though, there isn't the extra
overhead of having to redisplay.  In addition, you don't have to decide
whether to type \key{C-X~2} or \key{C-X~N} since \key{C-X~4} does the
right thing.
\NOTE{
Most versions of \jove{} may have additional bindings.  In that case you
can see the actual bindings by typing a question mark (\key{?}).
}

\dc{word-abbrev-mode}{C-X \{A,a\}}
This turns on \Def{Word Abbrev} mode (or off if it's currently on) in
the selected buffer.  \Def{Word Abbrev} mode lets you specify a word (an
abbreviation) and a phrase with which \jove{} should substitute the
abbreviation.  You can use this to define words to expand into long
phrases, e.g., ``jove'' can expand into ``Jonathan's Own Version of
Emacs''; another common use is defining words that you often misspell in
the same way, e.g., ``thier'' $\Rightarrow$ ``their'' or ``teh''
$\Rightarrow$ ``the''.  See the information on the
\cmd{auto-case-abbrev} variable.
\par\noindent
There are two kinds of abbreviations: mode specific and global.  If you
define a Mode specific abbreviation in C mode, it will expand only in
buffers that are in C mode.  This is so you can have the same
abbreviation expand to different things depending on your context.
Global abbreviations expand regardless of the major mode of the buffer.
The way it works is this: \jove{} looks first in the mode specific
table, and then in the global table.  Whichever it finds it in first is
the one that's used in the expansion.  If it doesn't find the word it is
left untouched.
\par\noindent
\Jove{} tries to expand words as they are typed, when you type a
punctuation character or \key{Space} or \key{Return}.  If you are in
\Def{Auto Fill} mode the expansion will be filled as if you typed it
yourself.

%[911122:new:14.18]
\dc{wrap-process-lines}{variable}
When set, lines from shell-commands and i-processes are wrapped around
if they are too long to fit the screen.
\NOTE{
This is a poor substitute in lieu of a real ``display-wrap-lines'' mode.
Since lines are chopped up rather arbitrarily this mode can give
problems with \cmd{parse-errors}.  In fact it is only there since
Jonathan likes it\ldots
}

\dc{wrap-search}{variable, ESC C-W}
If set, searches will ``wrap around'' the ends of the buffer instead
of stopping at the bottom or top.  The default is ``off''.

\dc{write-file}{C-X C-W}
This saves the current buffer to a specified file, and then makes that
file the default file name for this buffer.  If you specify a file that
already exists you are asked to confirm over-writing it.  If the
variable \cmd{make-backup-files} is set a backup is made of your
original file, unless you supply a negative numeric argument to this
command.

\dc{write-files-on-make}{variable}
When set, all modified files will be written out before calling make
when the \cmd{compile-it} command is executed.  The default is ``on''.

\dc{write-macros-to-file}{Not Bound}
This writes the currently defined macros to a specified file in a format
appropriate for reading them back in with the \cmd{source} command.  The
purpose of this command is to allow you to define macros once and use
them in other instances of \jove{}.  If you supply a numeric argument
only the macros changed or added since the last time you executed
\cmd{write-macros-to-file} (or the start of the \jove{} session) are
saved.

\dc{write-modified-files}{C-X {C-M,Return}}
This saves all the buffers that need saving.  If you supply a numeric
argument it asks for each buffer whether you really want to save it.

\dc{write-region}{Not Bound}
This writes the text in the region to a specified file.  If the file
already exists you are asked to confirm over-writing it.

\dc{write-word-abbrev-file}{Not Bound}
This writes the currently defined abbreviations to a specified file.
They can be read back in and automatically defined with
\cmd{read-word-abbrev-file}.

\dc{yank}{C-Y}
This undoes the last kill command.  That is, it inserts the killed text
at point.  When you do multiple kill commands in a row, they are merged
so that yanking them back with \key{C-Y} yanks back all of them.  If you
supply a numeric argument, the killed text is inserted that many times.
The entire portion of yanked text becomes the new region.  If the
argument is negative point is placed at the beginning of the yanked
text, otherwise it is placed at the end.

\dc{yank-pop}{ESC \{Y,y\}}
This yanks back previous killed text.  \Jove{} has a kill ring on which
the last 10 kills are stored. \cmd{yank} yanks a copy of the text at the
front of the ring.  If you want one of the last ten kills you use
\key{ESC~Y} which rotates the ring so another different entry is now at
the front.  You can use \key{ESC~Y} only immediately following a
\key{C-Y} or another \key{ESC~Y}.  If you supply a numeric argument,
the killed text is inserted that many times; if you supply a negative
argument the ring is rotated the other way.  If you use this command
enough times in a row you will eventually get back to where you started.
Experiment with this.  It's extremely useful.

\cleardoublepage

%=======================================================================
% $Log: jovecmds.tex,v $
% Revision 14.32.0.11  1994/06/13  01:45:07  tom
% (indentation-increment): new variable;
% (c-indentation-increment,handle-tab): updated;
% (view-mode): mention kill commands.
%
% Revision 14.32.0.10  1994/05/23  12:49:02  tom
% ("beginning-of-file-next-window", "end-of-file-next-window",
%  "case-region-capitalize", "grep", "keyseq-timeout-in-ms", "man",
%  "next-line-first-non-blank", "sentence-end", "sentence-sep",
%  "transpose-s-expressions", "transpose-words"): added;
% ("beginning-of-window", "binary-read-files", "binary-write-files",
%  "bind-to-key", "case-region-lower", "case-region-upper", "color",
%  "fill-paragraph", "transpose-lines"): updated;
%  ("sentence-format-string"): replaced with "sentence-end".
%
% Revision 14.32.0.9  1994/02/02  19:38:39  tom
% (dbx-format-string): add misnomer \NOTE;
% (dbx-program-pattern): new variable;
% (i-search-forward,i-search-reverse): add key descriptions;
% (search-forward-lit,search-forward-lit-nd,search-forward-re,
% search-forward-re-nd,search-reverse-lit,search-reverse-lit-nd,
% search-reverse-re,search-reverse-re-nd): new commands.
%
% Revision 14.32.0.3  1993/07/27  14:52:08  tom
% describe changes in default setting of "use-color".
%
% Revision 14.32  1993/06/22  03:56:03  tom
% (case-ignore-search): update for new case-ignore scheme;
% (color-erase-glitch, color-standout glitch): new variables.
%
% Revision 14.31  1993/02/18  10:57:41  tom
% describe new features.
%
% Revision 14.30  1993/02/09  23:08:23  tom
% Add "append-buffer", "dirs-extract", "dirs-unique", "join-next-line",
% "join-previous-line", "news", "next-buffer", "previous-buffer",
% "prompt-with-prefix-arg"; Update "delete-white-space", "digit", "dirs",
% "find-file", "help", "match-regular-expressions", "popd", "pushd";
% Replace example of "c-argument-indentation" with something more instructive.
%
% Revision 14.28  1992/10/04  01:59:47  tom
% update bind-keymap-to-key, default-color (new), make-keymap, use-color,
% remove sparse-*bind-*.
%
% Revision 14.27  1992/09/22  15:39:12  tom
% move "bind-keymap-to-buffer" to its rightful place; add "quote-char",
% "up-list".
%
% Revision 14.26  1992/08/26  23:57:10  tom
% add RCS directives
%
%=======================================================================
