jove.4

早期freebsd实现

is currently stopped.
.dc "copy-region" "ESC W"
This takes all the text in the region and copies it onto the kill ring
buffer.  This is just like running
.IQ kill-region
followed by the
.IQ yank
command.  See the
.IQ kill-region
and
.IQ yank
commands.
.dc "current-error" "Not Bound"
This moves to the current error in the list of parsed errors.  See the
.IQ next-error
and
.IQ previous-error
commands for more detailed
information.
.dc "date" "Not Bound"
This prints the date on the message line.
.dc "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.
.dc "define-global-word-abbrev" "Not Bound"
This defines a global abbreviation.
.dc "define-macro" "Not Bound"
This provides a different mechanism for defining keyboard macros.
Instead of gathering keystrokes and storing them into the
"keyboard-macro" (which is how
.IQ start-kbd-macro
works),
.IQ 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
.IQ 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 "\e^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
.IQ write-macros-to-file
to see how to save macros.
.dc "define-mode-word-abbrev" "Not Bound"
This defines a mode-specific abbreviation.
.dc "delete-blank-lines" "C-X C-O"
This deletes all the blank lines around point.  This is useful when you
previously opened many lines with "C-O" and now wish to delete the
unused ones.
.dc "delete-buffer" "C-X K"
This deletes a buffer and frees up all the memory associated with it.  Be
careful(!) - once a buffer has been deleted it is gone forever.  \s-2JOVE\s0
will ask you to confirm if you try to delete a buffer that needs saving.
This command is useful for when \s-2JOVE\s0 runs out of space to store
new buffers.
.dc "delete-current-window" "C-X D"
This deletes the current window and moves point into one of the
remaining ones.  It is an error to try to delete the only remaining
window.
.dc "delete-macro" "Not Bound"
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.
.dc "delete-next-character" "C-D"
This deletes the character that's just after point (that is, the
character under the cursor).  If point is at the end of a line, the
line separator is deleted and the next line is joined with the current
one.
.dc "delete-other-windows" "C-X 1"
This deletes all the other windows except the current one.  This can be
thought of as going back into One Window mode.
.dc "delete-previous-character" "DEL"
This deletes the character that's just before point (that is, the
character before the cursor).  If point is at the beginning of the
line, the line separator is deleted and that line is joined with the
previous one.
.dc "delete-white-space" "ESC \e"
This deletes all the Tabs and Spaces around point.
.dc "describe-bindings" "Not Bound"
This types out a list containing each bound key and the command that gets
invoked every time that key is typed.  To make a wall chart of \s-2JOVE\s0
commands, set
.IQ send-typeout-to-buffer
to "on" and \s-2JOVE\s0 will
store the key bindings in a buffer which you can save to a file and then
print.
.dc "describe-command" "Not Bound"
This prints some info on a specified command.
.dc "describe-key" "Not Bound"
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
.IQ describe-command
command
to find out exactly what it does.
.dc "describe-variable" "Not Bound"
This prints some info on a specified variable.
.dc "digit" "ESC [0-9]"
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.
.dc "digit-1" "Not Bound"
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.
.dc "digit-2" "Not Bound"
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.
.dc "digit-3" "Not Bound"
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.
.dc "digit-4" "Not Bound"
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.
.dc "digit-5" "Not Bound"
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.
.dc "digit-6" "Not Bound"
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.
.dc "digit-7" "Not Bound"
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.
.dc "digit-8" "Not Bound"
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.
.dc "digit-9" "Not Bound"
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.
.dc "digit-0" "Not Bound"
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.
.dc "dirs" "Not Bound"
This prints out the directory stack.  See the "cd", "pushd", "popd"
commands for more info.
.dc "disable-biff" "(variable)"
When this is set, \s-2JOVE\s0 disables biff when you're editing and enables it
again when you get out of \s-2JOVE\s0, 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".
.dc "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
.IQ bad-filename-extensions
will be displayed with an "!" in front of their names.  When
.IQ display-bad-filenames
is OFF the files will not be displayed at all.  The default value is on.
.dc "down-list" "ESC C-D"
This is the opposite of
.IQ 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.
.dc "dstop-process" "Not Bound"
Send the "dsusp" character to the current process.  This is the
character that suspends a process on the next read from the
terminal.  Most people have it set to C-Y.  This only works if
you have the interactive process feature, and if you are in a
buffer bound to a process.
.dc "edit-word-abbrevs" "Not Bound"
This creates a buffer with a list of each abbreviation and the phrase
it expands into, and enters a recursive edit to let you change the
abbreviations or add some more.  The format of this list is
"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.
.dc "end-kbd-macro" "C-X )"
This stops the definition of the keyboard macro.  Because of a bug in
\s-2JOVE\s0, this must be bound to "C-X )", or some key sequence which is
one or two characters long.  Anything else will not work properly.
.dc "end-of-file" "ESC >"
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 \s-2JOVE\s0 will set the mark so you can go back to where you were
if you want.
.dc "end-of-line" "C-E"
This moves point to the end of the current line.  If the line is too
long to fit on the screen \s-2JOVE\s0 will scroll the line to the left to
make the end of the line visible.  The line will slide back to its
normal position when you move backward past the leftmost visible character
or when you move off the line altogether.
.dc "end-of-window" "ESC ."
This moves point to the last character in the window.
.dc "eof-process" "Not Bound"
Sends EOF to the current interactive process.  This only works on
versions of \s-2JOVE\s0 running under versions of UNIX with pty's.
.dc "erase-buffer" "Not Bound"
This erases the contents of the specified buffer.  This is like
.IQ 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.
.dc "error-format-string" "(variable)"
This is the error format string that is used by
.IQ parse-errors
to find the error messages in a buffer.  The way it works is by using
this string as a \s-2JOVE\s0 regular expression search string, where the
\e('s and \e)'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:
.sp 1
	"file.c", line 540: missing semi-colon
.sp 1
For strings of this format, an appropriate value for
.IQ error-format-string
would be something like this:
.sp 1
	^"\e([^"]*\e)", line \e([0-9]*\e):
.sp 1
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.
.sp 1
If you do not know how to use regular expressions then this variable will
be hard for you to use.  Also note that you can look at the default
value of this variable by printing it out, but it is a really complicated
string because it is trying to accommodate the outputs of more than one
compiler at a time.
.dc "error-window-size" "(variable)"
This is the percentage of the screen to use for the error-window on the
screen.  When you execute
.IQ compile-it,
.IQ error-window-size
percent of the screen will go to the error window.  If the window already
exists and is a different size, it is made to be this size.  The default
value is 20%.
.dc "exchange-point-and-mark" "C-X C-X"
This moves point to mark and makes mark the old point.  This is for
quickly moving from one end of the region to another.
.dc "execute-kbd-macro" "C-X E"
This executes the keyboard macro.  If you supply a numeric argument the
macro is executed that many times.
.dc "execute-macro" "Not Bound"
This executes a specified macro.  If you supply a numeric argument the
macro is executed that many times.
.dc "execute-named-command" "ESC X"
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 \s-2JOVE\s0 will fill in the rest for you.  If you are
not sure of the name of the command, type "?" and \s-2JOVE\s0 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 \s-2JOVE\s0 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
.IQ bind-to-key
command.
.dc "exit-jove" "C-X C-C"
This exits \s-2JOVE\s0.  If any buffers need saving \s-2JOVE\s0 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
.IQ exit-jove
will return you from that.
.dc "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.
.dc "file-creation-mode" "(variable)"
This variable has an octal value.  It contains the mode (see
.IQ chmod(1)
) with which files should be created.  This mode gets modified by your
current umask setting (see
.IQ umask(1)