jove.4

早期freebsd实现

.bp
.NH 1
Alphabetical List of Commands and Variables
.dc "abort-char" "(variable)"
This variable defines \s-2JOVE'S\s0 abort characer.  When the abort
character is typed, the current \s-2JOVE\s0 command is aborted.  The
default value is C-G.
.dc "add-lisp-special" "Not Bound"
This command is to tell \s-2JOVE\s0 what identifiers require special
indentation in lisp mode.  Lisp functions like defun and let are two of
the default functions that get treated specially.  This is just a kludge
to define some of your own.  It prompts for the function name.
.dc "allow-^S-and-^Q" "(variable)"
This variable, when set, tells \s-2JOVE\s0 that your terminal does not need
to use the characters C-S and C-Q for flow control, and that it is
okay to bind things to them.  This variable should be set depending
upon what kind of terminal you have.
.dc "allow-bad-filenames" "(variable)"
If set, this variable permits filenames to contain "bad" characters
such as those from the set *&%!"`[]{}.  These files are harder to deal
with, because the characters mean something to the shell.  The default
value is "off".
.dc "append-region" "Not Bound"
This appends the region to a specified file.  If the file does not
already exist it is created.
.dc "apropos" "Not Bound"
This types out all the commands, variables and macros with the specific
keyword in their names.  For each command and macro that contains the
string, the key sequence that can be used to execute the command or macro is
printed; with variables, the current value is printed.  So, to find all the
commands that are related to windows, you type
.DS
ESC X apropos window<Return>
.DE
.dc "auto-case-abbrev" "(variable)"
When this variable is on (the default), word abbreviations are adjusted for
case automatically.  For example, if "jove" were the abbreviation for
"jonathan's own version of emacs", then typing "jove" would give you
"jonathan's own version of emacs", typing "Jove" would give you "Jonathan's
own version of emacs", and typing "JOVE" would give you "Jonathan's Own
Version of Emacs".  When this variable is "off", upper and lower case are
distinguished when looking for the abbreviation, i.e., in the example above,
"JOVE" and "Jove" would not be expanded unless they were defined separately.
.dc "auto-execute-command" "Not Bound"
This tells \s-2JOVE\s0 to execute a command automatically when a file whose
name matches a specified pattern is visited.  The first argument is the
command you want executed and the second is a regular expression
pattern that specifies the files that apply.  For example, if you want
to be in show-match-mode when you edit C source files (that is, files
that end with ".c" or ".h") you can type
.ID
ESC X auto-execute-command show-match-mode .*\.[ch]$
.DE
.dc "auto-execute-macro" "Not Bound"
This is like
.IQ auto-execute-command
except you use it to execute macros
automatically instead of built-in commands.
.dc "auto-fill-mode" "Not Bound"
This turns on Auto Fill mode (or off if it's currently on) in the
selected buffer.  When \s-2JOVE\s0 is in Auto Fill mode it automatically
breaks lines for you when you reach the right margin so you don't have
to remember to hit Return.  \s-2JOVE\s0 uses 78 as the right margin but you
can change that by setting the variable
.IQ right-margin
to another
value.  See the
.IQ set
command to learn how to do this.
.dc "auto-indent-mode" "Not Bound"
This turns on Auto Indent mode (or off if it's currently on) in the
selected buffer.  When \s-2JOVE\s0 is in Auto Indent mode, Return indents the
new line to the same position as the line you were just on.  This is
useful for lining up C code (or any other language (but what else is
there besides C?)).  This is out of date because of the new command
called
.IQ newline-and-indent
but it remains because of several
"requests" on the part of, uh, enthusiastic and excitable users, that
it be left as it is.
.dc "background-color" "(variable)"
This specifies the background color of the screen (PC version only).  The
default value is 0, which stands for black.
.dc "backward-character" "C-B"
This moves point backward over a single character.  If point is at the
beginning of the line it moves to the end of the previous line.
.dc "backward-list" "ESC C-P"
This moves backward over a list as opposed to an s-expression.  The
difference between this and
.IQ backward-s-expression
is that this first searchs for a ")" and then moves to the matching "(".
This is useful when you're trying to find unmatched parens in a program.
.dc "backward-paragraph" "ESC ["
This moves point backward to the beginning of the current or previous
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 \s-2JOVE\s0 allows the first line of a paragraph
to be indented differently from the other lines.
.dc "backward-s-expression" "ESC C-B"
This moves point backward over a s-expression.  It is just like
.IQ forward-s-expression
with a negative argument.
.dc "backward-sentence" "ESC A"
This moves point backward to the beginning of the current or previous
sentence.  \s-2JOVE\s0 considers the end of a sentence to be the characters
".", "!" or "?" followed by a Return or by one or more spaces.
.dc "backward-up-list" "ESC C-U"
This is similar to
.IQ backward-s-expression
except it backs up and OUT of the enclosing s-expression.  In other
words, it moves backward to the "(" that would match a ")" if you were to
type it right then.
.dc "backward-word" "ESC B"
This moves point backward to the beginning of the current or previous
word.
.dc "bad-filename-extensions" "(variable)"
This contains a list of words separated by spaces which are to be
considered bad filename extensions, and so will not be counted in
filename completion.  The default is ".o" so if you have jove.c and
jove.o in the same directory, the filename completion will not complain
of an ambiguity because it will ignore jove.o.
.dc "begin-kbd-macro" "C-X ("
This starts defining the keyboard macro by remembering all your key
strokes until you execute
.IQ end-kbd-macro,
by typing "C-X )".  Because of a bug in \s-2JOVE\s0 you shouldn't
terminate the macro by typing "ESC X end-kbd-macro";
.IQ end-kbd-macro
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-kbd-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 "beginning-of-file" "ESC <"
This moves point backward to the beginning of the buffer.  This sometimes
prints the "Point Pushed" message.  If the top 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 "beginning-of-line" "C-A"
This moves point to the beginning of the current line.
.dc "beginning-of-window" "ESC ,"
This moves point to the beginning of the current window.  The sequence
"ESC ," is the same as "ESC <" (beginning of file) except without the shift
key on the "<", and can thus can easily be remembered.
.dc "bind-keymap-to-key" "Not Bound"
This is the way to build nested keymaps.  For example, when \s-2JOVE \s0
starts up, internally it does a
.ID
bind-keymap-to-key ESC-map ^[
.DE
To make the arrow keys on vt100's work, you would do the following.
.ID
.nf
make-keymap vt100-map
bind-keymap-to-key vt100-map ^[[
bind-to-key next-line ^[[A
bind-to-key previous-line ^[[B
bind-to-key forward-character ^[[C
bind-to-key backward-character ^[[D
.fi
.DE
I may have gotten the escape sequences wrong, but you get the general
idea.  Theoretically you can use these keymaps to bind arbitrarily long
key sequences, like those generated by the SUN keyboards, but that is a
bit of a pain because you will have to generate a bunch of keymaps by
hand, almost one per key, because of the way the key sequences are
organized.  Eventually there will be a more general way to have these
keymaps built for you.
.dc "bind-macro-to-key" "Not Bound"
This is like
.IQ bind-to-key
except you use it to attach keys to named macros.
.dc "bind-macro-to-word-abbrev" "Not Bound"
This command allows you to bind a macro to a previously defined word
abbreviation.  Whenever you type the abbreviation, it will first be expanded
as an abbreviation, and then the macro will be executed.  Note that if the
macro moves around, you should set the mark first (C-@) and then exchange
the point and mark last (C-X C-X).
.dc "bind-to-key" "Not Bound"
This attaches a key to an internal \s-2JOVE\s0 command so that future hits on
that key invoke that command.  For example, to make "C-W" erase the
previous word, you type "ESC X bind-to-key kill-previous-word C-W".
.dc "buffer-position" "Not Bound"
This displays the current file name, current line number, total number
of lines, percentage of the way through the file, and the position of
the cursor in the current line.
.dc "c-argument-indentation" "(variable)"
This variable describes how to indent lines which are part of nested
expressions in C.  The default is -1, which means to indent a continued
line by lining it up with the first argument of the current expression.
Otherwise, the line will be indented by c-argument-indentation characters
past the indent of the first line of the expression.  For example, the
default value produces:
.nf
		Typeout(fmt, itoa(bcount++), line_cnt(b, nbuf),
			TypeNames[b->b_type],
			IsModified(b) ? "*" : b->b_ntbf ? "+" : NullStr,
			buf_width, b->b_name, filename(b));
.fi
.dc "c-indentation-increment" "(variable)"
This defines a set of tabstops independent of the value of
internal-tabstops and physical-tabstops.  This value will be used in C
mode, and JOVE will insert the correct number of spaces and Tabs to get
the right behavior.  For programmers that like to indent with 4 spaces,
set this value to 4.  Don't set internal-tabstops to 4 because that will
not work anymore.  Setting internal-tabstops to 4 tells JOVE to display
Tabs as every 4 spaces.  This will cause your programs to look terrible
with anyone else who displays the file with normal tabstops at every 8
characters.  Not to mention printing your program won't look right.  But
all that aside, if you set c-indentation-increment to 8 (the default),
and then set internal-tabstops to 4 as well, JOVE will insert TWO Tabs to
get the indentation to 8, which is clearly not what you want.
.dc "c-mode" "Not Bound"
This turns on C mode in the currently selected buffer.  This is one of
currently four possible major modes:  Fundamental, Text, C, Lisp.
When in C or Lisp mode, Tab, "}", and ")" behave a little differently
from usual: They are indented to the "right" place for C (or Lisp)
programs.  In \s-2JOVE\s0, the "right" place is simply the way the author
likes it (but I've got good taste).
.dc "case-character-capitalize" "Not Bound"
This capitalizes the character after point, i.e., the character under
the cursor.  If a negative argument is supplied that many characters
.IQ before
point are upper cased.
.dc "case-ignore-search" "(variable)"
This variable, when set, tells \s-2JOVE\s0 to treat upper and lower case as
the same when searching.  Thus "jove" and "JOVE" would match, and
"JoVe" would match either.  The default value of this variable is "off".
.dc "case-region-lower" "Not Bound"
This changes all the upper case letters in the region to their lower
case equivalent.
.dc "case-region-upper" "Not Bound"
This changes all the lower case letters in the region to their upper
case equivalent.
.dc "case-word-capitalize" "ESC C"
This capitalizes the current word by making the current letter upper
case and making the rest of the word lower case.  Point is moved to
the end of the word.  If point is not positioned on a word it is first
moved forward to the beginning of the next word.  If a negative
argument is supplied that many words
.IQ before
point are capitalized.
This is useful for correcting the word just typed without having to
move point to the beginning of the word yourself.
.dc "case-word-lower" "ESC L"
This lower-cases the current word and leaves point at the end of it.
If point is in the middle of a word the rest of the word is
converted.  If point is not in a word it is first moved forward to the
beginning of the next word.  If a negative argument is supplied that
many words
.IQ before
point are converted to lower case.  This is useful
for correcting the word just typed without having to move point to the
beginning of the word yourself.
.dc "case-word-upper" "ESC U"
This upper-cases the current word and leaves point at the end of it.
If point is in the middle of a word the rest of the word is
converted.  If point is not in a word it is first moved forward to the
beginning of the next word.  If a negative argument is supplied that
many words
.IQ before
point are converted to upper case.  This is useful
for correcting the word just typed without having to move point to the
beginning of the word yourself.
.dc "cd" "Not Bound"
This changes the current directory.
.dc "character-to-octal-insert" "Not Bound"
This inserts a Back-slash followed by the ascii value of the next
character typed.  For example, "C-G" inserts the string "\e007".
.dc "clear-and-redraw" "ESC C-L"
This clears the entire screen and redraws all the windows.  Use this
when \s-2JOVE\s0 gets confused about what's on the screen, or when the screen
gets filled with garbage characters or output from another program.
.dc "comment-format" "(variable)"
This variable tells \s-2JOVE\s0 how to format your comments when you run the
command
.IQ fill-comment.
Its format is this:
.ID
<open pattern>%!<line header>%c<line trailer>%!<close pattern>
.DE
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
.IQ fill-comment
for more.
.dc "compile-it" "C-X C-E"
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
.IQ parse-errors
command.  To compile a C program without "make", use "C-U C-X C-E" and
\s-2JOVE\s0 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
.IQ error-format-string
to make it possible to parse errors of a different format.
.dc "continue-process" "Not Bound"
This sends SIGCONT to the current interactive process,
.IQ if
the process