cmds.doc

早期freebsd实现

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"