jove.4

早期freebsd实现

to see how to
save macros.
.dc "redraw-display" "C-L"
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.
.dc "recursive-edit" "Not Bound"
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.
.dc "rename-buffer" "Not Bound"
This lets you rename the current buffer.
.dc "replace-in-region" "Not Bound"
This is the same as
.IQ replace-string
except that it is restricted
to occurrences between Point and Mark.
.dc "replace-string" "ESC R"
This replaces all occurrences of a specified string with a specified
replacement string.  This is just like
.IQ query-replace-string
except
it replaces without asking.
.dc "right-margin" "(variable)"
Where the right margin is for
.IQ "Auto Fill"
mode and the
.IQ justify-paragraph
and
.IQ justify-region
commands.  The default is 78.
.dc "right-margin-here" "Not Bound"
This sets the
.IQ 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.
.dc "save-file" "C-X C-S"
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
.IQ 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
.IQ write-file.
.dc "scroll-down" "ESC Z"
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.
.dc "scroll-step" "(variable)"
How many lines should be scrolled if the
.IQ previous-line
or
.IQ 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.
.dc "scroll-up" "C-Z"
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.
.dc "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.
.dc "search-forward" "C-S"
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.
.dc "search-reverse" "C-R"
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.
.dc "select-buffer" "C-X B"
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.
.dc "self-insert" "Most Printing Characters"
This inserts the character that invoked it into the buffer at point.
Initially all but a few of the printing characters are bound to
.IQ self-insert.
.dc "send-typeout-to-buffer" "(variable)"
When this is set \s-2JOVE\s0 will send output that normally overwrites the
screen (temporarily) to a buffer instead.  This affects commands like
.IQ list-buffers,
.IQ list-processes,
and other commands that use command
completion.  The default value is "off".
.dc "set" "Not Bound"
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
.IQ set
command to do that.
.dc "set-mark" "C-@"
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
.IQ pop-mark
command.  If you type this enough times you will get back
to where you started.
.dc "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
.IQ shell;
otherwise "/bin/csh" is the default.
.dc "shell-command" "C-X !"
This runs a UNIX command and places the output from that command in a
buffer.  \s-2JOVE\s0 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 \s-2JOVE\s0 to split the
window and attach the new buffer to that window.  Otherwise, \s-2JOVE\s0
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, \s-2JOVE\s0
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
.IQ shell-command-to-buffer,
and
try again.
.dc "shell-command-to-buffer" "Not Bound"
This is just like
.IQ shell-command
except it lets you specify the
buffer to use instead of \s-2JOVE\s0.
.dc "shell-flags" "(variable)"
This defines the flags that are passed to shell commands.  The default is
"-c".  See the
.IQ shell
variable to change the default shell.
.dc "show-match-mode" "Not Bound"
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 nothing happens.
.dc "shrink-window" "Not Bound"
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.
.dc "source" "Not Bound"
This reads a bunch of \s-2JOVE\s0 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 \s-2JOVE\s0.  For example,
here's part of my initialization file:
.DS I
bind-to-key i-search-reverse ^R
bind-to-key i-search-forward ^S
bind-to-key pause-jove ^[S
.DE
What they do is make "C-R" call the
.IQ i-search-reverse
command and
"C-S" call
.IQ i-search-forward
and "ESC S" call
.IQ pause-jove.
.dc "spell-buffer" "Not Bound"
This runs the current buffer through the UNIX
.IQ spell
program and places
the output in buffer "Spell".  Then \s-2JOVE\s0 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
.IQ parse-spelling-errors-in-buffer
command comes along and finds all the
misspelled words and sets things up so the error commands work.
.dc "split-current-window" "C-X 2"
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.
.dc "start-remembering" "C-X ("
This starts remembering your key strokes in the Keyboard macro.  To
stop remembering you type "C-X )".  Because of a bug in \s-2JOVE\s0 you can't
stop remembering by typing "ESC X stop-remembering";
.IQ stop-remembering
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
.IQ execute-keyboard-macro
command.
Sometimes you may want a macro to accept different input each time it runs.
To see how to do this, see the
.IQ make-macro-interactive
command.
.dc "stop-process" "Not Bound"
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.
.dc "stop-remembering" "C-X )"
This stop the definition of the keyboard macro.  Because of a bug in
\s-2JOVE\s0, this must be bound to "C-X )".  Anything else will not work
properly.
.dc "string-length" "Not Bound"
This prints the number of characters in the string that point sits in.
Strings are surrounded by double quotes.  \s-2JOVE\s0 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.
.dc "suspend-jove" "ESC S"
This is a synonym for
.IQ pause-jove.
.dc "sync-frequency" "(variable)"
The temporary files used by \s-2JOVE\s0 are forced out to disk every
.IQ 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.
.dc "tag-file" "(variable)"
This the name of the file in which \s-2JOVE\s0 should look up tag
definitions.  The default value is "./tags".
.dc "text-mode" "Not Bound"
This sets the major mode to Text.  Currently the other modes are
Fundamental, C and Lisp mode.
.dc "transpose-characters" "C-T"
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.
.dc "transpose-lines" "C-X C-T"
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
.IQ transpose-characters,
can be used to drag a line down a page.
.dc "unbind-key" "Not Bound"
Use this to unbind
.IQ 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.
.dc "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.
.dc "use-i/d-char" "(variable)"
If your terminal has insert/delete character capability you can tell \s-2JOVE\s0
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.
.dc "version" "Not Bound"
Displays the version number of this \s-2JOVE\s0.
.dc "visible-bell" "(variable)"
Use the terminal's visible bell instead of beeping.  This is set
automatically if your terminal has the capability.
.dc "visible-spaces-in-window" "Not Bound"
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