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

   This is the thirteenth edition of the `GNU Emacs Manual', updated
for Emacs version 20.7.

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

   Published by the Free Software Foundation 59 Temple Place, Suite 330
Boston, MA  02111-1307 USA

   Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998,
1999    Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
General Public License" are included exactly as in the original, and
provided that the entire resulting derived work is distributed under the
terms of a permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "The GNU Manifesto",
"Distribution" and "GNU General Public License" may be included in a
translation approved by the Free Software Foundation instead of in the
original English.


File: emacs,  Node: Sending Mail,  Next: Rmail,  Prev: Picture,  Up: Top

Sending Mail
************

   To send a message in Emacs, you start by typing a command (`C-x m')
to select and initialize the `*mail*' buffer.  Then you edit the text
and headers of the message in this buffer, and type another command
(`C-c C-s' or `C-c C-c') to send the message.

`C-x m'
     Begin composing a message to send (`compose-mail').

`C-x 4 m'
     Likewise, but display the message in another window
     (`compose-mail-other-window').

`C-x 5 m'
     Likewise, but make a new frame (`compose-mail-other-frame').

`C-c C-s'
     In Mail mode, send the message (`mail-send').

`C-c C-c'
     Send the message and bury the mail buffer (`mail-send-and-exit').

   The command `C-x m' (`compose-mail') selects a buffer named `*mail*'
and initializes it with the skeleton of an outgoing message.  `C-x 4 m'
(`compose-mail-other-window') selects the `*mail*' buffer in a
different window, leaving the previous current buffer visible.  `C-x 5
m' (`compose-mail-other-frame') creates a new frame to select the
`*mail*' buffer.

   Because the mail-composition buffer is an ordinary Emacs buffer, you
can switch to other buffers while in the middle of composing mail, and
switch back later (or never).  If you use the `C-x m' command again
when you have been composing another message but have not sent it, you
are asked to confirm before the old message is erased.  If you answer
`n', the `*mail*' buffer is left selected with its old contents, so you
can finish the old message and send it.  `C-u C-x m' is another way to
do this.  Sending the message marks the `*mail*' buffer "unmodified,"
which avoids the need for confirmation when `C-x m' is next used.

   If you are composing a message in the `*mail*' buffer and want to
send another message before finishing the first, rename the `*mail*'
buffer using `M-x rename-uniquely' (*note Misc Buffer::).  Then you can
use `C-x m' or its variants described above to make a new `*mail*'
buffer.  Once you've done that, you can work with each mail buffer
independently.

* Menu:

* Format: Mail Format.	     Format of the mail being composed.
* Headers: Mail Headers.     Details of permitted mail header fields.
* Aliases: Mail Aliases.     Abbreviating and grouping mail addresses.
* Mode: Mail Mode.	     Special commands for editing mail being composed.
* Spook: Distracting NSA.    How to distract the NSA's attention.
* Mail Methods::             Using alternative mail-composition methods.


File: emacs,  Node: Mail Format,  Next: Mail Headers,  Up: Sending Mail

The Format of the Mail Buffer
=============================

   In addition to the "text" or "body", a message has "header fields"
which say who sent it, when, to whom, why, and so on.  Some header
fields, such as `Date' and `Sender', are created automatically when you
send the message.  Others, such as the recipient names, must be
specified by you in order to send the message properly.

   Mail mode provides a few commands to help you edit some header
fields, and some are preinitialized in the buffer automatically at
times.  You can insert and edit header fields using ordinary editing
commands.

   The line in the buffer that says

     --text follows this line--

is a special delimiter that separates the headers you have specified
from the text.  Whatever follows this line is the text of the message;
the headers precede it.  The delimiter line itself does not appear in
the message actually sent.  The text used for the delimiter line is
controlled by the variable `mail-header-separator'.

   Here is an example of what the headers and text in the mail buffer
might look like.

     To: gnu@gnu.org
     CC: lungfish@spam.org, byob@spam.org
     Subject: The Emacs Manual
     --Text follows this line--
     Please ignore this message.


File: emacs,  Node: Mail Headers,  Next: Mail Aliases,  Prev: Mail Format,  Up: Sending Mail

Mail Header Fields
==================

   A header field in the mail buffer starts with a field name at the
beginning of a line, terminated by a colon.  Upper and lower case are
equivalent in field names (and in mailing addresses also).  After the
colon and optional whitespace comes the contents of the field.

   You can use any name you like for a header field, but normally people
use only standard field names with accepted meanings.  Here is a table
of fields commonly used in outgoing messages.

`To'
     This field contains the mailing addresses to which the message is
     addressed.  If you list more than one address, use commas, not
     spaces, to separate them.

`Subject'
     The contents of the `Subject' field should be a piece of text that
     says what the message is about.  The reason `Subject' fields are
     useful is that most mail-reading programs can provide a summary of
     messages, listing the subject of each message but not its text.

`CC'
     This field contains additional mailing addresses to send the
     message to, like `To' except that these readers should not regard
     the message as directed at them.

`BCC'
     This field contains additional mailing addresses to send the
     message to, which should not appear in the header of the message
     actually sent.  Copies sent this way are called "blind carbon
     copies".

     To send a blind carbon copy of every outgoing message to yourself,
     set the variable `mail-self-blind' to `t'.

`FCC'
     This field contains the name of one file and directs Emacs to
     append a copy of the message to that file when you send the
     message.  If the file is in Rmail format, Emacs writes the message
     in Rmail format; otherwise, Emacs writes the message in system
     mail file format.

     To put a fixed file name in the `FCC' field each time you start
     editing an outgoing message, set the variable
     `mail-archive-file-name' to that file name.  Unless you remove the
     `FCC' field before sending, the message will be written into that
     file when it is sent.

`From'
     Use the `From' field to say who you are, when the account you are
     using to send the mail is not your own.  The contents of the `From'
     field should be a valid mailing address, since replies will
     normally go there.  If you don't specify the `From' field
     yourself, Emacs uses the value of `user-mail-address' as the
     default.

`Reply-to'
     Use this field to direct replies to a different address.  Most
     mail-reading programs (including Rmail) automatically send replies
     to the `Reply-to' address in preference to the `From' address.  By
     adding a `Reply-to' field to your header, you can work around any
     problems your `From' address may cause for replies.

     To put a fixed `Reply-to' address into every outgoing message, set
     the variable `mail-default-reply-to' to that address (as a string).
     Then `mail' initializes the message with a `Reply-to' field as
     specified.  You can delete or alter that header field before you
     send the message, if you wish.  When Emacs starts up, if the
     environment variable `REPLYTO' is set, `mail-default-reply-to' is
     initialized from that environment variable.

`In-reply-to'
     This field contains a piece of text describing a message you are
     replying to.  Some mail systems can use this information to
     correlate related pieces of mail.  Normally this field is filled
     in by Rmail when you reply to a message in Rmail, and you never
     need to think about it (*note Rmail::).

`References'
     This field lists the message IDs of related previous messages.
     Rmail sets up this field automatically when you reply to a message.

   The `To', `CC', `BCC' and `FCC' header fields can appear any number
of times, and each such header field can contain multiple addresses,
separated by commas.  This way, you can specify any number of places to
send the message.  A `To', `CC', or `BCC' field can also have
continuation lines: one or more lines starting with whitespace,
following the starting line of the field, are considered part of the
field.  Here's an example of a `To' field with a continuation line:

     To: foo@here.net, this@there.net,
       me@gnu.cambridge.mass.usa.earth.spiral3281

   When you send the message, if you didn't write a `From' field
yourself, Emacs puts in one for you.  The variable `mail-from-style'
controls the format:

`nil'
     Use just the email address, as in `king@grassland.com'.

`parens'
     Use both email address and full name, as in `king@grassland.com
     (Elvis Parsley)'.

`angles'
     Use both email address and full name, as in `Elvis Parsley
     <king@grassland.com>'.

`system-default'
     Allow the system to insert the `From' field.


File: emacs,  Node: Mail Aliases,  Next: Mail Mode,  Prev: Mail Headers,  Up: Sending Mail

Mail Aliases
============

   You can define "mail aliases" in a file named `~/.mailrc'.  These
are short mnemonic names which stand for mail addresses or groups of
mail addresses.  Like many other mail programs, Emacs expands aliases
when they occur in the `To', `From', `CC', `BCC', and `Reply-to'
fields, plus their `Resent-' variants.

   To define an alias in `~/.mailrc', write a line in the following
format:

     alias SHORTADDRESS FULLADDRESSES

Here FULLADDRESSES stands for one or more mail addresses for
SHORTADDRESS to expand into.  Separate multiple addresses with spaces;
if an address contains a space, quote the whole address with a pair of
double-quotes.

   For instance, to make `maingnu' stand for `gnu@gnu.org' plus a local
address of your own, put in this line:

     alias maingnu gnu@gnu.org local-gnu

   Emacs also recognizes include commands in `.mailrc' files.  They
look like this:

     source FILENAME

The file `~/.mailrc' is used primarily by other mail-reading programs;
it can contain various other commands.  Emacs ignores everything in it
except for alias definitions and include commands.

   Another way to define a mail alias, within Emacs alone, is with the
`define-mail-alias' command.  It prompts for the alias and then the
full address.  You can use it to define aliases in your `.emacs' file,
like this:

     (define-mail-alias "maingnu" "gnu@gnu.org")

   `define-mail-alias' records aliases by adding them to a variable
named `mail-aliases'.  If you are comfortable with manipulating Lisp
lists, you can set `mail-aliases' directly.  The initial value of
`mail-aliases' is `t', which means that Emacs should read `.mailrc' to
get the proper value.

   You can specify a different file name to use instead of `~/.mailrc'
by setting the variable `mail-personal-alias-file'.

   Normally, Emacs expands aliases when you send the message.  You do
not need to expand mail aliases before sending the message, but you can
expand them if you want to see where the mail will actually go.  To do
this, use the command `M-x expand-mail-aliases'; it expands all mail
aliases currently present in the mail headers that hold addresses.

   If you like, you can have mail aliases expand as abbrevs, as soon as
you type them in (*note Abbrevs::).  To enable this feature, execute the
following:

     (add-hook 'mail-setup-hook 'mail-abbrevs-setup)

This can go in your `.emacs' file.  *Note Hooks::.  If you use this
feature, you must use `define-mail-abbrev' instead of
`define-mail-alias'; the latter does not work with this package.  Note
that the mail abbreviation package uses the variable `mail-abbrevs'
instead of `mail-aliases', and that all alias names are converted to
lower case.

   The mail abbreviation package also provides the `C-c C-a'
(`mail-interactive-insert-alias') command, which reads an alias name
(with completion) and inserts its definition at point.  This is useful
when editing the message text itself or a header field such as
`Subject' in which Emacs does not normally expand aliases.

   Note that abbrevs expand only if you insert a word-separator
character afterward.  However, you can rebind `C-n' and `M->' to cause
expansion as well.  Here's how to do that:

     (add-hook 'mail-setup-hook
               '(lambda ()
                  (substitute-key-definition
                    'next-line 'mail-abbrev-next-line
                    mail-mode-map global-map)
                  (substitute-key-definition
                    'end-of-buffer 'mail-abbrev-end-of-buffer
                    mail-mode-map global-map)))


File: emacs,  Node: Mail Mode,  Next: Distracting NSA,  Prev: Mail Aliases,  Up: Sending Mail

Mail Mode
=========

   The major mode used in the mail buffer is Mail mode, which is much
like Text mode except that various special commands are provided on the
`C-c' prefix.  These commands all have to do specifically with editing
or sending the message.  In addition, Mail mode defines the character
`%' as a word separator; this is helpful for using the word commands to
edit mail addresses.

   Mail mode is normally used in buffers set up automatically by the
`mail' command and related commands.  However, you can also switch to
Mail mode in a file-visiting buffer.  That is a useful thing to do if
you have saved draft message text in a file.

* Menu:

* Mail Sending::        Commands to send the message.
* Header Editing::      Commands to move to header fields and edit them.
* Citing Mail::         Copying all or part of a message you are replying to.
* Mail Mode Misc::      Spell checking, signatures, etc.


File: emacs,  Node: Mail Sending,  Next: Header Editing,  Up: Mail Mode

Mail Sending
------------

   Mail mode has two commands for sending the message you have been
editing:

`C-c C-s'
     Send the message, and leave the mail buffer selected (`mail-send').

`C-c C-c'
     Send the message, and select some other buffer
     (`mail-send-and-exit').

   `C-c C-s' (`mail-send') sends the message and marks the mail buffer
unmodified, but leaves that buffer selected so that you can modify the
message (perhaps with new recipients) and send it again.  `C-c C-c'
(`mail-send-and-exit') sends and then deletes the window or switches to
another buffer.  It puts the mail buffer at the lowest priority for
reselection by default, since you are finished with using it.  This is
the usual way to send the message.

   In a file-visiting buffer, sending the message does not clear the
modified flag, because only saving the file should do that.  As a
result, you don't get a warning if you try to send the same message
twice.

   When you send a message that contains non-ASCII characters, they need
to be encoded with a coding system (*note Coding Systems::).  Usually
the coding system is specified automatically by your chosen language
environment (*note Language Environments::).  You can explicitly specify
the coding system for outgoing mail by setting the variable
`sendmail-coding-system'.

   If the coding system thus determined does not handle the characters
in a particular message, Emacs asks you to select the coding system to
use, showing a list of possible coding systems.


File: emacs,  Node: Header Editing,  Next: Citing Mail,  Prev: Mail Sending,  Up: Mail Mode

Mail Header Editing
-------------------

   Mail mode provides special commands to move to particular header
fields and to complete addresses in headers.

`C-c C-f C-t'
     Move to the `To' header field, creating one if there is none
     (`mail-to').

`C-c C-f C-s'
     Move to the `Subject' header field, creating one if there is none
     (`mail-subject').

`C-c C-f C-c'
     Move to the `CC' header field, creating one if there is none
     (`mail-cc').

`C-c C-f C-b'
     Move to the `BCC' header field, creating one if there is none
     (`mail-bcc').

`C-c C-f C-f'
     Move to the `FCC' header field, creating one if there is none
     (`mail-fcc').

`M-<TAB>'
     Complete a mailing address (`mail-complete').

   There are five commands to move point to particular header fields,
all based on the prefix `C-c C-f' (`C-f' is for "field").  They are
listed in the table above.  If the field in question does not exist,
these commands create one.  We provide special motion commands for these
particular fields because they are the fields users most often want to
edit.

   While editing a header field that contains mailing addresses, such as
`To:', `CC:' and `BCC:', you can complete a mailing address by typing
`M-<TAB>' (`mail-complete').  It inserts the full name corresponding to
the address, if it can determine the full name.  The variable
`mail-complete-style' controls whether to insert the full name, and
what style to use, as in `mail-from-style' (*note Mail Headers::).

   For completion purposes, the valid mailing addresses are taken to be
the local users' names plus your personal mail aliases.  You can specify
additional sources of valid addresses; use the customization buffer to
see the options for this.

   If you type `M-<TAB>' in the body of the message, it invokes
`ispell-complete-word', as in Text mode.


File: emacs,  Node: Citing Mail,  Next: Mail Mode Misc,  Prev: Header Editing,  Up: Mail Mode

Citing Mail
-----------

   Mail mode also has commands for yanking or "citing" all or part of a
message that you are replying to.  These commands are active only when
you started sending a message using an Rmail command.

`C-c C-y'
     Yank the selected message from Rmail (`mail-yank-original').

`C-c C-r'
     Yank the region from the Rmail buffer (`mail-yank-region').

`C-c C-q'
     Fill each paragraph cited from another message
     (`mail-fill-yanked-message').

   When mail sending is invoked from the Rmail mail reader using an
Rmail command, `C-c C-y' can be used inside the mail buffer to insert
the text of the message you are replying to.  Normally it indents each
line of that message three spaces and eliminates most header fields.  A
numeric argument specifies the number of spaces to indent.  An argument
of just `C-u' says not to indent at all and not to eliminate anything.
`C-c C-y' always uses the current message from the Rmail buffer, so you
can insert several old messages by selecting one in Rmail, switching to
`*mail*' and yanking it, then switching back to Rmail to select another.

   You can specify the text for `C-c C-y' to insert at the beginning of
each line: set `mail-yank-prefix' to the desired string.  (A value of
`nil' means to use indentation; this is the default.)  However, `C-u
C-c C-y' never adds anything at the beginning of the inserted lines,
regardless of the value of `mail-yank-prefix'.

   To yank just a part of an incoming message, set the region in Rmail
to the part you want; then go to the `*Mail*' message and type `C-c
C-r' (`mail-yank-region').  Each line that is copied is indented or
prefixed according to `mail-yank-prefix'.

   After using `C-c C-y' or `C-c C-r', you can type `C-c C-q'
(`mail-fill-yanked-message') to fill the paragraphs of the yanked old
message or messages.  One use of `C-c C-q' fills all such paragraphs,
each one individually.  To fill a single paragraph of the quoted
message, use `M-q'.  If filling does not automatically handle the type
of citation prefix you use, try setting the fill prefix explicitly.
*Note Filling::.


File: emacs,  Node: Mail Mode Misc,  Prev: Citing Mail,  Up: Mail Mode

Mail Mode Miscellany
--------------------

`C-c C-t'
     Move to the beginning of the message body text (`mail-text').

`C-c C-w'
     Insert the file `~/.signature' at the end of the message text
     (`mail-signature').

`C-c C-i FILE <RET>'
     Insert the contents of FILE at the end of the outgoing message
     (`mail-attach-file').

`M-x ispell-message'
     Do spelling correction on the message text, but not on citations
     from other messages.

   `C-c C-t' (`mail-text') moves point to just after the header
separator line--that is, to the beginning of the message body text.

   `C-c C-w' (`mail-signature') adds a standard piece of text at the
end of the message to say more about who you are.  The text comes from
the file `~/.signature' in your home directory.  To insert your
signature automatically, set the variable `mail-signature' to `t'; then
starting a mail message automatically inserts the contents of your
`~/.signature' file.  If you want to omit your signature from a
particular message, delete it from the buffer before you send the
message.

   You can also set `mail-signature' to a string; then that string is
inserted automatically as your signature when you start editing a
message to send.  If you set it to some other Lisp expression, the
expression is evaluated each time, and its value (which should be a
string) specifies the signature.

   You can do spelling correction on the message text you have written
with the command `M-x ispell-message'.  If you have yanked an incoming
message into the outgoing draft, this command skips what was yanked,
but it checks the text that you yourself inserted.  (It looks for
indentation or `mail-yank-prefix' to distinguish the cited lines from
your input.)  *Note Spelling::.

   To include a file in the outgoing message, you can use `C-x i', the
usual command to insert a file in the current buffer.  But it is often
more convenient to use a special command, `C-c C-i'
(`mail-attach-file').  This command inserts the file contents at the
end of the buffer, after your signature if any, with a delimiter line
that includes the file name.

   Turning on Mail mode (which `C-x m' does automatically) runs the
normal hooks `text-mode-hook' and `mail-mode-hook'.  Initializing a new
outgoing message runs the normal hook `mail-setup-hook'; if you want to
add special fields to your mail header or make other changes to the
appearance of the mail buffer, use that hook.  *Note Hooks::.

   The main difference between these hooks is just when they are
invoked.  Whenever you type `M-x mail', `mail-mode-hook' runs as soon
as the `*mail*' buffer is created.  Then the `mail-setup' function puts
in the default contents of the buffer.  After these default contents
are inserted, `mail-setup-hook' runs.


File: emacs,  Node: Distracting NSA,  Next: Mail Methods,  Prev: Mail Mode,  Up: Sending Mail

Distracting the NSA
===================

   `M-x spook' adds a line of randomly chosen keywords to an outgoing
mail message.  The keywords are chosen from a list of words that suggest
you are discussing something subversive.

   The idea behind this feature is the suspicion that the NSA snoops on
all electronic mail messages that contain keywords suggesting they might
find them interesting.  (The NSA says they don't, but that's what they
_would_ say.)  The idea is that if lots of people add suspicious words
to their messages, the NSA will get so busy with spurious input that
they will have to give up reading it all.

   Here's how to insert spook keywords automatically whenever you start
entering an outgoing message:

     (add-hook 'mail-setup-hook 'spook)

   Whether or not this confuses the NSA, it at least amuses people.


File: emacs,  Node: Mail Methods,  Prev: Distracting NSA,  Up: Sending Mail

Mail-Composition Methods
========================

   This chapter describes the usual Emacs mode for editing and sending
mail--Mail mode.  Emacs has alternative facilities for editing and
sending mail, including MH-E and Message mode, not documented in this
manual.  You can choose any of them as your preferred method.  The
commands `C-x m', `C-x 4 m' and `C-x 5 m' use whichever agent you have
specified.  So do various other Emacs commands and facilities that send
mail.

   To specify your mail-composition method, set the variable
`mail-user-agent'.  Currently legitimate values include
`sendmail-user-agent', `mh-e-user-agent', and `message-user-agent'.

   If you select a different mail-composition method, the information in
this chapter about the `*mail*' buffer and Mail mode does not apply;
other methods may use completely different commands with a different
format in a differently named buffer.


File: emacs,  Node: Rmail,  Next: Dired,  Prev: Sending Mail,  Up: Top

Reading Mail with Rmail
***********************

   Rmail is an Emacs subsystem for reading and disposing of mail that
you receive.  Rmail stores mail messages in files called Rmail files.
Reading the message in an Rmail file is done in a special major mode,
Rmail mode, which redefines most letters to run commands for managing
mail.  The command `rmail-mode' is used to switch into Rmail mode, and
it runs the hook `rmail-mode-hook' as usual, but don't run this command
by hand; it can't do a reasonable job unless the buffer is visiting a
proper Rmail file.

* Menu:

* Basic: Rmail Basics.       Basic concepts of Rmail, and simple use.
* Scroll: Rmail Scrolling.   Scrolling through a message.
* Motion: Rmail Motion.      Moving to another message.
* Deletion: Rmail Deletion.  Deleting and expunging messages.
* Inbox: Rmail Inbox.        How mail gets into the Rmail file.
* Files: Rmail Files.        Using multiple Rmail files.
* Output: Rmail Output.	     Copying message out to files.
* Labels: Rmail Labels.      Classifying messages by labeling them.
* Attrs: Rmail Attributes.   Certain standard labels, called attributes.
* Reply: Rmail Reply.        Sending replies to messages you are viewing.
* Summary: Rmail Summary.    Summaries show brief info on many messages.
* Sort: Rmail Sorting.       Sorting messages in Rmail.
* Display: Rmail Display.    How Rmail displays a message; customization.
* Editing: Rmail Editing.    Editing message text and headers in Rmail.
* Digest: Rmail Digest.      Extracting the messages from a digest message.
* Out of Rmail::	     Converting an Rmail file to mailbox format.
* Rot13: Rmail Rot13.	     Reading messages encoded in the rot13 code.
* Movemail: Movemail.        More details of fetching new mail.


File: emacs,  Node: Rmail Basics,  Next: Rmail Scrolling,  Up: Rmail

Basic Concepts of Rmail
=======================

   Using Rmail in the simplest fashion, you have one Rmail file
`~/RMAIL' in which all of your mail is saved.  It is called your
"primary Rmail file".  The command `M-x rmail' reads your primary Rmail
file, merges new mail in from your inboxes, displays the first message
you haven't read yet, and lets you begin reading.  The variable
`rmail-file-name' specifies the name of the primary Rmail file.

   Rmail uses narrowing to hide all but one message in the Rmail file.
The message that is shown is called the "current message".  Rmail
mode's special commands can do such things as delete the current
message, copy it into another file, send a reply, or move to another
message.  You can also create multiple Rmail files and use Rmail to move
messages between them.

   Within the Rmail file, messages are normally arranged sequentially in
order of receipt; you can specify other ways to sort them.  Messages are
assigned consecutive integers as their "message numbers".  The number
of the current message is displayed in Rmail's mode line, followed by
the total number of messages in the file.  You can move to a message by
specifying its message number with the `j' key (*note Rmail Motion::).

   Following the usual conventions of Emacs, changes in an Rmail file
become permanent only when the file is saved.  You can save it with `s'
(`rmail-save'), which also expunges deleted messages from the file
first (*note Rmail Deletion::).  To save the file without expunging,
use `C-x C-s'.  Rmail also saves the Rmail file after merging new mail
from an inbox file (*note Rmail Inbox::).

   You can exit Rmail with `q' (`rmail-quit'); this expunges and saves
the Rmail file and then switches to another buffer.  But there is no
need to `exit' formally.  If you switch from Rmail to editing in other
buffers, and never happen to switch back, you have exited.  (The Rmail
command `b', `rmail-bury', does this for you.)  Just make sure to save
the Rmail file eventually (like any other file you have changed).  `C-x
s' is a good enough way to do this (*note Saving::).


File: emacs,  Node: Rmail Scrolling,  Next: Rmail Motion,  Prev: Rmail Basics,  Up: Rmail

Scrolling Within a Message
==========================

   When Rmail displays a message that does not fit on the screen, you
must scroll through it to read the rest.  You could do this with `C-v',
`M-v' and `M-<', but in Rmail scrolling is so frequent that it deserves
to be easier to type.

`<SPC>'
     Scroll forward (`scroll-up').

`<DEL>'
     Scroll backward (`scroll-down').

`.'
     Scroll to start of message (`rmail-beginning-of-message').

   Since the most common thing to do while reading a message is to
scroll through it by screenfuls, Rmail makes <SPC> and <DEL> synonyms of
`C-v' (`scroll-up') and `M-v' (`scroll-down')

   The command `.' (`rmail-beginning-of-message') scrolls back to the
beginning of the selected message.  This is not quite the same as `M-<':
for one thing, it does not set the mark; for another, it resets the
buffer boundaries to the current message if you have changed them.


File: emacs,  Node: Rmail Motion,  Next: Rmail Deletion,  Prev: Rmail Scrolling,  Up: Rmail

Moving Among Messages
=====================

   The most basic thing to do with a message is to read it.  The way to
do this in Rmail is to make the message current.  The usual practice is
to move sequentially through the file, since this is the order of
receipt of messages.  When you enter Rmail, you are positioned at the
first message that you have not yet made current (that is, the first one
that has the `unseen' attribute; *note Rmail Attributes::).  Move
forward to see the other new messages; move backward to reexamine old
messages.

`n'
     Move to the next nondeleted message, skipping any intervening
     deleted messages (`rmail-next-undeleted-message').

`p'
     Move to the previous nondeleted message
     (`rmail-previous-undeleted-message').

`M-n'
     Move to the next message, including deleted messages
     (`rmail-next-message').

`M-p'
     Move to the previous message, including deleted messages
     (`rmail-previous-message').

`j'
     Move to the first message.  With argument N, move to message
     number N (`rmail-show-message').

`>'
     Move to the last message (`rmail-last-message').

`<'
     Move to the first message (`rmail-first-message').

`M-s REGEXP <RET>'
     Move to the next message containing a match for REGEXP
     (`rmail-search').

`- M-s REGEXP <RET>'
     Move to the previous message containing a match for REGEXP.

   `n' and `p' are the usual way of moving among messages in Rmail.
They move through the messages sequentially, but skip over deleted
messages, which is usually what you want to do.  Their command
definitions are named `rmail-next-undeleted-message' and
`rmail-previous-undeleted-message'.  If you do not want to skip deleted
messages--for example, if you want to move to a message to undelete
it--use the variants `M-n' and `M-p' (`rmail-next-message' and
`rmail-previous-message').  A numeric argument to any of these commands
serves as a repeat count.

   In Rmail, you can specify a numeric argument by typing just the
digits.  You don't need to type `C-u' first.

   The `M-s' (`rmail-search') command is Rmail's version of search.
The usual incremental search command `C-s' works in Rmail, but it
searches only within the current message.  The purpose of `M-s' is to
search for another message.  It reads a regular expression (*note
Regexps::) nonincrementally, then searches starting at the beginning of
the following message for a match.  It then selects that message.  If
REGEXP is empty, `M-s' reuses the regexp used the previous time.

   To search backward in the file for another message, give `M-s' a
negative argument.  In Rmail you can do this with `- M-s'.

   It is also possible to search for a message based on labels.  *Note
Rmail Labels::.

   To move to a message specified by absolute message number, use `j'
(`rmail-show-message') with the message number as argument.  With no
argument, `j' selects the first message.  `<' (`rmail-first-message')
also selects the first message.  `>' (`rmail-last-message') selects the
last message.


File: emacs,  Node: Rmail Deletion,  Next: Rmail Inbox,  Prev: Rmail Motion,  Up: Rmail

Deleting Messages
=================

   When you no longer need to keep a message, you can "delete" it.  This
flags it as ignorable, and some Rmail commands pretend it is no longer
present; but it still has its place in the Rmail file, and still has its
message number.

   "Expunging" the Rmail file actually removes the deleted messages.
The remaining messages are renumbered consecutively.  Expunging is the
only action that changes the message number of any message, except for
undigestifying (*note Rmail Digest::).

`d'
     Delete the current message, and move to the next nondeleted message
     (`rmail-delete-forward').

`C-d'
     Delete the current message, and move to the previous nondeleted
     message (`rmail-delete-backward').

`u'
     Undelete the current message, or move back to a deleted message and
     undelete it (`rmail-undelete-previous-message').

`x'
     Expunge the Rmail file (`rmail-expunge').

   There are two Rmail commands for deleting messages.  Both delete the
current message and select another message.  `d'
(`rmail-delete-forward') moves to the following message, skipping
messages already deleted, while `C-d' (`rmail-delete-backward') moves
to the previous nondeleted message.  If there is no nondeleted message
to move to in the specified direction, the message that was just
deleted remains current.  A numeric argument to either command reverses
the direction of motion after deletion.

   Whenever Rmail deletes a message, it invokes the function(s) listed
in `rmail-delete-message-hook'.  When the hook functions are invoked,
the message has been marked deleted, but it is still the current message
in the Rmail buffer.

   To make all the deleted messages finally vanish from the Rmail file,
type `x' (`rmail-expunge').  Until you do this, you can still
"undelete" the deleted messages.  The undeletion command, `u'
(`rmail-undelete-previous-message'), is designed to cancel the effect
of a `d' command in most cases.  It undeletes the current message if
the current message is deleted.  Otherwise it moves backward to
previous messages until a deleted message is found, and undeletes that
message.

   You can usually undo a `d' with a `u' because the `u' moves back to
and undeletes the message that the `d' deleted.  But this does not work
when the `d' skips a few already-deleted messages that follow the
message being deleted; then the `u' command undeletes the last of the
messages that were skipped.  There is no clean way to avoid this
problem.  However, by repeating the `u' command, you can eventually get
back to the message that you intend to undelete.  You can also select a
particular deleted message with the `M-p' command, then type `u' to
undelete it.

   A deleted message has the `deleted' attribute, and as a result
`deleted' appears in the mode line when the current message is deleted.
In fact, deleting or undeleting a message is nothing more than adding
or removing this attribute.  *Note Rmail Attributes::.


File: emacs,  Node: Rmail Inbox,  Next: Rmail Files,  Prev: Rmail Deletion,  Up: Rmail

Rmail Files and Inboxes
=======================

   The operating system places incoming mail for you in a file that we
call your "inbox".  When you start up Rmail, it runs a C program called
`movemail' to copy the new messages from your inbox into your primary
Rmail file, which also contains other messages saved from previous
Rmail sessions.  It is in this file that you actually read the mail
with Rmail.  This operation is called "getting new mail".  You can get
new mail at any time in Rmail by typing `g'.

   The variable `rmail-primary-inbox-list' contains a list of the files
which are inboxes for your primary Rmail file.  If you don't set this
variable explicitly, it is initialized from the `MAIL' environment
variable, or, as a last resort, set to `nil', which means to use the
default inbox.  The default inbox is `/var/mail/USERNAME',
`/usr/spool/mail/USERNAME', or `/usr/mail/USERNAME', depending on your
operating system.

   To see what the default is on your system, use `C-h v
rmail-primary-inbox <RET>'.  You can specify the inbox file(s) for any
Rmail file with the command `set-rmail-inbox-list'; see *Note Rmail
Files::.

   There are two reasons for having separate Rmail files and inboxes.

  1. The inbox file format varies between operating systems and
     according to the other mail software in use.  Only one part of
     Rmail needs to know about the alternatives, and it need only
     understand how to convert all of them to Rmail's own format.

  2. It is very cumbersome to access an inbox file without danger of
     losing mail, because it is necessary to interlock with mail
     delivery.  Moreover, different operating systems use different
     interlocking techniques.  The strategy of moving mail out of the
     inbox once and for all into a separate Rmail file avoids the need
     for interlocking in all the rest of Rmail, since only Rmail
     operates on the Rmail file.

   Rmail was written to use Babyl format as its internal format.  Since
then, we have recognized that the usual inbox format on Unix and GNU
systems is adequate for the job, and we plan to change Rmail to use that
as its internal format.  However, the Rmail file will still be separate
from the inbox file, even on systems where their format is the same.


File: emacs,  Node: Rmail Files,  Next: Rmail Output,  Prev: Rmail Inbox,  Up: Rmail

Multiple Rmail Files
====================

   Rmail operates by default on your "primary Rmail file", which is
named `~/RMAIL' and receives your incoming mail from your system inbox
file.  But you can also have other Rmail files and edit them with
Rmail.  These files can receive mail through their own inboxes, or you
can move messages into them with explicit Rmail commands (*note Rmail
Output::).

`i FILE <RET>'
     Read FILE into Emacs and run Rmail on it (`rmail-input').

`M-x set-rmail-inbox-list <RET> FILES <RET>'
     Specify inbox file names for current Rmail file to get mail from.

`g'
     Merge new mail from current Rmail file's inboxes
     (`rmail-get-new-mail').

`C-u g FILE <RET>'
     Merge new mail from inbox file FILE.

   To run Rmail on a file other than your primary Rmail file, you may
use the `i' (`rmail-input') command in Rmail.  This visits the file in
Rmail mode.  You can use `M-x rmail-input' even when not in Rmail.

   The file you read with `i' should normally be a valid Rmail file.
If it is not, Rmail tries to decompose it into a stream of messages in
various known formats.  If it succeeds, it converts the whole file to an
Rmail file.  If you specify a file name that doesn't exist, `i'
initializes a new buffer for creating a new Rmail file.

   You can also select an Rmail file from a menu.  Choose first the menu
bar Classify item, then from the Classify menu choose the Input Rmail
File item; then choose the Rmail file you want.  The variables
`rmail-secondary-file-directory' and `rmail-secondary-file-regexp'
specify which files to offer in the menu: the first variable says which
directory to find them in; the second says which files in that
directory to offer (all those that match the regular expression).
These variables also apply to choosing a file for output (*note Rmail
Output::).

   Each Rmail file can contain a list of inbox file names; you can
specify this list with `M-x set-rmail-inbox-list <RET> FILES <RET>'.
The argument can contain any number of file names, separated by commas.
It can also be empty, which specifies that this file should have no
inboxes.  Once a list of inboxes is specified, the Rmail file remembers
it permanently until you specify a different list.

   As a special exception, if your primary Rmail file does not specify
any inbox files, it uses your standard system inbox.

   The `g' command (`rmail-get-new-mail') merges mail into the current
Rmail file from its specified inboxes.  If the Rmail file has no
inboxes, `g' does nothing.  The command `M-x rmail' also merges new
mail into your primary Rmail file.

   To merge mail from a file that is not the usual inbox, give the `g'
key a numeric argument, as in `C-u g'.  Then it reads a file name and
merges mail from that file.  The inbox file is not deleted or changed
in any way when `g' with an argument is used.  This is, therefore, a
general way of merging one file of messages into another.


File: emacs,  Node: Rmail Output,  Next: Rmail Labels,  Prev: Rmail Files,  Up: Rmail

Copying Messages Out to Files
=============================

   These commands copy messages from an Rmail file into another file.

`o FILE <RET>'
     Append a copy of the current message to the file FILE, using Rmail
     file format by default (`rmail-output-to-rmail-file').

`C-o FILE <RET>'
     Append a copy of the current message to the file FILE, using
     system inbox file format by default (`rmail-output').

`w FILE <RET>'
     Output just the message body to the file FILE, taking the default
     file name from the message `Subject' header.

   The commands `o' and `C-o' copy the current message into a specified
file.  This file may be an Rmail file or it may be in system inbox
format; the output commands ascertain the file's format and write the
copied message in that format.

   When copying a message to a file in Unix mail file format, these
commands include whichever header fields are currently visible.  Use the
`t' command first, if you wish, to specify which headers to show (and
copy).

   The `o' and `C-o' commands differ in two ways: each has its own
separate default file name, and each specifies a choice of format to
use when the file does not already exist.  The `o' command uses Rmail
format when it creates a new file, while `C-o' uses system inbox format
for a new file.  The default file name for `o' is the file name used
last with `o', and the default file name for `C-o' is the file name
used last with `C-o'.

   If the output file is an Rmail file currently visited in an Emacs
buffer, the output commands copy the message into that buffer.  It is
up to you to save the buffer eventually in its file.

   Sometimes you may receive a message whose body holds the contents of
a file.  You can save the body to a file (excluding the message header)
with the `w' command (`rmail-output-body-to-file').  Often these
messages contain the intended file name in the `Subject' field, so the
`w' command uses the `Subject' field as the default for the output file
name.  However, the file name is read using the minibuffer, so you can
specify a different name if you wish.

   You can also output a message to an Rmail file chosen with a menu.
Choose first the menu bar Classify item, then from the Classify menu
choose the Output Rmail File menu item; then choose the Rmail file you
want.  This outputs the current message to that file, like the `o'
command.  The variables `rmail-secondary-file-directory' and
`rmail-secondary-file-regexp' specify which files to offer in the menu:
the first variable says which directory to find them in; the second
says which files in that directory to offer (all those that match the
regular expression).

   Copying a message gives the original copy of the message the `filed'
attribute, so that `filed' appears in the mode line when such a message
is current.  If you like to keep just a single copy of every mail
message, set the variable `rmail-delete-after-output' to `t'; then the
`o' and `C-o' commands delete the original message after copying it.
(You can undelete the original afterward if you wish.)

   Copying messages into files in system inbox format uses the header
fields that are displayed in Rmail at the time.  Thus, if you use the
`t' command to view the entire header and then copy the message, the
entire header is copied.  *Note Rmail Display::.

   The variable `rmail-output-file-alist' lets you specify intelligent
defaults for the output file, based on the contents of the current
message.  The value should be a list whose elements have this form:

     (REGEXP . NAME-EXP)

If there's a match for REGEXP in the current message, then the default
file name for output is NAME-EXP.  If multiple elements match the
message, the first matching element decides the default file name.  The
subexpression NAME-EXP may be a string constant giving the file name to
use, or more generally it may be any Lisp expression that returns a
file name as a string.  `rmail-output-file-alist' applies to both `o'
and `C-o'.


File: emacs,  Node: Rmail Labels,  Next: Rmail Attributes,  Prev: Rmail Output,  Up: Rmail

Labels
======

   Each message can have various "labels" assigned to it as a means of
classification.  Each label has a name; different names are different
labels.  Any given label is either present or absent on a particular
message.  A few label names have standard meanings and are given to
messages automatically by Rmail when appropriate; these special labels
are called "attributes".  (*Note Rmail Attributes::.)  All other labels
are assigned only by users.

`a LABEL <RET>'
     Assign the label LABEL to the current message (`rmail-add-label').

`k LABEL <RET>'
     Remove the label LABEL from the current message
     (`rmail-kill-label').

`C-M-n LABELS <RET>'
     Move to the next message that has one of the labels LABELS
     (`rmail-next-labeled-message').

`C-M-p LABELS <RET>'
     Move to the previous message that has one of the labels LABELS
     (`rmail-previous-labeled-message').

`C-M-l LABELS <RET>'
     Make a summary of all messages containing any of the labels LABELS
     (`rmail-summary-by-labels').

   The `a' (`rmail-add-label') and `k' (`rmail-kill-label') commands
allow you to assign or remove any label on the current message.  If the
LABEL argument is empty, it means to assign or remove the same label
most recently assigned or removed.

   Once you have given messages labels to classify them as you wish,
there are two ways to use the labels: in moving and in summaries.

   The command `C-M-n LABELS <RET>' (`rmail-next-labeled-message')
moves to the next message that has one of the labels LABELS.  The
argument LABELS specifies one or more label names, separated by commas.
`C-M-p' (`rmail-previous-labeled-message') is similar, but moves
backwards to previous messages.  A numeric argument to either command
serves as a repeat count.

   The command `C-M-l LABELS <RET>' (`rmail-summary-by-labels')
displays a summary containing only the messages that have at least one
of a specified set of labels.  The argument LABELS is one or more label
names, separated by commas.  *Note Rmail Summary::, for information on
summaries.

   If the LABELS argument to `C-M-n', `C-M-p' or `C-M-l' is empty, it
means to use the last set of labels specified for any of these commands.


File: emacs,  Node: Rmail Attributes,  Next: Rmail Reply,  Prev: Rmail Labels,  Up: Rmail

Rmail Attributes
================

   Some labels such as `deleted' and `filed' have built-in meanings and
are assigned to or removed from messages automatically at appropriate
times; these labels are called "attributes".  Here is a list of Rmail
attributes:

`unseen'
     Means the message has never been current.  Assigned to messages
     when they come from an inbox file, and removed when a message is
     made current.  When you start Rmail, it initially shows the first
     message that has this attribute.

`deleted'
     Means the message is deleted.  Assigned by deletion commands and
     removed by undeletion commands (*note Rmail Deletion::).

`filed'
     Means the message has been copied to some other file.  Assigned by
     the file output commands (*note Rmail Files::).

`answered'
     Means you have mailed an answer to the message.  Assigned by the
     `r' command (`rmail-reply').  *Note Rmail Reply::.

`forwarded'
     Means you have forwarded the message.  Assigned by the `f' command
     (`rmail-forward').  *Note Rmail Reply::.

`edited'
     Means you have edited the text of the message within Rmail.  *Note
     Rmail Editing::.

`resent'
     Means you have resent the message.  Assigned by the command `M-x
     rmail-resend'.  *Note Rmail Reply::.

   All other labels are assigned or removed only by the user, and have
no standard meaning.

