compile.c File Reference

Compile a Pattern. More...

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include "private.h"
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "gui/lib.h"
#include "lib.h"
#include "parse/lib.h"

Include dependency graph for compile.c:

Go to the source code of this file.

Macros
#define	MUTT_PDR_ERRORDONE   (MUTT_PDR_ERROR | MUTT_PDR_DONE)

Typedefs
typedef uint8_t	ParseDateRangeFlags

Enumerations
enum	ParseDateRangeFlag {   MUTT_PDR_NONE = 0 , MUTT_PDR_MINUS = 1U << 0 , MUTT_PDR_PLUS = 1U << 1 , MUTT_PDR_WINDOW = 1U << 2 ,   MUTT_PDR_ABSOLUTE = 1U << 3 , MUTT_PDR_DONE = 1U << 4 , MUTT_PDR_ERROR = 1U << 5 }
	Flags for parse_date_range(), e.g. More...

Functions
static bool	eat_regex (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
	Parse a regex - Implements eat_arg_t -.
static bool	eat_string (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
	Parse a plain string - Implements eat_arg_t -.
static bool	eat_group (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
	Parse a group name - Implements eat_arg_t -.
static bool	add_query_msgid (char *line, int line_num, void *user_data)
	Parse a Message-ID and add it to a list - Implements mutt_file_map_t -.
static bool	eat_query (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err, struct Mailbox *m)
	Parse a query for an external search program - Implements eat_arg_t -.
static const char *	get_offset (struct tm *tm, const char *s, int sign)
	Calculate a symbolic offset.
static const char *	get_date (const char *s, struct tm *t, struct Buffer *err)
	Parse a (partial) date in dd/mm/yyyy format.
static const char *	parse_date_range (const char *pc, struct tm *min, struct tm *max, bool have_min, struct tm *base_min, struct Buffer *err)
	Parse a date range.
static void	adjust_date_range (struct tm *min, struct tm *max)
	Put a date range in the correct order.
bool	eval_date_minmax (struct Pattern *pat, const char *s, struct Buffer *err)
	Evaluate a date-range pattern against 'now'.
static bool	eat_range (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
	Parse a number range - Implements eat_arg_t -.
static bool	eat_date (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
	Parse a date pattern - Implements eat_arg_t -.
static char *	find_matching_paren (char *s)
	Find the matching parenthesis.
void	mutt_pattern_free (struct PatternList **pat)
	Free a Pattern.
static struct Pattern *	mutt_pattern_new (void)
	Create a new Pattern.
static struct PatternList *	mutt_pattern_list_new (void)
	Create a new list containing a Pattern.
static struct Pattern *	attach_leaf (struct PatternList *list, struct Pattern *leaf)
	Attach a Pattern to a Pattern List.
static struct Pattern *	attach_new_root (struct PatternList **curlist)
	Create a new Pattern as a parent for a List.
static struct Pattern *	attach_new_leaf (struct PatternList **curlist)
	Attach a new Pattern to a List.
struct PatternList *	mutt_pattern_comp (struct MailboxView *mv, const char *s, PatternCompFlags flags, struct Buffer *err)
	Create a Pattern.

Detailed Description

Compile a Pattern.

Authors

• R Primus
• Pietro Cerutti
• Richard Russon
• Thomas Klausner

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 compile.c.

Macro Definition Documentation

MUTT_PDR_ERRORDONE

#define MUTT_PDR_ERRORDONE   (MUTT_PDR_ERROR | MUTT_PDR_DONE)

Definition at line 67 of file compile.c.

Typedef Documentation

ParseDateRangeFlags

typedef uint8_t ParseDateRangeFlags

Definition at line 65 of file compile.c.

Enumeration Type Documentation

ParseDateRangeFlag

enum ParseDateRangeFlag

Flags for parse_date_range(), e.g.

MUTT_PDR_MINUS

Enumerator
MUTT_PDR_NONE	No flags are set.
MUTT_PDR_MINUS	Pattern contains a range.
MUTT_PDR_PLUS	Extend the range using '+'.
MUTT_PDR_WINDOW	Extend the range in both directions using '*'.
MUTT_PDR_ABSOLUTE	Absolute pattern range.
MUTT_PDR_DONE	Pattern parse successfully.
MUTT_PDR_ERROR	Invalid pattern.

Definition at line 53 of file compile.c.

{
  // clang-format off
  MUTT_PDR_NONE     =       0,  
  MUTT_PDR_MINUS    = 1U << 0,  
  MUTT_PDR_PLUS     = 1U << 1,  
  MUTT_PDR_WINDOW   = 1U << 2,  
  MUTT_PDR_ABSOLUTE = 1U << 3,  
  MUTT_PDR_DONE     = 1U << 4,  
  MUTT_PDR_ERROR    = 1U << 5,  
  // clang-format on
};

Function Documentation

get_offset()

static const char * get_offset ( struct tm * tm, const char * s, int sign )

static

Calculate a symbolic offset.

Parameters

tm	Store the time here
s	string to parse
sign	Sign of range, 1 for positive, -1 for negative

Return values

ptr	Next char after parsed offset

• Ny years
• Nm months
• Nw weeks
• Nd days

Definition at line 282 of file compile.c.

{
  char *ps = NULL;
  int offset = strtol(s, &ps, 0);
  if (((sign < 0) && (offset > 0)) || ((sign > 0) && (offset < 0)))
    offset = -offset;
 
  switch (*ps)
  {
    case 'y':
      tm->tm_year += offset;
      break;
    case 'm':
      tm->tm_mon += offset;
      break;
    case 'w':
      tm->tm_mday += 7 * offset;
      break;
    case 'd':
      tm->tm_mday += offset;
      break;
    case 'H':
      tm->tm_hour += offset;
      break;
    case 'M':
      tm->tm_min += offset;
      break;
    case 'S':
      tm->tm_sec += offset;
      break;
    default:
      return s;
  }
  mutt_date_normalize_time(tm);
  return ps + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_date()

static const char * get_date ( const char * s, struct tm * t, struct Buffer * err )

static

Parse a (partial) date in dd/mm/yyyy format.

Parameters

s	String to parse
t	Store the time here
err	Buffer for error messages

Return values

ptr	First character after the date

This function parses a (partial) date separated by '/'. The month and year are optional and if the year is less than 70 it's assumed to be after 2000.

Examples:

• "10" = 10 of this month, this year
• "10/12" = 10 of December, this year
• "10/12/04" = 10 of December, 2004
• "10/12/2008" = 10 of December, 2008
• "20081210" = 10 of December, 2008

Definition at line 336 of file compile.c.

{
  char *p = NULL;
  struct tm tm = mutt_date_localtime(mutt_date_now());
  bool iso8601 = true;
 
  for (int v = 0; v < 8; v++)
  {
    if (s[v] && (s[v] >= '0') && (s[v] <= '9'))
      continue;
 
    iso8601 = false;
    break;
  }
 
  if (iso8601)
  {
    int year = 0;
    int month = 0;
    int mday = 0;
    sscanf(s, "%4d%2d%2d", &year, &month, &mday);
 
    t->tm_year = year;
    if (t->tm_year > 1900)
      t->tm_year -= 1900;
    t->tm_mon = month - 1;
    t->tm_mday = mday;
 
    if ((t->tm_mday < 1) || (t->tm_mday > 31))
    {
      buf_printf(err, _("Invalid day of month: %s"), s);
      return NULL;
    }
    if ((t->tm_mon < 0) || (t->tm_mon > 11))
    {
      buf_printf(err, _("Invalid month: %s"), s);
      return NULL;
    }
 
    return (s + 8);
  }
 
  t->tm_mday = strtol(s, &p, 10);
  if ((t->tm_mday < 1) || (t->tm_mday > 31))
  {
    buf_printf(err, _("Invalid day of month: %s"), s);
    return NULL;
  }
  if (*p != '/')
  {
    /* fill in today's month and year */
    t->tm_mon = tm.tm_mon;
    t->tm_year = tm.tm_year;
    return p;
  }
  p++;
  t->tm_mon = strtol(p, &p, 10) - 1;
  if ((t->tm_mon < 0) || (t->tm_mon > 11))
  {
    buf_printf(err, _("Invalid month: %s"), p);
    return NULL;
  }
  if (*p != '/')
  {
    t->tm_year = tm.tm_year;
    return p;
  }
  p++;
  t->tm_year = strtol(p, &p, 10);
  if (t->tm_year < 70) /* year 2000+ */
    t->tm_year += 100;
  else if (t->tm_year > 1900)
    t->tm_year -= 1900;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_date_range()

static const char * parse_date_range ( const char * pc, struct tm * min, struct tm * max, bool have_min, struct tm * base_min, struct Buffer * err )

static

Parse a date range.

Parameters

pc	String to parse
min	Earlier date
max	Later date
have_min	Do we have a base minimum date?
base_min	Base minimum date
err	Buffer for error messages

Return values

ptr	First character after the date

Definition at line 422 of file compile.c.

{
  ParseDateRangeFlags flags = MUTT_PDR_NONE;
  while (*pc && ((flags & MUTT_PDR_DONE) == 0))
  {
    const char *pt = NULL;
    char ch = *pc++;
    SKIPWS(pc);
    switch (ch)
    {
      case '-':
      {
        /* try a range of absolute date minus offset of Ndwmy */
        pt = get_offset(min, pc, -1);
        if (pc == pt)
        {
          if (flags == MUTT_PDR_NONE)
          { /* nothing yet and no offset parsed => absolute date? */
            if (!get_date(pc, max, err))
            {
              flags |= (MUTT_PDR_ABSOLUTE | MUTT_PDR_ERRORDONE); /* done bad */
            }
            else
            {
              /* reestablish initial base minimum if not specified */
              if (!have_min)
                memcpy(min, base_min, sizeof(struct tm));
              flags |= (MUTT_PDR_ABSOLUTE | MUTT_PDR_DONE); /* done good */
            }
          }
          else
          {
            flags |= MUTT_PDR_ERRORDONE;
          }
        }
        else
        {
          pc = pt;
          if ((flags == MUTT_PDR_NONE) && !have_min)
          { /* the very first "-3d" without a previous absolute date */
            max->tm_year = min->tm_year;
            max->tm_mon = min->tm_mon;
            max->tm_mday = min->tm_mday;
          }
          flags |= MUTT_PDR_MINUS;
        }
        break;
      }
      case '+':
      { /* enlarge plus range */
        pt = get_offset(max, pc, 1);
        if (pc == pt)
        {
          flags |= MUTT_PDR_ERRORDONE;
        }
        else
        {
          pc = pt;
          flags |= MUTT_PDR_PLUS;
        }
        break;
      }
      case '*':
      { /* enlarge window in both directions */
        pt = get_offset(min, pc, -1);
        if (pc == pt)
        {
          flags |= MUTT_PDR_ERRORDONE;
        }
        else
        {
          pc = get_offset(max, pc, 1);
          flags |= MUTT_PDR_WINDOW;
        }
        break;
      }
      default:
        flags |= MUTT_PDR_ERRORDONE;
    }
    SKIPWS(pc);
  }
  if ((flags & MUTT_PDR_ERROR) && !(flags & MUTT_PDR_ABSOLUTE))
  { /* get_date has its own error message, don't overwrite it here */
    buf_printf(err, _("Invalid relative date: %s"), pc - 1);
  }
  return (flags & MUTT_PDR_ERROR) ? NULL : pc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

adjust_date_range()

static void adjust_date_range ( struct tm * min, struct tm * max )

static

Put a date range in the correct order.

Parameters

[in,out]	min	Earlier date
[in,out]	max	Later date

Definition at line 516 of file compile.c.

{
  if ((min->tm_year > max->tm_year) ||
      ((min->tm_year == max->tm_year) && (min->tm_mon > max->tm_mon)) ||
      ((min->tm_year == max->tm_year) && (min->tm_mon == max->tm_mon) &&
       (min->tm_mday > max->tm_mday)))
  {
    int tmp;
 
    tmp = min->tm_year;
    min->tm_year = max->tm_year;
    max->tm_year = tmp;
 
    tmp = min->tm_mon;
    min->tm_mon = max->tm_mon;
    max->tm_mon = tmp;
 
    tmp = min->tm_mday;
    min->tm_mday = max->tm_mday;
    max->tm_mday = tmp;
 
    min->tm_hour = 0;
    min->tm_min = 0;
    min->tm_sec = 0;
    max->tm_hour = 23;
    max->tm_min = 59;
    max->tm_sec = 59;
  }
}

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 554 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 = 137;
  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:

find_matching_paren()

static char * find_matching_paren ( char * s )

static

Find the matching parenthesis.

Parameters

s	string to search

Return values

ptr	Matching close parenthesis End of string NUL, if not found

Definition at line 812 of file compile.c.

{
  int level = 1;
 
  for (; *s; s++)
  {
    if (*s == '(')
    {
      level++;
    }
    else if (*s == ')')
    {
      level--;
      if (level == 0)
        break;
    }
  }
  return s;
}

Here is the caller graph for this function:

mutt_pattern_free()

void mutt_pattern_free

(

struct PatternList **

pat

)

Free a Pattern.

Parameters

[out]

pat

Pattern to free

Definition at line 836 of file compile.c.

{
  if (!pat || !*pat)
    return;
 
  struct Pattern *np = SLIST_FIRST(*pat);
  struct Pattern *next = NULL;
 
  while (np)
  {
    next = SLIST_NEXT(np, entries);
 
    if (np->is_multi)
    {
      mutt_list_free(&np->p.multi_cases);
    }
    else if (np->string_match || np->dynamic)
    {
      FREE(&np->p.str);
    }
    else if (np->group_match)
    {
      np->p.group = NULL;
    }
    else if (np->p.regex)
    {
      regfree(np->p.regex);
      FREE(&np->p.regex);
    }
 
#ifdef USE_DEBUG_GRAPHVIZ
    FREE(&np->raw_pattern);
#endif
    mutt_pattern_free(&np->child);
    FREE(&np);
 
    np = next;
  }
 
  FREE(pat);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_pattern_new()

static struct Pattern * mutt_pattern_new ( void )

static

Create a new Pattern.

Return values

ptr	Newly created Pattern

Definition at line 882 of file compile.c.

{
  return MUTT_MEM_CALLOC(1, struct Pattern);
}

Here is the caller graph for this function:

mutt_pattern_list_new()

static struct PatternList * mutt_pattern_list_new ( void )

static

Create a new list containing a Pattern.

Return values

ptr	Newly created list containing a single node with a Pattern

Definition at line 891 of file compile.c.

{
  struct PatternList *h = MUTT_MEM_CALLOC(1, struct PatternList);
  SLIST_INIT(h);
  struct Pattern *p = mutt_pattern_new();
  SLIST_INSERT_HEAD(h, p, entries);
  return h;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_leaf()

static struct Pattern * attach_leaf ( struct PatternList * list, struct Pattern * leaf )

static

Attach a Pattern to a Pattern List.

Parameters

list	Pattern List to attach to
leaf	Pattern to attach

Return values

ptr	Attached leaf

Definition at line 906 of file compile.c.

{
  struct Pattern *last = NULL;
  SLIST_FOREACH(last, list, entries)
  {
    // TODO - or we could use a doubly-linked list
    if (!SLIST_NEXT(last, entries))
    {
      SLIST_NEXT(last, entries) = leaf;
      break;
    }
  }
  return leaf;
}

Here is the caller graph for this function:

attach_new_root()

static struct Pattern * attach_new_root ( struct PatternList ** curlist )

static

Create a new Pattern as a parent for a List.

Parameters

curlist

Pattern List

Return values

ptr	First Pattern in the original List

Note

curlist will be altered to the new root Pattern

Definition at line 928 of file compile.c.

{
  struct PatternList *root = mutt_pattern_list_new();
  struct Pattern *leaf = SLIST_FIRST(root);
  leaf->child = *curlist;
  *curlist = root;
  return leaf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_new_leaf()

static struct Pattern * attach_new_leaf ( struct PatternList ** curlist )

static

Attach a new Pattern to a List.

Parameters

curlist

Pattern List

Return values

ptr	New Pattern in the original List

Note

curlist may be altered

Definition at line 944 of file compile.c.

{
  if (*curlist)
  {
    return attach_leaf(*curlist, mutt_pattern_new());
  }
  else
  {
    return attach_new_root(curlist);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_pattern_comp()

struct PatternList * mutt_pattern_comp	(	struct MailboxView *	mv,
		const char *	s,
		PatternCompFlags	flags,
		struct Buffer *	err )

Create a Pattern.

Parameters

mv	Mailbox view
s	Pattern string
flags	Flags, e.g. MUTT_PC_FULL_MSG
err	Buffer for error messages

Return values

ptr	Newly allocated Pattern

Definition at line 964 of file compile.c.

{
  /* curlist when assigned will always point to a list containing at least one node
   * with a Pattern value.  */
  struct PatternList *curlist = NULL;
  bool pat_not = false;
  bool all_addr = false;
  bool pat_or = false;
  bool implicit = true; /* used to detect logical AND operator */
  bool is_alias = false;
  const struct PatternFlags *entry = NULL;
  char *p = NULL;
  char *buf = NULL;
  struct Mailbox *m = mv ? mv->mailbox : NULL;
 
  if (!s || (s[0] == '\0'))
  {
    buf_strcpy(err, _("empty pattern"));
    return NULL;
  }
 
  struct Buffer *ps = buf_pool_get();
  buf_strcpy(ps, s);
  buf_seek(ps, 0);
 
  SKIPWS(ps->dptr);
  while (*ps->dptr)
  {
    switch (*ps->dptr)
    {
      case '^':
        ps->dptr++;
        all_addr = !all_addr;
        break;
      case '!':
        ps->dptr++;
        pat_not = !pat_not;
        break;
      case '@':
        ps->dptr++;
        is_alias = !is_alias;
        break;
      case '|':
        if (!pat_or)
        {
          if (!curlist)
          {
            buf_printf(err, _("error in pattern at: %s"), ps->dptr);
            buf_pool_release(&ps);
            return NULL;
          }
 
          struct Pattern *pat = SLIST_FIRST(curlist);
          if (SLIST_NEXT(pat, entries))
          {
            /* A & B | C == (A & B) | C */
            struct Pattern *root = attach_new_root(&curlist);
            root->op = MUTT_PAT_AND;
          }
 
          pat_or = true;
        }
        ps->dptr++;
        implicit = false;
        pat_not = false;
        all_addr = false;
        is_alias = false;
        break;
      case '%':
      case '=':
      case '~':
      {
        if (ps->dptr[1] == '\0')
        {
          buf_printf(err, _("missing pattern: %s"), ps->dptr);
          goto cleanup;
        }
        short thread_op = 0;
        if (ps->dptr[1] == '(')
          thread_op = MUTT_PAT_THREAD;
        else if ((ps->dptr[1] == '<') && (ps->dptr[2] == '('))
          thread_op = MUTT_PAT_PARENT;
        else if ((ps->dptr[1] == '>') && (ps->dptr[2] == '('))
          thread_op = MUTT_PAT_CHILDREN;
        if (thread_op != 0)
        {
          ps->dptr++; /* skip ~ */
          if ((thread_op == MUTT_PAT_PARENT) || (thread_op == MUTT_PAT_CHILDREN))
            ps->dptr++;
          p = find_matching_paren(ps->dptr + 1);
          if (p[0] != ')')
          {
            buf_printf(err, _("mismatched parentheses: %s"), ps->dptr);
            goto cleanup;
          }
          struct Pattern *leaf = attach_new_leaf(&curlist);
          leaf->op = thread_op;
          leaf->pat_not = pat_not;
          leaf->all_addr = all_addr;
          leaf->is_alias = is_alias;
          pat_not = false;
          all_addr = false;
          is_alias = false;
          /* compile the sub-expression */
          buf = mutt_strn_dup(ps->dptr + 1, p - (ps->dptr + 1));
          leaf->child = mutt_pattern_comp(mv, buf, flags, err);
          if (!leaf->child)
          {
            FREE(&buf);
            goto cleanup;
          }
          FREE(&buf);
          ps->dptr = p + 1; /* restore location */
          break;
        }
        if (implicit && pat_or)
        {
          /* A | B & C == (A | B) & C */
          struct Pattern *root = attach_new_root(&curlist);
          root->op = MUTT_PAT_OR;
          pat_or = false;
        }
 
        char prefix = ps->dptr[0];
        entry = lookup_tag(prefix, ps->dptr[1]);
        if (!entry)
        {
          buf_printf(err, _("%c%c: invalid pattern"), prefix, ps->dptr[1]);
          goto cleanup;
        }
        if (entry->flags && ((flags & entry->flags) == 0))
        {
          buf_printf(err, _("%c%c: not supported in this mode"), prefix, ps->dptr[1]);
          goto cleanup;
        }
 
        struct Pattern *leaf = attach_new_leaf(&curlist);
        leaf->pat_not = pat_not;
        leaf->all_addr = all_addr;
        leaf->is_alias = is_alias;
        leaf->sendmode = (flags & MUTT_PC_SEND_MODE_SEARCH);
        leaf->op = entry->op;
        pat_not = false;
        all_addr = false;
        is_alias = false;
 
        // Determine the actual eat_arg to use.
        // If the entry was found via fallback (entry->prefix is '~' but we used '=' or '%'),
        // override the eat_arg to use string or group parsing respectively.
        enum PatternEat eat_arg = entry->eat_arg;
        if ((entry->prefix == '~') && (prefix == '=') && (eat_arg == EAT_REGEX))
          eat_arg = EAT_STRING;
        else if ((entry->prefix == '~') && (prefix == '%') && (eat_arg == EAT_REGEX))
          eat_arg = EAT_GROUP;
 
        ps->dptr++; /* move past the prefix (~, %, =) */
        ps->dptr++; /* eat the operator and any optional whitespace */
        SKIPWS(ps->dptr);
        if (eat_arg)
        {
          if (ps->dptr[0] == '\0')
          {
            buf_addstr(err, _("missing parameter"));
            goto cleanup;
          }
          switch (eat_arg)
          {
            case EAT_REGEX:
              if (!eat_regex(leaf, flags, ps, err))
                goto cleanup;
              break;
            case EAT_STRING:
              if (!eat_string(leaf, flags, ps, err))
                goto cleanup;
              break;
            case EAT_GROUP:
              if (!eat_group(leaf, flags, ps, err))
                goto cleanup;
              break;
            case EAT_DATE:
              if (!eat_date(leaf, flags, ps, err))
                goto cleanup;
              break;
            case EAT_RANGE:
              if (!eat_range(leaf, flags, ps, err))
                goto cleanup;
              break;
            case EAT_MESSAGE_RANGE:
              if (!eat_message_range(leaf, flags, ps, err, mv))
                goto cleanup;
              break;
            case EAT_QUERY:
              if (!eat_query(leaf, flags, ps, err, m))
                goto cleanup;
              break;
            default:
              break;
          }
        }
        implicit = true;
        break;
      }
 
      case '(':
      {
        p = find_matching_paren(ps->dptr + 1);
        if (p[0] != ')')
        {
          buf_printf(err, _("mismatched parentheses: %s"), ps->dptr);
          goto cleanup;
        }
        /* compile the sub-expression */
        buf = mutt_strn_dup(ps->dptr + 1, p - (ps->dptr + 1));
        struct PatternList *sub = mutt_pattern_comp(mv, buf, flags, err);
        FREE(&buf);
        if (!sub)
          goto cleanup;
        struct Pattern *leaf = SLIST_FIRST(sub);
        if (curlist)
        {
          attach_leaf(curlist, leaf);
          FREE(&sub);
        }
        else
        {
          curlist = sub;
        }
        leaf->pat_not ^= pat_not;
        leaf->all_addr |= all_addr;
        leaf->is_alias |= is_alias;
        pat_not = false;
        all_addr = false;
        is_alias = false;
        ps->dptr = p + 1; /* restore location */
        break;
      }
 
      default:
        buf_printf(err, _("error in pattern at: %s"), ps->dptr);
        goto cleanup;
    }
    SKIPWS(ps->dptr);
  }
  buf_pool_release(&ps);
 
  if (!curlist)
  {
    buf_strcpy(err, _("empty pattern"));
    return NULL;
  }
 
  if (SLIST_NEXT(SLIST_FIRST(curlist), entries))
  {
    struct Pattern *root = attach_new_root(&curlist);
    root->op = pat_or ? MUTT_PAT_OR : MUTT_PAT_AND;
  }
 
  return curlist;
 
cleanup:
  mutt_pattern_free(&curlist);
  buf_pool_release(&ps);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function: