[gnus] / texi / gnus.texi

\input texinfo                  @c -*-texinfo-*-
@comment %**start of header (This is for running Texinfo on a region.)
@setfilename gnus.info
@settitle (ding) Gnus 0.84 Manual
@synindex fn cp
@synindex vr cp
@synindex pg cp
@iftex
@finalout
@end iftex
@setchapternewpage odd
@c      @smallbook
@comment %**end of header (This is for running Texinfo on a region.)
@tex
\overfullrule=0pt
%\global\baselineskip 30pt      % For printing in double spaces
@end tex

@ifinfo

This file documents Gnus, the GNU Emacs newsreader.

Copyright (C) 1995 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.

@ignore
Permission is granted to process this file through Tex and print the
results, provided the printed document carries copying permission
notice identical to this one except for the removal of this paragraph
(this paragraph not being relevant to the printed manual).

@end ignore
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided also 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.
@end ifinfo

@iftex

@titlepage
@title (ding) Gnus Manual

@author by Lars Magne Ingebrigtsen
@page
@vskip 0pt plus 1filll
Copyright @copyright{} 1995 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 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.

Cover art by Etienne Suvasa.
@end titlepage
@page

@end iftex

@node Top
@top The Gnus Newsreader

You can read news (and mail) from within Emacs by using Gnus.  The news
can be gotten by any nefarious means you can think of - @sc{nntp}, local
spool or your mbox file.  All at the same time, if you want to push your
luck.

@menu
* History::                 How Gnus got where it is today.
* Terminology::             We use really difficult, like, words here.
* Starting Up::             Finding news can be a pain.
* The Group Buffer::        Selecting, subscribing and killing groups.
* The Summary Buffer::      Reading, saving and posting articles.
* The Article Buffer::      Displaying and handling articles.
* The Server Buffer::       Making and editing virtual servers.
* Various::                 General purpose settings.
* Customization::           Tailoring Gnus to your needs.
* Troubleshooting::         What you might try if things do not work.
* The End::                 Farewell, and goodbye.
* Index::                   Variable, function and concept index.
* Key Index::               Key Index.
@end menu

@node History
@chapter History

@cindex history
@sc{gnus} was written by Masanobu UMEDA.  When autumn crept up in '94,
Lars Magne Ingebrigtsen grew bored and decided to rewrite Gnus.

The recommended pronunciation of the name this program is "ding
guh-noose", with "ding" being half-sung in a loud, high-pitched voice,
and "guh-noose" being grumbled and a disaffected fashion.  Any
irritation and/or damage this name may cause you is not the
responsibility of the author, even though you might like to strangle him
for the stupid idea.

If you want to investigate the person responsible for this outrage, you
can point your (feh!) web browser to
@file{http://www.ifi.uio.no/~larsi/}.  This is also the primary
distribution point for the new and spiffy versions of Gnus, also know as
The Site That Destroys Newsrcs And Drives People Mad.

@dfn{(ding)}, is, of course, short for @dfn{ding is not Gnus}, which is
a total and utter lie, but who cares? (Besides, the "Gnus" in this
abbreviation should probably be pronounced "news" as UMEDA intended,
which makes it a more appropriate name, don't you think?)

@menu
* Why?::                What's the point of Gnus?
* Compatibility::       Just how compatible is (ding) Gnus with @sc{gnus}?
* Contributors::        Oodles of people.  
* New Features::        A short description of all the new stuff in Gnus.
* Newest Features::     Features so new that they haven't been written yet.
@end menu

@node Why?
@section Why?

What's the point of Gnus?  

I want to provide a "rad", "happening", "way cool" and "hep" newsreader,
that lets you do anything you can think of.  That was my original
motivation, but while working on Gnus, it has become clear to me that
this generation of newsreaders really belong in the stone age.
Newsreaders haven't developed much since the infancy of the net.  If the
volume continues to rise with the current rate of increase, all current
newsreaders will be pretty much useless.  How do you deal with
newsgroups that have hundreds (or thousands) of new articles each day? 

(ding) Gnus offer no real solutions to these questions, but I would very
much like to see Gnus being used as a testing ground for new methods of
reading and fetching news.  Expanding on Umeda-san's wise decision to
separate the newsreader from the backends, (ding) Gnus now offers a
simple interface for anybody who wants to write new backends for
fetching mail and news from different sources.  I have added hooks for
customizations everywhere I can imagine useful.  By doing so, I'm
inviting every one of you to explore and invent new ways of reading
news. 

May Gnus never be complete. @kbd{C-u 100 M-x hail-emacs}. 

@node Compatibility
@section Compatibility

@cindex compatibility
(ding) Gnus was designed to be fully compatible with @sc{gnus}.  Almost
all key bindings have been kept.  More key bindings have been added, of
course, but only in one or two obscure cases have old bindings been
changed.

Our motto is:
@quotation
@cartouche
@center In a cloud bones of steel.
@end cartouche
@end quotation

All commands have kept their names.  Some internal functions have changed
their names.

The @code{gnus-uu} package has changed drastically. @xref{Decoding
Articles}. 

One major compatibility question if the presence of several summary
buffers.  All variables that are relevant while reading a group are
buffer-local to the summary buffer they belong in.  Although most
important variables have their values copied into their global
counterparts whenever a command is executed in the summary buffer, this
change might lead to incorrect values being used unless you are careful.

All code that relies on knowledge of @sc{gnus} internals will probably
fail.  To take two examples: Sorting @code{gnus-newsrc-assoc} (or
changing it in any way, as a matter of fact) is strictly verboten.  Gnus
maintains a hash table that points to the entries in this assoc (which
speeds up many functions), and changing the assoc directly will lead to
peculiar results.

@cindex hilit19
@cindex highlighting
Old hilit19 code does not work at all.  In fact, you should probably
remove all hilit code from all Gnus hooks
(@code{gnus-group-prepare-hook}, @code{gnus-summary-prepare-hook} and
@code{gnus-summary-article-hook}).  (Well, at the very least the first
two.)  Gnus provides various integrated functions for highlighting.
These are faster and more accurate.  To make life easier for everybody,
Gnus will by default remove all hilit calls from all hilit hooks.
Uncleanliness!  Away!

Packages like @code{expire-kill} will no longer work.  As a matter of
fact, you should probably remove all old @sc{gnus} packages (and other
code) when you start using (ding) Gnus.  More likely than not, (ding)
Gnus already does what you have written code to make @sc{gnus} do.
(Snicker.)

Even though old methods of doing things are still supported, only the
new methods are documented in this manual.  If you detect a new method of
doing something while reading this manual, that does not mean you have
to stop doing it the old way.

(ding) Gnus understands all @sc{gnus} startup files.

@kindex M-x gnus-bug
Overall, a casual user who hasn't written much code that depends on
@sc{gnus} internals should suffer no problems.  If problems occur,
please let me know (@kbd{M-x gnus-bug}).

Problems specific to GNU XEmacs can be reported to popineau@@ese-metz.fr
(Fabrice Popineau).  I will just forward any such questions to him,
anyway, so you might have to wait longer if you mail XEmacs questions to
me.

@node Contributors
@section Contributors
@cindex contributors

The new Gnus version couldn't have been done without the help of all the
people on the (ding) mailing list.  Every day for months I have gotten
tens of nice bug reports from them, filling me with joy, every single
one of them.  Smooches.  The people on the list have been tried beyond
endurance, what with my "oh, that's a neat idea <type type>, yup, I'll
release it right away <ship off> no wait, that doesn't work at all <type
type>, yup, I'll ship that one off right away <ship off> no, wait, that
absolutely does not work" policy for releases.  Microsoft - bah.  I'm
@emph{much} worse.

I would like to take this opportunity to thank the Academy for...  oops,
wrong show.

@itemize @bullet
@item
Of course, GNUS was written by Masanobu UMEDA.
@item 
Many excellent functions, especially dealing with scoring and
highlighting (as well as the soon-to-come @sc{soup} support) was written
by Per Abrahamsen.
@item
Innumerable bug fixes were written by Sudish Joseph.
@item
I stole some pieces from the XGnus distribution by Felix Lee and JWZ.
@item 
nnfolder has been much enhanced by Scott Byer.
@item
The orphan scoring was written by Peter Mutsaers.
@item 
GNU XEmacs support has been added by Fabrice Popineau. 
@item 
Various bits and pieces, especially dealing with .newsrc files, was
suggested and added by Hallvard B Furuseth.
@item 
Brian Edmonds has written @code{gnus-bbdb}, as well as other bits and
pieces. 
@item 
Ricardo Nassif did the proof-reading.
@item
Kevin Davidson came up with the name @dfn{ding}, so blame him.
@item 
Stainless Steel Rat, Jack Vinson, Daniel Quinlan, Ilja Weis, Frank D.
Cringle, Geoffrey T. Dairiki and Andrew Eskilsson have all contributed
code and suggestions.
@end itemize


@node New Features
@section New Features
@cindex new features

The look of all buffers can be changed by setting format-like variables.
 
Local spool and several @sc{nntp} servers can be used at once.  Virtual
groups and private mail groups are featured.

Gnus can use various strategies for gathering threads that have lost
their roots (thereby gathering loose sub-threads in one thread) or it
can go back and retrieve enough headers to build a complete thread.

Killed groups can be displayed in the group buffer, and you can read
them as well.

Gnus can do partial group updates - you do not have to retrieve the
entire active file just to check for new articles in a few groups.

Gnus implements a sliding scale of subscribedness to groups.

The approach to killing has been changed.  Instead of simply killing or
not, you can score articles for easier reading.

@node Newest Features
@section Newest Features
@cindex todo

Also known as the @dfn{todo list}.  Sure to be implemented before the
next millennium.

@itemize @bullet
@item
Native @sc{mime} support is something that should be done.  I was hoping
I could steal code from @code{Mew}, the @sc{mime} mail reader for Emacs,
but I'm not quite sure what the status of that project is.  (ding) might
support @sc{mime} quite soon, and it might not.
@item
When the user references the parent of an article, some sort of
re-threading should be done to build a proper tree.  The same goes for
article expunging.  However, as it stands, it's not a trivial issue to
re-generate parts of the summary buffer.  Generating the entire buffer
is very easy, but slow.
@end itemize

@node Terminology
@chapter Terminology

@cindex terminology
@table @dfn
@item news
@cindex news
This is what you are supposed to use this thing for - reading news.
News is generally fetched from a nearby @sc{nntp} server, and is
generally publicly available to everybody.  If you post news, the entire
world is likely to read just what you have written, and they'll all
snigger mischievously.  Behind your back.
@item mail
@cindex mail
Everything that's delivered to you personally is mail.  Some news/mail
readers (like Gnus) blur the distinction between mail and news, but
there is a difference.  Mail is private.  News is public.  Mailing is
not posting, and replying is not following up.
@item reply
Send a mail to the person who has written what you are reading.
@item follow up
Post an article to the current newsgroup responding to the article you
are reading.
@item backend
Gnus gets fed articles from a number of backends, both news and mail
backends.  Gnus does not handle the underlying media, so to speak - this
is all done by the backends.
@item native
Gnus will always use one method (and backend) as the @dfn{native}, or
default, way of getting news.
@item foreign
You can also have any number of foreign groups at the same time.  These
are groups that use different backends for getting news.
@item head
@cindex head
The top part of an article, where administration information (etc.) is
put. 
@item body
@cindex body
The rest of an article. Everything that is not in the head is in the
body. 
@item header
@cindex header
A line from the head of an article. 
@item headers
@cindex headers
A collection of such lines, or a collection of heads.  Or even a
collection of @sc{nov} lines.
@item @sc{nov}
@cindex nov
When Gnus enters a group, it asks the backend for the headers for all
the unread articles in the group.  Most servers support the News OverView
format, which is much smaller and much faster to read than the normal
HEAD format. 
@item level
@cindex levels
Each group is subscribed at some @dfn{level} or other (1-9).  The ones
that have a lower level are "more" subscribed than the groups with a
higher level.  In fact, groups on levels 1-5 are considered
@dfn{subscribed}; 6-7 are @dfn{unsubscribed}; 8 are @dfn{zombies}; and 9
are @dfn{killed}.  Commands for listing groups and scanning for new
articles will all use the numeric prefix as @dfn{working level}.
@item killed groups
@cindex killed groups
No information on killed groups is stored or updated, which makes killed
groups much easier to handle than subscribed groups.
@item zombie groups
@cindex zombie groups
Just like killed groups, only slightly less dead.
@item active file
@cindex active file
The news server has to keep track of what articles it carries, and what
groups exist.  All this information in stored in the active file, which
is rather large, as you might surmise.
@end table

@node Starting Up
@chapter Starting Gnus
@cindex starting up

@kindex M-x gnus
If your system administrator has set things up properly, starting Gnus
and reading news is extremely easy - you just type @kbd{M-x gnus}.

If things do not go smoothly at startup, you have to twiddle some
variables. 

@menu
* Finding the News::    Choosing a method for getting news.
* The First Time::      What does Gnus do the first time you start it?
* The Server is Down::  How can I read my mail then?
* New Groups::          What is Gnus supposed to do with new groups?
* Startup Files::       Those pesky startup files - @file{.newsrc}.
* Auto Save::           Recovering from a crash.
* The Active File::     Reading the active file over a slow line Takes Time.
* Startup Variables::   Other variables you might change.
@end menu

@node Finding the News
@section Finding the News

@vindex gnus-select-method
The @code{gnus-select-method} variable controls how Gnus finds news.
This variable should be a list where the first element says @dfn{how}
and the second element says @dfn{where}.  This method is is your native
method.  All groups that are not fetched with this method are foreign
groups.

For instance, if you want to get your daily dosage of news from the
@samp{news.somewhere.edu} @sc{nntp} server, you'd say:

@lisp
(setq gnus-select-method '(nntp "news.somewhere.edu"))
@end lisp

If you want to read directly from the local spool, say:

@lisp
(setq gnus-select-method '(nnspool ""))
@end lisp

If you can use a local spool, you probably should, as it will almost
certainly be much faster.

If this variable is not set, Gnus will take a look at the
@code{NNTPSERVER} environment variable.  If that isn't set either, it
will try to use the machine that is running Emacs as an @sc{nntp}
server.

@vindex gnus-nntp-server
If @code{gnus-nntp-server} is set, this variable will override
@code{gnus-select-method}.  You should therefore set
@code{gnus-nntp-server} to @code{nil}, which is what it is by default.

@vindex gnus-secondary-servers
You can also make Gnus prompt you interactively for the name of an
@sc{nntp} server.  If you give a non-numerical prefix to @code{gnus}
(i.e., @kbd{C-u M-x gnus}), Gnus will let you choose between the servers
in the @code{gnus-secondary-servers} list (if any).  You can also just
type in the name of any server you feel like visiting.

However, if you use one @sc{nntp} server regularly, and are just
interested in a couple of groups from a different server, you would be
better served by using the @code{gnus-group-browse-foreign-server}
command from the group buffer.  It will let you have a look at what
groups are available, and you can subscribe to any of the groups you
want to.  This also makes @file{.newsrc} maintenance much tidier.
@xref{Foreign Groups}.

@vindex gnus-secondary-select-methods
A slightly different approach to foreign groups is to set the
@code{gnus-secondary-select-methods} variable.  The select methods
listed in this variable are in many ways just as native as the
@code{gnus-select-method} server.  They will also be queried for active
files during startup (if that's required), and new newsgroups that
appear on these servers will be subscribed (or not) just as native
groups are.

For instance, if you use the @code{nnmbox} backend to read you mail, you
would typically set this variable to

@lisp
(setq gnus-secondary-select-methods '((nnmbox "")))
@end lisp

@node The First Time
@section The First Time
@cindex first time usage

If no startup files exist, Gnus will try to determine what groups should
be subscribed by default.

@vindex gnus-default-subscribed-newsgroups
If the variable @code{gnus-default-subscribed-newsgroups} is set, Gnus
will subscribe you to just those groups in that list, leaving the rest
killed.  Your system administrator should have set this variable to
something useful.

Since she hasn't, Gnus will just subscribe you to a few randomly picked
groups (i.e., @samp{*.newusers}).  (@dfn{Random} is here defined as
"whatever Lars thinks you should read".)

You'll also be subscribed to the Gnus documentation group, which should
help you with most common problems.  

If @code{gnus-default-subscribed-newsgroups} is @code{t}, Gnus will just
use the normal functions for handling new groups, and not do anything
special.

@node The Server is Down
@section The Server is Down
@cindex server errors

If the default server is down, Gnus will understandably have some
problems starting.  However, if you have some mail groups in addition to
the news groups, you may want to start Gnus anyway.

Gnus, being the trusting sort of program, will ask whether to proceed
without a native select method if that server can't be contacted.  This
will happen whether the server doesn't actually exist (i.e., you have
given the wrong address) or the server has just momentarily taken ill
for some reason or other.  

If Gnus says "nntp server on <your server> can't be opened. Continue?",
you do not want to continue unless you have some foreign groups that you
want to read.  Even if you don't, Gnus will let you continue, but you'll
find it difficult to actually do anything in the group buffer.  But,
hey, that's your problem.  Blllrph!

@node New Groups
@section New Groups
@cindex new groups

@vindex gnus-subscribe-newsgroup-method
What Gnus does when it encounters a new group is determined by the
@code{gnus-subscribe-newsgroup-method} variable.

This variable should contain a function.  Some handy pre-fab values
are:

@table @code
@item gnus-subscribe-randomly
@vindex gnus-subscribe-randomly
Subscribe all new groups randomly.
@item gnus-subscribe-alphabetically
@vindex gnus-subscribe-alphabetically
Subscribe all new groups alphabetically.
@item gnus-subscribe-hierarchically
@vindex gnus-subscribe-hierarchically
Subscribe all new groups hierarchically.
@item gnus-subscribe-interactively
@vindex gnus-subscribe-interactively
Subscribe new groups interactively.  This means that Gnus will ask
you about @strong{all} new groups.
@item gnus-subscribe-zombies
@vindex gnus-subscribe-zombies
Make all new groups zombies.  You can browse the zombies later and
either kill them all off properly, or subscribe to them.  This is the
default.
@end table

@vindex gnus-subscribe-hierarchical-interactive
A closely related variable is
@code{gnus-subscribe-hierarchical-interactive}.  (That's quite a
mouthful.)  If this variable is non-@code{nil}, Gnus will ask you in a
hierarchical fashion whether to subscribe to new groups or not.  Gnus
will ask you for each sub-hierarchy whether you want to descend the
hierarchy or not.

One common way to control which new newsgroups should be subscribed or
ignored is to put an @dfn{options} line at the start of the
@file{.newsrc} file.  Here's an example:

@example
options -n !alt.all !rec.all sci.all
@end example

@vindex gnus-subscribe-options-newsgroup-method
This line obviously belongs to a serious-minded intellectual scientific
person (or she may just be plain old boring), because it says that all
groups that have names beginning with @samp{alt} and @samp{rec} should
be ignored, and all groups with names beginning with @samp{sci} should
be subscribed.  Gnus will not use the normal subscription method for
subscribing these groups.
@code{gnus-subscribe-options-newsgroup-method} is used instead.  This
variable defaults to @code{gnus-subscribe-alphabetically}.

@vindex gnus-options-not-subscribe
@vindex gnus-options-subscribe
If you don't want to mess with your @file{.newsrc} file, you can just
set the two variables @code{gnus-options-subscribe} and
@code{gnus-options-not-subscribe}.  These two variables do exactly the
same as the @file{.newsrc} options -n trick.  Both are regexps, and if
the the new group matches the first, it will be unconditionally
subscribed, and if it matches the latter, it will be ignored.

@vindex gnus-check-new-newsgroups
If you are satisfied that you really never want to see any new groups,
you could set @code{gnus-check-new-newsgroups} to @code{nil}.  This will
also save you some time at startup.  Even if this variable is
@code{nil}, you can always subscribe to the new groups just by pressing
@kbd{U} in the group buffer (@pxref{Group Maintenance}).

Gnus normally determines whether a group is new or not by comparing the
list of groups from the active file(s) with the lists of subscribed and
dead groups.  This isn't a particularly fast method.  If
@code{gnus-check-new-newsgroups} is @code{ask-server}, Gnus will ask the
server for new groups since the last time.  This is both faster &
cheaper.  This also means that you can get rid of the list of killed
groups altogether, so you may set @code{gnus-save-killed-list} to
@code{nil}, which will save time both at startup, at exit, and all over.
Saves disk space, too.  Why isn't this the default, then?
Unfortunately, not all servers support this function.

This variable can also be a list of select methods.  If so, Gnus will
issue an @code{ask-server} command to each of the select methods, and
subscribe them (or not) using the normal methods.  This might be handy
if you are monitoring a few servers for new groups.  A side effect is
that startup will take much longer, so you can meditate while waiting.
Use the mantra "dingnusdingnusdingnus" to achieve permanent happiness.

@node Startup Files
@section Startup Files
@cindex startup files
@cindex .newsrc

Now, you all know about the @file{.newsrc} file.  All subscription
information is traditionally stored in this file.

Things got a bit more complicated with @sc{gnus}.  In addition to
keeping the @file{.newsrc} file updated, it also used a file called
@file{.newsrc.el} for storing all the information that didn't fit into
the @file{.newsrc} file.  (Actually, it duplicated everything in the
@file{.newsrc} file.)  @sc{gnus} would read whichever one of these files
that were the most recently saved, which enabled people to swap between
@sc{gnus} and other newsreaders.

That was kinda silly, so (ding) Gnus went one better: In addition to the
@file{.newsrc} and @file{.newsrc.el} files, (ding) Gnus also has a file
called @file{.newsrc.eld}.  It will read whichever of these files that
are most recent, but it will never write a @file{.newsrc.el} file.

@vindex gnus-save-newsrc-file
You can also turn off writing the @file{.newsrc} file by setting
@code{gnus-save-newsrc-file} to @code{nil}, which means you can delete
the file and save some space, as well as making exit from Gnus faster.
However, this will make it impossible to use other newsreaders than
Gnus.  But hey, who would want to, right?

@vindex gnus-save-killed-list
If @code{gnus-save-killed-list} is @code{nil}, Gnus will not save the
list of killed groups to the startup file.  This will save both time
(when starting and quitting) and space (on disk).  It will also means
that Gnus has no record of what groups are new or old, so the automatic
new groups subscription methods become meaningless.  You should always
set @code{gnus-check-new-newsgroups} to @code{nil} or @code{ask-server}
if you set this variable to @code{nil} (@pxref{New Groups}).

@vindex gnus-startup-file
The @code{gnus-startup-file} variable says where the startup files are.
The default value is @file{~/.newsrc}, with the Gnus (El Dingo) startup
file being whatever that one is with a @samp{.eld} appended.

@vindex gnus-save-newsrc-hook
@code{gnus-save-newsrc-hook} is called before saving the @file{.newsrc}
file.

@node Auto Save
@section Auto Save
@cindex dribble file
@cindex auto-save

Whenever you do something that changes the Gnus data (reading articles,
catching up, killing/subscribing groups), the change is added to a
special @dfn{dribble buffer}.  This buffer is auto-saved the normal
Emacs way.  If your Emacs should crash before you have saved the
@file{.newsrc} files, all changes you have made can be recovered from
this file.

If Gnus detects this file at startup, it will ask the user whether to
read it. The auto save file is deleted whenever the real startup file is
saved.

@vindex gnus-use-dribble-file
If @code{gnus-use-dribble-file} is @code{nil}, Gnus won't create and
maintain a dribble buffer.

@node The Active File
@section The Active File
@cindex active file
@cindex ignored groups

When Gnus starts, or indeed whenever it tries to determine whether new
articles have arrived, it reads the active file.  This is a very large
file that lists all the active groups and articles on the @sc{nntp}
server.

@vindex gnus-ignored-newsgroups
Before examining the active file, Gnus deletes all lines that match the
regexp @code{gnus-ignored-newsgroups}.  This is done primarily to reject
any groups with bogus names, but you can use this variable to make Gnus
ignore hierarchies you aren't ever interested in.  This variable is
@code{nil} by default, and will slow down active file handling somewhat
if you set it to anything else.

@vindex gnus-read-active-file
The active file can be rather Huge, so if you have a slow network, you
can set @code{gnus-read-active-file} to @code{nil} to prevent Gnus from
reading the active file.

Gnus will try to make do by just getting information on the groups
that you actually subscribe to.

Note that if you subscribe to lots and lots of groups, setting this
variable to @code{nil} will probably make Gnus slower, not faster.  At
present, having this variable @code{nil} will slow Gnus down
considerably, unless you read news over a 2400 baud modem.  

This variable can also have the value @code{some}.  Gnus will then
attempt to read active info only on the subscribed groups.  On some
servers this is quite fast (on sparkling, brand new INN servers that
support the @samp{LIST ACTIVE group} command), on others this is not
fast at all.  In any case, @code{some} should be faster than @code{nil},
and is certainly faster than @code{t} over slow lines.

If this variable is @code{nil}, Gnus will as for group info in total
lock-step, which isn't very fast.  If it is @code{some} and you use an
NNTP server, Gnus will pump out commands as fast as it can, and read all
the replies in one swoop.  This will normally result in better
performance, but if the server does not support the aforementioned
@samp{LIST ACTIVE group} command, this isn't very nice to the server. 

In any case, if you use @code{some} or @code{nil}, you should kill all
groups that you aren't interested in.

@node Startup Variables
@section Startup Variables

@table @code
@item gnus-check-bogus-newsgroups
@vindex gnus-check-bogus-newsgroups
If non-@code{nil}, Gnus will check for and delete all bogus groups at
startup.  A @dfn{bogus group} is a group that you have in your
@file{.newsrc} file, but doesn't exist on the news server.  Checking for
bogus groups isn't very quick, so to save time and resources, it's best
to leave this option off, and instead do the checking for bogus groups
once in a while from the group buffer (@pxref{Group Maintenance}).
@item gnus-inhibit-startup-message
@vindex gnus-inhibit-startup-message
If non-@code{nil}, the startup message won't be displayed.  That way,
your boss might not notice that you are reading news instead of doing
your job.
@item gnus-no-groups-message
@vindex gnus-no-groups-message
Message displayed by Gnus when no groups are available.
@end table

@node The Group Buffer
@chapter The Group Buffer
@cindex group buffer

The @dfn{group buffer} lists all (or parts) of the available groups.  It
is the first buffer shown when Gnus starts, and will never be killed as
long as Gnus is active.

@menu
* Group Buffer Format::    Information listed and how you can change it.
* Group Maneuvering::      Commands for moving in the group buffer.
* Selecting a Group::      Actually reading news.
* Group Subscribing::      Unsubscribing, killing, subscribing.
* Group Levels::           Levels? What are those, then?
* Marking Groups::         You can mark groups for later processing.
* Foreign Groups::         How to create foreign groups.
* Group Parameters::       Each group may have different parameters set.
* Listing Groups::         Gnus can list various subsets of the groups.
* Group Maintenance::      Maintaining a tidy @file{.newsrc} file.
* Browse Foreign Server::  You can browse a server.  See what if has to offer.
* Exiting Gnus::           Stop reading news and get some work done.
* Misc Group Stuff::       Other stuff that you can to do.
@end menu

@node Group Buffer Format
@section Group Buffer Format
@cindex group buffer format

The default format of the group buffer is nice and dull, but you can
make it as exciting and ugly as you feel like.

Here's a couple of example group lines:

@example
     25: news.announce.newusers
 *    0: alt.fan.andrea-dworkin
@end example

Quite simple, huh?

You can see that there are 25 unread articles in
@samp{news.announce.newusers}.  There are no unread articles, but some
ticked articles, in @samp{alt.fan.andrea-dworkin} (see that little
asterisk at the beginning of the line?)

@vindex gnus-group-line-format
You can fuck that up to your heart's delight by fiddling with the
@code{gnus-group-line-format} variable.  This variable works along the
lines of a @code{format} specification, which is pretty much the same as
a @code{printf} specifications, for those of you who use (feh!) C.

In addition to the normal "padding" specs that @code{format} supports
(eg. @samp{%7d}), specifications like @samp{%7,12s} are allowed.  A spec
of this type means that the field will be at least 7 characters long,
and never more that 12 characters long.

The default value that produced those lines above is 
@samp{"%M%S%5y: %(%g%)\n"}.

There should always be a colon on the line; the cursor always moves to
the colon after performing an operation.  Nothing else is required - not
even the group name.  All displayed text is just window dressing, and is
never examined by Gnus.  Gnus stores all real information it needs using
text properties.

(Note that if you make a really strange, wonderful, spreadsheet-like
layout, everybody will believe you are hard at work with the accounting
instead of wasting time reading news.)

Here's a list of all available format characters:

@table @samp
@item M    
Only marked articles.
@item S
Whether the group is subscribed.
@item L    
Level of subscribedness.
@item N
Number of unread articles.
@item I
Number of dormant articles.
@item T
Number of ticked articles.
@item R
Number of read articles.
@item t
Total number of articles.
@item y
Number of unread, unticked, non-dormant articles.
@item i
Number of ticked and dormant articles.
@item g
Full group name.
@item G
Group name.
@item D
Newsgroup description.
@item o
Moderated.
@item O
Moderated.
@item s
Select method.
@item n
Select from where.
@item z
A string that looks like @samp{<%s:%n>} if a foreign select method is
used.
@item u
User defined specifier.  The next character in the format string should
be a letter.  @sc{gnus} will call the function
@code{gnus-user-format-function-}@samp{X}, where @samp{X} is the letter
following @samp{%u}.  The function will be passed the current headers as
argument.  The function should return a string, which will be inserted
into the buffer just like information from any other specifier.
@end table

@cindex *
All the "number-of" specs will be filled with an asterisk (@samp{*}) if
no info is available - for instance, if it is a non-activated foreign
group, or a bogus (or semi-bogus) native group.

@vindex gnus-group-mode-line-format
The mode line can be changed by setting
(@code{gnus-group-mode-line-format}).  It doesn't understand that many
format specifiers:

@table @samp
@item S
Default news server.
@item M
Default select method.
@end table

@node Group Maneuvering
@section Group Maneuvering
@cindex group movement

All movement commands understand the numeric prefix and will behave as
expected, hopefully. 

@table @kbd
@item n
@kindex n (Group)
@findex gnus-group-next-unread-group
Go to the next group that has unread articles
(@code{gnus-group-next-unread-group}).
@item p
@itemx DEL
@kindex DEL (Group)
@kindex p (Group)
@findex gnus-group-prev-unread-group
Go to the previous group group that has unread articles
(@code{gnus-group-prev-unread-group}).
@item N
@kindex N (Group)
@findex gnus-group-next-group
Go to the next group (@code{gnus-group-next-group}).
@item P
@kindex P (Group)
@findex gnus-group-prev-group
Go to the previous group (@code{gnus-group-prev-group}).
@item M-p
@kindex M-p (Group)
@findex gnus-group-next-unread-group-same-level
Go to the next unread group on the same level (or lower)
(@code{gnus-group-next-unread-group-same-level}). 
@item M-n
@kindex M-n (Group)
@findex gnus-group-prev-unread-group-same-level
Go to the previous unread group on the same level (or lower)
(@code{gnus-group-prev-unread-group-same-level}). 
@end table

Three commands for jumping to groups:

@table @kbd
@item j
@kindex j (Group)
@findex gnus-group-jump-to-group
Jump to a group (and make it visible if it isn't already)
(@code{gnus-group-jump-to-group}).  Killed groups can be jumped to, just
like living groups.
@item ,
@kindex , (Group)
@findex gnus-group-best-unread-group
Jump to the unread group with the lowest level
(@code{gnus-group-best-unread-group}). 
@item .
@kindex . (Group)
@findex gnus-group-first-unread-group
Jump to the first group with unread articles
(@code{gnus-group-first-unread-group}).  
@end table

@vindex gnus-group-goto-unread
If @code{gnus-group-goto-unread} is @code{nil}, all the movement
commands will move to the next group, not the next unread group.  Even
the commands that say they move to the next unread group. 

@node Selecting a Group
@section Selecting a Group
@cindex group selection

@table @kbd
@item SPACE
@kindex SPACE (Group)
@findex gnus-group-read-group
Select the current group, switch to the summary buffer and display the
first unread article (@code{gnus-group-read-group}).  If there are no
unread articles in the group, or if you give a non-numerical prefix to
this command, Gnus will offer to fetch all the old articles in this
group from the server.  If you give a numerical prefix @var{N}, Gnus
will fetch @var{N} number of articles.  If @var{N} is positive, fetch
the @var{N} newest articles, if @var{N} is negative, fetch the
@var{abs(N)} oldest articles.
@item RET
@kindex RET (Group)
@findex gnus-group-select-group
Select the current group and switch to the summary buffer
(@code{gnus-group-select-group}).  Takes the same arguments as
@code{gnus-group-read-group} - the only difference is that this command
does not display the first unread article automatically upon group
entry. 
@item c
@kindex c (Group)
@findex gnus-group-catchup-current
Mark all unticked articles in this group as read
(@code{gnus-group-catchup-current}). 
@item C
@kindex C (Group)
@findex gnus-group-catchup-current-all
Mark all articles in this group, even the ticked ones, as read
(@code{gnus-group-catchup-current-all}). 
@end table

@vindex gnus-large-newsgroup
The @code{gnus-large-newsgroup} variable says what Gnus should consider
to be a big group.  If the group has more unread articles than this,
Gnus will query the user before entering the group.  The user can then
specify how many articles should be fetched from the server.  If the
user specifies a negative number (@samp{-n}), the @samp{n} oldest
articles will be fetched.  If it is positive, the @samp{n} articles that
have arrived most recently will be fetched.

@vindex gnus-select-group-hook
@vindex gnus-auto-select-newsgroup
If @code{gnus-auto-select-newsgroup} is non-@code{nil}, the first unread
article in the group will be displayed when you enter the group.  If you
want to prevent automatic selection in some group (say, in a binary
group with Huge articles) you can set this variable to @code{nil} in
@code{gnus-select-group-hook}, which is called when a group is selected.

@findex gnus-thread-sort-by-total-score
@findex gnus-thread-sort-by-date
@findex gnus-thread-sort-by-score
@findex gnus-thread-sort-by-subject
@findex gnus-thread-sort-by-author
@findex gnus-thread-sort-by-number
@vindex gnus-thread-sort-functions
If you are using a threaded summary display, you can sort the threads by
setting @code{gnus-thread-sort-functions}, which is a list of functions.
By default, sorting is done on article numbers.  Ready-made sorting
functions include @code{gnus-thread-sort-by-number},
@code{gnus-thread-sort-by-author}, @code{gnus-thread-sort-by-subject},
@code{gnus-thread-sort-by-date}, @code{gnus-thread-sort-by-score},
@code{gnus-thread-sort-by-total-score}.

Each function takes two threads and return non-@code{nil} if the first
thread should be sorted before the other.  If you use more than one
function, the primary sort key should be the last function in the list.

If you would like to sort by score, then by subject, and finally by
date, you could do something like:

@lisp
(setq gnus-thread-sort-functions 
      '(gnus-thread-sort-by-date
        gnus-thread-sort-by-subject
        gnus-thread-sort-by-score))
@end lisp

@vindex gnus-thread-score-function
The function in the @code{gnus-thread-score-function} variable (default
@code{+}) is used for calculating the total score of a thread.  Useful
functions might be @code{max}, @code{min}, or squared means, or whatever
tickles you fancy.

@node Group Subscribing
@section Group Subscribing
@cindex subscribing

@table @kbd
@item S t
@itemx u
@kindex S t (Group)
@kindex u (Group)
@findex gnus-group-unsubscribe-current-group
Toggle subscription to the current group
(@code{gnus-group-unsubscribe-current-group}).  
@item S s
@itemx U
@kindex S s (Group)
@kindex U (Group)
@findex gnus-group-unsubscribe-group
Prompt for a group to subscribe, and then subscribe it.  If it was
subscribed already, unsubscribe it instead
(@code{gnus-group-unsubscribe-group}).
@item S k
@itemx C-k
@kindex S k (Group)
@kindex C-k (Group)
@findex gnus-group-kill-group
Kill the current group (@code{gnus-group-kill-group}).
@item S y
@itemx C-y
@kindex S y (Group)
@kindex C-y (Group)
@findex gnus-group-yank-group
Yank the last killed group (@code{gnus-group-yank-group}).
@item S w
@itemx C-w
@kindex S w (Group)
@kindex C-w (Group)
@findex gnus-group-kill-region
Kill all groups in the region (@code{gnus-group-kill-region}). 
@item S z
@kindex S z (Group)
@findex gnus-group-kill-all-zombies
Kill all zombie groups (@code{gnus-group-kill-all-zombies}).
@end table

@node Group Levels
@section Group Levels
@cindex group level

All groups have a level of @dfn{subscribedness}.  For instance, if a
group is on level 2, it is more subscribed than a group on level 5.  You
can ask Gnus to just list groups on a given level or lower
(@pxref{Listing Groups}), or to just check for new articles in groups on
a given level or lower (@pxref{Misc Group Stuff}).

@table @kbd
@item S l
@kindex S l (Group)
@findex gnus-group-set-current-level
Set the level of the current group.  If a numeric prefix is given, the
next @var{n} groups will have their levels set.  The user will be
prompted for a level.
@end table

@vindex gnus-level-killed
@vindex gnus-level-zombie
@vindex gnus-level-unsubscribed
@vindex gnus-level-subscribed
Gnus considers groups on between levels 1 and
@code{gnus-level-subscribed} (inclusive) to be subscribed,
@code{gnus-level-subscribed} (exclusive) and
@code{gnus-level-unsubscribed} (inclusive) to be unsubscribed,
@code{gnus-level-zombie} to be zombies (walking dead) and
@code{gnus-level-killed} to be killed, completely dead.  Gnus treats
subscribed and unsubscribed groups exactly the same, but zombie and
killed groups have no information on what articles you have read, etc,
stored.  This distinction between dead and living groups isn't done
because it is nice or clever, it is done purely for reasons of
efficiency. 

It is recommended that you keep all your mail groups (if any) on quite
low levels (eg. 1 or 2).

If you want to play with the level variables, you should show some care.
Set them once, and don't touch them ever again.  

@vindex gnus-level-default-unsubscribed
@vindex gnus-level-default-subscribed
Two closely related variables are @code{gnus-level-default-subscribed}
and @code{gnus-level-default-unsubscribed}, which are the levels that new
groups will be put on if they are (un)subscribed.  These two variables
should, of course, be inside the relevant legal ranges.

@vindex gnus-keep-same-level
If @code{gnus-keep-same-level} is non-@code{nil}, some movement commands
will only move to groups that are of the same level (or lower).  In
particular, going from the last article in one group to the next group
will go to the next group of the same level (or lower).  This might be
handy if you want to read the most important groups before you read the
rest.

@vindex gnus-group-default-list-level
All groups with a level less than or equal to
@code{gnus-group-default-list-level} will be listed in the group buffer
by default.

@vindex gnus-group-use-permament-levels
If @code{gnus-group-use-permament-levels} is non-@code{nil}, once you
give a level prefix to @kbd{g} or @kbd{l}, all subsequent commands will
use this level as the "work" level.

@node Marking Groups
@section Marking Groups
@cindex marking groups

If you want to perform some action on several groups, and they appear
subsequently in the group buffer, you would normally just give a
numerical prefix to the command.  Most group commands will then do your
bidding on those groups.

However, if the groups are not in sequential order, you can still
perform an action on several groups.  You simply mark the groups first,
and then execute the command.  

@table @kbd
@item #
@kindex # (Group)
@item G m
@kindex G m (Group)
@findex gnus-group-mark-group
Set the mark on the current group (@code{gnus-group-mark-group}). 
@item M-#
@kindex M-# (Group)
@item G u
@kindex G u (Group)
@findex gnus-group-unmark-group
Remove the mark from the current group
(@code{gnus-group-unmark-group}). 
@item G w
@kindex G w (Group)
@findex gnus-group-mark-region
Mark all groups between point and mark (@code{gnus-group-mark-region}). 
@end table

@node Foreign Groups
@section Foreign Groups
@cindex foreign groups

A @dfn{foreign group} is a group that is not read by the usual (or
default) means.  It could be, for instance, a group from a different
@sc{nntp} server, it could be a virtual group, or it could be your own
personal mail group.

A foreign group (or any group, really) is specified by a @dfn{name} and
a @dfn{select method}.  To take the latter first, a select method is a
list where the first element says what backend to use (eg. @code{nntp},
@code{nnspool}, @code{nnml}) and the second element is the @dfn{server
name}.  There may be additional elements in the select method, where the
value may have special meaning for the backend in question.

One could say that a select method defines a @dfn{virtual server} - so
we do just that (@pxref{The Server Buffer}).

The @dfn{name} of the group is the name the backend will recognize the
group as.

For instance, the group @samp{soc.motss} on the @sc{nntp} server
@samp{some.where.edu} will have the name @samp{soc.motss} and select
method @code{(nntp "some.where.edu")}.  Gnus will call this group, in
all circumstances, @samp{nntp+some.where.edu:soc.motss}, even though the
nntp backend just knows this group as @samp{soc.motss}.

Here are some commands for making and editing general foreign groups,
and some commands to ease the creation of some special-purpose groups:

@table @kbd
@item G m
@kindex G m (Group)
@findex gnus-group-make-group
Make a new group (@code{gnus-group-make-group}).  Gnus will prompt you
for a name, a method and possibly an @dfn{address}.  For an easier way
to subscribe to @sc{nntp} groups, @xref{Browse Foreign Server}.

@item G e
@kindex G e (Group)
@findex gnus-group-edit-group-method
Enter a buffer where you can edit the select method of the current
group (@code{gnus-group-edit-group-method}).

@item G p
@kindex G p (Group)
@findex gnus-group-edit-group-parameters
Enter a buffer where you can edit the group parameters
(@code{gnus-group-edit-group-parameters}). 

@item G E
@kindex G E (Group)
@findex gnus-group-edit-group
Enter a buffer where you can edit the group info
(@code{gnus-group-edit-group}).

@item G d
@kindex G d (Group)
@findex gnus-group-make-directory-group
Make a directory group.  You will be prompted for a directory name
(@code{gnus-group-make-directory-group}).  

@item G h 
@kindex G h (Group)
@findex gnus-group-make-help-group
Make the (ding) Gnus help group (@code{gnus-group-make-help-group}).

@item G a
@kindex G a (Group)
@findex gnus-group-make-archive-group
@vindex gnus-group-archive-directory
Make the (ding) Gnus archive group
(@code{gnus-group-make-archive-group}).  The archive group will be
fetched from @code{gnus-group-archive-directory}.

@item G k
@kindex G k (Group)
@findex gnus-group-make-kiboze-group
Make a kiboze group.  You will be prompted for a name, for a regexp to
match groups to be "included" in the kiboze group, and a series of
strings to match on headers (@code{gnus-group-make-kiboze-group}).

@item G D
@kindex G D (Group)
@findex gnus-group-enter-directory
Read a random directory as if with were a newsgroup with the
@code{nneething} backend (@code{gnus-group-enter-directory}).

@item G f
@kindex G f (Group)
@findex gnus-group-make-doc-group
Make a group based on some file or other
(@code{gnus-group-make-doc-group}).  You will be prompted for a file
name and a file type.  Currently supported types are @code{babyl},
@code{mbox} and @code{digest}.

@item G V
@kindex G V (Group)
@findex gnus-group-make-empty-virtual
Make a new, fresh, empty @code{nnvirtual} group
(@code{gnus-group-make-empty-virtual}).

@item G v
@kindex G v (Group)
@findex gnus-group-add-to-virtual
Add the current group to an @code{nnvirtual} group
(@code{gnus-group-add-to-virtual}).  Uses the process/prefix convention.
@end table

The different methods all have their peculiarities, of course.

@menu
* nntp::             Reading news from a different @sc{nntp} server.
* nnspool::          Reading news from the local spool.
* nnvirtual::        Combining articles from many groups.
* nnkiboze::         Looking through parts of the newsfeed for articles.
* nndir::            You can read a directory as if it was a newsgroup.
* nneething::          Dired? Who needs dired?
* nndoc::            Single files can be the basis of a group.
* Reading Mail::     Reading your personal mail with Gnus.
@end menu

@vindex gnus-activate-foreign-newsgroups
If the @code{gnus-activate-foreign-newsgroups} is a positive number,
Gnus will check all foreign groups with this level or lower at startup.
This might take quite a while, especially if you subscribe to lots of
groups from different @sc{nntp} servers.  It is @code{nil} by default,
which means that you won't be told whether there are new articles in
these groups.  How many unread articles there are will be determined
when, or if, you decide to enter them.  You can also activate any group
with @kbd{M-g} to see how many unread articles there are.

@node nntp
@subsection nntp
@cindex @sc{nntp}

Subscribing to a foreign group from an @sc{nntp} server is rather easy.
You just specify @code{nntp} as method and the address of the @sc{nntp}
server as the, uhm, address.

If the @sc{nntp} server is located at a non-standard port, setting the
third element of the select method to this port number should allow you
to connect to the right port.  You'll have to edit the group info for
that (@pxref{Foreign Groups}).

The name of the foreign group can be the same as a native group.  In
fact, you can subscribe to the same group from as many different servers
you feel like.  There will be no name collisions.

The following variables can be used to create a virtual @code{nntp}
server: 

@table @code
@item nntp-server-opened-hook
@vindex nntp-server-opened-hook
@cindex @sc{mode reader}
@cindex authinfo
@findex nntp-send-authinfo
@findex nntp-send-mode-reader
@code{nntp-server-opened-hook} is run after a connection has been made.
It can be used to send commands to the @sc{nntp} server after it has
been contacted.  By default is sends the command @samp{MODE READER} to
the server with the @code{nntp-send-mode-reader} function.  Another
popular function is @code{nntp-send-authinfo}, which will prompt you for
an @sc{nntp} password and stuff.

@item nntp-maximum-request
@vindex nntp-maximum-request
If the @sc{nntp} server doesn't support @sc{nov} headers, this backend
will collect headers by sending a series of @code{head} commands.  To
speed things up, the backend sends lots of these commands without
waiting for reply, and then reads all the replies.  This is controlled
by the @code{nntp-maximum-request} variable, and is 400 by default.  If
your network is buggy, you should set this to 1.

@item nntp-connection-timeout
@vindex nntp-connection-timeout
If you have lots of foreign @code{nntp} groups that you connect to
regularly, you're sure to have problems with @sc{nntp} servers not
responding properly, or being too loaded to reply within reasonable
time.  This is can lead to awkward problems, which can be helped
somewhat by setting @code{nntp-connection-timeout}.  This is an integer
that says how many seconds the @code{nntp} backend should wait for a
connection before giving up.  If it is @code{nil}, which is the default,
no timeouts are done.

@item nntp-server-hook
@vindex nntp-server-hook
This hook is run as the last step when connecting to an @sc{nntp}
server.

@findex nntp-open-rlogin
@findex nntp-open-network-stream
@item nntp-open-server-function
@vindex nntp-open-server-function
This function is used to connect to the remote system.  Two pre-made
functions are @code{nntp-open-network-stream}, which is the default, and
simply connects to some port or other on the remote system.  The other
is @code{nntp-open-rlogin}, which does an rlogin on the remote system,
and then does a telnet to the @sc{nntp} server available there.

@item nntp-rlogin-parameters
@vindex nntp-rlogin-parameters
If you use @code{nntp-open-rlogin} as the
@code{nntp-open-server-function}, this list will be used as the
parameter list given to @code{rsh}.

@item nntp-rlogin-user-name
@vindex nntp-rlogin-user-name
User name on the remote system when using the @code{rlogin} connect
function. 

@item nntp-address
@vindex nntp-address
The address of the remote system running the @sc{nntp} server.

@item nntp-port-number
@vindex nntp-port-number
Port number to connect to when using the @code{nntp-open-network-stream}
connect function.

@item nntp-buggy-select
@vindex nntp-buggy-select
Set this to non-@code{nil} if your select routine is buggy.

@item nntp-nov-is-evil 
@vindex nntp-nov-is-evil 
If the @sc{nntp} server does not support @sc{nov}, you could set this
variable to @code{t}, but @code{nntp} usually checks whether @sc{nov}
can be used automatically.

@item nntp-xover-commands
@vindex nntp-xover-commands
List of strings that are used as commands to fetch @sc{nov} lines from a
server.  The default value of this variable is @code{("XOVER"
"XOVERVIEW")}. 

@item nntp-nov-gap
@vindex nntp-nov-gap
@code{nntp} normally sends just one big request for @sc{nov} lines to
the server.  The server responds with one huge list of lines.  However,
if you have read articles 2-5000 in the group, and only want to read
article 1 and 5001, that means that @code{nntp} will fetch 4999 @sc{nov}
lines that you do not want, and will not use.  This variable says how
big a gap between two consecutive articles is allowed to be before the
@code{XOVER} request is split into several request.  Note that if your
network is fast, setting this variable to a really small number means
that fetching will probably be slower.  If this variable is @code{nil},
@code{nntp} will never split requests.

@item nntp-prepare-server-hook
@vindex nntp-prepare-server-hook
A hook run before attempting to connect to an @sc{nntp} server.

@item nntp-async-number
@vindex nntp-async-number
How many articles should be pre-fetched when in asynchronous mode.  If
this variable is @code{t}, @code{nntp} will pre-fetch all the articles
that it can without bound.  If it is @code{nil}, no pre-fetching will be
made.

@end table

@node nnspool
@subsection nnspool
@cindex nnspool
@cindex news spool

Subscribing to a foreign group from the local spool is extremely easy,
and might be useful, for instance, to speed up reading groups like
@samp{alt.binaries.pictures.furniture}.

Anyways, you just specify @code{nnspool} as the method and @samp{""} (or
anything else) as the address.

If you have access to a local spool, you should probably use that as the
native select method (@pxref{Finding the News}).

@table @code
@item nnspool-inews-program
@vindex nnspool-inews-program
Program used to post an article.

@item nnspool-inews-switches
@vindex nnspool-inews-switches
Parameters given to the inews program when posting an article. 

@item nnspool-spool-directory
@vindex nnspool-spool-directory
Where nnspool looks for the articles.  This is normally
@file{/usr/spool/news/}.

@item nnspool-nov-directory 
@vindex nnspool-nov-directory 
Where nnspool will look for @sc{nov} files.  This is normally
@file{/usr/spool/news/over.view/}.

@item nnspool-lib-dir
@vindex nnspool-lib-dir
Where the news lib dir is (@file{/usr/lib/news/} by default).

@item nnspool-active-file
@vindex nnspool-active-file
The path of the active file.

@item nnspool-newsgroups-file
@vindex nnspool-newsgroups-file
The path of the group description file.

@item nnspool-history-file
@vindex nnspool-history-file
The path of the news history file.

@item nnspool-active-times-file
@vindex nnspool-active-times-file
The path of the active date file.

@item nnspool-nov-is-evil
@vindex nnspool-nov-is-evil
If non-@code{nil}, @code{nnspool} won't try to use any @sc{nov} files
that it finds.

@item nnspool-sift-nov-with-sed
@vindex nnspool-sift-nov-with-sed
If non-@code{nil}, which is the default, use @code{sed} to get the
relevant portion from the overview file.  If nil, @code{nnspool} will
load the entire file into a buffer and process it there.

@end table

@node nnvirtual
@subsection nnvirtual
@cindex nnvirtual
@cindex virtual groups

An @dfn{nnvirtual group} is really nothing more than a collection of
other groups.

For instance, if you are tired of reading many small group, you can
put them all in one big group, and then grow tired of reading one
big, unwieldy group.  The joys of computing!

You specify @code{nnvirtual} as the method.  The address should be a
regexp to match component groups.

All marks in the virtual group will stick to the articles in the
component groups.  So if you tick an article in a virtual group, the
article will also be ticked in the component group from whence it came.
(And vice versa - marks from the component groups will also be shown in
the virtual group.)

Here's an example nnvirtual method that collects all Andrea Dworkin
newsgroups into one, big, happy newsgroup:

@lisp
(nnvirtual "^alt\\.fan\\.andrea-dworkin$\\|^rec\\.dworkin.*")
@end lisp

The component groups can be native or foreign; everything should work
smoothly, but if your computer explodes, it was probably my fault.

Collecting the same group from several servers might actually be a good
idea if users have set the Distribution header to limit distribution.
If you would like to read @samp{soc.motss} both from a server in Japan
and a server in Norway, you could use the following as the group regexp:

@example
"^nntp+some.server.jp:soc.motss$\\|^nntp+some.server.no:soc.motss$"
@end example

This should work kinda smoothly - all articles from both groups should
end up in this one, and there should be no duplicates.  Threading (and
the rest) will still work as usual, but there might be problems with the
sequence of articles.  Sorting on date might be an option here
(@pxref{Selecting a Group}.

One limitation, however - all groups that are included in a virtual
group has to be alive (i.e., subscribed or unsubscribed).  Killed or
zombie groups can't be component groups for nnvirtual groups.

@node nnkiboze
@subsection nnkiboze
@cindex nnkiboze
@cindex kibozing

@dfn{Kibozing} is defined by OED as "grepping through (parts of) the
news feed".  nnkiboze is a backend that will do this for you.  Oh joy!
Now you can grind any @sc{nntp} server down to a halt with useless
requests!  Oh happiness!

The address field of the nnkiboze method is, as with nnvirtual, a regexp
to match groups to be "included" in the nnkiboze group.  There most
similarities between nnkiboze and nnvirtual ends.

In addition to this regexp detailing component groups, an nnkiboze group
must have a score file to say what articles that are to be included in
the group (@pxref{Score Files}).

@kindex M-x nnkiboze-generate-groups
@findex nnkiboze-generate-groups
You must run @kbd{M-x nnkiboze-generate-groups} after creating the
nnkiboze groups you want to have.  This command will take time.  Lots of
time.  Oodles and oodles of time.  Gnus has to fetch the headers from
all the articles in all the components groups and run them through the
scoring process to determine if there are any articles in the groups
that are to be part of the nnkiboze groups.

Please limit the number of component groups by using restrictive
regexps.  Otherwise your sysadmin may become annoyed with you, and the
@sc{nntp} site may throw you off and never let you back in again.
Stranger things have happened.

nnkiboze component groups do not have to be alive - they can be dead,
and they can be foreign.  No restrictions.

@vindex nnkiboze-directory
The generation of an nnkiboze group means writing two files in
@code{nnkiboze-directory}, which is @file{~/News/} by default.  One
contains the @sc{nov} header lines for all the articles in the group,
and the other is an additional @file{.newsrc} file to store information
on what groups that have been searched through to find component
articles.

Articles that are marked as read in the nnkiboze group will have their
@sc{nov} lines removed from the @sc{nov} file.

@node nndir
@subsection nndir
@cindex nndir
@cindex directory groups

If you have a directory that has lots of articles in separate files in
it, you might treat it as a newsgroup.  The files have to have numerical
names, of course.

This might be an opportune moment to mention @code{ange-ftp}, that most
wonderful of all wonderful Emacs packages.  When I wrote @code{nndir}, I
didn't think much about it - a backend to read directories.  Big deal.

@code{ange-ftp} changes that picture dramatically.  For instance, if you
enter @file{"/ftp@@sina.tcamc.uh.edu:/pub/emacs/ding-list/"} as the the
directory name, ange-ftp will actually allow you to read this directory
over at @samp{sina} as a newsgroup.  Distributed news ahoy!

@code{nndir} will use @sc{nov} files if they are present.

@code{nndir} is a "read-only" backend - you can't delete or expire
articles with this method.  You can use @code{nnmh} or @code{nnml} for
whatever you use @code{nndir} for, so you could switch to any of those
methods if you feel the need to have a non-read-only @code{nndir}.

@node nneething
@subsection nneething
@cindex nneething

From the @code{nndir} backend (which reads a single spool-like
directory), it's just a hop and a skip to @code{nneething}, which
pretends that any random directory is a newsgroup. Strange, but true.

When @code{nneething} is presented with a directory, it will scan this
directory and assign article numbers to each file. When you enter such a
group, @code{nneething} must create "headers" that Gnus can use. After
all, Gnus is a newsreader, in case you're forgetting. @code{nneething}
does this in a two-step process. First, it snoops each file in question.
If the file looks like an article (i.e., the first few lines look like
headers), it will use this as the head. If this is just some random file
without a head (eg. a C source file), @code{nneething} will cobble up a
header out of thin air. It will use file ownership, name and date and do
whatever it can with these elements.

All this should happen automatically for you, and you will be presented
with something that looks very much like a newsgroup. Totally like a
newsgroup, to be precise. If you select an article, it will be displayed
in the article buffer, just as usual.

If you select a line that represents a directory, Gnus will pop you into
a new summary buffer for this @code{nneething} group. And so on. You can
traverse the entire disk this way, if you feel like, but remember that
Gnus is not dired, really, and does not intend to be, either.

There are two overall modes to this action - ephemeral or solid. When
doing the ephemeral thing (i.e., @kbd{G D} from the group buffer), Gnus
will not store information on what files you have read, and what files
are new, and so on. If you create a solid @code{nneething} group the
normal way with @kbd{G m}, Gnus will store a mapping table between
article numbers and file names, and you can treat this group like any
other groups. When you activate a solid @code{nneething} group, you will
be told how many unread articles it contains, etc., etc.

Some variables:

@table @code
@item nneething-map-file-directory
@vindex nneething-map-file-directory
All the mapping files for solid @code{nneething} groups will be stored
in this directory, which defaults to @file{~/.nneething/}.

@item nneething-exclude-files
@vindex nneething-exclude-files
All files that match this regexp will be ignored. Nice to use to exclude
auto-save files and the like, which is what it does by default.

@item nneething-map-file
@vindex nneething-map-file
Name of the map files.
@end table


@node nndoc
@subsection nndoc
@cindex nndoc
@cindex documentation group
@cindex help group

nndoc is a cute little thing that will let you read a single file as a
newsgroup.  Currently supported file types are @code{babyl}, @code{mbox}
and @code{digest}. 

nndoc will not try to change the file or insert any extra headers into
it - it will simply, like, let you use the file as the basis for a
group.  And that's it.

Virtual server variables:

@table @code
@item nndoc-article-type
@vindex nndoc-article-type
This should be one of @code{mbox}, @code{babyl} or @code{digest}. 
@end table

@node Reading Mail
@subsection Reading Mail
@cindex reading mail
@cindex mail

Reading mail with a newsreader - isn't that just plain WeIrD? But of
course.

@menu
* Creating Mail Groups::         How to create mail groups.
* Fancy Mail Splitting::         Gnus can do hairy splitting of incoming mail.
* Mail & Procmail::              Reading mail groups that procmail create.
* Expiring Old Mail Articles::   Getting rid of unwanted mail.
* Not Reading Mail::             Using mail backends for reading other files.
@end menu

Gnus will read the mail spool when you activate a mail group.  The mail
file is first copied to your home directory.  What happens after that
depends on what format you want to store your mail in.

@menu
* nnmbox::    Using the (quite) standard Un*x mbox.
* nnbabyl::   Many Emacs programs use the rmail babyl format.
* nnml::      Store your mail in a private spool?
* nnmh::      An mhspool-like backend useful for procmail people.
* nnfolder::  Having one file for each group.
@end menu

@vindex nnmail-read-incoming-hook
The mail backends all call @code{nnmail-read-incoming-hook} after
reading new mail.  You can use this hook to notify any mail watch
programs, if you want to.

@vindex nnmail-spool-file
@code{nnmail-spool-file} says where to look for new mail.  If this
variable is @code{nil}, the mail backends will never attempt to fetch
mail by themselves.  It is quite likely that Gnus supports POP-mail.
Set this variable to begin with the string @samp{po:}, and everything
should go smoothly, even though I have never tested this.

@vindex nnmail-use-procmail
If @code{nnmail-use-procmail} is non-@code{nil}, the mail backends will
look in @code{nnmail-procmail-directory} for incoming mail.  All the
files in that directory that have names ending in
@code{gnus-procmail-suffix} will be considered incoming mailboxes, and
will be searched for new mail.

@vindex nnmail-prepare-incoming-hook
@code{nnmail-prepare-incoming-hook} is run in a buffer that holds all
the new incoming mail, and can be used for, well, anything, really.

@vindex nnmail-tmp-directory
@code{nnmail-tmp-directory} says where to move the incoming mail to
while processing it.  This is usually done in the same directory that
the mail backend inhabits (i.e., @file{~/Mail/}), but if this variable is
non-@code{nil}, it will be used instead.

@vindex nnmail-delete-incoming
If @code{nnmail-delete-incoming} is non-@code{nil}, the mail backends
will delete the temporary incoming file after splitting mail into the
proper groups.  This is @code{nil} by default for reasons of security. 

Gnus gives you all the opportunity you could possibly want for shooting
yourself in the foot.  Let's say you create a group that will contain
all the mail you get from your boss.  And then you accidentally
unsubscribe from the group.  Gnus will still put all the mail from your
boss in the unsubscribed group, and so, when your boss mails you "Have
that report ready by Monday or you're fired!", you'll never see it and,
come Tuesday, you'll still believe that you're gainfully employed while
you really should be out collecting empty bottles to save up for next
month's rent money.

@node Creating Mail Groups
@subsubsection Creating Mail Groups
@cindex creating mail groups

You can make Gnus read your personal, private, secret mail.

You should first set @code{gnus-secondary-select-methods} to, for
instance, @code{((nnmbox ""))}.  When you start up Gnus, Gnus will ask
this backend for what groups it carries (@samp{mail.misc} by default)
and subscribe it the normal way.  (Which means you may have to look for
it among the zombie groups, I guess, all depending on your
@code{gnus-subscribe-newsgroup-method} variable.)

@vindex nnmail-split-methods
Then you should set the variable @code{nnmail-split-methods} to specify
how the incoming mail is to be split into groups.

@lisp
(setq nnmail-split-methods
  '(("mail.junk" "^From:.*Lars Ingebrigtsen")
    ("mail.crazy" "^Subject:.*die\\|^Organization:.*flabby")
    ("mail.other" "")))
@end lisp

This variable is a list of lists, where the first element of each of
these lists is the name of the mail group (they do not have to be called
something beginning with @samp{mail}, by the way), and the second
element is a regular expression used on the header of each mail to
determine if it belongs in this mail group.

The second element can also be a function.  In that case, it will be
called narrowed to the headers with the first element of the rule as the
argument.  It should return a non-@code{nil} value if it thinks that the
mail belongs in that group.

The last of these groups should always be a general one, and the regular
expression should @emph{always} be @samp{""} so that it matches any
mails that haven't been matched by any of the other regexps.

If you like to tinker with this yourself, you can set this variable to a
function of your choice. This function will be called without any
arguments in a buffer narrowed to the headers of an incoming mail
message. The function should return a list of groups names that it
thinks should carry this mail message.

@vindex nnmail-crosspost
The mail backends all support cross-posting.  If several regexps match,
the mail will be "cross-posted" to all those groups.
@code{nnmail-crosspost} says whether to use this mechanism or not.  Note
that no articles are crossposted to the general (@samp{""}) group. 

@node Fancy Mail Splitting
@subsubsection Fancy Mail Splitting
@cindex mail splitting
@cindex fancy mail splitting

@vindex nnmail-split-fancy
@findex nnmail-split-fancy
If the rather simple, standard method for specifying how to split mail
doesn't allow you to do what you want, you can set
@code{nnmail-split-methods} to @code{nnmail-split-fancy}.  Then you can
play with the @code{nnmail-split-fancy} variable. 

Let's look at an example value of this variable first:

@lisp
;; Messages from the mailer daemon are not crossposted to any of
;; the ordinary groups.  Warnings are put in a separate group
;; from real errors.
(| ("from" mail (| ("subject" "warn.*" "mail.warning")
                   "mail.misc"))
   ;; Non-error messages are crossposted to all relevant
   ;; groups, but we don't crosspost between the group for the
   ;; (ding) list and the group for other (ding) related mail.
   (& (| (any "ding@@ifi\\.uio\\.no" "ding.list")
         ("subject" "ding" "ding.misc"))
      ;; Other mailing lists...
      (any "procmail@@informatik\\.rwth-aachen\\.de" "procmail.list")
      (any "SmartList@@informatik\\.rwth-aachen\\.de" "SmartList.list")
      ;; People...
      (any "larsi@@ifi\\.uio\\.no" "people.Lars Magne Ingebrigtsen"))
   ;; Unmatched mail goes to the catch all group.
   "misc.misc"))")
@end lisp

This variable has the format of a @dfn{split}.  A split is a (possibly)
recursive structure where each split may contain other splits.  Here are
the four possible split syntaxes:

@table @dfn
@item GROUP 
If the split is a string, that will be taken as a group name. 
@item (FIELD VALUE SPLIT)
If the split is a list, and the first element is a string, then that
means that if header FIELD (a regexp) contains VALUE (also a regexp),
then store the message as specified by SPLIT.
@item (| SPLIT...)
If the split is a list, and the first element is @code{|} (vertical
bar), then process each SPLIT until one of them matches.  A SPLIT is
said to match if it will cause the mail message to be stored in one or
more groups.
@item (& SPLIT...)
If the split is a list, and the first element is @code{&}, then process
all SPLITs in the list.
@end table

In these splits, FIELD must match a complete field name.  VALUE must
match a complete word according to the fundamental mode syntax table.
You can use @code{.*} in the regexps to match partial field names or
words.

@vindex nnmail-split-abbrev-alist
FIELD and VALUE can also be lisp symbols, in that case they are expanded
as specified by the variable @code{nnmail-split-abbrev-alist}.  This is
an alist of cons cells, where the car of the cells contains the key, and
the cdr contains a string.

@node Mail & Procmail
@subsubsection Mail & Procmail
@cindex procmail

Many people use @code{procmail} to split incoming mail into groups.  If
you do that, you should set @code{nnmail-spool-file} to @code{procmail}
to ensure that the mail backends never ever try to fetch mail by
themselves.

This also means that you probably don't want to set
@code{nnmail-split-methods} either, which has some, perhaps, unexpected
side effects.

When a mail backend is queried for what groups it carries, it replies
with the contents of that variable, along with any groups it has figured
out that it carries by other means.  None of the backends (except
@code{nnmh}) actually go out to the disk and check what groups actually
exist.  (It's not trivial to distinguish between what the user thinks is
a basis for a newsgroup and what is just a plain old file or directory.)

This means that you have to tell Gnus (and the backends) what groups
exist by hand.

Let's take the @code{nnmh} backend as an example. 

The folders are located in @code{nnmh-directory}, say, @file{~/Mail/}.
There are three folders, @file{foo}, @file{bar} and @file{mail.baz}.

Go to the group buffer and type @kbd{G m}.  When prompted, answer
@samp{foo} for the name and @samp{nnmh} for the method.  Repeat
twice for the two other groups, @samp{bar} and @samp{mail.baz}.  Be sure
to include all your mail groups.

That's it.  You are now set to read your mail.  An active file for this
method will be created automatically.

@vindex nnmail-procmail-suffix
@vindex nnmail-procmail-directory
If you use @code{nnfolder} or any other backend that store more than a
single article in each file, you should never have procmail add mails to
the file that Gnus sees.  Instead, procmail should put all incoming mail
in @code{nnmail-procmail-directory}.  To arrive at the file name to put
the incoming mail in, append @code{nnmail-procmail-suffix} to the group
name.  The mail backends will read the mail from these files.

@vindex nnmail-resplit-incoming
When Gnus reads a file called @file{mail.misc.spool}, this mail will be
put in the @code{mail.misc}, as one would expect.  However, if you want
Gnus to split the mail the normal way, you could set
@code{nnmail-resplit-incoming} to @code{t}.

@vindex nnmail-keep-last-article
If you use @code{procmail}, you should set
@code{nnmail-keep-last-article} to non-@code{nil}, to prevent Gnus from
ever expiring the final article in a mail newsgroup. This is quite,
quite important.


@node Expiring Old Mail Articles
@subsubsection Expiring Old Mail Articles
@cindex article expiry

Traditional mail readers have a tendency to remove mail articles when
you mark them as read, in some way.  Gnus takes a fundamentally
different approach to mail reading.

Gnus basically considers mail just to be news that has been received in
a rather peculiar manner.  It does not think that it has the power to
actually change the mail, or delete any mail messages.  If you enter a
mail group, and mark articles as "read", or kill them in some other
fashion, the mail articles will still exist on the system.  I repeat:
Gnus will not delete your old, read mail.  Unless you ask it to, of
course.

To make Gnus get rid of your unwanted mail, you have to mark the
articles as @dfn{expirable}.  This does not mean that the articles will
disappear right away, however.  In general, a mail article will be
deleted from your system if, 1) it is marked as expirable, AND 2) it is
more than one week old.  If you do not mark an article as expirable, it
will remain on your system until hell freezes over.  This bears
repeating one more time, with some spurious capitalizations: IF you do
NOT mark articles as EXPIRABLE, Gnus will NEVER delete those ARTICLES.

@vindex gnus-auto-expirable-newsgroups
You do not have to mark articles as expirable by hand.  Groups that
match the regular expression @code{gnus-auto-expirable-newsgroups} will
have all articles that you read marked as expirable automatically.  All
articles that are marked as expirable have an @samp{E} in the first
column in the summary buffer.

Let's say you subscribe to a couple of mailing lists, and you want the
articles you have read to disappear after a while:

@lisp
(setq gnus-auto-expirable-newsgroups 
      "mail.nonsense-list\\|mail.nice-list")
@end lisp

Another way to have auto-expiry happen is to have the element
@code{auto-expire} in the select method of the group. 

@vindex nnmail-expiry-wait
The @code{nnmail-expiry-wait} variable supplies the default time an
expirable article has to live.  The default is seven days.

Gnus also supplies a function that lets you fine-tune how long articles
are to live, based on what group they are in.  Let's say you want to
have one month expiry period in the @samp{mail.private} group, a one day
expiry period in the @samp{mail.junk} group, and a six day expiry period
everywhere else:

@lisp
(setq nnmail-expiry-wait-function
      (lambda (group)
       (cond ((string= group "mail.private")
               31)
             ((string= group "mail.junk")
               1)
             (t
               6))))
@end lisp

@vindex nnmail-keep-last-article
If @code{nnmail-keep-last-article} is non-@code{nil}, Gnus will never
expire the final article in a mail newsgroup.  This is to make life
easier for procmail users.

By the way, that line up there about Gnus never expiring non-expirable
articles is a lie.  If you put @code{total-expire} in the group
parameters, articles will not be marked as expirable, but all read
articles will be put through the expiry process.  Use with extreme
caution. 

Note that at present, Gnus will not actually delete any expirable
articles automatically.  You have to enter one of the expiry functions
(eg. `C-c M-c-x' in the group buffer) to actually run articles through
the expiry process.  Or you can add a call to the expiry function in the
group exit hook.  Gnus will probably do all this automatically in the
future. 

@node Not Reading Mail
@subsubsection Not Reading Mail

If you start using any of the mail backends, they have the annoying
habit of assuming that you want to read mail with them.  This might not
be unreasonable, but it might not be what you want.

If you set @code{nnmail-spool-file} to @code{nil}, none of the backends
will ever attempt to read incoming mail, which should help.

@vindex nnbabyl-get-new-mail
@vindex nnmbox-get-new-mail
@vindex nnml-get-new-mail
@vindex nnmh-get-new-mail
@vindex nnfolder-get-new-mail
This might be too much, if, for instance, you are reading mail quite
happily with @code{nnml} and just want to peek at some old @sc{rmail}
file you have stashed away with @code{nnbabyl}.  All backends have
variables called backend-@code{get-new-mail}.  If you want to disable
the @code{nnbabyl} mail reading, you edit the virtual server for the
group to have a setting where @code{nnbabyl-get-new-mail} to @code{nil}.

All the mail backends will call @code{nn}*@code{-prepare-save-mail-hook}
narrowed to the article to be saved before saving it when reading
incoming mail.

@node nnmbox
@subsubsection nnmbox
@cindex nnmbox
@cindex unix mail box

@vindex nnmbox-active-file
@vindex nnmbox-mbox-file
The @dfn{nnmbox} backend will use the standard Un*x mbox file to store
mail.  @code{nnmbox} will add extra headers to each mail article to say
which group it belongs in.

Virtual server settings:

@table @code
@item nnmbox-mbox-file
@vindex nnmbox-mbox-file
The name of the mail box in the user's home directory. 

@item nnmbox-active-file
@vindex nnmbox-active-file
The name of the active file for the mail box.

@item nnmbox-get-new-mail
@vindex nnmbox-get-new-mail
If non-@code{nil}, @code{nnmbox} will read incoming mail and split it
into groups.
@end table

@node nnbabyl
@subsubsection nnbabyl
@cindex nnbabyl
@cindex rmail mbox

@vindex nnbabyl-active-file
@vindex nnbabyl-mbox-file
The @dfn{nnbabyl} backend will use a babyl mail box to store mail.
@code{nnbabyl} will add extra headers to each mail article to say which
group it belongs in.

Virtual server settings:

@table @code
@item nnbabyl-mbox-file
@vindex nnbabyl-mbox-file
The name of the rmail mbox file.

@item nnbabyl-active-file
@vindex nnbabyl-active-file
The name of the active file for the rmail box.

@item nnbabyl-get-new-mail
@vindex nnbabyl-get-new-mail
If non-@code{nil}, @code{nnbabyl} will read incoming mail. 
@end table

@node nnml
@subsubsection nnml
@cindex nnml
@cindex mail @sc{nov} spool

The @dfn{nnml} spool mail format isn't compatible with any other known
format.  It should be used with some caution.

@vindex nnml-directory
If you use this backend, Gnus will split all incoming mail into files;
one file for each mail, and put the articles into the correct
directories under the directory specified by the @code{nnml-directory}
variable.  The default value is @file{~/Mail/}.

You do not have to create any directories beforehand; Gnus will take
care of all that.

If you have a strict limit as to how many files you are allowed to store
in your account, you should not use this backend.  As each mail gets its
own file, you might very well occupy thousands of inodes within a few
weeks.  If this is no problem for you, and it isn't a problem for you
having your friendly systems administrator walking around, madly,
shouting "Who is eating all my inodes?! Who? Who!?!", then you should
know that this is probably the fastest format to use.  You do not have
to trudge through a big mbox file just to read your new mail.

@code{nnml} is probably the slowest backend when it comes to article
splitting.  It has to create lots of files, and it also generates
@sc{nov} databases for the incoming mails.  This makes is the fastest
backend when it comes to reading mail.

Virtual server settings:

@table @code
@item nnml-directory
@vindex nnml-directory
All @code{nnml} directories will be placed under this directory. 

@item nnml-active-file
@vindex nnml-active-file
The active file for the @code{nnml} server.

@item nnml-newsgroups-file
@vindex nnml-newsgroups-file
The @code{nnml} group description file.

@item nnml-get-new-mail
@vindex nnml-get-new-mail
If non-@code{nil}, @code{nnml} will read incoming mail.

@item nnml-nov-is-evil
@vindex nnml-nov-is-evil
If non-@code{nil}, this backend will ignore any @sc{nov} files.  

@item nnml-nov-file-name
@vindex nnml-nov-file-name
The name of the @sc{nov} files.  The default is @file{.overview}. 

@end table

@findex nnml-generate-nov-databases
If your @code{nnml} groups and @sc{nov} files get totally out of whack,
you can do a complete update by typing @kbd{M-x
nnml-generate-nov-databases}.  This command will trawl through the
entire @code{nnml} hierarchy, looking at each and every article, so it
might take a while to complete.

@node nnmh
@subsubsection nnmh
@cindex nnmh
@cindex mh-e mail spool

@code{nnmh} is just like @code{nnml}, except that is doesn't generate
@sc{nov} databases and it doesn't keep an active file.  This makes
@code{nnmh} a @emph{much} slower backend than @code{nnml}, but it also
makes it easier to write procmail scripts for.

Virtual server settings:

@table @code
@item nnmh-directory
@vindex nnmh-directory
All @code{nnmh} directories will be located under this directory.

@item nnmh-get-new-mail
@vindex nnmh-get-new-mail
If non-@code{nil}, @code{nnmh} will read incoming mail.

@item nnmh-be-safe
@vindex nnmh-be-safe
If non-@code{nil}, @code{nnmh} will go to ridiculous lengths to make
sure that the articles in the folder is actually what Gnus think they
are.  It will check date stamps, and stat everything in sight, so
setting this to @code{t} will mean a serious slow-down.  If you never
use anything by Gnus to read the nnmh articles, you do not have to set
this variable to @code{t}. 
@end table

@node nnfolder
@subsubsection nnfolder
@cindex nnfolder
@cindex mbox folders

@code{nnfolder} is a backend for storing each mail group in a separate
file.  Each file is in the standard Un*x mbox format.  @code{nnfolder}
will add extra headers to keep track of article numbers and arrival
dates.

Virtual server settings:

@table @code
@item nnfolder-directory
@vindex nnfolder-directory
All the @code{nnfolder} mail boxes will be stored under this directory. 

@item nnfolder-active-file
@vindex nnfolder-active-file
The name of the active file.

@item nnfolder-newsgroups-file
@vindex nnfolder-newsgroups-file
The name of the group description file.

@item nnfolder-get-new-mail
@vindex nnfolder-get-new-mail
If non-@code{nil}, @code{nnfolder} will read incoming mail.
@end table

@node Group Parameters
@section Group Parameters
@cindex group parameters

Gnus stores all information on a group in a list that is usually known
as the @dfn{group info}.  This list has from three to six elements.
Here's an example info.

@lisp
("nnml:mail.ding" 3 ((1 . 232) 244 (256 . 270)) ((tick 246 249))
                  (nnml "private") ((to-address . "ding@@ifi.uio.no")))
@end lisp

The first element is the @dfn{group name}, as Gnus knows the group,
anyway.  The second element is the @dfn{subscription level}, which
normally is a small integer.  The third element is a list of ranges of
read articles.  The fourth element is a list of lists of article marks
of various kinds.  The fifth element is the select method (or virtual
server, if you like).  The sixth element is a list of @dfn{group
parameters}, which is what this section is about.

Any of the last three elements may be missing if they are not required.
In fact, the vast majority of groups will normally only have the first
three elements, which saves quite a lot of cons cells.

At present, there's not much you can put in the group parameters list: 

@table @code
@item to-address
@cindex to-address
If the group parameter list contains an element that looks like
@samp{(to-address .  "some@@where.com")}, that address will be used by
the backend when doing followups and posts.  This is primarily useful in
mail groups that represent mailing lists.  You just set this address to
whatever the list address is.

This trick will actually work whether the group is foreign or not.
Let's say there's a group on the server that is called @samp{fa.4ad-l}.
This is a real newsgroup, but the server has gotten the articles from a
mail-to-news gateway.  Posting directly to this group is therefore
impossible - you have to send mail to the mailing list address instead.

@item to-group
@cindex to-group
IF the group parameter list contains an element like @code{(to-group
. "some.group.name")}, all posts will be sent to that groups.

@item auto-expire
@cindex auto-expire
If this symbol is present in the group parameter list, all articles that
are read will be marked as expirable.  For an alternative approach,
@xref{Expiring Old Mail Articles}.

@item total-expire
@cindex total-expire
If this symbol is present, all read articles will be put through the
expiry process, even if they are not marked as expirable.  Use with
caution. 
@end table

If you want to change the group parameters (or anything else of the
group info) you can use the @kbd{G E} to edit enter a buffer where you
can edit the group info.

You usually don't want to edit the entire group info, so you'd be better
off using the @kbd{G p} command to just edit the group parameters.

@node Listing Groups
@section Listing Groups
@cindex group listing

These commands all list various slices of the groups that are available.

@table @kbd
@item l
@itemx A s
@kindex A s (Group)
@kindex l (Group)
@findex gnus-group-list-groups
List all groups that have unread articles
(@code{gnus-group-list-groups}).  If the numeric prefix is used, this
command will list only groups of level ARG and lower.  By default, it
only lists groups of level five or lower (i.e., just subscribed groups).
@item L
@itemx A u
@kindex A u (Group)
@kindex L (Group)
@findex gnus-group-list-all-groups
List all groups, whether they have unread articles or not
(@code{gnus-group-list-all-groups}).  If the numeric prefix is used,
this command will list only groups of level ARG and lower.  By default,
it lists groups of level seven or lower (i.e., just subscribed and
unsubscribed groups).
@item A k
@kindex A k (Group)
@findex gnus-group-list-killed
List all killed groups (@code{gnus-group-list-killed}).
@item A z
@kindex A z (Group)
@findex gnus-group-list-zombies
List all zombie groups (@code{gnus-group-list-zombies}).
@item A m
@kindex A m (Group)
@findex gnus-group-list-matching
List all subscribed groups with unread articles that match a regexp
(@code{gnus-group-list-matching}). 
@item A M
@kindex A M (Group)
@findex gnus-group-list-all-matching
List groups that match a regexp (@code{gnus-group-list-all-matching}).
@end table

@node Group Maintenance
@section Group Maintenance
@cindex bogus groups

@table @kbd
@item b
@kindex b (Group)
@findex gnus-group-check-bogus-groups
Find bogus groups and delete them
(@code{gnus-group-check-bogus-groups}).
@item F
@kindex F (Group)
@findex gnus-find-new-newsgroups
Find new groups and process them (@code{gnus-find-new-newsgroups}).
@item C-c C-x
@kindex C-c C-x (Group)
@findex gnus-group-expire-articles
Run all expirable articles in the current group through the expiry
process (if any) (@code{gnus-group-expire-articles}).
@item C-c M-C-x
@kindex C-c M-C-x (Group)
@findex gnus-group-expire-all-groups
Run all articles in all groups through the expiry process
(@code{gnus-group-expire-all-groups}).
@item C-c C-s
@kindex C-c C-s (Group)
@findex gnus-group-sort-groups
@findex gnus-group-sort-by-level
@findex gnus-group-sort-by-unread
@findex gnus-group-sort-by-alphabet
@vindex gnus-group-sort-function
Sort the groups according to the function given by the
@code{gnus-group-sort-function} variable
(@code{gnus-group-sort-groups}).  Available sorting functions include
@code{gnus-group-sort-by-alphabet} (the default),
@code{gnus-group-sort-by-unread} and @code{gnus-group-sort-by-level}. 
@end table

@node Browse Foreign Server
@section Browse Foreign Server
@cindex foreign servers
@cindex browsing servers

@table @kbd
@item B
@kindex B (Group)
@findex gnus-group-browse-foreign-server
You will be queried for a select method and a server name.  Gnus will
then attempt to contact this server and let you browse the groups there
(@code{gnus-group-browse-foreign-server}).
@end table

@findex gnus-browse-server-mode
A new buffer with a list of available groups will appear.  This buffer
will be use the @code{gnus-browse-server-mode}.  This buffer looks a bit
(well, a lot) like a normal group buffer, but with one major difference
- you can't enter any of the groups.  If you want to read any of the
news available on that server, you have to subscribe to the groups you
think may be interesting, and then you have to exit this buffer.  The
new groups will be added to the group buffer, and then you can read them
as you would any other group.

Future versions of Gnus may possibly permit reading groups straight from
the browse buffer.

Here's a list of keystrokes available in the browse mode:

@table @kbd
@item n
@kindex n (Browse)
@findex gnus-group-next-group
Go to the next group (@code{gnus-group-next-group}).

@item p
@kindex p (Browse)
@findex gnus-group-prev-group
Go to the previous group (@code{gnus-group-prev-group}).

@item SPC
@kindex SPC (Browse)
@findex gnus-browse-read-group
Enter the current group and display the first article
(@code{gnus-browse-read-group}). 

@item RET
@kindex RET (Browse)
@findex gnus-browse-select-group
Enter the current group (@code{gnus-browse-select-group}). 

@item u
@kindex u (Browse)
@findex gnus-browse-unsubscribe-current-group
Unsubscribe to the current group, or, as will be the case here,
subscribe to it (@code{gnus-browse-unsubscribe-current-group}). 

@item l
@itemx q
@kindex q (Browse)
@kindex l (Browse)
@findex gnus-browse-exit
Exit browse mode (@code{gnus-browse-exit}).

@item ?
@kindex ? (Browse)
@findex gnus-browse-describe-briefly
Describe browse mode briefly (well, there's not much to describe, is
there) (@code{gnus-browse-describe-briefly}).
@end table

@node Exiting Gnus
@section Exiting Gnus
@cindex exiting Gnus

Yes, Gnus is ex(c)iting.

@table @kbd
@item z
@kindex z (Group)
@findex gnus-group-suspend
Suspend Gnus (@code{gnus-group-suspend}).  This doesn't really exit Gnus,
but it kills all buffers except the Group buffer.  I'm not sure why this
is a gain, but then who am I to judge?
@item q
@kindex q (Group)
@findex gnus-group-exit
Quit Gnus (@code{gnus-group-exit}).
@item Q
@kindex Q (Group)
@findex gnus-group-quit
Quit Gnus without saving any startup files (@code{gnus-group-quit}).
@end table

@vindex gnus-exit-gnus-hook
@vindex gnus-suspend-gnus-hook
@code{gnus-suspend-gnus-hook} is called when you suspend Gnus and
@code{gnus-exit-gnus-hook} is called when you quit Gnus.

Note:

@quotation
Miss Lisa Cannifax, while sitting in English class, feels her feet go
numbly heavy and herself fall into a hazy trance as the boy sitting
behind her drew repeated lines with his pencil across the back of her
plastic chair.
@end quotation

@node Misc Group Stuff
@section Misc Group Stuff

@table @kbd
@item g
@kindex g (Group)
@findex gnus-group-get-new-news
Check server for new articles.  If the numeric prefix is used, this
command will check only groups of level ARG and lower
(@code{gnus-group-get-new-news}). 
@item M-g
@kindex M-g (Group)
@findex gnus-group-get-new-news-this-group
Check whether new articles have arrived in the current group
(@code{gnus-group-get-new-news-this-group}).

@item ^
@kindex ^ (Group)
@findex gnus-group-enter-server-mode
Enter the server buffer (@code{gnus-group-enter-server-mode}). @xref{The
Server Buffer}.

@item M-f
@kindex M-f (Group)
@findex gnus-group-fetch-faq
Try to fetch the FAQ for the current group
(@code{gnus-group-fetch-faq}).  Gnus will try to get the FAQ from
@code{gnus-group-faq-directory}, which is usually a directory on a
remote machine. ange-ftp will be used for fetching the file.
@item R
@kindex R (Group)
@findex gnus-group-restart
Restart Gnus (@code{gnus-group-restart}).
@item r
@kindex r (Group)
@findex gnus-group-read-init-file
Read the init file (@code{gnus-init-file}, which defaults to
@file{~/.gnus}) (@code{gnus-group-read-init-file}).
@item s
@kindex s (Group)
@findex gnus-group-save-newsrc
Save the @file{.newsrc.eld} file (and @file{.newsrc} if wanted)
(@code{gnus-group-save-newsrc}).
@item Z
@kindex Z (Group)
@findex gnus-group-clear-dribble
Clear the dribble buffer (@code{gnus-group-clear-dribble}).
@item D
@kindex D (Group)
@findex gnus-group-describe-group
Describe the current group (@code{gnus-group-describe-group}).  If given
a prefix, force Gnus to re-read the description from the server.
@item G a
@kindex G a (Group)
@findex gnus-group-apropos
List all groups that have names that match a regexp
(@code{gnus-group-apropos}).
@item G d
@kindex G d (Group)
@findex gnus-group-description-apropos
List all groups that have names or descriptions that match a regexp
(@code{gnus-group-description-apropos}).
@item a
@kindex a (Group)
@findex gnus-group-post-news
Post an article to a group (@code{gnus-group-post-news}).
@item m
@kindex m (Group)
@findex gnus-group-mail
Mail a message somewhere (@code{gnus-group-mail}).
@item C-x C-t
@kindex C-x C-t (Group)
@findex gnus-group-transpose-groups
Transpose two groups (@code{gnus-group-transpose-groups}).
@item V
@kindex V (Group)
@findex gnus-version
Display current Gnus version numbers (@code{gnus-version}).
@item M-d
@kindex M-d (Group)
@findex gnus-group-describe-all-groups
Describe all groups (@code{gnus-group-describe-all-groups}).  If given a
prefix, force Gnus to re-read the description file from the server.
@item ?
@kindex ? (Group)
@findex gnus-group-describe-briefly
Give a very short help message (@code{gnus-group-describe-briefly}).
@item C-c C-i
@kindex C-c C-i (Group)
@findex gnus-info-find-node
Go to the Gnus info node (@code{gnus-info-find-node}).
@end table

@vindex gnus-group-prepare-hook
@code{gnus-group-prepare-hook} is called after the group buffer is
generated.  It may be used to modify the buffer in some strange,
unnatural way.

@node The Summary Buffer
@chapter The Summary Buffer
@cindex summary buffer

A line for each article is displayed in the summary buffer.  You can
move around, read articles, post articles and reply to articles.

@menu
* Summary Buffer Format::       Deciding how the summary buffer is to look.
* Summary Maneuvering::         Moving around the summary buffer.
* Choosing Articles::           Reading articles.
* Paging the Article::          Scrolling the current article.
* Reply Followup and Post::     Posting articles.
* Canceling and Superseding::   "Whoops, I shouldn't have called him that."
* Marking Articles::            Marking articles as read, expirable, etc.
* Threading::                   How threads are made.
* Asynchronous Fetching::       Gnus might be able to pre-fetch articles.
* Article Caching::             You may store articles in a cache.
* Exiting the Summary Buffer::  Returning to the Group buffer.
* Process/Prefix::              A convention used by many treatment commands.
* Saving Articles::             Ways of customizing article saving.
* Decoding Articles::           Gnus can treat series of (uu)encoded articles.
* Various Article Stuff::       Various stuff dealing with articles.
* Summary Sorting::             You can sort the summary buffer four ways.
* Finding the Parent::          No child support? Get the parent.
* Score Files::                 Maintaining a score file.
* Mail Group Commands::         Some commands can only be used in mail groups.
* Various Summary Stuff::       What didn't fit anywhere else.
@end menu

@node Summary Buffer Format
@section Summary Buffer Format
@cindex summary buffer format

@menu
* Summary Buffer Lines::     You can specify how summary lines should look.
* Summary Buffer Mode Line:: You can say how the mode line should look.
@end menu

@findex mail-extract-address-components
@findex gnus-extract-address-components
@vindex gnus-extract-address-components
Gnus will use the value of the @code{gnus-extract-address-components}
variable as a function for getting the name and address parts of a
@code{From} header.  Two pre-defined function exist:
@code{gnus-extract-address-components}, which is the default, quite
fast, and too simplistic solution, and
@code{mail-extract-address-components}, which works very nicely, but is
slower.

@vindex gnus-summary-same-subject
@code{gnus-summary-same-subject} is a string indicating that the current
article has the same subject as the previous.  This string will be used
with those specs that require it.

@node Summary Buffer Lines
@subsection Summary Buffer Lines

@vindex gnus-summary-line-format
You can change the format of the lines in the summary buffer by changing
the @code{gnus-summary-line-format} variable.  It works along the same
lines a a normal @code{format} string, with some extensions.

The default string is @samp{"%U%R%z%I%(%[%4L: %-20,20n%]%) %s\n"}.

The following format specification characters are understood:

@table @samp
@item N 
Article number.
@item S
Subject string.
@item s
Subject if the article is the root, @code{gnus-summary-same-subject}
otherwise. 
@item F
Full @code{From} line.
@item n
The name (from the @code{From} header).
@item A
The address (from the @code{From} header).
@item L
Number of lines in the article.
@item c
Number of characters in the article.
@item I
Indentation based on thread level (@pxref{Customizing Threading}).
@item T
Nothing if the article is a root and lots of spaces if it isn't (it
pushes everything after it off the screen).
@item \[
Opening bracket, which is normally @samp{\[}, but can also be @samp{<}
for adopted articles.
@item \]
Closing bracket, which is normally @samp{\]}, but can also be @samp{>}
for adopted articles.
@item <
One space for each thread level.
@item >
Twenty minus thread level spaces.
@item U
Unread.
@item R
Replied.
@item i
Score as a number.
@item z
@vindex gnus-summary-zcore-fuzz
Zcore, @samp{+} if above the default level and @samp{-} if below the
default level.  If the difference between
@code{gnus-summary-default-level} and the score is less than
@code{gnus-summary-zcore-fuzz}, this spec will not be used.
@item x
@code{Xref}.
@item D
@code{Date}.
@item M
@code{Message-Id}.
@item r
@code{References}.
@item t
Number of articles in the current sub-thread.  Using this spec will slow
down summary buffer generation somewhat.
@item u
User defined specifier.  The next character in the format string should
be a letter.  @sc{gnus} will call the function
@code{gnus-user-format-function-}@samp{X}, where @samp{X} is the letter
following @samp{%u}.  The function will be passed the current header as
argument.  The function should return a string, which will be inserted
into the summary just like information from any other summary specifier.
@end table

Text between @samp{%(} and @samp{%)} will be highlighted with
@code{gnus-mouse-face} when the mouse point is placed inside the area.
There can only be one such area.

The @samp{%U} (status), @samp{%R} (replied) and @samp{%z} (zcore) specs
have to be handled with care.  For reasons of efficiency, Gnus will
compute what column these characters will end up in, and "hard-code"
that.  This means that it is illegal to have these specs after a
variable-length spec.  Well, you might not be arrested, but your summary
buffer will look strange, which is bad enough.

The smart choice is to have these specs as far to the left as possible.
(Isn't that the case with everything, though?  But I digress.)

This restriction may disappear in later versions of Gnus.

@node Summary Buffer Mode Line
@subsection Summary Buffer Mode Line

@vindex gnus-summary-mode-line-format
You can also change the format of the summary mode bar.  Set
@code{gnus-summary-mode-line-format} to whatever you like.  Here are the
elements you can play with:

@table @samp
@item G
Group name.
@item A
Current article number.
@item V
Gnus version.
@item U
Number of unread articles in this group.
@item e
Number of unselected articles in this group.
@item Z
A string with the number of unread and unselected articles represented
either as @samp{<%U(+%u) more>} if there are both unread and unselected
articles, and just as @samp{<%U more>} if there are just unread articles
and no unselected ones.
@item g
Shortish group name. For instance, @samp{rec.arts.anime} will be
shortened to @samp{r.a.anime}. 
@item S
Subject of the current article.
@item u
Used-defined spec.
@item s
Name of the current score file.
@end table


@node Summary Maneuvering
@section Summary Maneuvering
@cindex summary movement

All the straight movement commands understand the numeric prefix and
behave pretty much as you'd expect. 

None of these commands select articles.

@table @kbd
@item G M-n
@itemx M-n
@kindex M-n (Summary)
@kindex G M-n (Summary)
@findex gnus-summary-next-unread-subject
Go to the next summary line of an unread article
(@code{gnus-summary-next-unread-subject}). 
@item G M-p
@itemx M-p
@kindex M-p (Summary)
@kindex G M-p (Summary)
@findex gnus-summary-prev-unread-subject
Go to the previous summary line of an unread article
(@code{gnus-summary-prev-unread-subject}). 
@item G g
@itemx j
@kindex j (Summary)
@kindex G g (Summary)
@findex gnus-summary-goto-subject
Ask for an article number and then go to this summary line
(@code{gnus-summary-goto-subject}). 
@end table

@vindex gnus-auto-select-next
If you are at the end of the group and issue one of the movement
commands, Gnus will offer to go to the next group.  If
@code{gnus-auto-select-next} is @code{t} and the next group is empty,
Gnus will exit summary mode and return to the group buffer.  If this
variable is neither @code{t} nor @code{nil}, Gnus will select the next
group, no matter whether it has any unread articles or not.  As a
special case, if this variable is @code{quietly}, Gnus will select the
next group without asking for confirmation.  Also @xref{Group Levels}.

If Gnus asks you to press a key to confirm going to the next group, you
can use the @kbd{C-n} and @kbd{C-p} keys to move around the group
buffer, searching for the next group to read without actually returning
to the group buffer.

@vindex gnus-auto-select-same
If @code{gnus-auto-select-same} is non-@code{nil}, all the movement
commands will try to go to the next article with the same subject as the
current.  This variable is not particularly useful if you use a threaded
display.

@vindex gnus-summary-check-current
If @code{gnus-summary-check-current} is non-@code{nil}, all the "unread"
movement commands will not proceed to the next (or previous) article if
the current article is unread.  Instead, they will choose the current
article.  

@vindex gnus-auto-center-summary
If @code{gnus-auto-center-summary} is non-@code{nil}, Gnus will keep the
point in the summary buffer centered at all times.  This makes things
quite tidy, but if you have a slow network connection, or simply do not
like this un-Emacsism, you can set this variable to @code{nil} to get
the normal Emacs scrolling action.

@node Choosing Articles
@section Choosing Articles
@cindex selecting articles

None of the following movement commands understand the numeric prefix,
and they all select and display an article.

@table @kbd
@item SPACE
@kindex SPACE (Summary)
@findex gnus-summary-next-page
Select the current article, or, if that one's read already, the next
unread article (@code{gnus-summary-next-page}).
@item G n
@itemx n
@kindex n (Summary)
@kindex G n (Summary)
@findex gnus-summary-next-unread-article
Go to next unread article (@code{gnus-summary-next-unread-article}).
@item G p
@itemx p
@kindex p (Summary)
@findex gnus-summary-prev-unread-article
Go to previous unread article (@code{gnus-summary-prev-unread-article}).
@item G N
@itemx N
@kindex N (Summary)
@kindex G N (Summary)
@findex gnus-summary-next-article
Go to the next article (@code{gnus-summary-next-article}).
@item G P
@itemx P
@kindex P (Summary)
@kindex G P (Summary)
@findex gnus-summary-prev-article
Go to the previous article (@code{gnus-summary-prev-article}).
@item G C-n
@kindex G C-n (Summary)
@findex gnus-summary-next-same-subject
Go to the next article with the same subject
(@code{gnus-summary-next-same-subject}). 
@item G C-p
@kindex G C-p (Summary)
@findex gnus-summary-prev-same-subject
Go to the previous article with the same subject
(@code{gnus-summary-prev-same-subject}). 
@item G f
@itemx .
@kindex G f  (Summary)
@kindex .  (Summary)
@findex gnus-summary-first-unread-article
Go to the first unread article
(@code{gnus-summary-first-unread-article}).
@item G b
@itemx ,
@kindex G b (Summary)
@kindex , (Summary)
Go to the article with the highest score
(@code{gnus-summary-best-unread-article}). 
@item G l
@itemx l
@kindex l (Summary)
@kindex G l (Summary)
@findex gnus-summary-goto-last-article
Go to the previous article read (@code{gnus-summary-goto-last-article}).
@item G p
@kindex G p (Summary)
@findex gnus-summary-pop-article
Pop an article off the summary history and go to this article
(@code{gnus-summary-pop-article}).  This command differs from the
command above in that you can pop as many previous articles off the
history as you like.
@end table

Some variables that are relevant for moving and selecting articles:

@table @code
@item gnus-auto-extend-newsgroup
@vindex gnus-auto-extend-newsgroup
All the movement commands will try to go to the previous (or next)
article, even if that article isn't displayed in the Summary buffer if
this variable is non-@code{nil}.  Gnus will then fetch the article from
the server and display it in the article buffer.
@item gnus-select-article-hook
@vindex gnus-select-article-hook
This hook is called whenever an article is selected.  By default it
exposes any threads hidden under the selected article.
@item gnus-mark-article-hook
@vindex gnus-mark-article-hook
This hook is called whenever an article is selected.  It is intended to
be used for marking articles as read.
@item gnus-visual-mark-article-hook
@vindex gnus-visual-mark-article-hook
This hook is run after selecting an article.  It is meant to be used for
highlighting the article in some way.  It is not run if
@code{gnus-visual} is @code{nil}.
@item gnus-summary-update-hook
@vindex gnus-summary-update-hook
This hook is called when a summary line is changed.  It is not run if
@code{gnus-visual} is @code{nil}.
@item gnus-summary-selected-face
@vindex gnus-summary-selected-face
This is the face (or @dfn{font} as some people call it) that is used to
highlight the current article in the summary buffer.
@item gnus-summary-highlight
@vindex gnus-summary-highlight
Summary lines are highlighted according to this variable, which is a
list where the elements are on the format @code{(FORM . FACE)}.  If you
would, for instance, like ticked articles to be italic and high-scored
articles to be bold, you could set this variable to something like
@lisp
(((eq mark gnus-ticked-mark) . italic)
 ((> score default) . bold))
@end lisp
As you may have guessed, if @var{FORM} returns a non-@code{nil} value,
@var{FACE} will be applied to the line.
@end table

@node Paging the Article
@section Scrolling the Article
@cindex article scrolling

@table @kbd
@item SPACE
@kindex SPACE (Summary)
@findex gnus-summary-next-page
Pressing @kbd{SPACE} will scroll the current article forward one page,
or, if you have come to the end of the current article, will choose the
next article (@code{gnus-summary-next-page}).
@item DEL
@kindex DEL (Summary)
@findex gnus-summary-prev-page
Scroll the current article back one page (@code{gnus-summary-prev-page}). 
@item RET
@kindex RET (Summary)
@findex gnus-summary-scroll-up
Scroll the current article one line forward
(@code{gnus-summary-scroll-up}).
@item A <
@itemx <
@kindex < (Summary)
@kindex A < (Summary)
@findex gnus-summary-beginning-of-article
Scroll to the beginning of the article
(@code{gnus-summary-beginning-of-article}).
@item A >
@itemx >
@kindex > (Summary)
@kindex A > (Summary)
@findex gnus-summary-end-of-article
Scroll to the end of the article (@code{gnus-summary-end-of-article}).
@end table

@node Reply Followup and Post
@section Reply, Followup and Post
@cindex reply
@cindex followup
@cindex post

@kindex C-c C-c (Post)
All the commands for posting and mailing will put you in a post or mail
buffer where you can edit the article all you like, before you send the
article by pressing @kbd{C-c C-c}.  If you are in a foreign news group,
and you wish to post the article using the foreign server, you can give
a prefix to @kbd{C-c C-c} to make Gnus try to post using the foreign
server. 

@menu 
* Mail::                 Mailing & replying.
* Post::                 Posting and following up.
* Mail & Post::          Mailing and posting at the same time.
@end menu

@node Mail
@subsection Mail

Commands for composing a mail message:

@table @kbd
@item S r
@itemx r
@kindex S r (Summary)
@kindex r (Summary)
@findex gnus-summary-reply
Mail a reply to the author of the current article
(@code{gnus-summary-reply}). 
@item S R
@itemx R
@kindex R (Summary)
@kindex S R (Summary)
@findex gnus-summary-reply-with-original
Mail a reply to the author of the current article and include the
original message (@code{gnus-summary-reply-with-original}).  This
command uses the process/prefix convention.
@item S o m
@kindex S o m (Summary)
@findex gnus-summary-mail-forward
Forward the current article to some other person
(@code{gnus-summary-mail-forward}). 
@item S o p
@kindex S o p (Summary)
@findex gnus-summary-post-forward
Forward the current article to a newsgroup
(@code{gnus-summary-post-forward}).
@item S m
@itemx m
@kindex m (Summary)
@kindex S m (Summary)
@findex gnus-summary-mail-other-window
Send a mail to some other person
(@code{gnus-summary-mail-other-window}).
@item S O m
@kindex S O m (Summary)
@findex gnus-uu-digest-mail-forward
Digest the current series and forward the result using mail
(@code{gnus-uu-digest-mail-forward}).  This command uses the
process/prefix convention (@pxref{Process/Prefix}). 
@item S O p
@kindex S O p (Summary)
@findex gnus-uu-digest-post-forward
Digest the current series and forward the result to a newsgroup
(@code{gnus-uu-digest-mail-forward}).  
@end table

Variables for customizing outgoing mail:

@table @code
@item gnus-reply-to-function
@vindex gnus-reply-to-function
Gnus uses the normal methods to determine where replies are to go, but
you can change the behavior to suit your needs by fiddling with this
variable.

If you want the replies to go to the @samp{Sender} instead of the
@samp{From} in the group @samp{mail.stupid-list}, you could do something
like this:

@lisp
(setq gnus-reply-to-function
      (lambda (group)
       (cond ((string= group "mail.stupid-list")
               (mail-fetch-field "sender"))
             (t
              nil))))
@end lisp

This function will be called narrowed to the head of the article that is
being replied to.

As you can see, this function should return a string if it has an
opinion as to what the To header should be.  If it does not, it should
just return @code{nil}, and the normal methods for determining the To
header will be used.

This function can also return a list.  In that case, each list element
should be a cons, where the car should be the name of an header
(eg. @samp{Cc}) and the cdr should be the header value
(eg. @samp{larsi@@ifi.uio.no}).  All these headers will be inserted into
the head of the outgoing mail. 

@item gnus-mail-send-method
@vindex gnus-mail-send-method
This variable says how a mail should be mailed.  It uses the function in
the @code{send-mail-function} variable as the default.

@item gnus-uu-digest-headers
@vindex gnus-uu-digest-headers
List of regexps to match headers included in digested messages.  The
headers will be included in the sequence they are matched.

@item gnus-mail-hook
Hook called as the last thing after setting up a mail buffer.

@end table

There are three "methods" for handling all mail.  The default is
@code{sendmail}.  Some people like what @code{mh} does better, and some
people prefer @code{vm}.

Three variables for customizing what to use when:

@table @code

@vindex gnus-mail-reply-method
@item gnus-mail-reply-method
This function is used to compose replies.  The three functions avaibale
are:

@findex gnus-mail-reply-using-vm
@findex gnus-mail-reply-using-mhe
@findex gnus-mail-reply-using-mail
@itemize @bullet
@item 
@code{gnus-mail-reply-using-mail} (sendmail)
@item 
@code{gnus-mail-reply-using-mhe} (mh)
@item
@code{gnus-mail-reply-using-vm} (vm)
@end itemize

@vindex gnus-mail-forward-method
@item gnus-mail-forward-method
This function is used to forward messages.  The three functions avaibale
are:

@findex gnus-mail-forward-using-vm
@findex gnus-mail-forward-using-mhe
@findex gnus-mail-forward-using-mail
@itemize @bullet
@item 
@code{gnus-mail-forward-using-mail} (sendmail)
@item 
@code{gnus-mail-forward-using-mhe} (mh)
@item
@code{gnus-mail-forward-using-vm} (vm)
@end itemize

@vindex gnus-mail-other-window-method
@item gnus-mail-other-window-method
This function is used to send mails.  The three functions avaibale are:

@findex gnus-mail-other-window-using-vm
@findex gnus-mail-other-window-using-mhe
@findex gnus-mail-other-window-using-mail
@itemize @bullet
@item 
@code{gnus-mail-other-window-using-mail} (sendmail)
@item 
@code{gnus-mail-other-window-using-mhe} (mh)
@item
@code{gnus-mail-other-window-using-vm} (vm)
@end itemize

@end table


@node Post
@subsection Post

Commands for posting an article:

@table @kbd
@item S p
@itemx a
@kindex a (Summary)
@kindex S p (Summary)
@findex gnus-summary-post-news
Post an article to the current group
(@code{gnus-summary-post-news}).
@item S f
@itemx f
@kindex f (Summary)
@kindex S f (Summary)
@findex gnus-summary-followup
Post a followup to the current article (@code{gnus-summary-followup}).
@item S F
@itemx F
@kindex S F (Summary)
@kindex F (Summary)
@findex gnus-summary-followup-with-original
Post a followup to the current article and include the original message
(@code{gnus-summary-followup-with-original}).   This command uses the
process/prefix convention.
@item S u
@kindex S u (Summary)
@findex gnus-uu-post-news
Uuencode a file, split it into parts, and post it as a series
(@code{gnus-uu-post-news}). 
@c (@pxref{Uuencoding & Posting}). 
@end table

@vindex gnus-required-headers
@code{gnus-required-headers} a list of header symbols.  These headers
will either be automatically generated, or, if that's impossible, they
will be prompted for.  The following symbols are legal:

@table @code
@item From
This required header will be filled out with the result of the
@code{gnus-inews-user-name} function, which depends on the
@code{gnus-user-from-line}, @code{gnus-user-login-name},
@code{gnus-local-domain} and @code{user-mail-address} variables.
@item Subject
This required header will be prompted for if not present already. 
@item Newsgroups
This required header says which newsgroups the article is to be posted
to.  If it isn't present already, it will be prompted for.
@item Organization
This optional header will be filled out depending on the
@code{gnus-local-organization} variable.
@item Lines
This optional header will be computed by Gnus.
@item Message-ID
This required header will be generated by Gnus.  A unique ID will be
created based on date, time, user name and system name.
@item X-Newsreader
This optional header will be filled out with the Gnus version numbers. 
@end table

In addition, you can enter conses into this list.  The car of this cons
should be a symbol who's name is the name of the header, and the cdr can
either a string to be entered verbatim as the value of this header, or
it can be a function to be called.  This function should return a string
to be inserted.  For instance, if you want to insert @samp{Mime-Version:
1.0}, you should enter @code{(Mime-Version . "1.0")} into the list.  If
you want to insert a funny quote, you could enter something like
@code{(X-Yow . yow)} into the list.  The function @code{yow} will then
be called without any arguments. 

Other variables for customizing outgoing articles:

@table @code
@item gnus-post-method
@vindex gnus-post-method
If non-@code{nil}, Gnus will use this method instead of the default
select method when posting.

@item nntp-news-default-headers
@vindex nntp-news-default-headers
If non-@code{nil}, this variable will override
@code{mail-default-headers} when posting.  This variable should then be
a string.  This string will be inserted, as is, in the head of all
outgoing articles.

@item gnus-use-followup-to
@vindex gnus-use-followup-to
If @code{nil}, always ignore the Followup-To header.  If it is @code{t},
use its value, but ignore the special value @samp{poster}, which will
send the followup as a reply mail to the person you are responding to.
If it is neither @code{nil} nor @code{t}, always use the Followup-To
value.

@item gnus-followup-to-function
@vindex gnus-followup-to-function
This variable is most useful in mail groups, where "following up" really
means sending a mail to a list address.  Gnus uses the normal methods to
determine where follow-ups are to go, but you can change the behavior
to suit your needs by fiddling with this variable.

If you want the followups to go to the @samp{Sender} instead of the
@samp{From} in the group @samp{mail.stupid-list}, you could do something
like this:

@lisp
(setq gnus-followup-to-function
      (lambda (group)
       (cond ((string= group "mail.stupid-list")
               (mail-fetch-field "sender"))
             (t
              nil))))
@end lisp

This function will be called narrowed to header of the article that is
being followed up.

@item gnus-deletable-headers
@vindex gnus-deletable-headers
Headers in this list that were previously generated by Gnus will be
deleted before posting.  Let's say you post an article.  Then you decide
to post it again to some other group, you naughty boy, so you jump back
to the @code{*post-buf*} buffer, edit the @code{Newsgroups} line, and
ship it off again.  By default, this variable makes sure that the old
generated @code{Message-ID} is deleted, and a new one generated.  If
this isn't done, the entire empire would probably crumble, anarchy would
prevail, and cats would start walking on two legs and rule the world.
Allegedly. 

@item gnus-signature-function
@vindex gnus-signature-function
If non-@code{nil}, this variable should be a function that returns a
signature file name.  The function will be called with the name of the
group being posted to.  If the function returns a string that doesn't
correspond to a file, the string itself is inserted.  If the function
returns @code{nil}, the @code{gnus-signature-file} variable will be used
instead.

@item gnus-post-prepare-function
@vindex gnus-post-prepare-function
This function is called with the name of the current group after the
post buffer has been initialized, and can be used for inserting a
signature.  Nice if you use different signatures in different groups.

@item gnus-post-prepapare-hook
@vindex gnus-post-prepapare-hook
This hook is called after a post buffer has been prepared. If you want
to insert a signature at this point, you could put
@code{gnus-inews-insert-signature} into this hook.

@item news-reply-header-hook
@vindex news-reply-header-hook
A related variable when following up and replying is this variable,
which inserts the @dfn{quote line}.  The default value is:

@lisp
(defvar news-reply-header-hook
  (lambda ()
    (insert "In article " news-reply-yank-message-id
            " " news-reply-yank-from " writes:\n\n")))
@end lisp

This will create lines like:

@example
In article <zngay8jrql@@eyesore.no> Lars Mars <lars@@eyesore.no> writes:
@end example

Having the @code{Message-Id} in this line is probably overkill, so I
would suggest this hook instead:

@lisp
(setq news-reply-header-hook
  (lambda () (insert news-reply-yank-from " writes:\n\n")))
@end lisp

@item gnus-prepare-article-hook
@vindex gnus-prepare-article-hook
This hook is called before the headers have been prepared.  By default
it inserts the signature specified by @code{gnus-signature-file}.

@item gnus-inews-article-function
@vindex gnus-inews-article-function
This function is used to do the actual article processing and header
checking/generation.  

@item gnus-inews-article-hook
@vindex gnus-inews-article-hook
This hook is called right before the article is posted.  By default it
handles FCC processing (i.e., saving the article to a file.)

@item gnus-inews-article-header-hook
@vindex gnus-inews-article-header-hook
This hook is called after inserting the required headers in an article
to be posted.  The hook is called from the @code{*post-news*} buffer,
narrowed to the head, and is intended for people who would like to
insert additional headers, or just change headers in some way or other.

@item gnus-check-before-posting
@vindex gnus-check-before-posting
If non-@code{nil}, Gnus will attempt to check the legality of the
headers, as well as some other stuff, before posting.  You can control
the granularity of the check by adding or removing elements from this
list.  Legal elemetents are:

@table @code
@item subject-cmsg 
Check the subject for commands.
@item multiple-headers 
Check for the existence of multiple equal headers.
@item sendsys 
Check for the existence of version and sendsys commands.
@item message-id
Check whether the @code{Message-ID} looks ok.
@item from
Check whether the @code{From} header seems nice.
@item long-lines 
Check for too long lines.
@item control-chars
Check for illegal characters.
@item size
Check for excessive size.
@item new-text
Check whether there is any new text in the messages.
@item signature
Check the length of the signature
@end table

@end table


@node Mail & Post
@subsection Mail & Post

Commands for sending mail and post at the same time:

@table @kbd
@item S b
@kindex S b (Summary)
@findex gnus-summary-followup-and-reply
Post a followup and send a reply to the current article
(@code{gnus-summary-followup-and-reply}).
@item S B
@kindex S B (Summary)
@findex gnus-summary-followup-and-reply-with-original
Post a followup and send a reply to the current article and include the
original message (@code{gnus-summary-followup-and-reply-with-original}).
This command uses the process/prefix convention.
@end table

Here's a list of variables that are relevant to both mailing and
posting:

@table @code
@item gnus-signature-file
@itemx mail-signature
@vindex mail-signature
@vindex gnus-signature-file
@cindex double signature
@cindex signature
If @code{gnus-signature-file} is non-@code{nil}, it should be the name
of a file containing a signature (@samp{~/.signature} by default).  This
signature will be appended to all outgoing post.  Most people find it
more convenient to use @code{mail-signature}, which (sort of) does the
same, but inserts the signature into the buffer before you start editing
the post (or mail).  So - if you have both of these variables set, you
will get two signatures.  Note that @code{mail-signature} does not work
the same way as @code{gnus-signature-file}, which is a bit confusing.
If @code{mail-signature} is @code{t}, it will insert
@file{~/.signature}.  If it is a string, this string will be inserted. 

Note that RFC1036 says that a signature should be preceded by the three
characters @samp{-- } on a line by themselves.  This is to make it
easier for the recipient to automatically recognize and process the
signature.  So don't remove those characters, even though you might feel
that they ruin you beautiful design, like, totally.

Also note that no signature should be more than four lines long.
Including ASCII graphics is an efficient way to get everybody to believe
that you are silly and have nothing important to say.

@item mail-yank-prefix
@vindex mail-yank-prefix
@cindex yanking
@cindex quoting
When you are replying to or following up an article, you normally want
to quote the person you are answering.  Inserting quoted text is done by
@dfn{yanking}, and each quoted line you yank will have
@code{mail-yank-prefix} prepended to it.  This is @samp{ } by default,
which isn't very pretty.  Most everybody prefers that lines are
prepended with @samp{> }, so @code{(setq mail-yank-prefix "> ")} in your
@file{.emacs} file.

@item mail-yank-ignored-headers
@vindex mail-yank-ignored-headers
When you yank a message, you do not want to quote any headers, so
@code{(setq mail-yank-ignored-headers ":")}.

@item user-mail-address
@vindex user-mail-address
If all of @code{gnus-user-login-name}, @code{gnus-use-generic-from} and
@code{gnus-local-domain} are @code{nil}, Gnus will use
@code{user-mail-address} as the address part of the @code{From} header.

@item gnus-user-from-line
@vindex gnus-user-from-line
Your full, complete e-mail address.  This variable overrides the other
Gnus variables if it is non-@code{nil}.

Here are two example values of this variable: @samp{"larsi@@ifi.uio.no
(Lars Magne Ingebrigtsen)"} and @samp{"Lars Magne Ingebrigtsen
<larsi@@ifi.uio.no>"}. The latter version is recommended, but the name
has to be quoted if it contains non-alpha-numerical characters -
@samp{"\"Lars M. Ingebrigtsen\" <larsi@@ifi.uio.no>"}.

@item mail-default-headers
@vindex mail-default-headers
This is a string that will be inserted into the header of all outgoing
mail messages and news articles.  Convenient to use to insert standard
headers.  If @code{nntp-news-default-headers} is non-@code{nil}, that
variable will override this one when posting articles.

@item gnus-auto-mail-to-author
@vindex gnus-auto-mail-to-author
If @code{ask}, you will be prompted for whether you want to send a mail
copy to the author of the article you are following up.  If
non-@code{nil} and not @code{ask}, Gnus will send a mail with a copy of
all follow-ups to the authors of the articles you follow up.  It's nice
in one way - you make sure that the person you are responding to gets
your response.  Other people loathe this method and will hate you dearly
for it, because it means that they will first get a mail, and then have
to read the same article later when they read the news.  It is
@code{nil} by default.

@item gnus-mail-courtesy-message
@vindex gnus-mail-courtesy-message
This is a string that will be prepended to all mails that are the result
of using the variable described above.  

@end table

You may want to do spell-checking on messages that you send out.  Or, if
you don't want to spell-check by hand, you could add automatic
spell-checking via the @code{ispell} package:

@vindex news-inews-hook
@lisp
(add-hook 'news-inews-hook 'ispell-message)     ;For news posts
(add-hook 'mail-send-hook 'ispell-message)      ;for mail posts via sendmail
@end lisp

@findex gnus-inews-insert-mime-headers
If you want to insert some @sc{mime} headers into the articles you post,
without doing any actual encoding, you could add
@code{gnus-inews-insert-mime-headers} to @code{gnus-inews-article-hook}.


@node Canceling and Superseding
@section Canceling Articles
@cindex canceling articles
@cindex superseding articles

Have you ever written something, and then decided that you really,
really, really wish you hadn't posted that?

Well, you can't cancel mail, but you can cancel posts.

@findex gnus-summary-cancel-article
@kindex C (Summary)
Find the article you wish to cancel (you can only cancel your own
articles, so don't try any funny stuff).  Then press @kbd{C} or @kbd{S
c} (@code{gnus-summary-cancel-article}).  Your article will be
canceled - machines all over the world will be deleting your article. 

Be aware, however, that not all sites honor cancels, so your article may
live on here and there, while most sites will delete the article in
question.

If you discover that you have made some mistakes and want to do some
corrections, you can post a @dfn{superseding} article that will replace
your original article.

@findex gnus-summary-supersede-article
@kindex S (Summary)
Go to the original article and press @kbd{S s}
(@code{gnus-summary-supersede-article}).  You will be put in a buffer
where you can edit the article all you want before sending it off the
usual way.

@vindex gnus-delete-supersedes-headers
You probably want to delete some of the old headers before sending the
superseding article - @code{Path} and @code{Date} are probably
incorrect.  Set @code{gnus-delete-supersedes-headers} to a regexp to
match the lines you want removed.  The default is
@samp{"^Path:\\|^Date"}. 

The same goes for superseding as for canceling, only more so: Some
sites do not honor superseding.  On those sites, it will appear that you
have posted almost the same article twice.

If you have just posted the article, and change your mind right away,
there is a trick you can use to cancel/supersede the article without
waiting for the article to appear on your site first.  You simply return
to the post buffer (which is called @code{*post-buf*}).  There you will
find the article you just posted, with all the headers intact.  Change
the @samp{Message-ID} header to a @samp{Cancel} or @samp{Supersedes}
header by substituting one of those words for @samp{Message-ID}.  Then
just press @kbd{C-c C-c} to send the article as you would do normally.
The previous article will be canceled/superseded.

Just remember, kids: There is no 'c' in 'supersede'.

@node Marking Articles
@section Marking Articles
@cindex article marking
@cindex article ticking
@cindex marks

There are several marks you can set on an article. 

You have marks that decide the @dfn{readed-ness} (whoo, neato-keano
neologism ohoy!) of the article.  Alphabetic marks generally mean
@dfn{read}, while non-alphabetic characters generally mean @dfn{unread}.

In addition, you also have marks that do not affect readedness.

@menu
* Unread Articles::      Marks for unread articles.
* Read Articles::        Marks for read articles.
* Other Marks::          Marks that do not affect readedness.
@end menu

@ifinfo
There's a plethora of commands for manipulating these marks:
@end ifinfo

@menu
* Setting Marks::           How to set and remove marks.
* Setting Process Marks::   How to mark articles for later processing.
@end menu

@node Unread Articles
@subsection Unread Articles

The following marks mark articles as unread, in one form or other.

@vindex gnus-dormant-mark
@vindex gnus-ticked-mark
@table @samp
@item !
@dfn{Ticked articles} are articles that will remain visible always.  If
you see an article that you find interesting, or you want to put off
reading it, or replying to it, until sometime later, you'd typically
tick it.  However, articles can be expired, so if you want to keep an
article forever, you'll have to save it.  Ticked articles have a
@samp{!} (@code{gnus-ticked-mark}) in the first column.
@item ?
A @dfn{dormant} article is marked with a @samp{?}
(@code{gnus-dormant-mark}), and will only appear in the summary buffer
if there are followups to it.
@item SPC
An @dfn{unread} article is marked with a @samp{SPC}
(@code{gnus-unread-mark}).  These are articles that haven't been read at
all yet.
@end table

@node Read Articles
@subsection Read Articles
@cindex expirable mark

All the following marks mark articles as read.

@table @samp
@item D
Articles that are marked as read.  They have a @samp{r}
(@code{gnus-del-mark}) in the first column.  These are articles that the
user has marked as read more or less manually.
@item d
Articles that are actually read are marked with @samp{R}
(@code{gnus-read-mark}). 
@item A
Articles that were marked as read in previous sessions are now
@dfn{old} and marked with @samp{O} (@code{gnus-ancient-mark}). 
@item K
Marked as killed (@code{gnus-killed-mark}).
@item X
Marked as killed by kill files (@code{gnus-kill-file-mark}).
@item Y
Marked as read by having a too low score (@code{gnus-low-score-mark}).
@item C
Marked as read by a catchup (@code{gnus-catchup-mark}).
@item G
Canceled article (@code{gnus-cancelled-mark})
@end table

All these marks just mean that the article is marked as read, really.
They are interpreted differently by the adaptive scoring scheme,
however.

One more special mark, though:

@table @samp
@item E
You can also mark articles as @dfn{expirable} (or have them marked as
such automatically).  That doesn't make much sense in normal groups,
because a user does not control the expiring of news articles, but in
mail groups, for instance, articles that are marked as @dfn{expirable}
can be deleted by Gnus at any time.  Expirable articles are marked with
@samp{E} (@code{gnus-expirable-mark}).
@end table

@node Other Marks
@subsection Other Marks
@cindex process mark
@cindex bookmarks

There are some marks that have nothing to do with whether the article is
read or not.

You can set a bookmark in the current article.  Say you are reading a
long thesis on cat's urinary tracts, and have to go home for dinner
before you've finished reading the thesis.  You can then set a bookmark
in the article, and Gnus will jump to this bookmark the next time it
encounters the article.

All articles that you have replied to or made a followup to (i.e., have
answered) will be marked with an @samp{A} in the second column
(@code{gnus-replied-mark}).

@vindex gnus-not-empty-thread-mark
@vindex gnus-empty-thread-mark
It the @samp{%e} spec is used, the presence of threads or not will be
marked with @code{gnus-not-empty-thread-mark} and
@code{gnus-empty-thread-mark}, respectively.

@vindex gnus-process-mark
Finally we have the @dfn{process mark} (@code{gnus-process-mark}.  A
variety of commands react to the presence of the process mark.  For
instance, @kbd{X u} (@code{gnus-uu-decode-uu}) will uudecode and view
all articles that have been marked with the process mark.  Articles
marked with the process mark have a @samp{#} in the second column.

@node Setting Marks
@subsection Setting Marks
@cindex setting marks

All the marking commands understand the numeric prefix.

@table @kbd
@item M t
@itemx !
@kindex ! (Summary)
@kindex M t (Summary)
@findex gnus-summary-tick-article-forward
Tick the current article (@code{gnus-summary-tick-article-forward}).
@item M ?
@itemx ?
@kindex ? (Summary)
@kindex M ? (Summary)
@findex gnus-summary-mark-as-dormant
Mark the current article as dormant
(@code{gnus-summary-mark-as-dormant}).
@item M d
@itemx d
@kindex M d (Summary)
@kindex d (Summary)
@findex gnus-summary-mark-as-read-forward
Mark the current article as read
(@code{gnus-summary-mark-as-read-forward}).
@item M k
@itemx k
@kindex k (Summary)
@kindex M k (Summary)
@findex gnus-summary-kill-same-subject-and-select
Mark all articles that have the same subject as the current one as read,
and then select the next unread article
(@code{gnus-summary-kill-same-subject-and-select}).
@item M K
@itemx C-k
@kindex M K (Summary)
@kindex C-k (Summary)
@findex gnus-summary-kill-same-subject
Mark all articles that have the same subject as the current one as read
(@code{gnus-summary-kill-same-subject}).  
@item M C
@kindex M C (Summary)
@findex gnus-summary-catchup
Catchup the current group (@code{gnus-summary-catchup}).
@item M C-c
@kindex M C-c (Summary)
@findex gnus-summary-catchup-all
Catchup all articles in the current group (@code{gnus-summary-catchup-all}).
@item M H
@kindex M H (Summary)
@findex gnus-summary-catchup-to-here
Catchup the current group to point
(@code{gnus-summary-catchup-to-here}). 
@item C-w
@kindex C-w (Summary)
@findex gnus-summary-mark-region-as-read
Mark all articles between point and mark as read
(@code{gnus-summary-mark-region-as-read}). 
@item M c
@itemx M-u
@kindex M c (Summary)
@kindex M-u (Summary)
@findex gnus-summary-clear-mark-forward
Clear all readedness-marks from the current article
(@code{gnus-summary-clear-mark-forward}).
@item M e
@itemx E
@kindex M e (Summary)
@kindex E (Summary)
@findex gnus-summary-mark-as-expirable
Mark the current article as expirable
(@code{gnus-summary-mark-as-expirable}).
@item M b
@kindex M b (Summary)
@findex gnus-summary-set-bookmark
Set a bookmark in the current article
(@code{gnus-summary-set-bookmark}).
@item M B
@kindex M B (Summary)
@findex gnus-summary-remove-bookmark
Remove the bookmark from the current article
(@code{gnus-summary-remove-bookmark}).
@item M M-r
@itemx x
@kindex M M-r (Summary)
@kindex M-d (Summary)
@findex gnus-summary-remove-lines-marked-as-read
Expunge all deleted articles from the summary buffer
(@code{gnus-summary-remove-lines-marked-as-read}). 
@item M M-C-r
@kindex M M-C-r (Summary)
@findex gnus-summary-remove-lines-marked-with
Ask for a mark and then expunge all articles that have been marked with
that mark (@code{gnus-summary-remove-lines-marked-with}).
@item M S
@kindex M S (Summary)
@findex gnus-summary-show-all-expunged
Display all expunged articles (@code{gnus-summary-show-all-expunged}).
@item M D
@kindex M D (Summary)
@findex gnus-summary-show-all-dormant
Display all dormant articles (@code{gnus-summary-show-all-dormant}).
@item M M-D
@kindex M M-D (Summary)
@findex gnus-summary-hide-all-dormant
Hide all dormant articles (@code{gnus-summary-hide-all-dormant}).
@item M s k
@kindex M s k (Summary)
@findex gnus-summary-kill-below
Kill all articles with scores below the default score (or below the
numeric prefix) (@code{gnus-summary-kill-below}).
@item M s c
@kindex M s c (Summary)
@findex gnus-summary-clear-above
Clear all marks from articles with scores over the default score (or
over the numeric prefix) (@code{gnus-summary-clear-above}).
@item M s u
@kindex M s u (Summary)
@findex gnus-summary-tick-above
Tick all articles with scores over the default score (or over the
numeric prefix) (@code{gnus-summary-tick-above}).
@item M s m
@kindex M s m (Summary)
@findex gnus-summary-mark-above
Prompt for a mark, and mark all articles with scores over the default
score (or over the numeric prefix) with this mark
(@code{gnus-summary-clear-above}).
@end table

@code{gnus-summary-goto-unread}
The @code{gnus-summary-goto-unread} variable controls what action should
be taken after setting a mark.  If non-@code{nil}, point will move to
the next/previous unread article.  If @code{nil}, point will just move
one line up or down.

@node Setting Process Marks
@subsection Setting Process Marks
@cindex setting process marks

@table @kbd
@item M p p
@itemx #
@kindex # (Summary)
@kindex M p p (Summary)
@findex gnus-summary-mark-as-processable
Mark the current article with the process mark
(@code{gnus-summary-mark-as-processable}). 
@findex gnus-summary-unmark-as-processable
@item M p u 
@itemx M-#
@kindex M p u (Summary)
@kindex M-# (Summary)
Remove the process mark, if any, from the current article
(@code{gnus-summary-unmark-as-processable}).
@item M p U
@kindex M p U (Summary)
@findex gnus-summary-unmark-all-processable
Remove the process mark from all articles
(@code{gnus-summary-unmark-all-processable}). 
@item M p R
@kindex M p R (Summary)
@findex gnus-uu-mark-by-regexp
Mark articles by a regular expression (@code{gnus-uu-mark-by-regexp}). 
@item M p r
@kindex M p r (Summary)
@findex gnus-uu-mark-region
Mark articles in region (@code{gnus-uu-mark-region}).
@item M p t
@kindex M p t (Summary)
@findex gnus-uu-mark-thread
Mark all articles in the current (sub)thread
(@code{gnus-uu-mark-thread}).
@item M p s
@kindex M p s (Summary)
@findex gnus-uu-mark-series
Mark all articles in the current series (@code{gnus-uu-mark-series}).
@item M p S
@kindex M p S (Summary)
@findex gnus-uu-mark-sparse
Mark all series that have already had some articles marked
(@code{gnus-uu-mark-sparse}).
@item M p a
@kindex M p a (Summary)
@findex gnus-uu-mark-all
Mark all articles in series order (@code{gnus-uu-mark-series}).
@end table

@node Threading
@section Threading
@cindex threading
@cindex article threading

Gnus threads articles by default.  @dfn{To thread} is to put replies to
articles directly after the articles they reply to - in a hierarchical
fashion.

@menu
* Customizing Threading::     Variables you can change to affect the threading.
* Thread Commands::           Thread based commands in the summary buffer.
@end menu

@node Customizing Threading
@subsection Customizing Threading
@cindex customizing threading
@cindex <
@cindex >

@table @code
@item gnus-show-threads
@vindex gnus-show-threads
If this variable is @code{nil}, no threading will be done, and all of
the rest of the variables here will have no effect.  Turning threading
off will speed group selection up a bit, but it is sure to make reading
slower and more awkward.
@item gnus-fetch-old-headers
@vindex gnus-fetch-old-headers
If non-@code{nil}, Gnus will attempt to build old threads by fetching
more old headers - headers to articles that are marked as read.  If you
would like to display as few summary lines as possible, but still
connect as many loose threads as possible, you should set this variable
to @code{some}.  In either case, fetching old headers only works if the
select method you are using supports @sc{xover}.  Also remember that if
the root of the thread has been expired by the server, there's not much
Gnus can do about that.

@item gnus-summary-gather-subject-limit
Loose threads are gathered by comparing subjects of articles.  If this
variable is @code{nil}, Gnus requires an exact match between the
subjects of the loose threads before gathering them into one big
super-thread.  This might be too strict a requirement, what with the
presence of stupid newsreaders that chop off long subjects lines.  If
you think so, set this variable to, say, 20 to require that only the
first 20 characters of the subjects have to match.  If you set this
variable to a real low number, you'll find that Gnus will gather
everything in sight into one thread, which isn't very helpful.

@cindex fuzzy article gathering
If you set this variable to the special value @code{fuzzy}, Gnus will
use a fuzzy string comparison algorithm on the subjects.

@item gnus-summary-make-false-root
@vindex gnus-summary-make-false-root
If non-@code{nil}, Gnus will gather all loose subtrees into one big tree
and create a dummy root at the top.  (Wait a minute.  Root at the top?
Yup.)  Loose subtrees occur when the real root has expired, or you've
read or killed the root in a previous session.

When there is no real root of a thread, Gnus will have to fudge
something.  This variable says what fudging method Gnus should use.
There are four possible values:

@cindex adopting articles

@table @code
@item adopt
Gnus will make the first of the orphaned articles the parent.  This
parent will adopt all the other articles.  The adopted articles will be
marked as such by pointy brackets (@samp{<>}) instead of the standard
square brackets (@samp{[]}).  This is the default method.
@item dummy
Gnus will create a dummy summary line that will pretend to be the
parent.  This dummy line does not correspond to any real article, so
selecting it will just select the first real article after the dummy
article.
@item empty
Gnus won't actually make any article the parent, but simply leave the
subject field of all orphans except the first empty.  (Actually, it will
use @code{gnus-summary-same-subject} as the subject (@pxref{Summary
Buffer Format}).)
@item none
Don't make any article parent at all.  Just gather the threads and
display them after one another.
@item nil
Don't gather loose threads.
@end table

@item gnus-thread-hide-subtree
@vindex gnus-thread-hide-subtree
If non-@code{nil}, all threads will be hidden when the summary buffer is
generated.
@item gnus-thread-hide-killed
@vindex gnus-thread-hide-killed
if you kill a thread and this variable is non-@code{nil}, the subtree
will be hidden.
@item gnus-thread-ignore-subject
@vindex gnus-thread-ignore-subject
Sometimes somebody changes the subject in the middle of a thread.  If
this variable is non-@code{nil}, the subject change is ignored.  If it
is @code{nil}, which is the default, a change in the subject will result
in a new thread.
@item gnus-thread-indent-level
@vindex gnus-thread-indent-level
This is a number that says how much each sub-thread should be indented.
The default is @samp{4}.
@end table

@node Thread Commands
@subsection Thread Commands
@cindex thread commands

@table @kbd
@item T k
@itemx M-C-k
@kindex T k (Summary)
@kindex M-C-k (Summary)
@findex gnus-summary-kill-thread
Mark all articles in the current sub-thread as read
(@code{gnus-summary-kill-thread}).  If the prefix argument is positive,
remove all marks instead.  If the prefix argument is negative, tick
articles instead.
@item T l
@itemx M-C-l
@kindex T l (Summary)
@kindex M-C-l (Summary)
@findex gnus-summary-lower-thread
Lower the score of the current thread
(@code{gnus-summary-lower-thread}). 
@item T i
@kindex T i (Summary)
@findex gnus-summary-raise-thread
Increase the score of the current thread
(@code{gnus-summary-raise-thread}).
@item T #
@kindex T # (Summary)
@findex gnus-uu-mark-thread
Mark the current thread with the process mark
(@code{gnus-uu-mark-thread}).
@item T T
@kindex T T (Summary)
@findex gnus-summary-toggle-threads
Toggle threading (@code{gnus-summary-toggle-threads}).
@item T s
@kindex T s (Summary)
@findex gnus-summary-show-thread
Expose the thread hidden under the current article, if any
(@code{gnus-summary-show-thread}).
@item T h
@kindex T h (Summary)
@findex gnus-summary-hide-thread
Hide the current (sub)thread (@code{gnus-summary-hide-thread}).
@item T S
@kindex T S (Summary)
@findex gnus-summary-show-all-threads
Expose all hidden threads (@code{gnus-summary-show-all-threads}).
@item T H
@kindex T H (Summary)
@findex gnus-summary-hide-all-threads
Hide all threads (@code{gnus-summary-hide-all-threads}).
@end table

The following commands are thread movement commands.  They all
understand the numeric prefix.

@table @kbd
@item T n
@kindex T n (Summary)
@findex gnus-summary-next-thread
Go to the next thread (@code{gnus-summary-next-thread}).
@item T p
@kindex T p (Summary)
@findex gnus-summary-prev-thread
Go to the previous thread (@code{gnus-summary-prev-thread}).
@item T d
@kindex T d (Summary)
@findex gnus-summary-down-thread
Descend the thread (@code{gnus-summary-down-thread}).
@item T u
@kindex T u (Summary)
@findex gnus-summary-up-thread
Ascend the thread (@code{gnus-summary-up-thread}).
@end table

@node Asynchronous Fetching
@section Asynchronous Article Fetching
@cindex asynchronous article fetching

If you read your news from an @sc{nntp} server that's far away, the
network latencies may make reading articles a chore.  You have to way
for a while after pressing @kbd{n} to go to the next article before the
article appears.  Why can't Gnus just go ahead and fetch the article
while you are reading the previous one?  Why not, indeed.

First, some caveats.  There are some pitfalls to using asynchronous
article fetching, especially the way Gnus does it.  

Let's say you are reading article 1, which is short, and article 2 is
quite long, and you are not interested in reading that.  Gnus does not
know this, so it goes ahead and fetches article 2.  You decide to read
article 3, but since Gnus is in the process of fetching article 2, the
connection is blocked.

To avoid these situations, Gnus will open two (count 'em two)
connections to the server.  Some people may think this isn't a very nice
thing to do, but I don't see any real alternatives.  Setting up that
extra connection takes some time, so Gnus startup will be slower.

Gnus will fetch more articles than you will read.  This will mean that
the link between your machine and the @sc{nntp} server will become more
loaded than if you didn't use article pre-fetch.  The server itself will
also become more loaded - both with the extra article requests, and the
extra connection.

Ok, so now you know that you shouldn't really use this thing... unless
you really want to.

@vindex gnus-asynchronous
Here's how:  Set @code{gnus-asynchronous} to @code{t}.  The rest should
happen automatically.

@vindex nntp-async-number
You can control how many articles that are to be pre-fetched by setting
@code{nntp-async-number}.  This is five by default, which means that when
you read an article in the group, @code{nntp} will pre-fetch the next
five articles.  If this variable is @code{t}, @code{nntp} will pre-fetch
all the articles that it can without bound.  If it is @code{nil}, no
pre-fetching will be made.

@vindex gnus-asynchronous-article-function
You may wish to create some sort of scheme for choosing which articles
that @code{nntp} should consider as candidates for pre-fetching.  For
instance, you may wish to pre-fetch all articles with high scores, and
not pre-fetch low-scored articles.  You can do that by setting the
@code{gnus-asynchronous-article-function}, which will be called with an
alist where the keys are the article numbers.  Your function should
return an alist where the articles you are not interested in have been
removed.  You could also do sorting on article score and the like. 

@node Article Caching
@section Article Caching
@cindex article caching
@cindex caching

If you have an @emph{extremely} slow @sc{nntp} connection, you may
consider turning article caching on.  Each article will then be stored
locally under your home directory.  As you may surmise, this could
potentially use @emph{huge} amounts of disk space, as well as eat up all
your inodes so fast it will make your head swim.  In vodka.

Used carefully, though, it could be just an easier way to save articles.

@vindex gnus-use-long-file-name
@vindex gnus-cache-directory
@vindex gnus-use-cache
To turn caching on, set @code{gnus-use-cache} to @code{t}.  By default,
all articles that are ticked or marked as dormant will then be copied
over to your local cache (@code{gnus-cache-directory}).  Whether this
cache is flat or hierarchal is controlled by the
@code{gnus-use-long-file-name} variable, as usual.

When re-select a ticked or dormant article, it will be fetched from the
cache instead of from the server.  As articles in your cache will never
expire, this might serve as a method of saving articles while still
keeping them where they belong.  Just mark all articles you want to save
as dormant, and don't worry.

When an article is marked as read, is it removed from the cache.

@vindex gnus-cache-remove-articles
@vindex gnus-cache-enter-articles
The entering/removal of articles from the cache is controlled by the
@code{gnus-cache-enter-articles} and @code{gnus-cache-remove-articles}
variables.  Both are lists of symbols.  The first is @code{(ticked
dormant)} by default, meaning that ticked and dormant articles will be
put in the cache.  The latter is @code{(read)} by default, meaning that
articles that are marked as read are removed from the cache.  Possibly
symbols in these two lists are @code{ticked}, @code{dormant},
@code{unread} and @code{read}.

@findex gnus-jog-cache
So where does the massive article-fetching and storing come into the
picture?  The @code{gnus-jog-cache} command will go through all
subscribed newsgroups, request all unread articles, and store them in
the cache.  You should only ever, ever ever ever, use this command if 1)
your connection to the @sc{nntp} server is really, really, really slow
and 2) you have a really, really, really huge disk.  Seriously.


@node Exiting the Summary Buffer
@section Exiting the Summary Buffer
@cindex summary exit

Exiting from the summary buffer will normally update all info on the
group and return you to the group buffer. 

@table @kbd
@item Z Z
@itemx q
@kindex Z Z (Summary)
@kindex q (Summary)
@findex gnus-summary-exit
Exit the current group and update all information on the group
(@code{gnus-summary-exit}).  @code{gnus-summary-exit-hook} is called
before doing much of the exiting, and calls
@code{gnus-summary-expire-articles} by default.
@item Z E
@itemx Q
@kindex Z E (Summary)
@kindex Q (Summary)
@findex gnus-summary-exit-no-update
Exit the current group without updating any information on the group
(@code{gnus-summary-exit-no-update}).
@item Z c
@itemx c
@kindex Z c (Summary)
@kindex c (Summary)
@findex gnus-summary-catchup-and-exit
Mark all unticked articles in the group as read and then exit
(@code{gnus-summary-catchup-and-exit}).
@item Z C
@kindex Z C (Summary)
@findex gnus-summary-catchup-all-and-exit
Mark all articles, even the ticked ones, as read and then exit
(@code{gnus-summary-catchup-all-and-exit}).
@item Z n
@kindex Z n (Summary)
@findex gnus-summary-catchup-and-goto-next-group
Mark all articles as read and go to the next group
(@code{gnus-summary-catchup-and-goto-next-group}). 
@item Z R
@kindex Z R (Summary)
@findex gnus-summary-reselect-current-group
Exit this group, and then enter it again
(@code{gnus-summary-reselect-current-group}).  If given a prefix, select
all articles, both read and unread.
@item Z G
@itemx M-g
@kindex Z G (Summary)
@kindex M-g (Summary)
@findex gnus-summary-rescan-group
Exit the group, check for new articles in the group, and select the
group (@code{gnus-summary-rescan-group}).  If given a prefix, select all
articles, both read and unread.
@item Z N
@kindex Z N (Summary)
@findex gnus-summary-next-group
Exit the group and go to the next group
(@code{gnus-summary-next-group}). 
@item Z P
@kindex Z P (Summary)
@findex gnus-summary-prev-group
Exit the group and go to the previous group
(@code{gnus-summary-prev-group}). 
@end table

@vindex gnus-exit-group-hook
@code{gnus-exit-group-hook} is called when you exit the current
group.  

@vindex gnus-use-cross-reference
The data on the current group will be updated (which articles you have
read, which articles you have replied to, etc.) when you exit the
summary buffer.  If the @code{gnus-use-cross-reference} variable is
@code{t}, articles that are cross-referenced to this group and are
marked as read, will also be marked as read in the other subscribed
groups they were cross-posted to.  If this variable is neither
@code{nil} nor @code{t}, the article will be marked as read in both
subscribed and unsubscribed groups.

Marking cross-posted articles as read ensures that you'll never have to
read the same article more than once.  Unless, of course, somebody has
posted it to several groups separately.  Posting the same article to
several groups (not cross-posting) is called @dfn{spamming}, and you are
by law required to send nasty-grams to anyone who perpetrates such a
heinous crime.

Remember: Cross-posting is kinda ok, but posting the same article
separately to several groups is not.

One thing that may cause Gnus to not do the cross-posting thing
correctly is if you use an @sc{nntp} server that supports @sc{xover}
(which is very nice, because it speeds things up considerably) which
does not include the @code{Xref} header in its @sc{nov} lines.  This is
Evil, but all too common, alas, alack.  Gnus tries to Do The Right Thing
even with @sc{xover} by registering the @code{Xref} lines of all
articles you actually read, but if you kill the articles, or just mark
them as read without reading them, Gnus will not get a chance to snoop
the @code{Xref} lines out of these articles, and will be unable to use
the cross reference mechanism.

@vindex gnus-nov-is-evil
If you want Gnus to get the @code{Xref}s right all the time, you have to
set @code{gnus-nov-is-evil} to @code{t}, which slows things down
considerably.

C'est la vie.

@node Process/Prefix
@section Process/Prefix
@cindex process/prefix convention

Many functions, among them functions for moving, decoding and saving
articles, use what is known as the @dfn{Process/Prefix convention}.

This is a method for figuring out what articles that the user wants the
command to be performed on.

It goes like this:

If the numeric prefix is N, perform the operation on the next N
articles, starting with the current one.  If the numeric prefix is
negative, perform the operation on the previous N articles, starting
with the current one.

If there is no numeric prefix, but some articles are marked with the
process mark, perform the operation on the articles that are marked with
the process mark.

If there is neither a numeric prefix nor any articles marked with the
process mark, just perform the operation on the current article.

Quite simple, really, but it needs to be made clear so that surprises
are avoided.

@node Saving Articles
@section Saving Articles
@cindex saving articles

Gnus can save articles in a number of ways.  Below is the documentation
for saving articles in a fairly straight-forward fashion (i.e., little
processing of the article is done before it is saved).  For a different
approach (uudecoding, unsharing) you should use @code{gnus-uu}
(@pxref{Decoding Articles}).

@vindex gnus-save-all-headers
If @code{gnus-save-all-headers} is non-@code{nil}, Gnus will not delete
unwanted headers before saving the article.

@table @kbd
@item O o
@itemx o
@kindex O o (Summary)
@kindex o (Summary)
@findex gnus-summary-save-article
Save the current article using the default article saver
(@code{gnus-summary-save-article}). 
@item O m
@kindex O m (Summary)
@findex gnus-summary-save-article-mail
Save the current article in mail format
(@code{gnus-summary-save-article-mail}). 
@item O r
@kindex O r (Summary)
@findex gnus-summary-save-article-mail
Save the current article in rmail format
(@code{gnus-summary-save-article-rmail}). 
@item O f
@kindex O f (Summary)
@findex gnus-summary-save-article-file
Save the current article in plain file format
(@code{gnus-summary-save-article-file}). 
@item O h
@kindex O h (Summary)
@findex gnus-summary-save-article-folder
Save the current article in mh folder format
(@code{gnus-summary-save-article-folder}). 
@item O p
@kindex O p (Summary)
@findex gnus-summary-pipe-output
Save the current article in a pipe.  Uhm, like, what I mean is - Pipe
the current article to a process (@code{gnus-summary-pipe-output}).
@end table

All these commands use the process/prefix convention
(@pxref{Process/Prefix}).

@vindex gnus-default-article-saver
You can customize the @code{gnus-default-article-saver} variable to make
Gnus do what you want it to.  You can use any of the four ready-made
functions below, or you can create your own.

@table @code
@item gnus-summary-save-in-rmail
@vindex gnus-summary-save-in-rmail
This is the default format, @dfn{babyl}.  Uses the function in the
@code{gnus-rmail-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-plain-save-name}.
@item gnus-summary-save-in-mail
@vindex gnus-summary-save-in-mail
Save in a Unix mail (mbox) file.  Uses the function in the
@code{gnus-mail-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-plain-save-name}.
@item gnus-summary-save-in-file
@vindex gnus-summary-save-in-file
Append the article straight to an ordinary file.  Uses the function in
the @code{gnus-file-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-numeric-save-name}.
@item gnus-summary-save-in-folder
@vindex gnus-summary-save-in-folder
Save the article to an MH folder using @code{rcvstore} from the MH
library.
@item gnus-summary-save-in-vm
@vindex gnus-summary-save-in-vm
Save the article in a VM folder.  You have to have the VM mail
reader to use this setting.
@end table

All of these functions, except for the last one, will save the article
in the @code{gnus-article-save-directory}, which is initialized from the
@samp{SAVEDIR} environment variable.

As you can see above, the functions use different functions to find a
suitable name of a file to save the article in.  Below is a list of
available functions that generate names:

@table @code
@item gnus-Numeric-save-name
@findex gnus-Numeric-save-name
Generates file names that look like @samp{~/News/Alt.andrea-dworkin/45}.
@item gnus-numeric-save-name
@findex gnus-numeric-save-name
Generates file names that look like @samp{~/News/alt.andrea-dworkin/45}.
@item gnus-Plain-save-name
@findex gnus-Plain-save-name
Generates file names that look like @samp{~/News/Alt.andrea-dworkin}.
@item gnus-plain-save-name
@findex gnus-plain-save-name
Generates file names that look like @samp{~/News/alt.andrea-dworkin}.
@end table

@vindex gnus-use-long-file-name
Finally, you have the @code{gnus-use-long-file-name} variable.  If it is
@code{nil}, all the preceding functions will replace all periods
(@samp{.}) in the group names with slashes (@samp{/}) - which means that
the functions will generate hierarchies of directories instead of having
all the files in the toplevel directory
(@samp{~/News/alt/andrea-dworkin} instead of
@samp{~/News/alt.andrea-dworkin}.)

This function also affects kill and score file names.  If this variable
is a list, and the list contains the element @code{not-score}, long file
names will not be used for score files, if it contains the element
@code{not-save}, long file names will not be used for saving, and if it
contains the element @code{not-kill}, long file names will not be used
for kill files.

If you'd like to save articles in a hierarchy that looks something like
a spool, you could

@lisp
(setq gnus-use-long-file-name '(not-save)) ; to get a hierarchy
(setq gnus-default-article-save 'gnus-summary-save-in-file) ; no encoding
@end lisp

Then just save with @kbd{o}. You'd then read this hierarchy with
ephemeral @code{nneething} groups - @kbd{G D} in the group buffer, and
the toplevel directory as the argument (@file{~/News/}). Then just walk
around to the groups/directories with @code{nneething}.


@node Decoding Articles
@section Decoding Articles
@cindex decoding articles

Sometime users post articles (or series of articles) that have been
encoded in some way or other.  Gnus can decode them for you.

@menu 
* Uuencoded Articles::    Uudecode articles.
* Shared Articles::       Unshar articles.
* PostScript Files::      Split PostScript.
@end menu

All these functions use the process/prefix convention
(@pxref{Process/Prefix}) for finding out what articles to work on, with
the extension that a "single article" means "a single series".  Gnus can
find out by itself what articles belong to a series, decode all the
articles and unpack/view/save the resulting file(s).

Gnus guesses what articles are in the series according to the following
simplish rule: The subjects must be (nearly) identical, except for the
last two numbers of the line.  (Spaces are largely ignored, however.)

For example: If you choose a subject called @samp{cat.gif (2/3)}, Gnus
will find all the articles that match the regexp @samp{^cat.gif
([0-9]+/[0-9]+).*$}.  

Subjects that are nonstandard, like @samp{cat.gif (2/3) Part 6 of a
series}, will not be properly recognized by any of the automatic viewing
commands, and you have to mark the articles manually with @key{#}.

@menu 
* Decoding Variables::     Variables for a happy decoding.
* Viewing Files::          You want to look at the result of the decoding?
@end menu

@node Uuencoded Articles
@subsection Uuencoded Articles
@cindex uudecode
@cindex uuencoded articles

@table @kbd
@item X u
@kindex X u (Summary)
@findex gnus-uu-decode-uu
Uudecodes the current series (@code{gnus-uu-decode-uu}).
@item X U
@kindex X U (Summary)
@findex gnus-uu-decode-uu-and-save
Uudecodes and saves the current series
(@code{gnus-uu-decode-uu-and-save}).
@item X v u
@kindex X v u (Summary)
@findex gnus-uu-decode-uu-view
Uudecodes and views the current series (@code{gnus-uu-decode-uu-view}).
@item X v U
@kindex X v U (Summary)
@findex gnus-uu-decode-uu-and-save-view
Uudecodes, views and saves the current series
(@code{gnus-uu-decode-uu-and-save-view}). 
@end table

Remember that these all react to the presence of articles marked with
the process mark.  If, for instance, you'd like to uncode and save an
entire newsgroup, you'd typically do @kbd{M p a}
(@code{gnus-uu-mark-all}) and then @kbd{X U}
(@code{gnus-uu-decode-uu-and-save}).

All this is very much different from how @code{gnus-uu} worked with
@sc{gnus 4.1}, where you had explicit keystrokes for everything under
the sun.  This version of @code{gnus-uu} generally assumes that you mark
articles in some way (@pxref{Setting Process Marks}) and then press
@kbd{X u}.

Note: When trying to decode articles that have names matching
@code{gnus-uu-notify-files}, which is hard-coded to
@samp{[Cc][Ii][Nn][Dd][Yy][0-9]+.\\(gif\\|jpg\\)}, @code{gnus-uu} will
automatically post an article on @samp{comp.unix.wizards} saying that
you have just viewed the file in question.  This feature can't be turned
off.

@node Shared Articles
@subsection Shared Articles
@cindex unshar
@cindex shared articles

@table @kbd
@item X s
@kindex X s (Summary)
@findex gnus-uu-decode-unshar
Unshars the current series (@code{gnus-uu-decode-unshar}).
@item X S
@kindex X S (Summary)
@findex gnus-uu-decode-unshar-and-save
Unshars and saves the current series (@code{gnus-uu-decode-unshar-and-save}).
@item X v s
@kindex X v s (Summary)
@findex gnus-uu-decode-unshar-view
Unshars and views the current series (@code{gnus-uu-decode-unshar-view}).
@item X v S
@kindex X v S (Summary)
@findex gnus-uu-decode-unshar-and-save-view
Unshars, views and saves the current series
(@code{gnus-uu-decode-unshar-and-save-view}). 
@end table

@node PostScript Files
@subsection PostScript Files
@cindex PostScript

@table @kbd
@item X p
@kindex X p (Summary)
@findex gnus-uu-decode-postscript
Unpack the current PostScript series (@code{gnus-uu-decode-postscript}).
@item X P
@kindex X P (Summary)
@findex gnus-uu-decode-postscript-and-save
Unpack and save the current PostScript series
(@code{gnus-uu-decode-postscript-and-save}).
@item X v p
@kindex X v p (Summary)
@findex gnus-uu-decode-postscript-view
View the current PostScript series
(@code{gnus-uu-decode-postscript-view}).
@item X v P
@kindex X v P (Summary)
@findex gnus-uu-decode-postscript-and-save-view
View and save the current PostScript series
(@code{gnus-uu-decode-postscript-and-save-view}). 
@end table

@node Decoding Variables
@subsection Decoding Variables

Adjective, not verb.

@menu 
* Rule Variables::          Variables that say how a file is to be viewed.
* Other Decode Variables::  Other decode variables.
* Uuencoding & Posting::    Variables for customizing uuencoding.
@end menu

@node Rule Variables
@subsubsection Rule Variables
@cindex rule variables

Gnus uses @dfn{rule variables} to decide how to view a file.  All these
variables are on the form
  
@lisp
      (list '(regexp1 command2)
            '(regexp2 command2)
            ...)
@end lisp

@table @code
@item gnus-uu-user-view-rules
@vindex gnus-uu-user-view-rules
This variable is consulted first when viewing files.  If you wish to use,
for instance, @code{sox} to convert an @samp{.au} sound file, you could
say something like:
@lisp
       (setq gnus-uu-user-view-rules
         (list '(\"\\\\.au$\" \"sox %s -t .aiff > /dev/audio\")))
@end lisp
@item gnus-uu-user-view-rules-end
@vindex gnus-uu-user-view-rules-end
This variable is consulted if Gnus couldn't make any matches from the
user and default view rules.
@item gnus-uu-user-archive-rules
@vindex gnus-uu-user-archive-rules
This variable can be used to say what commands should be used to unpack
archives.
@end table

@node Other Decode Variables
@subsubsection Other Decode Variables

@table @code
@item gnus-uu-ignore-files-by-name
@vindex gnus-uu-ignore-files-by-name
Files with name matching this regular expression won't be viewed.

@item gnus-uu-ignore-files-by-type
@vindex gnus-uu-ignore-files-by-type
Files with a @sc{mime} type matching this variable won't be viewed.
Note that Gnus tries to guess what type the file is based on the name.
@code{gnus-uu} is not a @sc{mime} package (yet), so this is slightly
kludgey.

@item gnus-uu-tmp-dir
@vindex gnus-uu-tmp-dir
Where @code{gnus-uu} does its work.

@item gnus-uu-do-not-unpack-archives
@vindex gnus-uu-do-not-unpack-archives
Non-@code{nil} means that @code{gnus-uu} won't peek inside archives
looking for files to display.

@item gnus-uu-view-and-save
@vindex gnus-uu-view-and-save
Non-@code{nil} means that the user will always be asked to save a file
after viewing it.

@item gnus-uu-ignore-default-view-rules
@vindex gnus-uu-ignore-default-view-rules
Non-@code{nil} means that @code{gnus-uu} will ignore the default viewing
rules.

@item gnus-uu-ignore-default-archive-rules
@vindex gnus-uu-ignore-default-archive-rules
Non-@code{nil} means that @code{gnus-uu} will ignore the default archive
unpacking commands.

@item gnus-uu-kill-carriage-return
@vindex gnus-uu-kill-carriage-return
Non-@code{nil} means that @code{gnus-uu} will strip all carriage returns
from articles.

@item gnus-uu-unmark-articles-not-decoded
@vindex gnus-uu-unmark-articles-not-decoded
Non-@code{nil} means that @code{gnus-uu} will mark articles that were
unsuccessfully decoded as unread.

@item gnus-uu-correct-stripped-uucode
@vindex gnus-uu-correct-stripped-uucode
Non-@code{nil} means that @code{gnus-uu} will @emph{try} to fix
uuencoded files that have had trailing spaces deleted.

@item gnus-uu-view-with-metamail
@vindex gnus-uu-view-with-metamail
Non-@code{nil} means that @code{gnus-uu} will ignore the viewing
commands defined by the rule variables and just fudge a @sc{mime}
content type based on the file name.  The result will be fed to
@code{metamail} for viewing.

@item gnus-uu-save-in-digest
@vindex gnus-uu-save-in-digest
Non-@code{nil} means that @code{gnus-uu}, when asked to save without
decoding, will save in digests.  If this variable is @code{nil},
@code{gnus-uu} will just save everything in a file without any
embellishments.  The digesting almost conforms to RFC1153 - no easy way
to specify any meaningful volume and issue numbers were found, so I
simply dropped them.

@end table

@node Uuencoding & Posting
@subsubsection Uuencoding & Posting

@table @code

@item gnus-uu-post-include-before-composing
@vindex gnus-uu-post-include-before-composing
Non-@code{nil} means that @code{gnus-uu} will ask for a file to encode
before you compose the article.  If this variable is @code{t}, you can
either include an encoded file with @key{C-c C-i} or have one included
for you when you post the article.

@item gnus-uu-post-length
@vindex gnus-uu-post-length
Maximum length of an article.  The encoded file will be split into how
many articles it takes to post the entire file.

@item gnus-uu-post-threaded
@vindex gnus-uu-post-threaded
Non-@code{nil} means that @code{gnus-uu} will post the encoded file in a
thread.  This may not be smart, as no other decoder I have seen are able
to follow threads when collecting uuencoded articles.  (Well, I have
seen one package that does that - @code{gnus-uu}, but somehow, I don't
think that counts...) Default is @code{nil}.

@item gnus-uu-post-separate-description
@vindex gnus-uu-post-separate-description
Non-@code{nil} means that the description will be posted in a separate
article.  The first article will typically be numbered (0/x).  If this
variable is @code{nil}, the description the user enters will be included
at the beginning of the first article, which will be numbered (1/x).
Default is @code{t}.

@end table

@node Viewing Files
@subsection Viewing Files
@cindex viewing files
@cindex pseudo-articles

After decoding, if the file is some sort of archive, Gnus will attempt
to unpack the archive and see if any of the files in the archive can be
viewed.  For instance, if you have a gzipped tar file @file{pics.tar.gz}
containing the files @file{pic1.jpg} and @file{pic2.gif}, Gnus will
uncompress and detar the main file, and then view the two pictures.
This unpacking process is recursive, so if the archive contains archives
of archives, it'll all be unpacked.

Finally, Gnus will normally insert a @dfn{pseudo-article} for each
extracted file into the summary buffer.  If you go to these "articles",
you will be prompted for a command to run (usually Gnus will make a
suggestion), and then the command will be run.

@vindex gnus-view-pseudo-asynchronously
If @code{gnus-view-pseudo-asynchronously} is @code{nil}, Emacs will wait
until the viewing is done before proceeding.

@vindex gnus-view-pseudos
If @code{gnus-view-pseudos} is @code{automatic}, Gnus will not insert
the pseudo-articles into the summary buffer, but view them
immediately.  If this variable is @code{not-confirm}, the user won't even
be asked for a confirmation before viewing is done.

@vindex gnus-view-pseudos-separately 
If @code{gnus-view-pseudos-separately} is non-@code{nil}, one
pseudo-article will be created for each file to be viewed.  If
@code{nil}, all files that use the same viewing command will be given as
a list of parameters to that command.

So; there you are, reading your @emph{pseudo-articles} in your
@emph{virtual newsgroup} from the @emph{virtual server}; and you think:
Why isn't anything real anymore? How did we get here?

@node Various Article Stuff 
@section Various Article Stuff 

@table @kbd
@item A w
@kindex A w (Summary)
@findex gnus-summary-stop-page-breaking
Remove page breaks from the current article
(@code{gnus-summary-stop-page-breaking}).
@item A s 
@kindex A s (Summary)
@findex gnus-summary-isearch-article
Perform an isearch in the article buffer
(@code{gnus-summary-isearch-article}). 
@item A c
@kindex A c (Summary)
@findex gnus-summary-caesar-message
Do a Caesar rotate (rot13) on the article buffer
(@code{gnus-summary-caesar-message}). 
@item A g
@kindex A g (Summary)
@findex gnus-summary-show-article
(Re)fetch the current article (@code{gnus-summary-show-article}). If
given a prefix, don't actually refetch any articles, just jump to the
current article and configure the windows to display the current
article.
@item A t
@kindex A t (Summary)
@findex gnus-summary-toggle-header
Toggle whether to display all headers in the article buffer
(@code{gnus-summary-toggle-header}). 
@item A m
@kindex A m (Summary)
@findex gnus-summary-toggle-mime
Toggle whether to run the article through @sc{mime} before displaying
(@code{gnus-summary-toggle-mime}).
@end table

There's a battery of commands for washing the article buffer:

@table @kbd
@item W h
@kindex W h (Summary)
@findex gnus-article-hide-headers
Hide headers (@code{gnus-article-hide-headers}).
@item W s
@kindex W s (Summary)
@findex gnus-article-hide-signature
Hide signature (@code{gnus-article-hide-signature}).
@item W c
@kindex W c (Summary)
@findex gnus-article-hide-citation
Hide citation (@code{gnus-article-hide-citation}).
@item W o
@kindex W o (Summary)
@findex gnus-article-treat-overstrike
Treat overstrike (@code{gnus-article-treat-overstrike}).
@item W w
@kindex W w (Summary)
@findex gnus-article-word-wrap
Do word wrap (@code{gnus-article-word-wrap}).
@item W d
@kindex W d (Summary)
@findex gnus-article-remove-cr
Remove CR (@code{gnus-article-remove-cr}).
@item W q
@kindex W q (Summary)
@findex gnus-article-de-quoted-unreadable
Treat quoted-printable (@code{gnus-article-de-quoted-unreadable}).
@item W f
@kindex W f (Summary)
@cindex x-face
@findex gnus-article-display-x-face
@findex gnus-article-x-face-command
@vindex gnus-article-x-face-command
@vindex gnus-article-x-face-too-ugly
Look for and display any X-Face headers
(@code{gnus-article-display-x-face}). The command executed by this
function is given by the @code{gnus-article-x-face-command} variable. If
this variable is a string, this string will be executed in a sub-shell.
If it is a function, this function will be called with the face as the
argument. If the @code{gnus-article-x-face-too-ugly} (which is a regexp)
matches the @code{From} header, the face will not be shown.
@end table

@node Summary Sorting
@section Summary Sorting
@cindex summary sorting

You can have the summary buffer sorted in various ways, even though I
can't really see why you'd want that.

@table @kbd
@item V s n
@kindex V s n (Summary)
@findex gnus-summary-sort-by-number
Sort by article number (@code{gnus-summary-sort-by-number}).
@item V s a
@kindex V s a (Summary)
@findex gnus-summary-sort-by-author
Sort by author (@code{gnus-summary-sort-by-author}).
@item V s s
@kindex V s s (Summary)
@findex gnus-summary-sort-by-subject
Sort by subject (@code{gnus-summary-sort-by-subject}).
@item V s d
@kindex V s d (Summary)
@findex gnus-summary-sort-by-date
Sort by date (@code{gnus-summary-sort-by-date}).
@item V s i
@kindex V s i (Summary)
@findex gnus-summary-sort-by-score
Sort by date (@code{gnus-summary-sort-by-score}).
@end table

These functions will work both when you use threading and when you don't
use threading.  In the latter case, all summary lines will be sorted,
line by line.  In the former case, sorting will be done on a
root-by-root basis, which might not be what you were looking for.  To
toggle whether to use threading, type @kbd{T T} (@pxref{Thread
Commands}).

@node Finding the Parent
@section Finding the Parent
@cindex parent articles
@cindex referring articles

@findex gnus-summary-refer-parent-article
@kindex ^ (Summary)
If you'd like to read the parent of the current article, and it is not
displayed in the article buffer, you might still be able to.  That is,
if the current group is fetched by @sc{nntp}, the parent hasn't expired
and the @code{References} in the current article are not mangled, you
can just press @kbd{^} or @kbd{A r}
(@code{gnus-summary-refer-parent-article}).  If everything goes well,
you'll get the parent.  If the parent is already displayed in the
summary buffer, point will just move to this article.

@findex gnus-summary-refer-article
@kindex M-^ (Summary)
You can also ask the @sc{nntp} server for an arbitrary article, no
matter what group it belongs to.  @kbd{V r}
(@code{gnus-summary-refer-article}) will ask you for a
@code{Message-Id}, which is one of those long thingies that look
something like @samp{<38o6up$6f2@@hymir.ifi.uio.no>}.  You have to get
it all exactly right.  No fuzzy searches, I'm afraid.

@vindex gnus-refer-article-method
If the group you are reading is located on a backend that does not
support fetching by @code{Message-Id} very well (like @code{nnspool}),
you can set @code{gnus-refer-article-method} to an @sc{nntp} method.  It
would, perhaps, be best if the @sc{nntp} server you consult is the same
as the one that keeps the spool you are reading from updated, but that's
not really necessary.

@node Score Files
@section Score Files
@cindex score files

Other people use @dfn{kill files}, but we here at (ding) Gnus Towers
like scoring better than killing, so we'd rather switch than fight.  They
do something completely different as well, so sit up straight and pay
attention!

@vindex gnus-summary-mark-below
All articles have a default score (@code{gnus-summary-default-score}).
This score may be raised or lowered either interactively or by score
files.  Articles that have a score lower than
@code{gnus-summary-mark-below} are marked as read.

Gnus will read any @dfn{score files} that apply to the current group
before generating the summary buffer.

There are several commands in the summary buffer that inserts score
entries based on the current article.  You can, for instance, ask Gnus
to lower or increase the score of all articles with a certain subject.

There are two sorts of scoring entries: Permanent and temporary.
Temporary score entries are self-expiring entries.  Any entries that are
temporary and have not been used for, say, a week, will be removed
silently to help keep the sizes of the score files down.

@menu 
* Summary Score Commands::   Adding score commands to the score file.
* Score Variables::          Customize your scoring.  (My, what terminology).
* Score File Format::        What a score file may contain.
* Score File Editing::       You can edit score files by hand as well.
* Adaptive Scoring::         Big Sister Gnus *knows* what you read.
* Scoring Tips::             How to score effectively.
* Reverse Scoring::          That problem child of old is not problem.
* Global Score Files::       Earth-spanning, ear-splitting score files.
* Kill Files::               They are still here, but they can be ignored.
@end menu

@node Summary Score Commands
@subsection Summary Score Commands
@cindex score commands

The score commands that alter score entries do not actually modify real
score files.  That would be too inefficient.  Gnus maintains a cache of
previously loaded score files, one of which is considered the
@dfn{current score file alist}.  The score commands simply insert
entries into this list, and upon group exit, this list is saved.

The current score file is by default the group's local score file, even
if no such score file actually exists.  To insert score commands into
some other score file (eg. @file{all.SCORE}), you must first make this
score file the current one.

General score commands that don't actually change the score file:

@table @kbd
@item V S s
@kindex V S s (Summary)
@findex gnus-summary-set-score
Set the score of the current article (@code{gnus-summary-set-score}).  
@item V S S
@kindex V S S (Summary)
@findex gnus-summary-current-score
Display the score of the current article
(@code{gnus-summary-current-score}).   
@item V S t
@kindex V S t (Summary)
@findex gnus-score-find-trace
Display all score rules that have been used on the current article
(@code{gnus-score-find-trace}).   
@item V S a
@kindex V S a (Summary)
@findex gnus-summary-score-entry
Add a new score entry, and allow specifying all elements 
(@code{gnus-summary-score-entry}).
@item V S c
@kindex V S c (Summary)
@findex gnus-score-change-score-file
Make a different score file the current
(@code{gnus-score-change-score-file}). 
@item V S e
@kindex V S e (Summary)
@findex gnus-score-edit-alist
Edit the current score file (@code{gnus-score-edit-alist}).  You will be
popped into a @code{gnus-score-mode} buffer (@pxref{Score File
Editing}).
@item V S f
@kindex V S f (Summary)
@findex gnus-score-edit-file
Edit a score file and make this score file the current one
(@code{gnus-score-edit-file}).
@item I C-i
@kindex I C-i (Summary)
@findex gnus-summary-raise-score
Increase the score of the current article
(@code{gnus-summary-raise-score}).
@item L C-l
@kindex L C-l (Summary)
@findex gnus-summary-lower-score
Lower the score of the current article
(@code{gnus-summary-lower-score}). 
@end table

The rest of these commands modify the local score file.

@table @kbd
@item V S m
@kindex V S m (Summary)
@findex gnus-score-set-mark-below
Prompt for a score, and mark all articles with a score below this as
read (@code{gnus-score-set-mark-below}).
@item V S E
@kindex V S E (Summary)
@findex gnus-score-set-expunge-below
Expunge all articles with a score below the default score (or the
numeric prefix) (@code{gnus-score-set-expunge-below}).
@end table

The keystrokes for actually making score entries follow a very regular
pattern, so there's no need to list all the commands.  (Hundreds of
them.)  

@enumerate
@item
The first key is either @kbd{I} (upper case i) for increasing the score
or @kbd{L} for lowering the score. 
@item
The second key says what header you want to score on.  The following
keys are available:
@table @kbd
@item a
Score on the author name.
@item s
Score on the subject line.
@item x
Score on the Xref line - i.e., the cross-posting line.
@item t
Score on thread - the References line.
@item d
Score on the date.
@item l
Score on the number of lines.
@item b
Score on the body.
@item h
Score on the head.
@end table

@item
The third key is the match type.
@table @kbd
@item e
Exact matching.
@item s
Substring matching.
@item f
Fuzzy matching.
@item r
Regexp matching
@end table

@item 
The fourth and final key says whether this is a temporary (i.e., expiring)
score entry, or a permanent (i.e., non-expiring) score entry, or whether
it is to be done immediately, without adding to the score file.
@table @kbd
@item t
Temporary score entry.
@item p
Permanent score entry.
@item i
Immediately scoring.
@end table

@end enumerate

So, let's say you want to increase the score on the current author with
exact matching permanently: @kbd{I a e p}.  If you want to lower the
score based on the subject line, using substring matching, and make a
temporary score entry: @kbd{L s s t}.  Pretty easy.

To make things a bit more complicated, there are shortcuts.  If you use
a capital letter on either the second or third keys, Gnus will use
defaults for the remaining one or two keystrokes.  The defaults are
"substring" and "temporary".  So @kbd{I A} is the same as @kbd{I a s t},
and @kbd{I a R} is the same as @kbd{I a r t}.

@vindex gnus-score-mimic-keymap
The @code{gnus-score-mimic-keymap} says whether these commands will
pretend they are keymaps or not.

@node Score Variables
@subsection Score Variables
@cindex score variables

@table @code
@item gnus-use-scoring
@vindex gnus-use-scoring
If @code{nil}, Gnus will not check for score files, and will not, in
general, do any score-related work.
@item gnus-kill-killed
@vindex gnus-kill-killed
If this variable is @code{nil}, Gnus will never apply score files to
articles that have already been through the kill process.  While this
may save you lots of time, it also means that if you apply a kill file
to a group, and then change the kill file and want to run it over you
group again to kill more articles, it won't work.  You have to set this
variable to @code{t} to do that.
@item gnus-kill-files-directory
@vindex gnus-kill-files-directory
All kill and score files will be stored in this directory, which is
initialized from the @samp{SAVEDIR} environment variable by default.
@item gnus-score-file-suffix
@vindex gnus-score-file-suffix
Suffix to add to the group name to arrive at the score file name
(@samp{SCORE} by default.)
@item gnus-score-interactive-default-score
@vindex gnus-score-interactive-default-score
Score used by all the interactive raise/lower commands to raise/lower
score with.  Default is 1000, which may seem excessive, but this is to
ensure that the adaptive scoring scheme gets enough room to play with.
We don't want the small changes from the adaptive scoring to overwrite
manually entered data.
@item gnus-summary-default-score
@vindex gnus-summary-default-score
Default score of an article, which is 0 by default.
@item gnus-score-over-mark
@vindex gnus-score-over-mark
Mark (in the third column) used for articles with a score over the
default.  Default is @samp{+}.
@item gnus-score-below-mark
@vindex gnus-score-below-mark
Mark (in the third column) used for articles with a score below the
default.  Default is @samp{-}.
@item gnus-score-find-score-files-function
@vindex gnus-score-find-score-files-function
Function used to find score files for the current group.  This function
is called with the name of the group as the argument. 

Predefined functions available are:
@table @code
@item gnus-score-find-single
@findex gnus-score-find-single
Only apply the group's own score file.
@item gnus-score-find-bnews
@findex gnus-score-find-bnews
Apply all score files that match, using bnews syntax.  For instance, if
the current group is @samp{gnu.emacs.gnus}, @samp{all.emacs.all.SCORE},
@samp{not.alt.all.SCORE} and @samp{gnu.all.SCORE} would all apply.  In
short, the instances of @samp{all} in the score file names are
translated into @samp{.*}, and then a regexp match is done.
@item gnus-score-find-hierarchical
@findex gnus-score-find-hierarchical
Apply all score files from all the parent groups.
@end table
This variable can also be a list of functions.  In that case, all these
functions will be called, and all the returned lists of score files will
be applied.  These functions can also return lists of score alists
directly.  In that case, the functions that return these non-file score
alists should probably be placed before the "real" score file functions,
to ensure that the last score file returned is the local score file.
Phu. 
@item gnus-kill-expiry-days
@vindex gnus-kill-expiry-days
This variable says how many days should pass before an unused score file
entry is expired.  The default is 7.
@end table

@node Score File Format
@subsection Score File Format
@cindex score file format

A score file is an @code{emacs-lisp} file that normally contains just a
single form.  Casual users are not expected to edit these files;
everything can be changed from the summary buffer.

Anyway, if you'd like to dig into it yourself, here's an example:

@lisp
(("from"
  ("Lars Ingebrigtsen" -10000)
  ("Per Abrahamsen")
  ("larsi\\|lmi" -50000 nil R))
 ("subject"
  ("Ding is Badd" nil 728373))
 ("xref"
  ("alt.politics" -1000 728372 s))
 ("lines"
  (2 -100 nil <))
 (mark 0)
 (expunge -1000)
 (mark-and-expunge -10)
 (read-only nil)
 (orphan -10)
 (adapt t)
 (files "/hom/larsi/News/gnu.SCORE")
 (local (gnus-newsgroup-auto-expire t)
        (gnus-summary-make-false-root 'empty))
 (eval (ding)))
@end lisp

This example demonstrates absolutely everything about a score file. 

Even though this looks much like lisp code, nothing here is actually
@code{eval}ed.  The lisp reader is used to read this form, though, so it
has to be legal syntactically, if not semantically.

Six keys are supported by this alist:

@table @code
@item STRING
If the key is a string, it is the name of the header to perform the
match on.  Scoring can only be performed on these eight headers:
@samp{From}, @samp{Subject}, @samp{References}, @samp{Message-ID},
@samp{Xref}, @samp{Lines}, @samp{Chars} and @samp{Date}.  In addition to
these headers, there are three strings to tell Gnus to fetch the entire
article and do the match on larger parts of the article: @samp{Body}
will perform the match on the body of the article, @samp{Head} will
perform the match on the head of the article, and @samp{All} will
perform the match on the entire article.  Note that using any of these
last three keys will slow down group entry @emph{considerably}.  

Following this key is a random number of score entries, where each score
entry has one to four elements.
@enumerate
@item 
The first element is the @dfn{match element}.  On most headers this will
be a string, but on the Lines and Chars headers, this must be an
integer. 
@item 
If the second element is present, it should be a number - the @dfn{score
element}.  This number should be an integer in the neginf to posinf
interval.  This number is added to the score of the article if the match
is successful.  If this element is not present, the
@code{gnus-score-interactive-default-score} number will be used instead.
@item 
If the third element is present, it should be a number - the @dfn{date
element}.  This date says when the last time this score entry matched,
which provides a mechanism for expiring the score entries.  It this
element is not present, the score entry is permanent.  The date is
represented by the number of days since December 31, 1 ce.
@item 
If the fourth element is present, it should be a symbol - the @dfn{type
element}.  This element specifies what function should be used to see
whether this score entry matches the article.  What match types that can
be used depends on what header you wish to perform the match on.
@table @dfn
@item From, Subject, References, Xref, Message-ID
For most header types, there are the @code{r} and @code{R} (regexp) as
well as @code{s} and @code{S} (substring) types and @code{e} and
@code{E} (exact match) types.  If this element is not present, Gnus will
assume that substring matching should be used.  @code{R} and @code{S}
differ from the other two in that the matches will be done in a
case-sensitive manner.  All these one-letter types are really just
abbreviations for the @code{regexp}, @code{string} and @code{exact}
types, which you can use instead, if you feel like.
@item Lines, Chars
These two headers use different match types: @code{<}, @code{>},
@code{=}, @code{>=} and @code{<=}.
@item Date
For the Date header we have three match types: @code{before}, @code{at}
and @code{after}.  I can't really imagine this ever being useful, but,
like, it would feel kinda silly not to provide this function.  Just in
case.  You never know.  Better safe than sorry.  Once burnt, twice shy.
Don't judge a book by its cover.  Never not have sex on a first date.
@item Head, Body, All
These three match keys use the same match types as the @code{From} (etc)
header uses.
@item Followup
This match key will add a score entry on all articles that followup to
some author.  Uses the same match types as the @code{From} header uses.
@end table
@end enumerate

@item mark
The value of this entry should be a number.  Any articles with a score
lower than this number will be marked as read.
@item expunge
The value of this entry should be a number.  Any articles with a score
lower than this number will be removed from the summary buffer.
@item mark-and-expunge
The value of this entry should be a number.  Any articles with a score
lower than this number will be marked as read and removed from the
summary buffer.
@item files
The value of this entry should be any number of file names.  These files
are assumed to be score files as well, and will be loaded the same way
this one was.
@item exclude-files
The clue of this entry should be any number of files.  This files will
not be loaded, even though they would normally be so, for some reason or
other. 
@item eval
The value of this entry will be @code{eval}el.  This element will be
ignored when handling global score files. 
@item read-only
Read-only score files will not be updated or saved.  Global score files
should feature this atom (@pxref{Global Score Files}).
@item orphan
The value of this entry should be a number.  Articles that do not have
parents will get this number added to their scores.
@item adapt
This entry controls the adaptive scoring.  If it is @code{t}, the
default adaptive scoring rules will be used.  If it is @code{ignore}, no
adaptive scoring will be performed on this group.  If it is a list, this
list will be used as the adaptive scoring rules.  If it isn't present,
or is something other than @code{t} or @code{ignore}, the default
adaptive scoring rules will be used.  If you want to use adaptive
scoring on most groups, you'd set @code{gnus-use-adaptive-scoring} to
@code{t}, and insert an @code{(adapt ignore)} in the groups where you do
not want adaptive scoring.  If you only want adaptive scoring in a few
groups, you'd set @code{gnus-use-adaptive-scoring} to @code{nil}, and
insert @code{(adapt t)} in the score files of the groups where you want
it. 
@item local
@cindex local variables
The value of this entry should be a list of @code{(VAR VALUE)} pairs.
Each @var{var} will be made buffer-local to the current summary buffer,
and set to the value specified.  This is a convenient, if albeit
strange, way of setting variables in some groups, and you don't like
hooks much.
@end table

@node Score File Editing
@subsection Score File Editing

You normally enter all scoring commands from the summary buffer, but you
might feel the urge to edit them by hand as well, so we've supplied you
with a mode for that.  

It's simply a slightly customized @code{emacs-lisp} mode, with these
additional commands:

@table @kbd
@item C-c C-c
@kindex C-c C-c (Score)
@findex gnus-score-edit-done
Save the changes you have made and return to the summary buffer
(@code{gnus-score-edit-done}). 
@item C-c C-d
@kindex C-c C-d (Score)
@findex gnus-score-edit-insert-date
Insert the current date in numerical format
(@code{gnus-score-edit-insert-date}).  This is really the day number, if
you were wondering.
@end table

@node Adaptive Scoring
@subsection Adaptive Scoring
@cindex adaptive scoring

If all this scoring is getting you down, Gnus has a way of making it all
happen automatically - as if by magic.  Or rather, as if by artificial
stupidity, to be precise.

@vindex gnus-use-adaptive-scoring
When you read an article, or mark an article as read, or kill an
article, you leave marks behind.  On exit from the group, Gnus can sniff
these marks and add score elements depending on what marks it finds.
You turn on this ability by setting @code{gnus-use-adaptive-scoring} to
@code{t}. 

@vindex gnus-default-adaptive-score-alist
To give you complete control over the scoring process, you can customize
the @code{gnus-default-adaptive-score-alist} variable.  By default, it
looks something like this:

@lisp
(defvar gnus-default-adaptive-score-alist
  '((gnus-unread-mark)
    (gnus-ticked-mark (from 4))
    (gnus-dormant-mark (from 5))
    (gnus-del-mark (from -4) (subject -1))
    (gnus-read-mark (from 4) (subject 2))
    (gnus-expirable-mark (from -1) (subject -1))
    (gnus-killed-mark (from -1) (subject -3))
    (gnus-kill-file-mark)
    (gnus-catchup-mark (from -1) (subject -1))))
@end lisp

As you see, each element in this alist has a mark as a key (either a
variable name or a "real" mark - a character).  Following this key is a
random number of header/score pairs.  

To take @code{gnus-del-mark} as an example - this alist says that all
articles that have that mark (i.e., are marked with @samp{D}) will have a
score entry added to lower based on the @code{From} header by -4, and
lowered by @code{Subject} by -1.  Change this to fit your prejudices. 

If you use this scheme, you should set @code{mark-below} to something
small - like -300, perhaps, to avoid having small random changes result
in articles getting marked as read.

After using adaptive scoring for a week or so, Gnus should start to
become properly trained and enhance the authors you like best, and kill
the authors you like least, without you having to say so explicitly. 

You can control what groups the adaptive scoring is to be performed on
by using the score files (@pxref{Score File Format}).  This will also
let you use different rules in different groups.

@vindex gnus-adaptive-file-suffix
The adaptive score entries will be put into a file where the name is the
group name with @code{gnus-adaptive-file-suffix} appended.

@vindex gnus-score-exact-adapt-limit
When doing adaptive scoring, substring matching would probably give you
the best results in most cases.  However, if the header one matches is
short, the possibility for false positives is great, so if the length of
the match is less than @code{gnus-score-exact-adapt-limit}, exact
matching will be used.  If this variable is @code{nil}, which it is by
default, exact matching will always be used to avoid this problem. 

@node Scoring Tips
@subsection Scoring Tips
@cindex scoring tips

@table @dfn
@item Crossposts
If you want to lower the score of crossposts, the line to match on is
the @code{Xref} header.
@lisp
("xref" (" talk.politics.misc:" -1000))
@end lisp
@item Multiple crossposts
If you want to lower the score of articles that have been crossposted to
more than, say, 3 groups:
@lisp
("xref" (" +[^ ]+:[0-9]+ +[^ ]+:[0-9]+ +[^ ]+:[0-9]+" -1000 nil r))
@end lisp
@item Matching on the body
This is generally not a very good idea - it takes a very long time.
Gnus actually has to fetch each individual article from the server.  But
you might want to anyway, I guess.  Even though there are three match
keys (@code{Head}, @code{Body} and @code{All}), you should choose one
and stick with it in each score file.  If you use any two, each article
will be fetched @emph{twice}.  If you want to match a bit on the
@code{Head} and a bit on the @code{Body}, just use @code{All} for all
the matches.  
@item Marking as read
You will probably want to mark articles that has a score below a certain
number as read.  This is most easily achieved by putting the following
in your @file{all.SCORE} file:
@lisp
((mark -100))
@end lisp
You may also consider doing something similar with @code{expunge}.  
@end table

@node Reverse Scoring
@subsection Reverse Scoring
@cindex reverse scoring

If you want to keep just articles that have @samp{Sex with Emacs} in the
subject header, and expunge all other articles, you could put something
like this in your score file:

@lisp
(("subject"
  ("Sex with Emacs" 2))
 (mark 1)
 (expunge 1))
@end lisp

So, you raise all articles that match @samp{Sex with Emacs} and mark the
rest as read, and expunge them to boot.

@node Global Score Files
@subsection Global Score Files
@cindex global score files

Sure, other newsreaders have "global kill files".  These are usually
nothing more than a single kill file that applies to all groups, stored
in the user's home directory.  Bah!  Puny, weak newsreaders!

What I'm talking about here are Global Score Files.  Score files from
all over the world, from users everywhere, uniting all nations in one
big, happy score file union!  Ange-score!  New and untested!

@vindex gnus-global-score-files
All you have to do to use other people's score files is to set the
@code{gnus-global-score-files} variable.  One entry for each score file,
or each score file directory.  Gnus will decide by itself what score
files are applicable to which group.

Say you want to use all score files in the
@file{/ftp@@ftp.some-where:/pub/score} directory and the single score
file @file{/ftp@@ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE}:

@lisp
(setq gnus-global-score-files
      '("/ftp@@ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE"
        "/ftp@@ftp.some-where:/pub/score/"))
@end lisp

@findex gnus-score-search-global-directories
Simple, eh?  Directory names must end with a @samp{/}.  These
directories are typically scanned only once during each Gnus session.
If you feel the need to manually re-scan the remote directories, you can
use the @code{gnus-score-search-global-directories} command.

Note that, at present, using this option will slow down group entry
somewhat.  (That is - a lot.)

If you want to start maintaining score files for other people to use,
just put your score file up for anonymous ftp and announce it to the
world.  Become a retro-moderator!  Participate in the retro-moderator
wars sure to ensue, where retro-moderators battle it out for the
sympathy of the people, luring them to use their score files on false
premises!  Yay!  The net is saved!

Here are some tips for the would-be retro-moderator, off the top of my
head: 

@itemize @bullet
@item 
Articles that are heavily crossposted are probably junk. 
@item
To lower a single inappropriate article, lower by @code{Message-Id}.
@item
Particularly brilliant authors can be raised on a permanent basis. 
@item
Authors that repeatedly post off-charter for the group can safely be
lowered out of existence.
@item
Set the @code{mark} and @code{expunge} atoms to obliterate the nastiest
articles completely.
@item 
Use expiring score entries to keep the size of the file down.  You
should probably have a long expiry period, though, as some sites keep
old articles for a long time.
@end itemize

... I wonder whether other newsreaders will support global score files
in the future.  @emph{Snicker}.  Yup, any day now, newsreaders like Blue
Wave, xrn and 1stReader are bound to implement scoring.  Should we start
holding our breath yet?

@node Kill Files
@subsection Kill Files
@cindex kill files

(ding) Gnus still supports those pesky old kill files.  In fact, the
kill file entries can now be expiring, which is something I wrote before
Per thought of doing score files, so I've left the code in there.

In short, kill processing is a lot slower (and I do mean @emph{a lot})
than score processing, so it might be a good idea to rewrite your kill
files into score files.

Anyway, a kill file is a normal @code{emacs-lisp} file.  You can put any
forms into this file, which means that you can use kill files as some
sort of primitive hook function to be run on group entry, even though
that isn't a very good idea.

Normal kill files look like this:

@lisp
(gnus-kill "From" "Lars Ingebrigtsen")
(gnus-kill "Subject" "ding")
(gnus-expunge "X")
@end lisp

This will mark every article written by me as read, and remove them from
the summary buffer.  Very useful, you'll agree.

Other programs use a totally different kill file syntax.  If Gnus
encounters what looks like a @code{rn} kill file, it will take a stab at
interpreting it. 

Two functions for editing a GNUS kill file:

@table @kbd
@item V k
@kindex V k (Summary)
@findex gnus-summary-edit-local-kill
Edit this group's kill file (@code{gnus-summary-edit-local-kill}).

@item V K
@kindex V K (Summary)
@findex gnus-summary-edit-global-kill
Edit the general kill file (@code{gnus-summary-edit-global-kill}).
@end table

@vindex gnus-kill-file-name
A kill file for the group @samp{soc.motss} is normally called
@file{soc.motss.KILL}.  The suffix appended to the group name to get
this file name is detailed by the @code{gnus-kill-file-name} variable.
The "global" kill file (not in the score file sense of "global", of
course) is called just @file{KILL}.

@vindex gnus-kill-save-kill-file
If @code{gnus-kill-save-kill-file} is non-@code{nil}, Gnus will save the
kill file after processing, which is necessary if you use expiring
kills. 


@node Mail Group Commands
@section Mail Group Commands
@cindex mail group commands

Some commands only make sense in mail groups.  If these commands are
illegal in the current group, they will raise a hell and let you know.

All these commands (except the expiry and edit commands) use the
process/prefix convention (@pxref{Process/Prefix}).

@table @kbd
@item B e
@kindex B e (Summary)
@findex gnus-summary-expire-articles
Expire all expirable articles in the group
(@code{gnus-summary-expire-articles}).

@item B M-C-e
@kindex B M-C-e (Summary)
@findex gnus-summary-expire-articles-now
Expunge all the expirable articles in the group
(@code{gnus-summary-expire-articles-now}). This means that @strong{all}
articles that are eligeble for expiry in the current group will
disappear forever into that big @file{/dev/null} in the sky.

@item B DEL
@kindex B DEL (Summary)
@findex gnus-summary-delete-articles
Delete the mail article.  This is "delete" as in "delete it from your
disk forever and ever, never to return again." Use with caution.
(@code{gnus-summary-delete-article}).

@item B m
@kindex B m (Summary)
@cindex move mail
@findex gnus-summary-move-article
Move the article from one mail group to another
(@code{gnus-summary-move-article}). 

@item B c
@kindex B c (Summary)
@cindex copy mail
@findex gnus-summary-copy-article
Copy the article from one group (mail group or not) to a mail group
(@code{gnus-summary-copy-article}).

@item B i
@kindex B i (Summary)
@findex gnus-summary-import-article
Import a random file into the current mail newsgroup
(@code{gnus-summary-import-article}).  You will be prompted for a file
name, a @code{From} header and a @code{Subject} header.

@item B r
@kindex B r (Summary)
@findex gnus-summary-respool-article
Respool the mail article (@code{gnus-summary-move-article}).

@item B w
@itemx e
@kindex B w (Summary)
@kindex e (Summary)
@findex gnus-summary-edit-article
@kindex C-c C-c (Article)
Edit the current article (@code{gnus-summary-edit-article}).  To finish
editing and make the changes permanent, type @kbd{C-c C-c}
(@kbd{gnus-summary-edit-article-done}).

@item B q
@kindex B q (Summary)
@findex gnus-summary-fancy-query
If you are using fancy splitting, this command will tell you where an
article would go (@code{gnus-summary-fancy-query}). 
@end table

@node Various Summary Stuff
@section Various Summary Stuff

@menu
* Group Information::                 Information oriented commands.
* Searching for Articles::            Multiple article commands.
* Really Various Summary Commands::   Those pesky non-conformant commands.
@end menu

@vindex gnus-summary-prepare-hook
@code{gnus-summary-prepare-hook} is called after the summary buffer has
been generated.  You might use it to, for instance, highlight lines or
modify the look of the buffer in some other ungodly manner.  I don't
care.

@node Group Information
@subsection Group Information

@table @kbd
@item H f
@kindex H f (Summary)
@findex gnus-summary-fetch-faq
@vindex gnus-group-faq-directory
Try to fetch the FAQ (list of frequently asked questions) for the
current group (@code{gnus-summary-fetch-faq}).  Gnus will try to get the
FAQ from @code{gnus-group-faq-directory}, which is usually a directory
on a remote machine. @code{ange-ftp} will be used for fetching the file.
@item H d
@kindex H d (Summary)
@findex gnus-summary-describe-group
Give a brief description of the current group
(@code{gnus-summary-describe-group}).  If given a prefix, force
rereading the description from the server.
@item H h
@kindex H h (Summary)
@findex gnus-summary-describe-briefly
Give a very brief description of the most important summary keystrokes
(@code{gnus-summary-describe-briefly}). 
@item H i
@kindex H i (Summary)
@findex gnus-info-find-node
Go to the Gnus info node (@code{gnus-info-find-node}).
@end table

@node Searching for Articles
@subsection Searching for Articles

@table @kbd
@item V C-s
@kindex V C-s (Summary)
@findex gnus-summary-search-article-forward
Search through all subsequent articles for a regexp
(@code{gnus-summary-search-article-forward}). 
@item V C-r
@kindex V C-r (Summary)
@findex gnus-summary-search-article-backward
Search through all previous articles for a regexp
(@code{gnus-summary-search-article-backward}). 
@item V &
@kindex V & (Summary)
@findex gnus-summary-execute-command
This command will prompt you for a header field, a regular expression to
match on this field, and a command to be executed if the match is made
(@code{gnus-summary-execute-command}).
@item V u
@kindex V u (Summary)
@findex gnus-summary-universal-argument
Perform any operation on all articles that have been marked with
the process mark (@code{gnus-summary-universal-argument}).
@end table

@node Really Various Summary Commands
@subsection Really Various Summary Commands

@table @kbd
@item V D
@kindex V D (Summary)
@findex gnus-summary-enter-digest-group
If the current article is a digest, you might use this command to enter
you into a group based on the current digest to ease reading
(@code{gnus-summary-enter-digest-group}).
@item V T
@kindex V T (Summary)
@findex gnus-summary-toggle-truncation
Toggle truncation of summary lines (@code{gnus-summary-toggle-truncation}).
@item V e
@kindex V e (Summary)
@findex gnus-summary-expand-window
Expand the summary buffer window (@code{gnus-summary-expand-window}).
If given a prefix, force an @code{article} window configuration. 
@end table

@node The Article Buffer
@chapter The Article Buffer
@cindex article buffer

The articles are displayed in the article buffer, of which there is only
one.  All the summary buffer share the same article buffer.

@menu
* Hiding Headers::        Deciding what headers should be displayed.
* Using Mime::            Pushing articles through @sc{mime} before reading them.
* Customizing Articles::  Tailoring the look of the articles.
* Article Keymap::        Keystrokes available in the article buffer
* Misc Article::          Other stuff.
@end menu

@node Hiding Headers
@section Hiding Headers
@cindex hiding headers
@cindex deleting headers

The top section of each article is the @dfn{head}.  (The rest is the
@dfn{body}, but you may have guessed that already.)

@vindex gnus-show-all-headers
There is a lot of useful information in the head: the name of the person
who wrote the article, the date it was written and the subject of the
article.  That's well and nice, but there's also lots of information
most people do not want to see - what systems the article has passed
through before reaching you, the @code{Message-Id}, the
@code{References}, etc. ad nauseum - and you'll probably want to get rid
of some of those lines.  If you want to keep all those lines in the
article buffer, you can set @code{gnus-show-all-headers} to @code{t}.

Gnus provides you with two variables for sifting headers:

@table @code
@item gnus-visible-headers
@vindex gnus-visible-headers
If this variable is non-@code{nil}, it should be a regular expression
that says what headers you wish to keep in the article buffer.  All
headers that do not match this variable will be hidden.

For instance, if you only want to see the name of the person who wrote
the article and the subject, you'd say:

@lisp
(setq gnus-visible-headers "^From:\\|^Subject:")
@end lisp

@item gnus-ignored-headers
@vindex gnus-ignored-headers
This variable is the reverse of @code{gnus-visible-headers}.  If this
variable is set (and @code{gnus-visible-headers} is @code{nil}), it
should be a regular expression that matches all lines that you want to
hide.  All lines that do not match this variable will remain visible.

For instance, if you just want to get rid of the @code{References} line
and the @code{Xref} line, you might say:

@lisp
(setq gnus-ignored-headers "^References:\\|^Xref:")
@end lisp

Note that if @code{gnus-visible-headers} is non-@code{nil}, this
variable will have no effect.
@end table

@vindex gnus-sorted-header-list
Gnus can also sort the headers for you.  (It does this by default.)  You
can control the sorting by setting the @code{gnus-sorted-header-list}
variable.  It is a list of regular expressions that says in what order
the headers are to be displayed.

For instance, if you want the name of the author of the article first,
and then the subject, you might say something like:

@lisp
(setq gnus-sorted-header-list '("^From:" "^Subject:"))
@end lisp

Any headers that are to remain visible, but are not listed in this
variable, will be displayed in random order after all the headers that
are listed in this variable.

@node Using Mime
@section Using Mime
@cindex @sc{mime}

Mime is a standard for waving your hands through the air, aimlessly,
while people stand around yawning.

@sc{mime}, however, is a standard for encoding your articles, aimlessly,
while all newsreaders die of fear.

@sc{mime} may specify what character set the article uses, the encoding
of the characters, and it also makes it possible to embed pictures and
other naughty stuff in innocent-looking articles.

@vindex gnus-show-mime
@vindex gnus-show-mime-method
Gnus handles @sc{mime} by shoving the articles through
@code{gnus-show-mime-method}, which is @code{metamail-buffer} by
default.  If @code{gnus-strict-mime} is non-@code{nil}, the @sc{mime}
method will only be used it there are @sc{mime} headers in the article.
Set @code{gnus-show-mime} to @code{t} if you want to use @sc{mime} all
the time; it might be best to just use the toggling functions from the
summary buffer to avoid getting nasty surprises. (For instance, you
enter the group @samp{alt.sing-a-long} and, before you know it,
@sc{mime} has decoded the sound file in the article and some horrible
sing-a-long song comes streaming out out your speakers, and you can't
find the volume button, because there isn't one, and people are starting
to look at you, and you try to stop the program, but you can't, and you
can't find the program to control the volume, and everybody else in the
room suddenly decides to look at you disdainfully, and you'll feel
rather stupid.)

Any similarity to real events and people is purely coincidental.  Ahem.

@node Customizing Articles
@section Customizing Articles
@cindex article customization

@vindex gnus-article-display-hook
The @code{gnus-article-display-hook} is called after the article has
been inserted into the article buffer.  It is meant to handle all
treatment of the article before it is displayed.  By default it contains
@code{gnus-article-hide-headers}, which hides unwanted headers.

@findex gnus-article-subcite
@findex gnus-article-hide-signature
@findex gnus-article-hide-citation
Other useful functions you might add to this hook is:

@table @code
@item gnus-article-hide-citation
Hide all cited text.
@item gnus-article-hide-signature
Umn, hides the signature.
@item gnus-article-treat-overstrike
Treat @samp{^H_} in a reasonable manner.
@item gnus-article-maybe-highlight
Do fancy article highlighting.
@item gnus-article-remove-cr
Removes trailing carriage returns.
@item gnus-article-de-quoted-unreadable
Do naive decoding of articles encoded with Quoted-Printable.
@item gnus-article-display-x-face
Displays any X-Face headers.
@end table

You can, of course, write your own functions.  The functions are called
from the article buffer, and you can do anything you like, pretty much.
There is no information that you have to keep in the buffer - you can
change everything.  However, you shouldn't delete any headers.  Instead
make them invisible if you want to make them go away.

@node Article Keymap
@section Article Keymap

Most of the keystrokes in the summary buffer can also be used in the
article buffer.  They should behave as if you typed them in the summary
buffer, which means that you don't actually have to have a summary
buffer displayed while reading.  You can do it all from the article
buffer.

A few additional keystrokes are available:

@table @kbd
@item SPACE
@kindex SPACE (Article)
@findex gnus-article-next-page
Scroll forwards one page (@code{gnus-article-next-page}).
@item DEL
@kindex DEL (Article)
@findex gnus-article-prev-page
Scroll backwards one page (@code{gnus-article-prev-page}).
@item C-c ^
@kindex C-c ^ (Article)
@findex gnus-article-refer-article
If point is in the neighborhood of a @code{Message-Id} and you press
@kbd{r}, Gnus will try to get that article from the server
(@code{gnus-article-refer-article}).
@item C-c C-m
@kindex C-c C-m (Article)
@findex gnus-article-mail
Send a reply to the address near point (@code{gnus-article-mail}). 
@item C-c C-M
@kindex C-c C-M (Article)
@findex gnus-article-mail-with-original
Send a reply to the address near point and include the original article
(@code{gnus-article-mail-with-original}). 
@item s
@kindex s (Article)
@findex gnus-article-show-summary
Reconfigure the buffers so that the summary buffer becomes visible
(@code{gnus-article-show-summary}).
@item ?
@kindex ? (Article)
@findex gnus-article-describe-briefly
Give a very brief description of the available keystrokes
(@code{gnus-article-describe-briefly}). 
@end table

@node Misc Article
@section Misc Article

@table @code
@vindex gnus-article-prepare-hook
@item gnus-article-prepare-hook
This hook is called right after the article has been inserted into the
article buffer.  It is mainly intended for functions that do something
depending on the contents; it should probably not be used for changing
the contents of the article buffer.
@vindex gnus-article-display-hook
@item gnus-article-display-hook
This hook is called as the last thing when displaying an article, and is
intended for modifying the contents of the buffer, doing highlights,
hiding headers, and the like.
@vindex gnus-article-mode-line-format
@item gnus-article-mode-line-format
This variable is a format string along the same lines as
@code{gnus-summary-mode-line-format}.  It accepts exactly the same
format specifications as that variable.
@vindex gnus-break-pages
@item gnus-break-pages
Controls whether @dfn{page breaking} is to take place.  If this variable
is non-@code{nil}, the articles will be divided into pages whenever a
page delimiter appears in the article.  If this variable is @code{nil},
paging will not be done.
@item gnus-page-delimiter
@vindex gnus-page-delimiter
This is the delimiter mentioned above.  By default, it is @samp{^L}
(form linefeed).
@end table

@node The Server Buffer
@chapter The Server Buffer

Traditionally, a @dfn{server} is a machine or a piece of software that
one connects to, and then requests information from.  Gnus does not
connect directly to any real servers, but does all transactions through
one backend or other.  But that's just putting one layer more between
the actual media and Gnus, so we might just as well say that each
backend represents a virtual server.

For instance, the @code{nntp} backend may be used to connect to several
different actual nntp servers, or, perhaps, to many different ports on
the same actual nntp server.  You tell Gnus which backend to use, and
what parameters to set by specifying a @dfn{select method}.  

These select methods specifications can sometimes become quite
complicated - say, for instance, that you want to read from the nntp
server @samp{news.funet.fi} on port number @samp{13}, which hangs if
queried for @sc{nov} headers and has a buggy select.  Ahem.  Anyways, if
you had to specify that for each group that used this server, that would
be too much work, so Gnus offers a way of putting names to methods,
which is what you do in the server buffer.

@menu
* Server Buffer Format::   You can customize the look of this buffer.
* Server Commands::        Commands to manipulate servers.
* Example Methods::        Examples server specifications.
* Servers & Methods::      You can use server names as select methods.
@end menu

@node Server Buffer Format
@section Server Buffer Format
@cindex server buffer format

@vindex gnus-server-line-format
You can change the look of the server buffer lines by changing the
@code{gnus-server-line-format} variable.  This is a @code{format}-like
variable, with some simple extensions:

@table @samp
@item h 
How the news is fetched - the backend name.
@item n
The name of this server.
@item w
Where the news is to be fetched from - the address.
@end table

@node Server Commands
@section Server Commands
@cindex server commands

@table @kbd
@item SPC
Browse the current server (@code{gnus-server-read-server}).
@item q
Return to the group buffer (@code{gnus-server-exit}).
@item l
List all servers (@code{gnus-server-list-servers}).
@item k
Kill the current server (@code{gnus-server-kill-server}).
@item y
Yank the previously killed server (@code{gnus-server-yank-server}).
@item c
Copy the current server (@code{gnus-server-copy-server}).
@item a
Add a new server (@code{gnus-server-add-server}).
@item e
Edit a server (@code{gnus-server-edit-server}).
@end table

@node Example Methods
@section Example Methods

Most select methods are pretty simple and self-explanatory: 

@lisp
(nntp "news.funet.fi")
@end lisp

Reading directly from the spool is even simpler:

@lisp
(nnspool "")
@end lisp

As you can see, the first element in a select method is the name of the
backend, and the second is the @dfn{address}, or @dfn{name}, if you
will. 

After these two elements, there may be a random number of @var{(variable
form)} pairs.

To go back to the first example - imagine that you want to read from
port @code{15} from that machine.  This is what the select method should
look like then:

@lisp
(nntp "news.funet.fi" (nntp-port-number 15))
@end lisp

You should read the documentation to each backend to find out what
variables are relevant, but here's an @code{nnmh} example. 

@code{nnmh} is a mail backend that reads a spool-like structure.  Say
you have two structures that you wish to access: One is your private
mail spool, and the other is a public one.  Here's the possible spec for
you private mail:

@lisp
(nnmh "private" (nnmh-directory "~/private/mail/"))
@end lisp

(This server is then called @samp{private}, but you may have guessed
that. 

Here's the method for the public spool:

@lisp
(nnmh "public" 
      (nnmh-directory "/usr/information/spool/") 
      (nnmh-get-new-mail nil))
@end lisp

@node Servers & Methods
@section Servers & Methods



@node Various
@chapter Various

@menu
* Interactive::                Making Gnus ask you many questions.
* Windows Configuration::      Configuring the Gnus buffer windows.
* Buttons::                    Get tendonitis in ten easy steps!
* Various Various::            Things that are really various.
@end menu

@node Interactive
@section Interactive
@cindex interaction

@table @code
@item gnus-novice-user
@vindex gnus-novice-user
If this variable is non-@code{nil}, you are either a newcomer to the
World of Usenet, or you are very cautious, which is a nice thing to be,
really.  You will be given questions of the type "Are you sure you want
to do this?" before doing anything dangerous.
@item gnus-expert-user
@vindex gnus-expert-user
If this variable is non-@code{nil}, you will never ever be asked any
questions by Gnus.  It will simply assume you know what your are doing,
no matter how strange.
@item gnus-interactive-catchup
@vindex gnus-interactive-catchup
Require confirmation before catching up a group if non-@code{nil}.
@item gnus-interactive-post
@vindex gnus-interactive-post
If non-@code{nil}, the user will be prompted for a group name when
posting an article.
@item gnus-interactive-exit
@vindex gnus-interactive-exit
Require confirmation before exiting Gnus.
@end table

@node Windows Configuration
@section Windows Configuration
@cindex windows configuration

No, there's nothing here about X, so be quiet.

@table @code
@item gnus-use-full-window
@vindex gnus-use-full-window
If non-@code{nil}, Gnus will delete all other windows and occupy the
entire Emacs screen by itself.  It is @code{t} by default.

@item gnus-buffer-configuration
@vindex gnus-buffer-configuration
This variable describes how much space each Gnus buffer should be given.
Here's an excerpt of this variable:

@lisp
((group ([group 1.0 point] 
         (if gnus-carpal [group-carpal 4])))
 (article ([summary 0.25 point] 
           [article 1.0])))
@end lisp

This is an alist.  The @dfn{key} is a symbol that names some action or
other.  For instance, when displaying the group buffer, the window
configuration function will use @code{group} as the key.  A full list of
possible names is listed below.

The @dfn{value} is a @dfn{rule} that says how much space each buffer
should occupy.  To take the @code{article} rule as an example -

@lisp
(article ([summary 0.25 point] 
          [article 1.0]))
@end lisp

This rule says that the summary buffer should occupy 25% of the screen,
and that it is placed over the article buffer.  As you may have noticed,
100% + 25% is actually 125% (yup, I saw y'all reaching for that
calculator there).  However, the special number @code{1.0} is used to
signal that this buffer should soak up all the rest of the space
avaiable after the rest of the buffers have taken whatever they need.  
There should be only one buffer with the @code{1.0} size spec.

Point will be put in the buffer that has the optional third element
@code{point}. 

Here's a more complicated example:

@lisp
(article ([group 4]
          [summary 0.25 point]
          (if gnus-carpal [summary-carpal 4])
          [article 1.0])
@end lisp

If the size spec is an integer instead of a floating point number, 
then that number will be used to say how many lines a buffer should
occupy, not a percentage.

If an element is a list instead of a vector, this list will be
@code{eval}ed.  If the result is non-@code{nil}, it will be used.  This
means that there will be three buffers if @code{gnus-carpal} is
@code{nil}, and four buffers if @code{gnus-carpal} is non-@code{nil}. 

Not complicated enough for you?  Well, try this on for size:

@lisp
(article ([group 1.0]
          [gnus-carpal 4])
         ((horizontal 0.5)
          [summary 0.25 point]
          [summary-carpal 4]
          [article 1.0]))
@end lisp

Whoops.  Two buffers with the mystery 100% tag.  And what's that
@code{horizontal} thingie?  

If the first element in one of the rule lists is a list with
@code{horizontal} as the first element, Gnus will split the window
horizontally, giving you two windows side-by-side.  Inside each of these
strips you may carry on all you like in the normal fashion.  The number
following @code{horizontal} says what percentage of the screen is to be
given to this strip.  

For each horizontal split, there @emph{must} be one element that has the
100% tag.  The splitting is never accurate, and this buffer will eat any
leftover lines from the splits. 

Here's a list of all possible keys:

@code{group}, @code{summary}, @code{article}, @code{server},
@code{browse}, @code{group-mail}, @code{summary-mail},
@code{summary-reply}, @code{info}, @code{summary-faq},
@code{edit-group}, @code{edit-server}, @code{reply}, @code{reply-yank},
@code{followup}, @code{followup-yank}, @code{edit-score}.  

@findex gnus-add-configuration
Since this variable is so long and complicated, there's a function you
can use to ease changing the config of a single setting:
@code{gnus-add-configuration}.  If, for instance, you want to change the
@code{article} setting, you could say:

@lisp
(gnus-add-configuration
 '(article ([group 4]
            [summary .25 point] 
            [article 1.0])))
@end lisp

@end table

@node Buttons
@section Buttons
@cindex buttons
@cindex mouse
@cindex click

Those new-fangled @dfn{mouse} contraptions is very popular with the
young, hep kids who don't want to learn the proper way to do things
these days.  Why, I remember way back in the summer of '89, when I was
using Emacs on a Tops 20 system.  Three hundred users on one single
machine, and every user was running Simula compilers.  Bah!

Right.

@vindex gnus-carpal
Well, you can make Gnus display bufferfuls of buttons you can click to
do anything by setting @code{gnus-carpal} to @code{t}.  Pretty simple,
really.  Tell the chiropractor I sent you.


@table @code
@item gnus-carpal-mode-hook
@vindex gnus-carpal-mode-hook
Hook run in all carpal mode buffers.
@item gnus-carpal-button-face
@vindex gnus-carpal-button-face
Face used on buttons.
@item gnus-carpal-group-buffer-buttons
@vindex gnus-carpal-group-buffer-buttons
Buttons in the group buffer.
@item gnus-carpal-summary-buffer-buttons
@vindex gnus-carpal-summary-buffer-buttons
Buttons in the summary buffer.
@item gnus-carpal-server-buffer-buttons
@vindex gnus-carpal-server-buffer-buttons
Buttons in the server buffer.
@item gnus-carpal-browse-buffer-buttons
@vindex gnus-carpal-browse-buffer-buttons
Buttons in the browse buffer.
@end table

All the @code{buttons} variables are lists.  The elements in these list
is either a cons cell where the car contains a text to be displayed and
the cdr contains a function symbol, or a simple string.

@node Various Various
@section Various Various
@cindex mode lines
@cindex highlights

@table @code
@item gnus-verbose
@vindex gnus-verbose
This variable is an integer between zero and ten.  The higher the value,
the more messages will be displayed.  If this variable is zero, Gnus
will never flash any messages, if it is seven, most important messages
will be shown, and if it is ten, Gnus won't ever shut up, but will flash
so many messages it will make your head swim.
@item gnus-updated-mode-lines
@vindex gnus-updated-mode-lines
This is a list of buffers that should keep their mode lines updated.
The list may contain the symbols @code{group}, @code{article} and
@code{summary}.  If the corresponding symbol is present, Gnus will keep
that mode line updated with information that may be pertinent.  If this
variable is @code{nil}, screen refresh may be quicker.

@cindex display-time
@item gnus-mode-non-string-length
@vindex gnus-mode-non-string-length
By default, Gnus displays information on the current article in the mode
lines of the summary and article buffers.  The information Gnus wishes
to display (eg. the subject of the article) is often longer than the
mode lines, and therefore have to be cut off at some point.  This
variable says how long the other elements on the line is (i.e., the
non-info part).  If you put additional elements on the mode line (eg. a
clock), you should modify this variable:
@c Hook written by Keinonen Kari <kk85613@cs.tut.fi>.
@lisp
(add-hook 'display-time-hook
          (lambda ()
            (setq gnus-mode-non-string-length
                  (+ 21 (length display-time-string)))))
@end lisp

@item gnus-visual
@vindex gnus-visual
If @code{nil}, Gnus won't attempt to create menus or use fancy colors
or fonts.  This will also inhibit loading the @file{gnus-visual.el}
file.
@item gnus-mouse-face
@vindex gnus-mouse-face
This is the face (i.e., font) used for mouse highlighting in Gnus.  No
mouse highlights will be done if @code{gnus-visual} is @code{nil}.
@end table

@node Customization
@chapter Customization
@cindex general customization

All variables are properly documented elsewhere in this manual.  This
section is designed to give general pointers on how to customize Gnus
for some quite common situations.

@menu
* Slow NNTP Connection::      You run a local Emacs and get the news elsewhere.
* Slow Terminal Connection::  You run a remote Emacs.
* Little Disk Space::         You feel that having large setup files is icky.
* Slow Machine::              You feel like buying a faster machine.
@end menu

@node Slow NNTP Connection
@section Slow @sc{nntp} Connection

If you run Emacs on a machine locally, and get your news from a machine
over some very thin strings, you want to cut down on the amount of data
Gnus has to get from the @sc{nntp} server.

@table @code
@item gnus-read-active-file
Set this to @code{nil}, which will inhibit Gnus from requesting the
entire active file from the server.  This file is often v.  large.  You
also have to set @code{gnus-check-new-news} and
@code{gnus-check-bogus-newsgroups} to @code{nil} to make sure that Gnus
doesn't suddenly decide to fetch the active file anyway.
@item gnus-nov-is-evil
This one has to be @code{nil}.  If not, grabbing article headers from
the @sc{nntp} server will not be very fast.  Not all @sc{nntp} servers
support @sc{xover}; Gnus will detect this by itself.
@end table

@node Slow Terminal Connection
@section Slow Terminal Connection

Let's say you use your home computer for dialing up the system that
runs Emacs and Gnus.  If your modem is slow, you want to reduce the
amount of data that is sent over the wires as much as possible.

@table @code
@item gnus-auto-center-summary
Set this to @code{nil} to inhibit Gnus from recentering the summary
buffer all the time.
@item gnus-visible-headers
Cut down on the headers that are included in the articles to the
minimum.  You can, in fact, make do without them altogether - most of the
useful data is in the summary buffer, anyway.  Set this variable to
@samp{"^NEVVVVER"} or @samp{"From:"}, or whatever you feel you need.
@item gnus-article-display-hook
Set this hook to all the available hiding commands:
@lisp
(setq gnus-article-display-hook 
      '(gnus-article-hide-headers gnus-article-hide-signature
        gnus-article-hide-citation))
@end lisp
@item gnus-use-full-window
By setting this to @code{nil}, you can make all the windows smaller.
While this doesn't really cut down much generally, it means that you
have to see smaller portions of articles before deciding that you didn't
want to read them anyway.
@item gnus-thread-hide-subtree
If this is non-@code{nil}, all threads in the summary buffer will be
hidden initially.
@item gnus-updated-mode-lines
If this is @code{nil}, Gnus will not put information in the buffer mode
lines, which might save some time.
@end table

@node Little Disk Space
@section Little Disk Space

The startup files can get rather large, so you may want to cut their
sizes a bit if you are running out of space.

@table @code
@item gnus-save-newsrc-file
If this is @code{nil}, Gnus will never save @file{.newsrc} - it will
only save @file{.newsrc.eld}.  This means that you will not be able to
use any other newsreaders than Gnus.
@item gnus-save-killed-list
If this is @code{nil}, Gnus will not save the list of dead groups.  You
should also set @code{gnus-check-new-newsgroups} to @code{ask-server}
and @code{gnus-check-bogus-newsgroups} to @code{nil} if you set this
variable to @code{nil}.
@end table

@node Slow Machine
@section Slow Machine

If you have a slow machine, or are just really impatient, there are a
few things you can do to make Gnus run faster.

Set@code{gnus-check-new-newsgroups} and
@code{gnus-check-bogus-newsgroups} to @code{nil} to make startup faster.

Set @code{gnus-show-threads}, @code{gnus-use-cross-reference} and
@code{gnus-nov-is-evil} to @code{nil} to make entering and exiting the
summary buffer faster.

Set @code{gnus-article-display-hook} to @code{nil} to make article
processing a bit faster.

@node Troubleshooting
@chapter Troubleshooting
@cindex troubleshooting

(ding) Gnus works @emph{so} well straight out of the box - I can't
imagine any problems, really.

Ahem.

@enumerate
@item
Make sure your computer is switched on.
@item
Make sure that you really load the current Gnus version.  If you have
been running @sc{gnus}, you need to exit Emacs and start it up again before
Gnus will work.
@item
Try doing an @kbd{M-x gnus-version}.  If you get something that looks
like @samp{(ding) Gnus v0.46; nntp 4.0} you have the right files loaded.
If, on the other hand, you get something like @samp{NNTP 3.x} or
@samp{nntp flee}, you have some old @file{.el} files lying around.
Delete these.
@item
Read the help group (@kbd{M h} in the group buffer) for a FAQ and a
how-to. 
@end enumerate

If all else fails, report the problem as a bug,

@cindex bugs
@cindex reporting bugs

@kindex M-x gnus-bug
@findex gnus-bug
If you find a bug in (ding) Gnus, you can report it with the @kbd{M-x
gnus-bug} command. @kbd{M-x set-variable RET debug-on-error RET t RET},
and send me the backtrace. I will fix bugs, but I can only fix them if
you send me a precise description as to how to reproduce the bug.

@c If you just need help, you are better off asking on
@c @samp{gnu.emacs.gnus}.  

@node The End
@chapter The End

Well, that's the manual - you can get on with your life now.  Keep in
touch.  Say hello to your cats from me.  

My @strong{ghod} - I just can't stand goodbyes.  Sniffle.

Ol' Chuck Reznikoff said it pretty well, so I leave the floor to him:

@quotation
@strong{Te Deum}
@sp 1
Not because of victories @*
I sing,@*
having none,@*
but for the common sunshine,@*
the breeze,@*
the largess of the spring.
@sp 1
Not for victory@*
but for the day's work done@*
as well as I was able;@*
not for a seat upon the dais@*
but at the common table.@*
@end quotation

@node Index
@chapter Index
@printindex cp

@node Key Index
@chapter Key Index
@printindex ky

@summarycontents
@contents
@bye

\f
@c Local Variables:
@c outline-regexp: "@chap\\|@\\(sub\\)*section\\|@appendix \\|@appendix\\(sub\\)*sec\\|\^L"
@c End:

\1f