cmds.doc

早期freebsd实现

Alphabetical List of Commands and Variables

:entry "abort-char" "Variable"
This variable defines JOVE'S abort characer.  When the abort character
is typed, the current JOVE command is aborted.  The default value is
C-G.

:entry "add-lisp-special" "Command"
This command is to tell JOVE 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.

:entry "allow-^S-and-^Q" "Variable"
This variable, when set, tells JOVE 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.

:entry "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".

:entry "append-region" "Command"
This appends the region to a specified file.  If the file does not
already exist it is created.

:entry "apropos" "Command"
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

     ESC X apropos window<Return>


:entry "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.

:entry "auto-execute-command" "Command"
This tells JOVE 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

     ESC X auto-execute-command show-match-mode .*.[ch]$


:entry "auto-execute-macro" "Command"
This is like "auto-execute-command" except you use it to execute
macros automatically instead of built-in commands.

:entry "auto-fill-mode" "Command"
This turns on Auto Fill mode (or off if it's currently on) in the
selected buffer.  When JOVE 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.  JOVE uses 78 as the right margin but you
can change that by setting the variable "right-margin" to another
value.  See the "set" command to learn how to do this.

:entry "auto-indent-mode" "Command"
This turns on Auto Indent mode (or off if it's currently on) in the
selected buffer.  When JOVE 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 "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.

:entry "background-color" "Variable"
This specifies the background color of the screen (PC version only).
The default value is 0, which stands for black.

:entry "backward-character" "Command"
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.

:entry "backward-list" "Command"
This moves backward over a list as opposed to an s-expression.  The
difference between this and "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.

:entry "backward-paragraph" "Command"
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 JOVE allows the first line of a
paragraph to be indented differently from the other lines.

:entry "backward-s-expression" "Command"
This moves point backward over a s-expression.  It is just like
"forward-s-expression" with a negative argument.

:entry "backward-sentence" "Command"
This moves point backward to the beginning of the current or previous
sentence.  JOVE considers the end of a sentence to be the characters
".", "!" or "?" followed by a Return or by one or more spaces.

:entry "backward-up-list" "Command"
This is similar to "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.

:entry "backward-word" "Command"
This moves point backward to the beginning of the current or previous
word.

:entry "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.

:entry "begin-kbd-macro" "Command"
This starts defining the keyboard macro by remembering all your key
strokes until you execute "end-kbd-macro," by typing "C-X )".  Because
of a bug in JOVE you shouldn't terminate the macro by typing "ESC X
end-kbd-macro"; "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 "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 "make-macro-interactive" command.

:entry "beginning-of-file" "Command"
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 JOVE will set the mark so you can go back to where
you were if you want.

:entry "beginning-of-line" "Command"
This moves point to the beginning of the current line.

:entry "beginning-of-window" "Command"
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.

:entry "bind-keymap-to-key" "Command"
This is the way to build nested keymaps.  For example, when JOVE
starts up, internally it does a

     bind-keymap-to-key ESC-map ^[

To make the arrow keys on vt100's work, you would do the following.

     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

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.

:entry "bind-macro-to-key" "Command"
This is like "bind-to-key" except you use it to attach keys to named
macros.

:entry "bind-macro-to-word-abbrev" "Command"
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).

:entry "bind-to-key" "Command"
This attaches a key to an internal JOVE 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".

:entry "buffer-position" "Command"
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.

:entry "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:
                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));

:entry "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.

:entry "c-mode" "Command"
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 JOVE, the "right" place is simply the way the author
likes it (but I've got good taste).

:entry "case-character-capitalize" "Command"
This capitalizes the character after point, i.e., the character under
the cursor.  If a negative argument is supplied that many characters
"before" point are upper cased.

:entry "case-ignore-search" "Variable"
This variable, when set, tells JOVE 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".

:entry "case-region-lower" "Command"
This changes all the upper case letters in the region to their lower
case equivalent.

:entry "case-region-upper" "Command"
This changes all the lower case letters in the region to their upper
case equivalent.

:entry "case-word-capitalize" "Command"
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 "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.

:entry "case-word-lower" "Command"
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
"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.

:entry "case-word-upper" "Command"
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
"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.

:entry "cd" "Command"
This changes the current directory.

:entry "character-to-octal-insert" "Command"