lib.h File Reference

Match patterns to emails. More...

#include <stdbool.h>
#include <stdint.h>
#include "mutt/lib.h"
#include "mutt.h"
#include "search_state.h"

Include dependency graph for lib.h:

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

Go to the source code of this file.

Data Structures
struct	Pattern
	A simple (non-regex) pattern. More...
struct	PatternCache
	Cache commonly-used patterns. More...

Macros
#define	MUTT_ALIAS_SIMPLESEARCH   "~f %s | ~t %s | ~c %s"
	Simple search pattern for aliases (from/to/cc fields)

Typedefs
typedef uint8_t	PatternCompFlags
typedef uint8_t	PatternExecFlags

Enumerations
enum	PatternCompFlag { MUTT_PC_NONE = 0 , MUTT_PC_FULL_MSG = 1U << 0 , MUTT_PC_PATTERN_DYNAMIC = 1U << 1 , MUTT_PC_SEND_MODE_SEARCH = 1U << 2 }
	Flags for mutt_pattern_comp(), e.g. More...
enum	PatternExecFlag { MUTT_PAT_EXEC_NONE = 0 , MUTT_MATCH_FULL_ADDRESS = 1U << 0 }
	Flags for mutt_pattern_exec(), e.g. More...
enum	PatternType {   MUTT_PAT_AND = MUTT_MT_MAX , MUTT_PAT_OR , MUTT_PAT_THREAD , MUTT_PAT_PARENT ,   MUTT_PAT_CHILDREN , MUTT_PAT_TO , MUTT_PAT_CC , MUTT_PAT_BCC ,   MUTT_PAT_COLLAPSED , MUTT_PAT_SUBJECT , MUTT_PAT_FROM , MUTT_PAT_DATE ,   MUTT_PAT_DATE_RECEIVED , MUTT_PAT_DUPLICATED , MUTT_PAT_UNREFERENCED , MUTT_PAT_BROKEN ,   MUTT_PAT_ID , MUTT_PAT_ID_EXTERNAL , MUTT_PAT_BODY , MUTT_PAT_HEADER ,   MUTT_PAT_HORMEL , MUTT_PAT_WHOLE_MSG , MUTT_PAT_SENDER , MUTT_PAT_MESSAGE ,   MUTT_PAT_SCORE , MUTT_PAT_SIZE , MUTT_PAT_REFERENCE , MUTT_PAT_RECIPIENT ,   MUTT_PAT_LIST , MUTT_PAT_SUBSCRIBED_LIST , MUTT_PAT_PERSONAL_RECIP , MUTT_PAT_PERSONAL_FROM ,   MUTT_PAT_ADDRESS , MUTT_PAT_CRYPT_SIGN , MUTT_PAT_CRYPT_VERIFIED , MUTT_PAT_CRYPT_ENCRYPT ,   MUTT_PAT_PGP_KEY , MUTT_PAT_XLABEL , MUTT_PAT_SERVERSEARCH , MUTT_PAT_DRIVER_TAGS ,   MUTT_PAT_MIMEATTACH , MUTT_PAT_MIMETYPE , MUTT_PAT_NEWSGROUPS , MUTT_PAT_MAX }
	Types of pattern to match. More...
enum	PatternAlias { PAA_TAG , PAA_UNTAG , PAA_VISIBLE }
	What to do with the matching Aliases. More...

Functions
	SLIST_HEAD (PatternList, Pattern)
bool	mutt_pattern_exec (struct Pattern *pat, PatternExecFlags flags, struct Mailbox *m, struct Email *e, struct PatternCache *cache)
	Match a pattern against an email header.
bool	mutt_pattern_alias_exec (struct Pattern *pat, PatternExecFlags flags, struct AliasView *av, struct PatternCache *cache)
	Match a pattern against an alias.
struct PatternList *	mutt_pattern_comp (struct MailboxView *mv, const char *s, PatternCompFlags flags, struct Buffer *err)
	Create a Pattern.
void	mutt_check_simple (struct Buffer *s, const char *simple)
	Convert a simple search into a real request.
void	mutt_pattern_free (struct PatternList **pat)
	Free a Pattern.
bool	dlg_pattern (struct Buffer *buf)
	Show menu to select a Pattern -.
bool	mutt_is_list_recipient (bool all_addr, struct Envelope *env)
	Matches known mailing lists.
bool	mutt_is_subscribed_list_recipient (bool all_addr, struct Envelope *env)
	Matches subscribed mailing lists.
int	mutt_pattern_func (struct MailboxView *mv, int op, char *prompt)
	Perform some Pattern matching.
int	mutt_pattern_alias_func (char *prompt, struct AliasMenuData *mdata, enum PatternAlias action, struct Menu *menu)
	Perform some Pattern matching for Alias.
int	mutt_search_command (struct MailboxView *mv, struct Menu *menu, int cur, struct SearchState *state, SearchFlags flags)
	Perform a search.
int	mutt_search_alias_command (struct Menu *menu, int cur, struct SearchState *state, SearchFlags flags)
	Perform a search.

Variables
const struct CompleteOps	CompletePatternOps
	Auto-Completion of Patterns.

Detailed Description

Match patterns to emails.

Authors

• Richard Russon
• Pietro Cerutti

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 lib.h.

Macro Definition Documentation

MUTT_ALIAS_SIMPLESEARCH

#define MUTT_ALIAS_SIMPLESEARCH   "~f %s | ~t %s | ~c %s"

Simple search pattern for aliases (from/to/cc fields)

Definition at line 64 of file lib.h.

Typedef Documentation

PatternCompFlags

typedef uint8_t PatternCompFlags

Definition at line 78 of file lib.h.

PatternExecFlags

typedef uint8_t PatternExecFlags

Definition at line 119 of file lib.h.

Enumeration Type Documentation

PatternCompFlag

enum PatternCompFlag

Flags for mutt_pattern_comp(), e.g.

MUTT_PC_FULL_MSG

Enumerator
MUTT_PC_NONE	No flags are set.
MUTT_PC_FULL_MSG	Enable body and header matching.
MUTT_PC_PATTERN_DYNAMIC	Enable runtime date range evaluation.
MUTT_PC_SEND_MODE_SEARCH	Allow send-mode body searching.

Definition at line 71 of file lib.h.

{
  MUTT_PC_NONE             =       0,  
  MUTT_PC_FULL_MSG         = 1U << 0,  
  MUTT_PC_PATTERN_DYNAMIC  = 1U << 1,  
  MUTT_PC_SEND_MODE_SEARCH = 1U << 2,  
};

PatternExecFlag

enum PatternExecFlag

Flags for mutt_pattern_exec(), e.g.

MUTT_MATCH_FULL_ADDRESS

Enumerator
MUTT_PAT_EXEC_NONE	No flags are set.
MUTT_MATCH_FULL_ADDRESS	Match the full address.

Definition at line 114 of file lib.h.

{
  MUTT_PAT_EXEC_NONE      =       0,  
  MUTT_MATCH_FULL_ADDRESS = 1U << 0,  
};

PatternType

enum PatternType

Types of pattern to match.

Note

This enum piggy-backs on top of MessageType

See also

mutt_pattern_comp(), mutt_pattern_exec()

Enumerator
MUTT_PAT_AND	Both patterns must match.
MUTT_PAT_OR	Either pattern can match.
MUTT_PAT_THREAD	Pattern matches email thread.
MUTT_PAT_PARENT	Pattern matches parent.
MUTT_PAT_CHILDREN	Pattern matches a child email.
MUTT_PAT_TO	Pattern matches 'To:' field.
MUTT_PAT_CC	Pattern matches 'Cc:' field.
MUTT_PAT_BCC	Pattern matches 'Bcc:' field.
MUTT_PAT_COLLAPSED	Thread is collapsed.
MUTT_PAT_SUBJECT	Pattern matches 'Subject:' field.
MUTT_PAT_FROM	Pattern matches 'From:' field.
MUTT_PAT_DATE	Pattern matches 'Date:' field.
MUTT_PAT_DATE_RECEIVED	Pattern matches date received.
MUTT_PAT_DUPLICATED	Duplicate message.
MUTT_PAT_UNREFERENCED	Message is unreferenced in the thread.
MUTT_PAT_BROKEN	Message is part of a broken thread.
MUTT_PAT_ID	Pattern matches email's Message-ID.
MUTT_PAT_ID_EXTERNAL	Message-ID is among results from an external query.
MUTT_PAT_BODY	Pattern matches email's body.
MUTT_PAT_HEADER	Pattern matches email's header.
MUTT_PAT_HORMEL	Pattern matches email's spam score.
MUTT_PAT_WHOLE_MSG	Pattern matches raw email text.
MUTT_PAT_SENDER	Pattern matches sender.
MUTT_PAT_MESSAGE	Pattern matches message number.
MUTT_PAT_SCORE	Pattern matches email's score.
MUTT_PAT_SIZE	Pattern matches email's size.
MUTT_PAT_REFERENCE	Pattern matches 'References:' or 'In-Reply-To:' field.
MUTT_PAT_RECIPIENT	User is a recipient of the email.
MUTT_PAT_LIST	Email is on mailing list.
MUTT_PAT_SUBSCRIBED_LIST	Email is on subscribed mailing list.
MUTT_PAT_PERSONAL_RECIP	Email is addressed to the user.
MUTT_PAT_PERSONAL_FROM	Email is from the user.
MUTT_PAT_ADDRESS	Pattern matches any address field.
MUTT_PAT_CRYPT_SIGN	Message is signed.
MUTT_PAT_CRYPT_VERIFIED	Message is crypographically verified.
MUTT_PAT_CRYPT_ENCRYPT	Message is encrypted.
MUTT_PAT_PGP_KEY	Message has PGP key.
MUTT_PAT_XLABEL	Pattern matches keyword/label.
MUTT_PAT_SERVERSEARCH	Server-side pattern matches.
MUTT_PAT_DRIVER_TAGS	Pattern matches message tags.
MUTT_PAT_MIMEATTACH	Pattern matches number of attachments.
MUTT_PAT_MIMETYPE	Pattern matches MIME type.
MUTT_PAT_NEWSGROUPS	Pattern matches newsgroup.
MUTT_PAT_MAX

Definition at line 148 of file lib.h.

{
  MUTT_PAT_AND = MUTT_MT_MAX, 
  MUTT_PAT_OR,                
  MUTT_PAT_THREAD,            
  MUTT_PAT_PARENT,            
  MUTT_PAT_CHILDREN,          
  MUTT_PAT_TO,                
  MUTT_PAT_CC,                
  MUTT_PAT_BCC,               
  MUTT_PAT_COLLAPSED,         
  MUTT_PAT_SUBJECT,           
  MUTT_PAT_FROM,              
  MUTT_PAT_DATE,              
  MUTT_PAT_DATE_RECEIVED,     
  MUTT_PAT_DUPLICATED,        
  MUTT_PAT_UNREFERENCED,      
  MUTT_PAT_BROKEN,            
  MUTT_PAT_ID,                
  MUTT_PAT_ID_EXTERNAL,       
  MUTT_PAT_BODY,              
  MUTT_PAT_HEADER,            
  MUTT_PAT_HORMEL,            
  MUTT_PAT_WHOLE_MSG,         
  MUTT_PAT_SENDER,            
  MUTT_PAT_MESSAGE,           
  MUTT_PAT_SCORE,             
  MUTT_PAT_SIZE,              
  MUTT_PAT_REFERENCE,         
  MUTT_PAT_RECIPIENT,         
  MUTT_PAT_LIST,              
  MUTT_PAT_SUBSCRIBED_LIST,   
  MUTT_PAT_PERSONAL_RECIP,    
  MUTT_PAT_PERSONAL_FROM,     
  MUTT_PAT_ADDRESS,           
  MUTT_PAT_CRYPT_SIGN,        
  MUTT_PAT_CRYPT_VERIFIED,    
  MUTT_PAT_CRYPT_ENCRYPT,     
  MUTT_PAT_PGP_KEY,           
  MUTT_PAT_XLABEL,            
  MUTT_PAT_SERVERSEARCH,      
  MUTT_PAT_DRIVER_TAGS,       
  MUTT_PAT_MIMEATTACH,        
  MUTT_PAT_MIMETYPE,          
  MUTT_PAT_NEWSGROUPS,        
  MUTT_PAT_MAX,
};

PatternAlias

enum PatternAlias

What to do with the matching Aliases.

Enumerator
PAA_TAG	Set AliasView.is_tagged, but don't touch the others.
PAA_UNTAG	Unset AliasView.is_tagged, but don't touch the others.
PAA_VISIBLE	Set AliasView.is_visible and hide the rest.

Definition at line 199 of file lib.h.

{
  PAA_TAG,        
  PAA_UNTAG,      
  PAA_VISIBLE,    
};

Function Documentation

SLIST_HEAD()

SLIST_HEAD	(	PatternList	,
		Pattern	)

mutt_pattern_exec()

bool mutt_pattern_exec	(	struct Pattern *	pat,
		PatternExecFlags	flags,
		struct Mailbox *	m,
		struct Email *	e,
		struct PatternCache *	cache )

Match a pattern against an email header.

Parameters

pat	Pattern to match
flags	Flags, e.g. MUTT_MATCH_FULL_ADDRESS
m	Mailbox
e	Email
cache	Cache for common Patterns

Return values

true	Success, pattern matched
false	Pattern did not match

flags: MUTT_MATCH_FULL_ADDRESS: match both personal and machine address cache: For repeated matches against the same Header, passing in non-NULL will store some of the cacheable pattern matches in this structure.

Definition at line 1151 of file exec.c.

{
  const bool needs_msg = pattern_needs_msg(m, pat);
  struct Message *msg = needs_msg ? mx_msg_open(m, e) : NULL;
  if (needs_msg && !msg)
  {
    return false;
  }
  const bool matched = pattern_exec(pat, flags, m, e, msg, cache);
  mx_msg_close(m, &msg);
  return matched;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_pattern_alias_exec()

bool mutt_pattern_alias_exec	(	struct Pattern *	pat,
		PatternExecFlags	flags,
		struct AliasView *	av,
		struct PatternCache *	cache )

Match a pattern against an alias.

Parameters

pat	Pattern to match
flags	Flags, e.g. MUTT_MATCH_FULL_ADDRESS
av	AliasView
cache	Cache for common Patterns

Return values

true	Success, pattern matched
false	Pattern did not match

flags: MUTT_MATCH_FULL_ADDRESS: match both personal and machine address cache: For repeated matches against the same Alias, passing in non-NULL will store some of the cacheable pattern matches in this structure.

Definition at line 1178 of file exec.c.

{
  switch (pat->op)
  {
    case MUTT_PAT_FROM: /* alias */
      if (!av->alias)
        return false;
      return pat->pat_not ^ (av->alias->name && patmatch(pat, av->alias->name));
    case MUTT_PAT_CC: /* comment */
      if (!av->alias)
        return false;
      return pat->pat_not ^ (av->alias->comment && patmatch(pat, av->alias->comment));
    case MUTT_PAT_TO: /* alias address list */
      if (!av->alias)
        return false;
      return pat->pat_not ^ match_addrlist(pat, (flags & MUTT_MATCH_FULL_ADDRESS),
                                           1, &av->alias->addr);
    case MUTT_PAT_DRIVER_TAGS:
      if (!av->alias)
        return false;
      return match_tags(pat, &av->alias->tags);
    case MUTT_PAT_AND:
      return pat->pat_not ^ (perform_alias_and(pat->child, flags, av, cache) > 0);
    case MUTT_PAT_OR:
      return pat->pat_not ^ (perform_alias_or(pat->child, flags, av, cache) > 0);
  }
 
  return false;
}

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:

mutt_check_simple()

void mutt_check_simple	(	struct Buffer *	buf,
		const char *	simple )

Convert a simple search into a real request.

Parameters

buf	Buffer for the result
simple	Search string to convert

Definition at line 91 of file pattern.c.

{
  bool do_simple = true;
 
  for (const char *p = buf_string(buf); p && (p[0] != '\0'); p++)
  {
    if ((p[0] == '\\') && (p[1] != '\0'))
    {
      p++;
    }
    else if ((p[0] == '~') || (p[0] == '=') || (p[0] == '%'))
    {
      do_simple = false;
      break;
    }
  }
 
  /* XXX - is mutt_istr_cmp() right here, or should we use locale's
   * equivalences?  */
 
  if (do_simple) /* yup, so spoof a real request */
  {
    /* convert old tokens into the new format */
    if (mutt_istr_equal("all", buf_string(buf)) || mutt_str_equal("^", buf_string(buf)) ||
        mutt_str_equal(".", buf_string(buf))) /* ~A is more efficient */
    {
      buf_strcpy(buf, "~A");
    }
    else if (mutt_istr_equal("del", buf_string(buf)))
    {
      buf_strcpy(buf, "~D");
    }
    else if (mutt_istr_equal("flag", buf_string(buf)))
    {
      buf_strcpy(buf, "~F");
    }
    else if (mutt_istr_equal("new", buf_string(buf)))
    {
      buf_strcpy(buf, "~N");
    }
    else if (mutt_istr_equal("old", buf_string(buf)))
    {
      buf_strcpy(buf, "~O");
    }
    else if (mutt_istr_equal("repl", buf_string(buf)))
    {
      buf_strcpy(buf, "~Q");
    }
    else if (mutt_istr_equal("read", buf_string(buf)))
    {
      buf_strcpy(buf, "~R");
    }
    else if (mutt_istr_equal("tag", buf_string(buf)))
    {
      buf_strcpy(buf, "~T");
    }
    else if (mutt_istr_equal("unread", buf_string(buf)))
    {
      buf_strcpy(buf, "~U");
    }
    else
    {
      struct Buffer *tmp = buf_pool_get();
      quote_simple(buf_string(buf), tmp);
      mutt_file_expand_fmt(buf, simple, buf_string(tmp));
      buf_pool_release(&tmp);
    }
  }
}

Here is the call graph for this function:

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_is_list_recipient()

bool mutt_is_list_recipient	(	bool	all_addr,
		struct Envelope *	env )

Matches known mailing lists.

Parameters

all_addr	If true, ALL Addresses must be mailing lists
env	Envelope

Return values

true	One Address is a mailing list (all_addr is false) All the Addresses are mailing lists (all_addr is true)

Definition at line 507 of file exec.c.

{
  return mutt_is_predicate_recipient(all_addr, env, &mutt_is_mail_list);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_is_subscribed_list_recipient()

bool mutt_is_subscribed_list_recipient	(	bool	all_addr,
		struct Envelope *	env )

Matches subscribed mailing lists.

Parameters

all_addr	If true, ALL Addresses must be on the subscribed list
env	Envelope

Return values

true	One Address is subscribed (all_addr is false) All the Addresses are subscribed (all_addr is true)

Definition at line 494 of file exec.c.

{
  return mutt_is_predicate_recipient(all_addr, env, &mutt_is_subscribed_list);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_pattern_func()

int mutt_pattern_func	(	struct MailboxView *	mv,
		int	op,
		char *	prompt )

Perform some Pattern matching.

Parameters

mv	Mailbox View
op	Operation to perform, e.g. MUTT_LIMIT
prompt	Prompt to show the user

Return values

0	Success
-1	Failure

Definition at line 295 of file pattern.c.

{
  if (!mv || !mv->mailbox)
    return -1;
 
  struct Mailbox *m = mv->mailbox;
 
  struct Buffer *err = NULL;
  int rc = -1;
  struct Progress *progress = NULL;
  struct Buffer *buf = buf_pool_get();
  bool interrupted = false;
 
  buf_strcpy(buf, mv->pattern);
  if (prompt || (op != MUTT_LIMIT))
  {
    if ((mw_get_field(prompt, buf, MUTT_COMP_CLEAR, HC_PATTERN, &CompletePatternOps, NULL) != 0) ||
        buf_is_empty(buf))
    {
      buf_pool_release(&buf);
      return -1;
    }
  }
 
  mutt_message(_("Compiling search pattern..."));
 
  char *simple = buf_strdup(buf);
  const char *const c_simple_search = cs_subset_string(NeoMutt->sub, "simple_search");
  mutt_check_simple(buf, NONULL(c_simple_search));
  const char *pbuf = buf->data;
  while (*pbuf == ' ')
    pbuf++;
  const bool match_all = mutt_str_equal(pbuf, "~A");
 
  err = buf_pool_get();
  struct PatternList *pat = mutt_pattern_comp(mv, buf->data, MUTT_PC_FULL_MSG, err);
  if (!pat)
  {
    mutt_error("%s", buf_string(err));
    goto bail;
  }
 
  if ((m->type == MUTT_IMAP) && (!imap_search(m, pat)))
    goto bail;
 
  progress = progress_new(MUTT_PROGRESS_READ, (op == MUTT_LIMIT) ? m->msg_count : m->vcount);
  progress_set_message(progress, _("Executing command on matching messages..."));
 
  if (op == MUTT_LIMIT)
  {
    m->vcount = 0;
    mv->vsize = 0;
    mv->collapsed = false;
    int padding = mx_msg_padding_size(m);
 
    for (int i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
 
      if (SigInt)
      {
        interrupted = true;
        SigInt = false;
        break;
      }
      progress_update(progress, i, -1);
      /* new limit pattern implicitly uncollapses all threads */
      e->vnum = -1;
      e->visible = false;
      e->limit_visited = true;
      e->collapsed = false;
      e->num_hidden = 0;
 
      if (match_all ||
          mutt_pattern_exec(SLIST_FIRST(pat), MUTT_MATCH_FULL_ADDRESS, m, e, NULL))
      {
        e->vnum = m->vcount;
        e->visible = true;
        m->v2r[m->vcount] = i;
        m->vcount++;
        struct Body *b = e->body;
        mv->vsize += b->length + b->offset - b->hdr_offset + padding;
      }
    }
  }
  else
  {
    for (int i = 0; i < m->vcount; i++)
    {
      struct Email *e = mutt_get_virt_email(m, i);
      if (!e)
        continue;
 
      if (SigInt)
      {
        interrupted = true;
        SigInt = false;
        break;
      }
      progress_update(progress, i, -1);
      if (mutt_pattern_exec(SLIST_FIRST(pat), MUTT_MATCH_FULL_ADDRESS, m, e, NULL))
      {
        switch (op)
        {
          case MUTT_UNDELETE:
            mutt_set_flag(m, e, MUTT_PURGE, false, true);
            FALLTHROUGH;
 
          case MUTT_DELETE:
            mutt_set_flag(m, e, MUTT_DELETE, (op == MUTT_DELETE), true);
            break;
          case MUTT_TAG:
          case MUTT_UNTAG:
            mutt_set_flag(m, e, MUTT_TAG, (op == MUTT_TAG), true);
            break;
        }
      }
    }
  }
  progress_free(&progress);
 
  mutt_clear_error();
 
  if (op == MUTT_LIMIT)
  {
    /* drop previous limit pattern */
    FREE(&mv->pattern);
    mutt_pattern_free(&mv->limit_pattern);
 
    if (m->msg_count && !m->vcount)
      mutt_error(_("No messages matched criteria"));
 
    /* record new limit pattern, unless match all */
    if (!match_all)
    {
      mv->pattern = simple;
      simple = NULL; /* don't clobber it */
      mv->limit_pattern = mutt_pattern_comp(mv, buf->data, MUTT_PC_FULL_MSG, err);
    }
  }
 
  if (interrupted)
    mutt_error(_("Search interrupted"));
 
  rc = 0;
 
bail:
  buf_pool_release(&buf);
  buf_pool_release(&err);
  FREE(&simple);
  mutt_pattern_free(&pat);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_pattern_alias_func()

int mutt_pattern_alias_func	(	char *	prompt,
		struct AliasMenuData *	mdata,
		enum PatternAlias	action,
		struct Menu *	menu )

Perform some Pattern matching for Alias.

Parameters

prompt	Prompt to show the user
mdata	Menu data holding Aliases
action	What to do with the results, e.g. PAA_TAG
menu	Current menu

Return values

0	Success
-1	Failure

Definition at line 170 of file pattern.c.

{
  int rc = -1;
  struct Progress *progress = NULL;
  struct Buffer *buf = buf_pool_get();
 
  buf_strcpy(buf, mdata->limit);
  if (prompt)
  {
    if ((mw_get_field(prompt, buf, MUTT_COMP_CLEAR, HC_PATTERN, &CompletePatternOps, NULL) != 0) ||
        buf_is_empty(buf))
    {
      buf_pool_release(&buf);
      return -1;
    }
  }
 
  mutt_message(_("Compiling search pattern..."));
 
  /* Compile the pattern string; "~A" means match-all.  If the simple string
   * was expanded into a pattern, compile it for evaluation. */
  bool match_all = false;
  struct PatternList *pat = NULL;
  char *simple = buf_strdup(buf);
  if (simple)
  {
    mutt_check_simple(buf, MUTT_ALIAS_SIMPLESEARCH);
    const char *pbuf = buf->data;
    while (*pbuf == ' ')
      pbuf++;
    match_all = mutt_str_equal(pbuf, "~A");
 
    struct Buffer *err = buf_pool_get();
    pat = mutt_pattern_comp(NULL, buf->data, MUTT_PC_FULL_MSG, err);
    if (!pat)
    {
      mutt_error("%s", buf_string(err));
      buf_pool_release(&err);
      goto bail;
    }
    buf_pool_release(&err);
  }
  else
  {
    match_all = true;
  }
 
  progress = progress_new(MUTT_PROGRESS_READ, ARRAY_SIZE(&mdata->ava));
  progress_set_message(progress, _("Executing command on matching messages..."));
 
  /* Apply the action (tag, untag, or filter visibility) to each alias
   * that matches the compiled pattern */
  int vcounter = 0;
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata->ava)
  {
    progress_update(progress, ARRAY_FOREACH_IDX_avp, -1);
 
    if (match_all ||
        mutt_pattern_alias_exec(SLIST_FIRST(pat), MUTT_MATCH_FULL_ADDRESS, avp, NULL))
    {
      switch (action)
      {
        case PAA_TAG:
          avp->is_tagged = true;
          break;
        case PAA_UNTAG:
          avp->is_tagged = false;
          break;
        case PAA_VISIBLE:
          avp->is_visible = true;
          vcounter++;
          break;
      }
    }
    else
    {
      switch (action)
      {
        case PAA_TAG:
        case PAA_UNTAG:
          // Do nothing
          break;
        case PAA_VISIBLE:
          avp->is_visible = false;
          break;
      }
    }
  }
  progress_free(&progress);
 
  FREE(&mdata->limit);
  if (!match_all)
  {
    mdata->limit = simple;
    simple = NULL;
  }
 
  if (menu && (action == PAA_VISIBLE))
  {
    menu->max = vcounter;
    menu_set_index(menu, 0);
  }
 
  mutt_clear_error();
 
  rc = 0;
 
bail:
  buf_pool_release(&buf);
  FREE(&simple);
  mutt_pattern_free(&pat);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_search_command()

int mutt_search_command	(	struct MailboxView *	mv,
		struct Menu *	menu,
		int	cur,
		struct SearchState *	state,
		SearchFlags	flags )

Perform a search.

Parameters

mv	Mailbox view to search through
menu	Current Menu
cur	Index number of current email
state	Current search state
flags	Search flags, e.g. SEARCH_PROMPT

Return values

>=0	Index of matching email
-1	No match, or error

Definition at line 462 of file pattern.c.

{
  struct Progress *progress = NULL;
  int rc = -1;
  struct Mailbox *m = mv ? mv->mailbox : NULL;
  if (!m)
    return -1;
  bool pattern_changed = false;
 
  if (buf_is_empty(state->string) || (flags & SEARCH_PROMPT))
  {
    if ((mw_get_field((state->reverse) ? _("Reverse search for: ") : _("Search for: "),
                      state->string, MUTT_COMP_CLEAR, HC_PATTERN,
                      &CompletePatternOps, NULL) != 0) ||
        buf_is_empty(state->string))
    {
      goto done;
    }
 
    /* compare the *expanded* version of the search pattern in case
     * $simple_search has changed while we were searching */
    struct Buffer *tmp = buf_pool_get();
    buf_copy(tmp, state->string);
    const char *const c_simple_search = cs_subset_string(NeoMutt->sub, "simple_search");
    mutt_check_simple(tmp, NONULL(c_simple_search));
    if (!buf_str_equal(tmp, state->string_expn))
    {
      mutt_pattern_free(&state->pattern);
      buf_copy(state->string_expn, tmp);
      buf_pool_release(&tmp);
    }
  }
 
  if (!state->pattern)
  {
    mutt_message(_("Compiling search pattern..."));
    mutt_pattern_free(&state->pattern);
    struct Buffer *err = buf_pool_get();
    state->pattern = mutt_pattern_comp(mv, state->string_expn->data, MUTT_PC_FULL_MSG, err);
    pattern_changed = true;
    if (!state->pattern)
    {
      mutt_error("%s", buf_string(err));
      buf_free(&err);
      buf_reset(state->string);
      buf_reset(state->string_expn);
      return -1;
    }
    buf_free(&err);
    mutt_clear_error();
  }
 
  if (pattern_changed)
  {
    for (int i = 0; i < m->msg_count; i++)
      m->emails[i]->searched = false;
    if ((m->type == MUTT_IMAP) && (!imap_search(m, state->pattern)))
      return -1;
  }
 
  int incr = state->reverse ? -1 : 1;
  if (flags & SEARCH_OPPOSITE)
    incr = -incr;
 
  progress = progress_new(MUTT_PROGRESS_READ, m->vcount);
  progress_set_message(progress, _("Searching..."));
 
  const bool c_wrap_search = cs_subset_bool(NeoMutt->sub, "wrap_search");
  for (int i = cur + incr, j = 0; j != m->vcount; j++)
  {
    const char *msg = NULL;
    progress_update(progress, j, -1);
    if (i > m->vcount - 1)
    {
      i = 0;
      if (c_wrap_search)
      {
        msg = _("Search wrapped to top");
      }
      else
      {
        mutt_message(_("Search hit bottom without finding match"));
        goto done;
      }
    }
    else if (i < 0)
    {
      i = m->vcount - 1;
      if (c_wrap_search)
      {
        msg = _("Search wrapped to bottom");
      }
      else
      {
        mutt_message(_("Search hit top without finding match"));
        goto done;
      }
    }
 
    struct Email *e = mutt_get_virt_email(m, i);
    if (!e)
      goto done;
 
    if (e->searched)
    {
      /* if we've already evaluated this message, use the cached value */
      if (e->matched)
      {
        mutt_clear_error();
        if (msg && *msg)
          mutt_message("%s", msg);
        rc = i;
        goto done;
      }
    }
    else
    {
      /* remember that we've already searched this message */
      e->searched = true;
      e->matched = mutt_pattern_exec(SLIST_FIRST(state->pattern),
                                     MUTT_MATCH_FULL_ADDRESS, m, e, NULL);
      if (e->matched)
      {
        mutt_clear_error();
        if (msg && *msg)
          mutt_message("%s", msg);
        rc = i;
        goto done;
      }
    }
 
    if (SigInt)
    {
      mutt_error(_("Search interrupted"));
      SigInt = false;
      goto done;
    }
 
    i += incr;
  }
 
  mutt_error(_("Not found"));
done:
  progress_free(&progress);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_search_alias_command()

int mutt_search_alias_command	(	struct Menu *	menu,
		int	cur,
		struct SearchState *	state,
		SearchFlags	flags )

Perform a search.

Parameters

menu	Menu to search through
cur	Index number of current email
state	Current search state
flags	Search flags, e.g. SEARCH_PROMPT

Return values

>=0	Index of matching alias
-1	No match, or error

Definition at line 619 of file pattern.c.

{
  struct Progress *progress = NULL;
  const struct AliasMenuData *mdata = menu->mdata;
  const struct AliasViewArray *ava = &mdata->ava;
  int rc = -1;
  bool pattern_changed = false;
 
  if (buf_is_empty(state->string) || flags & SEARCH_PROMPT)
  {
    if ((mw_get_field(state->reverse ? _("Reverse search for: ") : _("Search for: "),
                      state->string, MUTT_COMP_CLEAR, HC_PATTERN,
                      &CompletePatternOps, NULL) != 0) ||
        buf_is_empty(state->string))
    {
      goto done;
    }
 
    /* compare the *expanded* version of the search pattern in case
     * $simple_search has changed while we were searching */
    struct Buffer *tmp = buf_pool_get();
    buf_copy(tmp, state->string);
    mutt_check_simple(tmp, MUTT_ALIAS_SIMPLESEARCH);
    if (!buf_str_equal(tmp, state->string_expn))
    {
      mutt_pattern_free(&state->pattern);
      buf_copy(state->string_expn, tmp);
      buf_pool_release(&tmp);
    }
  }
 
  if (!state->pattern)
  {
    mutt_message(_("Compiling search pattern..."));
    struct Buffer *err = buf_pool_get();
    state->pattern = mutt_pattern_comp(NULL, state->string_expn->data, MUTT_PC_FULL_MSG, err);
    pattern_changed = true;
    if (!state->pattern)
    {
      mutt_error("%s", buf_string(err));
      buf_free(&err);
      buf_reset(state->string);
      buf_reset(state->string_expn);
      return -1;
    }
    buf_free(&err);
    mutt_clear_error();
  }
 
  if (pattern_changed)
  {
    struct AliasView *av = NULL;
    ARRAY_FOREACH(av, ava)
    {
      av->is_searched = false;
    }
  }
 
  int incr = state->reverse ? -1 : 1;
  if (flags & SEARCH_OPPOSITE)
    incr = -incr;
 
  progress = progress_new(MUTT_PROGRESS_READ, ARRAY_SIZE(ava));
  progress_set_message(progress, _("Searching..."));
 
  const bool c_wrap_search = cs_subset_bool(NeoMutt->sub, "wrap_search");
  for (int i = cur + incr, j = 0; j != ARRAY_SIZE(ava); j++)
  {
    const char *msg = NULL;
    progress_update(progress, j, -1);
    if (i > ARRAY_SIZE(ava) - 1)
    {
      i = 0;
      if (c_wrap_search)
      {
        msg = _("Search wrapped to top");
      }
      else
      {
        mutt_message(_("Search hit bottom without finding match"));
        goto done;
      }
    }
    else if (i < 0)
    {
      i = ARRAY_SIZE(ava) - 1;
      if (c_wrap_search)
      {
        msg = _("Search wrapped to bottom");
      }
      else
      {
        mutt_message(_("Search hit top without finding match"));
        goto done;
      }
    }
 
    struct AliasView *av = ARRAY_GET(ava, i);
    if (av->is_searched)
    {
      /* if we've already evaluated this message, use the cached value */
      if (av->is_matched)
      {
        mutt_clear_error();
        if (msg && *msg)
          mutt_message("%s", msg);
        rc = i;
        goto done;
      }
    }
    else
    {
      /* remember that we've already searched this message */
      av->is_searched = true;
      av->is_matched = mutt_pattern_alias_exec(SLIST_FIRST(state->pattern),
                                               MUTT_MATCH_FULL_ADDRESS, av, NULL);
      if (av->is_matched)
      {
        mutt_clear_error();
        if (msg && *msg)
          mutt_message("%s", msg);
        rc = i;
        goto done;
      }
    }
 
    if (SigInt)
    {
      mutt_error(_("Search interrupted"));
      SigInt = false;
      goto done;
    }
 
    i += incr;
  }
 
  mutt_error(_("Not found"));
done:
  progress_free(&progress);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CompletePatternOps

const struct CompleteOps CompletePatternOps

extern

Auto-Completion of Patterns.

Definition at line 98 of file complete.c.

                                              {
  .complete = complete_pattern,
};