This is ../info/emacs, produced by makeinfo version 4.6 from emacs.texi.

INFO-DIR-SECTION The Emacs editor and associated tools
START-INFO-DIR-ENTRY
* Emacs: (emacs).		The extensible self-documenting text editor.
END-INFO-DIR-ENTRY


File: emacs,  Node: File Variables,  Prev: Locals,  Up: Variables

Local Variables in Files
------------------------

A file can specify local variable values for use when you edit the file
with Emacs.  Visiting the file checks for local variables
specifications; it automatically makes these variables local to the
buffer, and sets them to the values specified in the file.

   There are two ways to specify local variable values: in the first
line, or with a local variables list.  Here's how to specify them in the
first line:

     -*- mode: MODENAME; VAR: VALUE; ... -*-

You can specify any number of variables/value pairs in this way, each
pair with a colon and semicolon as shown above.  `mode: MODENAME;'
specifies the major mode; this should come first in the line.  The
VALUEs are not evaluated; they are used literally.  Here is an example
that specifies Lisp mode and sets two variables with numeric values:

     ;; -*-mode: Lisp; fill-column: 75; comment-column: 50; -*-

   A "local variables list" goes near the end of the file, in the last
page.  (It is often best to put it on a page by itself.)  The local
variables list starts with a line containing the string `Local
Variables:', and ends with a line containing the string `End:'.  In
between come the variable names and values, one set per line, as
`VARIABLE: VALUE'.  The VALUEs are not evaluated; they are used
literally.  If a file has both a local variables list and a `-*-' line,
Emacs processes _everything_ in the `-*-' line first, and _everything_
in the local variables list afterward.

   Here is an example of a local variables list:

     ;;; Local Variables: ***
     ;;; mode:lisp ***
     ;;; comment-column:0 ***
     ;;; comment-start: ";;; "  ***
     ;;; comment-end:"***" ***
     ;;; End: ***

   As you see, each line starts with the prefix `;;; ' and each line
ends with the suffix ` ***'.  Emacs recognizes these as the prefix and
suffix based on the first line of the list, by finding them surrounding
the magic string `Local Variables:'; then it automatically discards
them from the other lines of the list.

   The usual reason for using a prefix and/or suffix is to embed the
local variables list in a comment, so it won't confuse other programs
that the file is intended as input for.  The example above is for a
language where comment lines start with `;;; ' and end with `***'; the
local values for `comment-start' and `comment-end' customize the rest
of Emacs for this unusual syntax.  Don't use a prefix (or a suffix) if
you don't need one.

   Two "variable names" have special meanings in a local variables
list: a value for the variable `mode' really sets the major mode, and a
value for the variable `eval' is simply evaluated as an expression and
the value is ignored.  `mode' and `eval' are not real variables;
setting variables named `mode' and `eval' in any other context has no
special meaning.  If `mode' is used to set a major mode, it should be
the first "variable" in the list.

   You can use the `mode' "variable" to set minor modes as well as
major modes; in fact, you can use it more than once, first to set the
major mode and then to set minor modes which are specific to particular
buffers.  But most minor modes should not be specified in the file in
any fashion, because they represent user preferences.  For example, you
should not try to specify Auto Fill mode with file local variables,
because whether to use Auto Fill mode for editing a particular kind of
text is a matter of personal taste, not an aspect of the format of the
text.

   The start of the local variables list must be no more than 3000
characters from the end of the file, and must be in the last page if the
file is divided into pages.  Otherwise, Emacs will not notice it is
there.  The purpose of this rule is so that a stray `Local Variables:'
not in the last page does not confuse Emacs, and so that visiting a
long file that is all one page and has no local variables list need not
take the time to search the whole file.

   You may be tempted to try to turn on Auto Fill mode with a local
variable list.  That is a mistake.  The choice of Auto Fill mode or not
is a matter of individual taste, not a matter of the contents of
particular files.  If you want to use Auto Fill, set up major mode
hooks with your `.emacs' file to turn it on (when appropriate) for you
alone (*note Init File::).  Don't try to use a local variable list that
would impose your taste on everyone.

   The variable `enable-local-variables' controls whether to process
local variables lists, and thus gives you a chance to override them.
Its default value is `t', which means do process local variables lists.
If you set the value to `nil', Emacs simply ignores local variables
lists.  Any other value says to query you about each local variables
list, showing you the local variables list to consider.

   The `eval' "variable", and certain actual variables, create a
special risk; when you visit someone else's file, local variable
specifications for these could affect your Emacs in arbitrary ways.
Therefore, the option `enable-local-eval' controls whether Emacs
processes `eval' variables, as well variables with names that end in
`-hook', `-hooks', `-function' or `-functions', and certain other
variables.  The three possibilities for the option's value are `t',
`nil', and anything else, just as for `enable-local-variables'.  The
default is `maybe', which is neither `t' nor `nil', so normally Emacs
does ask for confirmation about file settings for these variables.

   Use the command `normal-mode' to reset the local variables and major
mode of a buffer according to the file name and contents, including the
local variables list if any.  *Note Choosing Modes::.


File: emacs,  Node: Keyboard Macros,  Next: Key Bindings,  Prev: Variables,  Up: Customization

Keyboard Macros
===============

A "keyboard macro" is a command defined by the user to stand for
another sequence of keys.  For example, if you discover that you are
about to type `C-n C-d' forty times, you can speed your work by
defining a keyboard macro to do `C-n C-d' and calling it with a repeat
count of forty.

`C-x ('
     Start defining a keyboard macro (`start-kbd-macro').

`C-x )'
     End the definition of a keyboard macro (`end-kbd-macro').

`C-x e'
     Execute the most recent keyboard macro (`call-last-kbd-macro').

`C-u C-x ('
     Re-execute last keyboard macro, then add more keys to its
     definition.

`C-x q'
     When this point is reached during macro execution, ask for
     confirmation (`kbd-macro-query').

`M-x name-last-kbd-macro'
     Give a command name (for the duration of the session) to the most
     recently defined keyboard macro.

`M-x insert-kbd-macro'
     Insert in the buffer a keyboard macro's definition, as Lisp code.

`C-x C-k'
     Edit a previously defined keyboard macro (`edit-kbd-macro').

`M-x apply-macro-to-region-lines'
     Run the last keyboard macro on each complete line in the region.

   Keyboard macros differ from ordinary Emacs commands in that they are
written in the Emacs command language rather than in Lisp.  This makes
it easier for the novice to write them, and makes them more convenient
as temporary hacks.  However, the Emacs command language is not powerful
enough as a programming language to be useful for writing anything
intelligent or general.  For such things, Lisp must be used.

   You define a keyboard macro while executing the commands which are
the definition.  Put differently, as you define a keyboard macro, the
definition is being executed for the first time.  This way, you can see
what the effects of your commands are, so that you don't have to figure
them out in your head.  When you are finished, the keyboard macro is
defined and also has been, in effect, executed once.  You can then do
the whole thing over again by invoking the macro.

* Menu:

* Basic Kbd Macro::  Defining and running keyboard macros.
* Save Kbd Macro::   Giving keyboard macros names; saving them in files.
* Kbd Macro Query::  Keyboard macros that do different things each use.


File: emacs,  Node: Basic Kbd Macro,  Next: Save Kbd Macro,  Up: Keyboard Macros

Basic Use
---------

To start defining a keyboard macro, type the `C-x (' command
(`start-kbd-macro').  From then on, your keys continue to be executed,
but also become part of the definition of the macro.  `Def' appears in
the mode line to remind you of what is going on.  When you are
finished, the `C-x )' command (`end-kbd-macro') terminates the
definition (without becoming part of it!).  For example,

     C-x ( M-f foo C-x )

defines a macro to move forward a word and then insert `foo'.

   The macro thus defined can be invoked again with the `C-x e' command
(`call-last-kbd-macro'), which may be given a repeat count as a numeric
argument to execute the macro many times.  `C-x )' can also be given a
repeat count as an argument, in which case it repeats the macro that
many times right after defining it, but defining the macro counts as
the first repetition (since it is executed as you define it).
Therefore, giving `C-x )' an argument of 4 executes the macro
immediately 3 additional times.  An argument of zero to `C-x e' or `C-x
)' means repeat the macro indefinitely (until it gets an error or you
type `C-g').

   If you wish to repeat an operation at regularly spaced places in the
text, define a macro and include as part of the macro the commands to
move to the next place you want to use it.  For example, if you want to
change each line, you should position point at the start of a line, and
define a macro to change that line and leave point at the start of the
next line.  Then repeating the macro will operate on successive lines.

   After you have terminated the definition of a keyboard macro, you
can add to the end of its definition by typing `C-u C-x ('.  This is
equivalent to plain `C-x (' followed by retyping the whole definition
so far.  As a consequence it re-executes the macro as previously
defined.

   You can use function keys in a keyboard macro, just like keyboard
keys.  You can even use mouse events, but be careful about that: when
the macro replays the mouse event, it uses the original mouse position
of that event, the position that the mouse had while you were defining
the macro.  The effect of this may be hard to predict.  (Using the
current mouse position would be even less predictable.)

   One thing that doesn't always work well in a keyboard macro is the
command `C-M-c' (`exit-recursive-edit').  When this command exits a
recursive edit that started within the macro, it works as you'd expect.
But if it exits a recursive edit that started before you invoked the
keyboard macro, it also necessarily exits the keyboard macro as part of
the process.

   You can edit a keyboard macro already defined by typing `C-x C-k'
(`edit-kbd-macro').  Follow that with the keyboard input that you would
use to invoke the macro--`C-x e' or `M-x NAME' or some other key
sequence.  This formats the macro definition in a buffer and enters a
specialized major mode for editing it.  Type `C-h m' once in that
buffer to display details of how to edit the macro.  When you are
finished editing, type `C-c C-c'.

   The command `M-x apply-macro-to-region-lines' repeats the last
defined keyboard macro on each complete line within the current region.
It does this line by line, by moving point to the beginning of the line
and then executing the macro.


File: emacs,  Node: Save Kbd Macro,  Next: Kbd Macro Query,  Prev: Basic Kbd Macro,  Up: Keyboard Macros

Naming and Saving Keyboard Macros
---------------------------------

If you wish to save a keyboard macro for longer than until you define
the next one, you must give it a name using `M-x name-last-kbd-macro'.
This reads a name as an argument using the minibuffer and defines that
name to execute the macro.  The macro name is a Lisp symbol, and
defining it in this way makes it a valid command name for calling with
`M-x' or for binding a key to with `global-set-key' (*note Keymaps::).
If you specify a name that has a prior definition other than another
keyboard macro, an error message is printed and nothing is changed.

   Once a macro has a command name, you can save its definition in a
file.  Then it can be used in another editing session.  First, visit
the file you want to save the definition in.  Then use this command:

     M-x insert-kbd-macro <RET> MACRONAME <RET>

This inserts some Lisp code that, when executed later, will define the
same macro with the same definition it has now.  (You need not
understand Lisp code to do this, because `insert-kbd-macro' writes the
Lisp code for you.)  Then save the file.  You can load the file later
with `load-file' (*note Lisp Libraries::).  If the file you save in is
your init file `~/.emacs' (*note Init File::) then the macro will be
defined each time you run Emacs.

   If you give `insert-kbd-macro' a numeric argument, it makes
additional Lisp code to record the keys (if any) that you have bound to
the keyboard macro, so that the macro will be reassigned the same keys
when you load the file.


File: emacs,  Node: Kbd Macro Query,  Prev: Save Kbd Macro,  Up: Keyboard Macros

Executing Macros with Variations
--------------------------------

Using `C-x q' (`kbd-macro-query'), you can get an effect similar to
that of `query-replace', where the macro asks you each time around
whether to make a change.  While defining the macro, type `C-x q' at
the point where you want the query to occur.  During macro definition,
the `C-x q' does nothing, but when you run the macro later, `C-x q'
asks you interactively whether to continue.

   The valid responses when `C-x q' asks are <SPC> (or `y'), <DEL> (or
`n'), <RET> (or `q'), `C-l' and `C-r'.  The answers are the same as in
`query-replace', though not all of the `query-replace' options are
meaningful.

   These responses include <SPC> to continue, and <DEL> to skip the
remainder of this repetition of the macro and start right away with the
next repetition.  <RET> means to skip the remainder of this repetition
and cancel further repetitions.  `C-l' redraws the screen and asks you
again for a character to say what to do.

   `C-r' enters a recursive editing level, in which you can perform
editing which is not part of the macro.  When you exit the recursive
edit using `C-M-c', you are asked again how to continue with the
keyboard macro.  If you type a <SPC> at this time, the rest of the
macro definition is executed.  It is up to you to leave point and the
text in a state such that the rest of the macro will do what you want.

   `C-u C-x q', which is `C-x q' with a numeric argument, performs a
completely different function.  It enters a recursive edit reading
input from the keyboard, both when you type it during the definition of
the macro, and when it is executed from the macro.  During definition,
the editing you do inside the recursive edit does not become part of
the macro.  During macro execution, the recursive edit gives you a
chance to do some particularized editing on each repetition.  *Note
Recursive Edit::.


File: emacs,  Node: Key Bindings,  Next: Keyboard Translations,  Prev: Keyboard Macros,  Up: Customization

Customizing Key Bindings
========================

This section describes "key bindings" which map keys to commands, and
the "keymaps" which record key bindings.  It also explains how to
customize key bindings.

   Recall that a command is a Lisp function whose definition provides
for interactive use.  Like every Lisp function, a command has a function
name which usually consists of lower case letters and hyphens.

* Menu:

* Keymaps::          Generalities.  The global keymap.
* Prefix Keymaps::   Keymaps for prefix keys.
* Local Keymaps::    Major and minor modes have their own keymaps.
* Minibuffer Maps::  The minibuffer uses its own local keymaps.
* Rebinding::        How to redefine one key's meaning conveniently.
* Init Rebinding::   Rebinding keys with your init file, `.emacs'.
* Function Keys::    Rebinding terminal function keys.
* Named ASCII Chars::Distinguishing <TAB> from C-i, and so on.
* Mouse Buttons::    Rebinding mouse buttons in Emacs.
* Disabling::        Disabling a command means confirmation is required
                       before it can be executed.  This is done to protect
                       beginners from surprises.


File: emacs,  Node: Keymaps,  Next: Prefix Keymaps,  Up: Key Bindings

Keymaps
-------

The bindings between key sequences and command functions are recorded
in data structures called "keymaps".  Emacs has many of these, each
used on particular occasions.

   Recall that a "key sequence" ("key", for short) is a sequence of
"input events" that have a meaning as a unit.  Input events include
characters, function keys and mouse buttons--all the inputs that you
can send to the computer with your terminal.  A key sequence gets its
meaning from its "binding", which says what command it runs.  The
function of keymaps is to record these bindings.

   The "global" keymap is the most important keymap because it is
always in effect.  The global keymap defines keys for Fundamental mode;
most of these definitions are common to most or all major modes.  Each
major or minor mode can have its own keymap which overrides the global
definitions of some keys.

   For example, a self-inserting character such as `g' is
self-inserting because the global keymap binds it to the command
`self-insert-command'.  The standard Emacs editing characters such as
`C-a' also get their standard meanings from the global keymap.
Commands to rebind keys, such as `M-x global-set-key', actually work by
storing the new binding in the proper place in the global map.  *Note
Rebinding::.

   Meta characters work differently; Emacs translates each Meta
character into a pair of characters starting with <ESC>.  When you type
the character `M-a' in a key sequence, Emacs replaces it with `<ESC>
a'.  A meta key comes in as a single input event, but becomes two
events for purposes of key bindings.  The reason for this is
historical, and we might change it someday.

   Most modern keyboards have function keys as well as character keys.
Function keys send input events just as character keys do, and keymaps
can have bindings for them.

   On many terminals, typing a function key actually sends the computer
a sequence of characters; the precise details of the sequence depends on
which function key and on the model of terminal you are using.  (Often
the sequence starts with `<ESC> ['.)  If Emacs understands your
terminal type properly, it recognizes the character sequences forming
function keys wherever they occur in a key sequence (not just at the
beginning).  Thus, for most purposes, you can pretend the function keys
reach Emacs directly and ignore their encoding as character sequences.

   Mouse buttons also produce input events.  These events come with
other data--the window and position where you pressed or released the
button, and a time stamp.  But only the choice of button matters for key
bindings; the other data matters only if a command looks at it.
(Commands designed for mouse invocation usually do look at the other
data.)

   A keymap records definitions for single events.  Interpreting a key
sequence of multiple events involves a chain of keymaps.  The first
keymap gives a definition for the first event; this definition is
another keymap, which is used to look up the second event in the
sequence, and so on.

   Key sequences can mix function keys and characters.  For example,
`C-x <SELECT>' makes sense.  If you make <SELECT> a prefix key, then
`<SELECT> C-n' makes sense.  You can even mix mouse events with
keyboard events, but we recommend against it, because such sequences
are inconvenient to type in.

   As a user, you can redefine any key; but it might be best to stick to
key sequences that consist of `C-c' followed by a letter.  These keys
are "reserved for users,", so they won't conflict with any properly
designed Emacs extension.  If you redefine some other key, your
definition may be overridden by certain extensions or major modes which
redefine the same key.


File: emacs,  Node: Prefix Keymaps,  Next: Local Keymaps,  Prev: Keymaps,  Up: Key Bindings

Prefix Keymaps
--------------

A prefix key such as `C-x' or <ESC> has its own keymap, which holds the
definition for the event that immediately follows that prefix.

   The definition of a prefix key is usually the keymap to use for
looking up the following event.  The definition can also be a Lisp
symbol whose function definition is the following keymap; the effect is
the same, but it provides a command name for the prefix key that can be
used as a description of what the prefix key is for.  Thus, the binding
of `C-x' is the symbol `Ctl-X-Prefix', whose function definition is the
keymap for `C-x' commands.  The definitions of `C-c', `C-x', `C-h' and
<ESC> as prefix keys appear in the global map, so these prefix keys are
always available.

   Aside from ordinary prefix keys, there is a fictitious "prefix key"
which represents the menu bar; see *Note Menu Bar: (elisp)Menu Bar, for
special information about menu bar key bindings.  Mouse button events
that invoke pop-up menus are also prefix keys; see *Note Menu Keymaps:
(elisp)Menu Keymaps, for more details.

   Some prefix keymaps are stored in variables with names:

   * `ctl-x-map' is the variable name for the map used for characters
     that follow `C-x'.

   * `help-map' is for characters that follow `C-h'.

   * `esc-map' is for characters that follow <ESC>.  Thus, all Meta
     characters are actually defined by this map.

   * `ctl-x-4-map' is for characters that follow `C-x 4'.

   * `mode-specific-map' is for characters that follow `C-c'.


File: emacs,  Node: Local Keymaps,  Next: Minibuffer Maps,  Prev: Prefix Keymaps,  Up: Key Bindings

Local Keymaps
-------------

So far we have explained the ins and outs of the global map.  Major
modes customize Emacs by providing their own key bindings in "local
keymaps".  For example, C mode overrides <TAB> to make it indent the
current line for C code.  Portions of text in the buffer can specify
their own keymaps to substitute for the keymap of the buffer's major
mode.

   Minor modes can also have local keymaps.  Whenever a minor mode is
in effect, the definitions in its keymap override both the major mode's
local keymap and the global keymap.

   The local keymaps for Lisp mode and several other major modes always
exist even when not in use.  These are kept in variables named
`lisp-mode-map' and so on.  For major modes less often used, the local
keymap is normally constructed only when the mode is used for the first
time in a session.  This is to save space.  If you wish to change one
of these keymaps, you must use the major mode's "mode hook"--see below.

   All minor mode keymaps are created in advance.  There is no way to
defer their creation until the first time the minor mode is enabled.

   A local keymap can locally redefine a key as a prefix key by defining
it as a prefix keymap.  If the key is also defined globally as a prefix,
then its local and global definitions (both keymaps) effectively
combine: both of them are used to look up the event that follows the
prefix key.  Thus, if the mode's local keymap defines `C-c' as another
keymap, and that keymap defines `C-z' as a command, this provides a
local meaning for `C-c C-z'.  This does not affect other sequences that
start with `C-c'; if those sequences don't have their own local
bindings, their global bindings remain in effect.

   Another way to think of this is that Emacs handles a multi-event key
sequence by looking in several keymaps, one by one, for a binding of the
whole key sequence.  First it checks the minor mode keymaps for minor
modes that are enabled, then it checks the major mode's keymap, and then
it checks the global keymap.  This is not precisely how key lookup
works, but it's good enough for understanding ordinary circumstances.

   To change the local bindings of a major mode, you must change the
mode's local keymap.  Normally you must wait until the first time the
mode is used, because most major modes don't create their keymaps until
then.  If you want to specify something in your `~/.emacs' file to
change a major mode's bindings, you must use the mode's mode hook to
delay the change until the mode is first used.

   For example, the command `texinfo-mode' to select Texinfo mode runs
the hook `texinfo-mode-hook'.  Here's how you can use the hook to add
local bindings (not very useful, we admit) for `C-c n' and `C-c p' in
Texinfo mode:

     (add-hook 'texinfo-mode-hook
               '(lambda ()
                  (define-key texinfo-mode-map
                              "\C-cp"
                              'backward-paragraph)
                  (define-key texinfo-mode-map
                              "\C-cn"
                              'forward-paragraph)
                  ))

   *Note Hooks::.


File: emacs,  Node: Minibuffer Maps,  Next: Rebinding,  Prev: Local Keymaps,  Up: Key Bindings

Minibuffer Keymaps
------------------

The minibuffer has its own set of local keymaps; they contain various
completion and exit commands.

   * `minibuffer-local-map' is used for ordinary input (no completion).

   * `minibuffer-local-ns-map' is similar, except that <SPC> exits just
     like <RET>.  This is used mainly for Mocklisp compatibility.

   * `minibuffer-local-completion-map' is for permissive completion.

   * `minibuffer-local-must-match-map' is for strict completion and for
     cautious completion.


File: emacs,  Node: Rebinding,  Next: Init Rebinding,  Prev: Minibuffer Maps,  Up: Key Bindings

Changing Key Bindings Interactively
-----------------------------------

The way to redefine an Emacs key is to change its entry in a keymap.
You can change the global keymap, in which case the change is effective
in all major modes (except those that have their own overriding local
definitions for the same key).  Or you can change the current buffer's
local map, which affects all buffers using the same major mode.

`M-x global-set-key <RET> KEY CMD <RET>'
     Define KEY globally to run CMD.

`M-x local-set-key <RET> KEY CMD <RET>'
     Define KEY locally (in the major mode now in effect) to run CMD.

`M-x global-unset-key <RET> KEY'
     Make KEY undefined in the global map.

`M-x local-unset-key <RET> KEY'
     Make KEY undefined locally (in the major mode now in effect).

   For example, suppose you like to execute commands in a subshell
within an Emacs buffer, instead of suspending Emacs and executing
commands in your login shell.  Normally, `C-z' is bound to the function
`suspend-emacs' (when not using the X Window System), but you can
change `C-z' to invoke an interactive subshell within Emacs, by binding
it to `shell' as follows:

     M-x global-set-key <RET> C-z shell <RET>

`global-set-key' reads the command name after the key.   After you
press the key, a message like this appears so that you can confirm that
you are binding the key you want:

     Set key C-z to command:

   You can redefine function keys and mouse events in the same way; just
type the function key or click the mouse when it's time to specify the
key to rebind.

   You can rebind a key that contains more than one event in the same
way.  Emacs keeps reading the key to rebind until it is a complete key
(that is, not a prefix key).  Thus, if you type `C-f' for KEY, that's
the end; the minibuffer is entered immediately to read CMD.  But if you
type `C-x', another character is read; if that is `4', another
character is read, and so on.  For example,

     M-x global-set-key <RET> C-x 4 $ spell-other-window <RET>

redefines `C-x 4 $' to run the (fictitious) command
`spell-other-window'.

   The two-character keys consisting of `C-c' followed by a letter are
reserved for user customizations.  Lisp programs are not supposed to
define these keys, so the bindings you make for them will be available
in all major modes and will never get in the way of anything.

   You can remove the global definition of a key with
`global-unset-key'.  This makes the key "undefined"; if you type it,
Emacs will just beep.  Similarly, `local-unset-key' makes a key
undefined in the current major mode keymap, which makes the global
definition (or lack of one) come back into effect in that major mode.

   If you have redefined (or undefined) a key and you subsequently wish
to retract the change, undefining the key will not do the job--you need
to redefine the key with its standard definition.  To find the name of
the standard definition of a key, go to a Fundamental mode buffer and
use `C-h c'.  The documentation of keys in this manual also lists their
command names.

   If you want to prevent yourself from invoking a command by mistake,
it is better to disable the command than to undefine the key.  A
disabled command is less work to invoke when you really want to.  *Note
Disabling::.


File: emacs,  Node: Init Rebinding,  Next: Function Keys,  Prev: Rebinding,  Up: Key Bindings

Rebinding Keys in Your Init File
--------------------------------

If you have a set of key bindings that you like to use all the time,
you can specify them in your `.emacs' file by using their Lisp syntax.

   The simplest method for doing this works for ASCII characters and
Meta-modified ASCII characters only.  This method uses a string to
represent the key sequence you want to rebind.  For example, here's how
to bind `C-z' to `shell':

     (global-set-key "\C-z" 'shell)

This example uses a string constant containing one character, `C-z'.
The single-quote before the command name, `shell', marks it as a
constant symbol rather than a variable.  If you omit the quote, Emacs
would try to evaluate `shell' immediately as a variable.  This probably
causes an error; it certainly isn't what you want.

   Here is another example that binds a key sequence two characters
long:

     (global-set-key "\C-xl" 'make-symbolic-link)

   When the key sequence includes function keys or mouse button events,
or non-ASCII characters such as `C-=' or `H-a', you must use the more
general method of rebinding, which uses a vector to specify the key
sequence.

   The way to write a vector in Emacs Lisp is with square brackets
around the vector elements.  Use spaces to separate the elements.  If an
element is a symbol, simply write the symbol's name--no other
delimiters or punctuation are needed.  If a vector element is a
character, write it as a Lisp character constant: `?' followed by the
character as it would appear in a string.

   Here are examples of using vectors to rebind `C-=' (a control
character outside of ASCII), `H-a' (a Hyper character; ASCII doesn't
have Hyper at all); <f7> (a function key), and `C-Mouse-1' (a
keyboard-modified mouse button):

     (global-set-key [?\C-=] 'make-symbolic-link)
     (global-set-key [?\H-a] 'make-symbolic-link)
     (global-set-key [f7] 'make-symbolic-link)
     (global-set-key [C-mouse-1] 'make-symbolic-link)

   You can use a vector for the simple cases too.  Here's how to rewrite
the first two examples, above, to use vectors:

     (global-set-key [?\C-z] 'shell)
     
     (global-set-key [?\C-x ?l] 'make-symbolic-link)


File: emacs,  Node: Function Keys,  Next: Named ASCII Chars,  Prev: Init Rebinding,  Up: Key Bindings

Rebinding Function Keys
-----------------------

Key sequences can contain function keys as well as ordinary characters.
Just as Lisp characters (actually integers) represent keyboard
characters, Lisp symbols represent function keys.  If the function key
has a word as its label, then that word is also the name of the
corresponding Lisp symbol.  Here are the conventional Lisp names for
common function keys:

`left', `up', `right', `down'
     Cursor arrow keys.

`begin', `end', `home', `next', `prior'
     Other cursor repositioning keys.

`select', `print', `execute', `backtab'
`insert', `undo', `redo', `clearline'
`insertline', `deleteline', `insertchar', `deletechar',
     Miscellaneous function keys.

`f1', `f2', ... `f35'
     Numbered function keys (across the top of the keyboard).

`kp-add', `kp-subtract', `kp-multiply', `kp-divide'
`kp-backtab', `kp-space', `kp-tab', `kp-enter'
`kp-separator', `kp-decimal', `kp-equal'
     Keypad keys (to the right of the regular keyboard), with names or
     punctuation.

`kp-0', `kp-1', ... `kp-9'
     Keypad keys with digits.

`kp-f1', `kp-f2', `kp-f3', `kp-f4'
     Keypad PF keys.

   These names are conventional, but some systems (especially when using
X windows) may use different names.  To make certain what symbol is used
for a given function key on your terminal, type `C-h c' followed by
that key.

   A key sequence which contains function key symbols (or anything but
ASCII characters) must be a vector rather than a string.  The vector
syntax uses spaces between the elements, and square brackets around the
whole vector.  Thus, to bind function key `f1' to the command `rmail',
write the following:

     (global-set-key [f1] 'rmail)

To bind the right-arrow key to the command `forward-char', you can use
this expression:

     (global-set-key [right] 'forward-char)

This uses the Lisp syntax for a vector containing the symbol `right'.
(This binding is present in Emacs by default.)

   *Note Init Rebinding::, for more information about using vectors for
rebinding.

   You can mix function keys and characters in a key sequence.  This
example binds `C-x <NEXT>' to the command `forward-page'.

     (global-set-key [?\C-x next] 'forward-page)

where `?\C-x' is the Lisp character constant for the character `C-x'.
The vector element `next' is a symbol and therefore does not take a
question mark.

   You can use the modifier keys <CTRL>, <META>, <HYPER>, <SUPER>,
<ALT> and <SHIFT> with function keys.  To represent these modifiers,
add the strings `C-', `M-', `H-', `s-', `A-' and `S-' at the front of
the symbol name.  Thus, here is how to make `Hyper-Meta-<RIGHT>' move
forward a word:

     (global-set-key [H-M-right] 'forward-word)


File: emacs,  Node: Named ASCII Chars,  Next: Mouse Buttons,  Prev: Function Keys,  Up: Key Bindings

Named ASCII Control Characters
------------------------------

<TAB>, <RET>, <BS>, <LFD>, <ESC> and <DEL> started out as names for
certain ASCII control characters, used so often that they have special
keys of their own.  Later, users found it convenient to distinguish in
Emacs between these keys and the "same" control characters typed with
the <CTRL> key.

   Emacs 19 distinguishes these two kinds of input, when used with the X
Window System.  It treats the "special" keys as function keys named
`tab', `return', `backspace', `linefeed', `escape', and `delete'.
These function keys translate automatically into the corresponding
ASCII characters _if_ they have no bindings of their own.  As a result,
neither users nor Lisp programs need to pay attention to the
distinction unless they care to.

   If you do not want to distinguish between (for example) <TAB> and
`C-i', make just one binding, for the ASCII character <TAB> (octal code
011).  If you do want to distinguish, make one binding for this ASCII
character, and another for the "function key" `tab'.

   With an ordinary ASCII terminal, there is no way to distinguish
between <TAB> and `C-i' (and likewise for other such pairs), because
the terminal sends the same character in both cases.


File: emacs,  Node: Mouse Buttons,  Next: Disabling,  Prev: Named ASCII Chars,  Up: Key Bindings

Rebinding Mouse Buttons
-----------------------

Emacs uses Lisp symbols to designate mouse buttons, too.  The ordinary
mouse events in Emacs are "click" events; these happen when you press a
button and release it without moving the mouse.  You can also get
"drag" events, when you move the mouse while holding the button down.
Drag events happen when you finally let go of the button.

   The symbols for basic click events are `mouse-1' for the leftmost
button, `mouse-2' for the next, and so on.  Here is how you can
redefine the second mouse button to split the current window:

     (global-set-key [mouse-2] 'split-window-vertically)

   The symbols for drag events are similar, but have the prefix `drag-'
before the word `mouse'.  For example, dragging the first button
generates a `drag-mouse-1' event.

   You can also define bindings for events that occur when a mouse
button is pressed down.  These events start with `down-' instead of
`drag-'.  Such events are generated only if they have key bindings.
When you get a button-down event, a corresponding click or drag event
will always follow.

   If you wish, you can distinguish single, double, and triple clicks.
A double click means clicking a mouse button twice in approximately the
same place.  The first click generates an ordinary click event.  The
second click, if it comes soon enough, generates a double-click event
instead.  The event type for a double click event starts with
`double-': for example, `double-mouse-3'.

   This means that you can give a special meaning to the second click at
the same place, but it must act on the assumption that the ordinary
single click definition has run when the first click was received.

   This constrains what you can do with double clicks, but user
interface designers say that this constraint ought to be followed in
any case.  A double click should do something similar to the single
click, only "more so".  The command for the double-click event should
perform the extra work for the double click.

   If a double-click event has no binding, it changes to the
corresponding single-click event.  Thus, if you don't define a
particular double click specially, it executes the single-click command
twice.

   Emacs also supports triple-click events whose names start with
`triple-'.  Emacs does not distinguish quadruple clicks as event types;
clicks beyond the third generate additional triple-click events.
However, the full number of clicks is recorded in the event list, so you
can distinguish if you really want to.  We don't recommend distinct
meanings for more than three clicks, but sometimes it is useful for
subsequent clicks to cycle through the same set of three meanings, so
that four clicks are equivalent to one click, five are equivalent to
two, and six are equivalent to three.

   Emacs also records multiple presses in drag and button-down events.
For example, when you press a button twice, then move the mouse while
holding the button, Emacs gets a `double-drag-' event.  And at the
moment when you press it down for the second time, Emacs gets a
`double-down-' event (which is ignored, like all button-down events, if
it has no binding).

   The variable `double-click-time' specifies how long may elapse
between clicks that are recognized as a pair.  Its value is measured in
milliseconds.  If the value is `nil', double clicks are not detected at
all.  If the value is `t', then there is no time limit.

   The symbols for mouse events also indicate the status of the modifier
keys, with the usual prefixes `C-', `M-', `H-', `s-', `A-' and `S-'.
These always precede `double-' or `triple-', which always precede
`drag-' or `down-'.

   A frame includes areas that don't show text from the buffer, such as
the mode line and the scroll bar.  You can tell whether a mouse button
comes from a special area of the screen by means of dummy "prefix
keys."  For example, if you click the mouse in the mode line, you get
the prefix key `mode-line' before the ordinary mouse-button symbol.
Thus, here is how to define the command for clicking the first button in
a mode line to run `scroll-up':

     (global-set-key [mode-line mouse-1] 'scroll-up)

   Here is the complete list of these dummy prefix keys and their
meanings:

`mode-line'
     The mouse was in the mode line of a window.

`vertical-line'
     The mouse was in the vertical line separating side-by-side
     windows.  (If you use scroll bars, they appear in place of these
     vertical lines.)

`vertical-scroll-bar'
     The mouse was in a vertical scroll bar.  (This is the only kind of
     scroll bar Emacs currently supports.)

   You can put more than one mouse button in a key sequence, but it
isn't usual to do so.


File: emacs,  Node: Disabling,  Prev: Mouse Buttons,  Up: Key Bindings

Disabling Commands
------------------

Disabling a command marks the command as requiring confirmation before
it can be executed.  The purpose of disabling a command is to prevent
beginning users from executing it by accident and being confused.

   An attempt to invoke a disabled command interactively in Emacs
displays a window containing the command's name, its documentation, and
some instructions on what to do immediately; then Emacs asks for input
saying whether to execute the command as requested, enable it and
execute it, or cancel.  If you decide to enable the command, you are
asked whether to do this permanently or just for the current session.
Enabling permanently works by automatically editing your `.emacs' file.

   The direct mechanism for disabling a command is to put a non-`nil'
`disabled' property on the Lisp symbol for the command.  Here is the
Lisp program to do this:

     (put 'delete-region 'disabled t)

   If the value of the `disabled' property is a string, that string is
included in the message printed when the command is used:

     (put 'delete-region 'disabled
          "It's better to use `kill-region' instead.\n")

   You can make a command disabled either by editing the `.emacs' file
directly or with the command `M-x disable-command', which edits the
`.emacs' file for you.  Likewise, `M-x enable-command' edits `.emacs'
to enable a command permanently.  *Note Init File::.

   Whether a command is disabled is independent of what key is used to
invoke it; disabling also applies if the command is invoked using
`M-x'.  Disabling a command has no effect on calling it as a function
from Lisp programs.


File: emacs,  Node: Keyboard Translations,  Next: Syntax,  Prev: Key Bindings,  Up: Customization

Keyboard Translations
=====================

Some keyboards do not make it convenient to send all the special
characters that Emacs uses.  The most common problem case is the <DEL>
character.  Some keyboards provide no convenient way to type this very
important character--usually because they were designed to expect the
character `C-h' to be used for deletion.  On these keyboard, if you
press the key normally used for deletion, Emacs handles the `C-h' as a
prefix character and offers you a list of help options, which is not
what you want.

   You can work around this problem within Emacs by setting up keyboard
translations to turn `C-h' into <DEL> and <DEL> into `C-h', as follows:

     ;; Translate `C-h' to <DEL>.
     (keyboard-translate ?\C-h ?\C-?)
     
     ;; Translate <DEL> to `C-h'.
     (keyboard-translate ?\C-? ?\C-h)

   Keyboard translations are not the same as key bindings in keymaps
(*note Keymaps::).  Emacs contains numerous keymaps that apply in
different situations, but there is only one set of keyboard
translations, and it applies to every character that Emacs reads from
the terminal.  Keyboard translations take place at the lowest level of
input processing; the keys that are looked up in keymaps contain the
characters that result from keyboard translation.

   Under X, the keyboard key named <DELETE> is a function key and is
distinct from the ASCII character named <DEL>.  *Note Named ASCII
Chars::.  Keyboard translations affect only ASCII character input, not
function keys; thus, the above example used under X does not affect the
<DELETE> key.  However, the translation above isn't necessary under X,
because Emacs can also distinguish between the <BACKSPACE> key and
`C-h'; and it normally treats <BACKSPACE> as <DEL>.

   For full information about how to use keyboard translations, see
*Note Translating Input: (elisp)Translating Input.


File: emacs,  Node: Syntax,  Next: Init File,  Prev: Keyboard Translations,  Up: Customization

The Syntax Table
================

All the Emacs commands which parse words or balance parentheses are
controlled by the "syntax table".  The syntax table says which
characters are opening delimiters, which are parts of words, which are
string quotes, and so on.  Each major mode has its own syntax table
(though sometimes related major modes use the same one) which it
installs in each buffer that uses that major mode.  The syntax table
installed in the current buffer is the one that all commands use, so we
call it "the" syntax table.  A syntax table is a Lisp object, a vector
of length 256 whose elements are numbers.

   To display a description of the contents of the current syntax table,
type `C-h s' (`describe-syntax').  The description of each character
includes both the string you would have to give to
`modify-syntax-entry' to set up that character's current syntax, and
some English to explain that string if necessary.

   For full information on the syntax table, see *Note Syntax Tables:
(elisp)Syntax Tables.


File: emacs,  Node: Init File,  Prev: Syntax,  Up: Customization

The Init File, `~/.emacs'
=========================

When Emacs is started, it normally loads a Lisp program from the file
`.emacs' in your home directory.  We call this file your "init file"
because it specifies how to initialize Emacs for you.  You can use the
command line switches `-q' and `-u' to tell Emacs whether to load an
init file, and which one (*note Entering Emacs::).

   There can also be a "default init file", which is the library named
`default.el', found via the standard search path for libraries.  The
Emacs distribution contains no such library; your site may create one
for local customizations.  If this library exists, it is loaded
whenever you start Emacs (except when you specify `-q').  But your init
file, if any, is loaded first; if it sets `inhibit-default-init'
non-`nil', then `default' is not loaded.

   Your site may also have a "site startup file"; this is named
`site-start.el', if it exists.  Emacs loads this library before it
loads your init file.  To inhibit loading of this library, use the
option `-no-site-file'.

   If you have a large amount of code in your `.emacs' file, you should
move it into another file such as `~/SOMETHING.el', byte-compile it,
and make your `.emacs' file load it with `(load "~/SOMETHING")'.  *Note
Byte Compilation: (elisp)Byte Compilation, for more information about
compiling Emacs Lisp programs.

* Menu:

* Init Syntax::	     Syntax of constants in Emacs Lisp.
* Init Examples::    How to do some things with an init file.
* Terminal Init::    Each terminal type can have an init file.
* Find Init::	     How Emacs finds the init file.


File: emacs,  Node: Init Syntax,  Next: Init Examples,  Up: Init File

Init File Syntax
----------------

The `.emacs' file contains one or more Lisp function call expressions.
Each of these consists of a function name followed by arguments, all
surrounded by parentheses.  For example, `(setq fill-column 60)' calls
the function `setq' to set the variable `fill-column' (*note Filling::)
to 60.

   The second argument to `setq' is an expression for the new value of
the variable.  This can be a constant, a variable, or a function call
expression.  In `.emacs', constants are used most of the time.  They
can be:

Numbers:
     Numbers are written in decimal, with an optional initial minus
     sign.

Strings:
     Lisp string syntax is the same as C string syntax with a few extra
     features.  Use a double-quote character to begin and end a string
     constant.

     In a string, you can include newlines and special characters
     literally.  But often it is cleaner to use backslash sequences for
     them: `\n' for newline, `\b' for backspace, `\r' for carriage
     return, `\t' for tab, `\f' for formfeed (control-L), `\e' for
     escape, `\\' for a backslash, `\"' for a double-quote, or `\OOO'
     for the character whose octal code is OOO.  Backslash and
     double-quote are the only characters for which backslash sequences
     are mandatory.

     `\C-' can be used as a prefix for a control character, as in
     `\C-s' for ASCII control-S, and `\M-' can be used as a prefix for
     a Meta character, as in `\M-a' for `Meta-A' or `\M-\C-a' for
     `Control-Meta-A'.

Characters:
     Lisp character constant syntax consists of a `?' followed by
     either a character or an escape sequence starting with `\'.
     Examples: `?x', `?\n', `?\"', `?\)'.  Note that strings and
     characters are not interchangeable in Lisp; some contexts require
     one and some contexts require the other.

True:
     `t' stands for `true'.

False:
     `nil' stands for `false'.

Other Lisp objects:
     Write a single-quote (') followed by the Lisp object you want.


File: emacs,  Node: Init Examples,  Next: Terminal Init,  Prev: Init Syntax,  Up: Init File

Init File Examples
------------------

Here are some examples of doing certain commonly desired things with
Lisp expressions:

   * Make <TAB> in C mode just insert a tab if point is in the middle
     of a line.

          (setq c-tab-always-indent nil)

     Here we have a variable whose value is normally `t' for `true' and
     the alternative is `nil' for `false'.

   * Make searches case sensitive by default (in all buffers that do not
     override this).

          (setq-default case-fold-search nil)

     This sets the default value, which is effective in all buffers
     that do not have local values for the variable.  Setting
     `case-fold-search' with `setq' affects only the current buffer's
     local value, which is not what you probably want to do in an init
     file.

   * Specify your own email address, if Emacs can't figure it out
     correctly.

          (setq user-mail-address "coon@yoyodyne.com")

     Various Emacs packages that need your own email address use the
     value of `user-mail-address'.

   * Make Text mode the default mode for new buffers.

          (setq default-major-mode 'text-mode)

     Note that `text-mode' is used because it is the command for
     entering Text mode.  The single-quote before it makes the symbol a
     constant; otherwise, `text-mode' would be treated as a variable
     name.

   * Turn on Auto Fill mode automatically in Text mode and related
     modes.

          (add-hook 'text-mode-hook
            '(lambda () (auto-fill-mode 1)))

     This shows how to add a hook function to a normal hook variable
     (*note Hooks::).  The function we supply is a list starting with
     `lambda', with a single-quote in front of it to make it a list
     constant rather than an expression.

     It's beyond the scope of this manual to explain Lisp functions,
     but for this example it is enough to know that the effect is to
     execute `(auto-fill-mode 1)' when Text mode is entered.  You can
     replace that with any other expression that you like, or with
     several expressions in a row.

     Emacs comes with a function named `turn-on-auto-fill' whose
     definition is `(lambda () (auto-fill-mode 1))'.  Thus, a simpler
     way to write the above example is as follows:

          (add-hook 'text-mode-hook 'turn-on-auto-fill)

   * Load the installed Lisp library named `foo' (actually a file
     `foo.elc' or `foo.el' in a standard Emacs directory).

          (load "foo")

     When the argument to `load' is a relative file name, not starting
     with `/' or `~', `load' searches the directories in `load-path'
     (*note Lisp Libraries::).

   * Load the compiled Lisp file `foo.elc' from your home directory.

          (load "~/foo.elc")

     Here an absolute file name is used, so no searching is done.

   * Rebind the key `C-x l' to run the function `make-symbolic-link'.

          (global-set-key "\C-xl" 'make-symbolic-link)

     or

          (define-key global-map "\C-xl" 'make-symbolic-link)

     Note once again the single-quote used to refer to the symbol
     `make-symbolic-link' instead of its value as a variable.

   * Do the same thing for Lisp mode only.

          (define-key lisp-mode-map "\C-xl" 'make-symbolic-link)

   * Redefine all keys which now run `next-line' in Fundamental mode so
     that they run `forward-line' instead.

          (substitute-key-definition 'next-line 'forward-line
                                     global-map)

   * Make `C-x C-v' undefined.

          (global-unset-key "\C-x\C-v")

     One reason to undefine a key is so that you can make it a prefix.
     Simply defining `C-x C-v ANYTHING' will make `C-x C-v' a prefix,
     but `C-x C-v' must first be freed of its usual non-prefix
     definition.

   * Make `$' have the syntax of punctuation in Text mode.  Note the
     use of a character constant for `$'.

          (modify-syntax-entry ?\$ "." text-mode-syntax-table)

   * Enable the use of the command `eval-expression' without
     confirmation.

          (put 'eval-expression 'disabled nil)


File: emacs,  Node: Terminal Init,  Next: Find Init,  Prev: Init Examples,  Up: Init File

Terminal-specific Initialization
--------------------------------

Each terminal type can have a Lisp library to be loaded into Emacs when
it is run on that type of terminal.  For a terminal type named
TERMTYPE, the library is called `term/TERMTYPE' and it is found by
searching the directories `load-path' as usual and trying the suffixes
`.elc' and `.el'.  Normally it appears in the subdirectory `term' of
the directory where most Emacs libraries are kept.

   The usual purpose of the terminal-specific library is to map the
escape sequences used by the terminal's function keys onto more
meaningful names, using `function-key-map'.  See the file
`term/lk201.el' for an example of how this is done.  Many function keys
are mapped automatically according to the information in the Termcap
data base; the terminal-specific library needs to map only the function
keys that Termcap does not specify.

   When the terminal type contains a hyphen, only the part of the name
before the first hyphen is significant in choosing the library name.
Thus, terminal types `aaa-48' and `aaa-30-rv' both use the library
`term/aaa'.  The code in the library can use `(getenv "TERM")' to find
the full terminal type name.

   The library's name is constructed by concatenating the value of the
variable `term-file-prefix' and the terminal type.  Your `.emacs' file
can prevent the loading of the terminal-specific library by setting
`term-file-prefix' to `nil'.

   Emacs runs the hook `term-setup-hook' at the end of initialization,
after both your `.emacs' file and any terminal-specific library have
been read in.  Add hook functions to this hook if you wish to override
part of any of the terminal-specific libraries and to define
initializations for terminals that do not have a library.  *Note
Hooks::.


File: emacs,  Node: Find Init,  Prev: Terminal Init,  Up: Init File

How Emacs Finds Your Init File
------------------------------

Normally Emacs uses the environment variable `HOME' to find `.emacs';
that's what `~' means in a file name.  But if you have done `su', Emacs
tries to find your own `.emacs', not that of the user you are currently
pretending to be.  The idea is that you should get your own editor
customizations even if you are running as the super user.

   More precisely, Emacs first determines which user's init file to use.
It gets the user name from the environment variables `LOGNAME' and
`USER'; if neither of those exists, it uses effective user-ID.  If that
user name matches the real user-ID, then Emacs uses `HOME'; otherwise,
it looks up the home directory corresponding to that user name in the
system's data base of users.


File: emacs,  Node: Quitting,  Next: Lossage,  Prev: Customization,  Up: Top

Quitting and Aborting
=====================

`C-g'
     Quit.  Cancel running or partially typed command.

`C-]'
     Abort innermost recursive editing level and cancel the command
     which invoked it (`abort-recursive-edit').

`<ESC> <ESC> <ESC>'
     Either quit or abort, whichever makes sense
     (`keyboard-escape-quit').

`M-x top-level'
     Abort all recursive editing levels that are currently executing.

`C-x u'
     Cancel a previously made change in the buffer contents (`undo').

   There are two ways of canceling commands which are not finished
executing: "quitting" with `C-g', and "aborting" with `C-]' or `M-x
top-level'.  Quitting cancels a partially typed command or one which is
already running.  Aborting exits a recursive editing level and cancels
the command that invoked the recursive edit.  (*Note Recursive Edit::.)

   Quitting with `C-g' is used for getting rid of a partially typed
command, or a numeric argument that you don't want.  It also stops a
running command in the middle in a relatively safe way, so you can use
it if you accidentally give a command which takes a long time.  In
particular, it is safe to quit out of killing; either your text will
_all_ still be in the buffer, or it will _all_ be in the kill ring (or
maybe both).  Quitting an incremental search does special things
documented under searching; in general, it may take two successive
`C-g' characters to get out of a search (*note Incremental Search::).

   `C-g' works by setting the variable `quit-flag' to `t' the instant
`C-g' is typed; Emacs Lisp checks this variable frequently and quits if
it is non-`nil'.  `C-g' is only actually executed as a command if you
type it while Emacs is waiting for input.

   If you quit with `C-g' a second time before the first `C-g' is
recognized, you activate the "emergency escape" feature and return to
the shell.  *Note Emergency Escape::.

   There may be times when you cannot quit.  When Emacs is waiting for
the operating system to do something, quitting is impossible unless
special pains are taken for the particular system call within Emacs
where the waiting occurs.  We have done this for the system calls that
users are likely to want to quit from, but it's possible you will find
another.  In one very common case--waiting for file input or output
using NFS--Emacs itself knows how to quit, but most NFS implementations
simply do not allow user programs to stop waiting for NFS when the NFS
server is hung.

   Aborting with `C-]' (`abort-recursive-edit') is used to get out of a
recursive editing level and cancel the command which invoked it.
Quitting with `C-g' does not do this, and could not do this, because it
is used to cancel a partially typed command _within_ the recursive
editing level.  Both operations are useful.  For example, if you are in
a recursive edit and type `C-u 8' to enter a numeric argument, you can
cancel that argument with `C-g' and remain in the recursive edit.

   The command `<ESC> <ESC> <ESC>' (`keyboard-escape-quit') can either
quit or abort.  This key was defined because <ESC> is used to "get out"
in many PC programs.  It can cancel a prefix argument, clear a selected
region, or get out of a Query Replace, like `C-g'.  It can get out of
the minibuffer or a recursive edit, like `C-]'.  It can also get out of
splitting the frame into multiple windows, like `C-x 1'.  One thing it
cannot do, however, is stop a command that is running.  That's because
it executes as an ordinary command, and Emacs doesn't notice it until
it is ready for a command.

   The command `M-x top-level' is equivalent to "enough" `C-]' commands
to get you out of all the levels of recursive edits that you are in.
`C-]' gets you out one level at a time, but `M-x top-level' goes out
all levels at once.  Both `C-]' and `M-x top-level' are like all other
commands, and unlike `C-g', in that they take effect only when Emacs is
ready for a command.  `C-]' is an ordinary key and has its meaning only
because of its binding in the keymap.  *Note Recursive Edit::.

   `C-x u' (`undo') is not strictly speaking a way of canceling a
command, but you can think of it as canceling a command that already
finished executing.  *Note Undo::.


File: emacs,  Node: Lossage,  Next: Bugs,  Prev: Quitting,  Up: Top

Dealing with Emacs Trouble
==========================

This section describes various conditions in which Emacs fails to work
normally, and how to recognize them and correct them.

* Menu:

* DEL Gets Help::       What to do if <DEL> doesn't delete.
* Stuck Recursive::     `[...]' in mode line around the parentheses.
* Screen Garbled::      Garbage on the screen.
* Text Garbled::        Garbage in the text.
* Unasked-for Search::  Spontaneous entry to incremental search.
* Memory Full::         How to cope when you run out of memory.
* After a Crash::       Recovering editing in an Emacs session that crashed.
* Emergency Escape::    Emergency escape---
                          What to do if Emacs stops responding.
* Total Frustration::   When you are at your wits' end.


File: emacs,  Node: DEL Gets Help,  Next: Stuck Recursive,  Up: Lossage

If <DEL> Fails to Delete
------------------------

If you find that <DEL> enters Help like `Control-h' instead of deleting
a character, your terminal is sending the wrong code for <DEL>.  You
can work around this problem by changing the keyboard translation table
(*note Keyboard Translations::).


File: emacs,  Node: Stuck Recursive,  Next: Screen Garbled,  Prev: DEL Gets Help,  Up: Lossage

Recursive Editing Levels
------------------------

Recursive editing levels are important and useful features of Emacs, but
they can seem like malfunctions to the user who does not understand
them.

   If the mode line has square brackets `[...]' around the parentheses
that contain the names of the major and minor modes, you have entered a
recursive editing level.  If you did not do this on purpose, or if you
don't understand what that means, you should just get out of the
recursive editing level.  To do so, type `M-x top-level'.  This is
called getting back to top level.  *Note Recursive Edit::.


File: emacs,  Node: Screen Garbled,  Next: Text Garbled,  Prev: Stuck Recursive,  Up: Lossage

Garbage on the Screen
---------------------

If the data on the screen looks wrong, the first thing to do is see
whether the text is really wrong.  Type `C-l', to redisplay the entire
screen.  If the screen appears correct after this, the problem was
entirely in the previous screen update.  (Otherwise, see *Note Text
Garbled::.)

   Display updating problems often result from an incorrect termcap
entry for the terminal you are using.  The file `etc/TERMS' in the Emacs
distribution gives the fixes for known problems of this sort.
`INSTALL' contains general advice for these problems in one of its
sections.  Very likely there is simply insufficient padding for certain
display operations.  To investigate the possibility that you have this
sort of problem, try Emacs on another terminal made by a different
manufacturer.  If problems happen frequently on one kind of terminal
but not another kind, it is likely to be a bad termcap entry, though it
could also be due to a bug in Emacs that appears for terminals that
have or that lack specific features.


File: emacs,  Node: Text Garbled,  Next: Unasked-for Search,  Prev: Screen Garbled,  Up: Lossage

Garbage in the Text
-------------------

If `C-l' shows that the text is wrong, try undoing the changes to it
using `C-x u' until it gets back to a state you consider correct.  Also
try `C-h l' to find out what command you typed to produce the observed
results.

   If a large portion of text appears to be missing at the beginning or
end of the buffer, check for the word `Narrow' in the mode line.  If it
appears, the text you don't see is probably still present, but
temporarily off-limits.  To make it accessible again, type `C-x n w'.
*Note Narrowing::.


File: emacs,  Node: Unasked-for Search,  Next: Memory Full,  Prev: Text Garbled,  Up: Lossage

Spontaneous Entry to Incremental Search
---------------------------------------

If Emacs spontaneously displays `I-search:' at the bottom of the
screen, it means that the terminal is sending `C-s' and `C-q' according
to the poorly designed xon/xoff "flow control" protocol.

   If this happens to you, your best recourse is to put the terminal in
a mode where it will not use flow control, or give it so much padding
that it will never send a `C-s'.  (One way to increase the amount of
padding is to set the variable `baud-rate' to a larger value.  Its
value is the terminal output speed, measured in the conventional units
of baud.)

   If you don't succeed in turning off flow control, the next best thing
is to tell Emacs to cope with it.  To do this, call the function
`enable-flow-control'.

   Typically there are particular terminal types with which you must use
flow control.  You can conveniently ask for flow control on those
terminal types only, using `enable-flow-control-on'.  For example, if
you find you must use flow control on VT-100 and H19 terminals, put the
following in your `.emacs' file:

     (enable-flow-control-on "vt100" "h19")

   When flow control is enabled, you must type `C-\' to get the effect
of a `C-s', and type `C-^' to get the effect of a `C-q'.  (These
aliases work by means of keyboard translations; see *Note Keyboard
Translations::.)


File: emacs,  Node: Memory Full,  Next: After a Crash,  Prev: Unasked-for Search,  Up: Lossage

Running out of Memory
---------------------

If you get the error message `Virtual memory exceeded', save your
modified buffers with `C-x s'.  This method of saving them has the
smallest need for additional memory.  Emacs keeps a reserve of memory
which it makes available when this error happens; that should be enough
to enable `C-x s' to complete its work.

   Once you have saved your modified buffers, you can exit this Emacs
job and start another, or you can use `M-x kill-some-buffers' to free
space in the current Emacs job.  If you kill buffers containing a
substantial amount of text, you can safely go on editing.  Emacs refills
its memory reserve automatically when it sees sufficient free space
available, in case you run out of memory another time.

   Do not use `M-x buffer-menu' to save or kill buffers when you run
out of memory, because the buffer menu needs a fair amount memory
itself, and the reserve supply may not be enough.


File: emacs,  Node: After a Crash,  Next: Emergency Escape,  Prev: Memory Full,  Up: Lossage

Recovery After a Crash
----------------------

If Emacs or the computer crashes, you can recover the files you were
editing at the time of the crash from their auto-save files.  To do
this, start Emacs again and type the command `M-x recover-session'.

   This command initially displays a buffer which lists interrupted
session files, each with its date.  You must choose which session to
recover from.  Typically the one you want is the most recent one.  Move
point to the one you choose, and type `C-c C-c'.

   Then `recover-session' asks about each of the files that you were
editing during that session; it asks whether to recover that file.  If
you answer `y' for a file, it shows the dates of that file and its
auto-save file, then asks once again whether to recover that file.  For
the second question, you must confirm with `yes'.  If you do, Emacs
visits the file but gets the text from the auto-save file.

   When `recover-session' is done, the files you've chosen to recover
are present in Emacs buffers.  You should then save them.  Only
this--saving them--updates the files themselves.


File: emacs,  Node: Emergency Escape,  Next: Total Frustration,  Prev: After a Crash,  Up: Lossage

Emergency Escape
----------------

Because at times there have been bugs causing Emacs to loop without
checking `quit-flag', a special feature causes Emacs to be suspended
immediately if you type a second `C-g' while the flag is already set,
so you can always get out of GNU Emacs.  Normally Emacs recognizes and
clears `quit-flag' (and quits!) quickly enough to prevent this from
happening.

   When you resume Emacs after a suspension caused by multiple `C-g', it
asks two questions before going back to what it had been doing:

     Auto-save? (y or n)
     Abort (and dump core)? (y or n)

Answer each one with `y' or `n' followed by <RET>.

   Saying `y' to `Auto-save?' causes immediate auto-saving of all
modified buffers in which auto-saving is enabled.

   Saying `y' to `Abort (and dump core)?' causes an illegal instruction
to be executed, dumping core.  This is to enable a wizard to figure out
why Emacs was failing to quit in the first place.  Execution does not
continue after a core dump.  If you answer `n', execution does
continue.  With luck, GNU Emacs will ultimately check `quit-flag' and
quit normally.  If not, and you type another `C-g', it is suspended
again.

   If Emacs is not really hung, just slow, you may invoke the double
`C-g' feature without really meaning to.  Then just resume and answer
`n' to both questions, and you will arrive at your former state.
Presumably the quit you requested will happen soon.

   The double-`C-g' feature is turned off when Emacs is running under
the X Window System, since you can use the window manager to kill Emacs
or to create another window and run another program.


File: emacs,  Node: Total Frustration,  Prev: Emergency Escape,  Up: Lossage

Help for Total Frustration
--------------------------

If using Emacs (or something else) becomes terribly frustrating and none
of the techniques described above solve the problem, Emacs can still
help you.

   First, if the Emacs you are using is not responding to commands, type
`C-g C-g' to get out of it and then start a new one.

   Second, type `M-x doctor <RET>'.

   The doctor will help you feel better.  Each time you say something to
the doctor, you must end it by typing <RET> <RET>.  This lets the
doctor know you are finished.


File: emacs,  Node: Bugs,  Next: Contributing,  Prev: Lossage,  Up: Top

Reporting Bugs
==============

Sometimes you will encounter a bug in Emacs.  Although we cannot
promise we can or will fix the bug, and we might not even agree that it
is a bug, we want to hear about problems you encounter.  Often we agree
they are bugs and want to fix them.

   To make it possible for us to fix a bug, you must report it.  In
order to do so effectively, you must know when and how to do it.

* Menu:

* Criteria:  Bug Criteria.	 Have you really found a bug?
* Understanding Bug Reporting::	 How to report a bug effectively.
* Checklist::			 Steps to follow for a good bug report.
* Sending Patches::		 How to send a patch for GNU Emacs.


File: emacs,  Node: Bug Criteria,  Next: Understanding Bug Reporting,  Up: Bugs

When Is There a Bug
-------------------

If Emacs executes an illegal instruction, or dies with an operating
system error message that indicates a problem in the program (as
opposed to something like "disk full"), then it is certainly a bug.

   If Emacs updates the display in a way that does not correspond to
what is in the buffer, then it is certainly a bug.  If a command seems
to do the wrong thing but the problem corrects itself if you type
`C-l', it is a case of incorrect display updating.

   Taking forever to complete a command can be a bug, but you must make
certain that it was really Emacs's fault.  Some commands simply take a
long time.  Type `C-g' and then `C-h l' to see whether the input Emacs
received was what you intended to type; if the input was such that you
_know_ it should have been processed quickly, report a bug.  If you
don't know whether the command should take a long time, find out by
looking in the manual or by asking for assistance.

   If a command you are familiar with causes an Emacs error message in a
case where its usual definition ought to be reasonable, it is probably a
bug.

   If a command does the wrong thing, that is a bug.  But be sure you
know for certain what it ought to have done.  If you aren't familiar
with the command, or don't know for certain how the command is supposed
to work, then it might actually be working right.  Rather than jumping
to conclusions, show the problem to someone who knows for certain.

   Finally, a command's intended definition may not be best for editing
with.  This is a very important sort of problem, but it is also a
matter of judgment.  Also, it is easy to come to such a conclusion out
of ignorance of some of the existing features.  It is probably best not
to complain about such a problem until you have checked the
documentation in the usual ways, feel confident that you understand it,
and know for certain that what you want is not available.  If you are
not sure what the command is supposed to do after a careful reading of
the manual, check the index and glossary for any terms that may be
unclear.

   If after careful rereading of the manual you still do not understand
what the command should do, that indicates a bug in the manual, which
you should report.  The manual's job is to make everything clear to
people who are not Emacs experts--including you.  It is just as
important to report documentation bugs as program bugs.

   If the on-line documentation string of a function or variable
disagrees with the manual, one of them must be wrong; that is a bug.


File: emacs,  Node: Understanding Bug Reporting,  Next: Checklist,  Prev: Bug Criteria,  Up: Bugs

Understanding Bug Reporting
---------------------------

When you decide that there is a bug, it is important to report it and to
report it in a way which is useful.  What is most useful is an exact
description of what commands you type, starting with the shell command
to run Emacs, until the problem happens.

   The most important principle in reporting a bug is to report _facts_,
not hypotheses or categorizations.  It is always easier to report the
facts, but people seem to prefer to strain to posit explanations and
report them instead.  If the explanations are based on guesses about
how Emacs is implemented, they will be useless; we will have to try to
figure out what the facts must have been to lead to such speculations.
Sometimes this is impossible.  But in any case, it is unnecessary work
for us.

   For example, suppose that you type `C-x C-f /glorp/baz.ugh <RET>',
visiting a file which (you know) happens to be rather large, and Emacs
prints out `I feel pretty today'.  The best way to report the bug is
with a sentence like the preceding one, because it gives all the facts
and nothing but the facts.

   Do not assume that the problem is due to the size of the file and
say, "When I visit a large file, Emacs prints out `I feel pretty
today'."  This is what we mean by "guessing explanations".  The problem
is just as likely to be due to the fact that there is a `z' in the file
name.  If this is so, then when we got your report, we would try out
the problem with some "large file", probably with no `z' in its name,
and not find anything wrong.  There is no way in the world that we
could guess that we should try visiting a file with a `z' in its name.

   Alternatively, the problem might be due to the fact that the file
starts with exactly 25 spaces.  For this reason, you should make sure
that you inform us of the exact contents of any file that is needed to
reproduce the bug.  What if the problem only occurs when you have typed
the `C-x C-a' command previously?  This is why we ask you to give the
exact sequence of characters you typed since starting the Emacs session.

   You should not even say "visit a file" instead of `C-x C-f' unless
you _know_ that it makes no difference which visiting command is used.
Similarly, rather than saying "if I have three characters on the line,"
say "after I type `<RET> A B C <RET> C-p'," if that is the way you
entered the text.


File: emacs,  Node: Checklist,  Next: Sending Patches,  Prev: Understanding Bug Reporting,  Up: Bugs

Checklist for Bug Reports
-------------------------

The best way to send a bug report is to mail it electronically to the
Emacs maintainers at `bug-gnu-emacs@prep.ai.mit.edu'.  (If you want to
suggest a change as an improvement, use the same address.)

   If you'd like to read the bug reports, you can find them on the
newsgroup `gnu.emacs.bug'; keep in mind, however, that as a spectator
you should not criticize anything about what you see there.  The
purpose of bug reports is to give information to the Emacs maintainers.
Spectators are welcome only as long as they do not interfere with
this.  In particular, some bug reports contain large amounts of data;
spectators should not complain about this.

   Please do not post bug reports using netnews; mail is more reliable
than netnews about reporting your correct address, which we may need in
order to ask you for more information.

   If you can't send electronic mail, then mail the bug report on paper
or machine-readable media to this address:

GNU Emacs Bugs
Free Software Foundation
59 Temple Place, Suite 330
Boston, MA 02111-1307 USA

   We do not promise to fix the bug; but if the bug is serious, or
ugly, or easy to fix, chances are we will want to.

   A convenient way to send a bug report for Emacs is to use the command
`M-x report-emacs-bug'.  This sets up a mail buffer (*note Sending
Mail::) and automatically inserts _some_ of the essential information.
However, it cannot supply all the necessary information; you should
still read and follow the guidelines below, so you can enter the other
crucial information by hand before you send the message.

   To enable maintainers to investigate a bug, your report should
include all these things:

   * The version number of Emacs.  Without this, we won't know whether
     there is any point in looking for the bug in the current version
     of GNU Emacs.

     You can get the version number by typing `M-x emacs-version
     <RET>'.  If that command does not work, you probably have something
     other than GNU Emacs, so you will have to report the bug somewhere
     else.

   * The type of machine you are using, and the operating system name
     and version number.  `M-x emacs-version <RET>' provides this
     information too.  Copy its output from the `*Messages*' buffer, so
     that you get it all and get it accurately.

   * The operands given to the `configure' command when Emacs was
     installed.

   * A complete list of any modifications you have made to the Emacs
     source.  (We may not have time to investigate the bug unless it
     happens in an unmodified Emacs.  But if you've made modifications
     and you don't tell us, you are sending us on a wild goose chase.)

     Be precise about these changes.  A description in English is not
     enough--send a context diff for them.

     Adding files of your own, or porting to another machine, is a
     modification of the source.

   * Details of any other deviations from the standard procedure for
     installing GNU Emacs.

   * The complete text of any files needed to reproduce the bug.

     If you can tell us a way to cause the problem without visiting any
     files, please do so.  This makes it much easier to debug.  If you
     do need files, make sure you arrange for us to see their exact
     contents.  For example, it can often matter whether there are
     spaces at the ends of lines, or a newline after the last line in
     the buffer (nothing ought to care whether the last line is
     terminated, but try telling the bugs that).

   * The precise commands we need to type to reproduce the bug.

     The easy way to record the input to Emacs precisely is to write a
     dribble file.  To start the file, execute the Lisp expression

          (open-dribble-file "~/dribble")

     using `M-:' or from the `*scratch*' buffer just after starting
     Emacs.  From then on, Emacs copies all your input to the specified
     dribble file until the Emacs process is killed.

   * For possible display bugs, the terminal type (the value of
     environment variable `TERM'), the complete termcap entry for the
     terminal from `/etc/termcap' (since that file is not identical on
     all machines), and the output that Emacs actually sent to the
     terminal.

     The way to collect the terminal output is to execute the Lisp
     expression

          (open-termscript "~/termscript")

     using `M-:' or from the `*scratch*' buffer just after starting
     Emacs.  From then on, Emacs copies all terminal output to the
     specified termscript file as well, until the Emacs process is
     killed.  If the problem happens when Emacs starts up, put this
     expression into your `.emacs' file so that the termscript file
     will be open when Emacs displays the screen for the first time.

     Be warned: it is often difficult, and sometimes impossible, to fix
     a terminal-dependent bug without access to a terminal of the type
     that stimulates the bug.

   * A description of what behavior you observe that you believe is
     incorrect.  For example, "The Emacs process gets a fatal signal,"
     or, "The resulting text is as follows, which I think is wrong."

     Of course, if the bug is that Emacs gets a fatal signal, then one
     can't miss it.  But if the bug is incorrect text, the maintainer
     might fail to notice what is wrong.  Why leave it to chance?

     Even if the problem you experience is a fatal signal, you should
     still say so explicitly.  Suppose something strange is going on,
     such as, your copy of the source is out of sync, or you have
     encountered a bug in the C library on your system.  (This has
     happened!)  Your copy might crash and the copy here might not.  If
     you _said_ to expect a crash, then when Emacs here fails to crash,
     we would know that the bug was not happening.  If you don't say to
     expect a crash, then we would not know whether the bug was
     happening--we would not be able to draw any conclusion from our
     observations.

   * If the manifestation of the bug is an Emacs error message, it is
     important to report the precise text of the error message, and a
     backtrace showing how the Lisp program in Emacs arrived at the
     error.

     To get the error message text accurately, copy it from the
     `*Messages*' buffer into the bug report.  Copy all of it, not just
     part.

     To make a backtrace for the error, evaluate the Lisp expression
     `(setq debug-on-error t)' before the error happens (that is to
     say, you must execute that expression and then make the bug
     happen).  This causes the error to run the Lisp debugger, which
     shows you a backtrace.  Copy the text of the debugger's backtrace
     into the bug report.

     This use of the debugger is possible only if you know how to make
     the bug happen again.  If you can't make it happen again, at least
     copy the whole error message.

   * Check whether any programs you have loaded into the Lisp world,
     including your `.emacs' file, set any variables that may affect the
     functioning of Emacs.  Also, see whether the problem happens in a
     freshly started Emacs without loading your `.emacs' file (start
     Emacs with the `-q' switch to prevent loading the init file.)  If
     the problem does _not_ occur then, you must report the precise
     contents of any programs that you must load into the Lisp world in
     order to cause the problem to occur.

   * If the problem does depend on an init file or other Lisp programs
     that are not part of the standard Emacs system, then you should
     make sure it is not a bug in those programs by complaining to
     their maintainers first.  After they verify that they are using
     Emacs in a way that is supposed to work, they should report the
     bug.

   * If you wish to mention something in the GNU Emacs source, show the
     line of code with a few lines of context.  Don't just give a line
     number.

     The line numbers in the development sources don't match those in
     your sources.  It would take extra work for the maintainers to
     determine what code is in your version at a given line number, and
     we could not be certain.

   * Additional information from a C debugger such as GDB might enable
     someone to find a problem on a machine which he does not have
     available.  If you don't know how to use GDB, please read the GDB
     manual--it is not very long, and using GDB is easy.  You can find
     the GDB distribution, including the GDB manual in online form, in
     most of the same places you can find the Emacs distribution.

     However, you need to think when you collect the additional
     information if you want it to show what causes the bug.

     For example, many people send just a backtrace, but that is not
     very useful by itself.  A simple backtrace with arguments often
     conveys little about what is happening inside GNU Emacs, because
     most of the arguments listed in the backtrace are pointers to Lisp
     objects.  The numeric values of these pointers have no
     significance whatever; all that matters is the contents of the
     objects they point to (and most of the contents are themselves
     pointers).

     To provide useful information, you need to show the values of Lisp
     objects in Lisp notation.  Do this for each variable which is a
     Lisp object, in several stack frames near the bottom of the stack.
     Look at the source to see which variables are Lisp objects,
     because the debugger thinks of them as integers.

     To show a variable's value in Lisp syntax, first print its value,
     then use the user-defined GDB command `pr' to print the Lisp
     object in Lisp syntax.  (If you must use another debugger, call
     the function `debug_print' with the object as an argument.)  The
     `pr' command is defined by the file `.gdbinit' in the `src'
     subdirectory, and it works only if you are debugging a running
     process (not with a core dump).

     To make Lisp errors stop Emacs and return to GDB, put a breakpoint
     at `Fsignal'.

     To find out which Lisp functions are running, using GDB, move up
     the stack, and each time you get to a frame for the function
     `Ffuncall', type these GDB commands:

          p *args
          pr

     To print the first argument that the function received, use these
     commands:

          p args[1]
          pr

     You can print the other arguments likewise.  The argument `nargs'
     of `Ffuncall' says how many arguments `Ffuncall' received; these
     include the Lisp function itself and the arguments for that
     function.

   * If the symptom of the bug is that Emacs fails to respond, don't
     assume Emacs is "hung"--it may instead be in an infinite loop.  To
     find out which, make the problem happen under GDB and stop Emacs
     once it is not responding.  (If Emacs is using X Windows directly,
     you can stop Emacs by typing `C-c' at the GDB job.)  Then try
     stepping with `step'.  If Emacs is hung, the `step' command won't
     return.  If it is looping, `step' will return.

     If this shows Emacs is hung in a system call, stop it again and
     examine the arguments of the call.  In your bug report, state
     exactly where in the source the system call is, and what the
     arguments are.

     If Emacs is in an infinite loop, please determine where the loop
     starts and ends.  The easiest way to do this is to use the GDB
     command `finish'.  Each time you use it, Emacs resumes execution
     until it exits one stack frame.  Keep typing `finish' until it
     doesn't return--that means the infinite loop is in the stack frame
     which you just tried to finish.

     Stop Emacs again, and use `finish' repeatedly again until you get
     _back to_ that frame.  Then use `next' to step through that frame.
     By stepping, you will see where the loop starts and ends.  Also
     please examine the data being used in the loop and try to
     determine why the loop does not exit when it should.  Include all
     of this information in your bug report.

   Here are some things that are not necessary in a bug report:

   * A description of the envelope of the bug--this is not necessary
     for a reproducible bug.

     Often people who encounter a bug spend a lot of time investigating
     which changes to the input file will make the bug go away and which
     changes will not affect it.

     This is often time consuming and not very useful, because the way
     we will find the bug is by running a single example under the
     debugger with breakpoints, not by pure deduction from a series of
     examples.  You might as well save time by not searching for
     additional examples.

     Of course, if you can find a simpler example to report _instead_ of
     the original one, that is a convenience.  Errors in the output
     will be easier to spot, running under the debugger will take less
     time, etc.

     However, simplification is not vital; if you can't do this or
     don't have time to try, please report the bug with your original
     test case.

   * A system call trace of Emacs execution.

     System call traces are very useful for certain special kinds of
     debugging, but in most cases they give little useful information.
     It is therefore strange that many people seem to think that _the_
     way to report information about a crash is to send a system call
     trace.

     In most programs, a backtrace is normally far, far more
     informative than a system call trace.  Even in Emacs, a simple
     backtrace is generally more informative, though to give full
     information you should supplement the backtrace by displaying
     variable values and printing them as Lisp objects with `pr' (see
     above).

   * A patch for the bug.

     A patch for the bug is useful if it is a good one.  But don't omit
     the other information that a bug report needs, such as the test
     case, on the assumption that a patch is sufficient.  We might see
     problems with your patch and decide to fix the problem another
     way, or we might not understand it at all.  And if we can't
     understand what bug you are trying to fix, or why your patch
     should be an improvement, we mustn't install it.

     *Note Sending Patches::, for guidelines on how to make it easy for
     us to understand and install your patches.

   * A guess about what the bug is or what it depends on.

     Such guesses are usually wrong.  Even experts can't guess right
     about such things without first using the debugger to find the
     facts.


File: emacs,  Node: Sending Patches,  Prev: Checklist,  Up: Bugs

Sending Patches for GNU Emacs
-----------------------------

If you would like to write bug fixes or improvements for GNU Emacs,
that is very helpful.  When you send your changes, please follow these
guidelines to make it easy for the maintainers to use them.  If you
don't follow these guidelines, your information might still be useful,
but using it will take extra work.  Maintaining GNU Emacs is a lot of
work in the best of circumstances, and we can't keep up unless you do
your best to help.

   * Send an explanation with your changes of what problem they fix or
     what improvement they bring about.  For a bug fix, just include a
     copy of the bug report, and explain why the change fixes the bug.

     (Referring to a bug report is not as good as including it, because
     then we will have to look it up, and we have probably already
     deleted it if we've already fixed the bug.)

   * Always include a proper bug report for the problem you think you
     have fixed.  We need to convince ourselves that the change is
     right before installing it.  Even if it is correct, we might have
     trouble understanding it if we don't have a way to reproduce the
     problem.

   * Include all the comments that are appropriate to help people
     reading the source in the future understand why this change was
     needed.

   * Don't mix together changes made for different reasons.  Send them
     _individually_.

     If you make two changes for separate reasons, then we might not
     want to install them both.  We might want to install just one.  If
     you send them all jumbled together in a single set of diffs, we
     have to do extra work to disentangle them--to figure out which
     parts of the change serve which purpose.  If we don't have time
     for this, we might have to ignore your changes entirely.

     If you send each change as soon as you have written it, with its
     own explanation, then two changes never get tangled up, and we can
     consider each one properly without any extra work to disentangle
     them.

   * Send each change as soon as that change is finished.  Sometimes
     people think they are helping us by accumulating many changes to
     send them all together.  As explained above, this is absolutely
     the worst thing you could do.

     Since you should send each change separately, you might as well
     send it right away.  That gives us the option of installing it
     immediately if it is important.

   * Use `diff -c' to make your diffs.  Diffs without context are hard
     to install reliably.  More than that, they are hard to study; we
     must always study a patch to decide whether we want to install it.
     Unidiff format is better than contextless diffs, but not as easy
     to read as `-c' format.

     If you have GNU diff, use `diff -c -F'^[_a-zA-Z0-9$]+ *('' when
     making diffs of C code.  This shows the name of the function that
     each change occurs in.

   * Write the change log entries for your changes.  This is both to
     save us the extra work of writing them, and to help explain your
     changes so we can understand them.

     The purpose of the change log is to show people where to find what
     was changed.  So you need to be specific about what functions you
     changed; in large functions, it's often helpful to indicate where
     within the function the change was.

     On the other hand, once you have shown people where to find the
     change, you need not explain its purpose in the change log.  Thus,
     if you add a new function, all you need to say about it is that it
     is new.  If you feel that the purpose needs explaining, it
     probably does--but put the explanation in comments in the code.
     It will be more useful there.

     Please read the `ChangeLog' files in the `src' and `lisp'
     directories to see what sorts of information to put in, and to
     learn the style that we use.  If you would like your name to
     appear in the header line, showing who made the change, send us
     the header line.  *Note Change Log::.

   * When you write the fix, keep in mind that we can't install a
     change that would break other systems.  Please think about what
     effect your change will have if compiled on another type of system.

     Sometimes people send fixes that _might_ be an improvement in
     general--but it is hard to be sure of this.  It's hard to install
     such changes because we have to study them very carefully.  Of
     course, a good explanation of the reasoning by which you concluded
     the change was correct can help convince us.

     The safest changes are changes to the configuration files for a
     particular machine.  These are safe because they can't create new
     bugs on other machines.

     Please help us keep up with the workload by designing the patch in
     a form that is clearly safe to install.


File: emacs,  Node: Contributing,  Next: Service,  Prev: Bugs,  Up: Top

Contributing to Emacs Development
=================================

If you would like to help pretest Emacs releases to assure they work
well, or if you would like to work on improving Emacs, please contact
the maintainers at `bug-gnu-emacs@prep.ai.mit.edu'.  A pretester should
be prepared to investigate bugs as well as report them.  If you'd like
to work on improving Emacs, please ask for suggested projects or
suggest your own ideas.

   If you have already written an improvement, please tell us about it.
If you have not yet started work, it is useful to contact
`bug-gnu-emacs@prep.ai.mit.edu' before you start; it might be possible
to suggest ways to make your extension fit in better with the rest of
Emacs.


File: emacs,  Node: Service,  Next: Command Arguments,  Prev: Contributing,  Up: Top

How To Get Help with GNU Emacs
==============================

If you need help installing, using or changing GNU Emacs, there are two
ways to find it:

   * Send a message to the mailing list
     `help-gnu-emacs@prep.ai.mit.edu', or post your request on
     newsgroup `gnu.emacs.help'.  (This mailing list and newsgroup
     interconnect, so it does not matter which one you use.)

   * Look in the service directory for someone who might help you for a
     fee.  The service directory is found in the file named
     `etc/SERVICE' in the Emacs distribution.


File: emacs,  Node: Command Arguments,  Next: Antinews,  Prev: Service,  Up: Top

Command Line Arguments
**********************

GNU Emacs supports command line arguments to request various actions
when invoking Emacs.  These are for compatibility with other editors and
for sophisticated activities.  We don't recommend using them for
ordinary editing.

   Arguments starting with `-' are "options".  Other arguments specify
files to visit.  Emacs visits the specified files while it starts up.
The last file name on your command line becomes the current buffer; the
other files are also present in other buffers.

   You can use options to specify various other things, such as the size
and position of the X window Emacs uses, its colors, and so on.  A few
options support advanced usage, such as running Lisp functions on files
in batch mode.  The sections of this chapter describe the available
options, arranged according to their purpose.

   There are two ways of writing options: the short forms that start
with a single `-', and the long forms that start with `--'.  For
example, `-d' is a short form and `--display' is the corresponding long
form.

   The long forms with `--' are easier to remember, but longer to type.
However, you don't have to spell out the whole option name; any
unambiguous abbreviation is enough.  When a long option takes an
argument, you can use either a space or an equal sign to separate the
option name and the argument.  Thus, you can write either `--display
sugar-bombs:0.0' or `--display=sugar-bombs:0.0'.  We recommend an equal
sign because it makes the relationship clearer, and the tables below
always show an equal sign.

   Most options specify how to initialize Emacs, or set parameters for
the Emacs session.  We call them "initial options".  A few options
specify things to do: for example, load libraries, call functions, or
exit Emacs.  These are called "action options".  These and file names
together are called "action arguments".  Emacs processes all the action
arguments in the order they are written.

* Menu:

* Action Arguments::	Arguments to visit files, load libraries,
			  and call functions.
* Initial Options::     Arguments that take effect while starting Emacs.
* Command Example::     Examples of using command line arguments.
* Resume Arguments::	Specifying arguments when you resume a running Emacs.
* Environment::         Environment variables that Emacs uses.

* Display X::           Changing the default display and using remote login.
* Font X::	        Choosing a font for text, under X.
* Colors X::	        Choosing colors, under X.
* Window Size X::       Start-up window size, under X.
* Borders X::	        Internal and external borders, under X.
* Title X::             Specifying the initial frame's title.
* Icons X::             Choosing what sort of icon to use, under X.
* Resources X::         Advanced use of classes and resources, under X.
* Lucid Resources::     X resources for Lucid menus.
* Motif Resources::     X resources for Motif menus.


File: emacs,  Node: Action Arguments,  Next: Initial Options,  Up: Command Arguments

Action Arguments
================

Here is a table of the action arguments and options:

`FILE'
     Visit FILE using `find-file'.  *Note Visiting::.

`+LINENUM FILE'
     Visit FILE using `find-file', then go to line number LINENUM in it.

`-l FILE'
`--load=FILE'
     Load a file FILE of Lisp code with the function `load'.  *Note
     Lisp Libraries::.

`-f FUNCTION'
`--funcall=FUNCTION'
     Call Lisp function FUNCTION with no arguments.

`--eval EXPRESSION'
     Evaluate Lisp expression EXPRESSION.

`--insert=FILE'
     Insert the contents of FILE into the current buffer.  This is like
     what `M-x insert-file' does.  *Note Misc File Ops::.

`--kill'
     Exit from Emacs without asking for confirmation.

   The init file can access the values of the action arguments as the
elements of a list in the variable `command-line-args'.  The init file
can override the normal processing of the action arguments, or define
new ones, by reading and setting this variable.


File: emacs,  Node: Initial Options,  Next: Command Example,  Prev: Action Arguments,  Up: Command Arguments

Initial Options
===============

The initial options specify parameter for the Emacs session.  This
section describes the more general initial options; some other options
specifically related to X Windows appear in the following sections.

   Some initial options affect the loading of init files.  The normal
actions of Emacs are to first load `site-start.el' if it exists, then
your own init file `~/.emacs' if it exists, and finally `default.el' if
it exists; certain options prevent loading of some of these files or
substitute other files for them.

`-t DEVICE'
`--terminal=DEVICE'
     Use DEVICE as the device for terminal input and output.

`-d DISPLAY'
`--display=DISPLAY'
     Use the X Window System and use the display named DISPLAY to open
     the initial Emacs frame.

`-nw'
`--no-windows'
     Don't communicate directly with X, disregarding the `DISPLAY'
     environment variable even if it is set.

`-batch'
`--batch'
     Run Emacs in "batch mode", which means that the text being edited
     is not displayed and the standard terminal interrupt characters
     such as `C-z' and `C-c' continue to have their normal effect.
     Emacs in batch mode outputs to `stderr' only what would normally
     be printed in the echo area under program control.

     Batch mode is used for running programs written in Emacs Lisp from
     shell scripts, makefiles, and so on.  Normally the `-l' option or
     `-f' option will be used as well, to invoke a Lisp program to do
     the batch processing.

     `-batch' implies `-q' (do not load an init file).  It also causes
     Emacs to kill itself after all command options have been
     processed.  In addition, auto-saving is not done except in buffers
     for which it has been explicitly requested.

`-q'
`--no-init-file'
     Do not load your Emacs init file `~/.emacs', or `default.el'
     either.

`--no-site-file'
     Do not load `site-start.el'.  The options `-q', `-u' and `-batch'
     have no effect on the loading of this file--this is the only
     option that blocks it.

`-u USER'
`--user=USER'
     Load USER's Emacs init file `~USER/.emacs' instead of your own.

`--debug-init'
     Enable the Emacs Lisp debugger for errors in the init file.


File: emacs,  Node: Command Example,  Next: Resume Arguments,  Prev: Initial Options,  Up: Command Arguments

Command Argument Example
========================

Here is an example of using Emacs with arguments and options.  It
assumes you have a Lisp program file called `hack-c.el' which, when
loaded, performs some useful operation on current buffer, expected to be
a C program.

     emacs -batch foo.c -l hack-c -f save-buffer >& log

This says to visit `foo.c', load `hack-c.el' (which makes changes in
the visited file), save `foo.c' (note that `save-buffer' is the
function that `C-x C-s' is bound to), and then exit back to the shell
(because of `-batch').  `-batch' also guarantees there will be no
problem redirecting output to `log', because Emacs will not assume that
it has a display terminal to work with.


File: emacs,  Node: Resume Arguments,  Next: Environment,  Prev: Command Example,  Up: Command Arguments

Resuming Emacs with Arguments
=============================

You can specify action arguments for Emacs when you resume it after a
suspension.  To prepare for this, put the following code in your
`.emacs' file (*note Hooks::):

     (add-hook 'suspend-hook 'resume-suspend-hook)
     (add-hook 'suspend-resume-hook 'resume-process-args)

   As further preparation, you must execute the shell script
`emacs.csh' (if you use csh as your shell) or `emacs.bash' (if you use
bash as your shell).  These scripts define an alias named `edit', which
will resume Emacs giving it new command line arguments such as files to
visit.

   Only action arguments work properly when you resume Emacs.  Initial
arguments are not recognized--it's too late to execute them anyway.

   Note that resuming Emacs (with or without arguments) must be done
from within the shell that is the parent of the Emacs job.  This is why
`edit' is an alias rather than a program or a shell script.  It is not
possible to implement a resumption command that could be run from other
subjobs of the shell; no way to define a command that could be made the
value of `EDITOR', for example.  Therefore, this feature does not take
the place of the Emacs Server feature (*note Emacs Server::).

   The aliases use the Emacs Server feature if you appear to have a
server Emacs running.  However, they cannot determine this with complete
accuracy.  They may think that a server is still running when in
actuality you have killed that Emacs, because the file `/tmp/.esrv...'
still exists.  If this happens, find that file and delete it.


File: emacs,  Node: Environment,  Next: Display X,  Prev: Resume Arguments,  Up: Command Arguments

Environment Variables
=====================

This appendix describes how Emacs uses environment variables.  An
environment variable is a string passed from the operating system to
Emacs, and the collection of environment variables is known as the
environment.  Environment variable names are case sensitive and it is
conventional to use upper case letters only.

   Because environment variables come from the operating system there
is no general way to set them; it depends on the operating system and
especially the shell that you are using.  For example, here's how to set
the environment variable `ORGANIZATION' to `not very much' using bash:

     export ORGANIZATION="not very much"

and here's how to do it in csh or tcsh:

     setenv ORGANIZATION "not very much"

   When Emacs is set-up to use the X windowing system, it inherits the
use of a large number of environment variables from the X library.  See
the X documentation for more information.

* Menu:

* General Variables::     Environment variables that all versions of Emacs use.
* Misc Variables::        Certain system specific variables.


File: emacs,  Node: General Variables,  Next: Misc Variables,  Up: Environment

General Variables
-----------------

`AUTHORCOPY'
     The name of a file used to archive news articles posted with the
     GNUS package.

`CDPATH'
     Used by the `cd' command.

`DOMAINNAME'
     The name of the internet domain that the machine running Emacs is
     located in.  Used by the GNUS package.

`EMACSDATA'
     Used to initialize the variable `data-directory' used to locate the
     architecture-independent files that come with Emacs.  Setting this
     variable overrides the setting in `paths.h' when Emacs was built.

`EMACSLOADPATH'
     A colon-separated list of directories from which to load Emacs Lisp
     files.  Setting this variable overrides the setting in `paths.h'
     when Emacs was built.

`EMACSLOCKDIR'
     The directory that Emacs places lock files--files used to protect
     users from editing the same files simultaneously.  Setting this
     variable overrides the setting in `paths.h' when Emacs was built.

`EMACSPATH'
     The location of Emacs-specific binaries.  Setting this variable
     overrides the setting in `paths.h' when Emacs was built.

`ESHELL'
     Used for shell-mode to override the `SHELL' environment variable.

`HISTFILE'
     The name of the file that shell commands are saved in between
     logins.  This variable defaults to `~/.history' if you use (t)csh
     as shell, to `~/.bash_history' if you use bash, to `~/.sh_history'
     if you use ksh, and to `~/.history' otherwise.

`HOME'
     The location of the user's files in the directory tree; used for
     expansion of file names starting with a tilde (`~').  On MS-DOS, it
     defaults to the directory from which Emacs was started, with `/bin'
     removed from the end if it was present.

`HOSTNAME'
     The name of the machine that Emacs is running on.

`INCPATH'
     A colon-separated list of directories.  Used by the `complete'
     package to search for files.

`INFOPATH'
     A colon separated list of directories holding info files.  Setting
     this variable overrides the setting in `paths.el' when Emacs was
     built.

`LOGNAME'
     The user's login name.  See also `USER'.

`MAIL'
     The name of the user's system mail box.

`MAILRC'
     Name of file containing mail aliases.  This defaults to
     `~/.mailrc'.

`MH'
     Name of setup file for the mh system.  This defaults to
     `~/.mh_profile'.

`NAME'
     The real-world name of the user.

`NNTPSERVER'
     The name of the news server.  Used by the mh and GNUS packages.

`ORGANIZATION'
     The name of the organization to which you belong.  Used for
     setting the `Organization:' header in your posts from the GNUS
     package.

`PATH'
     A colon-separated list of directories in which executables reside.
     (On MS-DOS, it is semicolon-separated instead.)  This variable is
     used to set the Emacs Lisp variable `exec-path' which you should
     consider to use instead.

`PWD'
     If set, this should be the default directory when Emacs was
     started.

`REPLYTO'
     If set, this specifies an initial value for the variable
     `mail-default-reply-to'.  *Note Mail Headers::.

`SAVEDIR'
     The name of a directory in which news articles are saved by
     default.  Used by the GNUS package.

`SHELL'
     The name of an interpreter used to parse and execute programs run
     from inside Emacs.

`TERM'
     The name of the terminal that Emacs is running on.  The variable
     must be set unless Emacs is run in batch mode.  On MS-DOS, it
     defaults to `internal', which specifies a built-in terminal
     emulation that handles the machine's own display.

`TERMCAP'
     The name of the termcap library file describing how to program the
     terminal specified by the `TERM' variable.  This defaults to
     `/etc/termcap'.

`TMPDIR'
     Used by the Emerge package as a prefix for temporary files.

`TZ'
     This specifies the current time zone and possibly also daylight
     savings information.  On MS-DOS, the default is based on country
     code; see the file `msdos.c' for details.

`USER'
     The user's login name.  See also `LOGNAME'.  On MS-DOS, this
     defaults to `root'.

`VERSION_CONTROL'
     Used to initialize the `version-control' variable (*note Backup
     Names::).


File: emacs,  Node: Misc Variables,  Prev: General Variables,  Up: Environment

Misc Variables
--------------

These variables are used only on particular configurations:

`COMSPEC'
     On MS-DOS, the name of the command interpreter to use.  This is
     used to make a default value for the `SHELL' environment variable.

`NAME'
     On MS-DOS, this variable defaults to the value of the `USER'
     variable.

`TEMP'
`TMP'
     On MS-DOS, these specify the name of the directory for storing
     temporary files in.

`EMACSTEST'
     On MS-DOS, this specifies a file to use to log the operation of the
     internal terminal emulator.  This feature is useful for submitting
     bug reports.

`EMACSCOLORS'
     Used on MS-DOS systems to set screen colors early, so that the
     screen won't momentarily flash the default colors when Emacs
     starts up.  The value of this variable should be two-character
     encoding of the foreground (the first character) and the
     background (the second character) colors of the default face.
     Each character should be the hexadecimal code for the desired
     color on a standard PC text-mode display.

     Only the low three bits of the background color are actually used,
     because the PC display supports only eight background colors.

`WINDOW_GFX'
     Used when initializing the Sun windows system.


File: emacs,  Node: Display X,  Next: Font X,  Prev: Environment,  Up: Command Arguments

Specifying the Display Name
===========================

The environment variable `DISPLAY' tells all X clients, including
Emacs, where to display their windows.  Its value is set up by default
in ordinary circumstances, when you start an X server and run jobs
locally.  Occasionally you may need to specify the display yourself; for
example, if you do a remote login and want to run a client program
remotely, displaying on your local screen.

   With Emacs, the main reason people change the default display is to
let them log into another system, run Emacs on that system, but have the
window displayed at their local terminal.  You might need to use login
to another system because the files you want to edit are there, or
because the Emacs executable file you want to run is there.

   The syntax of the `DISPLAY' environment variable is
`HOST:DISPLAY.SCREEN', where HOST is the host name of the X Window
System server machine, DISPLAY is an arbitrarily-assigned number that
distinguishes your server (X terminal) from other servers on the same
machine, and SCREEN is a rarely-used field that allows an X server to
control multiple terminal screens.  The period and the SCREEN field are
optional.  If included, SCREEN is usually zero.

   For example, if your host is named `glasperle' and your server is
the first (or perhaps the only) server listed in the configuration, your
`DISPLAY' is `glasperle:0.0'.

   You can specify the display name explicitly when you run Emacs,
either by changing the `DISPLAY' variable, or with the option `-d
DISPLAY' or `--display=DISPLAY'.  Here is an example:

     emacs --display=glasperle:0 &

   You can inhibit the direct use of X with the `-nw' option.  This is
also an initial option.  It tells Emacs to display using ordinary ASCII
on its controlling terminal.

   Sometimes, security arrangements prevent a program on a remote system
from displaying on your local system.  In this case, trying to run Emacs
produces messages like this:

     Xlib:  connection to "glasperle:0.0" refused by server

You might be able to overcome this problem by using the `xhost' command
on the local system to give permission for access from your remote
machine.


File: emacs,  Node: Font X,  Next: Colors X,  Prev: Display X,  Up: Command Arguments

Font Specification Options
==========================

By default, Emacs displays text in the font named `9x15', which makes
each character nine pixels wide and fifteen pixels high.  You can
specify a different font on your command line through the option `-fn
NAME'.

`-fn NAME'
     Use font NAME as the default font.

`--font=NAME'
     `--font' is an alias for `-fn'.

   Under X, each font has a long name which consists of eleven words or
numbers, separated by dashes.  Some fonts also have shorter
nicknames--`9x15' is such a nickname.  You can use either kind of name.
You can use wild card patterns for the font name; then Emacs lets X
choose one of the fonts that match the pattern.  Here is an example,
which happens to specify the font whose nickname is `6x13':

     emacs -fn "-misc-fixed-medium-r-semicondensed--13-*-*-*-c-60-iso8859-1" &

You can also specify the font in your `.Xdefaults' file:

     emacs.font: -misc-fixed-medium-r-semicondensed--13-*-*-*-c-60-iso8859-1

   A long font name has the following form:

     -MAKER-FAMILY-WEIGHT-SLANT-WIDTHTYPE-STYLE...
     ...-PIXELS-HEIGHT-HORIZ-VERT-SPACING-WIDTH-CHARSET

FAMILY
     This is the name of the font family-for example, `courier'.

WEIGHT
     This is normally `bold', `medium' or `light'.  Other words may
     appear here in some font names.

SLANT
     This is `r' (roman), `i' (italic), `o' (oblique), `ri' (reverse
     italic), or `ot' (other).

WIDTHTYPE
     This is normally `condensed', `extended', `semicondensed' or
     `normal'.  Other words may appear here in some font names.

STYLE
     This is an optional additional style name.  Usually it is
     empty--most long font names have two hyphens in a row at this
     point.

PIXELS
     This is the font height, in pixels.

HEIGHT
     This is the font height on the screen, measured in printer's points
     (approximately 1/72 of an inch), times ten.  For a given vertical
     resolution, HEIGHT and PIXELS are proportional; therefore, it is
     common to specify just one of them and use `*' for the other.

HORIZ
     This is the horizontal resolution, in pixels per inch, of the
     screen for which the font is intended.

VERT
     This is the vertical resolution, in dots per inch, of the screen
     for which the font is intended.  Normally the resolution of the
     fonts on your system is the right value for your screen;
     therefore, you normally specify `*' for this and HORIZ.

SPACING
     This is `m' (monospace), `p' (proportional) or `c' (character
     cell).  Emacs can use `m' and `c' fonts.

WIDTH
     This is the average character width, in pixels, times ten.

CHARSET
     This is the character set that the font depicts.  Normally you
     should use `iso8859-1'.

   Use only fixed width fonts--that is, fonts in which all characters
have the same width; Emacs cannot yet handle display properly for
variable width fonts.  Any font with `m' or `c' in the SPACING field of
the long name is a fixed width font.  Here's how to use the `xlsfonts'
program to list all the fixed width fonts available on your system:

     xlsfonts -fn '*x*'
     xlsfonts -fn '*-*-*-*-*-*-*-*-*-*-*-m*'
     xlsfonts -fn '*-*-*-*-*-*-*-*-*-*-*-c*'

To see what a particular font looks like, use the `xfd' command.  For
example:

     xfd -fn 6x13

displays the entire font `6x13'.

   While running Emacs, you can set the font of the current frame
(*note Frame Parameters::) or for a specific kind of text (*note
Faces::).


File: emacs,  Node: Colors X,  Next: Window Size X,  Prev: Font X,  Up: Command Arguments

Window Color Options
====================

On a color display, you can specify which color to use for various
parts of the Emacs display.  To find out what colors are available on
your system, look at the `/usr/lib/X11/rgb.txt' file.  If you do not
specify colors, the default for the background is white and the default
for all other colors is black.  On a monochrome display, the foreground
is black, the background is white, and the border is gray if the
display supports that.

   Here is a list of the options for specifying colors:

`-fg COLOR'
`--foreground-color=COLOR'
     Specify the foreground color.

`-bg COLOR'
`--background-color=COLOR'
     Specify the background color.

`-bd COLOR'
`--border-color=COLOR'
     Specify the color of the border of the X window.

`-cr COLOR'
`--cursor-color=COLOR'
     Specify the color of the Emacs cursor which indicates where point
     is.

`-ms COLOR'
`--mouse-color=COLOR'
     Specify the color for the mouse cursor when the mouse is in the
     Emacs window.

`-r'
`--reverse-video'
     Reverse video--swap the foreground and background colors.

   For example, to use a coral mouse cursor and a slate blue text
cursor, enter:

     emacs -ms coral -cr 'slate blue' &

   You can reverse the foreground and background colors through the
`-r' option or with the X resource `reverseVideo'.


File: emacs,  Node: Window Size X,  Next: Borders X,  Prev: Colors X,  Up: Command Arguments

Options for Window Geometry
===========================

The `-geometry' option controls the size and position of the initial
Emacs frame.  Here is the format for specifying the window geometry:

`-g WIDTHxHEIGHT{+-}XOFFSET{+-}YOFFSET'
     Specify window size WIDTH and HEIGHT (measured in character
     columns and lines), and positions XOFFSET and YOFFSET (measured in
     pixels).

`--geometry=WIDTHxHEIGHT{+-}XOFFSET{+-}YOFFSET'
     This is another way of writing the same thing.

`{+-}' means either a plus sign or a minus sign.  A plus sign before
XOFFSET means it is the distance from the left side of the screen; a
minus sign means it counts from the right side.  A plus sign before
YOFFSET means it is the distance from the top of the screen, and a
minus sign there indicates the distance from the bottom.  The values
XOFFSET and YOFFSET may themselves be positive or negative, but that
doesn't change their meaning, only their direction.

   Emacs uses the same units as `xterm' does to interpret the geometry.
The WIDTH and HEIGHT are measured in characters, so a large font
creates a larger frame than a small font.  The XOFFSET and YOFFSET are
measured in pixels.

   Since the mode line and the echo area occupy the last 2 lines of the
frame, the height of the initial text window is 2 less than the height
specified in your geometry.  In non-X-toolkit versions of Emacs, the
menu bar also takes one line of the specified number.

   You do not have to specify all of the fields in the geometry
specification.

   If you omit both XOFFSET and YOFFSET, the window manager decides
where to put the Emacs frame, possibly by letting you place it with the
mouse.  For example, `164x55' specifies a window 164 columns wide,
enough for two ordinary width windows side by side, and 55 lines tall.

   The default width for Emacs is 80 characters and the default height
is 40 lines.  You can omit either the width or the height or both.  If
you start the geometry with an integer, Emacs interprets it as the
width.  If you start with an `x' followed by an integer, Emacs
interprets it as the height.  Thus, `81' specifies just the width;
`x45' specifies just the height.

   If you start with `+' or `-', that introduces an offset, which means
both sizes are omitted.  Thus, `-3' specifies the XOFFSET only.  (If
you give just one offset, it is always XOFFSET.)  `+3-3' specifies both
the XOFFSET and the YOFFSET, placing the frame near the bottom left of
the screen.

   You can specify a default for any or all of the fields in
`.Xdefaults' file, and then override selected fields with a
`--geometry' option.


File: emacs,  Node: Borders X,  Next: Title X,  Prev: Window Size X,  Up: Command Arguments

Internal and External Borders
=============================

An Emacs frame has an internal border and an external border.  The
internal border is an extra strip of the background color around all
four edges of the frame.  Emacs itself adds the internal border.  The
external border is added by the window manager outside the internal
border; it may contain various boxes you can click on to move or iconify
the window.

`-ib WIDTH'

`--internal-border=WIDTH'
     Specify WIDTH as the width of the internal border.

`-bw WIDTH'

`--border-width=WIDTH'
     Specify WIDTH as the width of the main border.

   When you specify the size of the frame, that does not count the
borders.  The frame's position is measured from the outside edge of the
external border.

   Use the `-ib N' option to specify an internal border N pixels wide.
The default is 1.  Use `-bw N' to specify the width of the external
border (though the window manager may not pay attention to what you
specify).  The default width of the external border is 2.


File: emacs,  Node: Title X,  Next: Icons X,  Prev: Borders X,  Up: Command Arguments

Frame Titles
============

An Emacs frame may or may not have a specified title.  The frame title,
if specified, appears in window decorations and icons as the name of
the frame.  If an Emacs frame has no specified title, the default title
is the name of the executable program (if there is only one frame) or
the selected window's buffer name (if there is more than one frame).

   You can specify a title for the initial Emacs frame with a command
line option:

`-title TITLE'
`--title=TITLE'
`-T TITLE'
     Specify TITLE as the title for the initial Emacs frame.

   The `--name' option (*note Resources X::) also specifies the title
for the initial Emacs frame.


File: emacs,  Node: Icons X,  Next: Resources X,  Prev: Title X,  Up: Command Arguments

Icons
=====

Most window managers allow the user to "iconify" a frame, removing it
from sight, and leaving a small, distinctive "icon" window in its
place.  Clicking on the icon window makes the frame itself appear again.
If you have many clients running at once, you can avoid cluttering up
the screen by iconifying most of the clients.

`-i'
`--icon-type'
     Use a picture of a gnu as the Emacs icon.

`-iconic'
`--iconic'
     Start Emacs in iconified state.

   The `-i' or `--icon-type' option tells Emacs to use an icon window
containing a picture of the GNU gnu.  If omitted, Emacs lets the window
manager choose what sort of icon to use--usually just a small rectangle
containing the frame's title.

   The `-iconic' option tells Emacs to begin running as an icon, rather
than opening a frame right away.  In this situation, the icon window
provides only indication that Emacs has started; the usual text frame
doesn't appear until you deiconify it.


File: emacs,  Node: Resources X,  Next: Lucid Resources,  Prev: Icons X,  Up: Command Arguments

X Resources
===========

Programs running under the X Window System organize their user options
under a hierarchy of classes and resources.  You can specify default
values for these options in your X resources file, usually named
`~/.Xdefaults'.

   Each line in the file specifies a value for one option or for a
collection of related options, for one program or for several programs
(optionally even for all programs).

   Programs define named resources with particular meanings.  They also
define how to group resources into named classes.  For instance, in
Emacs, the `internalBorder' resource controls the width of the internal
border, and the `borderWidth' resource controls the width of the
external border.  Both of these resources are part of the `BorderWidth'
class.  Case distinctions are significant in these names.

   In `~/.Xdefaults', you can specify a value for a single resource on
one line, like this:

     emacs.borderWidth: 2

Or you can use a class name to specify the same value for all resources
in that class.  Here's an example:

     emacs.BorderWidth: 2

   If you specify a value for a class, it becomes the default for all
resources in that class.  You can specify values for individual
resources as well; these override the class value, for those particular
resources.  Thus, this example specifies 2 as the default width for all
borders, but overrides this value with 4 for the external border:

     emacs.Borderwidth: 2
     emacs.borderwidth: 4

   The order in which the lines appear in the file does not matter.
Also, command-line options always override the X resources file.

   The string `emacs' in the examples above is also a resource name.
It actually represents the name of the executable file that you invoke
to run Emacs.  If Emacs is installed under a different name, it looks
for resources under that name instead of `emacs'.

`-name NAME'
`--name=NAME'
     Use NAME as the resource name (and the title) for the initial
     Emacs frame.  This option does not affect subsequent frames, but
     Lisp programs can specify frame names when they create frames.

     If you don't specify this option, the default is to use the Emacs
     executable's name as the resource name.

`-xrm RESOURCE-VALUES'
`--xrm=RESOURCE-VALUES'
     Specify X resource values for this Emacs job (see below).

   For consistency, `-name' also specifies the name to use for other
resource values that do not belong to any particular frame.

   The resources that name Emacs invocations also belong to a class; its
name is `Emacs'.  If you write `Emacs' instead of `emacs', the resource
applies to all frames in all Emacs jobs, regardless of frame titles and
regardless of the name of the executable file.  Here is an example:

     Emacs.BorderWidth: 2
     Emacs.borderWidth: 4

   You can specify a string of additional resource values for Emacs to
use with the command line option `-xrm RESOURCES'.  The text RESOURCES
should have the same format that you would use inside a file of X
resources.  To include multiple resource specifications in DATA, put a
newline between them, just as you would in a file.  You can also use
`#include "FILENAME"' to include a file full of resource
specifications.  Resource values specified with `-xrm' take precedence
over all other resource specifications.

   The following table lists the resource names that designate options
for Emacs, each with the class that it belongs to:

`background' (class `Background')
     Background color name.

`bitmapIcon' (class `BitmapIcon')
     Use a bitmap icon (a picture of a gnu) if `on', let the window
     manager choose an icon if `off'.

`borderColor' (class `BorderColor')
     Color name for the external border.

`borderWidth' (class `BorderWidth')
     Width in pixels of the external border.

`cursorColor' (class `Foreground')
     Color name for text cursor (point).

`font' (class `Font')
     Font name for text.

`foreground' (class `Foreground')
     Color name for text.

`geometry' (class `Geometry')
     Window size and position.  Be careful not to specify this resource
     as `emacs*geometry', because that may affect individual menus as
     well as the Emacs frame itself.

     If this resource specifies a position, that position applies only
     to the initial Emacs frame (or, in the case of a resource for a
     specific frame name, only that frame).  However, the size if
     specified here applies to all frames.

`iconName' (class `Title')
     Name to display in the icon.

`internalBorder' (class `BorderWidth')
     Width in pixels of the internal border.

`menuBar' (class `MenuBar')
     Give frames menu bars if `on'; don't have menu bars if `off'.

`paneFont' (class `Font')
     Font name for menu pane titles, in non-toolkit versions of Emacs.

`pointerColor' (class `Foreground')
     Color of the mouse cursor.

`reverseVideo' (class `ReverseVideo')
     Switch foreground and background default colors if `on', use
     colors as specified if `off'.

`verticalScrollBars' (class `ScrollBars')
     Give frames scroll bars if `on'; don't have scroll bars if `off'.

`selectionFont' (class `Font')
     Font name for pop-up menu items, in non-toolkit versions of Emacs.
     (For toolkit versions, see *Note Lucid Resources::, also see
     *Note Motif Resources::.)

`title' (class `Title')
     Name to display in the title bar of the initial Emacs frame.

   Here are resources for controlling the appearance of particular faces
(*note Faces::):

`FACE.attributeFont'
     Font for face FACE.

`FACE.attributeForeground'
     Foreground color for face FACE.

`FACE.attributeBackground'
     Background color for face FACE.

`FACE.attributeUnderline'
     Underline flag for face FACE.  Use `on' or `true' for yes.


File: emacs,  Node: Lucid Resources,  Next: Motif Resources,  Prev: Resources X,  Up: Command Arguments

Lucid Menu X Resources
======================

If the Emacs installed at your site was built to use the X toolkit with
the Lucid menu widgets, then the menu bar is a separate widget and has
its own resources.  The resource names contain `pane.menubar'
(following, as always, the name of the Emacs invocation or `Emacs'
which stands for all Emacs invocations).  Specify them like this:

     Emacs.pane.menubar.RESOURCE:  VALUE

For example, to specify the font `8x16' for the menu bar items, write
this:

     Emacs.pane.menubar.font:  8x16

   Resources for _non-menubar_ toolkit popup menus have `menu*', in
like fashion.  For example, to specify the font `8x16' for the popup
menu items, write this:

     Emacs.menu*.font:	8x16

   For dialog boxes, use `dialog' instead of `menu':

     Emacs.dialog*.font:	8x16

   Experience shows that on some systems you may need to add `shell.'
before the `pane.menubar' or `menu*'.  On some other systems, you must
not add `shell.'.

   Here is a list of the specific resources for menu bars and popup
menus:

`font'
     Font for menu item text.

`foreground'
     Color of the foreground.

`background'
     Color of the background.

`buttonForeground'
     In the menu bar, the color of the foreground for a selected item.

`horizontalSpacing'
     Horizontal spacing in pixels between items.  Default is 3.

`verticalSpacing'
     Vertical spacing in pixels between items.  Default is 1.

`arrowSpacing'
     Horizontal spacing between the arrow (which indicates a submenu)
     and the associated text.  Default is 10.

`shadowThickness'
     Thickness of shadow line around the widget.


File: emacs,  Node: Motif Resources,  Prev: Lucid Resources,  Up: Command Arguments

Motif Menu X Resources
======================

If the Emacs installed at your site was built to use the X toolkit with
the Motif widgets, then the menu bar is a separate widget and has its
own resources.  The resource names contain `pane.menubar' (following,
as always, the name of the Emacs invocation or `Emacs' which stands for
all Emacs invocations).  Specify them like this:

     Emacs.pane.menubar.SUBWIDGET.RESOURCE:  VALUE

   Each individual string in the menu bar is a subwidget; the
subwidget's name is the same as the menu item string.  For example, the
word `Files' in the menu bar is part of a subwidget named
`emacs.pane.menubar.Files'.  Most likely, you want to specify the same
resources for the whole menu bar.  To do this, use `*' instead of a
specific subwidget name.  For example, to specify the font `8x16' for
the menu bar items, write this:

     Emacs.pane.menubar.*.fontList:  8x16

This also specifies the resource value for submenus.

   Each item in a submenu in the menu bar also has its own name for X
resources; for example, the `Files' submenu has an item named `Save
Buffer'.  A resource specification for a submenu item looks like this:

     Emacs.pane.menubar.popup_*.MENU.ITEM.RESOURCE: VALUE

For example, here's how to specify the font for the `Save Buffer' item:

     Emacs.pane.menubar.popup_*.Files.Save Buffer.fontList: 8x16

   For an item in a second-level submenu, such as `Check Message' under
`Spell' under `Edit', the resource fits this template:

     Emacs.pane.menubar.popup_*.popup_*.MENU.RESOURCE: VALUE

For example,

     Emacs.pane.menubar.popup_*.popup_*.Spell.Check Message: VALUE

   It's impossible to specify a resource for all the menu bar items
without also specifying it for the submenus as well.  So if you want the
submenu items to look different from the menu bar itself, you must ask
for that in two steps.  First, specify the resource for all of them;
then, override the value for submenus alone.  Here is an example:

     Emacs.pane.menubar.*.fontList:  8x16
     Emacs.pane.menubar.popup_*.fontList: 8x16

   For toolkit popup menus, use `menu*' instead of `pane.menubar'.  For
example, to specify the font `8x16' for the popup menu items, write
this:

     Emacs.menu*.fontList:  8x16

   Here is a list of the specific resources for menu bars and popup
menus:

`armColor'
     The color to show in an armed button.

`fontList'
     The font to use.

`marginBottom'
`marginHeight'
`marginLeft'
`marginRight'
`marginTop'
`marginWidth'
     Amount of space to leave around the item, within the border.

`borderWidth'
     The width of border around the menu item, on all sides.

`shadowThickness'
     The width of the border shadow.

`bottomShadowColor'
     The color for the border shadow, on the bottom and the right.

`topShadowColor'
     The color for the border shadow, on the bottom and the right.


File: emacs,  Node: Antinews,  Next: MS-DOS,  Prev: Command Arguments,  Up: Top

Emacs 19.28 and 19.29 Antinews
******************************

For those users who live backwards in time, here is information about
downgrading to Emacs version 19.28 or 19.29.  We hope you will enjoy the
greater simplicity that results from the absence of certain Emacs 19.34
features.

   * This version doesn't support Windows NT, or the DEC Alpha.

   * In Emacs 19.28, or even 19.29, the features for controlling
     indentation in C are much simpler.  There is a separate variable
     for each aspect of indentation which you can control.  Here is a
     list of them:

    `c-indent-level'
          Level of indentation of C statements with respect to
          containing block.

    `c-label-offset'
          Offset of C label lines and case statements relative to usual
          indentation.

    `c-continued-brace-offset'
          Extra indentation for substatements that start with
          open-braces.  This is in addition to
          `c-continued-statement-offset'.

    `c-continued-statement-offset'
          Extra indentation for lines not starting new statements.

    `c-brace-offset'
          Extra indentation for braces, compared with other text in
          same context.

    `c-brace-imaginary-offset'
          Imagined indentation of a C open brace that actually follows
          a statement.

    `c-argdecl-indent'
          Indentation level of declarations of C function arguments.

   * There is no support for editing formatted text.  The text formatter
     TeX does a much better job of formatting than any formatted text
     editor; we recommend you learn to use it.

   * `C-Mouse-2' now runs the menu for setting the default font.

   * <F1> is no longer an alias for the Help key; you must actually type
     `C-h' if you want help.

   * Integers and buffer sizes are limited to 24 bits on most machines.
     But as memory gets more expensive, you won't want to edit such
     large files any more.

   * There are no indirect buffers, so you can only display one view of
     an outline.  Meanwhile, the prefix key for Outline minor mode is
     now `C-c C-o'.

   * When you are in Transient Mark mode, incremental search always
     deactivates the mark.

   * Dynamic abbrev completion has been eliminated in 19.28, and some
     of the other dynamic abbrev customization features are also gone.

   * In Dired, Occur mode, Compilation mode, and other such modes, you
     must use `C-c C-c' to select the item point is on.  <RET> won't do
     it.

   * `M-x buffer-menu' now displays the menu buffer in another window.

   * The VC (version control) package no longer supports CVS or
     selecting branches other than the principal branch.

   * There is no `recover-session' command; if Emacs crashes, you simply
     have to remember which files you were editing before the crash,
     and use `recover-file' on the individual files.

   * In Emacs Lisp mode, `C-M-x' now lets `defvar' operate as it
     usually does--setting the value of the variable only if it has no
     value yet.  Use `<ESC> <ESC>' to evaluate a Lisp expression,
     instead of `M-:'.

   * GNU-standard long option names are not supported.  (Real hackers
     prefer the shorter single-dash names, to save typing.)  All the
     initial options must come before all the action options, and
     whatever initial options you use must appear in this order: `-t',
     `-d', `-nw', `-batch', `-q' or `-no-init-file', `-no-site-file',
     `-u' or `-user', `-debug-init'.

   * Many special-case kludges for MS-DOS have been removed.  This means
     that many features don't work on MS-DOS; however, the code of Emacs
     is much simpler.

     For instance, you cannot print from within Emacs, Dired doesn't
     support shell wildcards in filenames, some Lisp packages won't
     work because their standard filenames are invalid on MS-DOS,
     `display-time' doesn't work, Font Lock mode won't work unless you
     create some faces by hand first, and `call-process' cannot
     redirect `stderr'.

     As an additional bonus, you get random characters inserted into the
     buffer without a warning (unless you're clever enough to discover
     that setting `visible-bell' makes this problem to go away).

     In a word, it's a great relief for those who still need proof that
     MS-DOG isn't a real operating system.


File: emacs,  Node: MS-DOS,  Next: Manifesto,  Prev: Antinews,  Up: Top

MS-DOS Issues
*************

This section briefly describes the peculiarities of using Emacs under
the MS-DOS "operating system" (also known as "MS-DOG").  If you build
Emacs for MS-DOS, the binary will also run on Windows 3, Windows NT,
Windows 95, or OS-2 as a DOS application; the information in this
chapter applies for all of those systems, if you use an Emacs that was
built for MS-DOS.

   Note that it is possible to build Emacs specifically for Windows NT
or Windows 95.  If you do that, most of this chapter does not apply;
instead, you get behavior much closer to what is documented in the rest
of the manual, including support for long file names, multiple frames,
scroll bars, mouse menus, and subprocesses.  However, the section on
text files and binary files does still apply.  There are also two
sections at the end of this chapter which apply specifically for Windows
NT and 95.

* Menu:

* Keyboard and Mouse on MS-DOS::
* Display on MS-DOS::
* File Names on MS-DOS::
* Text and Binary::
* Printing and MS-DOS::
* Subprocesses on MS-DOS::
* Windows Subprocesses::
* System Menu on Windows::


File: emacs,  Node: Keyboard and Mouse on MS-DOS,  Next: Display on MS-DOS,  Up: MS-DOS

Keyboard and Mouse on MS-DOS
============================

The PC keyboard maps use the left <Alt> key as the <META> key.  You
have two choices for emulating the <SUPER> and <HYPER> keys: either the
right <CONTROL> key or the right <ALT> key by setting the variables
`dos-hyper-key' and `dos-super-key' to 1 or 2 respectively.

   The variable `dos-keypad-mode' is a flag variable which controls
what key codes are returned by keys in the numeric keypad.  There is no
dedicated <LFD> key; use `C-j' instead.  You can also define the
<kp-enter> key to act as <LFD>, by putting the following line into your
`_emacs' file:

     ;; Make the Enter key from the Numeric keypad act as LFD.
     (define-key function-key-map [kp-enter] [?\C-j])

   The key which is called <DEL> in Emacs (because that's how it is
designated on most workstations) is known as <BS> (backspace) on a PC.
That is why the PC-specific terminal initialization remaps the <BS> key
to act as <DEL>; the <DEL> key is remapped to act as `C-d' for the same
reasons.

   Emacs on MS-DOS supports a mouse (on the default terminal only).
The mouse commands work as documented, including those that use menus
and the menu bar (*note Menu Bars::).  Scroll bars don't work in MS-DOS
Emacs.  PC mice usually have only two buttons; these act as `Mouse-1'
and `Mouse-2', but if you press both of them together, that has the
effect of `Mouse-3'.

   The variable `dos-display-scancodes', when non-`nil', directs Emacs
to display the ASCII value and the keyboard scan code of each
keystroke; this feature serves as a complement to the `view-lossage'
command, for debugging.


File: emacs,  Node: Display on MS-DOS,  Next: File Names on MS-DOS,  Prev: Keyboard and Mouse on MS-DOS,  Up: MS-DOS

Display on MS-DOS
=================

Display on MS-DOS cannot use multiple fonts, but it does support
multiple faces, each of which can specify a foreground and a background
color.  Therefore, you can get the full functionality of Emacs packages
which use fonts (such as `font-lock', Enriched Text mode, and others)
by defining the relevant faces to use different colors.  Use the
`list-colors-display' and `list-faces-display' commands (*note
Modifying Faces::) to see what colors and faces are available and what
they look like.

   Multiple frames (*note Frames::) are supported on MS-DOS, but they
all overlap, so you only see a single frame at any given moment.  That
single visible frame occupies the entire screen.  When you run Emacs
under Windows version 3, you can make the visible frame smaller than
the full screen, but Emacs still cannot display more than a single
frame at a time.

   The `mode4350' command switches the display to 43 or 50 lines,
depending on your hardware; the `mode25' command switches to the
default 80x25 screen size.

   By default, Emacs only knows how to set screen sizes of 80 columns by
25 or 43/50 rows.  However, if your video adapter has special video
modes that will switch the display to other sizes, you can have Emacs
support those too.  When you ask Emacs to switch the frame to N rows by
M cols dimensions, it checks if there is a variable called
`screen-dimensions-NxM', and if so, uses its value (which must be an
integer) as the video mode to switch to.  (Emacs switches to that video
mode by calling the BIOS `Set Video Mode' function with the value of
`screen-dimensions-NxM' in the `AL' register.)  For example, suppose
your adapter will switch to 66x80 dimensions when put into video mode
85.  Then you can make Emacs support this screen size by putting the
following into your `_emacs' file:

     (setq screen-dimensions-66x80 85)

   Since Emacs on MS-DOS can only set the frame size to specific
supported dimensions, it cannot honor every possible frame resizing
request.  When an unsupported size is requested, Emacs chooses the next
larger supported size beyond the specified size.  For example, if you
ask for 36x80 frame, you will get 50x80 instead.

   The variables `screen-dimensions-NxM' are used only when they
exactly match the specified size; the search for the next larger
supported size ignores them.  In the above example, even if your VGA
supports 44x80 dimensions and you define a variable
`screen-dimensions-44x80' with a suitable value, you will still get
50x80 screen when you ask for a 36x80 frame.  If you want to get the
44x80 size in this case, you can do it by setting the variable named
`screen-dimensions-36x80' with the same video mode value as
`screen-dimensions-44x80'.

   Changing frame dimensions on MS-DOS has the effect of changing all
the other frames to the new dimensions.


File: emacs,  Node: File Names on MS-DOS,  Next: Text and Binary,  Prev: Display on MS-DOS,  Up: MS-DOS

File Names on MS-DOS
====================

MS-DOS normally uses a backslash, `\', to separate name units within a
file name, instead of the slash used on other systems.  Emacs on MS-DOS
permits use of either slash or backslash, and also knows about drive
letters in file names.

   On MS-DOS, file names are case-insensitive and limited to eight
characters, plus optionally a period and three more characters.  Emacs
knows enough about these limitations to handle file names that were
meant for other operating systems.  For instance, leading dots `.' in
file names are invalid in MS-DOS, so Emacs transparently converts them
to underscores `_'; thus your default init file (*note Init File::) is
called `_emacs' on MS-DOS.  Excess characters before or after the
period are generally ignored by MS-DOS itself, so if you, e.g., visit a
file `LongFileName.EvenLongerExtension', you will silently get
`longfile.eve'; but Emacs will still display the long file name on the
mode line.  Other than that, it's up to you to specify file names which
are valid under MS-DOS; the transparent conversion as described above
only works on file names built into Emacs.

   The above restrictions on the file names on MS-DOS make it almost
impossible to construct the name of a backup file (*note Backup
Names::) without losing some of the original file name characters.  For
example, the name of a backup file for `docs.txt' is `docs.tx~' even if
single backup is used.

   If you run Emacs as a DOS application under Windows 95 or NT, you can
turn on support for long file names.  If you do that, Emacs doesn't
truncate file names or convert them to lower case; instead, it uses the
file names that you specify, verbatim.  To enable long file name
support, set the environment variable `LFN' to `y' before starting
Emacs.

   MS-DOS has no notion of home directory, so Emacs on MS-DOS pretends
that the directory where it is installed is the value of `HOME'
environment variable.  That is, if your Emacs binary, `emacs.exe', is
in the directory `c:/utils/emacs/bin', then Emacs acts as if `HOME'
were set to `c:/utils/emacs'.  In particular, that is where Emacs looks
for the init file `_emacs'.  With this in mind, you can use `~' in file
names as an alias for the home directory, as you would in Unix.  You
can also set `HOME' variable in the environment before starting Emacs;
its value will then override the above default behavior.


File: emacs,  Node: Text and Binary,  Next: Printing and MS-DOS,  Prev: File Names on MS-DOS,  Up: MS-DOS

Text Files and Binary Files
===========================

Emacs on MS-DOS distinguishes between text and binary files.  This
distinction is not part of MS-DOS; it is made by Emacs only.  Emacs
treats files of human-readable text (including program source code) as
text files, and treats executable programs, compressed archives, etc.,
as binary files.  Emacs uses the file name to decide whether to treat a
file as text or binary: the variable `file-name-buffer-file-type-alist'
defines the file name patterns which denote binary files.

   Emacs reads and writes binary files verbatim.  Text files use a two
character sequence to end a line: carriage-return (control-m) followed
by newline (control-j).  When you visit a text file, Emacs strips off
these control-m characters; when you write a text file to disk, Emacs
puts them back in.  Thus, the text appears within Emacs with just a
newline character at the end of each line.

   You can tell whether Emacs considers the visited file as text or
binary based on the mode line (*note Mode Line::).  Text files have a
`T:' marker prefixed to the major mode name; binary files have a `B:'
prefix.

   One consequence of this special format-conversion of text files is
that character positions as reported by Emacs (*note Position Info::)
do not agree with the file size information known to the operating
system.


File: emacs,  Node: Printing and MS-DOS,  Next: Subprocesses on MS-DOS,  Prev: Text and Binary,  Up: MS-DOS

Printing and MS-DOS
===================

Printing commands, such as `lpr-buffer' (*note Hardcopy::) and
`ps-print-buffer' (*note Postscript::) can work in MS-DOS by sending
the output to one of the printer ports, if a Unix-style `lpr' program
is unavailable.  A few DOS-specific variables control how this works.

   If you want to use your local printer, printing on it in the usual
DOS manner, then set the Lisp variable `dos-printer' to the name of the
printer port--for example. `"PRN"', the usual local printer port
(that's the default), or `"LPT2"' or `"COM1"' for a serial printer.
You can also set `dos-printer' to a file name, in which case "printed"
output is actually appended to that file.  If you set `dos-printer' to
`"NUL"', printed output is silently discarded.

   If you set `dos-printer' to a file name, it's best to use an
absolute file name.  Emacs changes the working directory according to
the default directory of the current buffer, so if the file name in
`dos-printer' is relative, you will end up with several such files,
each one in the directory of the buffer from which the printing was
done.

   The commands `print-buffer' and `print-region' call the `pr'
program, or use special switches to the `lpr' program, to produce
headers on each printed page.  MS-DOS doesn't normally have these
programs, so by default, the variable `lpr-headers-switches' is set so
that the requests to print page headers are silently ignored.  Thus,
`print-buffer' and `print-region' produce the same output as
`lpr-buffer' and `lpr-region', respectively.  If you do have a suitable
`pr' program (e.g., from GNU Textutils), set `lpr-headers-switches' to
`nil'; Emacs will then call `pr' to produce the page headers, and print
the resulting output as specified by `dos-printer'.

   Finally, if you do have an `lpr' work-alike, you can set
`print-region-function' to `nil'.  Then Emacs uses `lpr' for printing,
as on other systems.  (If the name of the program isn't `lpr', set the
`lpr-command' variable to specify where to find it.)

   A separate variable, `dos-ps-printer', defines how PostScript files
should be printed.  If its value is a string, it is used as the name of
the device (or file) to which PostScript output is sent, just as
`dos-printer' is used for non-PostScript printing.  (These are two
distinct variables in case you have two printers attached to two
different ports, and only one of them is a PostScript printer.)  If the
value of `dos-ps-printer' is not a string, then the variables
`ps-lpr-command' and `ps-lpr-switches' (*note Postscript::) control how
to print PostScript files.  Thus, if you have a non-PostScript printer,
you can set these variables to the name and the switches appropriate
for a PostScript interpreter program (e.g., Ghostscript).

   For example, to use Ghostscript for printing on an Epson printer
connected to `LPT2' port, put this on your `.emacs' file:

     (setq dos-ps-printer t)  ; Anything but a string.
     (setq ps-lpr-command "c:/gs/gs386")
     (setq ps-lpr-switches '("-q" "-dNOPAUSE"
     			"-sDEVICE=epson"
     			"-r240x72"
     			"-sOutputFile=LPT2"
     			"-Ic:/gs"
     			"-"))

(This assumes that Ghostscript is installed in the `"c:/gs"' directory.)


File: emacs,  Node: Subprocesses on MS-DOS,  Next: Windows Subprocesses,  Prev: Printing and MS-DOS,  Up: MS-DOS

Subprocesses on MS-DOS
======================

Because MS-DOS is a single-process "operating system", asynchronous
subprocesses are not available.  In particular, Shell mode and its
variants do not work.  Most Emacs features that use asynchronous
subprocesses also don't work on MS-DOS, including spelling correction
and GUD.  When in doubt, try and see; commands that don't work print an
error message saying that asynchronous processes aren't supported.

   Compilation under Emacs with `M-x compile' and grep with `M-x grep'
do work, by running the inferior processes synchronously.  This means
you cannot do any more editing until the compilation or the grep
process finishes.

   Printing commands, such as `lpr-buffer' (*note Hardcopy::) and
`ps-print-buffer' (*note Postscript::), work in MS-DOS by sending the
output to one of the printer ports.  *Note Printing and MS-DOS::.

   When you run a subprocess synchronously on MS-DOS, make sure the
program terminates and does not try to read keyboard input.  If the
program does not terminate on its own, you will be unable to terminate
it, because MS-DOS provides no general way to terminate a process.

   Accessing files on other machines is not supported on MS-DOS.  Other
network-oriented commands such as sending mail, Web browsing, remote
login, etc., don't work either, unless network access is built into
MS-DOS with some network redirector.

   Dired on MS-DOS uses the `ls-lisp' package where other platforms use
the system `ls' command.  Therefore, Dired on MS-DOS supports only some
of the possible options you can mention in the `dired-listing-switches'
variable.  The options that work are `-A', `-a', `-c', `-i', `-r', `-S',
`-s', `-t', and `-u'.


File: emacs,  Node: Windows Subprocesses,  Next: System Menu on Windows,  Prev: Subprocesses on MS-DOS,  Up: MS-DOS

Subprocesses on Windows 95 and Windows NT
=========================================

Subprocesses, both synchronous and asynchronous, work fine on both
Windows 95 and Windows NT as long as you run only 32-bit Windows
applications.  However, when you run a DOS application in a subprocess,
you may encounter problems or be unable to run the application at all;
and if you run two DOS applications at the same time in two
subprocesses, you may have to reboot your system.

   Since the standard command interpreter (and most command line
utilities) on Windows 95 are DOS applications, these problems are
significant when using that system.  But there's nothing we can do
about them; only Microsoft can fix them.

   If you run just one DOS application subprocess, the subprocess should
work as expected as long as it is "well-behaved" and does not perform
direct screen access or other unusual actions.  If you have a CPU
monitor application, your machine will appear to be 100% busy even when
the DOS application is idle, but this is only an artefact of the way CPU
monitors measure processor load.

   You must terminate the DOS application before you start any other DOS
application in a different subprocess.  Emacs is unable to interrupt or
terminate a DOS subprocess.  The only way you can terminate such a
subprocess is by giving it a command that tells its program to exit.

   If you attempt to run two DOS applications at the same time in
separate subprocesses, the second one that is started will be suspended
until the first one finishes, even if either or both of them are
asynchronous.

   If you can go to the first subprocess, and tell it to exit, the
second subprocess should continue normally.  However, if the second
subprocess is synchronous, Emacs itself will be hung until the first
subprocess finishes.  If it will not finish without user input, then
you have no choice but to reboot if you are running on Windows 95.  If
you are running on Windows NT, you can use a process viewer application
to kill the appropriate instance of ntvdm instead (this will terminate
both DOS subprocesses).

   If you have to reboot Windows 95 in this situation, do not use the
`Shutdown' command on the `Start' menu; that usually hangs the system.
Instead, type `CTL-ALT-<DEL>' and then choose `Shutdown'.  That usually
works, although it may take a few minutes to do its job.


File: emacs,  Node: System Menu on Windows,  Prev: Windows Subprocesses,  Up: MS-DOS

Using the System Menu on Windows
================================

Emacs normally turns off the Windows feature that tapping the <ALT> key
invokes the Windows menu.  The reason is that the <ALT> also serves as
<META> in Emacs.  When using Emacs, users often press the <META> key
temporarily and then change their minds; if this has the effect of
bringing up the Windows menu, it alters the meaning of subsequent
commands.  Many users find this frustrating.

   You can reenable Windows's default handling of tapping the <ALT> key
by setting `win32-pass-alt-to-system' to a non-`nil' value.


File: emacs,  Node: Manifesto,  Prev: MS-DOS,  Up: Top

The GNU Manifesto
*****************

     The GNU Manifesto which appears below was written by Richard
     Stallman at the beginning of the GNU project, to ask for
     participation and support.  For the first few years, it was
     updated in minor ways to account for developments, but now it
     seems best to leave it unchanged as most people have seen it.

     Since that time, we have learned about certain common
     misunderstandings that different wording could help avoid.
     Footnotes added in 1993 help clarify these points.

     For up-to-date information about the available GNU software,
     please see the latest issue of the GNU's Bulletin.  The list is
     much too long to include here.

What's GNU?  Gnu's Not Unix!
============================

GNU, which stands for Gnu's Not Unix, is the name for the complete
Unix-compatible software system which I am writing so that I can give it
away free to everyone who can use it.(1) Several other volunteers are
helping me.  Contributions of time, money, programs and equipment are
greatly needed.

   So far we have an Emacs text editor with Lisp for writing editor
commands, a source level debugger, a yacc-compatible parser generator,
a linker, and around 35 utilities.  A shell (command interpreter) is
nearly completed.  A new portable optimizing C compiler has compiled
itself and may be released this year.  An initial kernel exists but
many more features are needed to emulate Unix.  When the kernel and
compiler are finished, it will be possible to distribute a GNU system
suitable for program development.  We will use TeX as our text
formatter, but an nroff is being worked on.  We will use the free,
portable X window system as well.  After this we will add a portable
Common Lisp, an Empire game, a spreadsheet, and hundreds of other
things, plus on-line documentation.  We hope to supply, eventually,
everything useful that normally comes with a Unix system, and more.

   GNU will be able to run Unix programs, but will not be identical to
Unix.  We will make all improvements that are convenient, based on our
experience with other operating systems.  In particular, we plan to
have longer file names, file version numbers, a crashproof file system,
file name completion perhaps, terminal-independent display support, and
perhaps eventually a Lisp-based window system through which several
Lisp programs and ordinary Unix programs can share a screen.  Both C
and Lisp will be available as system programming languages.  We will
try to support UUCP, MIT Chaosnet, and Internet protocols for
communication.

   GNU is aimed initially at machines in the 68000/16000 class with
virtual memory, because they are the easiest machines to make it run
on.  The extra effort to make it run on smaller machines will be left
to someone who wants to use it on them.

   To avoid horrible confusion, please pronounce the `G' in the word
`GNU' when it is the name of this project.

Why I Must Write GNU
====================

I consider that the golden rule requires that if I like a program I must
share it with other people who like it.  Software sellers want to divide
the users and conquer them, making each user agree not to share with
others.  I refuse to break solidarity with other users in this way.  I
cannot in good conscience sign a nondisclosure agreement or a software
license agreement.  For years I worked within the Artificial
Intelligence Lab to resist such tendencies and other inhospitalities,
but eventually they had gone too far: I could not remain in an
institution where such things are done for me against my will.

   So that I can continue to use computers without dishonor, I have
decided to put together a sufficient body of free software so that I
will be able to get along without any software that is not free.  I
have resigned from the AI lab to deny MIT any legal excuse to prevent
me from giving GNU away.

Why GNU Will Be Compatible with Unix
====================================

Unix is not my ideal system, but it is not too bad.  The essential
features of Unix seem to be good ones, and I think I can fill in what
Unix lacks without spoiling them.  And a system compatible with Unix
would be convenient for many other people to adopt.

How GNU Will Be Available
=========================

GNU is not in the public domain.  Everyone will be permitted to modify
and redistribute GNU, but no distributor will be allowed to restrict its
further redistribution.  That is to say, proprietary modifications will
not be allowed.  I want to make sure that all versions of GNU remain
free.

Why Many Other Programmers Want to Help
=======================================

I have found many other programmers who are excited about GNU and want
to help.

   Many programmers are unhappy about the commercialization of system
software.  It may enable them to make more money, but it requires them
to feel in conflict with other programmers in general rather than feel
as comrades.  The fundamental act of friendship among programmers is the
sharing of programs; marketing arrangements now typically used
essentially forbid programmers to treat others as friends.  The
purchaser of software must choose between friendship and obeying the
law.  Naturally, many decide that friendship is more important.  But
those who believe in law often do not feel at ease with either choice.
They become cynical and think that programming is just a way of making
money.

   By working on and using GNU rather than proprietary programs, we can
be hospitable to everyone and obey the law.  In addition, GNU serves as
an example to inspire and a banner to rally others to join us in
sharing.  This can give us a feeling of harmony which is impossible if
we use software that is not free.  For about half the programmers I
talk to, this is an important happiness that money cannot replace.

How You Can Contribute
======================

I am asking computer manufacturers for donations of machines and money.
I'm asking individuals for donations of programs and work.

   One consequence you can expect if you donate machines is that GNU
will run on them at an early date.  The machines should be complete,
ready to use systems, approved for use in a residential area, and not
in need of sophisticated cooling or power.

   I have found very many programmers eager to contribute part-time
work for GNU.  For most projects, such part-time distributed work would
be very hard to coordinate; the independently-written parts would not
work together.  But for the particular task of replacing Unix, this
problem is absent.  A complete Unix system contains hundreds of utility
programs, each of which is documented separately.  Most interface
specifications are fixed by Unix compatibility.  If each contributor
can write a compatible replacement for a single Unix utility, and make
it work properly in place of the original on a Unix system, then these
utilities will work right when put together.  Even allowing for Murphy
to create a few unexpected problems, assembling these components will
be a feasible task.  (The kernel will require closer communication and
will be worked on by a small, tight group.)

   If I get donations of money, I may be able to hire a few people full
or part time.  The salary won't be high by programmers' standards, but
I'm looking for people for whom building community spirit is as
important as making money.  I view this as a way of enabling dedicated
people to devote their full energies to working on GNU by sparing them
the need to make a living in another way.

Why All Computer Users Will Benefit
===================================

Once GNU is written, everyone will be able to obtain good system
software free, just like air.(2)

   This means much more than just saving everyone the price of a Unix
license.  It means that much wasteful duplication of system programming
effort will be avoided.  This effort can go instead into advancing the
state of the art.

   Complete system sources will be available to everyone.  As a result,
a user who needs changes in the system will always be free to make them
himself, or hire any available programmer or company to make them for
him.  Users will no longer be at the mercy of one programmer or company
which owns the sources and is in sole position to make changes.

   Schools will be able to provide a much more educational environment
by encouraging all students to study and improve the system code.
Harvard's computer lab used to have the policy that no program could be
installed on the system if its sources were not on public display, and
upheld it by actually refusing to install certain programs.  I was very
much inspired by this.

   Finally, the overhead of considering who owns the system software
and what one is or is not entitled to do with it will be lifted.

   Arrangements to make people pay for using a program, including
licensing of copies, always incur a tremendous cost to society through
the cumbersome mechanisms necessary to figure out how much (that is,
which programs) a person must pay for.  And only a police state can
force everyone to obey them.  Consider a space station where air must
be manufactured at great cost: charging each breather per liter of air
may be fair, but wearing the metered gas mask all day and all night is
intolerable even if everyone can afford to pay the air bill.  And the
TV cameras everywhere to see if you ever take the mask off are
outrageous.  It's better to support the air plant with a head tax and
chuck the masks.

   Copying all or parts of a program is as natural to a programmer as
breathing, and as productive.  It ought to be as free.

Some Easily Rebutted Objections to GNU's Goals
==============================================

     "Nobody will use it if it is free, because that means they can't
     rely on any support."

     "You have to charge for the program to pay for providing the
     support."

   If people would rather pay for GNU plus service than get GNU free
without service, a company to provide just service to people who have
obtained GNU free ought to be profitable.(3)

   We must distinguish between support in the form of real programming
work and mere handholding.  The former is something one cannot rely on
from a software vendor.  If your problem is not shared by enough
people, the vendor will tell you to get lost.

   If your business needs to be able to rely on support, the only way
is to have all the necessary sources and tools.  Then you can hire any
available person to fix your problem; you are not at the mercy of any
individual.  With Unix, the price of sources puts this out of
consideration for most businesses.  With GNU this will be easy.  It is
still possible for there to be no available competent person, but this
problem cannot be blamed on distribution arrangements.  GNU does not
eliminate all the world's problems, only some of them.

   Meanwhile, the users who know nothing about computers need
handholding: doing things for them which they could easily do
themselves but don't know how.

   Such services could be provided by companies that sell just
hand-holding and repair service.  If it is true that users would rather
spend money and get a product with service, they will also be willing
to buy the service having got the product free.  The service companies
will compete in quality and price; users will not be tied to any
particular one.  Meanwhile, those of us who don't need the service
should be able to use the program without paying for the service.

     "You cannot reach many people without advertising, and you must
     charge for the program to support that."

     "It's no use advertising a program people can get free."

   There are various forms of free or very cheap publicity that can be
used to inform numbers of computer users about something like GNU.  But
it may be true that one can reach more microcomputer users with
advertising.  If this is really so, a business which advertises the
service of copying and mailing GNU for a fee ought to be successful
enough to pay for its advertising and more.  This way, only the users
who benefit from the advertising pay for it.

   On the other hand, if many people get GNU from their friends, and
such companies don't succeed, this will show that advertising was not
really necessary to spread GNU.  Why is it that free market advocates
don't want to let the free market decide this?(4)

     "My company needs a proprietary operating system to get a
     competitive edge."

   GNU will remove operating system software from the realm of
competition.  You will not be able to get an edge in this area, but
neither will your competitors be able to get an edge over you.  You and
they will compete in other areas, while benefiting mutually in this
one.  If your business is selling an operating system, you will not
like GNU, but that's tough on you.  If your business is something else,
GNU can save you from being pushed into the expensive business of
selling operating systems.

   I would like to see GNU development supported by gifts from many
manufacturers and users, reducing the cost to each.(5)

     "Don't programmers deserve a reward for their creativity?"

   If anything deserves a reward, it is social contribution.
Creativity can be a social contribution, but only in so far as society
is free to use the results.  If programmers deserve to be rewarded for
creating innovative programs, by the same token they deserve to be
punished if they restrict the use of these programs.

     "Shouldn't a programmer be able to ask for a reward for his
     creativity?"

   There is nothing wrong with wanting pay for work, or seeking to
maximize one's income, as long as one does not use means that are
destructive.  But the means customary in the field of software today
are based on destruction.

   Extracting money from users of a program by restricting their use of
it is destructive because the restrictions reduce the amount and the
ways that the program can be used.  This reduces the amount of wealth
that humanity derives from the program.  When there is a deliberate
choice to restrict, the harmful consequences are deliberate destruction.

   The reason a good citizen does not use such destructive means to
become wealthier is that, if everyone did so, we would all become
poorer from the mutual destructiveness.  This is Kantian ethics; or,
the Golden Rule.  Since I do not like the consequences that result if
everyone hoards information, I am required to consider it wrong for one
to do so.  Specifically, the desire to be rewarded for one's creativity
does not justify depriving the world in general of all or part of that
creativity.

     "Won't programmers starve?"

   I could answer that nobody is forced to be a programmer.  Most of us
cannot manage to get any money for standing on the street and making
faces.  But we are not, as a result, condemned to spend our lives
standing on the street making faces, and starving.  We do something
else.

   But that is the wrong answer because it accepts the questioner's
implicit assumption: that without ownership of software, programmers
cannot possibly be paid a cent.  Supposedly it is all or nothing.

   The real reason programmers will not starve is that it will still be
possible for them to get paid for programming; just not paid as much as
now.

   Restricting copying is not the only basis for business in software.
It is the most common basis because it brings in the most money.  If it
were prohibited, or rejected by the customer, software business would
move to other bases of organization which are now used less often.
There are always numerous ways to organize any kind of business.

   Probably programming will not be as lucrative on the new basis as it
is now.  But that is not an argument against the change.  It is not
considered an injustice that sales clerks make the salaries that they
now do.  If programmers made the same, that would not be an injustice
either.  (In practice they would still make considerably more than
that.)

     "Don't people have a right to control how their creativity is
     used?"

   "Control over the use of one's ideas" really constitutes control over
other people's lives; and it is usually used to make their lives more
difficult.

   People who have studied the issue of intellectual property rights
carefully (such as lawyers) say that there is no intrinsic right to
intellectual property.  The kinds of supposed intellectual property
rights that the government recognizes were created by specific acts of
legislation for specific purposes.

   For example, the patent system was established to encourage
inventors to disclose the details of their inventions.  Its purpose was
to help society rather than to help inventors.  At the time, the life
span of 17 years for a patent was short compared with the rate of
advance of the state of the art.  Since patents are an issue only among
manufacturers, for whom the cost and effort of a license agreement are
small compared with setting up production, the patents often do not do
much harm.  They do not obstruct most individuals who use patented
products.

   The idea of copyright did not exist in ancient times, when authors
frequently copied other authors at length in works of non-fiction.  This
practice was useful, and is the only way many authors' works have
survived even in part.  The copyright system was created expressly for
the purpose of encouraging authorship.  In the domain for which it was
invented--books, which could be copied economically only on a printing
press--it did little harm, and did not obstruct most of the individuals
who read the books.

   All intellectual property rights are just licenses granted by society
because it was thought, rightly or wrongly, that society as a whole
would benefit by granting them.  But in any particular situation, we
have to ask: are we really better off granting such license?  What kind
of act are we licensing a person to do?

   The case of programs today is very different from that of books a
hundred years ago.  The fact that the easiest way to copy a program is
from one neighbor to another, the fact that a program has both source
code and object code which are distinct, and the fact that a program is
used rather than read and enjoyed, combine to create a situation in
which a person who enforces a copyright is harming society as a whole
both materially and spiritually; in which a person should not do so
regardless of whether the law enables him to.

     "Competition makes things get done better."

   The paradigm of competition is a race: by rewarding the winner, we
encourage everyone to run faster.  When capitalism really works this
way, it does a good job; but its defenders are wrong in assuming it
always works this way.  If the runners forget why the reward is offered
and become intent on winning, no matter how, they may find other
strategies--such as, attacking other runners.  If the runners get into
a fist fight, they will all finish late.

   Proprietary and secret software is the moral equivalent of runners
in a fist fight.  Sad to say, the only referee we've got does not seem
to object to fights; he just regulates them ("For every ten yards you
run, you can fire one shot").  He really ought to break them up, and
penalize runners for even trying to fight.

     "Won't everyone stop programming without a monetary incentive?"

   Actually, many people will program with absolutely no monetary
incentive.  Programming has an irresistible fascination for some
people, usually the people who are best at it.  There is no shortage of
professional musicians who keep at it even though they have no hope of
making a living that way.

   But really this question, though commonly asked, is not appropriate
to the situation.  Pay for programmers will not disappear, only become
less.  So the right question is, will anyone program with a reduced
monetary incentive?  My experience shows that they will.

   For more than ten years, many of the world's best programmers worked
at the Artificial Intelligence Lab for far less money than they could
have had anywhere else.  They got many kinds of non-monetary rewards:
fame and appreciation, for example.  And creativity is also fun, a
reward in itself.

   Then most of them left when offered a chance to do the same
interesting work for a lot of money.

   What the facts show is that people will program for reasons other
than riches; but if given a chance to make a lot of money as well, they
will come to expect and demand it.  Low-paying organizations do poorly
in competition with high-paying ones, but they do not have to do badly
if the high-paying ones are banned.

     "We need the programmers desperately.  If they demand that we stop
     helping our neighbors, we have to obey."

   You're never so desperate that you have to obey this sort of demand.
Remember: millions for defense, but not a cent for tribute!

     "Programmers need to make a living somehow."

   In the short run, this is true.  However, there are plenty of ways
that programmers could make a living without selling the right to use a
program.  This way is customary now because it brings programmers and
businessmen the most money, not because it is the only way to make a
living.  It is easy to find other ways if you want to find them.  Here
are a number of examples.

   A manufacturer introducing a new computer will pay for the porting of
operating systems onto the new hardware.

   The sale of teaching, hand-holding and maintenance services could
also employ programmers.

   People with new ideas could distribute programs as freeware, asking
for donations from satisfied users, or selling hand-holding services.
I have met people who are already working this way successfully.

   Users with related needs can form users' groups, and pay dues.  A
group would contract with programming companies to write programs that
the group's members would like to use.

   All sorts of development can be funded with a Software Tax:

     Suppose everyone who buys a computer has to pay x percent of the
     price as a software tax.  The government gives this to an agency
     like the NSF to spend on software development.

     But if the computer buyer makes a donation to software development
     himself, he can take a credit against the tax.  He can donate to
     the project of his own choosing--often, chosen because he hopes to
     use the results when it is done.  He can take a credit for any
     amount of donation up to the total tax he had to pay.

     The total tax rate could be decided by a vote of the payers of the
     tax, weighted according to the amount they will be taxed on.

     The consequences:

        * The computer-using community supports software development.

        * This community decides what level of support is needed.

        * Users who care which projects their share is spent on can
          choose this for themselves.

   In the long run, making programs free is a step toward the
post-scarcity world, where nobody will have to work very hard just to
make a living.  People will be free to devote themselves to activities
that are fun, such as programming, after spending the necessary ten
hours a week on required tasks such as legislation, family counseling,
robot repair and asteroid prospecting.  There will be no need to be
able to make a living from programming.

   We have already greatly reduced the amount of work that the whole
society must do for its actual productivity, but only a little of this
has translated itself into leisure for workers because much
nonproductive activity is required to accompany productive activity.
The main causes of this are bureaucracy and isometric struggles against
competition.  Free software will greatly reduce these drains in the
area of software production.  We must do this, in order for technical
gains in productivity to translate into less work for us.

   ---------- Footnotes ----------

   (1) The wording here was careless.  The intention was that nobody
would have to pay for _permission_ to use the GNU system.  But the
words don't make this clear, and people often interpret them as saying
that copies of GNU should always be distributed at little or no charge.
That was never the intent; later on, the manifesto mentions the
possibility of companies providing the service of distribution for a
profit.  Subsequently I have learned to distinguish carefully between
"free" in the sense of freedom and "free" in the sense of price.  Free
software is software that users have the freedom to distribute and
change.  Some users may obtain copies at no charge, while others pay to
obtain copies--and if the funds help support improving the software, so
much the better.  The important thing is that everyone who has a copy
has the freedom to cooperate with others in using it.

   (2) This is another place I failed to distinguish carefully between
the two different meanings of "free".  The statement as it stands is
not false--you can get copies of GNU software at no charge, from your
friends or over the net.  But it does suggest the wrong idea.

   (3) Several such companies now exist.

   (4) The Free Software Foundation raises most of its funds from a
distribution service, although it is a charity rather than a company.
If _no one_ chooses to obtain copies by ordering from the FSF, it will
be unable to do its work.  But this does not mean that proprietary
restrictions are justified to force every user to pay.  If a small
fraction of all the users order copies from the FSF, that is sufficient
to keep the FSF afloat.  So we ask users to choose to support us in
this way.  Have you done your part?

   (5) A group of computer companies recently pooled funds to support
maintenance of the GNU C Compiler.


File: emacs,  Node: Glossary,  Next: Key Index,  Prev: Intro,  Up: Top

Glossary
********

Abbrev
     An abbrev is a text string which expands into a different text
     string when present in the buffer.  For example, you might define
     a few letters as an abbrev for a long phrase that you want to
     insert frequently.  *Note Abbrevs::.

Aborting
     Aborting means getting out of a recursive edit (q.v.).  The
     commands `C-]' and `M-x top-level' are used for this.  *Note
     Quitting::.

Alt
     Alt is the name of a modifier bit which a keyboard input character
     may have.  To make a character Alt, type it while holding down the
     <ALT> key.  Such characters are given names that start with `Alt-'
     (usually written `A-' for short).  (Note that many terminals have a
     key labeled <ALT> which is really a <META> key.)  *Note Alt: User
     Input.

Auto Fill Mode
     Auto Fill mode is a minor mode in which text that you insert is
     automatically broken into lines of fixed width.  *Note Filling::.

Auto Saving
     Auto saving is the practice of saving the contents of an Emacs
     buffer in a specially-named file, so that the information will not
     be lost if the buffer is lost due to a system error or user error.
     *Note Auto Save::.

Backup File
     A backup file records the contents that a file had before the
     current editing session.  Emacs makes backup files automatically
     to help you track down or cancel changes you later regret making.
     *Note Backup::.

Balance Parentheses
     Emacs can balance parentheses manually or automatically.  Manual
     balancing is done by the commands to move over balanced expressions
     (*note Lists::).  Automatic balancing is done by blinking or
     highlighting the parenthesis that matches one just inserted (*note
     Matching Parens: Matching.).

Bind
     To bind a key sequence means to give it a binding (q.v.).  *Note
     Rebinding::.

Binding
     A key sequence gets its meaning in Emacs by having a binding,
     which is a command (q.v.), a Lisp function that is run when the
     user types that sequence.  *Note Binding: Commands.  Customization
     often involves rebinding a character to a different command
     function.  The bindings of all key sequences are recorded in the
     keymaps (q.v.).  *Note Keymaps::.

Blank Lines
     Blank lines are lines that contain only whitespace.  Emacs has
     several commands for operating on the blank lines in the buffer.

Buffer
     The buffer is the basic editing unit; one buffer corresponds to
     one text being edited.  You can have several buffers, but at any
     time you are editing only one, the `selected' buffer, though
     several can be visible when you are using multiple windows (q.v.).
     Most buffers are visiting (q.v.) some file.  *Note Buffers::.

Buffer Selection History
     Emacs keeps a buffer selection history which records how recently
     each Emacs buffer has been selected.  This is used for choosing a
     buffer to select.  *Note Buffers::.

Button Down Event
     A button down event is the kind of input event generated right
     away when you press a mouse button.  *Note Mouse Buttons::.

`C-'
     `C-' in the name of a character is an abbreviation for Control.
     *Note C-: User Input.

`C-M-'
     `C-M-' in the name of a character is an abbreviation for
     Control-Meta.  *Note C-M-: User Input.

Case Conversion
     Case conversion means changing text from upper case to lower case
     or vice versa.  *Note Case::, for the commands for case conversion.

Character
     Characters form the contents of an Emacs buffer; see *Note Text
     Characters::.  Also, key sequences (q.v.) are usually made up of
     characters (though they may include other input events as well).
     *Note User Input::.

Click Event
     A click event is the kind of input event generated when you press a
     mouse button and release it without moving the mouse.  *Note Mouse
     Buttons::.

Command
     A command is a Lisp function specially defined to be able to serve
     as a key binding in Emacs.  When you type a key sequence (q.v.),
     its binding (q.v.) is looked up in the relevant keymaps (q.v.) to
     find the command to run.  *Note Commands::.

Command Name
     A command name is the name of a Lisp symbol which is a command
     (*note Commands::).  You can invoke any command by its name using
     `M-x' (*note M-x::).

Comment
     A comment is text in a program which is intended only for humans
     reading the program, and which is marked specially so that it will
     be ignored when the program is loaded or compiled.  Emacs offers
     special commands for creating, aligning and killing comments.
     *Note Comments::.

Compilation
     Compilation is the process of creating an executable program from
     source code.  Emacs has commands for compiling files of Emacs Lisp
     code (*note Byte Compilation: (elisp)Byte Compilation.) and
     programs in C and other languages (*note Compilation::).

Complete Key
     A complete key is a key sequence which fully specifies one action
     to be performed by Emacs.  For example, `X' and `C-f' and `C-x m'
     are complete keys.  Complete keys derive their meanings from being
     bound (q.v.) to commands (q.v.).  Thus, `X' is conventionally
     bound to a command to insert `X' in the buffer; `C-x m' is
     conventionally bound to a command to begin composing a mail
     message.  *Note Keys::.

Completion
     Completion is what Emacs does when it automatically fills out an
     abbreviation for a name into the entire name.  Completion is done
     for minibuffer (q.v.) arguments when the set of possible valid
     inputs is known; for example, on command names, buffer names, and
     file names.  Completion occurs when <TAB>, <SPC> or <RET> is
     typed.  *Note Completion::.

Continuation Line
     When a line of text is longer than the width of the window, it
     takes up more than one screen line when displayed.  We say that the
     text line is continued, and all screen lines used for it after the
     first are called continuation lines.  *Note Continuation: Basic.

Control Character
     ASCII characters with octal codes 0 through 037, and also code
     0177, do not have graphic images assigned to them.  These are the
     Control characters.  To type a Control character, hold down the
     <CTRL> key and type the corresponding non-Control character.
     <RET>, <TAB>, <ESC>, <LFD> and <DEL> are all control characters.
     *Note User Input::.

     When you are using the X Window System, every non-control
     character has a corresponding control character variant.

Copyleft
     A copyleft is a notice giving the public legal permission to
     redistribute a program or other work of art.  Copylefts are used by
     left-wing programmers to give people equal rights, just as
     copyrights are used by right-wing programmers to gain power over
     other people.

     The particular form of copyleft used by the GNU project is called
     the GNU General Public License.  *Note Copying::.

Current Buffer
     The current buffer in Emacs is the Emacs buffer on which most
     editing commands operate.  You can select any Emacs buffer as the
     current one.  *Note Buffers::.

Current Line
     The line point is on (*note Point::).

Current Paragraph
     The paragraph that point is in.  If point is between paragraphs,
     the current paragraph is the one that follows point.  *Note
     Paragraphs::.

Current Defun
     The defun (q.v.) that point is in.  If point is between defuns, the
     current defun is the one that follows point.  *Note Defuns::.

Cursor
     The cursor is the rectangle on the screen which indicates the
     position called point (q.v.) at which insertion and deletion takes
     place.  The cursor is on or under the character that follows
     point.  Often people speak of `the cursor' when, strictly
     speaking, they mean `point'.  *Note Cursor: Basic.

Customization
     Customization is making minor changes in the way Emacs works.  It
     is often done by setting variables (*note Variables::) or by
     rebinding key sequences (*note Keymaps::).

Default Argument
     The default for an argument is the value that will be assumed if
     you do not specify one.  When the minibuffer is used to read an
     argument, the default argument is used if you just type <RET>.
     *Note Minibuffer::.

Default Directory
     When you specify a file name that does not start with `/' or `~',
     it is interpreted relative to the current buffer's default
     directory.  *Note Default Directory: Minibuffer File.

Defun
     A defun is a list at the top level of parenthesis or bracket
     structure in a program.  It is so named because most such lists in
     Lisp programs are calls to the Lisp function `defun'.  *Note
     Defuns::.

<DEL>
     <DEL> is a character that runs the command to delete one character
     of text.  *Note DEL: Basic.

Deletion
     Deletion means erasing text without copying it into the kill ring
     (q.v.).  The alternative is killing (q.v.).  *Note Deletion:
     Killing.

Deletion of Files
     Deleting a file means erasing it from the file system.  *Note Misc
     File Ops::.

Deletion of Messages
     Deleting a message means flagging it to be eliminated from your
     mail file.  Until you expunge (q.v.) the Rmail file, you can still
     undelete the messages you have deleted.  *Note Rmail Deletion::.

Deletion of Windows
     Deleting a window means eliminating it from the screen.  Other
     windows expand to use up the space.  The deleted window can never
     come back, but no actual text is thereby lost.  *Note Windows::.

Directory
     File directories are named collections in the file system, within
     which you can place individual files or subdirectories.  *Note
     Directories::.

Dired
     Dired is the Emacs facility that displays the contents of a file
     directory and allows you to "edit the directory", performing
     operations on the files in the directory.  *Note Dired::.

Disabled Command
     A disabled command is one that you may not run without special
     confirmation.  The usual reason for disabling a command is that it
     is confusing for beginning users.  *Note Disabling::.

Down Event
     Short for `button down event'.

Drag Event
     A drag event is the kind of input event generated when you press a
     mouse button, move the mouse, and then release the button.  *Note
     Mouse Buttons::.

Dribble File
     A file into which Emacs writes all the characters that the user
     types on the keyboard.  Dribble files are used to make a record for
     debugging Emacs bugs.  Emacs does not make a dribble file unless
     you tell it to.  *Note Bugs::.

Echo Area
     The echo area is the bottom line of the screen, used for echoing
     the arguments to commands, for asking questions, and printing
     brief messages (including error messages).  The messages are
     stored in the buffer `*Messages*' so you can review them later.
     *Note Echo Area::.

Echoing
     Echoing is acknowledging the receipt of commands by displaying
     them (in the echo area).  Emacs never echoes single-character key
     sequences; longer key sequences echo only if you pause while
     typing them.

Error
     An error occurs when an Emacs command cannot execute in the current
     circumstances.  When an error occurs, execution of the command
     stops (unless the command has been programmed to do otherwise) and
     Emacs reports the error by printing an error message (q.v.).
     Type-ahead is discarded.  Then Emacs is ready to read another
     editing command.

Error Message
     An error message is a single line of output displayed by Emacs
     when the user asks for something impossible to do (such as,
     killing text forward when point is at the end of the buffer).
     They appear in the echo area, accompanied by a beep.

<ESC>
     <ESC> is a character used as a prefix for typing Meta characters on
     keyboards lacking a <META> key.  Unlike the <META> key (which,
     like the <SHIFT> key, is held down while another character is
     typed), the <ESC> key is pressed once and applies to the next
     character typed.

Expunging
     Expunging an Rmail file or Dired buffer means really discarding the
     messages or files you have previously flagged for deletion.

File Name
     A file name is a name that refers to a file.  File names may be
     relative or absolute; the meaning of a relative file name depends
     on the current directory, but an absolute file name refers to the
     same file regardless of which directory is current.  On GNU and
     Unix systems, an absolute file name starts with a slash (the root
     directory) or with `~/' or `~USER/' (a home directory).

     Some people use the term "pathname" for file names, but we do not;
     we use the word "path" only in the term "search path" (q.v.).

File Name Component
     A file name component names a file directly within a particular
     directory.  On GNU and Unix systems, a file name is a sequence of
     file name components, separated by slashes.  For example,
     `foo/bar' is a file name containing two components, `foo' and
     `bar'; it refers to the file named `bar' in the directory named
     `foo' in the current directory.

Fill Prefix
     The fill prefix is a string that should be expected at the
     beginning of each line when filling is done.  It is not regarded
     as part of the text to be filled.  *Note Filling::.

Filling
     Filling text means shifting text between consecutive lines so that
     all the lines are approximately the same length.  *Note Filling::.

Formatted Text
     Formatted text is text that displays with formatting information
     while you edit.  Formatting information includes fonts, colors,
     and specified margins.  *Note Formatted Text::.

Frame
     A frame is a rectangular cluster of Emacs windows.  Emacs starts
     out with one frame, but you can create more.  You can subdivide
     each frame into Emacs windows (q.v.).  When you are using X
     windows, all the frames can be visible at the same time.  *Note
     Frames::.

Function Key
     A function key is a key on the keyboard that sends input but does
     not correspond to any character.  *Note Function Keys::.

Global
     Global means `independent of the current environment; in effect
     throughout Emacs'.  It is the opposite of local (q.v.).  Particular
     examples of the use of `global' appear below.

Global Abbrev
     A global definition of an abbrev (q.v.) is effective in all major
     modes that do not have local (q.v.) definitions for the same
     abbrev.  *Note Abbrevs::.

Global Keymap
     The global keymap (q.v.) contains key bindings that are in effect
     except when overridden by local key bindings in a major mode's
     local keymap (q.v.).  *Note Keymaps::.

Global Mark Ring
     The global mark ring records the series of buffers you have
     recently set a mark in.  In many cases you can use this to
     backtrack through buffers you have been editing in, or in which
     you have found tags.  *Note Global Mark Ring::.

Global Substitution
     Global substitution means replacing each occurrence of one string
     by another string through a large amount of text.  *Note Replace::.

Global Variable
     The global value of a variable (q.v.) takes effect in all buffers
     that do not have their own local (q.v.) values for the variable.
     *Note Variables::.

Graphic Character
     Graphic characters are those assigned pictorial images rather than
     just names.  All the non-Meta (q.v.) characters except for the
     Control (q.v.) characters are graphic characters.  These include
     letters, digits, punctuation, and spaces; they do not include
     <RET> or <ESC>.  In Emacs, typing a graphic character inserts that
     character (in ordinary editing modes).  *Note Basic Editing: Basic.

Highlighting
     Highlighting text means displaying it with a different foreground
     and/or background color to make it stand out from the rest of the
     text in the buffer.

Hardcopy
     Hardcopy means printed output.  Emacs has commands for making
     printed listings of text in Emacs buffers.  *Note Hardcopy::.

<HELP>
     You can type <HELP> at any time to ask what options you have, or
     to ask what any command does.  The character <HELP> is really
     `C-h'.  *Note Help::.

Hyper
     Hyper is the name of a modifier bit which a keyboard input
     character may have.  To make a character Hyper, type it while
     holding down the <HYPER> key.  Such characters are given names
     that start with `Hyper-' (usually written `H-' for short).  *Note
     Hyper: User Input.

Inbox
     An inbox is a file in which mail is delivered by the operating
     system.  Rmail transfers mail from inboxes to Rmail files (q.v.)
     in which the mail is then stored permanently or until explicitly
     deleted.  *Note Rmail Inbox::.

Indentation
     Indentation means blank space at the beginning of a line.  Most
     programming languages have conventions for using indentation to
     illuminate the structure of the program, and Emacs has special
     commands to adjust indentation.  *Note Indentation::.

Indirect Buffer
     An indirect buffer is a buffer that shares the text of another
     buffer, called its base buffer.  *Note Indirect Buffers::.

Input Event
     An input event represents, within Emacs, one action taken by the
     user on the terminal.  Input events include typing characters,
     typing function keys, pressing or releasing mouse buttons, and
     switching between Emacs frames.  *Note User Input::.

Insertion
     Insertion means copying text into the buffer, either from the
     keyboard or from some other place in Emacs.

Justification
     Justification means adding extra spaces to lines of text to make
     them come exactly to a specified width.  *Note Justification:
     Filling.

Keyboard Macro
     Keyboard macros are a way of defining new Emacs commands from
     sequences of existing ones, with no need to write a Lisp program.
     *Note Keyboard Macros::.

Key Sequence
     A key sequence (key, for short) is a sequence of input events
     (q.v.)  that are meaningful as a single unit.  If the key sequence
     is enough to specify one action, it is a complete key (q.v.); if
     it is not enough, it is a prefix key (q.v.).  *Note Keys::.

Keymap
     The keymap is the data structure that records the bindings (q.v.)
     of key sequences to the commands that they run.  For example, the
     global keymap binds the character `C-n' to the command function
     `next-line'.  *Note Keymaps::.

Keyboard Translation Table
     The keyboard translation table is an array that translates the
     character codes that come from the terminal into the character
     codes that make up key sequences.  *Note Keyboard Translations::.

Kill Ring
     The kill ring is where all text you have killed recently is saved.
     You can reinsert any of the killed text still in the ring; this is
     called yanking (q.v.).  *Note Yanking::.

Killing
     Killing means erasing text and saving it on the kill ring so it
     can be yanked (q.v.) later.  Some other systems call this
     "cutting".  Most Emacs commands to erase text do killing, as
     opposed to deletion (q.v.).  *Note Killing::.

Killing Jobs
     Killing a job (such as, an invocation of Emacs) means making it
     cease to exist.  Any data within it, if not saved in a file, is
     lost.  *Note Exiting::.

List
     A list is, approximately, a text string beginning with an open
     parenthesis and ending with the matching close parenthesis.  In C
     mode and other non-Lisp modes, groupings surrounded by other kinds
     of matched delimiters appropriate to the language, such as braces,
     are also considered lists.  Emacs has special commands for many
     operations on lists.  *Note Lists::.

Local
     Local means `in effect only in a particular context'; the relevant
     kind of context is a particular function execution, a particular
     buffer, or a particular major mode.  It is the opposite of `global'
     (q.v.).  Specific uses of `local' in Emacs terminology appear
     below.

Local Abbrev
     A local abbrev definition is effective only if a particular major
     mode is selected.  In that major mode, it overrides any global
     definition for the same abbrev.  *Note Abbrevs::.

Local Keymap
     A local keymap is used in a particular major mode; the key bindings
     (q.v.) in the current local keymap override global bindings of the
     same key sequences.  *Note Keymaps::.

Local Variable
     A local value of a variable (q.v.) applies to only one buffer.
     *Note Locals::.

`M-'
     `M-' in the name of a character is an abbreviation for <META>, one
     of the modifier keys that can accompany any character.  *Note User
     Input::.

`M-C-'
     `M-C-' in the name of a character is an abbreviation for
     Control-Meta; it means the same thing as `C-M-'.  If your terminal
     lacks a real <META> key, you type a Control-Meta character by
     typing <ESC> and then typing the corresponding Control character.
     *Note C-M-: User Input.

`M-x'
     `M-x' is the key sequence which is used to call an Emacs command by
     name.  This is how you run commands that are not bound to key
     sequences.  *Note M-x::.

Mail
     Mail means messages sent from one user to another through the
     computer system, to be read at the recipient's convenience.  Emacs
     has commands for composing and sending mail, and for reading and
     editing the mail you have received.  *Note Sending Mail::.  *Note
     Rmail::, for how to read mail.

Major Mode
     The Emacs major modes are a mutually exclusive set of options,
     each of which configures Emacs for editing a certain sort of text.
     Ideally, each programming language has its own major mode.  *Note
     Major Modes::.

Mark
     The mark points to a position in the text.  It specifies one end
     of the region (q.v.), point being the other end.  Many commands
     operate on all the text from point to the mark.  Each buffer has
     its own mark.  *Note Mark::.

Mark Ring
     The mark ring is used to hold several recent previous locations of
     the mark, just in case you want to move back to them.  Each buffer
     has its own mark ring; in addition, there is a single global mark
     ring (q.v.).  *Note Mark Ring::.

Menu Bar
     The menu bar is the line at the top of an Emacs frame.  It contains
     words you can click on with the mouse to bring up menus.  The menu
     bar feature is supported only with X.  *Note Menu Bars::.

Message
     See `mail'.

Meta
     Meta is the name of a modifier bit which a command character may
     have.  It is present in a character if the character is typed with
     the <META> key held down.  Such characters are given names that
     start with `Meta-' (usually written `M-' for short).  For example,
     `M-<' is typed by holding down <META> and at the same time typing
     `<' (which itself is done, on most terminals, by holding down
     <SHIFT> and typing `,').  *Note Meta: User Input.

Meta Character
     A Meta character is one whose character code includes the Meta bit.

Minibuffer
     The minibuffer is the window that appears when necessary inside the
     echo area (q.v.), used for reading arguments to commands.  *Note
     Minibuffer::.

Minibuffer History
     The minibuffer history records the text you have specified in the
     past for minibuffer arguments, so you can conveniently use the
     same text again.  *Note Minibuffer History::.

Minor Mode
     A minor mode is an optional feature of Emacs which can be switched
     on or off independently of all other features.  Each minor mode
     has a command to turn it on or off.  *Note Minor Modes::.

Minor Mode Keymap
     A keymap that belongs to a minor mode and is active when that mode
     is enabled.  Minor mode keymaps take precedence over the buffer's
     local keymap, just as the local keymap takes precedence over the
     global keymap.  *Note Keymaps::.

Mode Line
     The mode line is the line at the bottom of each window (q.v.),
     giving status information on the buffer displayed in that window.
     *Note Mode Line::.

Modified Buffer
     A buffer (q.v.) is modified if its text has been changed since the
     last time the buffer was saved (or since when it was created, if it
     has never been saved).  *Note Saving::.

Moving Text
     Moving text means erasing it from one place and inserting it in
     another.  The usual way to move text by killing (q.v.) and then
     yanking (q.v.).  *Note Killing::.

Named Mark
     A named mark is a register (q.v.) in its role of recording a
     location in text so that you can move point to that location.
     *Note Registers::.

Narrowing
     Narrowing means creating a restriction (q.v.) that limits editing
     in the current buffer to only a part of the text in the buffer.
     Text outside that part is inaccessible to the user until the
     boundaries are widened again, but it is still there, and saving
     the file saves it all.  *Note Narrowing::.

Newline
     Linefeed characters in the buffer terminate lines of text and are
     therefore also called newlines.  *Note Newline: Text Characters.

Numeric Argument
     A numeric argument is a number, specified before a command, to
     change the effect of the command.  Often the numeric argument
     serves as a repeat count.  *Note Arguments::.

Overwrite Mode
     Overwrite mode is a minor mode.  When it is enabled, ordinary text
     characters replace the existing text after point rather than
     pushing it to the right.  *Note Minor Modes::.

Page
     A page is a unit of text, delimited by formfeed characters (ASCII
     control-L, code 014) coming at the beginning of a line.  Some Emacs
     commands are provided for moving over and operating on pages.
     *Note Pages::.

Paragraph
     Paragraphs are the medium-size unit of English text.  There are
     special Emacs commands for moving over and operating on paragraphs.
     *Note Paragraphs::.

Parsing
     We say that certain Emacs commands parse words or expressions in
     the text being edited.  Really, all they know how to do is find
     the other end of a word or expression.  *Note Syntax::.

Point
     Point is the place in the buffer at which insertion and deletion
     occur.  Point is considered to be between two characters, not at
     one character.  The terminal's cursor (q.v.) indicates the
     location of point.  *Note Point: Basic.

Prefix Argument
     See `numeric argument'.

Prefix Key
     A prefix key is a key sequence (q.v.) whose sole function is to
     introduce a set of longer key sequences.  `C-x' is an example of
     prefix key; any two-character sequence starting with `C-x' is
     therefore a legitimate key sequence.  *Note Keys::.

Primary Rmail File
     Your primary Rmail file is the file named `RMAIL' in your home
     directory.  That's where Rmail stores your incoming mail, unless
     you specify a different file name.  *Note Rmail::.

Primary Selection
     The primary selection is one particular X selection (q.v.); it is
     the selection that most X applications use for transferring text
     to and from other applications.

     The Emacs kill commands set the primary selection and the yank
     command uses the primary selection when appropriate.  *Note
     Killing::.

Prompt
     A prompt is text printed to ask the user for input.  Displaying a
     prompt is called prompting.  Emacs prompts always appear in the
     echo area (q.v.).  One kind of prompting happens when the
     minibuffer is used to read an argument (*note Minibuffer::); the
     echoing which happens when you pause in the middle of typing a
     multi-character key sequence is also a kind of prompting (*note
     Echo Area::).

Quitting
     Quitting means canceling a partially typed command or a running
     command, using `C-g'.  *Note Quitting::.

Quoting
     Quoting means depriving a character of its usual special
     significance.  In Emacs this is usually done with `C-q'.  What
     constitutes special significance depends on the context and on
     convention.  For example, an "ordinary" character as an Emacs
     command inserts itself; so in this context, a special character is
     any character that does not normally insert itself (such as <DEL>,
     for example), and quoting it makes it insert itself as if it were
     not special.  Not all contexts allow quoting.  *Note Quoting:
     Basic.

Read-Only Buffer
     A read-only buffer is one whose text you are not allowed to change.
     Normally Emacs makes buffers read-only when they contain text which
     has a special significance to Emacs; for example, Dired buffers.
     Visiting a file that is write protected also makes a read-only
     buffer.  *Note Buffers::.

Rectangle
     A rectangle consists of the text in a given range of columns on a
     given range of lines.  Normally you specify a rectangle by putting
     point at one corner and putting the mark at the opposite corner.
     *Note Rectangles::.

Recursive Editing Level
     A recursive editing level is a state in which part of the
     execution of a command involves asking the user to edit some text.
     This text may or may not be the same as the text to which the
     command was applied.  The mode line indicates recursive editing
     levels with square brackets (`[' and `]').  *Note Recursive Edit::.

Redisplay
     Redisplay is the process of correcting the image on the screen to
     correspond to changes that have been made in the text being edited.
     *Note Redisplay: Screen.

Regexp
     See `regular expression'.

Region
     The region is the text between point (q.v.) and the mark (q.v.).
     Many commands operate on the text of the region.  *Note Region:
     Mark.

Registers
     Registers are named slots in which text or buffer positions or
     rectangles can be saved for later use.  *Note Registers::.

Regular Expression
     A regular expression is a pattern that can match various text
     strings; for example, `l[0-9]+' matches `l' followed by one or more
     digits.  *Note Regexps::.

Repeat Count
     See `numeric argument'.

Replacement
     See `global substitution'.

Restriction
     A buffer's restriction is the amount of text, at the beginning or
     the end of the buffer, that is temporarily inaccessible.  Giving a
     buffer a nonzero amount of restriction is called narrowing (q.v.).
     *Note Narrowing::.

<RET>
     <RET> is a character that in Emacs runs the command to insert a
     newline into the text.  It is also used to terminate most arguments
     read in the minibuffer (q.v.).  *Note Return: User Input.

Rmail File
     An Rmail file is a file containing text in a special format used by
     Rmail for storing mail.  *Note Rmail::.

Saving
     Saving a buffer means copying its text into the file that was
     visited (q.v.) in that buffer.  This is the way text in files
     actually gets changed by your Emacs editing.  *Note Saving::.

Scroll Bar
     A scroll bar is a tall thin hollow box that appears at the side of
     a window.  You can use mouse commands in the scroll bar to scroll
     the window.  The scroll bar feature is supported only with X.
     *Note Scroll Bars::.

Scrolling
     Scrolling means shifting the text in the Emacs window so as to see
     a different part of the buffer.  *Note Scrolling: Display.

Searching
     Searching means moving point to the next occurrence of a specified
     string or the next match for a specified regular expression.
     *Note Search::.

Search Path
     A search path is a list of directory names, to be used for
     searching for files for certain purposes.  For example, the
     variable `load-path' holds a search path for finding Lisp library
     files.  *Note Lisp Libraries::.

Secondary Selection
     The secondary selection is one particular X selection; some X
     applications can use it for transferring text to and from other
     applications.  Emacs has special mouse commands for transferring
     text using the secondary selection.  *Note Secondary Selection::.

Selecting
     Selecting a buffer means making it the current (q.v.) buffer.
     *Note Selecting: Buffers.

Selection
     The X window system allows an application program to specify named
     selections whose values are text.  A program can also read the
     selections that other programs have set up.  This is the principal
     way of transferring text between window applications.  Emacs has
     commands to work with the primary (q.v.) selection and the
     secondary (q.v.)  selection.

Self-Documentation
     Self-documentation is the feature of Emacs which can tell you what
     any command does, or give you a list of all commands related to a
     topic you specify.  You ask for self-documentation with the help
     character, `C-h'.  *Note Help::.

Sentences
     Emacs has commands for moving by or killing by sentences.  *Note
     Sentences::.

Sexp
     A sexp (short for `s-expression') is the basic syntactic unit of
     Lisp in its textual form: either a list, or Lisp atom.  Many Emacs
     commands operate on sexps.  The term `sexp' is generalized to
     languages other than Lisp, to mean a syntactically recognizable
     expression.  *Note Sexps: Lists.

Simultaneous Editing
     Simultaneous editing means two users modifying the same file at
     once.  Simultaneous editing if not detected can cause one user to
     lose his work.  Emacs detects all cases of simultaneous editing
     and warns one of the users to investigate.  *Note Simultaneous
     Editing: Interlocking.

String
     A string is a kind of Lisp data object which contains a sequence of
     characters.  Many Emacs variables are intended to have strings as
     values.  The Lisp syntax for a string consists of the characters
     in the string with a `"' before and another `"' after.  A `"' that
     is part of the string must be written as `\"' and a `\' that is
     part of the string must be written as `\\'.  All other characters,
     including newline, can be included just by writing them inside the
     string; however, backslash sequences as in C, such as `\n' for
     newline or `\241' using an octal character code, are allowed as
     well.

String Substitution
     See `global substitution'.

Syntax Table
     The syntax table tells Emacs which characters are part of a word,
     which characters balance each other like parentheses, etc.  *Note
     Syntax::.

Super
     Super is the name of a modifier bit which a keyboard input
     character may have.  To make a character Super, type it while
     holding down the <SUPER> key.  Such characters are given names
     that start with `Super-' (usually written `s-' for short).  *Note
     Super: User Input.

Tags Table
     A tags table is a file that serves as an index to the function
     definitions in one or more other files.  *Note Tags::.

Termscript File
     A termscript file contains a record of all characters sent by
     Emacs to the terminal.  It is used for tracking down bugs in Emacs
     redisplay.  Emacs does not make a termscript file unless you tell
     it to.  *Note Bugs::.

Text
     Two meanings (*note Text::):

        * Data consisting of a sequence of characters, as opposed to
          binary numbers, images, graphics commands, executable
          programs, and the like.  The contents of an Emacs buffer are
          always text in this sense.

        * Data consisting of written human language, as opposed to
          programs, or following the stylistic conventions of human
          language.

Top Level
     Top level is the normal state of Emacs, in which you are editing
     the text of the file you have visited.  You are at top level
     whenever you are not in a recursive editing level (q.v.) or the
     minibuffer (q.v.), and not in the middle of a command.  You can
     get back to top level by aborting (q.v.) and quitting (q.v.).
     *Note Quitting::.

Transposition
     Transposing two units of text means putting each one into the place
     formerly occupied by the other.  There are Emacs commands to
     transpose two adjacent characters, words, sexps (q.v.) or lines
     (*note Transpose::).

Truncation
     Truncating text lines in the display means leaving out any text on
     a line that does not fit within the right margin of the window
     displaying it.  See also `continuation line'.  *Note Truncation:
     Basic.

Undoing
     Undoing means making your previous editing go in reverse, bringing
     back the text that existed earlier in the editing session.  *Note
     Undo::.

User Option
     A user option is a variable (q.v.) that exists so that you can
     customize Emacs by setting it to a new value.  *Note Variables::.

Variable
     A variable is an object in Lisp that can store an arbitrary value.
     Emacs uses some variables for internal purposes, and has others
     (known as `user options' (q.v.)) just so that you can set their
     values to control the behavior of Emacs.  The variables used in
     Emacs that you are likely to be interested in are listed in the
     Variables Index in this manual.  *Note Variables::, for
     information on variables.

Version Control
     Version control systems keep track of multiple versions of a
     source file.  They provide a more powerful alternative to keeping
     backup files (q.v.).  *Note Version Control::.

Visiting
     Visiting a file means loading its contents into a buffer (q.v.)
     where they can be edited.  *Note Visiting::.

Whitespace
     Whitespace is any run of consecutive formatting characters (space,
     tab, newline, and backspace).

Widening
     Widening is removing any restriction (q.v.) on the current buffer;
     it is the opposite of narrowing (q.v.).  *Note Narrowing::.

Window
     Emacs divides a frame (q.v.) into one or more windows, each of
     which can display the contents of one buffer (q.v.) at any time.
     *Note Screen::, for basic information on how Emacs uses the screen.
     *Note Windows::, for commands to control the use of windows.

Word Abbrev
     Synonymous with `abbrev'.

Word Search
     Word search is searching for a sequence of words, considering the
     punctuation between them as insignificant.  *Note Word Search::.

WYSIWYG
     WYSIWYG stands for "What you see is what you get."  Emacs generally
     provides WYSIWYG editing for files of characters; in Enriched mode
     (*note Formatted Text::), it provides WYSIWYG editing for files
     that include text formatting information.

Yanking
     Yanking means reinserting text previously killed.  It can be used
     to undo a mistaken kill, or for copying or moving text.  Some other
     systems call this "pasting".  *Note Yanking::.


File: emacs,  Node: Acknowledgments,  Next: Screen,  Prev: Concept Index,  Up: Top

Acknowledgments
***************

Many people have contributed code included in the Free Software
Foundation's distribution of GNU Emacs.  To show our appreciation for
their public spirit, we list here those who have written substantial
portions.

   * Per Abrahamsen wrote `double.el', for typing accented characters
     not normally available from the keyboard, `xt-mouse.el', which
     handles mouse commands through Xterm, and `cpp.el', which hides or
     highlights parts of C programs according to preprocessor
     conditionals.

   * Jay K. Adams wrote `jka-compr.el', providing automatic
     decompression and recompression for compressed files.

   * Joe Arceneaux wrote the original text property implementation, and
     implemented support for X11.

   * Boaz Ben-Zvi wrote `profile.el', to time Emacs Lisp functions.

   * Jim Blandy wrote Emacs 19's input system, brought its
     configuration and build process up to the GNU coding standards,
     and contributed to the frame support and multi-face support.

   * Frank Bresz wrote `diff.el', a program to display `diff' output.

   * Kevin Broadey wrote `foldout.el', providing folding extensions to
     Emacs's outline modes.

   * Vincent Broman wrote `ada.el', a mode for editing Ada code.

   * David M. Brown wrote `array.el', for editing arrays and other
     tabular data.

   * Hans Chalupsky wrote `advice.el', an overloading mechanism for
     Emacs Lisp functions, and `trace.el', a tracing facility for Emacs
     Lisp.

   * Bob Chassell wrote `texnfo-upd.el' and `makeinfo.el', modes and
     utilities for working with Texinfo files.

   * James Clark wrote `sgml-mode.el', a mode for editing SGML
     documents, and contributed to Emacs's dumping procedures.

   * Mike Clarkson wrote `edt.el', an emulation of DEC's EDT editor.

   * Doug Cutting and Jamie Zawinski wrote `disass.el', a disassembler
     for compiled Emacs Lisp code.

   * Michael DeCorte wrote `emacs.csh', a C-shell script that starts a
     new Emacs job, or restarts a paused Emacs if one exists.

   * Gary Delp wrote `mailpost.el', an interface between RMAIL and the
     `/usr/uci/post' mailer.

   * Matthieu Devin wrote `delsel.el', a package to make newly-typed
     text replace the current selection.

   * Scott Draves wrote `tq.el', help functions for maintaining
     transaction queues between Emacs and its subprocesses.

   * Viktor Dukhovni wrote support for dumping under SunOS version 4.

   * Rolf Ebert co-wrote Ada mode (`ada-mode.el').

   * Torbjorn Einarsson contributed F90 mode (`f90.el').

   * Hans Henrik Eriksen wrote `simula.el', a mode for editing SIMULA 87
     code.

   * Michael Ernst wrote `reposition.el', a command for recentering a
     function's source code and preceding comment on the screen.

   * Ata Etemadi wrote `cdl.el', functions for working with Common Data
     Language source code.

   * Fred Fish wrote the support for dumping COFF executable files.

   * Karl Fogel wrote:
        * `bookmark.el', for creating named placeholders, saving them
          and jumping to them later,

        * `mail-hist.el', a history mechanism for outgoing mail
          messages, and

        * `saveplace.el', for preserving point's location in files
          between editing sessions.

   * Noah Friedman wrote `rlogin.el', an interface to rlogin, and
     `type-break.el', which reminds you to take periodic breaks from
     typing.  With Roland McGrath, he wrote `rsz-mini.el', a minor mode
     to automatically resize the minibuffer to fit the text it contains.

   * Keith Gabryelski wrote `hexl.el', a mode for editing binary files.

   * Kevin Gallagher rewrote and enhanced the EDT emulation, and wrote
     `flow-ctrl.el', a package for coping with unsuppressible XON/XOFF
     flow control.

   * Kevin Gallo added multiple-frame support for Windows NT.

   * Howard Gayle wrote:
        * the C and lisp code for display tables and case tables,

        * `rot13.el', a command to display the plaintext form of a
          buffer encoded with the Caesar cipher,

        * much of the support for the ISO-8859 European character set
          (which includes `iso-ascii.el', `iso-insert.el',
          `iso-swed.el', `iso-syntax.el', `iso-transl.el', and
          `swedish.el'), and

        * `vt100-led.el', a package for controlling the LED's on
          VT100-compatible terminals.

   * Stephen Gildea made the Emacs quick reference card.

   * David Gillespie wrote:
        * Emacs 19's Common Lisp compatibility packages, replacing the
          old package by Cesar Augusto Quiroz Gonzalez,

        * `complete.el', a partial completion mechanism, and

        * `edmacro.el', a package for editing keyboard macros.

   * Boris Goldowsky wrote `avoid.el', a package to keep the mouse
     cursor out of the way of the text cursor; `shadowfile.el', a
     package for keeping identical copies of files in more than one
     place; `enriched.el', a package for saving text properties in
     files; and `facemenu.el', a package for specifying faces.

   * Michael Gschwind wrote `iso-cvt.el', a package to convert between
     the ISO 8859-1 character set and the notations for non-`ASCII'
     characters used by TeX and net tradition.

   * Henry Guillaume wrote `find-file.el', a package to visit a file
     which is related to the currently visited fil

   * Doug Gwyn wrote the portable `alloca' implementation.

   * Chris Hanson wrote `netuname.el', a package to use HP-UX's Remote
     File Access facility from Emacs.

   * K. Shane Hartman wrote:
        * `chistory.el' and `echistory.el', packages for browsing
          command history lists,

        * `electric.el' and `helper.el', providing an alternative
          command loop and appropriate help facilities,

        * `emacsbug.el', a package for reporting Emacs bugs,

        * `picture.el', a mode for editing ASCII pictures, and

        * `view.el', a package for perusing files and buffers without
          editing them.

   * Markus Heritsch co-wrote Ada mode (`ada-mode.el').

   * Karl Heuer wrote the original blessmail script, implemented the
     `intangible' text property, and rearranged the structure of the
     `Lisp_Object' type to allow for more data bits.

   * Manabu Higashida ported Emacs to the MS-DOS operating system.

   * Anders Holst wrote `hippie-exp.el', a versatile completion and
     expansion package.

   * Lars Ingebrigtsen did a major redesign of the GNUS newsreader.

   * Andrew Innes contributed extensively to the Windows NT support.

   * Kyle Jones wrote `life.el', a package to play Conway's "life" game,
     and `mldrag.el', a package which allows the user to resize windows
     by dragging mode lines and vertical window separators with the
     mouse.

   * David Kaufman wrote `yow.c', an essential utility program for the
     hopelessly pinheaded.

   * Henry Kautz wrote `bib-mode.el', a mode for maintaining
     bibliography databases compatible with `refer' (the `troff'
     version) and `lookbib', and `refbib.el', a package to convert
     those databases to the format used by the LaTeX text formatting
     package.

   * Howard Kaye wrote `sort.el', commands to sort text in Emacs
     buffers.

   * Michael Kifer wrote `ediff.el', an interactive interface to the
     `diff' and `patch' programs, and Viper, the newest emulation for
     VI.

   * Richard King wrote the first version of `userlock.el' and
     `filelock.c', which provide simple support for multiple users
     editing the same file.

   * Larry K. Kolodney wrote `cvtmail.c', a program to convert the mail
     directories used by Gosling Emacs into RMAIL format.

   * Robert Krawitz wrote the original `xmenu.c', part of Emacs's pop-up
     menu support.

   * Sebastian Kremer wrote Emacs 19's `dired-mode', with contributions
     by Lawrence R. Dodd.

   * Geoff Kuenning wrote Emacs 19's `ispell.el', based on work by Ken
     Stevens and others.

   * David Kågedal wrote `tempo.el', providing support for easy
     insertion of boilerplate text and other common constructions.

   * Daniel LaLiberte wrote:
        * `edebug.el', a source-level debugger for Emacs Lisp,

        * `cl-specs.el', specifications to help `edebug' debug code
          written using David Gillespie's Common Lisp support,

        * `cust-print.el', a customizable package for printing lisp
          objects,

        * `eval-reg.el', a re-implementation of `eval-region' in Emacs
          Lisp, and

        * `isearch.el', Emacs 19's incremental search minor mode.

   * James R. Larus wrote `mh-e.el', an interface to the MH mail system.

   * Lars Lindberg wrote `msb.el', which provides more flexible menus
     for buffer selection, and rewrote `dabbrev.el'.

   * Neil M. Mager wrote `appt.el', functions to notify users of their
     appointments.  It finds appointments recorded in the diary files
     generated by Edward M. Reingold's `calendar' package.

   * Ken Manheimer wrote `allout.el', a mode for manipulating and
     formatting outlines, and `icomplete.el', which provides incremental
     completion feedback in the minibuffer.

   * Bill Mann wrote `perl-mode.el', a mode for editing Perl code.

   * Brian Marick and Daniel LaLiberte wrote `hideif.el', support for
     hiding selected code within C `#ifdef' clauses.

   * Simon Marshall wrote:
        * `fast-lock.el', which caches the face data computed by Font
          Lock mode, and

        * `lazy-lock.el', which delays fontification in Font Lock mode
          until text is actually displayed.

   * Bengt Martensson, Mark Shapiro, Mike Newton, Aaron Larson, and
     Stefan Schoef, wrote `bibtex.el', a mode for editing BibTeX
     bibliography files.

   * Charlie Martin wrote `autoinsert.el', which provides automatic
     mode-sensitive insertion of text into new files.

   * Thomas May wrote `blackbox.el', a version of the traditional
     blackbox game.

   * Roland McGrath wrote:
        * `compile.el', a package for running compilations in a buffer,
          and then visiting the locations reported in error messages,

        * `etags.el', a package for jumping to function definitions and
          searching or replacing in all the files mentioned in a `TAGS'
          file,

        * `find-dired.el', for using `dired' commands on output from the
          `find' program, with Sebastian Kremer,

        * `map-ynp.el', a general purpose boolean question-asker,

        * `autoload.el', providing semi-automatic maintenance of
          autoload files, and

        * `upd-copyr.el', providing semi-automatic maintenance of
          copyright notices in source code.

   * David Megginson wrote `derived.el', which allows one to define new
     major modes by inheriting key bindings and commands from existing
     major modes.

   * Richard Mlynarik wrote:
        * `cl-indent.el', a package for indenting Common Lisp code,

        * `ebuff-menu.el', an "electric" browser for buffer listings,

        * `ehelp.el', bindings for browsing help screens,

        * `rfc822.el', a parser for E-mail addresses in the RFC-822
          format, used in mail messages and news articles,

        * `terminal.el', a terminal emulator for Emacs subprocesses, and

        * `yow.el', an essential utility (try `M-x yow').

   * Keith Moore wrote `aixcc.lex', a pre-processor designed to help
     Emacs parse the error messages produced by the AIX C compiler.

   * Thomas Neumann and Eric Raymond wrote `makefile.el', a mode for
     editing makefiles.

   * Jurgen Nickelsen wrote `ws-mode.el', providing WordStar emulation.

   * Jeff Norden wrote `kermit.el', a package to help the Kermit dialup
     communications program run comfortably in an Emacs shell buffer.

   * Andrew Norman wrote `ange-ftp.el', providing transparent FTP
     support.

   * Jeff Peck wrote:
        * `emacstool.c', support for running Emacs under SunView/Sun
          Windows,

        * `sun-curs.el', cursor definitions for Sun Windows, and

        * `sun-fns.el', providing mouse support for Sun Windows.

   * Damon Anton Permezel wrote `hanoi.el', an animated demonstration of
     the "Towers of Hanoi" puzzle.

   * Daniel Pfeiffer wrote:
        * `sh-script.el', a mode for editing shell scripts,

        * `skeleton.el', implementing a concise language for writing
          statement skeletons, and

        * `two-column.el', a minor mode for simultaneous two-column
          editing.

   * Fred Pierresteguy and Paul Reilly made Emacs work with X Toolkit
     widgets.

   * Christian Plaunt wrote `soundex.el', an implementation of the
     Soundex algorithm for comparing English words by their
     pronunciation.

   * Francesco A. Potorti wrote `cmacexp.el', providing a command which
     runs the C preprocessor on a region of a file and displays the
     results.

   * Michael D. Prange and Steven A. Wood wrote `fortran.el', a mode for
     editing FORTRAN code.

   * Ashwin Ram wrote `refer.el', commands to look up references in
     bibliography files by keyword.

   * Eric S. Raymond wrote:
        * `vc.el', an interface to the RCS and SCCS source code version
          control systems, with Paul Eggert,

        * `gud.el', a package for running source-level debuggers like
          GDB and SDB in Emacs,

        * `asm-mode.el', a mode for editing assembly language code,

        * `cookie1.el', support for "fortune-cookie" programs like
          `yow.el' and `spook.el',

        * `finder.el', a package for finding Emacs Lisp packages by
          keyword and topic,

        * `lisp-mnt.el', functions for working with the special headers
          used in Emacs Lisp library files, and

        * code to set and make use of the `load-history' lisp variable,
          which records the source file from which each lisp function
          loaded into Emacs came.

   * Edward M. Reingold wrote the extensive calendar and diary support
     (try `M-x calendar'), with contributions from Stewart Clamen, Paul
     Eggert, and Lara Rios.  Andy Oram contributed to its documentation.
     Reingold has also contributed to `tex-mode.el', a mode for editing
     TeX files, as have William F. Schelter, Dick King, Stephen Gildea,
     Michael Prange, and Jacob Gore.

   * Rob Riepel contributed `tpu-edt.el' and its associated files,
     providing an emulation of the VMS TPU text editor emulating the
     VMS EDT editor, and `vt-control.el', providing some control
     functions for the DEC VT line of terminals.

   * Roland B. Roberts contributed much of the VMS support distributed
     with Emacs 19, along with Joseph M. Kelsey, and `vms-pmail.el',
     support for using Emacs within VMS MAIL.

   * John Robinson wrote `bg-mouse.el', support for the mouse on the BBN
     Bitgraph terminal.

   * William Rosenblatt wrote `float.el', implementing a floating-point
     numeric type using lisp pairs and fixnums.

   * Guillermo J. Rozas wrote `scheme.el', a mode for editing Scheme
     code, and `fakemail.c', an interface to the System V mailer.

   * Wolfgang Rupprecht contributed Emacs 19's floating-point support
     (including `float-sup.el' and `floatfns.c'), and `sup-mouse.el',
     support for the Supdup mouse on lisp machines.

   * James B. Salem and Brewster Kahle wrote `completion.el', providing
     dynamic word completion.

   * Masahiko Sato wrote `vip.el', an emulation of the VI editor.

   * William Schelter wrote `telnet.el', support for `telnet' sessions
     within Emacs.

   * Gregor Schmid wrote `tcl.el', a mode for editing Tcl/Tk scripts.

   * Michael Schmidt and Tom Perrine wrote `modula2.el', a mode for
     editing Modula-2 code, based on work by Mick Jordan and Peter
     Robinson.

   * Ronald S. Schnell wrote `dunnet.el', a text adventure game.

   * Philippe Schnoebelen wrote `gomoku.el', a gomoku game played
     against Emacs, and `mpuz.el', a multiplication puzzle.

   * Randal Schwartz wrote `pp.el', a pretty-printer for lisp objects.

   * Olin Shivers wrote:
        * `comint.el', a library for modes running interactive
          command-line- oriented subprocesses,

        * `cmuscheme.el', for running inferior Scheme processes,

        * `inf-lisp.el', for running inferior Lisp process, and

        * `shell.el', for running inferior shells.

   * Espen Skoglund wrote `pascal.el', a mode for editing Pascal code.

   * Rick Sladkey wrote `backquote.el', a lisp macro for creating
     mostly-constant data.

   * Lynn Slater wrote `help-macro.el', a macro for writing interactive
     help for key bindings.

   * Chris Smith wrote `icon.el', a mode for editing Icon code.

   * David Smith wrote `ielm.el', a mode for interacting with the Emacs
     Lisp interpreter as a subprocess.

   * William Sommerfeld wrote `scribe.el', a mode for editing Scribe
     files, and `server.el', a package allowing programs to send files
     to an extant Emacs job to be edited.

   * Ake Stenhoff and Lars Lindberg wrote `imenu.el', a framework for
     browsing indices made from buffer contents.

   * Jonathan Stigelman wrote `hilit19.el', a package providing
     automatic highlighting in source code buffers, mail readers, and
     other contexts.

   * Steve Strassman did not write `spook.el', and even if he did, he
     really didn't mean for you to use it in an anarchistic way.

   * Spencer Thomas wrote the original `dabbrev.el', providing a command
     which completes the partial word before point, based on other
     nearby words for which it is a prefix.  He also wrote the original
     dumping support.

   * Jim Thompson wrote `ps-print.el', which converts Emacs text to
     Postscript.

   * Masanobu Umeda wrote:
        * GNUS, a featureful reader for Usenet news,

        * `prolog.el', a mode for editing Prolog code,

        * `rmailsort.el', a package for sorting messages in RMAIL
          folders,

        * `metamail.el', an interface to the Metamail program,

        * `tcp.el', emulation of the `open-network-stream' function for
          some Emacs configurations which lack it, and

        * `timezone.el', providing functions for dealing with time
          zones.

   * Geoffrey Voelker wrote the Windows NT support.

   * Johan Vromans wrote `forms.el' and its associated files, defining a
     mode for filling in forms, and `iso-acc.el', a minor mode providing
     electric accent keys for text using the ISO-8859 character set.

   * Barry Warsaw wrote:
        * `assoc.el', a set of utility functions for working with
          association lists,

        * `cc-mode.el', a major mode for editing C and C++ code, based
          on earlier work by Dave Detlefs, Stewart Clamen, and Richard
          Stallman,

        * `elp.el', a new profiler for Emacs Lisp programs.

        * `man.el', a mode for reading UNIX manual pages,

        * `regi.el', providing an AWK-like control structure for use in
          lisp programs, and

        * `reporter.el', providing customizable bug reporting for lisp
          packages.

        * `supercite.el', a minor mode for quoting sections of mail
          messages and news articles,

   * Morten Welinder wrote:
        * `desktop.el', facilities for saving some of Emacs's state
          between sessions,

        * `s-region.el', commands for setting the region using the
          shift key and motion commands, and

        * `dos-fns.el', functions for use under MS-DOS.

     He also helped port Emacs to MS-DOS.

   * Joseph Brian Wells wrote:
        * `apropos.el', a command to find commands, functions, and
          variables whose names contain matches for a regular
          expression,

        * `resume.el', support for processing command-line arguments
          after resuming a suspended Emacs job, and

        * `mail-extr.el', a package for extracting names and addresses
          from mail headers, with contributions from Jamie Zawinski.

   * Ed Wilkinson wrote `b2m.c', a program to convert mail files from
     RMAIL format to Unix `mbox' format.

   * Mike Williams wrote `mouse-sel.el', providing enhanced mouse
     selection, and `thingatpt.el', a library of functions for finding
     the "thing" (word, line, s-expression) containing point.

   * Dale R. Worley wrote `emerge.el', a package for interactively
     merging two versions of a file.

   * Tom Wurgler wrote `emacs-lock.el', which makes it harder to exit
     with valuable buffers unsaved.

   * Eli Zaretskii made many standard Emacs features work on MS-DOS.

   * Jamie Zawinski wrote:
        * Emacs 19's optimizing byte compiler, with Hallvard Furuseth,

        * much of the support for faces and X selections,

        * `mailabbrev.el', a package providing automatic expansion of
          mail aliases, and

        * `tar-mode.el', providing simple viewing and editing commands
          for tar files.

   * Neal Ziring and Felix S. T. Wu wrote `vi.el', an emulation of the
     VI text editor.

   Others too numerous to mention have reported and fixed bugs, and
added features to many parts of Emacs.  We thank them for their
generosity as well.

   This list intended to mention every contributor of a major package or
feature we currently distribute; if you know of someone we have omitted,
please report that as a manual bug.


File: emacs,  Node: Key Index,  Next: Command Index,  Prev: Glossary,  Up: Top

Key (Character) Index
*********************

* Menu:

* ! (Dired):                             Shell Commands in Dired.
* " (TeX mode):                          TeX Editing.
* # (Dired):                             Flagging Many Files.
* $ (Dired):                             Hiding Subdirectories.
* % C (Dired):                           Transforming File Names.
* % d (Dired):                           Flagging Many Files.
* % H (Dired):                           Transforming File Names.
* % l (Dired):                           Transforming File Names.
* % m (Dired):                           Marks vs Flags.
* % R (Dired):                           Transforming File Names.
* % S (Dired):                           Transforming File Names.
* % u (Dired):                           Transforming File Names.
* * (Dired):                             Marks vs Flags.
* + (Dired):                             Operating on Files.
* . (Calendar mode):                     Specified Dates.
* . (Dired):                             Flagging Many Files.
* . (Rmail):                             Rmail Scrolling.
* / (Dired):                             Marks vs Flags.
* < (Rmail):                             Rmail Motion.
* <BOTTOM>:                              Moving Point.
* <DEL> (Dired):                         Dired Deletion.
* <ESC> <ESC> <ESC>:                     Quitting.
* <F1>:                                  Help.
* <LEFT>:                                Moving Point.
* <NEXT>:                                Scrolling.
* <PRIOR>:                               Scrolling.
* <RET> (Dired):                         Dired Visiting.
* <RET> (Occur mode):                    Other Repeating Search.
* <RET> (Shell mode):                    Shell Mode.
* <RIGHT>:                               Moving Point.
* <SPC> (Dired):                         Dired Commands.
* <TAB> (GUD):                           Commands of GUD.
* <TAB> (Shell mode):                    Shell Mode.
* <TOP>:                                 Moving Point.
* = (Dired):                             Comparison in Dired.
* > (Rmail):                             Rmail Motion.
* @ (Dired):                             Marks vs Flags.
* a (Calendar mode):                     Holidays.
* A (Dired):                             Operating on Files.
* a (Rmail):                             Rmail Labels.
* B (Dired):                             Operating on Files.
* b (Rmail):                             Rmail Basics.
* BS (MS-DOS):                           Keyboard and Mouse on MS-DOS.
* C (Dired):                             Operating on Files.
* c (Dired):                             Marks vs Flags.
* c (Rmail):                             Rmail Reply.
* C-@:                                   Setting Mark.
* C-]:                                   Quitting.
* C-_:                                   Undo.
* C-a:                                   Moving Point.
* C-a (Calendar mode):                   Move to Beginning or End.
* C-b:                                   Moving Point.
* C-b (Calendar mode):                   Calendar Unit Motion.
* C-c ' (Picture mode):                  Insert in Picture.
* C-c . (Picture mode):                  Insert in Picture.
* C-c / (Picture mode):                  Insert in Picture.
* C-c : (C mode):                        Electric C.
* C-c ; (Fortran mode):                  Fortran Comments.
* C-c < (GUD):                           Commands of GUD.
* C-c < (Picture mode):                  Insert in Picture.
* C-c <RET> (Shell mode):                Shell History Copying.
* C-c > (GUD):                           Commands of GUD.
* C-c > (Picture mode):                  Insert in Picture.
* C-c @ (Outline minor mode):            Outline Mode.
* C-c \ (Picture mode):                  Insert in Picture.
* C-c ^ (Picture mode):                  Insert in Picture.
* C-c ` (Picture mode):                  Insert in Picture.
* C-c C-\ (C mode):                      Other C Commands.
* C-c C-\ (Shell mode):                  Shell Mode.
* C-c C-a (C mode):                      Electric C.
* C-c C-a (Mail mode):                   Mail Aliases.
* C-c C-a (Outline mode):                Outline Visibility.
* C-c C-a (Shell mode):                  Shell Mode.
* C-c C-b (Outline mode):                Outline Motion.
* C-c C-b (Picture mode):                Insert in Picture.
* C-c C-b (Shell mode):                  Shell Mode.
* C-c C-b (TeX mode):                    TeX Print.
* C-c C-c (Edit Abbrevs):                Editing Abbrevs.
* C-c C-c (Edit Tab Stops):              Tab Stops.
* C-c C-c (Mail mode):                   Mail Mode.
* C-c C-c (Outline mode):                Outline Visibility.
* C-c C-c (Shell mode):                  Shell Mode.
* C-c C-d:                               Hungry Delete.
* C-c C-d (GUD):                         Commands of GUD.
* C-c C-d (Outline mode):                Outline Visibility.
* C-c C-d (Picture mode):                Basic Picture.
* C-c C-e (C mode):                      Other C Commands.
* C-c C-e (LaTeX mode):                  LaTeX Editing.
* C-c C-e (Outline mode):                Outline Visibility.
* C-c C-e (Shell mode):                  Shell Mode.
* C-c C-f (GUD):                         Commands of GUD.
* C-c C-f (Outline mode):                Outline Motion.
* C-c C-f (Picture mode):                Insert in Picture.
* C-c C-f (Shell mode):                  Shell Mode.
* C-c C-f (TeX mode):                    TeX Print.
* C-c C-f C-b (Mail mode):               Mail Mode.
* C-c C-f C-c (Mail mode):               Mail Mode.
* C-c C-f C-f (Mail mode):               Mail Mode.
* C-c C-f C-s (Mail mode):               Mail Mode.
* C-c C-f C-t (Mail mode):               Mail Mode.
* C-c C-i (GUD):                         Commands of GUD.
* C-c C-i (Outline mode):                Outline Visibility.
* C-c C-k (Outline mode):                Outline Visibility.
* C-c C-k (Picture mode):                Rectangles in Picture.
* C-c C-k (TeX mode):                    TeX Print.
* C-c C-l (Calendar mode):               General Calendar.
* C-c C-l (GUD):                         Commands of GUD.
* C-c C-l (Outline mode):                Outline Visibility.
* C-c C-l (Shell mode):                  Shell Mode.
* C-c C-l (TeX mode):                    TeX Print.
* C-c C-n:                               Motion in C.
* C-c C-n (Fortran mode):                Fortran Motion.
* C-c C-n (GUD):                         Commands of GUD.
* C-c C-n (Outline mode):                Outline Motion.
* C-c C-n (Shell mode):                  Shell History Copying.
* C-c C-o:                               Changing Indent Style.
* C-c C-o (LaTeX mode):                  LaTeX Editing.
* C-c C-o (Outline mode):                Outline Visibility.
* C-c C-o (Shell mode):                  Shell Mode.
* C-c C-p:                               Motion in C.
* C-c C-p (Fortran mode):                Fortran Motion.
* C-c C-p (Outline mode):                Outline Motion.
* C-c C-p (Shell mode):                  Shell History Copying.
* C-c C-p (TeX mode):                    TeX Print.
* C-c C-q:                               C Indent.
* C-c C-q (Mail mode):                   Mail Mode.
* C-c C-q (Outline mode):                Outline Visibility.
* C-c C-q (TeX mode):                    TeX Print.
* C-c C-r (Fortran mode):                Fortran Columns.
* C-c C-r (GUD):                         Commands of GUD.
* C-c C-r (Shell mode):                  Shell Mode.
* C-c C-r (TeX mode):                    TeX Print.
* C-c C-s (C mode):                      Other C Commands.
* C-c C-s (GUD):                         Commands of GUD.
* C-c C-s (Mail mode):                   Mail Mode.
* C-c C-s (Outline mode):                Outline Visibility.
* C-c C-t:                               Hungry Delete.
* C-c C-t (GUD):                         Commands of GUD.
* C-c C-t (Mail mode):                   Mail Mode.
* C-c C-t (Outline mode):                Outline Visibility.
* C-c C-u:                               Motion in C.
* C-c C-u (Outline mode):                Outline Motion.
* C-c C-u (Shell mode):                  Shell Mode.
* C-c C-v (TeX mode):                    TeX Print.
* C-c C-w (Fortran mode):                Fortran Columns.
* C-c C-w (Mail mode):                   Mail Mode.
* C-c C-w (Picture mode):                Rectangles in Picture.
* C-c C-w (Shell mode):                  Shell Mode.
* C-c C-x (Picture mode):                Rectangles in Picture.
* C-c C-y (Mail mode):                   Mail Mode.
* C-c C-y (Picture mode):                Rectangles in Picture.
* C-c C-z (Shell mode):                  Shell Mode.
* C-c TAB (Picture mode):                Tabs in Picture.
* C-c TAB (TeX mode):                    TeX Print.
* C-c { (TeX mode):                      TeX Editing.
* C-c } (TeX mode):                      TeX Editing.
* C-d:                                   Deletion.
* C-d (Rmail):                           Rmail Deletion.
* C-d (Shell mode):                      Shell Mode.
* C-e:                                   Moving Point.
* C-e (Calendar mode):                   Move to Beginning or End.
* C-f:                                   Moving Point.
* C-f (Calendar mode):                   Calendar Unit Motion.
* C-g <1>:                               Minibuffer.
* C-g:                                   Quitting.
* C-h:                                   Help.
* C-h a:                                 Apropos.
* C-h b:                                 Misc Help.
* C-h c:                                 Key Help.
* C-h C-c:                               Misc Help.
* C-h C-d:                               Misc Help.
* C-h C-f:                               Misc Help.
* C-h C-h:                               Help.
* C-h C-k:                               Misc Help.
* C-h C-p:                               Misc Help.
* C-h C-w:                               Misc Help.
* C-h f:                                 Name Help.
* C-h i:                                 Misc Help.
* C-h k:                                 Key Help.
* C-h l:                                 Misc Help.
* C-h m:                                 Misc Help.
* C-h n:                                 Misc Help.
* C-h p:                                 Library Keywords.
* C-h s:                                 Syntax.
* C-h t:                                 Basic.
* C-h w:                                 Name Help.
* C-k:                                   Killing by Lines.
* C-k (Gnus):                            Summary of Gnus.
* C-l:                                   Scrolling.
* C-M-.:                                 Find Tag.
* C-M-/:                                 Dynamic Abbrevs.
* C-M-<DEL>:                             List Commands.
* C-M-@:                                 List Commands.
* C-M-\:                                 Indentation Commands.
* C-M-a:                                 Defuns.
* C-M-a (Fortran mode):                  Fortran Motion.
* C-M-b:                                 List Commands.
* C-M-c:                                 Recursive Edit.
* C-M-d:                                 List Commands.
* C-M-d (Dired):                         Subdirectory Motion.
* C-M-e:                                 Defuns.
* C-M-e (Fortran mode):                  Fortran Motion.
* C-M-f:                                 List Commands.
* C-M-g:                                 Font Lock.
* C-M-h:                                 Defuns.
* C-M-h (C mode):                        Other C Commands.
* C-M-h (Fortran mode):                  Fortran Motion.
* C-M-k:                                 List Commands.
* C-M-l:                                 Scrolling.
* C-M-l (Rmail):                         Rmail Make Summary.
* C-M-l (Shell mode):                    Shell Mode.
* C-M-n:                                 List Commands.
* C-M-n (Dired):                         Subdirectory Motion.
* C-M-n (Rmail):                         Rmail Labels.
* C-M-o:                                 Indentation Commands.
* C-M-p:                                 List Commands.
* C-M-p (Dired):                         Subdirectory Motion.
* C-M-p (Rmail):                         Rmail Labels.
* C-M-q <1>:                             Multi-line Indent.
* C-M-q:                                 C Indent.
* C-M-q (Fortran mode):                  ForIndent Commands.
* C-M-r:                                 Regexp Search.
* C-M-r (Rmail):                         Rmail Make Summary.
* C-M-s:                                 Regexp Search.
* C-M-t <1>:                             List Commands.
* C-M-t:                                 Transpose.
* C-M-t (Rmail):                         Rmail Make Summary.
* C-M-u:                                 List Commands.
* C-M-u (Dired):                         Subdirectory Motion.
* C-M-v:                                 Other Window.
* C-M-w:                                 Appending Kills.
* C-M-x (Emacs-Lisp mode):               Lisp Eval.
* C-M-x (Lisp mode):                     External Lisp.
* C-Mouse-2 (scroll bar):                Split Window.
* C-Mouse-3:                             Menu Mouse Clicks.
* C-n:                                   Moving Point.
* C-n (Calendar mode):                   Calendar Unit Motion.
* C-n (Dired):                           Dired Commands.
* C-n (Gnus Group mode):                 Summary of Gnus.
* C-n (Gnus Summary mode):               Summary of Gnus.
* C-o:                                   Blank Lines.
* C-o (Dired):                           Dired Visiting.
* C-o (Rmail):                           Rmail Output.
* C-p:                                   Moving Point.
* C-p (Calendar mode):                   Calendar Unit Motion.
* C-p (Dired):                           Dired Commands.
* C-p (Gnus Group mode):                 Summary of Gnus.
* C-p (Gnus Summary mode):               Summary of Gnus.
* C-q:                                   Inserting Text.
* C-r:                                   Incremental Search.
* C-s:                                   Incremental Search.
* C-SPC:                                 Setting Mark.
* C-t <1>:                               Transpose.
* C-t:                                   Moving Point.
* C-u:                                   Arguments.
* C-u - C-x ;:                           Comment Commands.
* C-u C-@:                               Mark Ring.
* C-u C-SPC:                             Mark Ring.
* C-u C-x C-q:                           Check-Out.
* C-u TAB:                               Multi-line Indent.
* C-v:                                   Scrolling.
* C-v (Calendar mode):                   Scroll Calendar.
* C-w:                                   Other Kill Commands.
* C-x #:                                 Emacs Server.
* C-x $:                                 Selective Display.
* C-x (:                                 Basic Kbd Macro.
* C-x ):                                 Basic Kbd Macro.
* C-x .:                                 Fill Prefix.
* C-x 0:                                 Change Window.
* C-x 1:                                 Change Window.
* C-x 2:                                 Split Window.
* C-x 3:                                 Split Window.
* C-x 4:                                 Pop Up Window.
* C-x 4 .:                               Find Tag.
* C-x 4 a:                               Change Log.
* C-x 4 b:                               Select Buffer.
* C-x 4 d:                               Dired Enter.
* C-x 4 f:                               Visiting.
* C-x 4 m:                               Sending Mail.
* C-x 5:                                 Creating Frames.
* C-x 5 .:                               Find Tag.
* C-x 5 0:                               Misc X.
* C-x 5 2:                               Creating Frames.
* C-x 5 b:                               Select Buffer.
* C-x 5 d:                               Dired Enter.
* C-x 5 f:                               Visiting.
* C-x 5 m:                               Sending Mail.
* C-x 5 o:                               Misc X.
* C-x 5 r:                               Creating Frames.
* C-x 6 1:                               Two-Column.
* C-x 6 2:                               Two-Column.
* C-x 6 <RET>:                           Two-Column.
* C-x 6 b:                               Two-Column.
* C-x 6 d:                               Two-Column.
* C-x 6 s:                               Two-Column.
* C-x 8:                                 European Display.
* C-x ;:                                 Options for Comments.
* C-x <:                                 Horizontal Scrolling.
* C-x < (Calendar mode):                 Scroll Calendar.
* C-x <SPC>:                             Commands of GUD.
* C-x <TAB> (Enriched mode):             Format Indentation.
* C-x =:                                 Position Info.
* C-x >:                                 Horizontal Scrolling.
* C-x > (Calendar mode):                 Scroll Calendar.
* C-x [:                                 Pages.
* C-x [ (Calendar mode):                 Calendar Unit Motion.
* C-x ]:                                 Pages.
* C-x ] (Calendar mode):                 Calendar Unit Motion.
* C-x ^:                                 Change Window.
* C-x `:                                 Compilation.
* C-x a g:                               Defining Abbrevs.
* C-x a i g:                             Defining Abbrevs.
* C-x a i l:                             Defining Abbrevs.
* C-x a l:                               Defining Abbrevs.
* C-x b:                                 Select Buffer.
* C-x C-a (GUD):                         Commands of GUD.
* C-x C-b:                               List Buffers.
* C-x C-c:                               Exiting.
* C-x C-d:                               Directories.
* C-x C-e:                               Lisp Eval.
* C-x C-f:                               Visiting.
* C-x C-k:                               Basic Kbd Macro.
* C-x C-l:                               Case.
* C-x C-n:                               Moving Point.
* C-x C-o:                               Blank Lines.
* C-x C-p:                               Pages.
* C-x C-q:                               Misc Buffer.
* C-x C-q (version control):             Check-Out.
* C-x C-r:                               Visiting.
* C-x C-s:                               Saving.
* C-x C-t:                               Transpose.
* C-x C-u:                               Case.
* C-x C-v:                               Visiting.
* C-x C-w:                               Saving.
* C-x C-x:                               Setting Mark.
* C-x C-z:                               External Lisp.
* C-x d:                                 Dired Enter.
* C-x DEL:                               Sentences.
* C-x e:                                 Basic Kbd Macro.
* C-x ESC ESC:                           Repetition.
* C-x f:                                 Fill Commands.
* C-x h:                                 Marking Objects.
* C-x k:                                 Kill Buffer.
* C-x l:                                 Pages.
* C-x m:                                 Sending Mail.
* C-x n n:                               Narrowing.
* C-x n p:                               Narrowing.
* C-x n w:                               Narrowing.
* C-x o:                                 Other Window.
* C-x q:                                 Kbd Macro Query.
* C-x r <SPC>:                           RegPos.
* C-x r b:                               Bookmarks.
* C-x r d:                               Rectangles.
* C-x r f:                               RegConfig.
* C-x r i:                               RegText.
* C-x r j:                               RegPos.
* C-x r k:                               Rectangles.
* C-x r l:                               Bookmarks.
* C-x r m:                               Bookmarks.
* C-x r o:                               Rectangles.
* C-x r r:                               RegRect.
* C-x r s:                               RegText.
* C-x r w:                               RegConfig.
* C-x r y:                               Rectangles.
* C-x s:                                 Saving.
* C-x TAB:                               Indentation Commands.
* C-x u:                                 Undo.
* C-x v =:                               Old Versions.
* C-x v a:                               Change Logs and VC.
* C-x v c:                               Version Control Undo.
* C-x v d:                               Status in VC.
* C-x v h:                               Version Headers.
* C-x v i:                               Registering.
* C-x v l:                               Status in VC.
* C-x v r:                               Making Snapshots.
* C-x v s:                               Making Snapshots.
* C-x v u:                               Version Control Undo.
* C-x v ~:                               Old Versions.
* C-x }:                                 Change Window.
* C-y:                                   Kill Ring.
* C-z:                                   Exiting.
* C-z (X windows):                       Misc X.
* d (Calendar mode):                     Diary Commands.
* d (Dired):                             Dired Deletion.
* d (Rmail):                             Rmail Deletion.
* DEL:                                   Deletion.
* DEL (and major modes):                 Major Modes.
* DEL (Gnus):                            Summary of Gnus.
* DEL (MS-DOS):                          Keyboard and Mouse on MS-DOS.
* DEL (programming modes):               Program Modes.
* DEL (Rmail):                           Rmail Scrolling.
* e (Rmail):                             Rmail Editing.
* ESC a:                                 Motion in C.
* ESC e:                                 Motion in C.
* f (Dired):                             Dired Visiting.
* f (Rmail):                             Rmail Reply.
* f2 1:                                  Two-Column.
* f2 2:                                  Two-Column.
* f2 <RET>:                              Two-Column.
* f2 b:                                  Two-Column.
* f2 d:                                  Two-Column.
* f2 s:                                  Two-Column.
* g (Dired):                             Dired Updating.
* G (Dired):                             Operating on Files.
* g (Rmail):                             Rmail Files.
* g CHAR (Calendar mode):                From Other Calendar.
* g d (Calendar mode):                   Specified Dates.
* g m (Calendar mode):                   Mayan Calendar.
* h (Calendar mode):                     Holidays.
* H (Dired):                             Operating on Files.
* h (Rmail):                             Rmail Make Summary.
* Help:                                  Help.
* i (Dired):                             Subdirectories in Dired.
* i (Rmail):                             Rmail Files.
* i a (Calendar mode):                   Special Diary Entries.
* i b (Calendar mode):                   Special Diary Entries.
* i c (Calendar mode):                   Special Diary Entries.
* i d (Calendar mode):                   Adding to Diary.
* i m (Calendar mode):                   Adding to Diary.
* i w (Calendar mode):                   Adding to Diary.
* i y (Calendar mode):                   Adding to Diary.
* j (Rmail):                             Rmail Motion.
* k (Dired):                             Dired Updating.
* k (Rmail):                             Rmail Labels.
* L (Dired):                             Operating on Files.
* l (Dired):                             Dired Updating.
* l (Gnus Group mode):                   Summary of Gnus.
* L (Gnus Group mode):                   Summary of Gnus.
* l (Rmail):                             Rmail Make Summary.
* LFD:                                   Basic Indent.
* LFD (and major modes):                 Major Modes.
* LFD (Fortran mode):                    ForIndent Commands.
* LFD (MS-DOS):                          Keyboard and Mouse on MS-DOS.
* LFD (TeX mode):                        TeX Editing.
* m (Calendar mode):                     Diary Commands.
* M (Calendar mode):                     Lunar Phases.
* m (Dired):                             Marks vs Flags.
* M (Dired):                             Operating on Files.
* m (Rmail):                             Rmail Reply.
* M-!:                                   Single Shell.
* M-$:                                   Spelling.
* M-$ (Dired):                           Hiding Subdirectories.
* M-%:                                   Query Replace.
* M-':                                   Expanding Abbrevs.
* M-(:                                   Balanced Editing.
* M-):                                   Balanced Editing.
* M-,:                                   Tags Search.
* M--:                                   Arguments.
* M-- M-c:                               Fixing Case.
* M-- M-l:                               Fixing Case.
* M-- M-u:                               Fixing Case.
* M-.:                                   Find Tag.
* M-/:                                   Dynamic Abbrevs.
* M-1:                                   Arguments.
* M-::                                   Lisp Eval.
* M-;:                                   Comment Commands.
* M-<:                                   Moving Point.
* M-< (Calendar mode):                   Move to Beginning or End.
* M-<DEL> (Dired):                       Marks vs Flags.
* M-<TAB>:                               Mail Mode.
* M-=:                                   Position Info.
* M-= (Calendar mode):                   Counting Days.
* M-= (Dired):                           Comparison in Dired.
* M->:                                   Moving Point.
* M-> (Calendar mode):                   Move to Beginning or End.
* M-? (Nroff mode):                      Nroff Mode.
* M-? (Shell mode):                      Shell Mode.
* M-@:                                   Words.
* M-\:                                   Deletion.
* M-^:                                   Indentation Commands.
* M-`:                                   Menu Bars.
* M-a:                                   Sentences.
* M-a (Calendar mode):                   Move to Beginning or End.
* M-b:                                   Words.
* M-c:                                   Case.
* M-d:                                   Words.
* M-DEL:                                 Words.
* M-Drag-Mouse-1:                        Secondary Selection.
* M-e:                                   Sentences.
* M-e (Calendar mode):                   Move to Beginning or End.
* M-f:                                   Words.
* M-g b (Enriched mode):                 Format Faces.
* M-g d (Enriched mode):                 Format Faces.
* M-g i (Enriched mode):                 Format Faces.
* M-g l (Enriched mode):                 Format Faces.
* M-g o (Enriched mode):                 Format Faces.
* M-g u (Enriched mode):                 Format Faces.
* M-h:                                   Paragraphs.
* M-i:                                   Tab Stops.
* M-j c (Enriched mode):                 Format Justification.
* M-j f (Enriched mode):                 Format Justification.
* M-j l (Enriched mode):                 Format Justification.
* M-j r (Enriched mode):                 Format Justification.
* M-j u (Enriched mode):                 Format Justification.
* M-k:                                   Sentences.
* M-l:                                   Case.
* M-LFD:                                 Multi-Line Comments.
* M-LFD (Fortran mode):                  ForIndent Commands.
* M-m:                                   Indentation Commands.
* M-m (Rmail):                           Rmail Reply.
* M-Mouse-1:                             Secondary Selection.
* M-Mouse-2:                             Secondary Selection.
* M-Mouse-3:                             Secondary Selection.
* M-n (minibuffer history):              Minibuffer History.
* M-n (Nroff mode):                      Nroff Mode.
* M-n (Rmail):                           Rmail Motion.
* M-n (Shell mode):                      Shell Ring.
* M-p (minibuffer history):              Minibuffer History.
* M-p (Nroff mode):                      Nroff Mode.
* M-p (Rmail):                           Rmail Motion.
* M-p (Shell mode):                      Shell Ring.
* M-q:                                   Fill Commands.
* M-q (C mode):                          Other C Commands.
* M-r:                                   Moving Point.
* M-r (minibuffer history):              Minibuffer History.
* M-r (Shell mode):                      Shell Ring.
* M-S (Enriched mode):                   Format Justification.
* M-s (Gnus Summary mode):               Summary of Gnus.
* M-s (minibuffer history):              Minibuffer History.
* M-s (Rmail):                           Rmail Motion.
* M-s (Shell mode):                      Shell Ring.
* M-s (Text mode):                       Fill Commands.
* M-SPC:                                 Deletion.
* M-t <1>:                               Words.
* M-t:                                   Transpose.
* M-TAB:                                 Symbol Completion.
* M-TAB (Picture mode):                  Tabs in Picture.
* M-TAB (Text mode):                     Text Mode.
* M-u:                                   Case.
* M-v:                                   Scrolling.
* M-v (Calendar mode):                   Scroll Calendar.
* M-w:                                   Kill Ring.
* M-x:                                   M-x.
* M-y:                                   Earlier Kills.
* M-z:                                   Other Kill Commands.
* M-{:                                   Paragraphs.
* M-{ (Calendar mode):                   Calendar Unit Motion.
* M-|:                                   Single Shell.
* M-}:                                   Paragraphs.
* M-} (Calendar mode):                   Calendar Unit Motion.
* M-~:                                   Saving.
* Mouse-1:                               Mouse Commands.
* Mouse-2:                               Mouse Commands.
* Mouse-2 (selection):                   Mouse References.
* Mouse-3:                               Mouse Commands.
* n (Gnus):                              Summary of Gnus.
* n (Rmail):                             Rmail Motion.
* o (Calendar mode):                     Specified Dates.
* O (Dired):                             Operating on Files.
* o (Dired):                             Dired Visiting.
* o (Rmail):                             Rmail Output.
* p (Calendar mode):                     To Other Calendar.
* P (Dired):                             Operating on Files.
* p (Gnus):                              Summary of Gnus.
* p (Rmail):                             Rmail Motion.
* p d (Calendar mode):                   General Calendar.
* q (Calendar mode):                     General Calendar.
* Q (Dired):                             Operating on Files.
* q (Gnus Group mode):                   Summary of Gnus.
* q (Rmail summary):                     Rmail Summary Edit.
* q (Rmail):                             Rmail Basics.
* R (Dired):                             Operating on Files.
* r (Rmail):                             Rmail Reply.
* RET:                                   Inserting Text.
* S (Calendar mode):                     Sunrise/Sunset.
* s (Calendar mode):                     Diary Commands.
* S (Dired):                             Operating on Files.
* s (Dired):                             Dired Updating.
* s (Gnus Summary mode):                 Summary of Gnus.
* s (Rmail):                             Rmail Basics.
* S-Mouse-1:                             Frame Parameters.
* SPC:                                   Completion Commands.
* SPC (Calendar mode):                   General Calendar.
* SPC (Gnus):                            Summary of Gnus.
* SPC (Rmail):                           Rmail Scrolling.
* t (Calendar mode):                     TeX Calendar.
* t (Rmail):                             Rmail Display.
* TAB:                                   Indentation.
* TAB (and major modes):                 Major Modes.
* TAB (completion):                      Completion Example.
* TAB (Indented Text mode):              Text Mode.
* TAB (programming modes):               Basic Indent.
* u (Calendar mode):                     Holidays.
* u (Dired):                             Dired Deletion.
* u (Gnus Group mode):                   Summary of Gnus.
* u (Rmail):                             Rmail Deletion.
* v (Dired):                             Dired Visiting.
* w (Rmail summary):                     Rmail Summary Edit.
* x (Calendar mode):                     Holidays.
* x (Dired):                             Dired Deletion.
* x (Rmail):                             Rmail Deletion.
* Z (Dired):                             Operating on Files.
* ~ (Dired):                             Flagging Many Files.

