replace 'pattern_t' with 'struct Pattern'

diff --git a/hook.c b/hook.c
index 30083fb2259c18384b411cf0bae976db48640ee3..bfa4aa537b25fdc950f63c34b8a2d79b2ef5a900 100644 (file)
--- a/hook.c
+++ b/hook.c
@@ -33,7 +33,7 @@ typedef struct hook
   int type;           /* hook type */
   REGEXP rx;          /* regular expression */
   char *command;      /* filename, command or pattern to execute */
-  pattern_t *pattern; /* used for fcc,save,send-hook */
+  struct Pattern *pattern; /* used for fcc,save,send-hook */
   struct hook *next;
 } HOOK;
 
@@ -47,7 +47,7 @@ int mutt_parse_hook(struct Buffer *buf, struct Buffer *s, unsigned long data, st
   struct Buffer command, pattern;
   int rc, not = 0;
   regex_t *rx = NULL;
-  pattern_t *pat = NULL;
+  struct Pattern *pat = NULL;
   char path[_POSIX_PATH_MAX];
 
   mutt_buffer_init(&pattern);

diff --git a/imap/imap.c b/imap/imap.c
index fa93945d2b749584bfa4ebae085d10ed626700ba..b5efe175c1f5efdcc2b38add3cf2c3406edc4e2b 100644 (file)
--- a/imap/imap.c
+++ b/imap/imap.c
@@ -1707,10 +1707,10 @@ void imap_mboxcache_free(IMAP_DATA *idata)
 
 /* returns number of patterns in the search that should be done server-side
  * (eg are full-text) */
-static int do_search(const pattern_t *search, int allpats)
+static int do_search(const struct Pattern *search, int allpats)
 {
   int rc = 0;
-  const pattern_t *pat = NULL;
+  const struct Pattern *pat = NULL;
 
   for (pat = search; pat; pat = pat->next)
   {
@@ -1734,10 +1734,10 @@ static int do_search(const pattern_t *search, int allpats)
   return rc;
 }
 
-/* convert mutt pattern_t to IMAP SEARCH command containing only elements
+/* convert mutt Pattern to IMAP SEARCH command containing only elements
  * that require full-text search (mutt already has what it needs for most
  * match types, and does a better job (eg server doesn't support regexps). */
-static int imap_compile_search(const pattern_t *pat, struct Buffer *buf)
+static int imap_compile_search(const struct Pattern *pat, struct Buffer *buf)
 {
   if (!do_search(pat, 0))
     return 0;
@@ -1751,7 +1751,7 @@ static int imap_compile_search(const pattern_t *pat, struct Buffer *buf)
 
     if ((clauses = do_search(pat->child, 1)) > 0)
     {
-      const pattern_t *clause = pat->child;
+      const struct Pattern *clause = pat->child;
 
       mutt_buffer_addch(buf, '(');
 
@@ -1819,7 +1819,7 @@ static int imap_compile_search(const pattern_t *pat, struct Buffer *buf)
   return 0;
 }
 
-int imap_search(struct Context *ctx, const pattern_t *pat)
+int imap_search(struct Context *ctx, const struct Pattern *pat)
 {
   struct Buffer buf;
   IMAP_DATA *idata = ctx->data;

diff --git a/imap/imap.h b/imap/imap.h
index 91d09f7f10e8d6b8535d073e02bb4039841effbd..590b01e3686b840f7c435f58b80cd45d1a816717 100644 (file)
--- a/imap/imap.h
+++ b/imap/imap.h
@@ -38,7 +38,7 @@ int imap_sync_mailbox(struct Context *ctx, int expunge);
 int imap_close_mailbox(struct Context *ctx);
 int imap_buffy_check(int force, int check_stats);
 int imap_status(char *path, int queue);
-int imap_search(struct Context *ctx, const pattern_t *pat);
+int imap_search(struct Context *ctx, const struct Pattern *pat);
 int imap_subscribe(char *path, int subscribe);
 int imap_complete(char *dest, size_t dlen, char *path);
 int imap_fast_trash(struct Context *ctx, char *dest);

diff --git a/mutt.h b/mutt.h
index 0509dadd0cb379b46e71350f89a02be0a665460e..aeaff3a9caf2d24fd43151bd05a703d04f40599f 100644 (file)
--- a/mutt.h
+++ b/mutt.h
@@ -924,7 +924,7 @@ typedef struct group_context_t
   struct group_context_t *next;
 } group_context_t;
 
-typedef struct pattern_t
+struct Pattern
 {
   short op;
   bool not : 1;
@@ -935,14 +935,14 @@ typedef struct pattern_t
   bool isalias : 1;
   int min;
   int max;
-  struct pattern_t *next;
-  struct pattern_t *child; /* arguments to logical op */
+  struct Pattern *next;
+  struct Pattern *child; /* arguments to logical op */
   union {
     regex_t *rx;
     struct Group *g;
     char *str;
   } p;
-} pattern_t;
+};
 
 /* This is used when a message is repeatedly pattern matched against.
  * e.g. for color, scoring, hooks.  It caches a few of the potentially slow
@@ -1017,7 +1017,7 @@ struct Context
   off_t size;
   off_t vsize;
   char *pattern;            /* limit pattern string */
-  pattern_t *limit_pattern; /* compiled limit pattern */
+  struct Pattern *limit_pattern; /* compiled limit pattern */
   struct Header **hdrs;
   struct Header *last_tag;  /* last tagged msg. used to link threads */
   struct MuttThread *tree;      /* top of thread tree */

diff --git a/mutt_curses.h b/mutt_curses.h
index 3fa073c582b829b73015cdc07fe7150e89159d1c..c3d91d68cce902941ea7039d8df41a282ee7e029 100644 (file)
--- a/mutt_curses.h
+++ b/mutt_curses.h
@@ -190,7 +190,7 @@ typedef struct color_line
   regex_t rx;
   int match; /* which substringmap 0 for old behaviour */
   char *pattern;
-  struct pattern_t *color_pattern; /* compiled pattern to speed up index color
+  struct Pattern *color_pattern; /* compiled pattern to speed up index color
                                       calculation */
   short fg;
   short bg;

diff --git a/pattern.c b/pattern.c
index e2818d81158d31835c3708a2994fbcd25dbeb1df..bf676175d13a2e7d9ac8e11a1e474fc99514d8a3 100644 (file)
--- a/pattern.c
+++ b/pattern.c
@@ -47,7 +47,7 @@ enum
   RANGE_E_CTX,
 };
 
-static bool eat_regexp(pattern_t *pat, struct Buffer *s, struct Buffer *err)
+static bool eat_regexp(struct Pattern *pat, struct Buffer *s, struct Buffer *err)
 {
   struct Buffer buf;
   char errmsg[STRING];
@@ -355,7 +355,7 @@ static void adjust_date_range(struct tm *min, struct tm *max)
   }
 }
 
-static bool eat_date(pattern_t *pat, struct Buffer *s, struct Buffer *err)
+static bool eat_date(struct Pattern *pat, struct Buffer *s, struct Buffer *err)
 {
   struct Buffer buffer;
   struct tm min, max;
@@ -493,7 +493,7 @@ static bool eat_date(pattern_t *pat, struct Buffer *s, struct Buffer *err)
   return true;
 }
 
-static bool eat_range(pattern_t *pat, struct Buffer *s, struct Buffer *err)
+static bool eat_range(struct Pattern *pat, struct Buffer *s, struct Buffer *err)
 {
   char *tmp = NULL;
   int do_exclusive = 0;
@@ -672,7 +672,7 @@ static int scan_range_slot(struct Buffer *s, regmatch_t pmatch[], int grp, int s
   }
 }
 
-static void order_range(pattern_t *pat)
+static void order_range(struct Pattern *pat)
 {
   int num;
 
@@ -683,7 +683,7 @@ static void order_range(pattern_t *pat)
   pat->max = num;
 }
 
-static int eat_range_by_regexp(pattern_t *pat, struct Buffer *s, int kind, struct Buffer *err)
+static int eat_range_by_regexp(struct Pattern *pat, struct Buffer *s, int kind, struct Buffer *err)
 {
   int regerr;
   regmatch_t pmatch[RANGE_RX_GROUPS];
@@ -731,7 +731,7 @@ static int eat_range_by_regexp(pattern_t *pat, struct Buffer *s, int kind, struc
   return RANGE_E_OK;
 }
 
-static bool eat_message_range(pattern_t *pat, struct Buffer *s, struct Buffer *err)
+static bool eat_message_range(struct Pattern *pat, struct Buffer *s, struct Buffer *err)
 {
   int skip_quote = 0;
   int i_kind;
@@ -779,7 +779,7 @@ static const struct pattern_flags
   int tag; /* character used to represent this op */
   int op;  /* operation to perform */
   int class;
-  bool (*eat_arg)(pattern_t *, struct Buffer *, struct Buffer *);
+  bool (*eat_arg)(struct Pattern *, struct Buffer *, struct Buffer *);
 } Flags[] = {
   { 'A', MUTT_ALL, 0, NULL },
   { 'b', MUTT_BODY, MUTT_FULL_MSG, eat_regexp },
@@ -832,7 +832,7 @@ static const struct pattern_flags
   { 0, 0, 0, NULL },
 };
 
-static pattern_t *SearchPattern = NULL;          /* current search pattern */
+static struct Pattern *SearchPattern = NULL;          /* current search pattern */
 static char LastSearch[STRING] = { 0 };          /* last pattern searched for */
 static char LastSearchExpn[LONG_STRING] = { 0 }; /* expanded version of
                                                     LastSearch */
@@ -860,7 +860,7 @@ int mutt_which_case(const char *s)
   return REG_ICASE; /* case-insensitive */
 }
 
-static int patmatch(const pattern_t *pat, const char *buf)
+static int patmatch(const struct Pattern *pat, const char *buf)
 {
   if (pat->stringmatch)
     return pat->ign_case ? !strcasestr(buf, pat->p.str) : !strstr(buf, pat->p.str);
@@ -870,7 +870,7 @@ static int patmatch(const pattern_t *pat, const char *buf)
     return regexec(pat->p.rx, buf, 0, NULL, 0);
 }
 
-static int msg_search(struct Context *ctx, pattern_t *pat, int msgno)
+static int msg_search(struct Context *ctx, struct Pattern *pat, int msgno)
 {
   struct Message *msg = NULL;
   STATE s;
@@ -1053,9 +1053,9 @@ static /* const */ char *find_matching_paren(/* const */ char *s)
   return s;
 }
 
-void mutt_pattern_free(pattern_t **pat)
+void mutt_pattern_free(struct Pattern **pat)
 {
-  pattern_t *tmp = NULL;
+  struct Pattern *tmp = NULL;
 
   while (*pat)
   {
@@ -1078,11 +1078,11 @@ void mutt_pattern_free(pattern_t **pat)
   }
 }
 
-pattern_t *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer *err)
+struct Pattern *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer *err)
 {
-  pattern_t *curlist = NULL;
-  pattern_t *tmp = NULL, *tmp2 = NULL;
-  pattern_t *last = NULL;
+  struct Pattern *curlist = NULL;
+  struct Pattern *tmp = NULL, *tmp2 = NULL;
+  struct Pattern *last = NULL;
   bool not = false;
   bool alladdr = false;
   bool or = false;
@@ -1298,7 +1298,7 @@ pattern_t *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer *err)
   return curlist;
 }
 
-static bool perform_and(pattern_t *pat, pattern_exec_flag flags, struct Context *ctx,
+static bool perform_and(struct Pattern *pat, pattern_exec_flag flags, struct Context *ctx,
                         struct Header *hdr, pattern_cache_t *cache)
 {
   for (; pat; pat = pat->next)
@@ -1307,7 +1307,7 @@ static bool perform_and(pattern_t *pat, pattern_exec_flag flags, struct Context
   return true;
 }
 
-static int perform_or(struct pattern_t *pat, pattern_exec_flag flags,
+static int perform_or(struct Pattern *pat, pattern_exec_flag flags,
                       struct Context *ctx, struct Header *hdr, pattern_cache_t *cache)
 {
   for (; pat; pat = pat->next)
@@ -1316,7 +1316,7 @@ static int perform_or(struct pattern_t *pat, pattern_exec_flag flags,
   return false;
 }
 
-static int match_adrlist(pattern_t *pat, int match_personal, int n, ...)
+static int match_adrlist(struct Pattern *pat, int match_personal, int n, ...)
 {
   va_list ap;
   struct Address *a = NULL;
@@ -1339,7 +1339,7 @@ static int match_adrlist(pattern_t *pat, int match_personal, int n, ...)
   return pat->alladdr; /* No matches, or all matches if alladdr */
 }
 
-static bool match_reference(pattern_t *pat, struct List *refs)
+static bool match_reference(struct Pattern *pat, struct List *refs)
 {
   for (; refs; refs = refs->next)
     if (patmatch(pat, refs->data) == 0)
@@ -1388,7 +1388,7 @@ static int match_user(int alladdr, struct Address *a1, struct Address *a2)
   return alladdr;
 }
 
-static int match_threadcomplete(struct pattern_t *pat, pattern_exec_flag flags,
+static int match_threadcomplete(struct Pattern *pat, pattern_exec_flag flags,
                                 struct Context *ctx, struct MuttThread *t, int left, int up,
                                 int right, int down)
 {
@@ -1440,7 +1440,7 @@ static int is_pattern_cache_set(int cache_entry)
  * 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. */
-int mutt_pattern_exec(struct pattern_t *pat, pattern_exec_flag flags,
+int mutt_pattern_exec(struct Pattern *pat, pattern_exec_flag flags,
                       struct Context *ctx, struct Header *h, pattern_cache_t *cache)
 {
   int result;
@@ -1767,7 +1767,7 @@ bool mutt_limit_current_thread(struct Header *h)
 
 int mutt_pattern_func(int op, char *prompt)
 {
-  pattern_t *pat = NULL;
+  struct Pattern *pat = NULL;
   char buf[LONG_STRING] = "", *simple = NULL;
   struct Buffer err;
   int i;

diff --git a/protos.h b/protos.h
index 47395f7b609e532094f62f5231de7d296e0bad6c..8fc87a1065fb8c36aaa72830a464ff2a1e09baf1 100644 (file)
--- a/protos.h
+++ b/protos.h
@@ -420,16 +420,16 @@ int mutt_wctoutf8(char *s, unsigned int c, size_t buflen);
 #define IsWPrint(wc) (iswprint(wc) || (option(OPTLOCALES) ? 0 : (wc >= 0xa0)))
 #endif
 
-static inline pattern_t *new_pattern(void)
+static inline struct Pattern *new_pattern(void)
 {
-  return safe_calloc(1, sizeof(pattern_t));
+  return safe_calloc(1, sizeof(struct Pattern));
 }
 
-int mutt_pattern_exec(struct pattern_t *pat, pattern_exec_flag flags,
+int mutt_pattern_exec(struct Pattern *pat, pattern_exec_flag flags,
                       struct Context *ctx, struct Header *h, pattern_cache_t *cache);
-pattern_t *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer *err);
+struct Pattern *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer *err);
 void mutt_check_simple(char *s, size_t len, const char *simple);
-void mutt_pattern_free(pattern_t **pat);
+void mutt_pattern_free(struct Pattern **pat);
 
 int getdnsdomainname(char *, size_t);
 

diff --git a/score.c b/score.c
index 0746ee3854fda849e55d4836b03e156cfb7f5f4e..97cb4c0bc18e30f1cc798f80948df4de775951e2 100644 (file)
--- a/score.c
+++ b/score.c
@@ -25,7 +25,7 @@
 typedef struct score_t
 {
   char *str;
-  pattern_t *pat;
+  struct Pattern *pat;
   int val;
   int exact; /* if this rule matches, don't evaluate any more */
   struct score_t *next;
@@ -63,7 +63,7 @@ int mutt_parse_score(struct Buffer *buf, struct Buffer *s, unsigned long data, s
 {
   SCORE *ptr = NULL, *last = NULL;
   char *pattern = NULL, *pc = NULL;
-  struct pattern_t *pat = NULL;
+  struct Pattern *pat = NULL;
 
   mutt_extract_token(buf, s, 0);
   if (!MoreArgs(s))