rename functions

diff --git a/alias.c b/alias.c
index 4eef21aaf0d46841bb487ed6ab82647f3f53bd92..341fc25d4d1e1fe8bf86027a26e115165608baef 100644 (file)
--- a/alias.c
+++ b/alias.c
@@ -667,10 +667,10 @@ bool mutt_addr_is_user(struct Address *addr)
     return true;
   }
 
-  if (mutt_match_regex_list(addr->mailbox, Alternates))
+  if (mutt_regexlist_match(addr->mailbox, Alternates))
   {
     mutt_debug(5, "yes, %s matched by alternates.\n", addr->mailbox);
-    if (mutt_match_regex_list(addr->mailbox, UnAlternates))
+    if (mutt_regexlist_match(addr->mailbox, UnAlternates))
       mutt_debug(5, "but, %s matched by unalternates.\n", addr->mailbox);
     else
       return true;

diff --git a/group.c b/group.c
index f0640e51b359cdc8e2d0bc9cc2d62e4291625ef5..e51e9ca85f603382f55c8173c374874c4d120573 100644 (file)
--- a/group.c
+++ b/group.c
@@ -55,7 +55,7 @@ static void group_remove(struct Group *g)
     return;
   mutt_hash_delete(Groups, g->name, g, NULL);
   mutt_addr_free(&g->as);
-  mutt_free_regex_list(&g->rs);
+  mutt_regexlist_free(&g->rs);
   FREE(&g->name);
   FREE(&g);
 }
@@ -135,12 +135,12 @@ static int group_remove_adrlist(struct Group *g, struct Address *a)
 
 static int group_add_regex(struct Group *g, const char *s, int flags, struct Buffer *err)
 {
-  return mutt_add_to_regex_list(&g->rs, s, flags, err);
+  return mutt_regexlist_add(&g->rs, s, flags, err);
 }
 
 static int group_remove_regex(struct Group *g, const char *s)
 {
-  return mutt_remove_from_regex_list(&g->rs, s);
+  return mutt_regexlist_remove(&g->rs, s);
 }
 
 void mutt_group_context_add_adrlist(struct GroupContext *ctx, struct Address *a)
@@ -194,7 +194,7 @@ bool mutt_group_match(struct Group *g, const char *s)
 
   if (s && g)
   {
-    if (mutt_match_regex_list(s, g->rs))
+    if (mutt_regexlist_match(s, g->rs))
       return true;
     for (ap = g->as; ap; ap = ap->next)
       if (ap->mailbox && (mutt_str_strcasecmp(s, ap->mailbox) == 0))

diff --git a/hdrline.c b/hdrline.c
index 2caaa8b43102a8ac997d6bb0400d9dceabe101b1..c9afe27e1a35eab36baf5d2ea8f9bb2a39fecbee 100644 (file)
--- a/hdrline.c
+++ b/hdrline.c
@@ -72,17 +72,17 @@ enum FlagChars
 
 bool mutt_is_mail_list(struct Address *addr)
 {
-  if (!mutt_match_regex_list(addr->mailbox, UnMailLists))
-    return mutt_match_regex_list(addr->mailbox, MailLists);
+  if (!mutt_regexlist_match(addr->mailbox, UnMailLists))
+    return mutt_regexlist_match(addr->mailbox, MailLists);
   return false;
 }
 
 bool mutt_is_subscribed_list(struct Address *addr)
 {
-  if (!mutt_match_regex_list(addr->mailbox, UnMailLists) &&
-      !mutt_match_regex_list(addr->mailbox, UnSubscribedLists))
+  if (!mutt_regexlist_match(addr->mailbox, UnMailLists) &&
+      !mutt_regexlist_match(addr->mailbox, UnSubscribedLists))
   {
-    return mutt_match_regex_list(addr->mailbox, SubscribedLists);
+    return mutt_regexlist_match(addr->mailbox, SubscribedLists);
   }
   return false;
 }
@@ -392,7 +392,7 @@ static char *apply_subject_mods(struct Envelope *env)
   if (env->subject == NULL || *env->subject == '\0')
     return env->disp_subj = NULL;
 
-  env->disp_subj = mutt_apply_replace(NULL, 0, env->subject, SubjectRegexList);
+  env->disp_subj = mutt_replacelist_apply(NULL, 0, env->subject, SubjectRegexList);
   return env->disp_subj;
 }
 

diff --git a/init.c b/init.c
index 65f647db561373fdd2a5cb6b73c9118744f289d4..354015bb8459454c14e34976eb4c6096a23ad831 100644 (file)
--- a/init.c
+++ b/init.c
@@ -768,13 +768,13 @@ void mutt_free_opts(void)
   for (int i = 0; MuttVars[i].option; i++)
     free_opt(MuttVars + i);
 
-  mutt_free_regex_list(&Alternates);
-  mutt_free_regex_list(&UnAlternates);
-  mutt_free_regex_list(&MailLists);
-  mutt_free_regex_list(&UnMailLists);
-  mutt_free_regex_list(&SubscribedLists);
-  mutt_free_regex_list(&UnSubscribedLists);
-  mutt_free_regex_list(&NoSpamList);
+  mutt_regexlist_free(&Alternates);
+  mutt_regexlist_free(&UnAlternates);
+  mutt_regexlist_free(&MailLists);
+  mutt_regexlist_free(&UnMailLists);
+  mutt_regexlist_free(&SubscribedLists);
+  mutt_regexlist_free(&UnSubscribedLists);
+  mutt_regexlist_free(&NoSpamList);
 }
 
 static void add_to_stailq(struct ListHead *head, const char *str)
@@ -1023,9 +1023,9 @@ static int parse_alternates(struct Buffer *buf, struct Buffer *s,
     if (parse_group_context(&gc, buf, s, data, err) == -1)
       goto bail;
 
-    mutt_remove_from_regex_list(&UnAlternates, buf->data);
+    mutt_regexlist_remove(&UnAlternates, buf->data);
 
-    if (mutt_add_to_regex_list(&Alternates, buf->data, REG_ICASE, err) != 0)
+    if (mutt_regexlist_add(&Alternates, buf->data, REG_ICASE, err) != 0)
       goto bail;
 
     if (mutt_group_context_add_regex(gc, buf->data, REG_ICASE, err) != 0)
@@ -1047,10 +1047,10 @@ static int parse_unalternates(struct Buffer *buf, struct Buffer *s,
   do
   {
     mutt_extract_token(buf, s, 0);
-    mutt_remove_from_regex_list(&Alternates, buf->data);
+    mutt_regexlist_remove(&Alternates, buf->data);
 
     if ((mutt_str_strcmp(buf->data, "*") != 0) &&
-        mutt_add_to_regex_list(&UnAlternates, buf->data, REG_ICASE, err) != 0)
+        mutt_regexlist_add(&UnAlternates, buf->data, REG_ICASE, err) != 0)
     {
       return -1;
     }
@@ -1084,7 +1084,7 @@ static int parse_replace_list(struct Buffer *buf, struct Buffer *s,
   }
   mutt_extract_token(&templ, s, 0);
 
-  if (add_to_replace_list(list, buf->data, templ.data, err) != 0)
+  if (mutt_replacelist_add(list, buf->data, templ.data, err) != 0)
   {
     FREE(&templ.data);
     return -1;
@@ -1111,11 +1111,11 @@ static int parse_unreplace_list(struct Buffer *buf, struct Buffer *s,
   /* "*" is a special case. */
   if (mutt_str_strcmp(buf->data, "*") == 0)
   {
-    mutt_free_replace_list(list);
+    mutt_replacelist_free(list);
     return 0;
   }
 
-  remove_from_replace_list(list, buf->data);
+  mutt_replacelist_remove(list, buf->data);
   return 0;
 }
 
@@ -1179,7 +1179,7 @@ static int parse_spam_list(struct Buffer *buf, struct Buffer *s,
       mutt_extract_token(&templ, s, 0);
 
       /* Add to the spam list. */
-      if (add_to_replace_list(&SpamList, buf->data, templ.data, err) != 0)
+      if (mutt_replacelist_add(&SpamList, buf->data, templ.data, err) != 0)
       {
         FREE(&templ.data);
         return -1;
@@ -1190,7 +1190,7 @@ static int parse_spam_list(struct Buffer *buf, struct Buffer *s,
     /* If not, try to remove from the nospam list. */
     else
     {
-      mutt_remove_from_regex_list(&NoSpamList, buf->data);
+      mutt_regexlist_remove(&NoSpamList, buf->data);
     }
 
     return 0;
@@ -1204,17 +1204,17 @@ static int parse_spam_list(struct Buffer *buf, struct Buffer *s,
     /* "*" is a special case. */
     if (mutt_str_strcmp(buf->data, "*") == 0)
     {
-      mutt_free_replace_list(&SpamList);
-      mutt_free_regex_list(&NoSpamList);
+      mutt_replacelist_free(&SpamList);
+      mutt_regexlist_free(&NoSpamList);
       return 0;
     }
 
     /* If it's on the spam list, just remove it. */
-    if (remove_from_replace_list(&SpamList, buf->data) != 0)
+    if (mutt_replacelist_remove(&SpamList, buf->data) != 0)
       return 0;
 
     /* Otherwise, add it to the nospam list. */
-    if (mutt_add_to_regex_list(&NoSpamList, buf->data, REG_ICASE, err) != 0)
+    if (mutt_regexlist_add(&NoSpamList, buf->data, REG_ICASE, err) != 0)
       return -1;
 
     return 0;
@@ -1279,9 +1279,9 @@ static int parse_lists(struct Buffer *buf, struct Buffer *s, unsigned long data,
     if (parse_group_context(&gc, buf, s, data, err) == -1)
       goto bail;
 
-    mutt_remove_from_regex_list(&UnMailLists, buf->data);
+    mutt_regexlist_remove(&UnMailLists, buf->data);
 
-    if (mutt_add_to_regex_list(&MailLists, buf->data, REG_ICASE, err) != 0)
+    if (mutt_regexlist_add(&MailLists, buf->data, REG_ICASE, err) != 0)
       goto bail;
 
     if (mutt_group_context_add_regex(gc, buf->data, REG_ICASE, err) != 0)
@@ -1638,11 +1638,11 @@ static int parse_unlists(struct Buffer *buf, struct Buffer *s,
   do
   {
     mutt_extract_token(buf, s, 0);
-    mutt_remove_from_regex_list(&SubscribedLists, buf->data);
-    mutt_remove_from_regex_list(&MailLists, buf->data);
+    mutt_regexlist_remove(&SubscribedLists, buf->data);
+    mutt_regexlist_remove(&MailLists, buf->data);
 
     if ((mutt_str_strcmp(buf->data, "*") != 0) &&
-        mutt_add_to_regex_list(&UnMailLists, buf->data, REG_ICASE, err) != 0)
+        mutt_regexlist_add(&UnMailLists, buf->data, REG_ICASE, err) != 0)
     {
       return -1;
     }
@@ -1663,12 +1663,12 @@ static int parse_subscribe(struct Buffer *buf, struct Buffer *s,
     if (parse_group_context(&gc, buf, s, data, err) == -1)
       goto bail;
 
-    mutt_remove_from_regex_list(&UnMailLists, buf->data);
-    mutt_remove_from_regex_list(&UnSubscribedLists, buf->data);
+    mutt_regexlist_remove(&UnMailLists, buf->data);
+    mutt_regexlist_remove(&UnSubscribedLists, buf->data);
 
-    if (mutt_add_to_regex_list(&MailLists, buf->data, REG_ICASE, err) != 0)
+    if (mutt_regexlist_add(&MailLists, buf->data, REG_ICASE, err) != 0)
       goto bail;
-    if (mutt_add_to_regex_list(&SubscribedLists, buf->data, REG_ICASE, err) != 0)
+    if (mutt_regexlist_add(&SubscribedLists, buf->data, REG_ICASE, err) != 0)
       goto bail;
     if (mutt_group_context_add_regex(gc, buf->data, REG_ICASE, err) != 0)
       goto bail;
@@ -1688,10 +1688,10 @@ static int parse_unsubscribe(struct Buffer *buf, struct Buffer *s,
   do
   {
     mutt_extract_token(buf, s, 0);
-    mutt_remove_from_regex_list(&SubscribedLists, buf->data);
+    mutt_regexlist_remove(&SubscribedLists, buf->data);
 
     if ((mutt_str_strcmp(buf->data, "*") != 0) &&
-        mutt_add_to_regex_list(&UnSubscribedLists, buf->data, REG_ICASE, err) != 0)
+        mutt_regexlist_add(&UnSubscribedLists, buf->data, REG_ICASE, err) != 0)
     {
       return -1;
     }

diff --git a/mutt/regex.c b/mutt/regex.c
index f2601b2d207caa5091eadca48ea0524ae23819ef..81cd125e5112a0f7fdcd9120e54a67a18cd47a43 100644 (file)
--- a/mutt/regex.c
+++ b/mutt/regex.c
@@ -41,13 +41,13 @@
 #include "regex3.h"
 #include "string2.h"
 
-struct Regex *mutt_compile_regex(const char *s, int flags)
+struct Regex *mutt_regex_compile(const char *s, int flags)
 {
   struct Regex *pp = mutt_mem_calloc(1, sizeof(struct Regex));
   pp->pattern = mutt_str_strdup(s);
   pp->regex = mutt_mem_calloc(1, sizeof(regex_t));
   if (REGCOMP(pp->regex, NONULL(s), flags) != 0)
-    mutt_free_regex(&pp);
+    mutt_regex_free(&pp);
 
   return pp;
 }
@@ -86,14 +86,14 @@ struct Regex *mutt_regex_create(const char *str, int flags, struct Buffer *err)
   if ((rc != 0) && err)
   {
     regerror(rc, reg->regex, err->data, err->dsize);
-    mutt_free_regex(&reg);
+    mutt_regex_free(&reg);
     return NULL;
   }
 
   return reg;
 }
 
-void mutt_free_regex(struct Regex **pp)
+void mutt_regex_free(struct Regex **pp)
 {
   FREE(&(*pp)->pattern);
   regfree((*pp)->regex);
@@ -101,8 +101,7 @@ void mutt_free_regex(struct Regex **pp)
   FREE(pp);
 }
 
-int mutt_add_to_regex_list(struct RegexList **list, const char *s, int flags,
-                           struct Buffer *err)
+int mutt_regexlist_add(struct RegexList **list, const char *s, int flags, struct Buffer *err)
 {
   struct RegexList *t = NULL, *last = NULL;
   struct Regex *rx = NULL;
@@ -110,7 +109,7 @@ int mutt_add_to_regex_list(struct RegexList **list, const char *s, int flags,
   if (!s || !*s)
     return 0;
 
-  rx = mutt_compile_regex(s, flags);
+  rx = mutt_regex_compile(s, flags);
   if (!rx)
   {
     snprintf(err->data, err->dsize, "Bad regex: %s\n", s);
@@ -132,7 +131,7 @@ int mutt_add_to_regex_list(struct RegexList **list, const char *s, int flags,
 
   if (!*list || last)
   {
-    t = new_regex_list();
+    t = mutt_regexlist_new();
     t->regex = rx;
     if (last)
     {
@@ -143,12 +142,12 @@ int mutt_add_to_regex_list(struct RegexList **list, const char *s, int flags,
       *list = last = t;
   }
   else /* duplicate */
-    mutt_free_regex(&rx);
+    mutt_regex_free(&rx);
 
   return 0;
 }
 
-void mutt_free_regex_list(struct RegexList **list)
+void mutt_regexlist_free(struct RegexList **list)
 {
   struct RegexList *p = NULL;
 
@@ -158,12 +157,12 @@ void mutt_free_regex_list(struct RegexList **list)
   {
     p = *list;
     *list = (*list)->next;
-    mutt_free_regex(&p->regex);
+    mutt_regex_free(&p->regex);
     FREE(&p);
   }
 }
 
-bool mutt_match_regex_list(const char *s, struct RegexList *l)
+bool mutt_regexlist_match(const char *s, struct RegexList *l)
 {
   if (!s)
     return false;
@@ -180,19 +179,19 @@ bool mutt_match_regex_list(const char *s, struct RegexList *l)
   return false;
 }
 
-struct RegexList *new_regex_list(void)
+struct RegexList *mutt_regexlist_new(void)
 {
   return mutt_mem_calloc(1, sizeof(struct RegexList));
 }
 
-int mutt_remove_from_regex_list(struct RegexList **l, const char *str)
+int mutt_regexlist_remove(struct RegexList **l, const char *str)
 {
   struct RegexList *p = NULL, *last = NULL;
   int rc = -1;
 
   if (mutt_str_strcmp("*", str) == 0)
   {
-    mutt_free_regex_list(l); /* ``unCMD *'' means delete all current entries */
+    mutt_regexlist_free(l); /* ``unCMD *'' means delete all current entries */
     rc = 0;
   }
   else
@@ -203,7 +202,7 @@ int mutt_remove_from_regex_list(struct RegexList **l, const char *str)
     {
       if (mutt_str_strcasecmp(str, p->regex->pattern) == 0)
       {
-        mutt_free_regex(&p->regex);
+        mutt_regex_free(&p->regex);
         if (last)
           last->next = p->next;
         else
@@ -221,8 +220,8 @@ int mutt_remove_from_regex_list(struct RegexList **l, const char *str)
   return rc;
 }
 
-int add_to_replace_list(struct ReplaceList **list, const char *pat,
-                        const char *templ, struct Buffer *err)
+int mutt_replacelist_add(struct ReplaceList **list, const char *pat,
+                         const char *templ, struct Buffer *err)
 {
   struct ReplaceList *t = NULL, *last = NULL;
   struct Regex *rx = NULL;
@@ -232,7 +231,7 @@ int add_to_replace_list(struct ReplaceList **list, const char *pat,
   if (!pat || !*pat || !templ)
     return 0;
 
-  rx = mutt_compile_regex(pat, REG_ICASE);
+  rx = mutt_regex_compile(pat, REG_ICASE);
   if (!rx)
   {
     snprintf(err->data, err->dsize, _("Bad regex: %s"), pat);
@@ -263,7 +262,7 @@ int add_to_replace_list(struct ReplaceList **list, const char *pat,
    */
   if (!t)
   {
-    t = new_replace_list();
+    t = mutt_replacelist_new();
     t->regex = rx;
     rx = NULL;
     if (last)
@@ -272,7 +271,7 @@ int add_to_replace_list(struct ReplaceList **list, const char *pat,
       *list = t;
   }
   else
-    mutt_free_regex(&rx);
+    mutt_regex_free(&rx);
 
   /* Now t is the ReplaceList* that we want to modify. It is prepared. */
   t->template = mutt_str_strdup(templ);
@@ -297,7 +296,7 @@ int add_to_replace_list(struct ReplaceList **list, const char *pat,
   {
     snprintf(err->data, err->dsize, "%s", _("Not enough subexpressions for "
                                             "template"));
-    remove_from_replace_list(list, pat);
+    mutt_replacelist_remove(list, pat);
     return -1;
   }
 
@@ -307,12 +306,12 @@ int add_to_replace_list(struct ReplaceList **list, const char *pat,
 }
 
 /**
- * mutt_apply_replace - Apply replacements to a buffer
+ * mutt_replacelist_apply - Apply replacements to a buffer
  *
  * Note this function uses a fixed size buffer of LONG_STRING and so
  * should only be used for visual modifications, such as disp_subj.
  */
-char *mutt_apply_replace(char *dbuf, size_t dlen, char *sbuf, struct ReplaceList *rlist)
+char *mutt_replacelist_apply(char *dbuf, size_t dlen, char *sbuf, struct ReplaceList *rlist)
 {
   struct ReplaceList *l = NULL;
   static regmatch_t *pmatch = NULL;
@@ -403,7 +402,7 @@ char *mutt_apply_replace(char *dbuf, size_t dlen, char *sbuf, struct ReplaceList
   return dbuf;
 }
 
-void mutt_free_replace_list(struct ReplaceList **list)
+void mutt_replacelist_free(struct ReplaceList **list)
 {
   struct ReplaceList *p = NULL;
 
@@ -413,14 +412,14 @@ void mutt_free_replace_list(struct ReplaceList **list)
   {
     p = *list;
     *list = (*list)->next;
-    mutt_free_regex(&p->regex);
+    mutt_regex_free(&p->regex);
     FREE(&p->template);
     FREE(&p);
   }
 }
 
 /**
- * mutt_match_spam_list - Does a string match a spam pattern
+ * mutt_replacelist_match - Does a string match a spam pattern
  * @param s        String to check
  * @param l        List of spam patterns
  * @param text     Buffer to save match
@@ -433,7 +432,7 @@ void mutt_free_replace_list(struct ReplaceList **list)
  * match is performed but the format is not expanded and no assumptions are made
  * about the value of `text` so it may be NULL.
  */
-bool mutt_match_spam_list(const char *s, struct ReplaceList *l, char *text, int textsize)
+bool mutt_replacelist_match(const char *s, struct ReplaceList *l, char *text, int textsize)
 {
   static regmatch_t *pmatch = NULL;
   static int nmatch = 0;
@@ -505,12 +504,12 @@ bool mutt_match_spam_list(const char *s, struct ReplaceList *l, char *text, int
   return false;
 }
 
-struct ReplaceList *new_replace_list(void)
+struct ReplaceList *mutt_replacelist_new(void)
 {
   return mutt_mem_calloc(1, sizeof(struct ReplaceList));
 }
 
-int remove_from_replace_list(struct ReplaceList **list, const char *pat)
+int mutt_replacelist_remove(struct ReplaceList **list, const char *pat)
 {
   struct ReplaceList *cur = NULL, *prev = NULL;
   int nremoved = 0;
@@ -522,7 +521,7 @@ int remove_from_replace_list(struct ReplaceList **list, const char *pat)
   if (cur->regex && (mutt_str_strcmp(cur->regex->pattern, pat) == 0))
   {
     *list = cur->next;
-    mutt_free_regex(&cur->regex);
+    mutt_regex_free(&cur->regex);
     FREE(&cur->template);
     FREE(&cur);
     return 1;
@@ -534,7 +533,7 @@ int remove_from_replace_list(struct ReplaceList **list, const char *pat)
     if (mutt_str_strcmp(cur->regex->pattern, pat) == 0)
     {
       prev->next = cur->next;
-      mutt_free_regex(&cur->regex);
+      mutt_regex_free(&cur->regex);
       FREE(&cur->template);
       FREE(&cur);
       cur = prev->next;

diff --git a/mutt/regex3.h b/mutt/regex3.h
index 49afca86e8ca45834adb0a1e19edaafec24120bb..cb00b9381db8dd0562c0bfe3afc1e0c721ba703e 100644 (file)
--- a/mutt/regex3.h
+++ b/mutt/regex3.h
@@ -86,21 +86,21 @@ struct ReplaceList
   struct ReplaceList *next;
 };
 
-struct Regex *      mutt_compile_regex(const char *s, int flags);
+struct Regex *      mutt_regex_compile(const char *s, int flags);
 struct Regex *      mutt_regex_create(const char *str, int flags, struct Buffer *err);
-void                mutt_free_regex(struct Regex **pp);
+void                mutt_regex_free(struct Regex **pp);
 
-int                 mutt_add_to_regex_list(struct RegexList **list, const char *s, int flags, struct Buffer *err);
-void                mutt_free_regex_list(struct RegexList **list);
-bool                mutt_match_regex_list(const char *s, struct RegexList *l);
-struct RegexList *  new_regex_list(void);
-int                 mutt_remove_from_regex_list(struct RegexList **l, const char *str);
+int                 mutt_regexlist_add(struct RegexList **list, const char *s, int flags, struct Buffer *err);
+void                mutt_regexlist_free(struct RegexList **list);
+bool                mutt_regexlist_match(const char *s, struct RegexList *l);
+struct RegexList *  mutt_regexlist_new(void);
+int                 mutt_regexlist_remove(struct RegexList **l, const char *str);
 
-int                 add_to_replace_list(struct ReplaceList **list, const char *pat, const char *templ, struct Buffer *err);
-char *              mutt_apply_replace(char *dbuf, size_t dlen, char *sbuf, struct ReplaceList *rlist);
-void                mutt_free_replace_list(struct ReplaceList **list);
-bool                mutt_match_spam_list(const char *s, struct ReplaceList *l, char *text, int textsize);
-struct ReplaceList *new_replace_list(void);
-int                 remove_from_replace_list(struct ReplaceList **list, const char *pat);
+int                 mutt_replacelist_add(struct ReplaceList **list, const char *pat, const char *templ, struct Buffer *err);
+char *              mutt_replacelist_apply(char *dbuf, size_t dlen, char *sbuf, struct ReplaceList *rlist);
+void                mutt_replacelist_free(struct ReplaceList **list);
+bool                mutt_replacelist_match(const char *s, struct ReplaceList *l, char *text, int textsize);
+struct ReplaceList *mutt_replacelist_new(void);
+int                 mutt_replacelist_remove(struct ReplaceList **list, const char *pat);
 
 #endif /* _MUTT_REGEX_H */

diff --git a/parse.c b/parse.c
index 32b845c1951a867c8365529623f7c398f86a1e16..5a4197d62b9b5cd5b145a9af19ea06dc81ca94ae 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -1211,9 +1211,9 @@ struct Envelope *mutt_read_rfc822_header(FILE *f, struct Header *hdr,
 
     *buf = '\0';
 
-    if (mutt_match_spam_list(line, SpamList, buf, sizeof(buf)))
+    if (mutt_replacelist_match(line, SpamList, buf, sizeof(buf)))
     {
-      if (!mutt_match_regex_list(line, NoSpamList))
+      if (!mutt_regexlist_match(line, NoSpamList))
       {
         /* if spam tag already exists, figure out how to amend it */
         if (e->spam && *buf)