Shared constants/structs that are private to libpattern. More...

#include <stdbool.h>
#include "mutt/lib.h"
#include "email/lib.h"
#include "lib.h"

Include dependency graph for private.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	PatternFlags
	Mapping between user character and internal constant. More...

struct	RangeRegex
	Regular expression representing a range. More...

Macros
#define	RANGE_NUM_RX "([[:digit:]]+\|0x[[:xdigit:]]+)[MmKk]?"
	Regex for a number (decimal or hex) with optional K/M suffix.

#define	RANGE_REL_SLOT_RX "[[:blank:]]([.^$]\|-?" RANGE_NUM_RX ")?[[:blank:]]"
	Regex for one slot in a relative range (e.g., "5" or "-3")

#define	RANGE_REL_RX "^" RANGE_REL_SLOT_RX "," RANGE_REL_SLOT_RX
	Regex for relative range (e.g., "1,5" or "-3,.")

#define	RANGE_ABS_SLOT_RX "[[:blank:]]([.^$]\|" RANGE_NUM_RX ")?[[:blank:]]"
	Regex for one slot in an absolute range (no negative numbers)

#define	RANGE_ABS_RX "^" RANGE_ABS_SLOT_RX "-" RANGE_ABS_SLOT_RX
	Regex for absolute range (e.g., "1-5")

#define	RANGE_LT_RX "^()[[:blank:]](<[[:blank:]]" RANGE_NUM_RX ")[[:blank:]]*"
	Regex for less-than range (e.g., "<100")

#define	RANGE_GT_RX "^()[[:blank:]](>[[:blank:]]" RANGE_NUM_RX ")[[:blank:]]*"
	Regex for greater-than range (e.g., ">50")

#define	RANGE_BARE_RX "^[[:blank:]]([.^$]\|" RANGE_NUM_RX ")[[:blank:]]"
	Regex for bare number range.

#define	RANGE_RX_GROUPS 5
	Number of capture groups in range regexes.

#define	RANGE_DOT '.'
	Current position indicator '.'.

#define	RANGE_CIRCUM '^'
	First message indicator '^'.

#define	RANGE_DOLLAR '$'
	Last message indicator '$'.

#define	RANGE_LT '<'
	Less-than operator '<'.

#define	RANGE_GT '>'
	Greater-than operator '>'.

#define	MUTT_MAXRANGE -1

Enumerations
enum	ExpandoDataPattern { ED_PAT_DESCRIPTION = 1 , ED_PAT_EXPRESSION , ED_PAT_NUMBER }
	Expando UIDs for Patterns. More...

enum	PatternEat { EAT_NONE , EAT_DATE , EAT_GROUP , EAT_MESSAGE_RANGE , EAT_QUERY , EAT_RANGE , EAT_REGEX , EAT_STRING }
	Function to process pattern arguments. More...

enum	RangeType { RANGE_K_REL , RANGE_K_ABS , RANGE_K_LT , RANGE_K_GT , RANGE_K_BARE , RANGE_K_INVALID }
	Type of range. More...

enum	RangeSide { RANGE_S_LEFT , RANGE_S_RIGHT }
	Which side of the range. More...

Functions
static int	email_msgno (struct Email *e)
	Helper to get the Email's message number.

const struct PatternFlags *	lookup_op (int op)
	Lookup the Pattern Flags for an op.

const struct PatternFlags *	lookup_tag (char prefix, char tag)
	Lookup a pattern modifier.

bool	eval_date_minmax (struct Pattern pat, const char s, struct Buffer *err)
	Evaluate a date-range pattern against 'now'.

bool	eat_message_range (struct Pattern pat, PatternCompFlags flags, struct Buffer s, struct Buffer err, struct MailboxView mv)
	Parse a range of message numbers - Implements eat_arg_t -.

Variables
struct RangeRegex	RangeRegexes []
	Set of Regexes for various range types.

const struct PatternFlags	Flags []
	Lookup table for all patterns.

Detailed Description

Shared constants/structs that are private to libpattern.

Authors

Richard Russon

Copyright: This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file private.h.

Macro Definition Documentation

◆ RANGE_NUM_RX

#define RANGE_NUM_RX "([[:digit:]]+|0x[[:xdigit:]]+)[MmKk]?"

Regex for a number (decimal or hex) with optional K/M suffix.

Definition at line 103 of file private.h.

◆ RANGE_REL_SLOT_RX

#define RANGE_REL_SLOT_RX "[[:blank:]]*([.^$]|-?" RANGE_NUM_RX ")?[[:blank:]]*"

Regex for one slot in a relative range (e.g., "5" or "-3")

Definition at line 105 of file private.h.

◆ RANGE_REL_RX

#define RANGE_REL_RX "^" RANGE_REL_SLOT_RX "," RANGE_REL_SLOT_RX

Regex for relative range (e.g., "1,5" or "-3,.")

Definition at line 107 of file private.h.

◆ RANGE_ABS_SLOT_RX

#define RANGE_ABS_SLOT_RX "[[:blank:]]*([.^$]|" RANGE_NUM_RX ")?[[:blank:]]*"

Regex for one slot in an absolute range (no negative numbers)

Definition at line 110 of file private.h.

◆ RANGE_ABS_RX

#define RANGE_ABS_RX "^" RANGE_ABS_SLOT_RX "-" RANGE_ABS_SLOT_RX

Regex for absolute range (e.g., "1-5")

Definition at line 112 of file private.h.

◆ RANGE_LT_RX

#define RANGE_LT_RX "^()[[:blank:]]*(<[[:blank:]]*" RANGE_NUM_RX ")[[:blank:]]*"

Regex for less-than range (e.g., "<100")

Definition at line 115 of file private.h.

◆ RANGE_GT_RX

#define RANGE_GT_RX "^()[[:blank:]]*(>[[:blank:]]*" RANGE_NUM_RX ")[[:blank:]]*"

Regex for greater-than range (e.g., ">50")

Definition at line 117 of file private.h.

◆ RANGE_BARE_RX

#define RANGE_BARE_RX "^[[:blank:]]*([.^$]|" RANGE_NUM_RX ")[[:blank:]]*"

Regex for bare number range.

Definition at line 120 of file private.h.

◆ RANGE_RX_GROUPS

#define RANGE_RX_GROUPS 5

Number of capture groups in range regexes.

Definition at line 122 of file private.h.

◆ RANGE_DOT

#define RANGE_DOT '.'

Current position indicator '.'.

Definition at line 124 of file private.h.

◆ RANGE_CIRCUM

#define RANGE_CIRCUM '^'

First message indicator '^'.

Definition at line 125 of file private.h.

◆ RANGE_DOLLAR

#define RANGE_DOLLAR '$'

Last message indicator '$'.

Definition at line 126 of file private.h.

◆ RANGE_LT

#define RANGE_LT '<'

Less-than operator '<'.

Definition at line 127 of file private.h.

◆ RANGE_GT

#define RANGE_GT '>'

Greater-than operator '>'.

Definition at line 128 of file private.h.

◆ MUTT_MAXRANGE

#define MUTT_MAXRANGE -1

Definition at line 149 of file private.h.

Enumeration Type Documentation

◆ ExpandoDataPattern

enum ExpandoDataPattern

Expando UIDs for Patterns.

See also: ED_PATTERN, ExpandoDomain

Enumerator
ED_PAT_DESCRIPTION	PatternEntry.desc.
ED_PAT_EXPRESSION	PatternEntry.expr.
ED_PAT_NUMBER	PatternEntry.num.

Definition at line 38 of file private.h.

{
  ED_PAT_DESCRIPTION = 1,      
  ED_PAT_EXPRESSION,           
  ED_PAT_NUMBER,               
};

◆ PatternEat

enum PatternEat

Function to process pattern arguments.

Values for PatternFlags.eat_arg

Enumerator
EAT_NONE	No arguments required.
EAT_DATE	Process a date (range)
EAT_GROUP	Process a group name.
EAT_MESSAGE_RANGE	Process a message number (range)
EAT_QUERY	Process a query string.
EAT_RANGE	Process a number (range)
EAT_REGEX	Process a regex.
EAT_STRING	Process a plain string.

Definition at line 50 of file private.h.

{
  EAT_NONE,          
  EAT_DATE,          
  EAT_GROUP,         
  EAT_MESSAGE_RANGE, 
  EAT_QUERY,         
  EAT_RANGE,         
  EAT_REGEX,         
  EAT_STRING,        
};

◆ RangeType

enum RangeType

Type of range.

Enumerator
RANGE_K_REL	Relative range.
RANGE_K_ABS	Absolute range.
RANGE_K_LT	Less-than range.
RANGE_K_GT	Greater-than range.
RANGE_K_BARE	Single symbol.
RANGE_K_INVALID	Range is invalid.

Definition at line 91 of file private.h.

{
  RANGE_K_REL,  
  RANGE_K_ABS,  
  RANGE_K_LT,   
  RANGE_K_GT,   
  RANGE_K_BARE, 
  /* add new ones HERE */
  RANGE_K_INVALID, 
};

◆ RangeSide

enum RangeSide

Which side of the range.

Enumerator
RANGE_S_LEFT	Left side of range.
RANGE_S_RIGHT	Right side of range.

Definition at line 133 of file private.h.

{
  RANGE_S_LEFT,  
  RANGE_S_RIGHT, 
};

Function Documentation

◆ email_msgno()

static int email_msgno ( struct Email * e )

inlinestatic

Helper to get the Email's message number.

Parameters

e Email

Return values

num	Message number

Definition at line 144 of file private.h.

{
  return e->msgno + 1;
}

Here is the caller graph for this function:

◆ lookup_op()

const struct PatternFlags * lookup_op ( int op )

Lookup the Pattern Flags for an op.

Parameters

op	Operation, e.g. MUTT_PAT_SENDER

Return values

ptr	PatternFlags

Definition at line 258 of file flags.c.

{
  for (int i = 0; Flags[i].tag; i++)
    if (Flags[i].op == op)
      return (&Flags[i]);
  return NULL;
}

Here is the caller graph for this function:

◆ lookup_tag()

const struct PatternFlags * lookup_tag	(	char	prefix,
		char	tag )

Lookup a pattern modifier.

Parameters

prefix	Pattern prefix, e.g. '~', '', or '='
tag	Letter, e.g. 'b' for pattern '~b'

Return values

ptr	Pattern data

This function first looks for an exact match with the given prefix and tag. If not found and prefix is '' or '=', it falls back to looking for the tag with '~' prefix to maintain backward compatibility where '=' means string-match and '' means group-match modifier.

Definition at line 235 of file flags.c.

{
  // First, try exact match
  for (int i = 0; Flags[i].tag; i++)
    if ((Flags[i].prefix == prefix) && (Flags[i].tag == tag))
      return &Flags[i];
 
  // Fall back to '~' prefix for '%' and '=' modifiers
  if ((prefix == '%') || (prefix == '='))
  {
    for (int i = 0; Flags[i].tag; i++)
      if ((Flags[i].prefix == '~') && (Flags[i].tag == tag))
        return &Flags[i];
  }
 
  return NULL;
}

Here is the caller graph for this function:

◆ eval_date_minmax()

bool eval_date_minmax	(	struct Pattern *	pat,
		const char *	s,
		struct Buffer *	err )

Evaluate a date-range pattern against 'now'.

Parameters

pat	Pattern to modify
s	Pattern string to use
err	Buffer for error messages

Return values

true	Pattern valid and updated
false	Pattern invalid

Definition at line 544 of file compile.c.

{
  /* the '0' time is Jan 1, 1970 UTC, so in order to prevent a negative time
   * when doing timezone conversion, we use Jan 2, 1970 UTC as the base here */
  struct tm min = { 0 };
  min.tm_mday = 2;
  min.tm_year = 70;
 
  /* Arbitrary year in the future.  Don't set this too high or
   * mutt_date_make_time() returns something larger than will fit in a time_t
   * on some systems */
  struct tm max = { 0 };
  max.tm_year = 130;
  max.tm_mon = 11;
  max.tm_mday = 31;
  max.tm_hour = 23;
  max.tm_min = 59;
  max.tm_sec = 59;
 
  if (strchr("<>=", s[0]))
  {
    /* offset from current time
     *  <3d  less than three days ago
     *  >3d  more than three days ago
     *  =3d  exactly three days ago */
    struct tm *tm = NULL;
    bool exact = false;
 
    if (s[0] == '<')
    {
      min = mutt_date_localtime(mutt_date_now());
      tm = &min;
    }
    else
    {
      max = mutt_date_localtime(mutt_date_now());
      tm = &max;
 
      if (s[0] == '=')
        exact = true;
    }
 
    /* Reset the HMS unless we are relative matching using one of those
     * offsets. */
    char *offset_type = NULL;
    strtol(s + 1, &offset_type, 0);
    if (!(*offset_type && strchr("HMS", *offset_type)))
    {
      tm->tm_hour = 23;
      tm->tm_min = 59;
      tm->tm_sec = 59;
    }
 
    /* force negative offset */
    get_offset(tm, s + 1, -1);
 
    if (exact)
    {
      /* start at the beginning of the day in question */
      memcpy(&min, &max, sizeof(max));
      min.tm_hour = 0;
      min.tm_sec = 0;
      min.tm_min = 0;
    }
  }
  else
  {
    const char *pc = s;
 
    bool have_min = false;
    bool until_now = false;
    if (mutt_isdigit(*pc))
    {
      /* minimum date specified */
      pc = get_date(pc, &min, err);
      if (!pc)
      {
        return false;
      }
      have_min = true;
      SKIPWS(pc);
      if (*pc == '-')
      {
        const char *pt = pc + 1;
        SKIPWS(pt);
        until_now = (*pt == '\0');
      }
    }
 
    if (!until_now)
    { /* max date or relative range/window */
 
      struct tm base_min = { 0 };
 
      if (!have_min)
      { /* save base minimum and set current date, e.g. for "-3d+1d" */
        memcpy(&base_min, &min, sizeof(base_min));
        min = mutt_date_localtime(mutt_date_now());
        min.tm_hour = 0;
        min.tm_sec = 0;
        min.tm_min = 0;
      }
 
      /* preset max date for relative offsets,
       * if nothing follows we search for messages on a specific day */
      max.tm_year = min.tm_year;
      max.tm_mon = min.tm_mon;
      max.tm_mday = min.tm_mday;
 
      if (!parse_date_range(pc, &min, &max, have_min, &base_min, err))
      { /* bail out on any parsing error */
        return false;
      }
    }
  }
 
  /* Since we allow two dates to be specified we'll have to adjust that. */
  adjust_date_range(&min, &max);
 
  pat->min = mutt_date_make_time(&min, true);
  pat->max = mutt_date_make_time(&max, true);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ RangeRegexes

struct RangeRegex RangeRegexes[]

extern

Set of Regexes for various range types.

This array, will also contain the compiled regexes.

Definition at line 60 of file pattern.c.

                                   {
  // clang-format off
  [RANGE_K_REL]  = { RANGE_REL_RX,  1, 3, 0, { 0 } },
  [RANGE_K_ABS]  = { RANGE_ABS_RX,  1, 3, 0, { 0 } },
  [RANGE_K_LT]   = { RANGE_LT_RX,   1, 2, 0, { 0 } },
  [RANGE_K_GT]   = { RANGE_GT_RX,   2, 1, 0, { 0 } },
  [RANGE_K_BARE] = { RANGE_BARE_RX, 1, 1, 0, { 0 } },
  // clang-format on
};

◆ Flags

const struct PatternFlags Flags[]

extern

Lookup table for all patterns.

Patterns in use:

~ .bcdefghi.klmn.p.rstuvwxyz
~ ABCDEFGHI..LMNOPQRSTUV.XY.
~# ~$ ~() ~<() ~= ~>()
Group patterns - c C e f L
IMAP patterns - =b =B =h =/

Definition at line 47 of file flags.c.

                                    {
  // clang-format off
  { '~', 'A', MUTT_ALL, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~A
    N_("all messages") },
  { '~', 'b', MUTT_PAT_BODY, MUTT_PC_FULL_MSG | MUTT_PC_SEND_MODE_SEARCH, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~b
    N_("messages whose body matches REGEX") },
  { '=', 'b', MUTT_PAT_BODY, MUTT_PC_FULL_MSG | MUTT_PC_SEND_MODE_SEARCH, EAT_STRING,
    // L10N: Pattern Completion Menu description for =b
    N_("IMAP: messages whose body contains STRING") },
  { '~', 'B', MUTT_PAT_WHOLE_MSG, MUTT_PC_FULL_MSG | MUTT_PC_SEND_MODE_SEARCH, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~B
    N_("messages whose body or headers match REGEX") },
  { '=', 'B', MUTT_PAT_WHOLE_MSG, MUTT_PC_FULL_MSG | MUTT_PC_SEND_MODE_SEARCH, EAT_STRING,
    // L10N: Pattern Completion Menu description for =B
    N_("IMAP: messages whose body or headers contain STRING") },
  { '~', 'c', MUTT_PAT_CC, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~c
    N_("messages whose Cc: header matches REGEX") },
  { '%', 'c', MUTT_PAT_CC, 0, EAT_GROUP,
    // L10N: Pattern Completion Menu description for %c
    N_("messages whose Cc: is a member of GROUP") },
  { '~', 'C', MUTT_PAT_RECIPIENT, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~C
    N_("messages whose To:, Cc: or Bcc: header matches REGEX") },
  { '%', 'C', MUTT_PAT_RECIPIENT, 0, EAT_GROUP,
    // L10N: Pattern Completion Menu description for %C
    N_("messages whose To:, Cc: or Bcc: is a member of GROUP") },
  { '~', 'd', MUTT_PAT_DATE, 0, EAT_DATE,
    // L10N: Pattern Completion Menu description for ~d
    N_("messages sent in DATERANGE") },
  { '~', 'D', MUTT_DELETED, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~D
    N_("deleted messages") },
  { '~', 'e', MUTT_PAT_SENDER, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~e
    N_("messages whose Sender: header matches REGEX") },
  { '%', 'e', MUTT_PAT_SENDER, 0, EAT_GROUP,
    // L10N: Pattern Completion Menu description for %e
    N_("messages whose Sender: is a member of GROUP") },
  { '~', 'E', MUTT_EXPIRED, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~E
    N_("expired messages") },
  { '~', 'f', MUTT_PAT_FROM, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~f
    N_("messages whose From: header matches REGEX") },
  { '%', 'f', MUTT_PAT_FROM, 0, EAT_GROUP,
    // L10N: Pattern Completion Menu description for %f
    N_("messages whose From: is a member of GROUP") },
  { '~', 'F', MUTT_FLAG, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~F
    N_("flagged messages") },
  { '~', 'g', MUTT_PAT_CRYPT_SIGN, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~g
    N_("cryptographically signed messages") },
  { '~', 'G', MUTT_PAT_CRYPT_ENCRYPT, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~G
    N_("cryptographically encrypted messages") },
  { '~', 'h', MUTT_PAT_HEADER, MUTT_PC_FULL_MSG | MUTT_PC_SEND_MODE_SEARCH, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~h
    N_("messages whose header matches REGEX") },
  { '=', 'h', MUTT_PAT_HEADER, MUTT_PC_FULL_MSG | MUTT_PC_SEND_MODE_SEARCH, EAT_STRING,
    // L10N: Pattern Completion Menu description for =h
    N_("IMAP: messages whose header contains STRING") },
  { '~', 'H', MUTT_PAT_HORMEL, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~H
    N_("messages whose spam header matches REGEX") },
  { '~', 'i', MUTT_PAT_ID, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~i
    N_("messages whose Message-Id: header matches REGEX") },
  { '~', 'I', MUTT_PAT_ID_EXTERNAL, 0, EAT_QUERY,
    // L10N: Pattern Completion Menu description for ~I
    N_("messages whose Message-Id: is included in results from $external_search_command") },
  { '~', 'k', MUTT_PAT_PGP_KEY, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~k
    N_("messages which contain a PGP key") },
  { '~', 'K', MUTT_PAT_BCC, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~K
    N_("messages whose Bcc: header matches REGEX") },
  { '~', 'l', MUTT_PAT_LIST, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~l
    N_("messages addressed to known mailing lists") },
  { '~', 'L', MUTT_PAT_ADDRESS, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~L
    N_("messages whose From:, Sender:, To: or Cc: header matches REGEX") },
  { '%', 'L', MUTT_PAT_ADDRESS, 0, EAT_GROUP,
    // L10N: Pattern Completion Menu description for %L
    N_("messages whose From:, Sender:, To: or Cc: is a member of GROUP") },
  { '~', 'm', MUTT_PAT_MESSAGE, 0, EAT_MESSAGE_RANGE,
    // L10N: Pattern Completion Menu description for ~m
    N_("messages whose number is in RANGE") },
  { '~', 'M', MUTT_PAT_MIMETYPE, MUTT_PC_FULL_MSG, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~M
    N_("messages with a Content-Type matching REGEX") },
  { '~', 'n', MUTT_PAT_SCORE, 0, EAT_RANGE,
    // L10N: Pattern Completion Menu description for ~n
    N_("messages whose score is in RANGE") },
  { '~', 'N', MUTT_NEW, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~N
    N_("new messages") },
  { '~', 'O', MUTT_OLD, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~O
    N_("old messages") },
  { '~', 'p', MUTT_PAT_PERSONAL_RECIP, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~p
    N_("messages addressed to you") },
  { '~', 'P', MUTT_PAT_PERSONAL_FROM, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~P
    N_("messages from you") },
  { '~', 'Q', MUTT_REPLIED, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~Q
    N_("messages which have been replied to") },
  { '~', 'r', MUTT_PAT_DATE_RECEIVED, 0, EAT_DATE,
    // L10N: Pattern Completion Menu description for ~r
    N_("messages received in DATERANGE") },
  { '~', 'R', MUTT_READ, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~R
    N_("read messages") },
  { '~', 's', MUTT_PAT_SUBJECT, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~s
    N_("messages whose Subject: header matches REGEX") },
  { '~', 'S', MUTT_SUPERSEDED, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~S
    N_("superseded messages") },
  { '~', 't', MUTT_PAT_TO, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~t
    N_("messages whose To: header matches REGEX") },
  { '~', 'T', MUTT_TAG, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~T
    N_("tagged messages") },
  { '~', 'u', MUTT_PAT_SUBSCRIBED_LIST, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~u
    N_("messages addressed to subscribed mailing lists") },
  { '~', 'U', MUTT_UNREAD, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~U
    N_("unread messages") },
  { '~', 'v', MUTT_PAT_COLLAPSED, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~v
    N_("messages in collapsed threads") },
  { '~', 'V', MUTT_PAT_CRYPT_VERIFIED, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~V
    N_("cryptographically verified messages") },
  { '~', 'w', MUTT_PAT_NEWSGROUPS, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~w
    N_("newsgroups matching REGEX") },
  { '~', 'x', MUTT_PAT_REFERENCE, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~x
    N_("messages whose References: or In-Reply-To: header matches REGEX") },
  { '~', 'X', MUTT_PAT_MIMEATTACH, 0, EAT_RANGE,
    // L10N: Pattern Completion Menu description for ~X
    N_("messages with RANGE attachments") },
  { '~', 'y', MUTT_PAT_XLABEL, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~y
    N_("messages whose X-Label: header matches REGEX") },
  { '~', 'Y', MUTT_PAT_DRIVER_TAGS, 0, EAT_REGEX,
    // L10N: Pattern Completion Menu description for ~Y
    N_("messages whose tags match REGEX") },
  { '~', 'z', MUTT_PAT_SIZE, 0, EAT_RANGE,
    // L10N: Pattern Completion Menu description for ~z
    N_("messages whose size is in RANGE") },
  { '~', '#', MUTT_PAT_BROKEN, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~#
    N_("broken threads") },
  { '~', '$', MUTT_PAT_UNREFERENCED, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~$
    N_("unreferenced messages") },
  { '=', '/', MUTT_PAT_SERVERSEARCH, 0, EAT_STRING,
    // L10N: Pattern Completion Menu description for =/
    N_("GMail: custom server-side search for STRING") },
  { '~', '=', MUTT_PAT_DUPLICATED, 0, EAT_NONE,
    // L10N: Pattern Completion Menu description for ~=
    N_("duplicated messages") },
  { 0, 0, 0, 0, EAT_NONE, NULL, },
  // clang-format on
};

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ RANGE_NUM_RX

◆ RANGE_REL_SLOT_RX

◆ RANGE_REL_RX

◆ RANGE_ABS_SLOT_RX

◆ RANGE_ABS_RX

◆ RANGE_LT_RX

◆ RANGE_GT_RX

◆ RANGE_BARE_RX

◆ RANGE_RX_GROUPS

◆ RANGE_DOT

◆ RANGE_CIRCUM

◆ RANGE_DOLLAR

◆ RANGE_LT

◆ RANGE_GT

◆ MUTT_MAXRANGE

Enumeration Type Documentation

◆ ExpandoDataPattern

◆ PatternEat

◆ RangeType

◆ RangeSide

Function Documentation

◆ email_msgno()

◆ lookup_op()

◆ lookup_tag()

◆ eval_date_minmax()

Variable Documentation

◆ RangeRegexes

◆ Flags