X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=35577a40ff641cf94c7929604dc9a5d139bb6ef6;hp=9c81fe14b3a7578cd8993c3a02eced5c07283b42;hb=fa7f733a61a6fe3143198791ab470ddf4d08fdbe;hpb=5435729df11cfc6ca23e65e66ab034befece0b18 diff --git a/init.c b/init.c index 9c81fe1..35577a4 100644 --- a/init.c +++ b/init.c @@ -1,20 +1,11 @@ /* + * Copyright notice from original mutt: * Copyright (C) 1996-2002 Michael R. Elkins - * - * 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, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. - */ + * + * This file is part of mutt-ng, see http://www.muttng.org/. + * It's licensed under the GNU General Public License, + * please see the file GPL in the top level source directory. + */ #if HAVE_CONFIG_H # include "config.h" @@ -23,7 +14,6 @@ #include "mutt.h" #include "mapping.h" #include "mutt_curses.h" -#include "mutt_regex.h" #include "history.h" #include "keymap.h" #include "mbyte.h" @@ -35,12 +25,15 @@ #include "mutt_ssl.h" #endif - - #include "mx.h" #include "init.h" #include "mailbox.h" +#include "lib/mem.h" +#include "lib/intl.h" +#include "lib/str.h" +#include "lib/rx.h" + #include #include #include @@ -51,7 +44,7 @@ void toggle_quadoption (int opt) { - int n = opt/4; + int n = opt / 4; int b = (opt % 4) * 2; QuadOptions[n] ^= (1 << b); @@ -59,7 +52,7 @@ void toggle_quadoption (int opt) void set_quadoption (int opt, int flag) { - int n = opt/4; + int n = opt / 4; int b = (opt % 4) * 2; QuadOptions[n] &= ~(0x3 << b); @@ -68,7 +61,7 @@ void set_quadoption (int opt, int flag) int quadoption (int opt) { - int n = opt/4; + int n = opt / 4; int b = (opt % 4) * 2; return (QuadOptions[n] >> b) & 0x3; @@ -78,16 +71,15 @@ int query_quadoption (int opt, const char *prompt) { int v = quadoption (opt); - switch (v) - { - case M_YES: - case M_NO: - return (v); + switch (v) { + case M_YES: + case M_NO: + return (v); - default: - v = mutt_yesorno (prompt, (v == M_ASKYES)); - CLEARLINE (LINES - 1); - return (v); + default: + v = mutt_yesorno (prompt, (v == M_ASKYES)); + CLEARLINE (LINES - 1); + return (v); } /* not reached */ @@ -101,126 +93,120 @@ int mutt_option_index (char *s) for (i = 0; MuttVars[i].option; i++) if (mutt_strcmp (s, MuttVars[i].option) == 0) - return (MuttVars[i].type == DT_SYN ? mutt_option_index ((char *) MuttVars[i].data) : i); + return (MuttVars[i].type == + DT_SYN ? mutt_option_index ((char *) MuttVars[i].data) : i); return (-1); } -int mutt_extract_token (BUFFER *dest, BUFFER *tok, int flags) +int mutt_extract_token (BUFFER * dest, BUFFER * tok, int flags) { - char ch; - char qc = 0; /* quote char */ - char *pc; + char ch; + char qc = 0; /* quote char */ + char *pc; /* reset the destination pointer to the beginning of the buffer */ dest->dptr = dest->data; SKIPWS (tok->dptr); - while ((ch = *tok->dptr)) - { - if (!qc) - { + while ((ch = *tok->dptr)) { + if (!qc) { if ((ISSPACE (ch) && !(flags & M_TOKEN_SPACE)) || - (ch == '#' && !(flags & M_TOKEN_COMMENT)) || - (ch == '=' && (flags & M_TOKEN_EQUAL)) || - (ch == ';' && !(flags & M_TOKEN_SEMICOLON)) || - ((flags & M_TOKEN_PATTERN) && strchr ("~!|", ch))) - break; + (ch == '#' && !(flags & M_TOKEN_COMMENT)) || + (ch == '=' && (flags & M_TOKEN_EQUAL)) || + (ch == ';' && !(flags & M_TOKEN_SEMICOLON)) || + ((flags & M_TOKEN_PATTERN) && strchr ("~!|", ch))) + break; } tok->dptr++; if (ch == qc) - qc = 0; /* end of quote */ + qc = 0; /* end of quote */ else if (!qc && (ch == '\'' || ch == '"') && !(flags & M_TOKEN_QUOTE)) qc = ch; - else if (ch == '\\' && qc != '\'') - { - if (!*tok->dptr) - return -1; /* premature end of token */ - switch (ch = *tok->dptr++) - { - case 'c': - case 'C': - if (!*tok->dptr) - return -1; /* premature end of token */ - mutt_buffer_addch (dest, (toupper ((unsigned char) *tok->dptr) - - '@') & 0x7f); - tok->dptr++; - break; - case 'r': - mutt_buffer_addch (dest, '\r'); - break; - case 'n': - mutt_buffer_addch (dest, '\n'); - break; - case 't': - mutt_buffer_addch (dest, '\t'); - break; - case 'f': - mutt_buffer_addch (dest, '\f'); - break; - case 'e': - mutt_buffer_addch (dest, '\033'); - break; - default: - if (isdigit ((unsigned char) ch) && - isdigit ((unsigned char) *tok->dptr) && - isdigit ((unsigned char) *(tok->dptr + 1))) - { - - mutt_buffer_addch (dest, (ch << 6) + (*tok->dptr << 3) + *(tok->dptr + 1) - 3504); - tok->dptr += 2; - } - else - mutt_buffer_addch (dest, ch); + else if (ch == '\\' && qc != '\'') { + if (!*tok->dptr) + return -1; /* premature end of token */ + switch (ch = *tok->dptr++) { + case 'c': + case 'C': + if (!*tok->dptr) + return -1; /* premature end of token */ + mutt_buffer_addch (dest, (toupper ((unsigned char) *tok->dptr) + - '@') & 0x7f); + tok->dptr++; + break; + case 'r': + mutt_buffer_addch (dest, '\r'); + break; + case 'n': + mutt_buffer_addch (dest, '\n'); + break; + case 't': + mutt_buffer_addch (dest, '\t'); + break; + case 'f': + mutt_buffer_addch (dest, '\f'); + break; + case 'e': + mutt_buffer_addch (dest, '\033'); + break; + default: + if (isdigit ((unsigned char) ch) && + isdigit ((unsigned char) *tok->dptr) && + isdigit ((unsigned char) *(tok->dptr + 1))) { + + mutt_buffer_addch (dest, + (ch << 6) + (*tok->dptr << 3) + *(tok->dptr + + 1) - 3504); + tok->dptr += 2; + } + else + mutt_buffer_addch (dest, ch); } } - else if (ch == '^' && (flags & M_TOKEN_CONDENSE)) - { - if (!*tok->dptr) - return -1; /* premature end of token */ + else if (ch == '^' && (flags & M_TOKEN_CONDENSE)) { + if (!*tok->dptr) + return -1; /* premature end of token */ ch = *tok->dptr++; if (ch == '^') - mutt_buffer_addch (dest, ch); + mutt_buffer_addch (dest, ch); else if (ch == '[') - mutt_buffer_addch (dest, '\033'); + mutt_buffer_addch (dest, '\033'); else if (isalpha ((unsigned char) ch)) - mutt_buffer_addch (dest, toupper ((unsigned char) ch) - '@'); - else - { - mutt_buffer_addch (dest, '^'); - mutt_buffer_addch (dest, ch); + mutt_buffer_addch (dest, toupper ((unsigned char) ch) - '@'); + else { + mutt_buffer_addch (dest, '^'); + mutt_buffer_addch (dest, ch); } } - else if (ch == '`' && (!qc || qc == '"')) - { - FILE *fp; - pid_t pid; - char *cmd, *ptr; - size_t expnlen; - BUFFER expn; - int line = 0; + else if (ch == '`' && (!qc || qc == '"')) { + FILE *fp; + pid_t pid; + char *cmd, *ptr; + size_t expnlen; + BUFFER expn; + int line = 0; pc = tok->dptr; do { - if ((pc = strpbrk (pc, "\\`"))) - { - /* skip any quoted chars */ - if (*pc == '\\') - pc += 2; - } + if ((pc = strpbrk (pc, "\\`"))) { + /* skip any quoted chars */ + if (*pc == '\\') + pc += 2; + } } while (pc && *pc != '`'); - if (!pc) - { - dprint (1, (debugfile, "mutt_get_token: mismatched backtics\n")); - return (-1); + if (!pc) { + dprint (1, (debugfile, "mutt_get_token: mismatched backtics\n")); + return (-1); } cmd = mutt_substrdup (tok->dptr, pc); - if ((pid = mutt_create_filter (cmd, NULL, &fp, NULL)) < 0) - { - dprint (1, (debugfile, "mutt_get_token: unable to fork command: %s", cmd)); - FREE (&cmd); - return (-1); + if ((pid = mutt_create_filter (cmd, NULL, &fp, NULL)) < 0) { + dprint (1, + (debugfile, "mutt_get_token: unable to fork command: %s", + cmd)); + FREE (&cmd); + return (-1); } FREE (&cmd); @@ -233,63 +219,58 @@ int mutt_extract_token (BUFFER *dest, BUFFER *tok, int flags) mutt_wait_filter (pid); /* if we got output, make a new string consiting of the shell ouptput - plus whatever else was left on the original line */ + plus whatever else was left on the original line */ /* BUT: If this is inside a quoted string, directly add output to * the token */ - if (expn.data && qc) - { - mutt_buffer_addstr (dest, expn.data); - FREE (&expn.data); + if (expn.data && qc) { + mutt_buffer_addstr (dest, expn.data); + FREE (&expn.data); } - else if (expn.data) - { - expnlen = mutt_strlen (expn.data); - tok->dsize = expnlen + mutt_strlen (tok->dptr) + 1; - ptr = safe_malloc (tok->dsize); - memcpy (ptr, expn.data, expnlen); - strcpy (ptr + expnlen, tok->dptr); /* __STRCPY_CHECKED__ */ - if (tok->destroy) - FREE (&tok->data); - tok->data = ptr; - tok->dptr = ptr; - tok->destroy = 1; /* mark that the caller should destroy this data */ - ptr = NULL; - FREE (&expn.data); + else if (expn.data) { + expnlen = mutt_strlen (expn.data); + tok->dsize = expnlen + mutt_strlen (tok->dptr) + 1; + ptr = safe_malloc (tok->dsize); + memcpy (ptr, expn.data, expnlen); + strcpy (ptr + expnlen, tok->dptr); /* __STRCPY_CHECKED__ */ + if (tok->destroy) + FREE (&tok->data); + tok->data = ptr; + tok->dptr = ptr; + tok->destroy = 1; /* mark that the caller should destroy this data */ + ptr = NULL; + FREE (&expn.data); } } - else if (ch == '$' && (!qc || qc == '"') && (*tok->dptr == '{' || isalpha ((unsigned char) *tok->dptr))) - { + else if (ch == '$' && (!qc || qc == '"') + && (*tok->dptr == '{' || isalpha ((unsigned char) *tok->dptr))) { char *env = NULL, *var = NULL; - if (*tok->dptr == '{') - { - tok->dptr++; - if ((pc = strchr (tok->dptr, '}'))) - { - var = mutt_substrdup (tok->dptr, pc); - tok->dptr = pc + 1; - } + if (*tok->dptr == '{') { + tok->dptr++; + if ((pc = strchr (tok->dptr, '}'))) { + var = mutt_substrdup (tok->dptr, pc); + tok->dptr = pc + 1; + } } - else - { - for (pc = tok->dptr; isalpha ((unsigned char) *pc) || *pc == '_'; pc++) - ; - var = mutt_substrdup (tok->dptr, pc); - tok->dptr = pc; + else { + for (pc = tok->dptr; isalpha ((unsigned char) *pc) || *pc == '_'; + pc++); + var = mutt_substrdup (tok->dptr, pc); + tok->dptr = pc; } if (var && (env = getenv (var))) - mutt_buffer_addstr (dest, env); + mutt_buffer_addstr (dest, env); FREE (&var); } else mutt_buffer_addch (dest, ch); } - mutt_buffer_addch (dest, 0); /* terminate the string */ + mutt_buffer_addch (dest, 0); /* terminate the string */ SKIPWS (tok->dptr); return 0; } -static void add_to_list (LIST **list, const char *str) +static void add_to_list (LIST ** list, const char *str) { LIST *t, *last = NULL; @@ -298,10 +279,8 @@ static void add_to_list (LIST **list, const char *str) return; /* check to make sure the item is not already on this list */ - for (last = *list; last; last = last->next) - { - if (ascii_strcasecmp (str, last->data) == 0) - { + for (last = *list; last; last = last->next) { + if (ascii_strcasecmp (str, last->data) == 0) { /* already on the list, so just ignore it */ last = NULL; break; @@ -310,12 +289,10 @@ static void add_to_list (LIST **list, const char *str) break; } - if (!*list || last) - { + if (!*list || last) { t = (LIST *) safe_calloc (1, sizeof (LIST)); t->data = safe_strdup (str); - if (last) - { + if (last) { last->next = t; last = last->next; } @@ -324,72 +301,47 @@ static void add_to_list (LIST **list, const char *str) } } -static int add_to_rx_list (RX_LIST **list, const char *s, int flags, BUFFER *err) +static int add_to_rx_list (rx_t ** list, const char *s, int flags, + BUFFER * err) { - RX_LIST *t, *last = NULL; - REGEXP *rx; + rx_t* rx; + int i = 0; if (!s || !*s) return 0; - if (!(rx = mutt_compile_regexp (s, flags))) - { + if (!(rx = rx_compile (s, flags))) { snprintf (err->data, err->dsize, "Bad regexp: %s\n", s); return -1; } - /* check to make sure the item is not already on this list */ - for (last = *list; last; last = last->next) - { - if (ascii_strcasecmp (rx->pattern, last->rx->pattern) == 0) - { - /* already on the list, so just ignore it */ - last = NULL; - break; - } - if (!last->next) - break; - } - - if (!*list || last) - { - t = mutt_new_rx_list(); - t->rx = rx; - if (last) - { - last->next = t; - last = last->next; - } - else - *list = last = t; - } - else /* duplicate */ - mutt_free_regexp (&rx); - + i = rx_lookup ((*list), rx->pattern); + if (i >= 0) + rx_free (&rx); + else + list_push_back (list, rx); return 0; } -static int add_to_spam_list (SPAM_LIST **list, const char *pat, const char *templ, BUFFER *err) +static int add_to_spam_list (SPAM_LIST ** list, const char *pat, + const char *templ, BUFFER * err) { SPAM_LIST *t = NULL, *last = NULL; - REGEXP *rx; + rx_t* rx; int n; const char *p; if (!pat || !*pat || !templ) return 0; - if (!(rx = mutt_compile_regexp (pat, REG_ICASE))) - { + if (!(rx = rx_compile (pat, REG_ICASE))) { snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat); return -1; } /* check to make sure the item is not already on this list */ - for (last = *list; last; last = last->next) - { - if (ascii_strcasecmp (rx->pattern, last->rx->pattern) == 0) - { + for (last = *list; last; last = last->next) { + if (ascii_strcasecmp (rx->pattern, last->rx->pattern) == 0) { /* Already on the list. Formerly we just skipped this case, but * now we're supporting removals, which means we're supporting * re-adds conceptually. So we probably want this to imply a @@ -397,7 +349,7 @@ static int add_to_spam_list (SPAM_LIST **list, const char *pat, const char *temp * the template, and leaving t pointed at the current item. */ t = last; - safe_free(&t->template); + FREE(t->template); break; } if (!last->next) @@ -407,9 +359,8 @@ static int add_to_spam_list (SPAM_LIST **list, const char *pat, const char *temp /* If t is set, it's pointing into an extant SPAM_LIST* that we want to * update. Otherwise we want to make a new one to link at the list's end. */ - if (!t) - { - t = mutt_new_spam_list(); + if (!t) { + t = mutt_new_spam_list (); t->rx = rx; if (last) last->next = t; @@ -418,53 +369,48 @@ static int add_to_spam_list (SPAM_LIST **list, const char *pat, const char *temp } /* Now t is the SPAM_LIST* that we want to modify. It is prepared. */ - t->template = safe_strdup(templ); + t->template = safe_strdup (templ); /* Find highest match number in template string */ t->nmatch = 0; - for (p = templ; *p;) - { - if (*p == '%') - { - n = atoi(++p); - if (n > t->nmatch) - t->nmatch = n; - while (*p && isdigit((int)*p)) - ++p; + for (p = templ; *p;) { + if (*p == '%') { + n = atoi (++p); + if (n > t->nmatch) + t->nmatch = n; + while (*p && isdigit ((int) *p)) + ++p; } else - ++p; + ++p; } - t->nmatch++; /* match 0 is always the whole expr */ + t->nmatch++; /* match 0 is always the whole expr */ return 0; } -static int remove_from_spam_list (SPAM_LIST **list, const char *pat) +static int remove_from_spam_list (SPAM_LIST ** list, const char *pat) { SPAM_LIST *spam, *prev; int nremoved = 0; /* Being first is a special case. */ spam = *list; - if (spam->rx && !mutt_strcmp(spam->rx->pattern, pat)) - { + if (spam->rx && !mutt_strcmp (spam->rx->pattern, pat)) { *list = spam->next; - mutt_free_regexp(&spam->rx); - safe_free(&spam->template); - safe_free(&spam); + rx_free (&spam->rx); + FREE(&spam->template); + FREE(&spam); return 1; } prev = spam; - for (spam = prev->next; spam;) - { - if (!mutt_strcmp(spam->rx->pattern, pat)) - { + for (spam = prev->next; spam;) { + if (!mutt_strcmp (spam->rx->pattern, pat)) { prev->next = spam->next; - mutt_free_regexp(&spam->rx); - safe_free(&spam->template); - safe_free(&spam); + rx_free (&spam->rx); + FREE(spam->template); + FREE(spam); spam = prev->next; ++nremoved; } @@ -476,73 +422,53 @@ static int remove_from_spam_list (SPAM_LIST **list, const char *pat) } -static void remove_from_list (LIST **l, const char *str) +static void remove_from_list (LIST ** l, const char *str) { LIST *p, *last = NULL; if (mutt_strcmp ("*", str) == 0) - mutt_free_list (l); /* ``unCMD *'' means delete all current entries */ - else - { + mutt_free_list (l); /* ``unCMD *'' means delete all current entries */ + else { p = *l; last = NULL; - while (p) - { - if (ascii_strcasecmp (str, p->data) == 0) - { - FREE (&p->data); - if (last) - last->next = p->next; - else - (*l) = p->next; - FREE (&p); + while (p) { + if (ascii_strcasecmp (str, p->data) == 0) { + FREE (&p->data); + if (last) + last->next = p->next; + else + (*l) = p->next; + FREE (&p); } - else - { - last = p; - p = p->next; + else { + last = p; + p = p->next; } } } } -static int remove_from_rx_list (RX_LIST **l, const char *str) +static int remove_from_rx_list (list2_t** l, const char *str) { - RX_LIST *p, *last = NULL; - int rv = -1; - - if (mutt_strcmp ("*", str) == 0) - { - mutt_free_rx_list (l); /* ``unCMD *'' means delete all current entries */ - rv = 0; - } - else - { - p = *l; - last = NULL; - while (p) - { - if (ascii_strcasecmp (str, p->rx->pattern) == 0) - { - mutt_free_regexp (&p->rx); - if (last) - last->next = p->next; - else - (*l) = p->next; - FREE (&p); - rv = 0; - } - else - { - last = p; - p = p->next; - } + int i = 0; + + if (mutt_strcmp ("*", str) == 0) { + list_del (l, rx_free); + return (0); + } + else { + i = rx_lookup ((*l), str); + if (i >= 0) { + rx_t* r = list_pop_idx ((*l), i); + rx_free (&r); + return (0); } } - return (rv); + return (-1); } -static int parse_ifdef (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data, + BUFFER * err) { int i, j, res = 0; BUFFER token; @@ -552,34 +478,52 @@ static int parse_ifdef (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) /* is the item defined as a variable or a function? */ if (!(res = (mutt_option_index (tmp->data) != -1))) - for (i = 0; !res && i < MENU_MAX; i++) - { + for (i = 0; !res && i < MENU_MAX; i++) { struct binding_t *b = km_get_table (Menus[i].value); if (!b) - continue; + continue; for (j = 0; b[j].name; j++) - if (!ascii_strncasecmp (tmp->data, b[j].name, mutt_strlen (tmp->data)) - && (mutt_strlen (b[j].name) == mutt_strlen (tmp->data))) - { - res = 1; - break; - } + if (!ascii_strncasecmp (tmp->data, b[j].name, mutt_strlen (tmp->data)) + && (mutt_strlen (b[j].name) == mutt_strlen (tmp->data))) { + res = 1; + break; + } + } + /* check for feature_* */ + if (!res) { + char *p = NULL; + + i = 0; + j = mutt_strlen (tmp->data); + /* need at least input of 'feature_X' */ + if (j >= 7) { + p = tmp->data + 7; + j -= 7; + while (Features[i].name) { + if (mutt_strlen (Features[i].name) == j && + ascii_strncasecmp (Features[i].name, p, j)) { + res = 1; + break; + } + i++; + } } + } - if (!MoreArgs (s)) - { - snprintf (err->data, err->dsize, _("ifdef: too few arguments")); + if (!MoreArgs (s)) { + if (data) + snprintf (err->data, err->dsize, _("ifdef: too few arguments")); + else + snprintf (err->data, err->dsize, _("ifndef: too few arguments")); return (-1); } mutt_extract_token (tmp, s, M_TOKEN_SPACE); - if (res) - { - if (mutt_parse_rc_line (tmp->data, &token, err) == -1) - { - mutt_error ("Erreur: %s", err->data); + if ((data && res) || (!data && !res)) { + if (mutt_parse_rc_line (tmp->data, &token, err) == -1) { + mutt_error ("Error: %s", err->data); FREE (&token.data); return (-1); } @@ -588,14 +532,14 @@ static int parse_ifdef (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) return 0; } -static int parse_unignore (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unignore (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); /* don't add "*" to the unignore list */ - if (strcmp (buf->data, "*")) + if (strcmp (buf->data, "*")) add_to_list (&UnIgnore, buf->data); remove_from_list (&Ignore, buf->data); @@ -605,10 +549,10 @@ static int parse_unignore (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *e return 0; } -static int parse_ignore (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_ignore (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); remove_from_list (&UnIgnore, buf->data); add_to_list (&Ignore, buf->data); @@ -618,10 +562,10 @@ static int parse_ignore (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err return 0; } -static int parse_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_list (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); add_to_list ((LIST **) data, buf->data); } @@ -630,57 +574,21 @@ static int parse_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) return 0; } -static int _parse_rx_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err, int flags) -{ - do - { - mutt_extract_token (buf, s, 0); - if (add_to_rx_list ((RX_LIST **) data, buf->data, flags, err) != 0) - return -1; - - } - while (MoreArgs (s)); - - return 0; -} - -static int parse_rx_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) -{ - return _parse_rx_list (buf, s, data, err, REG_ICASE); -} - -static int parse_rx_unlist (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) -{ - do - { - mutt_extract_token (buf, s, 0); - if (mutt_strcmp (buf->data, "*") == 0) - { - mutt_free_rx_list ((RX_LIST **) data); - break; - } - remove_from_rx_list ((RX_LIST **) data, buf->data); - } - while (MoreArgs (s)); - - return 0; -} - static void _alternates_clean (void) { int i; - if (Context && Context->msgcount) - { + + if (Context && Context->msgcount) { for (i = 0; i < Context->msgcount; i++) Context->hdrs[i]->recip_valid = 0; } } -static int parse_alternates (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_alternates (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - _alternates_clean(); - do - { + _alternates_clean (); + do { mutt_extract_token (buf, s, 0); remove_from_rx_list (&UnAlternates, buf->data); @@ -692,16 +600,16 @@ static int parse_alternates (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER return 0; } -static int parse_unalternates (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unalternates (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - _alternates_clean(); - do - { + _alternates_clean (); + do { mutt_extract_token (buf, s, 0); remove_from_rx_list (&Alternates, buf->data); if (mutt_strcmp (buf->data, "*") && - add_to_rx_list (&UnAlternates, buf->data, REG_ICASE, err) != 0) + add_to_rx_list (&UnAlternates, buf->data, REG_ICASE, err) != 0) return -1; } @@ -710,19 +618,19 @@ static int parse_unalternates (BUFFER *buf, BUFFER *s, unsigned long data, BUFFE return 0; } -static int parse_spam_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { BUFFER templ; - memset(&templ, 0, sizeof(templ)); + memset (&templ, 0, sizeof (templ)); /* Insist on at least one parameter */ - if (!MoreArgs(s)) - { + if (!MoreArgs (s)) { if (data == M_SPAM) - strfcpy(err->data, _("spam: no matching pattern"), err->dsize); + strfcpy (err->data, _("spam: no matching pattern"), err->dsize); else - strfcpy(err->data, _("nospam: no matching pattern"), err->dsize); + strfcpy (err->data, _("nospam: no matching pattern"), err->dsize); return -1; } @@ -730,45 +638,40 @@ static int parse_spam_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER * mutt_extract_token (buf, s, 0); /* data should be either M_SPAM or M_NOSPAM. M_SPAM is for spam commands. */ - if (data == M_SPAM) - { + if (data == M_SPAM) { /* If there's a second parameter, it's a template for the spam tag. */ - if (MoreArgs(s)) - { + if (MoreArgs (s)) { mutt_extract_token (&templ, s, 0); /* Add to the spam list. */ if (add_to_spam_list (&SpamList, buf->data, templ.data, err) != 0) { - FREE(&templ.data); - return -1; + FREE (&templ.data); + return -1; } - FREE(&templ.data); + FREE (&templ.data); } /* If not, try to remove from the nospam list. */ - else - { - remove_from_rx_list(&NoSpamList, buf->data); + else { + remove_from_rx_list (&NoSpamList, buf->data); } return 0; } /* M_NOSPAM is for nospam commands. */ - else if (data == M_NOSPAM) - { + else if (data == M_NOSPAM) { /* nospam only ever has one parameter. */ /* "*" is a special case. */ - if (!mutt_strcmp(buf->data, "*")) - { + if (!mutt_strcmp (buf->data, "*")) { mutt_free_spam_list (&SpamList); - mutt_free_rx_list (&NoSpamList); + list_del (&NoSpamList, rx_free); return 0; } /* If it's on the spam list, just remove it. */ - if (remove_from_spam_list(&SpamList, buf->data) != 0) + if (remove_from_spam_list (&SpamList, buf->data) != 0) return 0; /* Otherwise, add it to the nospam list. */ @@ -779,20 +682,19 @@ static int parse_spam_list (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER * } /* This should not happen. */ - strfcpy(err->data, "This is no good at all.", err->dsize); + strfcpy (err->data, "This is no good at all.", err->dsize); return -1; } -static int parse_unlist (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unlist (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); /* * Check for deletion of entire list */ - if (mutt_strcmp (buf->data, "*") == 0) - { + if (mutt_strcmp (buf->data, "*") == 0) { mutt_free_list ((LIST **) data); break; } @@ -803,13 +705,13 @@ static int parse_unlist (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err return 0; } -static int parse_lists (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_lists (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); remove_from_rx_list (&UnMailLists, buf->data); - + if (add_to_rx_list (&MailLists, buf->data, REG_ICASE, err) != 0) return -1; } @@ -818,16 +720,16 @@ static int parse_lists (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) return 0; } -static int parse_unlists (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unlists (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); remove_from_rx_list (&SubscribedLists, buf->data); remove_from_rx_list (&MailLists, buf->data); - - if (mutt_strcmp (buf->data, "*") && - add_to_rx_list (&UnMailLists, buf->data, REG_ICASE, err) != 0) + + if (mutt_strcmp (buf->data, "*") && + add_to_rx_list (&UnMailLists, buf->data, REG_ICASE, err) != 0) return -1; } while (MoreArgs (s)); @@ -835,10 +737,10 @@ static int parse_unlists (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *er return 0; } -static int parse_subscribe (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_subscribe (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); remove_from_rx_list (&UnMailLists, buf->data); remove_from_rx_list (&UnSubscribedLists, buf->data); @@ -853,96 +755,88 @@ static int parse_subscribe (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER * return 0; } -static int parse_unsubscribe (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_unsubscribe (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { - do - { + do { mutt_extract_token (buf, s, 0); remove_from_rx_list (&SubscribedLists, buf->data); - + if (mutt_strcmp (buf->data, "*") && - add_to_rx_list (&UnSubscribedLists, buf->data, REG_ICASE, err) != 0) + add_to_rx_list (&UnSubscribedLists, buf->data, REG_ICASE, err) != 0) return -1; } while (MoreArgs (s)); return 0; } - -static int parse_unalias (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) + +static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { ALIAS *tmp, *last = NULL; - do - { + do { mutt_extract_token (buf, s, 0); - if (mutt_strcmp ("*", buf->data) == 0) - { - if (CurrentMenu == MENU_ALIAS) - { - for (tmp = Aliases; tmp ; tmp = tmp->next) - tmp->del = 1; - set_option (OPTFORCEREDRAWINDEX); + if (mutt_strcmp ("*", buf->data) == 0) { + if (CurrentMenu == MENU_ALIAS) { + for (tmp = Aliases; tmp; tmp = tmp->next) + tmp->del = 1; + set_option (OPTFORCEREDRAWINDEX); } else - mutt_free_alias (&Aliases); + mutt_free_alias (&Aliases); break; } else - for (tmp = Aliases; tmp; tmp = tmp->next) - { - if (mutt_strcasecmp (buf->data, tmp->name) == 0) - { - if (CurrentMenu == MENU_ALIAS) - { - tmp->del = 1; - set_option (OPTFORCEREDRAWINDEX); - break; - } - - if (last) - last->next = tmp->next; - else - Aliases = tmp->next; - tmp->next = NULL; - mutt_free_alias (&tmp); - break; - } - last = tmp; + for (tmp = Aliases; tmp; tmp = tmp->next) { + if (mutt_strcasecmp (buf->data, tmp->name) == 0) { + if (CurrentMenu == MENU_ALIAS) { + tmp->del = 1; + set_option (OPTFORCEREDRAWINDEX); + break; + } + + if (last) + last->next = tmp->next; + else + Aliases = tmp->next; + tmp->next = NULL; + mutt_free_alias (&tmp); + break; + } + last = tmp; } } while (MoreArgs (s)); return 0; } -static int parse_alias (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { ALIAS *tmp = Aliases; ALIAS *last = NULL; char *estr = NULL; - - if (!MoreArgs (s)) - { + + if (!MoreArgs (s)) { strfcpy (err->data, _("alias: no address"), err->dsize); return (-1); } mutt_extract_token (buf, s, 0); - dprint (2, (debugfile, "parse_alias: First token is '%s'.\n", - buf->data)); + dprint (2, (debugfile, "parse_alias: First token is '%s'.\n", buf->data)); /* check to see if an alias with this name already exists */ - for (; tmp; tmp = tmp->next) - { + for (; tmp; tmp = tmp->next) { if (!mutt_strcasecmp (tmp->name, buf->data)) break; last = tmp; } - if (!tmp) - { + if (!tmp) { /* create a new alias */ tmp = (ALIAS *) safe_calloc (1, sizeof (ALIAS)); tmp->self = tmp; @@ -951,40 +845,35 @@ static int parse_alias (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) if (CurrentMenu == MENU_ALIAS) set_option (OPTMENUCALLER); } - else - { + else { /* override the previous value */ rfc822_free_address (&tmp->addr); if (CurrentMenu == MENU_ALIAS) set_option (OPTFORCEREDRAWINDEX); } - mutt_extract_token (buf, s, M_TOKEN_QUOTE | M_TOKEN_SPACE | M_TOKEN_SEMICOLON); - dprint (2, (debugfile, "parse_alias: Second token is '%s'.\n", - buf->data)); + mutt_extract_token (buf, s, + M_TOKEN_QUOTE | M_TOKEN_SPACE | M_TOKEN_SEMICOLON); + dprint (2, (debugfile, "parse_alias: Second token is '%s'.\n", buf->data)); tmp->addr = mutt_parse_adrlist (tmp->addr, buf->data); if (last) last->next = tmp; else Aliases = tmp; - if (mutt_addrlist_to_idna (tmp->addr, &estr)) - { - snprintf (err->data, err->dsize, _("Warning: Bad IDN '%s' in alias '%s'.\n"), - estr, tmp->name); + if (mutt_addrlist_to_idna (tmp->addr, &estr)) { + snprintf (err->data, err->dsize, + _("Warning: Bad IDN '%s' in alias '%s'.\n"), estr, tmp->name); return -1; } #ifdef DEBUG - if (debuglevel >= 2) - { + if (debuglevel >= 2) { ADDRESS *a; - for (a = tmp->addr; a; a = a->next) - { + + for (a = tmp->addr; a; a = a->next) { if (!a->group) - dprint (2, (debugfile, "parse_alias: %s\n", - a->mailbox)); + dprint (2, (debugfile, "parse_alias: %s\n", a->mailbox)); else - dprint (2, (debugfile, "parse_alias: Group %s\n", - a->mailbox)); + dprint (2, (debugfile, "parse_alias: Group %s\n", a->mailbox)); } } #endif @@ -992,45 +881,41 @@ static int parse_alias (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) } static int -parse_unmy_hdr (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +parse_unmy_hdr (BUFFER * buf, BUFFER * s, unsigned long data, BUFFER * err) { LIST *last = NULL; LIST *tmp = UserHeader; LIST *ptr; size_t l; - do - { + do { mutt_extract_token (buf, s, 0); if (mutt_strcmp ("*", buf->data) == 0) mutt_free_list (&UserHeader); - else - { + else { tmp = UserHeader; last = NULL; l = mutt_strlen (buf->data); if (buf->data[l - 1] == ':') - l--; - - while (tmp) - { - if (ascii_strncasecmp (buf->data, tmp->data, l) == 0 && tmp->data[l] == ':') - { - ptr = tmp; - if (last) - last->next = tmp->next; - else - UserHeader = tmp->next; - tmp = tmp->next; - ptr->next = NULL; - mutt_free_list (&ptr); - } - else - { - last = tmp; - tmp = tmp->next; - } + l--; + + while (tmp) { + if (ascii_strncasecmp (buf->data, tmp->data, l) == 0 + && tmp->data[l] == ':') { + ptr = tmp; + if (last) + last->next = tmp->next; + else + UserHeader = tmp->next; + tmp = tmp->next; + ptr->next = NULL; + mutt_free_list (&ptr); + } + else { + last = tmp; + tmp = tmp->next; + } } } } @@ -1038,41 +923,37 @@ parse_unmy_hdr (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) return 0; } -static int parse_my_hdr (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data, + BUFFER * err) { LIST *tmp; size_t keylen; char *p; mutt_extract_token (buf, s, M_TOKEN_SPACE | M_TOKEN_QUOTE); - if ((p = strpbrk (buf->data, ": \t")) == NULL || *p != ':') - { + if ((p = strpbrk (buf->data, ": \t")) == NULL || *p != ':') { strfcpy (err->data, _("invalid header field"), err->dsize); return (-1); } keylen = p - buf->data + 1; - if (UserHeader) - { - for (tmp = UserHeader; ; tmp = tmp->next) - { + if (UserHeader) { + for (tmp = UserHeader;; tmp = tmp->next) { /* see if there is already a field by this name */ - if (ascii_strncasecmp (buf->data, tmp->data, keylen) == 0) - { - /* replace the old value */ - FREE (&tmp->data); - tmp->data = buf->data; - memset (buf, 0, sizeof (BUFFER)); - return 0; + if (ascii_strncasecmp (buf->data, tmp->data, keylen) == 0) { + /* replace the old value */ + FREE (&tmp->data); + tmp->data = buf->data; + memset (buf, 0, sizeof (BUFFER)); + return 0; } if (!tmp->next) - break; + break; } tmp->next = mutt_new_list (); tmp = tmp->next; } - else - { + else { tmp = mutt_new_list (); UserHeader = tmp; } @@ -1082,24 +963,22 @@ static int parse_my_hdr (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err } static int -parse_sort (short *val, const char *s, const struct mapping_t *map, BUFFER *err) +parse_sort (short *val, const char *s, const struct mapping_t *map, + BUFFER * err) { int i, flags = 0; - if (mutt_strncmp ("reverse-", s, 8) == 0) - { + if (mutt_strncmp ("reverse-", s, 8) == 0) { s += 8; flags = SORT_REVERSE; } - - if (mutt_strncmp ("last-", s, 5) == 0) - { + + if (mutt_strncmp ("last-", s, 5) == 0) { s += 5; flags |= SORT_LAST; } - if ((i = mutt_getvaluebyname (s, map)) == -1) - { + if ((i = mutt_getvaluebyname (s, map)) == -1) { snprintf (err->data, err->dsize, _("%s: unknown sorting method"), s); return (-1); } @@ -1111,34 +990,34 @@ parse_sort (short *val, const char *s, const struct mapping_t *map, BUFFER *err) static void mutt_set_default (struct option_t *p) { - switch (p->type & DT_MASK) - { - case DT_STR: - if (!p->init && *((char **) p->data)) - p->init = (unsigned long) safe_strdup (* ((char **) p->data)); - break; - case DT_PATH: - if (!p->init && *((char **) p->data)) - { - char *cp = safe_strdup (*((char **) p->data)); - /* mutt_pretty_mailbox (cp); */ - p->init = (unsigned long) cp; - } - break; - case DT_ADDR: - if (!p->init && *((ADDRESS **) p->data)) - { - char tmp[HUGE_STRING]; - *tmp = '\0'; - rfc822_write_address (tmp, sizeof (tmp), *((ADDRESS **) p->data), 0); - p->init = (unsigned long) safe_strdup (tmp); - } - break; - case DT_RX: + switch (p->type & DT_MASK) { + case DT_STR: + if (!p->init && *((char **) p->data)) + p->init = (unsigned long) safe_strdup (*((char **) p->data)); + break; + case DT_PATH: + if (!p->init && *((char **) p->data)) { + char *cp = safe_strdup (*((char **) p->data)); + + /* mutt_pretty_mailbox (cp); */ + p->init = (unsigned long) cp; + } + break; + case DT_ADDR: + if (!p->init && *((ADDRESS **) p->data)) { + char tmp[HUGE_STRING]; + + *tmp = '\0'; + rfc822_write_address (tmp, sizeof (tmp), *((ADDRESS **) p->data), 0); + p->init = (unsigned long) safe_strdup (tmp); + } + break; + case DT_RX: { - REGEXP *pp = (REGEXP *) p->data; + rx_t* pp = (rx_t*) p->data; + if (!p->init && pp->pattern) - p->init = (unsigned long) safe_strdup (pp->pattern); + p->init = (unsigned long) safe_strdup (pp->pattern); break; } } @@ -1146,78 +1025,74 @@ static void mutt_set_default (struct option_t *p) static void mutt_restore_default (struct option_t *p) { - switch (p->type & DT_MASK) - { - case DT_STR: - if (p->init) - mutt_str_replace ((char **) p->data, (char *) p->init); - break; - case DT_PATH: - if (p->init) - { - char path[_POSIX_PATH_MAX]; - - strfcpy (path, (char *) p->init, sizeof (path)); - mutt_expand_path (path, sizeof (path)); - mutt_str_replace ((char **) p->data, path); - } - break; - case DT_ADDR: - if (p->init) - { - rfc822_free_address ((ADDRESS **) p->data); - *((ADDRESS **) p->data) = rfc822_parse_adrlist (NULL, (char *) p->init); + switch (p->type & DT_MASK) { + case DT_STR: + if (p->init) + mutt_str_replace ((char **) p->data, (char *) p->init); + break; + case DT_PATH: + if (p->init) { + char path[_POSIX_PATH_MAX]; + + strfcpy (path, (char *) p->init, sizeof (path)); + mutt_expand_path (path, sizeof (path)); + mutt_str_replace ((char **) p->data, path); + } + break; + case DT_ADDR: + if (p->init) { + rfc822_free_address ((ADDRESS **) p->data); + *((ADDRESS **) p->data) = rfc822_parse_adrlist (NULL, (char *) p->init); + } + break; + case DT_BOOL: + if (p->init) + set_option (p->data); + else + unset_option (p->data); + break; + case DT_QUAD: + set_quadoption (p->data, p->init); + break; + case DT_NUM: + case DT_SORT: + case DT_MAGIC: + *((short *) p->data) = p->init; + break; + case DT_RX: + { + rx_t *pp = (rx_t *) p->data; + int flags = 0; + + FREE (&pp->pattern); + if (pp->rx) { + regfree (pp->rx); + FREE (&pp->rx); } - break; - case DT_BOOL: - if (p->init) - set_option (p->data); - else - unset_option (p->data); - break; - case DT_QUAD: - set_quadoption (p->data, p->init); - break; - case DT_NUM: - case DT_SORT: - case DT_MAGIC: - *((short *) p->data) = p->init; - break; - case DT_RX: - { - REGEXP *pp = (REGEXP *) p->data; - int flags = 0; - - FREE (&pp->pattern); - if (pp->rx) - { - regfree (pp->rx); - FREE (&pp->rx); - } - - if (p->init) - { - char *s = (char *) p->init; - - pp->rx = safe_calloc (1, sizeof (regex_t)); - if (mutt_strcmp (p->option, "mask") != 0) - flags |= mutt_which_case ((const char *) p->init); - if (mutt_strcmp (p->option, "mask") == 0 && *s == '!') - { - s++; - pp->not = 1; - } - if (REGCOMP (pp->rx, s, flags) != 0) - { - fprintf (stderr, _("mutt_restore_default(%s): error in regexp: %s\n"), - p->option, pp->pattern); - FREE (&pp->pattern); - regfree (pp->rx); - FREE (&pp->rx); - } - } + + if (p->init) { + char *s = (char *) p->init; + + pp->rx = safe_calloc (1, sizeof (regex_t)); + if (mutt_strcmp (p->option, "mask") != 0) + flags |= mutt_which_case ((const char *) p->init); + if (mutt_strcmp (p->option, "mask") == 0 && *s == '!') { + s++; + pp->not = 1; + } + if (REGCOMP (pp->rx, s, flags) != 0) { + fprintf (stderr, + _("mutt_restore_default(%s): error in regexp: %s\n"), + p->option, pp->pattern); + FREE (&pp->pattern); + regfree (pp->rx); + FREE (&pp->rx); + } + else + mutt_str_replace (&pp->pattern, (char *) p->init); } - break; + } + break; } if (p->flags & R_INDEX) @@ -1234,36 +1109,32 @@ static void mutt_restore_default (struct option_t *p) set_option (OPTREDRAWTREE); } -static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data, + BUFFER * err) { int idx, query, unset, inv, reset, r = 0; char *p, scratch[_POSIX_PATH_MAX]; - while (MoreArgs (s)) - { + while (MoreArgs (s)) { /* reset state variables */ query = 0; unset = data & M_SET_UNSET; inv = data & M_SET_INV; reset = data & M_SET_RESET; - if (*s->dptr == '?') - { + if (*s->dptr == '?') { query = 1; s->dptr++; } - else if (mutt_strncmp ("no", s->dptr, 2) == 0) - { + else if (mutt_strncmp ("no", s->dptr, 2) == 0) { s->dptr += 2; unset = !unset; } - else if (mutt_strncmp ("inv", s->dptr, 3) == 0) - { + else if (mutt_strncmp ("inv", s->dptr, 3) == 0) { s->dptr += 3; inv = !inv; } - else if (*s->dptr == '&') - { + else if (*s->dptr == '&') { reset = 1; s->dptr++; } @@ -1272,268 +1143,238 @@ static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) mutt_extract_token (tmp, s, M_TOKEN_EQUAL); if ((idx = mutt_option_index (tmp->data)) == -1 && - !(reset && !mutt_strcmp ("all", tmp->data))) - { + !(reset && !mutt_strcmp ("all", tmp->data))) { snprintf (err->data, err->dsize, _("%s: unknown variable"), tmp->data); return (-1); } SKIPWS (s->dptr); - if (reset) - { - if (query || unset || inv) - { - snprintf (err->data, err->dsize, _("prefix is illegal with reset")); - return (-1); + if (reset) { + if (query || unset || inv) { + snprintf (err->data, err->dsize, _("prefix is illegal with reset")); + return (-1); } - if (s && *s->dptr == '=') - { - snprintf (err->data, err->dsize, _("value is illegal with reset")); - return (-1); + if (s && *s->dptr == '=') { + snprintf (err->data, err->dsize, _("value is illegal with reset")); + return (-1); } - - if (!mutt_strcmp ("all", tmp->data)) - { - for (idx = 0; MuttVars[idx].option; idx++) - mutt_restore_default (&MuttVars[idx]); - return 0; + + if (!mutt_strcmp ("all", tmp->data)) { + for (idx = 0; MuttVars[idx].option; idx++) + mutt_restore_default (&MuttVars[idx]); + return 0; } else - mutt_restore_default (&MuttVars[idx]); - } - else if (DTYPE (MuttVars[idx].type) == DT_BOOL) - { - if (s && *s->dptr == '=') - { - if (unset || inv || query) - { - snprintf (err->data, err->dsize, "Usage: set variable=yes|no"); - return (-1); - } - - s->dptr++; - mutt_extract_token (tmp, s, 0); - if (ascii_strcasecmp ("yes", tmp->data) == 0) - unset = inv = 0; - else if (ascii_strcasecmp ("no", tmp->data) == 0) - unset = 1; - else - { - snprintf (err->data, err->dsize, "Usage: set variable=yes|no"); - return (-1); - } + mutt_restore_default (&MuttVars[idx]); + } + else if (DTYPE (MuttVars[idx].type) == DT_BOOL) { + if (s && *s->dptr == '=') { + if (unset || inv || query) { + snprintf (err->data, err->dsize, "Usage: set variable=yes|no"); + return (-1); + } + + s->dptr++; + mutt_extract_token (tmp, s, 0); + if (ascii_strcasecmp ("yes", tmp->data) == 0) + unset = inv = 0; + else if (ascii_strcasecmp ("no", tmp->data) == 0) + unset = 1; + else { + snprintf (err->data, err->dsize, "Usage: set variable=yes|no"); + return (-1); + } } - if (query) - { - snprintf (err->data, err->dsize, option (MuttVars[idx].data) - ? _("%s is set") : _("%s is unset"), tmp->data); - return 0; + if (query) { + snprintf (err->data, err->dsize, option (MuttVars[idx].data) + ? _("%s is set") : _("%s is unset"), tmp->data); + return 0; } if (unset) - unset_option (MuttVars[idx].data); + unset_option (MuttVars[idx].data); else if (inv) - toggle_option (MuttVars[idx].data); + toggle_option (MuttVars[idx].data); else - set_option (MuttVars[idx].data); + set_option (MuttVars[idx].data); } else if (DTYPE (MuttVars[idx].type) == DT_STR || - DTYPE (MuttVars[idx].type) == DT_PATH || - DTYPE (MuttVars[idx].type) == DT_ADDR) - { - if (unset) - { - if (DTYPE (MuttVars[idx].type) == DT_ADDR) - rfc822_free_address ((ADDRESS **) MuttVars[idx].data); - else - FREE ((void *)MuttVars[idx].data); + DTYPE (MuttVars[idx].type) == DT_PATH || + DTYPE (MuttVars[idx].type) == DT_ADDR) { + if (unset) { + if (DTYPE (MuttVars[idx].type) == DT_ADDR) + rfc822_free_address ((ADDRESS **) MuttVars[idx].data); + else + FREE ((void *) MuttVars[idx].data); } - else if (query || *s->dptr != '=') - { - char _tmp[STRING]; - char *val = NULL; - - if (DTYPE (MuttVars[idx].type) == DT_ADDR) - { - _tmp[0] = '\0'; - rfc822_write_address (_tmp, sizeof (_tmp), *((ADDRESS **) MuttVars[idx].data), 0); - val = _tmp; - } - else - val = *((char **) MuttVars[idx].data); - - /* user requested the value of this variable */ - snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, - NONULL (val)); - break; + else if (query || *s->dptr != '=') { + char _tmp[STRING]; + char *val = NULL; + + if (DTYPE (MuttVars[idx].type) == DT_ADDR) { + _tmp[0] = '\0'; + rfc822_write_address (_tmp, sizeof (_tmp), + *((ADDRESS **) MuttVars[idx].data), 0); + val = _tmp; + } + else + val = *((char **) MuttVars[idx].data); + + /* user requested the value of this variable */ + snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, + NONULL (val)); + break; } - else - { + else { s->dptr++; /* copy the value of the string */ if (DTYPE (MuttVars[idx].type) == DT_ADDR) - rfc822_free_address ((ADDRESS **) MuttVars[idx].data); + rfc822_free_address ((ADDRESS **) MuttVars[idx].data); else - FREE ((void *)MuttVars[idx].data); + FREE ((void *) MuttVars[idx].data); mutt_extract_token (tmp, s, 0); - if (DTYPE (MuttVars[idx].type) == DT_PATH) - { - strfcpy (scratch, tmp->data, sizeof (scratch)); - mutt_expand_path (scratch, sizeof (scratch)); - *((char **) MuttVars[idx].data) = safe_strdup (scratch); + if (DTYPE (MuttVars[idx].type) == DT_PATH) { + strfcpy (scratch, tmp->data, sizeof (scratch)); + mutt_expand_path (scratch, sizeof (scratch)); + *((char **) MuttVars[idx].data) = safe_strdup (scratch); } - else if (DTYPE (MuttVars[idx].type) == DT_STR) - { - *((char **) MuttVars[idx].data) = safe_strdup (tmp->data); - if (mutt_strcmp (MuttVars[idx].option, "charset") == 0) - mutt_set_charset (Charset); + else if (DTYPE (MuttVars[idx].type) == DT_STR) { + *((char **) MuttVars[idx].data) = safe_strdup (tmp->data); + if (mutt_strcmp (MuttVars[idx].option, "charset") == 0) + mutt_set_charset (Charset); } - else - { - *((ADDRESS **) MuttVars[idx].data) = rfc822_parse_adrlist (NULL, tmp->data); + else { + *((ADDRESS **) MuttVars[idx].data) = + rfc822_parse_adrlist (NULL, tmp->data); } } } - else if (DTYPE(MuttVars[idx].type) == DT_RX) - { - REGEXP *ptr = (REGEXP *) MuttVars[idx].data; + else if (DTYPE (MuttVars[idx].type) == DT_RX) { + rx_t *ptr = (rx_t *) MuttVars[idx].data; regex_t *rx; int e, flags = 0; - if (query || *s->dptr != '=') - { - /* user requested the value of this variable */ - snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, - NONULL (ptr->pattern)); - break; + if (query || *s->dptr != '=') { + /* user requested the value of this variable */ + snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option, + NONULL (ptr->pattern)); + break; } - if (option(OPTATTACHMSG) && !mutt_strcmp(MuttVars[idx].option, "reply_regexp")) - { - snprintf (err->data, err->dsize, "Operation not permitted when in attach-message mode."); - r = -1; - break; + if (option (OPTATTACHMSG) + && !mutt_strcmp (MuttVars[idx].option, "reply_regexp")) { + snprintf (err->data, err->dsize, + "Operation not permitted when in attach-message mode."); + r = -1; + break; } - + s->dptr++; /* copy the value of the string */ mutt_extract_token (tmp, s, 0); - if (!ptr->pattern || mutt_strcmp (ptr->pattern, tmp->data) != 0) - { - int not = 0; - - /* $mask is case-sensitive */ - if (mutt_strcmp (MuttVars[idx].option, "mask") != 0) - flags |= mutt_which_case (tmp->data); - - p = tmp->data; - if (mutt_strcmp (MuttVars[idx].option, "mask") == 0) - { - if (*p == '!') - { - not = 1; - p++; - } - } - - rx = (regex_t *) safe_malloc (sizeof (regex_t)); - if ((e = REGCOMP (rx, p, flags)) != 0) - { - regerror (e, rx, err->data, err->dsize); - regfree (rx); - FREE (&rx); - break; - } - - /* get here only if everything went smootly */ - if (ptr->pattern) - { - FREE (&ptr->pattern); - regfree ((regex_t *) ptr->rx); - FREE (&ptr->rx); - } - - ptr->pattern = safe_strdup (tmp->data); - ptr->rx = rx; - ptr->not = not; - - /* $reply_regexp and $alterantes require special treatment */ - - if (Context && Context->msgcount && - mutt_strcmp (MuttVars[idx].option, "reply_regexp") == 0) - { - regmatch_t pmatch[1]; - int i; - + if (!ptr->pattern || mutt_strcmp (ptr->pattern, tmp->data) != 0) { + int not = 0; + + /* $mask is case-sensitive */ + if (mutt_strcmp (MuttVars[idx].option, "mask") != 0) + flags |= mutt_which_case (tmp->data); + + p = tmp->data; + if (mutt_strcmp (MuttVars[idx].option, "mask") == 0) { + if (*p == '!') { + not = 1; + p++; + } + } + + rx = (regex_t *) safe_malloc (sizeof (regex_t)); + if ((e = REGCOMP (rx, p, flags)) != 0) { + regerror (e, rx, err->data, err->dsize); + regfree (rx); + FREE (&rx); + break; + } + + /* get here only if everything went smootly */ + if (ptr->pattern) { + FREE (&ptr->pattern); + regfree ((regex_t *) ptr->rx); + FREE (&ptr->rx); + } + + ptr->pattern = safe_strdup (tmp->data); + ptr->rx = rx; + ptr->not = not; + + /* $reply_regexp and $alterantes require special treatment */ + + if (Context && Context->msgcount && + mutt_strcmp (MuttVars[idx].option, "reply_regexp") == 0) { + regmatch_t pmatch[1]; + int i; + #define CUR_ENV Context->hdrs[i]->env - for (i = 0; i < Context->msgcount; i++) - { - if (CUR_ENV && CUR_ENV->subject) - { - CUR_ENV->real_subj = (regexec (ReplyRegexp.rx, - CUR_ENV->subject, 1, pmatch, 0)) ? - CUR_ENV->subject : - CUR_ENV->subject + pmatch[0].rm_eo; - } - } + for (i = 0; i < Context->msgcount; i++) { + if (CUR_ENV && CUR_ENV->subject) { + CUR_ENV->real_subj = (regexec (ReplyRegexp.rx, + CUR_ENV->subject, 1, pmatch, + 0)) ? CUR_ENV-> + subject : CUR_ENV->subject + pmatch[0].rm_eo; + } + } #undef CUR_ENV - } + } } } - else if (DTYPE(MuttVars[idx].type) == DT_MAGIC) - { - if (query || *s->dptr != '=') - { - switch (DefaultMagic) - { - case M_MBOX: - p = "mbox"; - break; - case M_MMDF: - p = "MMDF"; - break; - case M_MH: - p = "MH"; - break; - case M_MAILDIR: - p = "Maildir"; - break; - default: - p = "unknown"; - break; - } - snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, p); - break; + else if (DTYPE (MuttVars[idx].type) == DT_MAGIC) { + if (query || *s->dptr != '=') { + switch (DefaultMagic) { + case M_MBOX: + p = "mbox"; + break; + case M_MMDF: + p = "MMDF"; + break; + case M_MH: + p = "MH"; + break; + case M_MAILDIR: + p = "Maildir"; + break; + default: + p = "unknown"; + break; + } + snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, p); + break; } s->dptr++; /* copy the value of the string */ mutt_extract_token (tmp, s, 0); - if (mx_set_magic (tmp->data)) - { - snprintf (err->data, err->dsize, _("%s: invalid mailbox type"), tmp->data); - r = -1; - break; + if (mx_set_magic (tmp->data)) { + snprintf (err->data, err->dsize, _("%s: invalid mailbox type"), + tmp->data); + r = -1; + break; } } - else if (DTYPE(MuttVars[idx].type) == DT_NUM) - { + else if (DTYPE (MuttVars[idx].type) == DT_NUM) { short *ptr = (short *) MuttVars[idx].data; int val; char *t; - if (query || *s->dptr != '=') - { - /* user requested the value of this variable */ - snprintf (err->data, err->dsize, "%s=%d", MuttVars[idx].option, *ptr); - break; + if (query || *s->dptr != '=') { + /* user requested the value of this variable */ + snprintf (err->data, err->dsize, "%s=%d", MuttVars[idx].option, *ptr); + break; } s->dptr++; @@ -1541,121 +1382,113 @@ static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) mutt_extract_token (tmp, s, 0); val = strtol (tmp->data, &t, 0); - if (!*tmp->data || *t || (short) val != val) - { - snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data); - r = -1; - break; + if (!*tmp->data || *t || (short) val != val) { + snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data); + r = -1; + break; } else - *ptr = (short) val; + *ptr = (short) val; /* these ones need a sanity check */ - if (mutt_strcmp (MuttVars[idx].option, "history") == 0) - { - if (*ptr < 0) - *ptr = 0; - mutt_init_history (); + if (mutt_strcmp (MuttVars[idx].option, "history") == 0) { + if (*ptr < 0) + *ptr = 0; + mutt_init_history (); } - else if (mutt_strcmp (MuttVars[idx].option, "pager_index_lines") == 0) - { - if (*ptr < 0) - *ptr = 0; + else if (mutt_strcmp (MuttVars[idx].option, "pager_index_lines") == 0) { + if (*ptr < 0) + *ptr = 0; } } - else if (DTYPE (MuttVars[idx].type) == DT_QUAD) - { - if (query) - { - char *vals[] = { "no", "yes", "ask-no", "ask-yes" }; + else if (DTYPE (MuttVars[idx].type) == DT_QUAD) { + if (query) { + char *vals[] = { "no", "yes", "ask-no", "ask-yes" }; - snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, - vals [ quadoption (MuttVars[idx].data) ]); - break; + snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, + vals[quadoption (MuttVars[idx].data)]); + break; } - if (*s->dptr == '=') - { - s->dptr++; - mutt_extract_token (tmp, s, 0); - if (ascii_strcasecmp ("yes", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_YES); - else if (ascii_strcasecmp ("no", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_NO); - else if (ascii_strcasecmp ("ask-yes", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_ASKYES); - else if (ascii_strcasecmp ("ask-no", tmp->data) == 0) - set_quadoption (MuttVars[idx].data, M_ASKNO); - else - { - snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data); - r = -1; - break; - } + if (*s->dptr == '=') { + s->dptr++; + mutt_extract_token (tmp, s, 0); + if (ascii_strcasecmp ("yes", tmp->data) == 0) + set_quadoption (MuttVars[idx].data, M_YES); + else if (ascii_strcasecmp ("no", tmp->data) == 0) + set_quadoption (MuttVars[idx].data, M_NO); + else if (ascii_strcasecmp ("ask-yes", tmp->data) == 0) + set_quadoption (MuttVars[idx].data, M_ASKYES); + else if (ascii_strcasecmp ("ask-no", tmp->data) == 0) + set_quadoption (MuttVars[idx].data, M_ASKNO); + else { + snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data); + r = -1; + break; + } } - else - { - if (inv) - toggle_quadoption (MuttVars[idx].data); - else if (unset) - set_quadoption (MuttVars[idx].data, M_NO); - else - set_quadoption (MuttVars[idx].data, M_YES); + else { + if (inv) + toggle_quadoption (MuttVars[idx].data); + else if (unset) + set_quadoption (MuttVars[idx].data, M_NO); + else + set_quadoption (MuttVars[idx].data, M_YES); } } - else if (DTYPE (MuttVars[idx].type) == DT_SORT) - { + else if (DTYPE (MuttVars[idx].type) == DT_SORT) { const struct mapping_t *map = NULL; - switch (MuttVars[idx].type & DT_SUBTYPE_MASK) - { - case DT_SORT_ALIAS: - map = SortAliasMethods; - break; - case DT_SORT_BROWSER: - map = SortBrowserMethods; - break; - case DT_SORT_KEYS: - if ((WithCrypto & APPLICATION_PGP)) - map = SortKeyMethods; - break; - case DT_SORT_AUX: - map = SortAuxMethods; - break; - default: - map = SortMethods; - break; + switch (MuttVars[idx].type & DT_SUBTYPE_MASK) { + case DT_SORT_ALIAS: + map = SortAliasMethods; + break; + case DT_SORT_BROWSER: + map = SortBrowserMethods; + break; + case DT_SORT_KEYS: + if ((WithCrypto & APPLICATION_PGP)) + map = SortKeyMethods; + break; + case DT_SORT_AUX: + map = SortAuxMethods; + break; + default: + map = SortMethods; + break; } - if (!map) - { - snprintf (err->data, err->dsize, _("%s: Unknown type."), MuttVars[idx].option); - r = -1; - break; + if (!map) { + snprintf (err->data, err->dsize, _("%s: Unknown type."), + MuttVars[idx].option); + r = -1; + break; } - - if (query || *s->dptr != '=') - { - p = mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, map); - - snprintf (err->data, err->dsize, "%s=%s%s%s", MuttVars[idx].option, - (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? "reverse-" : "", - (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : "", - p); - return 0; + + if (query || *s->dptr != '=') { + p = + mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, + map); + + snprintf (err->data, err->dsize, "%s=%s%s%s", MuttVars[idx].option, + (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? + "reverse-" : "", + (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : + "", p); + return 0; } s->dptr++; - mutt_extract_token (tmp, s , 0); + mutt_extract_token (tmp, s, 0); - if (parse_sort ((short *) MuttVars[idx].data, tmp->data, map, err) == -1) - { - r = -1; - break; + if (parse_sort ((short *) MuttVars[idx].data, tmp->data, map, err) == + -1) { + r = -1; + break; } } - else - { - snprintf (err->data, err->dsize, _("%s: unknown type"), MuttVars[idx].option); + else { + snprintf (err->data, err->dsize, _("%s: unknown type"), + MuttVars[idx].option); r = -1; break; } @@ -1680,7 +1513,7 @@ static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) /* reads the specified initialization file. returns -1 if errors were found so that we can pause to let the user know... */ -static int source_rc (const char *rcfile, BUFFER *err) +static int source_rc (const char *rcfile, BUFFER * err) { FILE *f; int line = 0, rc = 0, conv = 0; @@ -1690,55 +1523,51 @@ static int source_rc (const char *rcfile, BUFFER *err) size_t buflen; pid_t pid; - dprint (2, (debugfile, "Reading configuration file '%s'.\n", - rcfile)); - - if ((f = mutt_open_read (rcfile, &pid)) == NULL) - { + dprint (2, (debugfile, "Reading configuration file '%s'.\n", rcfile)); + + if ((f = mutt_open_read (rcfile, &pid)) == NULL) { snprintf (err->data, err->dsize, "%s: %s", rcfile, strerror (errno)); return (-1); } memset (&token, 0, sizeof (token)); - while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) - { - conv=ConfigCharset && (*ConfigCharset) && Charset; - if (conv) - { - currentline=safe_strdup(linebuf); - if (!currentline) continue; - mutt_convert_string(¤tline, ConfigCharset, Charset, 0); - } - else - currentline=linebuf; - - if (mutt_parse_rc_line (currentline, &token, err) == -1) - { + while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) { + conv = ConfigCharset && (*ConfigCharset) && Charset; + if (conv) { + currentline = safe_strdup (linebuf); + if (!currentline) + continue; + mutt_convert_string (¤tline, ConfigCharset, Charset, 0); + } + else + currentline = linebuf; + + if (mutt_parse_rc_line (currentline, &token, err) == -1) { mutt_error (_("Error in %s, line %d: %s"), rcfile, line, err->data); - if (--rc < -MAXERRS) - { - if (conv) FREE(¤tline); + if (--rc < -MAXERRS) { + if (conv) + FREE (¤tline); break; } } - else - { + else { if (rc < 0) rc = -1; } if (conv) - FREE(¤tline); + FREE (¤tline); } FREE (&token.data); FREE (&linebuf); fclose (f); if (pid != -1) mutt_wait_filter (pid); - if (rc) - { + if (rc) { /* the muttrc source keyword */ - snprintf (err->data, err->dsize, rc >= -MAXERRS ? _("source: errors in %s") - : _("source: reading aborted due too many errors in %s"), rcfile); + snprintf (err->data, err->dsize, + rc >= -MAXERRS ? _("source: errors in %s") + : _("source: reading aborted due too many errors in %s"), + rcfile); rc = -1; } return (rc); @@ -1746,15 +1575,14 @@ static int source_rc (const char *rcfile, BUFFER *err) #undef MAXERRS -static int parse_source (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err) +static int parse_source (BUFFER * tmp, BUFFER * s, unsigned long data, + BUFFER * err) { char path[_POSIX_PATH_MAX]; int rc = 0; - do - { - if (mutt_extract_token (tmp, s, 0) != 0) - { + do { + if (mutt_extract_token (tmp, s, 0) != 0) { snprintf (err->data, err->dsize, _("source: error at %s"), s->dptr); return (-1); } @@ -1779,7 +1607,7 @@ static int parse_source (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err every call to this function. err where to write error messages */ -int mutt_parse_rc_line (/* const */ char *line, BUFFER *token, BUFFER *err) +int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err) { int i, r = -1; BUFFER expn; @@ -1791,28 +1619,24 @@ int mutt_parse_rc_line (/* const */ char *line, BUFFER *token, BUFFER *err) *err->data = 0; SKIPWS (expn.dptr); - while (*expn.dptr) - { + while (*expn.dptr) { if (*expn.dptr == '#') - break; /* rest of line is a comment */ - if (*expn.dptr == ';') - { + break; /* rest of line is a comment */ + if (*expn.dptr == ';') { expn.dptr++; continue; } mutt_extract_token (token, &expn, 0); - for (i = 0; Commands[i].name; i++) - { - if (!mutt_strcmp (token->data, Commands[i].name)) - { - if (Commands[i].func (token, &expn, Commands[i].data, err) != 0) - goto finish; + for (i = 0; Commands[i].name; i++) { + if (!mutt_strcmp (token->data, Commands[i].name)) { + if (Commands[i].func (token, &expn, Commands[i].data, err) != 0) + goto finish; break; } } - if (!Commands[i].name) - { - snprintf (err->data, err->dsize, _("%s: unknown command"), NONULL (token->data)); + if (!Commands[i].name) { + snprintf (err->data, err->dsize, _("%s: unknown command"), + NONULL (token->data)); goto finish; } } @@ -1828,11 +1652,11 @@ finish: #define NUMCOMMANDS (sizeof (Commands)/sizeof (Commands[0])) /* initial string that starts completion. No telling how much crap * the user has typed so far. Allocate LONG_STRING just to be sure! */ -char User_typed [LONG_STRING] = {0}; +char User_typed[LONG_STRING] = { 0 }; -int Num_matched = 0; /* Number of matches for completion */ -char Completed [STRING] = {0}; /* completed string (command or variable) */ -char *Matches[MAX(NUMVARS,NUMCOMMANDS) + 1]; /* all the matches + User_typed */ +int Num_matched = 0; /* Number of matches for completion */ +char Completed[STRING] = { 0 }; /* completed string (command or variable) */ +char *Matches[MAX (NUMVARS, NUMCOMMANDS) + 1]; /* all the matches + User_typed */ /* helper function for completion. Changes the dest buffer if necessary/possible to aid completion. @@ -1845,13 +1669,11 @@ static void candidate (char *dest, char *try, char *src, int len) { int l; - if (strstr (src, try) == src) - { + if (strstr (src, try) == src) { Matches[Num_matched++] = src; if (dest[0] == 0) strfcpy (dest, src, len); - else - { + else { for (l = 0; src[l] && src[l] == dest[l]; l++); dest[l] = 0; } @@ -1862,7 +1684,7 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) { char *pt = buffer; int num; - int spaces; /* keep track of the number of leading spaces on the line */ + int spaces; /* keep track of the number of leading spaces on the line */ SKIPWS (buffer); spaces = buffer - pt; @@ -1871,76 +1693,71 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) while ((pt > buffer) && !isspace ((unsigned char) *pt)) pt--; - if (pt == buffer) /* complete cmd */ - { + if (pt == buffer) { /* complete cmd */ /* first TAB. Collect all the matches */ - if (numtabs == 1) - { + if (numtabs == 1) { Num_matched = 0; strfcpy (User_typed, pt, sizeof (User_typed)); memset (Matches, 0, sizeof (Matches)); memset (Completed, 0, sizeof (Completed)); for (num = 0; Commands[num].name; num++) - candidate (Completed, User_typed, Commands[num].name, sizeof (Completed)); + candidate (Completed, User_typed, Commands[num].name, + sizeof (Completed)); Matches[Num_matched++] = User_typed; /* All matches are stored. Longest non-ambiguous string is "" * i.e. dont change 'buffer'. Fake successful return this time */ if (User_typed[0] == 0) - return 1; + return 1; } if (Completed[0] == 0 && User_typed[0]) return 0; - /* Num_matched will _always_ be atleast 1 since the initial - * user-typed string is always stored */ + /* Num_matched will _always_ be atleast 1 since the initial + * user-typed string is always stored */ if (numtabs == 1 && Num_matched == 2) - snprintf(Completed, sizeof(Completed),"%s", Matches[0]); + snprintf (Completed, sizeof (Completed), "%s", Matches[0]); else if (numtabs > 1 && Num_matched > 2) /* cycle thru all the matches */ - snprintf(Completed, sizeof(Completed), "%s", - Matches[(numtabs - 2) % Num_matched]); + snprintf (Completed, sizeof (Completed), "%s", + Matches[(numtabs - 2) % Num_matched]); /* return the completed command */ strncpy (buffer, Completed, len - spaces); } else if (!mutt_strncmp (buffer, "set", 3) - || !mutt_strncmp (buffer, "unset", 5) - || !mutt_strncmp (buffer, "reset", 5) - || !mutt_strncmp (buffer, "toggle", 6)) - { /* complete variables */ + || !mutt_strncmp (buffer, "unset", 5) + || !mutt_strncmp (buffer, "reset", 5) + || !mutt_strncmp (buffer, "toggle", 6)) { /* complete variables */ char *prefixes[] = { "no", "inv", "?", "&", 0 }; - + pt++; /* loop through all the possible prefixes (no, inv, ...) */ - if (!mutt_strncmp (buffer, "set", 3)) - { - for (num = 0; prefixes[num]; num++) - { - if (!mutt_strncmp (pt, prefixes[num], mutt_strlen (prefixes[num]))) - { - pt += mutt_strlen (prefixes[num]); - break; - } + if (!mutt_strncmp (buffer, "set", 3)) { + for (num = 0; prefixes[num]; num++) { + if (!mutt_strncmp (pt, prefixes[num], mutt_strlen (prefixes[num]))) { + pt += mutt_strlen (prefixes[num]); + break; + } } } - + /* first TAB. Collect all the matches */ - if (numtabs == 1) - { + if (numtabs == 1) { Num_matched = 0; strfcpy (User_typed, pt, sizeof (User_typed)); memset (Matches, 0, sizeof (Matches)); memset (Completed, 0, sizeof (Completed)); for (num = 0; MuttVars[num].option; num++) - candidate (Completed, User_typed, MuttVars[num].option, sizeof (Completed)); + candidate (Completed, User_typed, MuttVars[num].option, + sizeof (Completed)); Matches[Num_matched++] = User_typed; /* All matches are stored. Longest non-ambiguous string is "" * i.e. dont change 'buffer'. Fake successful return this time */ if (User_typed[0] == 0) - return 1; + return 1; } if (Completed[0] == 0 && User_typed[0]) @@ -1949,44 +1766,42 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) /* Num_matched will _always_ be atleast 1 since the initial * user-typed string is always stored */ if (numtabs == 1 && Num_matched == 2) - snprintf(Completed, sizeof(Completed),"%s", Matches[0]); + snprintf (Completed, sizeof (Completed), "%s", Matches[0]); else if (numtabs > 1 && Num_matched > 2) - /* cycle thru all the matches */ - snprintf(Completed, sizeof(Completed), "%s", - Matches[(numtabs - 2) % Num_matched]); + /* cycle thru all the matches */ + snprintf (Completed, sizeof (Completed), "%s", + Matches[(numtabs - 2) % Num_matched]); strncpy (pt, Completed, buffer + len - pt - spaces); } - else if (!mutt_strncmp (buffer, "exec", 4)) - { + else if (!mutt_strncmp (buffer, "exec", 4)) { struct binding_t *menu = km_get_table (CurrentMenu); if (!menu && CurrentMenu != MENU_PAGER) menu = OpGeneric; - + pt++; /* first TAB. Collect all the matches */ - if (numtabs == 1) - { + if (numtabs == 1) { Num_matched = 0; strfcpy (User_typed, pt, sizeof (User_typed)); memset (Matches, 0, sizeof (Matches)); memset (Completed, 0, sizeof (Completed)); for (num = 0; menu[num].name; num++) - candidate (Completed, User_typed, menu[num].name, sizeof (Completed)); + candidate (Completed, User_typed, menu[num].name, sizeof (Completed)); /* try the generic menu */ - if (Completed[0] == 0 && CurrentMenu != MENU_PAGER) - { - menu = OpGeneric; - for (num = 0; menu[num].name; num++) - candidate (Completed, User_typed, menu[num].name, sizeof (Completed)); + if (Completed[0] == 0 && CurrentMenu != MENU_PAGER) { + menu = OpGeneric; + for (num = 0; menu[num].name; num++) + candidate (Completed, User_typed, menu[num].name, + sizeof (Completed)); } Matches[Num_matched++] = User_typed; /* All matches are stored. Longest non-ambiguous string is "" * i.e. dont change 'buffer'. Fake successful return this time */ if (User_typed[0] == 0) - return 1; + return 1; } if (Completed[0] == 0 && User_typed[0]) @@ -1995,11 +1810,11 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs) /* Num_matched will _always_ be atleast 1 since the initial * user-typed string is always stored */ if (numtabs == 1 && Num_matched == 2) - snprintf(Completed, sizeof(Completed),"%s", Matches[0]); + snprintf (Completed, sizeof (Completed), "%s", Matches[0]); else if (numtabs > 1 && Num_matched > 2) - /* cycle thru all the matches */ - snprintf(Completed, sizeof(Completed), "%s", - Matches[(numtabs - 2) % Num_matched]); + /* cycle thru all the matches */ + snprintf (Completed, sizeof (Completed), "%s", + Matches[(numtabs - 2) % Num_matched]); strncpy (pt, Completed, buffer + len - pt - spaces); } @@ -2013,7 +1828,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) { char var[STRING], *pt = buffer; int spaces; - + if (buffer[0] == 0) return 0; @@ -2023,88 +1838,87 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) pt = buffer + pos - spaces; while ((pt > buffer) && !isspace ((unsigned char) *pt)) pt--; - pt++; /* move past the space */ - if (*pt == '=') /* abort if no var before the '=' */ + pt++; /* move past the space */ + if (*pt == '=') /* abort if no var before the '=' */ return 0; - if (mutt_strncmp (buffer, "set", 3) == 0) - { + if (mutt_strncmp (buffer, "set", 3) == 0) { int idx; + strfcpy (var, pt, sizeof (var)); /* ignore the trailing '=' when comparing */ var[mutt_strlen (var) - 1] = 0; - if ((idx = mutt_option_index (var)) == -1) - return 0; /* no such variable. */ - else - { - char tmp [LONG_STRING], tmp2[LONG_STRING]; + if ((idx = mutt_option_index (var)) == -1) + return 0; /* no such variable. */ + else { + char tmp[LONG_STRING], tmp2[LONG_STRING]; char *s, *d; size_t dlen = buffer + len - pt - spaces; char *vals[] = { "no", "yes", "ask-no", "ask-yes" }; tmp[0] = '\0'; - if ((DTYPE(MuttVars[idx].type) == DT_STR) || - (DTYPE(MuttVars[idx].type) == DT_PATH) || - (DTYPE(MuttVars[idx].type) == DT_RX)) - { - strfcpy (tmp, NONULL (*((char **) MuttVars[idx].data)), sizeof (tmp)); - if (DTYPE (MuttVars[idx].type) == DT_PATH) - mutt_pretty_mailbox (tmp); + if ((DTYPE (MuttVars[idx].type) == DT_STR) || + (DTYPE (MuttVars[idx].type) == DT_PATH) || + (DTYPE (MuttVars[idx].type) == DT_RX)) { + strfcpy (tmp, NONULL (*((char **) MuttVars[idx].data)), sizeof (tmp)); + if (DTYPE (MuttVars[idx].type) == DT_PATH) + mutt_pretty_mailbox (tmp); } - else if (DTYPE (MuttVars[idx].type) == DT_ADDR) - { - rfc822_write_address (tmp, sizeof (tmp), *((ADDRESS **) MuttVars[idx].data), 0); + else if (DTYPE (MuttVars[idx].type) == DT_ADDR) { + rfc822_write_address (tmp, sizeof (tmp), + *((ADDRESS **) MuttVars[idx].data), 0); } else if (DTYPE (MuttVars[idx].type) == DT_QUAD) - strfcpy (tmp, vals[quadoption (MuttVars[idx].data)], sizeof (tmp)); + strfcpy (tmp, vals[quadoption (MuttVars[idx].data)], sizeof (tmp)); else if (DTYPE (MuttVars[idx].type) == DT_NUM) - snprintf (tmp, sizeof (tmp), "%d", (*((short *) MuttVars[idx].data))); - else if (DTYPE (MuttVars[idx].type) == DT_SORT) - { - const struct mapping_t *map; - char *p; - - switch (MuttVars[idx].type & DT_SUBTYPE_MASK) - { - case DT_SORT_ALIAS: - map = SortAliasMethods; - break; - case DT_SORT_BROWSER: - map = SortBrowserMethods; - break; - case DT_SORT_KEYS: - if ((WithCrypto & APPLICATION_PGP)) - map = SortKeyMethods; - else - map = SortMethods; - break; - default: - map = SortMethods; - break; - } - p = mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, map); - snprintf (tmp, sizeof (tmp), "%s%s%s", - (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? "reverse-" : "", - (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : "", - p); + snprintf (tmp, sizeof (tmp), "%d", (*((short *) MuttVars[idx].data))); + else if (DTYPE (MuttVars[idx].type) == DT_SORT) { + const struct mapping_t *map; + char *p; + + switch (MuttVars[idx].type & DT_SUBTYPE_MASK) { + case DT_SORT_ALIAS: + map = SortAliasMethods; + break; + case DT_SORT_BROWSER: + map = SortBrowserMethods; + break; + case DT_SORT_KEYS: + if ((WithCrypto & APPLICATION_PGP)) + map = SortKeyMethods; + else + map = SortMethods; + break; + default: + map = SortMethods; + break; + } + p = + mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK, + map); + snprintf (tmp, sizeof (tmp), "%s%s%s", + (*((short *) MuttVars[idx].data) & SORT_REVERSE) ? + "reverse-" : "", + (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" : + "", p); } else if (DTYPE (MuttVars[idx].type) == DT_BOOL) - strfcpy (tmp, option (MuttVars[idx].data) ? "yes" : "no", sizeof (tmp)); + strfcpy (tmp, option (MuttVars[idx].data) ? "yes" : "no", + sizeof (tmp)); else - return 0; - - for (s = tmp, d = tmp2; *s && (d - tmp2) < sizeof (tmp2) - 2;) - { - if (*s == '\\' || *s == '"') - *d++ = '\\'; - *d++ = *s++; + return 0; + + for (s = tmp, d = tmp2; *s && (d - tmp2) < sizeof (tmp2) - 2;) { + if (*s == '\\' || *s == '"') + *d++ = '\\'; + *d++ = *s++; } *d = '\0'; - + strfcpy (tmp, pt, sizeof (tmp)); snprintf (pt, dlen, "%s\"%s\"", tmp, tmp2); - + return 1; } } @@ -2112,33 +1926,31 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos) } /* Implement the -Q command line flag */ -int mutt_query_variables (LIST *queries) +int mutt_query_variables (LIST * queries) { LIST *p; - + char errbuff[STRING]; char command[STRING]; - + BUFFER err, token; - + memset (&err, 0, sizeof (err)); memset (&token, 0, sizeof (token)); - + err.data = errbuff; err.dsize = sizeof (errbuff); - - for (p = queries; p; p = p->next) - { + + for (p = queries; p; p = p->next) { snprintf (command, sizeof (command), "set ?%s\n", p->data); - if (mutt_parse_rc_line (command, &token, &err) == -1) - { + if (mutt_parse_rc_line (command, &token, &err) == -1) { fprintf (stderr, "%s\n", err.data); FREE (&token.data); return 1; } printf ("%s\n", err.data); } - + FREE (&token.data); return 0; } @@ -2147,7 +1959,7 @@ char *mutt_getnamebyvalue (int val, const struct mapping_t *map) { int i; - for (i=0; map[i].name; i++) + for (i = 0; map[i].name; i++) if (map[i].value == val) return (map[i].name); return NULL; @@ -2172,23 +1984,23 @@ static void start_debug (void) char buf2[_POSIX_PATH_MAX]; /* rotate the old debug logs */ - for (i=3; i>=0; i--) - { - snprintf (buf, sizeof(buf), "%s/.muttdebug%d", NONULL(Homedir), i); - snprintf (buf2, sizeof(buf2), "%s/.muttdebug%d", NONULL(Homedir), i+1); + for (i = 3; i >= 0; i--) { + snprintf (buf, sizeof (buf), "%s/.muttdebug%d", NONULL (Homedir), i); + snprintf (buf2, sizeof (buf2), "%s/.muttdebug%d", NONULL (Homedir), + i + 1); rename (buf, buf2); } - if ((debugfile = safe_fopen(buf, "w")) != NULL) - { + if ((debugfile = safe_fopen (buf, "w")) != NULL) { t = time (0); - setbuf (debugfile, NULL); /* don't buffer the debugging output! */ - fprintf (debugfile, "Mutt-ng %s started at %s.\nDebugging at level %d.\n\n", - MUTT_VERSION, asctime (localtime (&t)), debuglevel); + setbuf (debugfile, NULL); /* don't buffer the debugging output! */ + fprintf (debugfile, + "Mutt-ng %s started at %s.\nDebugging at level %d.\n\n", + MUTT_VERSION, asctime (localtime (&t)), debuglevel); } } #endif -static int mutt_execute_commands (LIST *p) +static int mutt_execute_commands (LIST * p) { BUFFER err, token; char errstr[SHORT_STRING]; @@ -2197,10 +2009,8 @@ static int mutt_execute_commands (LIST *p) err.data = errstr; err.dsize = sizeof (errstr); memset (&token, 0, sizeof (token)); - for (; p; p = p->next) - { - if (mutt_parse_rc_line (p->data, &token, &err) != 0) - { + for (; p; p = p->next) { + if (mutt_parse_rc_line (p->data, &token, &err) != 0) { fprintf (stderr, _("Error in command line: %s\n"), err.data); FREE (&token.data); return (-1); @@ -2210,7 +2020,7 @@ static int mutt_execute_commands (LIST *p) return 0; } -void mutt_init (int skip_sys_rc, LIST *commands) +void mutt_init (int skip_sys_rc, LIST * commands) { struct passwd *pw; struct utsname utsname; @@ -2226,16 +2036,15 @@ void mutt_init (int skip_sys_rc, LIST *commands) * XXX - use something even more difficult to predict? */ snprintf (AttachmentMarker, sizeof (AttachmentMarker), - "\033]9;%ld\a", (long) time (NULL)); - + "\033]9;%ld\a", (long) time (NULL)); + /* on one of the systems I use, getcwd() does not return the same prefix as is listed in the passwd file */ if ((p = getenv ("HOME"))) Homedir = safe_strdup (p); /* Get some information about the user */ - if ((pw = getpwuid (getuid ()))) - { + if ((pw = getpwuid (getuid ()))) { char rnbuf[STRING]; Username = safe_strdup (pw->pw_name); @@ -2245,18 +2054,15 @@ void mutt_init (int skip_sys_rc, LIST *commands) Realname = safe_strdup (mutt_gecos_name (rnbuf, sizeof (rnbuf), pw)); Shell = safe_strdup (pw->pw_shell); } - else - { - if (!Homedir) - { + else { + if (!Homedir) { mutt_endwin (NULL); fputs (_("unable to determine home directory"), stderr); exit (1); } if ((p = getenv ("USER"))) Username = safe_strdup (p); - else - { + else { mutt_endwin (NULL); fputs (_("unable to determine username"), stderr); exit (1); @@ -2273,11 +2079,10 @@ void mutt_init (int skip_sys_rc, LIST *commands) /* And about the host... */ uname (&utsname); /* some systems report the FQDN instead of just the hostname */ - if ((p = strchr (utsname.nodename, '.'))) - { + if ((p = strchr (utsname.nodename, '.'))) { Hostname = mutt_substrdup (utsname.nodename, p); p++; - strfcpy (buffer, p, sizeof (buffer)); /* save the domain for below */ + strfcpy (buffer, p, sizeof (buffer)); /* save the domain for below */ } else Hostname = safe_strdup (utsname.nodename); @@ -2288,27 +2093,27 @@ void mutt_init (int skip_sys_rc, LIST *commands) Fqdn = safe_strdup ("@"); else #endif /* DOMAIN */ - if (*DOMAIN != '@') - { + if (*DOMAIN != '@') { Fqdn = safe_malloc (mutt_strlen (DOMAIN) + mutt_strlen (Hostname) + 2); - sprintf (Fqdn, "%s.%s", NONULL(Hostname), DOMAIN); /* __SPRINTF_CHECKED__ */ + sprintf (Fqdn, "%s.%s", NONULL (Hostname), DOMAIN); /* __SPRINTF_CHECKED__ */ } else - Fqdn = safe_strdup(NONULL(Hostname)); + Fqdn = safe_strdup (NONULL (Hostname)); #ifdef USE_NNTP { FILE *f; char *i; - if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) - { + if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) { buffer[0] = '\0'; fgets (buffer, sizeof (buffer), f); - p = &buffer; + p = (char*) &buffer; SKIPWS (p); i = p; - while (*i && (*i != ' ') && (*i != '\t') && (*i != '\r') && (*i != '\n')) i++; + while (*i && (*i != ' ') && (*i != '\t') && (*i != '\r') + && (*i != '\n')) + i++; *i = '\0'; NewsServer = safe_strdup (p); fclose (f); @@ -2322,29 +2127,28 @@ void mutt_init (int skip_sys_rc, LIST *commands) Spoolfile = safe_strdup (p); else if ((p = getenv ("MAILDIR"))) Spoolfile = safe_strdup (p); - else - { + else { #ifdef HOMESPOOL mutt_concat_path (buffer, NONULL (Homedir), MAILPATH, sizeof (buffer)); #else - mutt_concat_path (buffer, MAILPATH, NONULL(Username), sizeof (buffer)); + mutt_concat_path (buffer, MAILPATH, NONULL (Username), sizeof (buffer)); #endif Spoolfile = safe_strdup (buffer); } if ((p = getenv ("MAILCAPS"))) MailcapPath = safe_strdup (p); - else - { + else { /* Default search path from RFC1524 */ - MailcapPath = safe_strdup ("~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR "/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap"); + MailcapPath = + safe_strdup ("~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR + "/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap"); } Tempdir = safe_strdup ((p = getenv ("TMPDIR")) ? p : "/tmp"); p = getenv ("VISUAL"); - if (!p) - { + if (!p) { p = getenv ("EDITOR"); if (!p) p = "vi"; @@ -2352,8 +2156,7 @@ void mutt_init (int skip_sys_rc, LIST *commands) Editor = safe_strdup (p); Visual = safe_strdup (p); - if ((p = getenv ("REPLYTO")) != NULL) - { + if ((p = getenv ("REPLYTO")) != NULL) { BUFFER buf, token; snprintf (buffer, sizeof (buffer), "Reply-To: %s", p); @@ -2369,14 +2172,13 @@ void mutt_init (int skip_sys_rc, LIST *commands) if ((p = getenv ("EMAIL")) != NULL) From = rfc822_parse_adrlist (NULL, p); - + mutt_set_langinfo_charset (); mutt_set_charset (Charset); - - + + /* Set standard defaults */ - for (i = 0; MuttVars[i].option; i++) - { + for (i = 0; MuttVars[i].option; i++) { mutt_set_default (&MuttVars[i]); mutt_restore_default (&MuttVars[i]); } @@ -2394,87 +2196,84 @@ void mutt_init (int skip_sys_rc, LIST *commands) #ifdef HAVE_GETSID /* Unset suspend by default if we're the session leader */ - if (getsid(0) == getpid()) + if (getsid (0) == getpid ()) unset_option (OPTSUSPEND); #endif mutt_init_history (); - - - + + + /* * - * BIG FAT WARNING + * BIG FAT WARNING * * When changing the code which looks for a configuration file, * please also change the corresponding code in muttbug.sh.in. * * */ - - - - - if (!Muttrc) - { - snprintf (buffer, sizeof(buffer), "%s/.muttngrc-%s", NONULL(Homedir), MUTT_VERSION); - if (access(buffer, F_OK) == -1) - snprintf (buffer, sizeof(buffer), "%s/.muttngrc", NONULL(Homedir)); - if (access(buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc-%s", NONULL(Homedir), MUTT_VERSION); - if (access(buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc", NONULL(Homedir)); - + + + + + if (!Muttrc) { + snprintf (buffer, sizeof (buffer), "%s/.muttngrc-%s", NONULL (Homedir), + MUTT_VERSION); + if (access (buffer, F_OK) == -1) + snprintf (buffer, sizeof (buffer), "%s/.muttngrc", NONULL (Homedir)); + if (access (buffer, F_OK) == -1) + snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc-%s", + NONULL (Homedir), MUTT_VERSION); + if (access (buffer, F_OK) == -1) + snprintf (buffer, sizeof (buffer), "%s/.muttng/muttngrc", + NONULL (Homedir)); + default_rc = 1; Muttrc = safe_strdup (buffer); } - else - { + else { strfcpy (buffer, Muttrc, sizeof (buffer)); FREE (&Muttrc); mutt_expand_path (buffer, sizeof (buffer)); Muttrc = safe_strdup (buffer); } FREE (&AliasFile); - AliasFile = safe_strdup (NONULL(Muttrc)); + AliasFile = safe_strdup (NONULL (Muttrc)); /* Process the global rc file if it exists and the user hasn't explicity requested not to via "-n". */ - if (!skip_sys_rc) - { - snprintf (buffer, sizeof(buffer), "%s/Muttngrc-%s", SYSCONFDIR, MUTT_VERSION); + if (!skip_sys_rc) { + snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", SYSCONFDIR, + MUTT_VERSION); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof(buffer), "%s/Muttngrc", SYSCONFDIR); + snprintf (buffer, sizeof (buffer), "%s/Muttngrc", SYSCONFDIR); if (access (buffer, F_OK) == -1) - snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", PKGDATADIR, MUTT_VERSION); + snprintf (buffer, sizeof (buffer), "%s/Muttngrc-%s", PKGDATADIR, + MUTT_VERSION); if (access (buffer, F_OK) == -1) snprintf (buffer, sizeof (buffer), "%s/Muttngrc", PKGDATADIR); - if (access (buffer, F_OK) != -1) - { - if (source_rc (buffer, &err) != 0) - { - fputs (err.data, stderr); - fputc ('\n', stderr); - need_pause = 1; + if (access (buffer, F_OK) != -1) { + if (source_rc (buffer, &err) != 0) { + fputs (err.data, stderr); + fputc ('\n', stderr); + need_pause = 1; } } } /* Read the user's initialization file. */ - if (access (Muttrc, F_OK) != -1) - { + if (access (Muttrc, F_OK) != -1) { if (!option (OPTNOCURSES)) endwin (); - if (source_rc (Muttrc, &err) != 0) - { + if (source_rc (Muttrc, &err) != 0) { fputs (err.data, stderr); fputc ('\n', stderr); need_pause = 1; } } - else if (!default_rc) - { + else if (!default_rc) { /* file specified by -F does not exist */ snprintf (buffer, sizeof (buffer), "%s: %s", Muttrc, strerror (errno)); mutt_endwin (buffer); @@ -2484,14 +2283,13 @@ void mutt_init (int skip_sys_rc, LIST *commands) if (mutt_execute_commands (commands) != 0) need_pause = 1; - if (need_pause && !option (OPTNOCURSES)) - { + if (need_pause && !option (OPTNOCURSES)) { if (mutt_any_key_to_continue (NULL) == -1) - mutt_exit(1); + mutt_exit (1); } #if 0 - set_option (OPTWEED); /* turn weeding on by default */ + set_option (OPTWEED); /* turn weeding on by default */ #endif } @@ -2499,7 +2297,7 @@ int mutt_get_hook_type (const char *name) { struct command_t *c; - for (c = Commands ; c->name ; c++) + for (c = Commands; c->name; c++) if (c->func == mutt_parse_hook && ascii_strcasecmp (c->name, name) == 0) return c->data; return 0;