1. Regular Expressions 

All string patterns in Mutt including those in more complex patterns must be
specified using regular expressions (regexp) in the ``POSIX extended'' syntax
(which is more or less the syntax used by egrep and GNU awk). For your convenience,
we have included below a brief description of this syntax. 

The search is case sensitive if the pattern contains at least one upper case letter,
and case insensitive otherwise. Note that ``\'' must be quoted if used for a
regular expression in an initialization command: ``\\''. 

A regular expression is a pattern that describes a set of strings. Regular
expressions are constructed analogously to arithmetic expressions, by using various
operators to combine smaller expressions. 

The fundamental building blocks are the regular expressions that match a single
character. Most characters, including all letters and digits, are regular
expressions that match themselves. Any metacharacter with special meaning may be
quoted by preceding it with a backslash. 

The period ``.'' matches any single character. The caret ``^'' and the dollar sign
``$'' are metacharacters that respectively match the empty string at the
beginning and end of a line. 

A list of characters enclosed by ``['' and ``]'' matches any single character in
that list; if the first character of the list is a caret ``^'' then it matches any
character not in the list. For example, the regular expression [0123456789] matches
any single digit. A range of ASCII characters may be specified by
giving the first and last characters, separated by a hyphen ``‐''. Most
metacharacters lose their special meaning inside lists. To include a literal ``]''
place it first in the list. Similarly, to include a literal ``^'' place it anywhere
but first. Finally, to include a literal hyphen ``‐'' place it last. 

Certain named classes of characters are predefined. Character classes consist of
``[:'', a keyword denoting the class, and ``:]''. The following classes are
defined by the POSIX standard: 

[:alnum:]

     Alphanumeric characters. 
[:alpha:]

     Alphabetic characters. 
[:blank:]

     Space or tab characters. 
[:cntrl:]

     Control characters. 
[:digit:]

     Numeric characters. 
[:graph:]

     Characters that are both printable and visible. (A space is printable, but not
visible, while an ``a'' is both.) 
[:lower:]

     Lower-case alphabetic characters. 
[:print:]

     Printable characters (characters that are not control characters.) 
[:punct:]

     Punctuation characters (characters that are not letter, digits, control
characters, or space characters). 
[:space:]

     Space characters (such as space, tab and formfeed, to name a few). 
[:upper:]

     Upper-case alphabetic characters. 
[:xdigit:]

     Characters that are hexadecimal digits. 

A character class is only valid in a regular expression inside the brackets of a
character list. Note that the brackets in these class names are part of the
symbolic names, and must be included in addition to the brackets delimiting the
bracket list. For example, [[:digit:]] is equivalent to [0-9]. 

Two additional special sequences can appear in character lists. These apply to
non-ASCII character sets, which can have single symbols (called collating
elements) that are represented with more than one character, as well as several
characters that are equivalent for collating or sorting purposes: 

Collating Symbols

     A collating symbols is a multi-character collating element enclosed in ``[.''
and ``.]''. For example, if ``ch'' is a collating element, then [[.ch.]] is a
     regexp that matches this collating element, while [ch] is a regexp that matches
either ``c'' or ``h''. 

Equivalence Classes

     An equivalence class is a locale-specific name for a list of characters that
are equivalent. The name is enclosed in ``[='' and ``=]''. For example, the
     name ``e'' might be used to represent all of ``?'' ``?'' and ``e''. In this
case, [[=e=]] is a regexp that matches any of ``?'', ``?'' and ``e''. 

A regular expression matching a single character may be followed by one of several
repetition operators: 

?

     The preceding item is optional and matched at most once. 
*

     The preceding item will be matched zero or more times. 
+

     The preceding item will be matched one or more times. 
{n}

     The preceding item is matched exactly n times. 
{n,}

     The preceding item is matched n or more times. 
{,m}

     The preceding item is matched at most m times. 
{n,m}

     The preceding item is matched at least n times, but no more than m times. 

Two regular expressions may be concatenated; the resulting regular expression
matches any string formed by concatenating two substrings that
respectively match the concatenated subexpressions. 

Two regular expressions may be joined by the infix operator ``|''; the resulting
regular expression matches any string matching either subexpression. 

Repetition takes precedence over concatenation, which in turn takes precedence over
alternation. A whole subexpression may be enclosed in parentheses
to override these precedence rules. 

Note: If you compile Mutt with the GNU rx package, the following operators may also
be used in regular expressions: 

\\y

     Matches the empty string at either the beginning or the end of a word. 
\\B

     Matches the empty string within a word. 
\\<

     Matches the empty string at the beginning of a word. 
\\>

     Matches the empty string at the end of a word. 
\\w

     Matches any word-constituent character (letter, digit, or underscore). 
\\W

     Matches any character that is not word-constituent. 
\\`

     Matches the empty string at the beginning of a buffer (string). 
\\'

     Matches the empty string at the end of a buffer. 

Please note however that these operators are not defined by POSIX, so they may or
may not be available in stock libraries on various systems. 

2. Patterns 

Many of Mutt's commands allow you to specify a pattern to match (limit, tag-pattern,
delete-pattern, etc.). There are several ways to select messages: 

     ~A              all messages
     ~b EXPR         messages which contain EXPR in the message body
     ~B EXPR         messages which contain EXPR in the whole message
     ~c USER         messages carbon-copied to USER
     ~C EXPR         message is either to: or cc: EXPR
     ~D              deleted messages
     ~d [MIN]-[MAX]  messages with ``date-sent'' in a Date range
     ~E              expired messages
     ~e EXPR         message which contains EXPR in the ``Sender'' field
     ~F              flagged messages
     ~f USER         messages originating from USER
     ~g              PGP signed messages
     ~G              PGP encrypted messages
     ~h EXPR         messages which contain EXPR in the message header
     ~k              message contains PGP key material
     ~i ID           message which match ID in the ``Message-ID'' field
     ~L EXPR         message is either originated or received by EXPR
     ~l              message is addressed to a known mailing list
     ~m [MIN]-[MAX]  message in the range MIN to MAX *)
     ~n [MIN]-[MAX]  messages with a score in the range MIN to MAX *)
     ~N              new messages
     ~O              old messages
     ~p              message is addressed to you (consults $alternates)
     ~P              message is from you (consults $alternates)
     ~Q              messages which have been replied to
     ~R              read messages
     ~r [MIN]-[MAX]  messages with ``date-received'' in a Date range
     ~S              superseded messages
     ~s SUBJECT      messages having SUBJECT in the ``Subject'' field.
     ~T              tagged messages
     ~t USER         messages addressed to USER
     ~U              unread messages
     ~v              message is part of a collapsed thread.
     ~x EXPR         messages which contain EXPR in the `References' field
     ~z [MIN]-[MAX]  messages with a size in the range MIN to MAX *)

Where EXPR, USER, ID, and SUBJECT are regular expressions. 

*) The forms <[MAX], >[MIN], [MIN]- and -[MAX] are allowed, too. 

Pattern Modifier

Note that patterns matching 'lists' of addresses (notably c,C,p,P and t) match if
there is at least one match in the whole list. If you want to make sure that
all elements of that list match, you need to prefix your pattern with ^. This
example matches all mails which only has recipients from Germany. 

     ^~C \.de$

Complex Patterns

Logical AND is performed by specifying more than one criterion. For example: 

     ~t mutt ~f elkins

would select messages which contain the word ``mutt'' in the list of recipients and
that have the word ``elkins'' in the ``From'' header field. 

Mutt also recognizes the following operators to create more complex search patterns: 

     ! -- logical NOT operator 
     | -- logical OR operator 
     () -- logical grouping operator 

Here is an example illustrating a complex search pattern. This pattern will select
all messages which do not contain ``mutt'' in the ``To'' or ``Cc'' field and
which are from ``elkins''. 

     !(~t mutt|~c mutt) ~f elkins

Searching by Date

Mutt supports two types of dates, absolute and relative. 

Absolute. Dates must be in DD/MM/YY format (month and year are optional, defaulting
to the current month and year). An example of a valid range of
dates is: 

     Limit to messages matching: ~d 20/1/95-31/10

If you omit the minimum (first) date, and just specify ``-DD/MM/YY'', all messages
before the given date will be selected. If you omit the maximum
(second) date, and specify ``DD/MM/YY-'', all messages after the given date will be
selected. If you specify a single date with no dash (``-''), only
messages sent on the given date will be selected. 

Relative. This type of date is relative to the current date, and may be specified
as: 

     >offset (messages older than offset units) 
     <offset (messages newer than offset units) 
     =offset (messages exactly offset units old) 
     
offset is specified as a positive number with one of the following
units: 
    
y       years
m       months
w       weeks
d       days
   
Example: to select messages less than 1 month old, you would use 
  
Limit to messages matching: ~d <1m
 
Note: all dates used when searching are relative to the local
time zone, so unless you change the setting of your
$index_format to include a %[...]
format, these are not the dates shown in the main index. 

3. Using color and mono video attributes

Usage: color object foreground background [ regexp ]
Usage: color index foreground background [ pattern ]
Usage: uncolor index pattern [ pattern ... ]

If your terminal supports color, you can spice up Mutt by creating your own color
scheme. To define the color of an object (type of information), you must
specify both a foreground color and a background color (it is not possible to only
specify one or the other). 

object can be one of: 

     attachment 
     body (match regexp in the body of messages) 
     bold (hiliting bold patterns in the body of messages) 
     error (error messages printed by Mutt) 
     header (match regexp in the message header) 
     hdrdefault (default color of the message header in the pager) 
     index (match pattern in the message index) 
     indicator (arrow or bar used to indicate the current item in a menu) 
     markers (the ``+'' markers at the beginning of wrapped lines in the pager) 
     message (informational messages) 
     normal 
     quoted (text matching $quote_regexp in the body of a message) 
     quoted1, quoted2, ..., quotedN (higher levels of quoting) 
     search (hiliting of words in the pager) 
     signature 
     status (mode lines used to display info about the mailbox or message) 
     tilde (the ``~'' used to pad blank lines in the pager) 
     tree (thread tree drawn in the message index and attachment menu) 
     underline (hiliting underlined patterns in the body of messages) 

foreground and background can be one of the following: 

     white 
     black 
     green 
     magenta 
     blue 
     cyan 
     yellow 
     red 
     default 
     colorx 

foreground can optionally be prefixed with the keyword bright to make the foreground
color boldfaced (e.g., brightred). 

If your terminal supports it, the special keyword default can be used as a
transparent color. The value brightdefault is also valid. If Mutt is linked against
the S-Lang library, you also need to set the COLORFGBG environment variable to the
default colors of your terminal for this to work; for example (for
Bourne-like shells): 

     set COLORFGBG="green;black"
     export COLORFGBG

Note: The S-Lang library requires you to use the lightgray and brown keywords
instead of white and yellow when setting this variable. 

Note: The uncolor command can be applied to the index object only. It removes
entries from the list. You must specify the same pattern specified in the
color command for it to be removed. The pattern ``*'' is a special token which means
to clear the color index list of all entries. 

Mutt also recognizes the keywords color0, color1, ..., colorN-1 (N being the number
of colors supported by your terminal). This is useful when you
remap the colors for your display (for example by changing the color associated with
color2 for your xterm), since color names may then lose their normal
meaning. 

If your terminal does not support color, it is still possible change the video
attributes through the use of the ``mono'' command: 

Usage: mono <object> <attribute> [ regexp ] 

where attribute is one of the following: 

     none 
     bold 
     underline 
     reverse 
     standout