cmds.doc

早期freebsd实现

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