+Alphabetical List of Commands and Variables
+
+:entry "abort-char" "Variable"
+This variable defines JOVE'S abort characer. When the abort character
+is typed, the current JOVE command is aborted. The default value is
+C-G.
+
+:entry "add-lisp-special" "Command"
+This command is to tell JOVE what identifiers require special
+indentation in lisp mode. Lisp functions like defun and 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.
+
+:entry "allow-^S-and-^Q" "Variable"
+This variable, when set, tells JOVE that your terminal does not need
+to use the characters C-S and 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.
+
+:entry "allow-bad-filenames" "Variable"
+If set, this variable permits filenames to contain "bad" characters
+such as those from the set *&%!"`[]{}. These files are harder to deal
+with, because the characters mean something to the shell. The default
+value is "off".
+
+:entry "append-region" "Command"
+This appends the region to a specified file. If the file does not
+already exist it is created.
+
+:entry "apropos" "Command"
+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
+
+ ESC X apropos window<Return>
+
+
+:entry "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.
+
+:entry "auto-execute-command" "Command"
+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 show-match-mode when you edit C source files (that is, files
+that end with ".c" or ".h") you can type
+
+ ESC X auto-execute-command show-match-mode .*.[ch]$
+
+
+:entry "auto-execute-macro" "Command"
+This is like "auto-execute-command" except you use it to execute
+macros automatically instead of built-in commands.
+
+:entry "auto-fill-mode" "Command"
+This turns on Auto Fill mode (or off if it's currently on) in the
+selected buffer. When JOVE is in Auto Fill mode it automatically
+breaks lines for you when you reach the right margin so you don't have
+to remember to hit Return. JOVE uses 78 as the right margin but you
+can change that by setting the variable "right-margin" to another
+value. See the "set" command to learn how to do this.
+
+:entry "auto-indent-mode" "Command"
+This turns on Auto Indent mode (or off if it's currently on) in the
+selected buffer. When JOVE is in Auto Indent mode, 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 "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.
+
+:entry "background-color" "Variable"
+This specifies the background color of the screen (PC version only).
+The default value is 0, which stands for black.
+
+:entry "backward-character" "Command"
+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.
+
+:entry "backward-list" "Command"
+This moves backward over a list as opposed to an s-expression. The
+difference between this and "backward-s-expression" is that this first
+searchs for a ")" and then moves to the matching "(". This is useful
+when you're trying to find unmatched parens in a program.
+
+:entry "backward-paragraph" "Command"
+This moves point backward to the beginning of the current or previous
+paragraph. Paragraphs are bounded by lines that begin with a Period
+or Tab, 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.
+
+:entry "backward-s-expression" "Command"
+This moves point backward over a s-expression. It is just like
+"forward-s-expression" with a negative argument.
+
+:entry "backward-sentence" "Command"
+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 Return or by one or more spaces.
+
+:entry "backward-up-list" "Command"
+This is similar to "backward-s-expression" except it backs up and OUT
+of the enclosing s-expression. In other words, it moves backward to
+the "(" that would match a ")" if you were to type it right then.
+
+:entry "backward-word" "Command"
+This moves point backward to the beginning of the current or previous
+word.
+
+:entry "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 ".o" so if you have jove.c and
+jove.o in the same directory, the filename completion will not
+complain of an ambiguity because it will ignore jove.o.
+
+:entry "begin-kbd-macro" "Command"
+This starts defining the keyboard macro by remembering all your key
+strokes until you execute "end-kbd-macro," by typing "C-X )". Because
+of a bug in JOVE you shouldn't terminate the macro by typing "ESC X
+end-kbd-macro"; "end-kbd-macro" must be bound to "C-X )" in order to
+make things work correctly. To execute the remembered key strokes you
+type "C-X E" which runs the "execute-kbd-macro" command. Sometimes
+you may want a macro to accept different input each time it runs. To
+see how to do this, see the "make-macro-interactive" command.
+
+:entry "beginning-of-file" "Command"
+This moves point backward to the beginning of the buffer. This
+sometimes prints the "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.
+
+:entry "beginning-of-line" "Command"
+This moves point to the beginning of the current line.
+
+:entry "beginning-of-window" "Command"
+This moves point to the beginning of the current window. The sequence
+"ESC ," is the same as "ESC <" (beginning of file) except without the
+shift key on the "<", and can thus can easily be remembered.
+
+:entry "bind-keymap-to-key" "Command"
+This is the way to build nested keymaps. For example, when JOVE
+starts up, internally it does a
+
+ bind-keymap-to-key ESC-map ^[
+
+To make the arrow keys on vt100's work, you would do the following.
+
+ 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
+
+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. Eventually there will be a more general way
+to have these keymaps built for you.
+
+:entry "bind-macro-to-key" "Command"
+This is like "bind-to-key" except you use it to attach keys to named
+macros.
+
+:entry "bind-macro-to-word-abbrev" "Command"
+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
+(C-@) and then exchange the point and mark last (C-X C-X).
+
+:entry "bind-to-key" "Command"
+This attaches a key to an internal JOVE command so that future hits on
+that key invoke that command. For example, to make "C-W" erase the
+previous word, you type "ESC X bind-to-key kill-previous-word C-W".
+
+:entry "buffer-position" "Command"
+This displays the current file name, current line number, total number
+of lines, percentage of the way through the file, and the position of
+the cursor in the current line.
+
+:entry "c-argument-indentation" "Variable"
+This variable describes how to indent lines which are part of nested
+expressions in C. The default is -1, 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 c-argument-
+indentation characters past the indent of the first line of the
+expression. For example, the default value produces:
+ Typeout(fmt, itoa(bcount++), line_cnt(b, nbuf),
+ TypeNames[b->b_type],
+ IsModified(b) ? "*" : b->b_ntbf ? "+" : NullStr,
+ buf_width, b->b_name, filename(b));
+
+:entry "c-indentation-increment" "Variable"
+This defines a set of tabstops independent of the value of internal-
+tabstops and physical-tabstops. This value will be used in C mode,
+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. But all that aside, if you set c-indentation-increment to
+8 (the default), and then set internal-tabstops to 4 as well, JOVE
+will insert TWO Tabs to get the indentation to 8, which is clearly not
+what you want.
+
+:entry "c-mode" "Command"
+This turns on C mode in the currently selected buffer. This is one of
+currently four possible major modes: Fundamental, Text, C, Lisp.
+When in C or Lisp mode, Tab, "}", and ")" behave a little differently
+from usual: They are indented to the "right" place for C (or Lisp)
+programs. In JOVE, the "right" place is simply the way the author
+likes it (but I've got good taste).
+
+:entry "case-character-capitalize" "Command"
+This capitalizes the character after point, i.e., the character under
+the cursor. If a negative argument is supplied that many characters
+"before" point are upper cased.
+
+:entry "case-ignore-search" "Variable"
+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 either. The default value of this variable is
+"off".
+
+:entry "case-region-lower" "Command"
+This changes all the upper case letters in the region to their lower
+case equivalent.
+
+:entry "case-region-upper" "Command"
+This changes all the lower case letters in the region to their upper
+case equivalent.
+
+:entry "case-word-capitalize" "Command"
+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 "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.
+
+:entry "case-word-lower" "Command"
+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
+"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.
+
+:entry "case-word-upper" "Command"
+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
+"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.
+
+:entry "cd" "Command"
+This changes the current directory.
+
+:entry "character-to-octal-insert" "Command"
+This inserts a Back-slash followed by the ascii value of the next
+character typed. For example, "C-G" inserts the string "\007".
+
+:entry "clear-and-redraw" "Command"
+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.
+
+:entry "comment-format" "Variable"
+This variable tells JOVE how to format your comments when you run the
+command "fill-comment." Its format is this:
+
+ <open pattern>%!<line header>%c<line trailer>%!<close pattern>
+
+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 "fill-comment" for more.
+
+:entry "compile-it" "Command"
+This compiles your program by running the UNIX command "make" into a
+buffer, and automatically parsing the error messages that are created
+(if any). See the "parse-errors" command. To compile a C program
+without "make", use "C-U C-X C-E" and JOVE will prompt for a command
+to run instead of make. (And then the command you type will become
+the default command.) You can use this to parse the output from the C
+compiler or the "grep" or "lint" programs. See also "error-format-
+string" to make it possible to parse errors of a different format.
+
+:entry "continue-process" "Command"
+This sends SIGCONT to the current interactive process, "if" the
+process is currently stopped.
+
+:entry "copy-region" "Command"
+This takes all the text in the region and copies it onto the kill ring
+buffer. This is just like running "kill-region" followed by the
+"yank" command. See the "kill-region" and "yank" commands.
+
+:entry "current-error" "Command"
+This moves to the current error in the list of parsed errors. See the
+"next-error" and "previous-error" commands for more detailed
+information.
+
+:entry "date" "Command"
+This prints the date on the message line.
+
+:entry "dbx-format-string" "Variable"
+This is the default regular-expression search string used by JOVE to
+parse output from dbx running in a shell process. The default format
+string works when you type "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 gdb or some other symbolic debugger.
+
+:entry "define-global-word-abbrev" "Command"
+This defines a global abbreviation.
+
+:entry "define-macro" "Command"
+This provides a different mechanism for defining keyboard macros.
+Instead of gathering keystrokes and storing them into the "keyboard-
+macro" (which is how "start-kbd-macro" works), "define-macro" prompts
+for a macro name (terminated with Space, or Newline) and then for the
+actual macro body. If you wish to specify control characters in the
+macro, you may simply insert them (using the "quoted-insert" command)
+or by inserting the character '^' followed by the appropriate letter
+for that character (e.g., ^A would be the two characters '^' followed
+by 'A'). You may use Back-slash to prevent the '^' from being
+interpreted as part of a control character when you really wish to
+insert one (e.g., a macro body "\^foo" would insert the string "^foo"
+into the buffer, whereas the body "^foo" would be the same as typing
+^F and then inserting the string "oo"). See "write-macros-to-file" to
+see how to save macros.
+
+:entry "define-mode-word-abbrev" "Command"
+This defines a mode-specific abbreviation.
+
+:entry "delete-blank-lines" "Command"
+This deletes all the blank lines around point. This is useful when
+you previously opened many lines with "C-O" and now wish to delete the
+unused ones.
+
+:entry "delete-buffer" "Command"
+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.
+
+:entry "delete-current-window" "Command"
+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.
+
+:entry "delete-macro" "Command"
+This deletes a macro from the list of named macros. It is an error to
+delete the keyboard-macro. Once the macro is deleted it is gone
+forever. If you are about to save macros to a file and decide you
+don't want to save a particular one, delete it.
+
+:entry "delete-next-character" "Command"
+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.
+
+:entry "delete-other-windows" "Command"
+This deletes all the other windows except the current one. This can
+be thought of as going back into One Window mode.
+
+:entry "delete-previous-character" "Command"
+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.
+
+:entry "delete-white-space" "Command"
+This deletes all the Tabs and Spaces around point.
+
+:entry "describe-bindings" "Command"
+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 "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.
+
+:entry "describe-command" "Command"
+This prints some info on a specified command.
+
+:entry "describe-key" "Command"
+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 "describe-command" command to
+find out exactly what it does.
+
+:entry "describe-variable" "Command"
+This prints some info on a specified variable.
+
+:entry "digit" "Command"
+This reads a numeric argument. When you type "ESC" followed by a
+number, "digit" keeps reading numbers until you type some other
+command. Then that command is executes with the numeric argument you
+specified.
+
+:entry "digit-1" "Command"
+This pretends you typed "ESC 1". 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 type "ESC" when you want to specify an argument.
+
+:entry "digit-2" "Command"
+This pretends you typed "ESC 2". 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 type "ESC" when you want to specify an argument.
+
+:entry "digit-3" "Command"
+This pretends you typed "ESC 3". 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 type "ESC" when you want to specify an argument.
+
+:entry "digit-4" "Command"
+This pretends you typed "ESC 4". 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 type "ESC" when you want to specify an argument.
+
+:entry "digit-5" "Command"
+This pretends you typed "ESC 5". 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 type "ESC" when you want to specify an argument.
+
+:entry "digit-6" "Command"
+This pretends you typed "ESC 6". 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 type "ESC" when you want to specify an argument.
+
+:entry "digit-7" "Command"
+This pretends you typed "ESC 7". 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 type "ESC" when you want to specify an argument.
+
+:entry "digit-8" "Command"
+This pretends you typed "ESC 8". 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 type "ESC" when you want to specify an argument.
+
+:entry "digit-9" "Command"
+This pretends you typed "ESC 9". 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 type "ESC" when you want to specify an argument.
+
+:entry "digit-0" "Command"
+This pretends you typed "ESC 0". 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 type "ESC" when you want to specify an argument.
+
+:entry "dirs" "Command"
+This prints out the directory stack. See the "cd", "pushd", "popd"
+commands for more info.
+
+:entry "disable-biff" "Variable"
+When this is set, JOVE disables biff when you're editing and enables
+it again 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). The default is "off".
+
+:entry "display-bad-filenames" "Variable"
+This variable affects only filename completion, in particular, what
+happens when "?" 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 "bad-filename-extensions" will be displayed with an
+"!" in front of their names. When "display-bad-filenames" is OFF the
+files will not be displayed at all. The default value is on.
+
+:entry "down-list" "Command"
+This is the opposite of "backward-up-list." It's not clear to me that
+this command serves any useful purpose in life. Try it out, and let
+me know what you think.
+
+:entry "dstop-process" "Command"
+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 C-Y. This only works if you have the
+interactive process feature, and if you are in a buffer bound to a
+process.
+
+:entry "edit-word-abbrevs" "Command"
+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
+"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 "C-X C-C" to
+exit the recursive edit.
+
+:entry "end-kbd-macro" "Command"
+This stops the definition of the keyboard macro. Because of a bug in
+JOVE, this must be bound to "C-X )", or some key sequence which is one
+or two characters long. Anything else will not work properly.
+
+:entry "end-of-file" "Command"
+This moves point forward to the end of the buffer. This sometimes
+prints the "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.
+
+:entry "end-of-line" "Command"
+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.
+
+:entry "end-of-window" "Command"
+This moves point to the last character in the window.
+
+:entry "eof-process" "Command"
+Sends EOF to the current interactive process. This only works on
+versions of JOVE running under versions of UNIX with pty's.
+
+:entry "erase-buffer" "Command"
+This erases the contents of the specified buffer. This is like
+"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.
+
+:entry "error-format-string" "Variable"
+This is the error format string that is used by "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 \('s and
+\)'s 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:
+
+ "file.c", line 540: missing semi-colon
+
+For strings of this format, an appropriate value for "error-format-
+string" would be something like this:
+
+ ^"\([^"]*\)", line \([0-9]*\):
+
+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 ", 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). The only constraints on the error
+messages is that the file name and line number appear on the same
+line, and that the file name appears before the line number. Most
+compilers seem to do this anyway, so this is not an unreasonable
+restriction.
+
+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.
+
+:entry "error-window-size" "Variable"
+This is the percentage of the screen to use for the error-window on
+the screen. When you execute "compile-it," "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%.
+
+:entry "exchange-point-and-mark" "Command"
+This moves point to mark and makes mark the old point. This is for
+quickly moving from one end of the region to another.
+
+:entry "execute-kbd-macro" "Command"
+This executes the keyboard macro. If you supply a numeric argument
+the macro is executed that many times.
+
+:entry "execute-macro" "Command"
+This executes a specified macro. If you supply a numeric argument the
+macro is executed that many times.
+
+:entry "execute-named-command" "Command"
+This is the way to execute a command that isn't bound to any key.
+When you are prompted with ": " 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 Space and JOVE will fill in the rest for you.
+If you are not sure of the name of the command, type "?" 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 "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 "bind-to-key" command.
+
+:entry "exit-jove" "Command"
+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
+"exit-jove" will return you from that.
+
+:entry "expand-environment-variables" "Variable"
+When this variable is on JOVE will try to expand any strings of the
+form "$var" into the value of the environment variable "var" when in
+the minibuffer. For example, if you type $HOME/.joverc, "$HOME" will
+be replaced with you home directory. The default value is off.
+
+:entry "file-creation-mode" "Variable"
+This variable has an octal value. It contains the mode (see
+"chmod(1)" ) with which files should be created. This mode gets
+modified by your current umask setting (see "umask(1)" ). The default
+value is usually "0666" or "0644."
+
+:entry "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.
+
+:entry "fill-comment" "Command"
+This command fills in your C comments to make them pretty and
+readable. This filling is done according the variable "comment-
+format."
+
+ /*
+ * the default format makes comments like this.
+ */
+
+This can be changed by changing the format variable. Other languages
+may be supported by changing the format variable appropriately. The
+formatter looks backwards from dot 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.
+
+:entry "fill-paragraph" "Command"
+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 be greater than the right margin.
+The default value for "right-margin" is 78, but can be changed with
+the "set" and "right-margin-here" commands. JOVE has a complicated
+algorithm for determining the beginning and end of the paragraph. 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 "fill-paragraph" (e.g., by typing C-U ESC J) and
+JOVE will indent each line to the column specified by the "left-
+margin" variable. See also the "left-margin" variable and "left-
+margin-here" command.
+
+:entry "fill-region" "Command"
+This is like "fill-paragraph," except it operates on a region instead
+of just a paragraph.
+
+:entry "filter-region" "Command"
+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 "filter-region" it
+through "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 "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 "C-Y".
+
+:entry "find-file" "Command"
+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 "(New file)"
+so that you know.
+
+:entry "find-tag" "Command"
+This finds the file that contains the specified tag. JOVE looks up
+tags by default in the "tags" file in the current directory. You can
+change the default tag name by setting the "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.
+
+:entry "find-tag-at-point" "Command"
+This finds the file that contains the tag that point is currently on.
+See "find-tag."
+
+:entry "first-non-blank" "Command"
+This moves point back to the indent of the current line.
+
+:entry "foreground-color" "Variable"
+This specifies the foreground color of the screen (PC version only).
+The default is 1, which stands for white. The attribute used for
+writing to the screen is formed by (bg&7)<<4 & (fg&7).
+
+:entry "forward-character" "Command"
+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.
+
+:entry "forward-list" "Command"
+This is like "forward-s-expression" except it moves over lists ONLY.
+What this does is search for the next "(" and then move to the
+matching ")". This is useful for when you are trying to find
+mismatched parentheses in a program.
+
+:entry "forward-paragraph" "Command"
+This moves point forward to the end of the current or next paragraph.
+Paragraphs are bounded by lines that begin with a Period or Tab, 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.
+
+:entry "forward-s-expression" "Command"
+This moves point forward over a s-expression. If the first
+significant character after point is "(", this moves past the matching
+")". 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 "{".
+
+:entry "forward-sentence" "Command"
+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 Return, or one or more spaces.
+
+:entry "forward-word" "Command"
+This moves point forward to the end of the current or next word.
+
+:entry "fundamental-mode" "Command"
+This sets the major mode to Fundamental. This affects what JOVE
+considers as characters that make up words. For instance, Single-
+quote is not part of a word in Fundamental mode, but is in Text mode.
+
+:entry "gather-numeric-argument" "Command"
+This command is one of two ways to specify a numeric argument to a
+command. It's usually bound to C-U. Typing C-U once means, Do the
+next command 4 times. Typing C-U twice will do the next command 16
+times, and so on. If at any point you type a number, then that number
+will be used instead of 4. For instance, C-U 3 5 means do the next
+command 35 times.
+
+:entry "goto-line" "Command"
+If a numeric argument is supplied point moves to the beginning of that
+line. If no argument is supplied one is prompted for.
+
+:entry "goto-window-with-buffer" "Command"
+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.
+
+:entry "grind-s-expr" "Command"
+When point is positioned on a "(", this re-indents that LISP
+expression.
+
+:entry "grow-window" "Command"
+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.
+
+:entry "handle-tab" "Command"
+This handles indenting to the "right" place in C and Lisp mode, and
+just inserts itself in Text mode.
+
+:entry "i-search-forward" "Command"
+Incremental search. Like 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 Return key to finish
+the search. You can take back a character with DEL and the search
+will back up to the position before that character was typed. C-G
+aborts the search.
+
+:entry "i-search-reverse" "Command"
+Incremental search. Like 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 Return key to finish
+the search. You can take back a character with DEL and the search
+will back up to the position before that character was typed. C-G
+aborts the search.
+
+:entry "i-shell-command" "Command"
+This is like "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.
+
+:entry "insert-file" "Command"
+This inserts a specified file into the current buffer at point. Point
+is positioned at the beginning of the inserted file.
+
+:entry "internal-tabstop" "Variable"
+The number of spaces JOVE should print when it displays a tab
+character. The default value is 8.
+
+:entry "interrupt-character" "Variable"
+This is set to the character that interrupts JOVE (with a signal) no
+matter what JOVE is doing. It's main use is for interrupting non-
+interactive processes, but it also has uses for debugging.
+Unfortunately there is no way to turn off the interrupt character.
+
+:entry "interrupt-process" "Command"
+This sends the interrupt character (usually C-C) to the interactive
+process in the current buffer. This is only for versions of JOVE that
+have the interactive processes feature. This only works when you are
+inside a buffer that's attached to a process.
+
+:entry "kill-next-word" "Command"
+This kills the text from point to the end of the current or next word.
+
+:entry "kill-previous-word" "Command"
+This kills the text from point to the beginning of the current or
+previous word.
+
+:entry "kill-process" "Command"
+This command prompts for a buffer name or buffer number (just as
+select-buffer does) and then sends the process in that buffer a kill
+signal (9).
+
+:entry "kill-region" "Command"
+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 "kill" in their names. Type "C-Y" to yank back the most recent
+kill.
+
+:entry "kill-s-expression" "Command"
+This kills the text from point to the end of the current or next s-
+expression.
+
+:entry "kill-some-buffers" "Command"
+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
+PDP-11's) and you have lots of buffers that you are no longer using.
+
+:entry "kill-to-beginning-of-sentence" "Command"
+This kills from point to the beginning of the current or previous
+sentence.
+
+:entry "kill-to-end-of-line" "Command"
+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
+"before" point are killed; if the argument is zero the text from point
+to the beginning of the line is killed.
+
+:entry "kill-to-end-of-sentence" "Command"
+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.
+
+:entry "left-margin" "Variable"
+This is how far lines should be indented when auto-indent mode is on,
+or when the "newline-and-indent" command is run (usually by typing
+LineFeed). It is also used by fill-paragraph and auto-fill mode. If
+the value is zero (the default) then the left margin is determined
+from the surrounding lines.
+
+:entry "left-margin-here" "Command"
+This sets the "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.
+
+:entry "lisp-mode" "Command"
+This turns on Lisp mode. Lisp mode is one of four mutually exclusive
+major modes: Fundamental, Text, C, and Lisp. In Lisp mode, the
+characters Tab and ) are treated specially, similar to the way they
+are treated in C mode. Also, Auto Indent mode is affected, and
+handled specially.
+
+:entry "list-buffers" "Command"
+This types out a list containing various information about each
+buffer. Right now that list looks like this:
+
+ (* means the buffer needs saving)
+ NO Lines Type Name File
+ -- ----- ---- ---- ----
+ 1 1 File Main [No file]
+ 2 1 Scratch * Minibuf [No file]
+ 3 519 File * commands.doc commands.doc
+
+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: "File", "Scratch", "Process", "I-Process". "File" is simply a
+buffer that holds a file; "Scratch" is for buffers that JOVE uses
+internally; "Process" is one that holds the output from a UNIX
+command; "I-Process" is one that has an interactive process attached
+to it. 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 Minibuf and commands.doc have been changed but not yet
+saved. In fact Minibuf won't be saved since it's an internal JOVE
+buffer that I don't even care about.
+
+:entry "list-processes" "Command"
+This makes a list somewhat like "list-buffers" does, except its list
+consists of the current interactive processes. Right now the list
+looks like this:
+
+ Buffer Status Pid Command
+ ------ ------ --- -------
+ *shell* Running 18415shell
+ fgrep Done 18512 fgrep -n Buffer *.c
+
+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 "Done" as in fgrep; if the process
+exited with an error the status is "Exit N" where N is the value of
+the exit code; if the process was killed by some signal the status is
+the name of the signal that was used; otherwise the process is
+running. The last column is the name of the command that is being
+run.
+
+:entry "macify" "Variable"
+When this variable is on, JOVE will use the standard Macintosh file-
+selector dialog in place of the traditional JOVE minibuffer. (Mac
+version only)
+
+:entry "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 "mailbox" and "disable-biff" variables.
+
+:entry "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
+/usr/spool/mail/$USER, where $USER is set to your login name.
+
+:entry "make-backup-files" "Variable"
+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
+"#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.
+
+:entry "make-buffer-unmodified" "Command"
+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 *
+disappear when you use this command.
+
+:entry "make-keymap" "Command"
+This creates an empty keymap with a name you supply. That name can be
+used to reference the keymap in other commands, such as bind-keymap-
+to-key.
+
+:entry "make-macro-interactive" "Command"
+This command is meaningful only while you are defining a keyboard
+macro, and when you are in the minibuffer. 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 the make-macro-interactive command just before typing
+the argument which will be used during the definition process. Note:
+you must bind this command to a key in order to use it; you can't say
+"ESC X make-macro-interactive".
+
+:entry "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).
+
+:entry "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".
+
+:entry "match-regular-expressions" "Variable"
+When set, JOVE will match regular expressions in search patterns.
+This makes special the characters ., *, [, ], ^, and $, and the two-
+character sequences \<, \>, \{, \} and \|. See the "ed(1)" manual
+page, the tutorial "Advanced Editing in UNIX", and the section above
+"Searching with Regular Expressions" for more information.
+
+:entry "meta-key" "Variable"
+You should set this variable to "on" if your terminal has a real Meta
+key. If your terminal has such a key, then a key sequence like ESC Y
+can be entered by holding down Meta and typing Y. NOTE: In some
+systems, this disables interrupting noninteractive shell commands.
+
+:entry "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 similar
+to that used by printf(3), with the special things being marked as
+"%x". Digits may be used between the 'x' may be:
+
+ C check for new mail, and displays "[New mail]" if there
+ is any (see also the mail-check-interval and disable-biff
+ variables)
+ F the current file name, with leading path stripped
+ M the current list of major and minor modes
+ b the current buffer name
+ c the fill character (-)
+ d the current directory
+ e extra space in modeline is distributed evenly
+ among the places %e is used (used for justifying,
+ separating, or centering parts of the modeline)
+ f the current file name
+ l the current load average (updated automatically)
+ mxy x, when the buffer is modified or y, when not
+ n the current buffer number
+ p interactive process status for process windows
+ s space, but only if previous character is not a space
+ t the current time (updated automatically)
+ w a '>' for windows which are scrolled left
+ [ ] the square brackets printed when in a recursive edit
+ ( ) items enclosed in %( ... %) will only be printed on
+ the bottom mode line, rather than copied when the
+ window is split
+
+In addition, any other character is simply copied into the mode line.
+Characters may be escaped with a backslash. To get a feel for all
+this, try typing "ESC X print mode-line" and compare the result with
+your current mode line.
+
+:entry "mode-line-color" "Variable"
+This specifies the color of the modeline (PC version only). Its
+default value is 0, and in that case it is drawn in reverse video. If
+it has any other value, this value is used as the attribute in the
+Bios calls.
+
+:entry "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 "off".
+
+:entry "name-kbd-macro" "Command"
+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 the "define-macro," "source" and "write-macros-to-file" commands.
+
+:entry "newline" "Command"
+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.
+
+:entry "newline-and-backup" "Command"
+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 "newline" is that point does not move down to the
+beginning of the new line.
+
+:entry "newline-and-indent" "Command"
+This behaves the same was as Return does when in Auto Indent mode.
+This makes Auto Indent mode obsolete but it remains in the name of
+backward compatibility.
+
+:entry "next-error" "Command"
+This moves to the next error in the list of errors that were parsed
+with "parse-errors." In one window the list of errors is shown with
+the current one always at the top. In another window is the file that
+contains the error. Point is positioned in this window on the line
+where the error occurred.
+
+:entry "next-line" "Command"
+This moves down to the next line.
+
+:entry "next-page" "Command"
+This displays the next page of the buffer by taking the bottom line of
+the window and redrawing the window with it at the top. If there
+isn't another page in the buffer JOVE rings the bell. If a numeric
+argument is supplied the screen is scrolled up that many lines; if the
+argument is negative the screen is scrolled down.
+
+:entry "next-window" "Command"
+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.
+
+:entry "number-lines-in-window" "Command"
+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.
+
+:entry "over-write-mode" "Command"
+This turns 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, DEL replaces the character before
+point with a space instead of deleting it. When Over Write mode is on
+"OvrWt" is displayed on the mode line.
+
+:entry "page-next-window" "Command"
+This displays the next page in the next window. This is exactly the
+same as "C-X N C-V C-X P".
+
+:entry "paren-flash" "Command"
+This handles the C mode curly brace indentation, the Lisp mode paren
+indentation, and the Show Match mode paren/curly brace/square bracket
+flashing.
+
+:entry "paren-flash-delay" "Variable"
+How long, in tenths of seconds, JOVE should pause on a matching
+parenthesis in "Show" mode. The default is 5.
+
+:entry "parse-errors" "Command"
+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 "next-error" and "previous-error" and "current-error"
+commands. This is a very useful tool and helps with compiling C
+programs and when used in conjunction with the "grep" UNIX command
+very helpful in making changes to a bunch of files. This command
+understands errors produced by cc, cpp, and lint; plus any other
+program with the same format (e.g., "grep -n"). 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.
+"current-error" is automatically executed after one of the parse
+commands, so you end up at the first error. See also "error-format-
+string" to make it possible to parse errors of a different format.
+
+:entry "parse-spelling-errors-in-buffer" "Command"
+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.
+
+:entry "pause-jove" "Command"
+This stops JOVE and returns control to the parent shell. This only
+works for users using the C-shell, and on systems that have the job
+control facility. To return to JOVE you type "fg" to the C-shell.
+
+:entry "physical-tabstop" "Variable"
+How many spaces your terminal prints when it prints a tab character.
+
+:entry "pop-mark" "Command"
+This gets executed when you run "set-mark" with a numeric argument.
+JOVE remembers the last 16 marks and you use "pop-mark" to go backward
+through the ring of marks. If you execute "pop-mark" enough times you
+will eventually get back to where you started.
+
+:entry "popd" "Command"
+This pops one entry off the directory stack. Entries are pushed with
+the "pushd" command. The names were stolen from the C-shell and the
+behavior is the same.
+
+:entry "previous-error" "Command"
+This is the same as "next-error" except it goes to the previous error.
+See "next-error" for documentation.
+
+:entry "previous-line" "Command"
+This moves up to the previous line.
+
+:entry "previous-page" "Command"
+This displays the previous page of the current buffer by taking the
+top line and redrawing the window with it at the bottom. If a numeric
+argument is supplied the screen is scrolled down that many lines; if
+the argument is negative the screen is scrolled up.
+
+:entry "previous-window" "Command"
+This moves into the next 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.
+
+:entry "print" "Command"
+This prints the value of a JOVE variable.
+
+:entry "process-bind-keymap-to-key" "Command"
+This is just like "bind-to-key" except that it starts at the process-
+keymap map, instead of the default mainmap.
+
+:entry "process-bind-to-key" "Command"
+This command is identical to 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
+
+ process-bind-to-key stop-process ^Z
+ process-bind-to-key interrupt-process ^C
+
+Then, when you start up an interactive process and switch into that
+buffer, C-Z will execute stop-process and C-C will execute interrupt-
+process. When you switch back to a non-process buffer, C-Z will go
+back to executing scroll-up (or whatever you have it bound to).
+
+:entry "process-dbx-output" "Command"
+This command only makes sense in a buffer running a shell process. If
+you are running dbx in a window, JOVE will automatically find the file
+you are currently stepping through and display it in another window.
+The string DBX will appear in the modeline along with the other minor
+modes when this feature is enabled.
+
+:entry "process-newline" "Command"
+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 Return. When you're at the end of the I-
+Process buffer this does what 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 "must"
+be bound to the key you usually use to enter shell commands (Return),
+or else you won't be able to enter any.
+
+:entry "process-prompt" "Variable"
+What a prompt looks like from the shell and i-shell-command processes.
+The default is "% ", 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 \| operator. For instance, for LISP
+hackers, the prompt can be
+
+ "% \|-> \|<[0-9]>: ".
+
+
+:entry "process-send-data-no-return" "Command"
+This is like "process-newline" except it sends everything to the
+process without the newline. Normally, when you type return in a
+process buffer it sends everything you typed including the Return.
+This command just provides a way to send data to the process without
+having to send a newline as well.
+
+:entry "push-shell" "Command"
+This spawns a child shell and relinquishes control to it. This works
+on any version of UNIX, but this isn't as good as "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 "C-D".
+
+:entry "pushd" "Command"
+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 "pushd."
+
+:entry "pwd" "Command"
+This prints the working directory.
+
+:entry "query-replace-string" "Command"
+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:
+
+ Space to replace this occurrence and go on to the next one.
+ Periodto replace this occurrence and then stop.
+ DEL to skip this occurrence and go on to the next one.
+ C-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 "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 recursive
+ editing level.
+ C-W to delete the matched string and then enter a recursive
+ edit.
+ U to undo all changes to the last modified line.
+ P or !to go ahead and replace the remaining occurrences without
+ asking.
+ Returnto stop the Query Replace.
+
+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.
+
+:entry "quit-process" "Command"
+This is the same as typing "C-\" (the Quit character) to a normal UNIX
+process, except it sends it to the current process in JOVE. This is
+only for versions of JOVE that have the interactive processes feature.
+This only works when you are inside a buffer that's attached to a
+process.
+
+:entry "quoted-insert" "Command"
+This lets you insert characters that normally would be executed as
+other JOVE commands. For example, to insert "C-F" you type "C-Q C-F".
+
+:entry "read-only-mode" "Command"
+Read-only-mode is a minor mode. It puts a buffer in read-only mode,
+so that any attempts to modify the buffer fail. When a file is found,
+and it's not got write permission, JOVE automatically puts the buffer
+in read-only mode. This is very helpful when you are in environments
+which use source control programs like RCS and SCCS. It prevents
+accidents like making a bunch of changes and only THEN discovering
+that you haven't checked the file out for making changes. This, like
+other minor modes, toggles.
+
+:entry "read-word-abbrev-file" "Command"
+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 Word Abbrev mode this command puts it in that
+mode.
+
+:entry "recursive-edit" "Command"
+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.
+
+:entry "redraw-display" "Command"
+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, "ESC 0 C-L" positions
+the line containing point at the top of the window.
+
+:entry "rename-buffer" "Command"
+This lets you rename the current buffer.
+
+:entry "replace-in-region" "Command"
+This is the same as "replace-string" except that it is restricted to
+occurrences between Point and Mark.
+
+:entry "replace-string" "Command"
+This replaces all occurrences of a specified string with a specified
+replacement string. This is just like "query-replace-string" except
+it replaces without asking.
+
+:entry "right-margin" "Variable"
+Where the right margin is for "Auto Fill" mode and the "justify-
+paragraph" and "justify-region" commands. The default is 78.
+
+:entry "right-margin-here" "Command"
+This sets the "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.
+
+:entry "save-file" "Command"
+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 "save-file" refuses to do the save. If
+you really do want to write the file you can use "C-X C-W" which
+executes "write-file."
+
+:entry "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.
+
+:entry "scroll-down" "Command"
+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.
+
+:entry "scroll-left" "Command"
+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 variable
+"scroll-all-lines" is ON then "scroll-left" may actually do nothing if
+the scrolling would cause Point not to be visible.
+
+:entry "scroll-next-page" "Command"
+This continuously scrolls up screen-full lines (PC version only).
+
+:entry "scroll-previous-page" "Command"
+This continuously scrolls down screen-full lines (PC version only).
+
+:entry "scroll-right" "Command"
+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 variable
+"scroll-all-lines" is ON then "scroll-right" may actually do nothing
+if the scrolling would cause Point not to be visible.
+
+:entry "scroll-step" "Variable"
+How many lines should be scrolled if the "previous-line" or "next-
+line" commands move you off the top or bottom of the screen. You may
+wish to decrease this variable if you are on a slow terminal. The
+default value is 0, which means to center the current line in the
+window. If the value is negative, the behavior is slightly different.
+If you move off the top of the window, and "scroll-step" is, say, -5
+then the new line will be displayed 5 lines from the bottom of the
+window. If you move off the bottom of the window, the new line will
+be positioned 5 lines from the top of the window.
+
+:entry "scroll-up" "Command"
+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.
+
+:entry "search-exit-char" "Variable"
+Set this to the character you want to use to exit incremental search.
+The default is Newline, which makes i-search compatible with normal
+string search.
+
+:entry "search-forward" "Command"
+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.
+
+:entry "search-forward-nd" "Command"
+This is just like "search-forward" except that it doesn't assume a
+default search string, and 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.
+
+:entry "search-reverse" "Command"
+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.
+
+:entry "search-reverse-nd" "Command"
+This is just like "search-reverse" except that it doesn't assume a
+default search string, and 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.
+
+:entry "select-buffer" "Command"
+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 Escape or Space will complete it for you. If you want to
+create a new buffer you can type Return instead of Space, and a new
+empty buffer will be created.
+
+:entry "select-buffer-1" "Command"
+This selects buffer number 0, if it exists (PC version only).
+
+:entry "select-buffer-1" "Command"
+This selects buffer number 1, if it exists (PC version only).
+
+:entry "select-buffer-2" "Command"
+This selects buffer number 2, if it exists (PC version only).
+
+:entry "select-buffer-3" "Command"
+This selects buffer number 3, if it exists (PC version only).
+
+:entry "select-buffer-4" "Command"
+This selects buffer number 4, if it exists (PC version only).
+
+:entry "select-buffer-5" "Command"
+This selects buffer number 5, if it exists (PC version only).
+
+:entry "select-buffer-6" "Command"
+This selects buffer number 6, if it exists (PC version only).
+
+:entry "select-buffer-7" "Command"
+This selects buffer number 7, if it exists (PC version only).
+
+:entry "select-buffer-8" "Command"
+This selects buffer number 8, if it exists (PC version only).
+
+:entry "select-buffer-9" "Command"
+This selects buffer number 9, if it exists (PC version only).
+
+:entry "self-insert" "Command"
+This inserts the character that invoked it into the buffer at point.
+Initially all but a few of the printing characters are bound to
+"self-insert."
+
+:entry "send-typeout-to-buffer" "Variable"
+When this is set JOVE will send output that normally overwrites the
+screen (temporarily) to a buffer instead. This affects commands like
+"list-buffers," "list-processes," and commands that use completion.
+The default value is "off".
+
+:entry "set" "Command"
+This gives a specified variable a new value. Occasionally you'll see
+lines like "set this variable to that value to do this". Well, you
+use the "set" command to do that.
+
+:entry "set-mark" "Command"
+This sets the mark at the current position in the buffer. It prints
+the message "Point pushed" on the message line. It says that instead
+of "Mark set" because when you set the mark the previous mark is still
+remembered on a ring of 16 marks. So "Point pushed" means point is
+pushed onto the ring of marks and becomes the value of "the mark". To
+go through the ring of marks you type "C-U C-@", or execute the "pop-
+mark" command. If you type this enough times you will get back to
+where you started.
+
+:entry "shell" "Variable"
+The shell to be used with all the shell commands command. If your
+SHELL environment variable is set, it is used as the value of "shell;"
+otherwise "/bin/csh" is the default.
+
+:entry "shell" "Command"
+This starts up an interactive shell in a window. JOVE uses "*shell*"
+as the name of the buffer in which the interacting takes place. See
+the manual for information on how to use interactive processes.
+
+:entry "shell-command" "Command"
+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, except
+that 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 "shell-command-to-buffer," and
+try again.
+
+:entry "shell-command-no-buffer" "Command"
+This is just like "shell-command" except it just runs the command
+without saving the output to any buffer. It will report the success
+of the command in the usual way.
+
+:entry "shell-command-to-buffer" "Command"
+This is just like "shell-command" except it lets you specify the
+buffer to use instead of JOVE.
+
+:entry "shell-command-with-typeout" "Command"
+This is just like "shell-command" except that instead of saving the
+output to a buffer, and displaying it in a window, this just types out
+the output in the same way that "list-buffers" does. Actually, how
+this behaves depends on the value of the variable "send-typeout-to-
+buffer." If it is on then shell-command-with-typeout will behave just
+like "shell-command."
+
+:entry "shell-flags" "Variable"
+This defines the flags that are passed to shell commands. The default
+is "-c". See the "shell" variable to change the default shell.
+
+:entry "shift-region-left" "Command"
+This shifts the region left by c-indentation-increment OR by the
+numeric argument, if one is supplied. If a negative argument is
+supplied the region is shifted the other way.
+
+:entry "shift-region-right" "Command"
+This shifts the region left by c-indentation-increment OR by the
+numeric argument, if one is supplied. If a negative argument is
+supplied the region is shifted the other way.
+
+:entry "show-match-mode" "Command"
+This turns on Show Match mode (or off if it's currently on) in the
+selected buffer. This changes "}", ")" and "]" so that when they are
+typed the 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 "paren-flash-delay" variable in
+tenths of a second. If the matching "{", "(" or "[" isn't visible,
+the line containing the match is displayed at the bottom of the
+screen.
+
+:entry "shrink-window" "Command"
+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.
+
+:entry "source" "Command"
+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 ".joverc")
+in your main directory. There should be one command per line and it
+should be as though you typed "ESC X" while in JOVE. For example,
+here's part of my initialization file:
+
+ bind-to-key i-search-reverse ^R
+ bind-to-key i-search-forward ^S
+ bind-to-key pause-jove ^[S
+
+What they do is make "C-R" call the "i-search-reverse" command and
+"C-S" call "i-search-forward" and "ESC S" call "pause-jove."
+
+:entry "spell-buffer" "Command"
+This runs the current buffer through the UNIX "spell" program and
+places the output in buffer "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 "parse-
+spelling-errors-in-buffer" command comes along and finds all the
+misspelled words and sets things up so the error commands work.
+
+:entry "split-current-window" "Command"
+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 "C-X 1" to go back to 1 window mode. If
+a numeric argument is supplied, the window is split "evenly" that many
+times (when possible).
+
+:entry "start-remembering" "Command"
+This is just another name for the "begin-kbd-macro" name. It is
+included for backward compatibility.
+
+:entry "stop-process" "Command"
+This sends a stop signal (C-Z, for most people) to the current
+process. It only works if you have the interactive process feature,
+and you are in a buffer attached to a process.
+
+:entry "stop-remembering" "Command"
+This is just another name for the "end-kbd-macro" command. It is
+included for backward compatibility.
+
+:entry "string-length" "Command"
+This prints the number of characters in the string that point sits in.
+Strings are surrounded by double quotes. JOVE knows that "\007" is
+considered a single character, namely "C-G", and also knows about
+other common ones, like "\r" (Return) and "\n" (LineFeed). This is
+mostly useful only for C programmers.
+
+:entry "suspend-jove" "Command"
+This is a synonym for "pause-jove."
+
+:entry "sync-frequency" "Variable"
+The temporary files used by JOVE are forced out to disk every "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.
+
+:entry "tag-file" "Variable"
+This the name of the file in which JOVE should look up tag
+definitions. The default value is "./tags".
+
+:entry "text-mode" "Command"
+This sets the major mode to Text. Currently the other modes are
+Fundamental, C and Lisp mode.
+
+:entry "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 /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 /tmp because the system removes all the files in
+/tmp upon reboot, and so you would not be able to recover editor
+buffers using the "jove -r" command.
+
+NOTE: In order for this to work correctly you must set this variable
+BEFORE JOVE creates the tmp file. You can set this in your .joverc
+(the closer to tbe beginning the better), or as soon as you start up
+JOVE before you visit any files.
+
+:entry "transpose-characters" "Command"
+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 "C-T" to drag a
+character down the length of a line. This command pretty quickly
+becomes very useful.
+
+:entry "transpose-lines" "Command"
+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, like "transpose-characters," can be used to drag a line down a
+page.
+
+:entry "unbind-key" "Command"
+Use this to unbind "any" key sequence. You can use this to unbind
+even a prefix command, since this command does not use "key-map
+completion". For example, "ESC X unbind-key ESC [" unbinds the
+sequence "ESC [". This is useful for "turning off" something set in
+the system-wide ".joverc" file.
+
+:entry "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.
+
+:entry "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. WARNING: if
+you set this to "on" when your terminal doesn't have insert/delete
+character capability, you will get weird (perhaps fatal) results.
+
+:entry "version" "Command"
+Displays the version number of this JOVE.
+
+:entry "visible-bell" "Variable"
+Use the terminal's visible bell instead of beeping. This is set
+automatically if your terminal has the capability.
+
+:entry "visible-spaces-in-window" "Command"
+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.
+
+:entry "visit-file" "Command"
+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 "NO" to the question.
+
+:entry "window-find" "Command"
+This lets you select another buffer in another window three different
+ways. This waits for another character which can be one of the
+following:
+
+ T Finds a tag in the other window.
+ ^T Finds the tag at point in the other window
+ F Finds a file in the other window.
+ B Selects a buffer in the other window.
+
+This is just a convenient short hand for "C-X 2" (or "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 "C-X 2" or "C-X O" since "C-X 4" does the right
+thing.
+
+:entry "word-abbrev-mode" "Command"
+This turns on Word Abbrev mode (or off if it's currently on) in the
+selected buffer. 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" => "their" or "teh" => "the". See the
+information on the "auto-case-abbrev" variable.
+
+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. JOVE tries to expand words as they are
+typed, when you type a punctuation character or Space or Return. If
+you are in Auto Fill mode the expansion will be filled as if you typed
+it yourself.
+
+:entry "wrap-search" "Variable"
+If set, searches will "wrap around" the ends of the buffer instead of
+stopping at the bottom or top. The default is "off".
+
+:entry "write-file" "Command"
+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.
+
+:entry "write-files-on-make" "Variable"
+When set, all modified files will be written out before calling make
+when the "compile-it" command is executed. The default is "on".
+
+:entry "write-macros-to-file" "Command"
+This writes the currently defined macros to a specified file in a
+format appropriate for reading them back in with the "source" command.
+The purpose of this command is to allow you to define macros once and
+use them in other instances of JOVE.
+
+:entry "write-modified-files" "Command"
+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.
+
+:entry "write-region" "Command"
+This writes the text in the region to a specified file. If the file
+already exists you are asked to confirm over-writing it.
+
+:entry "write-word-abbrev-file" "Command"
+This writes the currently defined abbreviations to a specified file.
+They can be read back in and automatically defined with "read-word-
+abbrev-file."
+
+:entry "xterm-mouse" "Command"
+This function enables the use of the mouse with \S-2JOVE\fP in an
+xterm window. The function is enabled when 'ansi-codes' is defined and
+the function is bound to <escape><open-square-bracket>M. Moving the
+mouse and pressing the left button will set the point to the mouse
+position and push it. Moving the mouse and pressing the right button
+will set the point to the mouse position and yank the region from the
+last mark and the current point. Moving the mouse and pressing the
+middle button will set the point to the mouse position and paste the
+contents of the mouse button in place. Note that this in a
+\s-2JOVE\fP function and is independent of the normal cut and paste
+operations available under xterm. It is possible to bind these
+operations to SHIFT+the mouse button, so that they will work in
+addition to \s-2JOVE\fP cut and paste.
+
+:entry "yank" "Command"
+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 "C-Y" yanks back all of them.
+
+:entry "yank-pop" "Command"
+This yanks back previous killed text. JOVE has a kill ring on which
+the last 10 kills are stored. "yank" yanks a copy of the text at the
+front of the ring. If you want one of the last ten kills you use "ESC
+Y" which rotates the ring so another different entry is now at the
+front. You can use "ESC Y" only immediately following a "C-Y" or
+another "ESC Y". If you supply a negative numeric 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.
projects / unix-history / commitdiff