From 872da02d09597eb49adfca7ea3646796aff76b7e Mon Sep 17 00:00:00 2001 From: Richard Russon Date: Sun, 24 Dec 2017 17:13:49 +0000 Subject: [PATCH] rename functions --- alias.c | 4 ++-- group.c | 8 +++---- hdrline.c | 12 +++++----- init.c | 62 +++++++++++++++++++++++++------------------------- mutt/regex.c | 63 +++++++++++++++++++++++++-------------------------- mutt/regex3.h | 26 ++++++++++----------- parse.c | 4 ++-- 7 files changed, 89 insertions(+), 90 deletions(-) diff --git a/alias.c b/alias.c index 4eef21aaf..341fc25d4 100644 --- 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 f0640e51b..e51e9ca85 100644 --- 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 2caaa8b43..c9afe27e1 100644 --- 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 65f647db5..354015bb8 100644 --- 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 f2601b2d2..81cd125e5 100644 --- 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(®); + mutt_regex_free(®); 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 49afca86e..cb00b9381 100644 --- 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 32b845c19..5a4197d62 100644 --- 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) -- 2.50.1