cmds.doc

早期freebsd实现

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