This is gnats.info, produced by makeinfo version 4.2 from gnats.texi.

START-INFO-DIR-ENTRY
* Keeping Track: (gnats).	GNU Problem Report Management System
END-INFO-DIR-ENTRY

   Copyright (C) 2002 Milan Zamazal Copyright (C) 1993, 1995, 2001 Free
Software Foundation, Inc.

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

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


File: gnats.info,  Node: Regexps,  Next: dbconfig recipes,  Prev: Access Control,  Up: Top

Querying using regular expressions
**********************************

   See also *Note Query expressions::.

   Unfortunately, we do not have room in this manual for a complete
exposition on regular expressions.  The following is a basic summary of
some regular expressions you might wish to use.

   _NOTE: When you use query expressions containing regular expressions
as part of an ordinary query-pr shell command line, you need to quote
them with `''', otherwise the shell will try to interpret the special
characters used, yielding highly unpredictable results._

   *Note Regular Expression Syntax: (regex)Regular Expression Syntax,
for details on regular expression syntax.  Also see *Note Syntax of
Regular Expressions: (emacs)Regexps, but beware that the syntax for
regular expressions in Emacs is slightly different.

   All search criteria options to `query-pr' rely on regular expression
syntax to construct their search patterns.  For example,

     query-pr --expr 'State="open"' --format full

matches all PRs whose `State' values match with the regular expression
`open'.

   We can substitute the expression `o' for `open', according to GNU
regular expression syntax.  This matches all values of `State' which
begin with the letter `o'.

   We see that

     query-pr --expr 'State="o"' --format full

   is equivalent to

     query-pr --expr 'State="open"' --format full

in this case, since the only value for `State' which matches the
expression `o' in a standard installation is `open'.  `State="o"' also
matches `o', `oswald', and even `oooooo', but none of those values are
valid states for a Problem Report in default GNATS installations.

   We can also use the expression operator `|' to signify a logical
`OR', such that

     query-pr --expr 'State="o|a"' --format full

matches all `open' or `analyzed' Problem Reports.

   Regular expression syntax considers a regexp token surrounded with
parentheses, as in `(REGEXP)', to be a "group".  This means that
`(ab)*' matches any number (including zero) of contiguous instances of
`ab'.  Matches include `', `ab', and `ababab'.

   Regular expression syntax considers a regexp token surrounded with
square brackets, as in `[REGEXP]', to be a "list".  This means that
`Char[(ley)(lene)(broiled)' matches any of the words `Charley',
`Charlene', or `Charbroiled' (case is significant; `charbroiled' is not
matched).

   Using groups and lists, we see that

     query-pr --expr 'Category="gcc|gdb|gas"' --format full

is equivalent to

     query-pr --expr 'Category="g(cc|db|as)"' --format full

and is also very similar to

     query-pr --expr 'Category="g[cda]"' --format full

with the exception that this last search matches any values which begin
with `gc', `gd', or `ga'.

   The `.' character is known as a "wildcard".  `.' matches on any
single character.  `*' matches the previous character (except
newlines), list, or group any number of times, including zero.
Therefore, we can understand `.*' to mean "match zero or more instances
of any character."

     query-pr --expr 'State=".*a"' --format full

matches all values for `State' which contain an `a'.  (These include
`analyzed' and `feedback'.)

   Another way to understand what wildcards do is to follow them on
their search for matching text.  By our syntax, `.*' matches any
character any number of times, including zero.  Therefore, `.*a'
searches for any group of characters which end with `a', ignoring the
rest of the field.  `.*a' matches `analyzed' (stopping at the first
`a') as well as `feedback'.

   _Note:_ When using `fieldtype:Text' or `fieldtype:Multitext' (*note
Query expressions::), you do not have to specify the token `.*' at the
beginning of your expression to match the entire field.  For the
technically minded, this is because these queries use `re_search'
rather than `re_match'.  `re_match' "anchors" the search at the
beginning of the field, while `re_search' does not anchor the search.

   For example, to search in the `>Description:' field for the text

     The defrobulator component returns a nil value.

we can use

     query-pr --expr 'fieldtype:Multitext="defrobulator.*nil"' --format full

   To also match newlines, we have to include the expression `(.|^M)'
instead of just a dot (`.').  `(.|^M)' matches "any single character
except a newline (`.') _or_ (`|') any newline (`^M')."  This means that
to search for the text

     The defrobulator component enters the bifrabulator routine
     and returns a nil value.

we must use

     query-pr --expr 'fieldtype:Multitext="defrobulator(.|^M)*nil"'
              --format full

   To generate the newline character `^M', type the following depending
on your shell:

`csh'
     `_control_-V _control_-M'

`tcsh'
     `_control_-V _control_-J'

`sh (_or_ bash)'
     Use the <RETURN> key, as in

          (.|
          )

   Again, see *Note Regular Expression Syntax: (regex)Regular
Expression Syntax, for a much more complete discussion on regular
expression syntax.


File: gnats.info,  Node: dbconfig recipes,  Next: Support,  Prev: Regexps,  Up: Top

`dbconfig' recipes
******************

   The `dbconfig' file (*Note The `dbconfig' file: dbconfig file) is
the heart of any GNATS installation.  It contains some very powerful
machinery, something which this appendix tries to illustrate.

   We provide a range of examples that are both intended to be useful in
their own right and to serve as starting points or building blocks for
your own modifications.

Provide Gnatsweb URL in initial response
........................................

   Sites that have Gnatsweb installed may wish to modify the response
e-mail which is sent to the submitter of a PR so that it includes a URL
where the status of the PR can be monitored.  In order to allow this,
you should first create an entry in `gnatsd.user_access' which allows
viewing of PRs in your database (*Note The `gnatsd.user_access' file:
gnatsd.user_access.)

   Next, locate the entry `mail-format "initial-response-to-submitter"'
in the `dbconfig' file of your database and add the following _before_
the line reading "The individual assigned..." in the `body' section:


\nYou can follow the status of this report on\n\
http://hostname/cgi-bin/scriptname?\n\
cmd=view&database=dbname&user=username&\n\
password=passwd&pr=%s\n\n\

Substitute `hostname', `cgi-bin' and `scriptname' as appropriate for
the setup of your web server.  The part before the `?' would typically
look something like `http://www.example.com/cgi-bin/gnatsweb.pl'.
Substitute the name of your database for `dbname', and the username and
password of the user with `view' rights for `username' and `passwd'.

Next, add a `Number' to the `fields' list statement inside the `body'
so it reads as follows:


fields { "Category" "Number" "Number" "Responsible"
         "Category" "Responsible" "Synopsis"
         "Arrival-Date" }

State full name of responsible in initial response
..................................................

   The initial e-mail response to the submitter of a PR identifies the
responsible person assigned to the PR as follows: "The individual
assigned to look at your report is: GNATS USERNAME".  Some sites may
wish to modify this so that the full name of the responsible person is
used instead of the GNATS user name.

   The full name is contained in the `fullname' subfield of the user's
entry in the `responsible' file and can be accessed as
`Responsible[fullname]' (*note Enumerated field administrative files:
administrative files..)

   The change is achieved by editing the `dbconfig' item `mail-format
"initial-response-to-submitter"' and changing the `fields' part of the
`Body' from


fields { "Category" "Number" "Responsible"
         "Category" "Responsible" "Synopsis"
         "Arrival-Date" }

to


fields { "Category" "Number" "Responsible[fullname]"
         "Category" "Responsible" "Synopsis"
         "Arrival-Date" }

Append-only Audit-Trail
.......................

   The Audit-Trail of a PR is by default editable.  For some
applications, one might want to make the Audit-Trail append-only, so it
provides a full and unchangeable case history.  Also by default, only
certain changes, such as change of state and change of responsible gets
recorded in the Audit-Trail.  In some cases, it might also be
convenient to have a way of inserting comments directly into the
Audit-Trail.

   The following procedure creates such an append-only Audit-Trail and
adds a PR field which makes it possible to register comments in the
Audit-Trail.

First, add the keyword `read-only' to the Audit-Trail field definition
in `dbconfig'.

Then, add the following field definition to `dbconfig':


field "Add-To-Audit-Trail" {
   description "Add a log entry to the Audit Trail"
   multitext { default "\n" }
   on-change  {
        add-audit-trail
        audit-trail-format {
        format "**** Comment added by %s on %s ****\n %s\n\n"
        fields { "$EditUserEmailAddr" "$CurrentDate" "$NewValue"
        }
        }
    }
    on-change {
        set-field "Add-To-Audit-Trail" { "\n" }
    }
}

Supporting GNATS "release-based" fields
.......................................

   When installing GNATS version 3.x, it was possible to choose whether
to enable three optional fields: `Quarter', `Keywords' and
`Date-Required'.  Default installations had these fields switched off,
and installations which had them were called "release-based".

   The default `dbconfig' shipped with GNATS version 4 or newer does
not have these fields, so if you are upgrading from an old
release-based system, you need to add the following field definitions to
your `dbconfig' file:


field "Quarter" {
    description "What quarter does the PR fall into?"
    text
    query-default inexact-regexp
    textsearch
}

field "Keywords" {
    description "Keywords used to index this PR"
    text
    query-default inexact-regexp
    textsearch
}

field "Date-Required" {
    description "Date that the PR must be fixed by"
    date
}

   A side note: Pre-release versions of GNATS 4 also had a field named
`Cases'.  For those who may need it, here is the field definition of
`Cases':


field "Cases" {
    text
    query-default inexact-regexp
    textsearch
}


File: gnats.info,  Node: Support,  Next: Index,  Prev: dbconfig recipes,  Up: Top

GNATS support
*************

   The GNATS home page is located at
<http://www.gnu.org/software/gnats>.  It contains all the important
references to the available information about GNATS and the related
software.

   There is also a special page dedicated to the GNATS development at
<http://savannah.gnu.org/projects/gnats>.

   There are several GNATS mailing lists.  The most important ones are:

<info-gnats@gnu.org>
     Announcements and other important information about GNATS and the
     related software.  This is a very low volume moderated list.

<bug-gnats@gnu.org>
     The bug reporting mailing list on the GNATS itself.  Please note
     that the preferred way to report GNATS bugs is to submit them via
     the web interface at
     <http://bugs.gnu.org/cgi-bin/gnatsweb.pl?database=gnats>.  New bug
     reports submitted via the web interface are copied to the mailing
     list automatically.

<help-gnats@gnu.org>
     General discussion about GNATS.  Anything related to GNATS (user
     questions, development, suggestions, etc.) can be discussed there.

   The complete list of GNATS related mailing lists is available from
the web page at <http://savannah.gnu.org/project/gnats>.

   When you report problems concerning GNATS itself, please do not
forget to provide especially the following information:

   * The GNATS version you are using.

   * The _exact_ way how to reproduce the bug.

   * Your configuration.

   * If you encounter a compilation or build problem, it is especially
     important to mention the operating system, compiler and possibly
     other build utilities you use.

   Providing this information in the initial report avoids further
unnecessary communication, saves our limited development resources and
helps to track down and fix the problem soon.


File: gnats.info,  Node: Index,  Prev: Support,  Up: Top

Index
*****

* Menu:

* -with-gnats-dblist-file:               Configure and make.
* -with-gnats-default-db:                Configure and make.
* -with-gnats-service:                   Configure and make.
* -with-gnats-user:                      Configure and make.
* -with-gnatsd-host-access-file:         Configure and make.
* -with-gnatsd-user-access-file:         Configure and make.
* -with-kerberos:                        Configure and make.
* -with-krb4:                            Configure and make.
* >Submitter-Id:                         using send-pr.
* _analyzed_ state:                      States.
* _change-request_ class:                Problem Report fields.
* _closed_ state:                        States.
* _critical_ severity problems:          Problem Report fields.
* _doc-bug_ class:                       Problem Report fields.
* _duplicate_ class:                     Problem Report fields.
* _feedback_ state:                      States.
* _high_ priority problems:              Problem Report fields.
* _low_ priority problems:               Problem Report fields.
* _medium_ priority problems:            Problem Report fields.
* _mistaken_ class:                      Problem Report fields.
* _non-critical_ severity problems:      Problem Report fields.
* _open_ state:                          States.
* _serious_ severity problems:           Problem Report fields.
* _support_ class:                       Problem Report fields.
* _suspended_ state:                     States.
* _sw-bug_ class:                        Problem Report fields.
* adding a problem category <1>:         mkcat.
* adding a problem category:             Management.
* adding and removing maintainers:       Management.
* adding another database:               Management.
* addresses file <1>:                    addresses file.
* addresses file:                        GNATS configuration.
* admin files:                           Admin files.
* administering GNATS:                   Management.
* administrative utilities:              Admin utils.
* age of PR:                             pr-age.
* alias for incoming Problem Reports:    Aliases.
* aliases:                               Aliases.
* appended-email-response:               Outgoing email formats.
* appending PRs <1>:                     using send-pr.
* appending PRs:                         Problem Report fields.
* arrival-date:                          Individual field configuration.
* Arrival-Date field:                    Problem Report fields.
* at:                                    Setting up the default database.
* at-pr:                                 at-pr.
* audit-mail:                            Outgoing email formats.
* audit-trail:                           Individual field configuration.
* Audit-Trail field:                     Problem Report fields.
* Audit-trail format:                    Audit-trail formats.
* autoload commands:                     Installing utils.
* automatic notification <1>:            at-pr.
* automatic notification:                States.
* BACK UP YOUR DATA:                     Management.
* bad Problem Reports:                   using send-pr.
* bug alias:                             Aliases.
* bug reporting:                         Support.
* building a new index:                  Management.
* building GNATS:                        Installation.
* building in a different directory:     Configure and make.
* builtin-name:                          Individual field configuration.
* bury-buffer:                           Emacs querying.
* business-day-hours:                    Overall database configuration.
* business-week-days:                    Overall database configuration.
* categories file <1>:                   rmcat.
* categories file <2>:                   mkcat.
* categories file <3>:                   categories file.
* categories file:                       GNATS configuration.
* category:                              Individual field configuration.
* Category field:                        Problem Report fields.
* category-dir-perms:                    Overall database configuration.
* check-db:                              check-db.
* Class field:                           Problem Report fields.
* classes file <1>:                      classes file.
* classes file:                          GNATS configuration.
* closed-date:                           Individual field configuration.
* command line options:                  send-pr from the shell.
* comment section in the PR template:    using send-pr.
* compiling the software:                Configure and make.
* confidential:                          Individual field configuration.
* Confidential field:                    Problem Report fields.
* confidentiality in PRs:                Problem Report fields.
* configure:                             Configure and make.
* configuring  GNATS:                    Installation.
* configuring and compiling the software: Configure and make.
* configuring GNATS for remote users:    Installing tools.
* configuring GNATS on a local network:  Installing tools.
* configuring GNATS on a network:        Installing tools.
* create-category-dirs:                  Overall database configuration.
* creating an account for the GNATS user: Configure and make.
* cron:                                  Setting up the default database.
* crontab:                               Setting up periodic jobs.
* current file:                          current file.
* daemon:                                Installing the daemon.
* database paradigm:                     Paradigm.
* database rationale:                    Introduction.
* database similarities:                 Fields.
* databases:                             GNATS configuration.
* databases file:                        databases file.
* datatype:                              Field datatypes.
* date:                                  Field datatypes.
* Date-Required:                         Problem Report fields.
* Date-Required field:                   Problem Report fields.
* dbconfig:                              dbconfig recipes.
* dbconfig file <1>:                     dbconfig file.
* dbconfig file:                         GNATS configuration.
* dbconfig mode:                         dbconfig mode.
* dbconfig recipes:                      dbconfig recipes.
* debug-mode:                            Overall database configuration.
* default installation locations <1>:    defaults.
* default installation locations:        Locations.
* defaults:                              GNATS configuration.
* deleted-pr-mail:                       Outgoing email formats.
* description:                           Individual field configuration.
* Description field:                     Problem Report fields.
* diff-prs:                              diff-prs.
* Direct e-mail:                         Submitting via e-mail.
* disabling SUBMITTER-ID:                submitters file.
* driver for edit-pr:                    pr-edit.
* duties for gnats-admin:                Management.
* edit controls:                         Edit controls.
* edit-pr <1>:                           Emacs editing.
* edit-pr:                               edit-pr.
* edit-pr driver:                        pr-edit.
* edit-pr from the shell:                edit-pr from the shell.
* effective problem reporting:           Helpful hints.
* Emacs:                                 Emacs.
* Emacs functions:                       Installing utils.
* Emacs lisp file installation:          Configure and make.
* emptying the pending directory:        Management.
* enum:                                  Field datatypes.
* enumerated-in-file:                    Field datatypes.
* Environment field:                     Problem Report fields.
* environment variables and GNATS tools: Environment.
* errors:                                using send-pr.
* example Problem Report:                Fields.
* example queries:                       Example queries.
* EXEC-PREFIX <1>:                       exec-prefix.
* EXEC-PREFIX:                           Configure and make.
* Field datatypes:                       Field datatypes.
* field format:                          Problem Report fields.
* fields:                                Fields.
* fields - list:                         Problem Report fields.
* file-pr:                               file-pr.
* files used for GNATS administration:   Admin files.
* final state ("closed"):                States.
* Fix field:                             Problem Report fields.
* flowchart of GNATS activities:         Flowchart.
* foreword:                              Top.
* format:                                Fields.
* format parameters:                     Audit-trail formats.
* format-name:                           Outgoing email formats.
* From header:                           Mail header fields.
* gen-index <1>:                         gen-index.
* gen-index:                             Management.
* GNATS administrator:                   Paradigm.
* GNATS configuration:                   GNATS configuration.
* GNATS database fields:                 Problem Report fields.
* GNATS fields - list:                   Problem Report fields.
* GNATS management:                      Management.
* GNATS support:                         Support.
* GNATS-ADM:                             gnats-adm.
* gnats-admin alias:                     Aliases.
* gnats-apply-or-submit:                 Emacs editing buffer.
* gnats-change-database <1>:             Emacs and databases.
* gnats-change-database:                 Emacs querying.
* gnats-dbconfig-mode:                   dbconfig mode.
* gnats-dbconfig-mode-hook:              dbconfig mode.
* GNATS-DEFAULT-ORGANIZATION:            Emacs submitting.
* GNATS-DEFAULT-SUBMITTER:               Emacs submitting.
* gnats-edit-mode-hook:                  Emacs editing buffer.
* gnats-next-field:                      Emacs editing buffer.
* gnats-previous-field:                  Emacs editing buffer.
* gnats-pwconv:                          gnats-pwconv.
* gnats-query-edit-pr:                   Emacs querying.
* gnats-query-mode-hook:                 Emacs querying.
* gnats-query-reread:                    Emacs querying.
* GNATS-QUERY-REVERSE-LISTING:           Emacs querying.
* gnats-query-view-pr:                   Emacs querying.
* gnats-show-connection:                 Other Emacs commands.
* gnats-view-edit-pr:                    Emacs viewing.
* gnats-view-mode-hook:                  Emacs viewing.
* gnatsd:                                gnatsd.
* gnatsd command protocol:               gnatsd command protocol.
* gnatsd commands:                       gnatsd commands.
* gnatsd description:                    Description of gnatsd.
* gnatsd environment variables:          gnatsd environment variables.
* gnatsd options:                        gnatsd options.
* gnatsd startup options:                gnatsd options.
* gnatsd, Emacs:                         Emacs and databases.
* gnatsd.host_access <1>:                gnatsd.host_access.
* gnatsd.host_access:                    GNATS configuration.
* gnatsd.user_access <1>:                gnatsd.user_access.
* gnatsd.user_access:                    GNATS configuration.
* gnatsd.user_access file:               GNATS configuration.
* GNATSDB <1>:                           gnatsd environment variables.
* GNATSDB:                               Environment.
* handling incoming traffic:             queue-pr.
* helpful hints:                         Helpful hints.
* How-To-Repeat field:                   Problem Report fields.
* incoming alias for Problem Reports:    Aliases.
* incoming PRs that GNATS cannot parse:  Paradigm.
* index file <1>:                        gen-index.
* index file:                            index file.
* Index file description:                Index file description.
* Individual field configuration:        Individual field configuration.
* information to submit:                 Helpful hints.
* Initial PR input fields:               Initial PR input fields.
* initial state ("open"):                States.
* initial-pr-notification:               Outgoing email formats.
* initial-pr-notification-pending:       Outgoing email formats.
* initial-response-to-submitter:         Outgoing email formats.
* initializing a database:               mkdb.
* installing GNATS:                      Installation.
* installing the utilities:              Installing utils.
* integer:                               Field datatypes.
* interactive interface:                 send-pr in Emacs.
* internal utilities:                    Internal utils.
* Internet standard RFC-822:             Mail header fields.
* introduction to GNATS:                 Introduction.
* invalid Problem Reports:               using send-pr.
* invoking edit-pr:                      edit-pr.
* invoking query-pr:                     query-pr.
* invoking send-pr:                      send-pr.
* invoking send-pr from Emacs:           send-pr in Emacs.
* invoking send-pr from the shell:       send-pr from the shell.
* invoking the GNATS user tools:         GNATS user tools.
* keep-all-received-headers:             Overall database configuration.
* kinds of helpful information:          Helpful hints.
* last-modified:                         Individual field configuration.
* libexecdir:                            Overall database configuration.
* life-cycle of a Problem Report:        States.
* lisp file installation:                Configure and make.
* loading .el files:                     Installing utils.
* locations:                             Locations.
* locks:                                 pr-edit.
* mail aliases:                          Aliases.
* mail header fields:                    Mail header fields.
* mail header section:                   using send-pr.
* mailing lists:                         Support.
* maintenance:                           Paradigm.
* make:                                  Configure and make.
* managing GNATS:                        Management.
* mkcat <1>:                             mkcat.
* mkcat:                                 Management.
* mkdb <1>:                              mkdb.
* mkdb:                                  Management.
* multi-enumerated-in-file:              Field datatypes.
* multienum:                             Field datatypes.
* multitext:                             Field datatypes.
* Named query definitions:               Named query definitions.
* networks:                              Installing tools.
* new database:                          mkdb.
* new problem categories:                mkcat.
* notification of overdue PRs:           at-pr.
* notify-about-expired-prs:              Overall database configuration.
* Notify-List field:                     Problem Report fields.
* number:                                Individual field configuration.
* Number field:                          Problem Report fields.
* OBJDIR:                                Configure and make.
* Organization field:                    Problem Report fields.
* originator:                            Individual field configuration.
* Originator field:                      Problem Report fields.
* other mail <1>:                        using send-pr.
* other mail:                            Problem Report fields.
* Outgoing email formats:                Outgoing email formats.
* Overall database configuration:        Overall database configuration.
* Overview of GNATS configuration:       GNATS configuration.
* overview to GNATS:                     Top.
* paradigm:                              Paradigm.
* password, Emacs:                       Emacs and databases.
* pending directory:                     Paradigm.
* pending file:                          categories file.
* PR confidentiality:                    Problem Report fields.
* PR locks:                              pr-edit.
* pr-age:                                pr-age.
* pr-edit:                               pr-edit.
* PREFIX <1>:                            prefix.
* PREFIX:                                Configure and make.
* prepare send-pr.conf:                  Installing utils.
* priority:                              Individual field configuration.
* Priority field:                        Problem Report fields.
* Problem Report format:                 Fields.
* Problem Report states:                 States.
* Problem Report template:               Fields.
* processing incoming traffic:           file-pr.
* pruning log files:                     Management.
* query expressions:                     Query expressions.
* query-pr <1>:                          Emacs querying.
* query-pr:                              query-pr.
* query-pr by mail:                      Invoking query-pr.
* query-pr output format:                Formatting query-pr output.
* querying individual problem reports:   query-pr.
* querying using regexps:                Regexps.
* queue-pr:                              queue-pr.
* queue-pr -q:                           Aliases.
* rationale:                             Introduction.
* Received-By headers:                   Mail header fields.
* regular expressions:                   Regexps.
* related mail <1>:                      using send-pr.
* related mail:                          Problem Report fields.
* Release field:                         Problem Report fields.
* reminder message:                      at-pr.
* removing a problem category <1>:       rmcat.
* removing a problem category:           Management.
* Reply-To header:                       Mail header fields.
* Report all the facts!:                 Helpful hints.
* reporting problems with send-pr:       send-pr.
* responsible:                           Individual field configuration.
* Responsible field:                     Problem Report fields.
* responsible file <1>:                  responsible file.
* responsible file:                      GNATS configuration.
* Responsible-Changed-<From>-<To> in Audit-Trail: Problem Report fields.
* Responsible-Changed-By in Audit-Trail: Problem Report fields.
* Responsible-Changed-When in Audit-Trail: Problem Report fields.
* Responsible-Changed-Why in Audit-Trail: Problem Report fields.
* rmcat <1>:                             rmcat.
* rmcat:                                 Management.
* sample Problem Report:                 Fields.
* saving related mail <1>:               using send-pr.
* saving related mail:                   Problem Report fields.
* send-pr <1>:                           Emacs submitting.
* send-pr <2>:                           Emacs querying.
* send-pr:                               send-pr.
* send-pr fields <1>:                    using send-pr.
* send-pr fields:                        send-pr from the shell.
* send-pr within Emacs:                  send-pr in Emacs.
* send-pr.conf file:                     send-pr.conf file.
* send-submitter-ack:                    Overall database configuration.
* setting up GNATS:                      Installation.
* severity:                              Individual field configuration.
* Severity field:                        Problem Report fields.
* shell invocation:                      send-pr from the shell.
* Site wide configuration files:         GNATS configuration.
* so what does it do:                    Paradigm.
* state:                                 Individual field configuration.
* State field:                           Problem Report fields.
* state--"analyzed":                     States.
* state--"closed":                       States.
* state--"feedback":                     States.
* state--"open":                         States.
* state--"suspended":                    States.
* State-Changed-<From>-<To> in Audit-Trail: Problem Report fields.
* State-Changed-By in Audit-Trail:       Problem Report fields.
* State-Changed-When in Audit-Trail:     Problem Report fields.
* State-Changed-Why in Audit-Trail:      Problem Report fields.
* states file <1>:                       states file.
* states file:                           GNATS configuration.
* states of Problem Reports:             States.
* Subject header:                        Mail header fields.
* submitter-id:                          Individual field configuration.
* Submitter-Id field <1>:                using send-pr.
* Submitter-Id field:                    Problem Report fields.
* submitters file <1>:                   submitters file.
* submitters file:                       GNATS configuration.
* Submitting a PR via e-mail:            Submitting via e-mail.
* subsequent mail <1>:                   using send-pr.
* subsequent mail:                       Problem Report fields.
* support site:                          Paradigm.
* synopsis:                              Individual field configuration.
* Synopsis field:                        Problem Report fields.
* syntax of regexps:                     Regexps.
* template:                              using send-pr.
* template comment section:              using send-pr.
* text:                                  Field datatypes.
* the section on query-by-mail needs to be relocated: Invoking query-pr.
* timely reminders:                      at-pr.
* To header:                             Mail header fields.
* unformatted:                           Individual field configuration.
* Unformatted field:                     Problem Report fields.
* unlock-database:                       Other Emacs commands.
* unlock-pr:                             Other Emacs commands.
* unpacking the distribution:            Configure and make.
* unparseable incoming PRs:              Paradigm.
* upgrade, procedure:                    Upgrading.
* upgrading from older versions:         Upgrading.
* upgrading, overview:                   Upgrading.
* usage for the GNATS user tools:        GNATS user tools.
* Using and Porting GNU CC:              Helpful hints.
* using edit-pr:                         edit-pr.
* using GNATS over a local network:      Installing tools.
* using GNATS over a network <1>:        Installing tools.
* using GNATS over a network:            Installing the daemon.
* using GNATS remotely:                  Installing tools.
* using query-pr:                        query-pr.
* using send-pr:                         send-pr.
* using send-pr from within Emacs:       send-pr in Emacs.
* view-pr:                               Emacs viewing.
* visual map of data flow:               Flowchart.
* what is a PR:                          Paradigm.
* where GNATS lives:                     Locations.
* why GNATS:                             Paradigm.


