define flags for mutt_pattern_comp()

diff --git a/color.c b/color.c
index f8573bf08b60fde59476475b4b3e79d8e60aa8dd..2cfda34461903fbf403e6efda8c1b16f2b61fccd 100644 (file)
--- a/color.c
+++ b/color.c
@@ -806,7 +806,7 @@ static enum CommandResult add_pattern(struct ColorLineHead *top, const char *s,
       struct Buffer *buf = mutt_buffer_pool_get();
       mutt_buffer_strcpy(buf, s);
       mutt_check_simple(buf, NONULL(C_SimpleSearch));
-      tmp->color_pattern = mutt_pattern_comp(buf->data, MUTT_FULL_MSG, err);
+      tmp->color_pattern = mutt_pattern_comp(buf->data, MUTT_PC_FULL_MSG, err);
       mutt_buffer_pool_release(&buf);
       if (!tmp->color_pattern)
       {

diff --git a/hook.c b/hook.c
index 6f70bebe3163c76d3cc44fc91a07e0fe46492c09..5b5134ae79db36daf1060a90e5e3d559804ae225 100644 (file)
--- a/hook.c
+++ b/hook.c
@@ -250,9 +250,11 @@ enum CommandResult mutt_parse_hook(struct Buffer *buf, struct Buffer *s,
   else if (data & (MUTT_SEND_HOOK | MUTT_SEND2_HOOK | MUTT_SAVE_HOOK |
                    MUTT_FCC_HOOK | MUTT_MESSAGE_HOOK | MUTT_REPLY_HOOK))
   {
-    pat = mutt_pattern_comp(
-        pattern.data,
-        (data & (MUTT_SEND_HOOK | MUTT_SEND2_HOOK | MUTT_FCC_HOOK)) ? 0 : MUTT_FULL_MSG, err);
+    pat = mutt_pattern_comp(pattern.data,
+                            (data & (MUTT_SEND_HOOK | MUTT_SEND2_HOOK | MUTT_FCC_HOOK)) ?
+                                MUTT_PC_NO_FLAGS :
+                                MUTT_PC_FULL_MSG,
+                            err);
     if (!pat)
       goto error;
   }
@@ -422,12 +424,12 @@ enum CommandResult mutt_parse_idxfmt_hook(struct Buffer *buf, struct Buffer *s,
     }
   }
 
-  /* MUTT_PATTERN_DYNAMIC sets so that date ranges are regenerated during
+  /* MUTT_PC_PATTERN_DYNAMIC sets so that date ranges are regenerated during
    * matching.  This of course is slower, but index-format-hook is commonly
    * used for date ranges, and they need to be evaluated relative to "now", not
    * the hook compilation time.  */
-  struct PatternHead *pat =
-      mutt_pattern_comp(mutt_b2s(pattern), MUTT_FULL_MSG | MUTT_PATTERN_DYNAMIC, err);
+  struct PatternHead *pat = mutt_pattern_comp(
+      mutt_b2s(pattern), MUTT_PC_FULL_MSG | MUTT_PC_PATTERN_DYNAMIC, err);
   if (!pat)
     goto out;
 

diff --git a/pattern.c b/pattern.c
index e52e85e839e04897521f777f153ee188fa07f8b0..d7d54d76749ad5002389073109c458edc75ff68d 100644 (file)
--- a/pattern.c
+++ b/pattern.c
@@ -161,7 +161,7 @@ enum RangeSide
 /**
  * typedef pattern_eat_t - Parse a pattern
  * @param pat   Pattern to store the results in
- * @param flags Flags, e.g. #MUTT_PATTERN_DYNAMIC
+ * @param flags Flags, e.g. #MUTT_PC_PATTERN_DYNAMIC
  * @param s     String to parse
  * @param err   Buffer for error messages
  * @retval true If the pattern was read successfully
@@ -176,7 +176,7 @@ struct PatternFlags
 {
   int tag;                ///< character used to represent this op
   int op;                 ///< operation to perform
-  int flags;              ///< Pattern flags, e.g. #MUTT_FULL_MSG
+  int flags;              ///< Pattern flags, e.g. #MUTT_PC_FULL_MSG
   pattern_eat_t *eat_arg; ///< Callback function to parse the argument
 };
 
@@ -1039,7 +1039,7 @@ static bool eat_date(struct Pattern *pat, int flags, struct Buffer *s, struct Bu
     goto out;
   }
 
-  if (flags & MUTT_PATTERN_DYNAMIC)
+  if (flags & MUTT_PC_PATTERN_DYNAMIC)
   {
     pat->dynamic = true;
     pat->p.str = mutt_str_strdup(tmp->data);
@@ -1237,8 +1237,8 @@ static bool msg_search(struct Mailbox *m, struct Pattern *pat, int msgno)
  */
 static const struct PatternFlags Flags[] = {
   { 'A', MUTT_ALL,                 0,             NULL },
-  { 'b', MUTT_PAT_BODY,            MUTT_FULL_MSG, eat_regex },
-  { 'B', MUTT_PAT_WHOLE_MSG,       MUTT_FULL_MSG, eat_regex },
+  { 'b', MUTT_PAT_BODY,            MUTT_PC_FULL_MSG, eat_regex },
+  { 'B', MUTT_PAT_WHOLE_MSG,       MUTT_PC_FULL_MSG, eat_regex },
   { 'c', MUTT_PAT_CC,              0,             eat_regex },
   { 'C', MUTT_PAT_RECIPIENT,       0,             eat_regex },
   { 'd', MUTT_PAT_DATE,            0,             eat_date },
@@ -1249,7 +1249,7 @@ static const struct PatternFlags Flags[] = {
   { 'F', MUTT_FLAG,                0,             NULL },
   { 'g', MUTT_PAT_CRYPT_SIGN,      0,             NULL },
   { 'G', MUTT_PAT_CRYPT_ENCRYPT,   0,             NULL },
-  { 'h', MUTT_PAT_HEADER,          MUTT_FULL_MSG, eat_regex },
+  { 'h', MUTT_PAT_HEADER,          MUTT_PC_FULL_MSG, eat_regex },
   { 'H', MUTT_PAT_HORMEL,          0,             eat_regex },
   { 'i', MUTT_PAT_ID,              0,             eat_regex },
   { 'I', MUTT_PAT_ID_EXTERNAL,     0,             eat_query },
@@ -1257,7 +1257,7 @@ static const struct PatternFlags Flags[] = {
   { 'l', MUTT_PAT_LIST,            0,             NULL },
   { 'L', MUTT_PAT_ADDRESS,         0,             eat_regex },
   { 'm', MUTT_PAT_MESSAGE,         0,             eat_message_range },
-  { 'M', MUTT_PAT_MIMETYPE,        MUTT_FULL_MSG, eat_regex },
+  { 'M', MUTT_PAT_MIMETYPE,        MUTT_PC_FULL_MSG, eat_regex },
   { 'n', MUTT_PAT_SCORE,           0,             eat_range },
   { 'N', MUTT_NEW,                 0,             NULL },
   { 'O', MUTT_OLD,                 0,             NULL },
@@ -1379,11 +1379,11 @@ static struct PatternHead *mutt_pattern_node_new(void)
 /**
  * mutt_pattern_comp - Create a Pattern
  * @param s     Pattern string
- * @param flags Flags, e.g. #MUTT_FULL_MSG
+ * @param flags Flags, e.g. #MUTT_PC_FULL_MSG
  * @param err   Buffer for error messages
  * @retval ptr Newly allocated Pattern
  */
-struct PatternHead *mutt_pattern_comp(const char *s, int flags, struct Buffer *err)
+struct PatternHead *mutt_pattern_comp(const char *s, PatternCompFlags flags, struct Buffer *err)
 {
   /* curlist when assigned will always point to a list containing at least one node
    * with a Pattern value.  */
@@ -2440,7 +2440,7 @@ int mutt_pattern_func(int op, char *prompt)
   mutt_buffer_init(&err);
   err.dsize = 256;
   err.data = mutt_mem_malloc(err.dsize);
-  struct PatternHead *pat = mutt_pattern_comp(buf->data, MUTT_FULL_MSG, &err);
+  struct PatternHead *pat = mutt_pattern_comp(buf->data, MUTT_PC_FULL_MSG, &err);
   if (!pat)
   {
     mutt_error("%s", err.data);
@@ -2534,7 +2534,7 @@ int mutt_pattern_func(int op, char *prompt)
     {
       Context->pattern = simple;
       simple = NULL; /* don't clobber it */
-      Context->limit_pattern = mutt_pattern_comp(buf->data, MUTT_FULL_MSG, &err);
+      Context->limit_pattern = mutt_pattern_comp(buf->data, MUTT_PC_FULL_MSG, &err);
     }
   }
 
@@ -2595,7 +2595,7 @@ int mutt_search_command(int cur, int op)
       mutt_pattern_free(&SearchPattern);
       err.dsize = 256;
       err.data = mutt_mem_malloc(err.dsize);
-      SearchPattern = mutt_pattern_comp(tmp->data, MUTT_FULL_MSG, &err);
+      SearchPattern = mutt_pattern_comp(tmp->data, MUTT_PC_FULL_MSG, &err);
       if (!SearchPattern)
       {
         mutt_buffer_pool_release(&tmp);

diff --git a/pattern.h b/pattern.h
index 5d03709f57fa986beef48851f2a8e04387212f1c..3f432fc62c13a89a35c2979c622f5859c1a76eeb 100644 (file)
--- a/pattern.h
+++ b/pattern.h
@@ -38,9 +38,10 @@ struct Mailbox;
 /* These Config Variables are only used in pattern.c */
 extern bool C_ThoroughSearch;
 
-/* flag to mutt_pattern_comp() */
-#define MUTT_FULL_MSG           (1<<0)  ///< enable body and header matching
-#define MUTT_PATTERN_DYNAMIC    (1<<1)  ///< enable runtime date range evaluation
+typedef uint8_t PatternCompFlags;       ///< Flags for mutt_pattern_comp(), e.g. #MUTT_PC_FULL_MSG
+#define MUTT_PC_NO_FLAGS            0   ///< No flags are set
+#define MUTT_PC_FULL_MSG        (1<<0)  ///< Enable body and header matching
+#define MUTT_PC_PATTERN_DYNAMIC (1<<1)  ///< Enable runtime date range evaluation
 
 /**
  * struct Pattern - A simple (non-regex) pattern
@@ -151,7 +152,7 @@ enum PatternType
 
 int mutt_pattern_exec(struct Pattern *pat, PatternExecFlags flags,
                       struct Mailbox *m, struct Email *e, struct PatternCache *cache);
-struct PatternHead *mutt_pattern_comp(const char *s, int flags, struct Buffer *err);
+struct PatternHead *mutt_pattern_comp(const char *s, PatternCompFlags flags, struct Buffer *err);
 void mutt_check_simple(struct Buffer *s, const char *simple);
 void mutt_pattern_free(struct PatternHead **pat);
 

diff --git a/score.c b/score.c
index 36004dd6ffae16066dc942cf100511ddbeec320e..476209701259680163e72cf2392975fd2567fbc7 100644 (file)
--- a/score.c
+++ b/score.c
@@ -123,7 +123,7 @@ enum CommandResult mutt_parse_score(struct Buffer *buf, struct Buffer *s,
       break;
   if (!ptr)
   {
-    struct PatternHead *pat = mutt_pattern_comp(pattern, 0, err);
+    struct PatternHead *pat = mutt_pattern_comp(pattern, MUTT_PC_NO_FLAGS, err);
     if (!pat)
     {
       FREE(&pattern);