{
alias_table[menu->current]->del = (op == OP_DELETE);
menu->redraw |= REDRAW_CURRENT;
- if (C_Resolve && menu->current < menu->max - 1)
+ if (C_Resolve && (menu->current < menu->max - 1))
{
menu->current++;
menu->redraw |= REDRAW_INDEX;
retry_name:
/* L10N: prompt to add a new alias */
- if (mutt_get_field(_("Alias as: "), buf, sizeof(buf), 0) != 0 || !buf[0])
+ if ((mutt_get_field(_("Alias as: "), buf, sizeof(buf), 0) != 0) || !buf[0])
return;
/* check to see if the user already has an alias defined */
do
{
- if (mutt_get_field(_("Address: "), buf, sizeof(buf), 0) != 0 || !buf[0])
+ if ((mutt_get_field(_("Address: "), buf, sizeof(buf), 0) != 0) || !buf[0])
{
mutt_alias_free(&new);
return;
{
TAILQ_FOREACH(a, &Aliases, entries)
{
- if (a->name && strncmp(a->name, buf, strlen(buf)) == 0)
+ if (a->name && (strncmp(a->name, buf, strlen(buf)) == 0))
{
if (!bestname[0]) /* init */
{
/* build alias list and show it */
TAILQ_FOREACH(a, &Aliases, entries)
{
- if (a->name && strncmp(a->name, buf, strlen(buf)) == 0)
+ if (a->name && (strncmp(a->name, buf, strlen(buf)) == 0))
{
tmp = mutt_mem_calloc(1, sizeof(struct Alias));
memcpy(tmp, a, sizeof(struct Alias));
mutt_debug(LL_DEBUG3, "rc: %d, path: '%s'\n", len, dst);
- if (len < 0 || (size_t) len >= dstlen - 1)
+ if ((len < 0) || ((size_t) len >= dstlen - 1))
return -1;
mutt_debug(LL_DEBUG3, "directory: '%s'\n", dst);
mutt_debug(LL_DEBUG3, "bcache: list: dir: '%s', id :'%s'\n", bcache->path, de->d_name);
- if (want_id && want_id(de->d_name, bcache, data) != 0)
+ if (want_id && (want_id(de->d_name, bcache, data) != 0))
goto out;
rc++;
snprintf(tmp, sizeof(tmp), _("Subscribe pattern: "));
else
snprintf(tmp, sizeof(tmp), _("Unsubscribe pattern: "));
- if (mutt_get_field(tmp, buf, sizeof(buf), 0) != 0 || (buf[0] == '\0'))
+ if ((mutt_get_field(tmp, buf, sizeof(buf), 0) != 0) || (buf[0] == '\0'))
{
break;
}
/* check to see if this color is already allocated to save space */
while (p)
{
- if (p->fg == fg && p->bg == bg)
+ if ((p->fg == fg) && (p->bg == bg))
{
(p->count)++;
return COLOR_PAIR(p->index);
p->fg = fg;
#ifdef USE_SLANG_CURSES
- if (fg == COLOR_DEFAULT || bg == COLOR_DEFAULT)
+ if ((fg == COLOR_DEFAULT) || (bg == COLOR_DEFAULT))
{
char fgc[128], bgc[128];
SLtt_set_color(i, NULL, get_color_name(fgc, sizeof(fgc), fg),
struct ColorList *p = ColorList;
while (p)
{
- if (p->fg == fg && p->bg == bg)
+ if ((p->fg == fg) && (p->bg == bg))
{
(p->count)--;
if (p->count > 0)
if (tmp)
{
#ifdef HAVE_COLOR
- if (fg != -1 && bg != -1)
+ if ((fg != -1) && (bg != -1))
{
- if (tmp->fg != fg || tmp->bg != bg)
+ if ((tmp->fg != fg) || (tmp->bg != bg))
{
mutt_free_color(tmp->fg, tmp->bg);
tmp->fg = fg;
tmp->pattern = mutt_str_strdup(s);
tmp->match = match;
#ifdef HAVE_COLOR
- if (fg != -1 && bg != -1)
+ if ((fg != -1) && (bg != -1))
{
tmp->fg = fg;
tmp->bg = bg;
{
char *eptr = NULL;
*ql = strtol(buf->data + 6, &eptr, 10);
- if (*eptr || *ql < 0)
+ if (*eptr || (*ql < 0))
{
mutt_buffer_printf(err, _("%s: no such object"), buf->data);
return -1;
static int fgbgattr_to_color(int fg, int bg, int attr)
{
#ifdef HAVE_COLOR
- if (fg != -1 && bg != -1)
+ if ((fg != -1) && (bg != -1))
return attr | mutt_alloc_color(fg, bg);
else
#endif
if (!OptNoCurses &&
has_colors()
/* delay use_default_colors() until needed, since it initializes things */
- && (fg == COLOR_DEFAULT || bg == COLOR_DEFAULT || object == MT_COLOR_TREE) &&
- use_default_colors() != OK)
+ && ((fg == COLOR_DEFAULT) || (bg == COLOR_DEFAULT) || (object == MT_COLOR_TREE)) &&
+ (use_default_colors() != OK))
/* the case of the tree object is special, because a non-default
* fg color of the tree element may be combined dynamically with
* the default bg color of an index line, not necessarily defined in
#endif
res = mutt_copy_message_ctx(fp_out, Context->mailbox, cur, cmflags, chflags);
- if ((mutt_file_fclose(&fp_out) != 0 && errno != EPIPE) || res < 0)
+ if (((mutt_file_fclose(&fp_out) != 0) && (errno != EPIPE)) || (res < 0))
{
mutt_error(_("Could not copy message"));
if (fp_filter_out)
return 0;
}
- if (fp_filter_out && mutt_wait_filter(filterpid) != 0)
+ if (fp_filter_out && (mutt_wait_filter(filterpid) != 0))
mutt_any_key_to_continue(NULL);
mutt_file_fclose(&fp_filter_out); /* XXX - check result? */
keypad(stdscr, true);
if (r != -1)
mutt_set_flag(Context->mailbox, cur, MUTT_READ, true);
- if (r != -1 && C_PromptAfter)
+ if ((r != -1) && C_PromptAfter)
{
mutt_unget_event(mutt_any_key_to_continue(_("Command: ")), 0);
rc = km_dokey(MENU_PAGER);
char buf[1024] = { 0 };
/* if enter is pressed after : with no command, just return */
- if (mutt_get_field(":", buf, sizeof(buf), MUTT_COMMAND) != 0 || !buf[0])
+ if ((mutt_get_field(":", buf, sizeof(buf), MUTT_COMMAND) != 0) || !buf[0])
return;
struct Buffer *err = mutt_buffer_alloc(256);
#ifdef USE_IMAP
/* we can use '/' as a delimiter, imap_complete rewrites it */
- if (*buf == '=' || *buf == '+' || *buf == '!')
+ if ((*buf == '=') || (*buf == '+') || (*buf == '!'))
{
if (*buf == '!')
p = NONULL(C_Spoolfile);
return imap_complete(buf, buflen, imap_path);
#endif
- if (*buf == '=' || *buf == '+' || *buf == '!')
+ if ((*buf == '=') || (*buf == '+') || (*buf == '!'))
{
dirpart[0] = *buf;
dirpart[1] = '\0';
else
tmp[0] = 0;
mutt_str_strfcpy(tmp + strlen(tmp), filepart, sizeof(tmp) - strlen(tmp));
- if (stat(tmp, &st) != -1 && (st.st_mode & S_IFDIR))
+ if ((stat(tmp, &st) != -1) && (st.st_mode & S_IFDIR))
{
mutt_str_strfcpy(filepart + strlen(filepart), "/",
sizeof(filepart) - strlen(filepart));
if (dirpart[0])
{
mutt_str_strfcpy(buf, dirpart, buflen);
- if ((mutt_str_strcmp("/", dirpart) != 0) && dirpart[0] != '=' && dirpart[0] != '+')
+ if ((mutt_str_strcmp("/", dirpart) != 0) && (dirpart[0] != '=') && (dirpart[0] != '+'))
mutt_str_strfcpy(buf + strlen(buf), "/", buflen - strlen(buf));
mutt_str_strfcpy(buf + strlen(buf), filepart, buflen - strlen(buf));
}
HeaderPadding[idx] = mutt_str_strlen(header);
width = mutt_strwidth(header);
- if (calc_max && MaxHeaderWidth < width)
+ if (calc_max && (MaxHeaderWidth < width))
MaxHeaderWidth = width;
HeaderPadding[idx] -= width;
}
STAILQ_FOREACH(np, chain, entries)
{
t = np->data;
- if (t && t[0] == '0' && t[1] == '\0')
+ if (t && (t[0] == '0') && (t[1] == '\0'))
t = "<random>";
if (c + mutt_str_strlen(t) + 2 >= MuttIndexWindow->cols)
struct AttachPtr **idx = actx->idx;
int rindex = actx->v2r[x];
- if (rindex == 0 && actx->idxlen == 1)
+ if ((rindex == 0) && (actx->idxlen == 1))
{
mutt_error(_("You may not delete the only attachment"));
idx[rindex]->content->tagged = false;
{
for (; m; m = m->next)
{
- if (m->type == TYPE_MULTIPART && m->parts &&
+ if ((m->type == TYPE_MULTIPART) && m->parts &&
(!(WithCrypto & APPLICATION_PGP) || !mutt_is_multipart_encrypted(m)))
{
mutt_gen_compose_attach_list(actx, m->parts, m->type, level);
case OP_COMPOSE_EDIT_HEADERS:
if ((mutt_str_strcmp("builtin", C_Editor) != 0) &&
- (op == OP_COMPOSE_EDIT_HEADERS || (op == OP_COMPOSE_EDIT_MESSAGE && C_EditHeaders)))
+ ((op == OP_COMPOSE_EDIT_HEADERS) || ((op == OP_COMPOSE_EDIT_MESSAGE) && C_EditHeaders)))
{
const char *tag = NULL;
char *err = NULL;
case OP_COMPOSE_EDIT_ENCODING:
CHECK_COUNT;
mutt_str_strfcpy(buf, ENCODING(CURATTACH->content->encoding), sizeof(buf));
- if (mutt_get_field("Content-Transfer-Encoding: ", buf, sizeof(buf), 0) == 0 &&
+ if ((mutt_get_field("Content-Transfer-Encoding: ", buf, sizeof(buf), 0) == 0) &&
(buf[0] != '\0'))
{
int enc = mutt_check_encoding(buf);
}
#ifdef MIXMASTER
- if (!STAILQ_EMPTY(&msg->chain) && mix_check_message(msg) != 0)
+ if (!STAILQ_EMPTY(&msg->chain) && (mix_check_message(msg) != 0))
break;
#endif
{
mutt_window_clearline(MuttMessageWindow, 0);
buf[0] = '\0';
- if (mutt_get_field(_("New file: "), buf, sizeof(buf), MUTT_FILE) != 0 ||
+ if ((mutt_get_field(_("New file: "), buf, sizeof(buf), MUTT_FILE) != 0) ||
(buf[0] == '\0'))
{
continue;
/* Call to lookup_mime_type () ? maybe later */
char type[256] = { 0 };
- if (mutt_get_field("Content-Type: ", type, sizeof(type), 0) != 0 || !type[0])
+ if ((mutt_get_field("Content-Type: ", type, sizeof(type), 0) != 0) || !type[0])
continue;
char *p = strchr(type, '/');
memset(&mbstate, 0, sizeof(mbstate));
while (slen && (k = mbrtowc(NULL, s, slen, &mbstate)))
{
- if (k == (size_t)(-1) || k == (size_t)(-2))
+ if ((k == (size_t)(-1)) || (k == (size_t)(-2)))
{
/* XXX put message in err buffer; fail? warning? */
mutt_debug(LL_DEBUG1, "mbtable_parse: mbrtowc returned %d converting %s in %s\n",
const int rc = select(conn->fd + 1, &rfds, NULL, NULL, &tv);
gettimeofday(&post_t, NULL);
- if (rc > 0 || (rc < 0 && errno != EINTR))
+ if ((rc > 0) || ((rc < 0) && (errno != EINTR)))
return rc;
if (SigInt)
}
/* strip \r from \r\n termination */
- if (i && buf[i - 1] == '\r')
+ if (i && (buf[i - 1] == '\r'))
i--;
buf[i] = '\0';
mutt_message(_("Filling entropy pool: %s..."), file);
/* check that the file permissions are secure */
- if (st.st_uid != getuid() || ((st.st_mode & (S_IWGRP | S_IRGRP)) != 0) ||
+ if ((st.st_uid != getuid()) || ((st.st_mode & (S_IWGRP | S_IRGRP)) != 0) ||
((st.st_mode & (S_IWOTH | S_IROTH)) != 0))
{
mutt_error(_("%s has insecure permissions"), file);
{
static char data[128];
- if (!name || X509_NAME_get_text_by_NID(name, nid, data, sizeof(data)) < 0)
+ if (!name || (X509_NAME_get_text_by_NID(name, nid, data, sizeof(data)) < 0))
mutt_str_strfcpy(data, _("Unknown"), sizeof(data));
return data;
/* Avoid CPU-intensive digest calculation if the certificates are
* not even remotely equal.
*/
- if (X509_subject_name_cmp(cert, peercert) != 0 || X509_issuer_name_cmp(cert, peercert) != 0)
+ if ((X509_subject_name_cmp(cert, peercert) != 0) ||
+ (X509_issuer_name_cmp(cert, peercert) != 0))
return false;
- if (!X509_digest(cert, EVP_sha256(), md, &mdlen) || peermdlen != mdlen)
+ if (!X509_digest(cert, EVP_sha256(), md, &mdlen) || (peermdlen != mdlen))
return false;
if (memcmp(peermd, md, mdlen) != 0)
cmp2 = hostname;
}
- if (*cmp1 == '\0' || *cmp2 == '\0')
+ if ((*cmp1 == '\0') || (*cmp2 == '\0'))
{
return false;
}
subj_alt_name = sk_GENERAL_NAME_value(subj_alt_names, i);
if (subj_alt_name->type == GEN_DNS)
{
- if (subj_alt_name->d.ia5->length >= 0 &&
- mutt_str_strlen((char *) subj_alt_name->d.ia5->data) ==
- (size_t) subj_alt_name->d.ia5->length &&
+ if ((subj_alt_name->d.ia5->length >= 0) &&
+ (mutt_str_strlen((char *) subj_alt_name->d.ia5->data) ==
+ (size_t) subj_alt_name->d.ia5->length) &&
(match_found = hostname_match(hostname_ascii,
(char *) (subj_alt_name->d.ia5->data))))
{
/* check hostname only for the leaf certificate */
buf[0] = 0;
- if (pos == 0 && C_SslVerifyHost != MUTT_NO)
+ if ((pos == 0) && (C_SslVerifyHost != MUTT_NO))
{
if (check_host(cert, host, buf, sizeof(buf)) == 0)
{
int rc;
rc = SSL_read(data->ssl, buf, count);
- if (rc <= 0 || errno == EINTR)
+ if ((rc <= 0) || (errno == EINTR))
{
if (errno == EINTR)
{
int rc;
rc = SSL_write(data->ssl, buf, count);
- if (rc <= 0 || errno == EINTR)
+ if ((rc <= 0) || (errno == EINTR))
{
if (errno == EINTR)
{
if (data)
{
- if (data->isopen && raw_socket_poll(conn, 0) >= 0)
+ if (data->isopen && (raw_socket_poll(conn, 0) >= 0))
SSL_shutdown(data->ssl);
/* hold onto this for the life of neomutt, in case we want to reconnect.
tls_fingerprint(GNUTLS_DIG_MD5, buf, sizeof(buf), cert);
while ((linestr = mutt_file_read_line(linestr, &linestrsize, fp, &linenum, 0)))
{
- if (linestr[0] == '#' && linestr[1] == 'H')
+ if ((linestr[0] == '#') && (linestr[1] == 'H'))
{
if (regexec(&preg, linestr, 3, pmatch, 0) == 0)
{
*certerr |= CERTERR_NOTYETVALID;
}
- if (chainidx == 0 && C_SslVerifyHost != MUTT_NO &&
+ if ((chainidx == 0) && (C_SslVerifyHost != MUTT_NO) &&
!gnutls_x509_crt_check_hostname(cert, hostname) &&
!tls_check_stored_hostname(certdata, hostname))
{
{
mutt_sig_unblock_system(false);
const int devnull = open("/dev/null", O_RDWR);
- if (devnull < 0 || dup2(pout[0], STDIN_FILENO) < 0 ||
- dup2(pin[1], STDOUT_FILENO) < 0 || dup2(devnull, STDERR_FILENO) < 0)
+ if ((devnull < 0) || (dup2(pout[0], STDIN_FILENO) < 0) ||
+ (dup2(pin[1], STDOUT_FILENO) < 0) || (dup2(devnull, STDERR_FILENO) < 0))
{
_exit(127);
}
FREE(&conn->sockdata);
return -1;
}
- if (close(pin[1]) < 0 || close(pout[0]) < 0)
+ if ((close(pin[1]) < 0) || (close(pout[0]) < 0))
mutt_perror("close");
fcntl(pin[0], F_SETFD, FD_CLOEXEC);
for (i = 0, j = 0; i < m->msg_count; i++)
{
if (!m->emails[i]->quasi_deleted &&
- ((committing && (!m->emails[i]->deleted || (m->magic == MUTT_MAILDIR && C_MaildirTrash))) ||
+ ((committing && (!m->emails[i]->deleted || ((m->magic == MUTT_MAILDIR) && C_MaildirTrash))) ||
(!committing && m->emails[i]->active)))
{
if (i != j)
else if (m->emails[j]->changed)
m->changed = true;
- if (!committing || (m->magic == MUTT_MAILDIR && C_MaildirTrash))
+ if (!committing || ((m->magic == MUTT_MAILDIR) && C_MaildirTrash))
{
if (m->emails[j]->deleted)
m->msg_deleted++;
}
else
{
- if (m->magic == MUTT_MH || m->magic == MUTT_MAILDIR || m->magic == MUTT_IMAP)
+ if ((m->magic == MUTT_MH) || (m->magic == MUTT_MAILDIR) || (m->magic == MUTT_IMAP))
{
m->size -= (m->emails[i]->content->length + m->emails[i]->content->offset -
m->emails[i]->content->hdr_offset);
break;
/* Is it the beginning of a header? */
- if (nl && buf[0] != ' ' && buf[0] != '\t')
+ if (nl && (buf[0] != ' ') && (buf[0] != '\t'))
{
ignore = true;
if (!from && mutt_str_startswith(buf, "From ", CASE_MATCH))
else if ((chflags & CH_NOQFROM) && mutt_str_startswith(buf, ">From ", CASE_IGNORE))
continue;
- else if (buf[0] == '\n' || (buf[0] == '\r' && buf[1] == '\n'))
+ else if ((buf[0] == '\n') || ((buf[0] == '\r') && (buf[1] == '\n')))
break; /* end of header */
if ((chflags & (CH_UPDATE | CH_XMIT | CH_NOSTATUS)) &&
ignore = false;
}
- if (!ignore && fputs(buf, fp_out) == EOF)
+ if (!ignore && (fputs(buf, fp_out) == EOF))
return -1;
}
return 0;
break;
/* Is it the beginning of a header? */
- if (nl && buf[0] != ' ' && buf[0] != '\t')
+ if (nl && (buf[0] != ' ') && (buf[0] != '\t'))
{
/* Do we have anything pending? */
if (this_one)
this_is_from = true;
from = true;
}
- else if (buf[0] == '\n' || (buf[0] == '\r' && buf[1] == '\n'))
+ else if ((buf[0] == '\n') || ((buf[0] == '\r') && (buf[1] == '\n')))
break; /* end of header */
/* note: CH_FROM takes precedence over header weeding. */
fputc('\n', fp_out);
}
- if ((chflags & CH_UPDATE) && (chflags & CH_NOSTATUS) == 0)
+ if ((chflags & CH_UPDATE) && ((chflags & CH_NOSTATUS) == 0))
{
if (e->old || e->read)
{
}
}
- if (chflags & CH_UPDATE_LEN && (chflags & CH_NOLEN) == 0)
+ if (chflags & CH_UPDATE_LEN && ((chflags & CH_NOLEN) == 0))
{
fprintf(fp_out, "Content-Length: " OFF_T_FMT "\n", e->content->length);
- if (e->lines != 0 || e->content->length == 0)
+ if ((e->lines != 0) || (e->content->length == 0))
fprintf(fp_out, "Lines: %d\n", e->lines);
}
FILE *fp = NULL;
if (((WithCrypto & APPLICATION_PGP) != 0) && (cmflags & MUTT_CM_DECODE_PGP) &&
- (e->security & APPLICATION_PGP) && e->content->type == TYPE_MULTIPART)
+ (e->security & APPLICATION_PGP) && (e->content->type == TYPE_MULTIPART))
{
if (crypt_pgp_decrypt_mime(fp_in, &fp, e->content, &cur))
return -1;
}
if (((WithCrypto & APPLICATION_SMIME) != 0) && (cmflags & MUTT_CM_DECODE_SMIME) &&
- (e->security & APPLICATION_SMIME) && e->content->type == TYPE_APPLICATION)
+ (e->security & APPLICATION_SMIME) && (e->content->type == TYPE_APPLICATION))
{
if (crypt_smime_decrypt_mime(fp_in, &fp, e->content, &cur))
return -1;
return -1;
}
- if ((cmflags & MUTT_CM_UPDATE) && (cmflags & MUTT_CM_NOHEADER) == 0 && new_offset != -1)
+ if ((cmflags & MUTT_CM_UPDATE) && ((cmflags & MUTT_CM_NOHEADER) == 0) &&
+ (new_offset != -1))
{
body->offset = new_offset;
mutt_body_free(&body->parts);
msg = mx_msg_open_new(dest, e, is_from(buf, NULL, 0, NULL) ? 0 : MUTT_ADD_FROM);
if (!msg)
return -1;
- if (dest->magic == MUTT_MBOX || dest->magic == MUTT_MMDF)
+ if ((dest->magic == MUTT_MBOX) || (dest->magic == MUTT_MMDF))
chflags |= CH_FROM | CH_FORCE_FROM;
chflags |= (dest->magic == MUTT_MAILDIR ? CH_NOSTATUS : CH_UPDATE);
rc = mutt_copy_message_fp(msg->fp, fp_in, e, cmflags, chflags);
rc = -1;
#ifdef USE_NOTMUCH
- if (msg->committed_path && dest->magic == MUTT_MAILDIR && src->magic == MUTT_NOTMUCH)
+ if (msg->committed_path && (dest->magic == MUTT_MAILDIR) && (src->magic == MUTT_NOTMUCH))
nm_update_filename(src, NULL, msg->committed_path, e);
#endif
const size_t l = mutt_addr_write(buf, sizeof(buf), a, false);
a->next = tmp;
- if (count && linelen + l > 74)
+ if (count && (linelen + l > 74))
{
strcpy(cbuf, "\n\t");
linelen = l + 8;
if (ch.ch == -2)
continue;
/* (ch.ch == 0) is technically possible. Treat the same as < 0 (abort) */
- if (ch.ch <= 0 || CI_is_return(ch.ch))
+ if ((ch.ch <= 0) || CI_is_return(ch.ch))
{
choice = -1;
break;
choice = p - letters + 1;
break;
}
- else if (ch.ch <= '9' && ch.ch > '0')
+ else if ((ch.ch <= '9') && (ch.ch > '0'))
{
choice = ch.ch - '0';
if (choice <= mutt_str_strlen(letters))
size_t n1, n2;
memset(&mbstate, 0, sizeof(mbstate));
- if ((n1 = wcrtomb(buf, wc, &mbstate)) == (size_t)(-1) ||
- (n2 = wcrtomb(buf + n1, 0, &mbstate)) == (size_t)(-1))
+ if (((n1 = wcrtomb(buf, wc, &mbstate)) == (size_t)(-1)) ||
+ ((n2 = wcrtomb(buf + n1, 0, &mbstate)) == (size_t)(-1)))
{
return -1; /* ERR */
}
char *p = buf;
for (; n && (k = mbrtowc(&wc, s, n, &mbstate1)); s += k, n -= k)
{
- if (k == (size_t)(-1) || k == (size_t)(-2))
+ if ((k == (size_t)(-1)) || (k == (size_t)(-2)))
{
- if (k == (size_t)(-1) && errno == EILSEQ)
+ if ((k == (size_t)(-1)) && (errno == EILSEQ))
memset(&mbstate1, 0, sizeof(mbstate1));
k = (k == (size_t)(-1)) ? 1 : n;
escaped = 0;
w = 0;
}
- else if (arboreal && wc == MUTT_SPECIAL_INDEX)
+ else if (arboreal && (wc == MUTT_SPECIAL_INDEX))
{
escaped = 1;
w = 0;
}
- else if (arboreal && wc < MUTT_TREE_MAX)
+ else if (arboreal && (wc < MUTT_TREE_MAX))
{
w = 1; /* hack */
}
}
if (w >= 0)
{
- if (w > max_width || (k2 = wcrtomb(scratch, wc, &mbstate2)) > buflen)
+ if ((w > max_width) || ((k2 = wcrtomb(scratch, wc, &mbstate2)) > buflen))
continue;
min_width -= w;
max_width -= w;
memset(&mbstate, 0, sizeof(mbstate));
for (; len && (k = mbrtowc(&wc, s, len, &mbstate)); s += k, len -= k)
{
- if (k == (size_t)(-1) || k == (size_t)(-2))
+ if ((k == (size_t)(-1)) || (k == (size_t)(-2)))
{
if (k == (size_t)(-1))
memset(&mbstate, 0, sizeof(mbstate));
memset(&mbstate, 0, sizeof(mbstate));
for (w = 0; n && (cl = mbrtowc(&wc, src, n, &mbstate)); src += cl, n -= cl)
{
- if (cl == (size_t)(-1) || cl == (size_t)(-2))
+ if ((cl == (size_t)(-1)) || (cl == (size_t)(-2)))
{
if (cl == (size_t)(-1))
memset(&mbstate, 0, sizeof(mbstate));
cl = 2; /* skip the index coloring sequence */
cw = 0;
}
- else if (cw < 0 && cl == 1 && src[0] && src[0] < MUTT_TREE_MAX)
+ else if ((cw < 0) && (cl == 1) && src[0] && (src[0] < MUTT_TREE_MAX))
cw = 1;
else if (cw < 0)
cw = 0; /* unprintable wchar */
- if (cl + l > maxlen || cw + w > maxwid)
+ if ((cl + l > maxlen) || (cw + w > maxwid))
break;
l += cl;
w += cw;
continue;
}
- if (k == (size_t)(-1) || k == (size_t)(-2))
+ if ((k == (size_t)(-1)) || (k == (size_t)(-2)))
{
if (k == (size_t)(-1))
memset(&mbstate, 0, sizeof(mbstate));
mutt_mem_realloc(&buf, sizeof(char *) * (*bufmax += 25));
buf[(*buflen)++] = mutt_str_strdup(tmp);
}
- if (buf && *bufmax == *buflen)
+ if (buf && (*bufmax == *buflen))
{ /* Do not smash memory past buf */
mutt_mem_realloc(&buf, sizeof(char *) * (++*bufmax));
}
}
addch('\n');
- if (C_Escape && tmp[0] == C_Escape[0] && tmp[1] != C_Escape[0])
+ if (C_Escape && (tmp[0] == C_Escape[0]) && (tmp[1] != C_Escape[0]))
{
/* remove trailing whitespace from the line */
p = tmp + mutt_str_strlen(tmp) - 1;
case 'e':
if ((mutt_str_strcasecmp("xpires", line + 1) == 0) && e &&
- mutt_date_parse_date(p, NULL) < time(NULL))
+ (mutt_date_parse_date(p, NULL) < time(NULL)))
{
e->expired = true;
}
/* HACK - neomutt has, for a very short time, produced negative
* Lines header values. Ignore them.
*/
- if (mutt_str_atoi(p, &e->lines) < 0 || (e->lines < 0))
+ if ((mutt_str_atoi(p, &e->lines) < 0) || (e->lines < 0))
e->lines = 0;
}
}
}
p->offset = ftello(fp); /* Mark the start of the real data */
- if (p->type == TYPE_TEXT && !p->subtype)
+ if ((p->type == TYPE_TEXT) && !p->subtype)
p->subtype = mutt_str_strdup("plain");
- else if (p->type == TYPE_MESSAGE && !p->subtype)
+ else if ((p->type == TYPE_MESSAGE) && !p->subtype)
p->subtype = mutt_str_strdup("rfc822");
FREE(&line);
if (last)
{
last->length = ftello(fp) - last->offset - len - 1 - crlf;
- if (last->parts && last->parts->length == 0)
+ if (last->parts && (last->parts->length == 0))
last->parts->length = ftello(fp) - last->parts->offset - len - 1 - crlf;
/* if the body is empty, we can end up with a -1 length */
if (last->length < 0)
ibl = dlen;
ob = buf;
obl = sizeof(buf) - strlen(tocode);
- if (iconv(cd, (ICONV_CONST char **) &ib, &ibl, &ob, &obl) == (size_t)(-1) ||
- iconv(cd, NULL, NULL, &ob, &obl) == (size_t)(-1))
+ if ((iconv(cd, (ICONV_CONST char **) &ib, &ibl, &ob, &obl) == (size_t)(-1)) ||
+ (iconv(cd, NULL, NULL, &ob, &obl) == (size_t)(-1)))
{
assert(errno == E2BIG);
iconv_close(cd);
{
assert(n > 0);
const size_t nn = try_block(d, n, fromcode, tocode, encoder, wlen);
- if ((nn == 0) && ((col + *wlen) <= (ENCWORD_LEN_MAX + 1) || (n <= 1)))
+ if ((nn == 0) && (((col + *wlen) <= (ENCWORD_LEN_MAX + 1)) || (n <= 1)))
break;
n = (nn ? nn : n) - 1;
assert(n > 0);
{
mutt_buffer_addch(&buf, ' ');
}
- else if ((*it == '=') && (!(it[1] & ~127) && hexval(it[1]) != -1) &&
- (!(it[2] & ~127) && hexval(it[2]) != -1))
+ else if ((*it == '=') && (!(it[1] & ~127) && (hexval(it[1]) != -1)) &&
+ (!(it[2] & ~127) && (hexval(it[2]) != -1)))
{
mutt_buffer_addch(&buf, (hexval(it[1]) << 4) | hexval(it[2]));
it += 2;
size_t holelen = beg ? beg - s : mutt_str_strlen(s);
/* Ignore whitespace between encoded words */
- if (beg && mutt_str_lws_len(s, holelen) == holelen)
+ if (beg && (mutt_str_lws_len(s, holelen) == holelen))
{
s = beg;
continue;
struct TagNode *np = NULL;
STAILQ_FOREACH(np, head, entries)
{
- if (filter && mutt_str_strcmp(np->name, filter) != 0)
+ if (filter && (mutt_str_strcmp(np->name, filter) != 0))
continue;
if (show_hidden || !np->hidden)
{
mutt_mem_realloc(&stte->buffer, (stte->buf_len + 1) * sizeof(wchar_t));
}
- if ((!stte->tag_level[RICH_NOFILL] && iswspace(c)) || c == (wchar_t) '\0')
+ if ((!stte->tag_level[RICH_NOFILL] && iswspace(c)) || (c == (wchar_t) '\0'))
{
if (c == (wchar_t) '\t')
stte->word_len += 8 - (stte->line_len + stte->word_len) % 8;
{
if (state != ST_EOF)
{
- if (!bytes || (wc = fgetwc(s->fp_in)) == WEOF)
+ if (!bytes || ((wc = fgetwc(s->fp_in)) == WEOF))
state = ST_EOF;
else
bytes--;
static int my_addwch(wchar_t wc)
{
int n = wcwidth(wc);
- if (IsWPrint(wc) && n > 0)
+ if (IsWPrint(wc) && (n > 0))
return mutt_addwch(wc);
if (!(wc & ~0x7f))
return printw("^%c", ((int) wc + 0x40) & 0x7f);
}
}
- if (wc == '\r' || wc == '\n')
+ if ((wc == '\r') || (wc == '\n'))
{
/* Convert from wide characters */
mutt_mb_wcstombs(buf, buflen, state->wbuf, state->lastchar);
int flagged = m->msg_flagged;
int update = false;
- if (m->readonly && flag != MUTT_TAG)
+ if (m->readonly && (flag != MUTT_TAG))
return; /* don't modify anything if we are read-only */
switch (flag)
* is checked in specific code in the maildir folder
* driver.
*/
- if (m->magic == MUTT_MAILDIR && upd_mbox && e->trash)
+ if ((m->magic == MUTT_MAILDIR) && upd_mbox && e->trash)
m->changed = true;
}
break;
* search results so that any future search will match the current status
* of this message and not what it was at the time it was last searched.
*/
- if (e->searched && (changed != e->changed || deleted != m->msg_deleted ||
- tagged != m->msg_tagged || flagged != m->msg_flagged))
+ if (e->searched && ((changed != e->changed) || (deleted != m->msg_deleted) ||
+ (tagged != m->msg_tagged) || (flagged != m->msg_flagged)))
{
e->searched = false;
}
cur = cur->parent;
start = cur;
- if (cur->message && cur != e->thread)
+ if (cur->message && (cur != e->thread))
mutt_set_flag(Context->mailbox, cur->message, flag, bf);
cur = cur->child;
while (true)
{
- if (cur->message && cur != e->thread)
+ if (cur->message && (cur != e->thread))
mutt_set_flag(Context->mailbox, cur->message, flag, bf);
if (cur->child)
(C_Weed ? (CH_WEED | CH_REORDER) : 0) | CH_DECODE, NULL);
}
}
- else if (expiration && expire < time(NULL))
+ else if (expiration && (expire < time(NULL)))
{
if (s->flags & MUTT_DISPLAY)
{
ch = fgetc(s->fp_in);
if (ch == EOF)
break;
- if ((ch >= 0) && (ch < 128) && (base64val(ch) != -1 || ch == '='))
+ if ((ch >= 0) && (ch < 128) && ((base64val(ch) != -1) || (ch == '=')))
buf[i++] = ch;
}
if (i != 4)
if (km_expand_key(keystroke, sizeof(keystroke),
km_find_func(MENU_PAGER, OP_VIEW_ATTACHMENTS)))
{
- if (C_HonorDisposition && b->disposition == DISP_ATTACH)
+ if (C_HonorDisposition && (b->disposition == DISP_ATTACH))
{
/* L10N: Caution: Arguments %1$s and %2$s are also defined but should
not be used in this translation!
return true;
}
}
- else if ((WithCrypto != 0) && a->type == TYPE_APPLICATION)
+ else if ((WithCrypto != 0) && (a->type == TYPE_APPLICATION))
{
if (((WithCrypto & APPLICATION_PGP) != 0) && mutt_is_application_pgp(a))
return true;
struct HcacheDbCtx *ctx = mutt_mem_malloc(sizeof(struct HcacheDbCtx));
- if (mutt_str_atoi(C_HeaderCachePagesize, &pagesize) < 0 || pagesize <= 0)
+ if ((mutt_str_atoi(C_HeaderCachePagesize, &pagesize) < 0) || (pagesize <= 0))
pagesize = 16384;
snprintf(ctx->lockfile, sizeof(ctx->lockfile), "%s-lock-hack", path);
if (ret)
goto fail_env;
- if (stat(path, &sb) != 0 && errno == ENOENT)
+ if ((stat(path, &sb) != 0) && (errno == ENOENT))
{
createflags |= DB_EXCL;
ctx->db->set_pagesize(ctx->db, pagesize);
{
int pagesize;
- if (mutt_str_atoi(C_HeaderCachePagesize, &pagesize) < 0 || pagesize <= 0)
+ if ((mutt_str_atoi(C_HeaderCachePagesize, &pagesize) < 0) || (pagesize <= 0))
pagesize = 16384;
GDBM_FILE db = gdbm_open((char *) path, pagesize, GDBM_WRCREAT, 00600, NULL);
hc->folder = get_foldername(folder);
hc->crc = hcachever;
- if (!path || path[0] == '\0')
+ if (!path || (path[0] == '\0'))
{
FREE(&hc->folder);
FREE(&hc);
{
int rc;
- if (ctx->txn && (ctx->txn_mode == TXN_READ || ctx->txn_mode == TXN_WRITE))
+ if (ctx->txn && ((ctx->txn_mode == TXN_READ) || (ctx->txn_mode == TXN_WRITE)))
return MDB_SUCCESS;
if (ctx->txn)
return rc;
}
rc = mdb_del(ctx->txn, ctx->db, &dkey, NULL);
- if (rc != MDB_SUCCESS && rc != MDB_NOTFOUND)
+ if ((rc != MDB_SUCCESS) && (rc != MDB_NOTFOUND))
{
mutt_debug(LL_DEBUG2, "mdb_del: %s\n", mdb_strerror(rc));
mdb_txn_abort(ctx->txn);
struct HcacheLmdbCtx *ctx = *vctx;
- if (ctx->txn && ctx->txn_mode == TXN_WRITE)
+ if (ctx->txn && (ctx->txn_mode == TXN_WRITE))
{
mdb_txn_commit(ctx->txn);
ctx->txn_mode = TXN_UNINITIALIZED;
if (STAILQ_EMPTY(&SubjectRegexList))
return env->subject;
- if (!env->subject || *env->subject == '\0')
+ if (!env->subject || (*env->subject == '\0'))
{
env->disp_subj = NULL;
return NULL;
if (*cp == '%')
{
cp++;
- if ((*cp == 'Z' || *cp == 'z') && (op == 'd' || op == '{'))
+ if (((*cp == 'Z') || (*cp == 'z')) && ((op == 'd') || (op == '{')))
{
if (len >= 5)
{
}
*p = 0;
- if (op == '[' || op == 'D')
+ if ((op == '[') || (op == 'D'))
tm = localtime(&e->date_sent);
else if (op == '(')
tm = localtime(&e->received);
mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
- if (len > 0 && op != 'd' && op != 'D') /* Skip ending op */
+ if ((len > 0) && (op != 'd') && (op != 'D')) /* Skip ending op */
src = cp + 1;
}
break;
parent_tags =
driver_tags_get_transformed(&e->thread->parent->message->tags);
}
- if (parent_tags && mutt_str_strcasecmp(tags, parent_tags) == 0)
+ if (parent_tags && (mutt_str_strcasecmp(tags, parent_tags) == 0))
have_tags = false;
FREE(&parent_tags);
}
if (!optional)
{
colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_COLLAPSED);
- if (threads && is_index && e->collapsed && e->num_hidden > 1)
+ if (threads && is_index && e->collapsed && (e->num_hidden > 1))
{
snprintf(buf + colorlen, buflen - colorlen, fmt, e->num_hidden);
add_index_color(buf, buflen - colorlen, flags, MT_COLOR_INDEX);
}
else
{
- if (!(threads && is_index && e->collapsed && e->num_hidden > 1))
+ if (!(threads && is_index && e->collapsed && (e->num_hidden > 1)))
optional = 0;
}
break;
case 'r':
tmp[0] = 0;
mutt_addr_write(tmp, sizeof(tmp), e->env->to, true);
- if (optional && tmp[0] == '\0')
+ if (optional && (tmp[0] == '\0'))
optional = 0;
mutt_format_s(buf, buflen, prec, tmp);
break;
case 'R':
tmp[0] = 0;
mutt_addr_write(tmp, sizeof(tmp), e->env->cc, true);
- if (optional && tmp[0] == '\0')
+ if (optional && (tmp[0] == '\0'))
optional = 0;
mutt_format_s(buf, buflen, prec, tmp);
break;
wch = get_nth_wchar(C_FlagChars, FLAG_CHAR_IMPORTANT);
else if (e->replied)
wch = get_nth_wchar(C_FlagChars, FLAG_CHAR_REPLIED);
- else if (e->read && (ctx && ctx->msgnotreadyet != e->msgno))
+ else if (e->read && (ctx && (ctx->msgnotreadyet != e->msgno)))
wch = get_nth_wchar(C_FlagChars, FLAG_CHAR_SEMPTY);
else if (e->old)
wch = get_nth_wchar(C_FlagChars, FLAG_CHAR_OLD);
memset(&mbstate2, 0, sizeof(mbstate2));
for (; len && (k = mbrtowc(&wc, *macro, len, &mbstate1)); *macro += k, len -= k)
{
- if (k == (size_t)(-1) || k == (size_t)(-2))
+ if ((k == (size_t)(-1)) || (k == (size_t)(-2)))
{
if (k == (size_t)(-1))
memset(&mbstate1, 0, sizeof(mbstate1));
}
/* glibc-2.1.3's wcwidth() returns 1 for unprintable chars! */
const int w = wcwidth(wc);
- if (IsWPrint(wc) && w >= 0)
+ if (IsWPrint(wc) && (w >= 0))
{
if (w > n)
break;
{
char buf[MB_LEN_MAX * 2];
size_t n1, n2;
- if ((n1 = wcrtomb(buf, wc, &mbstate2)) != (size_t)(-1) &&
- (n2 = wcrtomb(buf + n1, 0, &mbstate2)) != (size_t)(-1))
+ if (((n1 = wcrtomb(buf, wc, &mbstate2)) != (size_t)(-1)) &&
+ ((n2 = wcrtomb(buf + n1, 0, &mbstate2)) != (size_t)(-1)))
{
fputs(buf, fp);
}
}
}
- else if (wc < 0x20 || wc == 0x7f)
+ else if ((wc < 0x20) || (wc == 0x7f))
{
if (n < 2)
break;
{
if (*s == ' ')
m = n;
- if (k == (size_t)(-1) || k == (size_t)(-2))
+ if ((k == (size_t)(-1)) || (k == (size_t)(-2)))
{
if (k == (size_t)(-1))
memset(&mbstate, 0, sizeof(mbstate));
}
dump_menu(fp, menu);
- if (menu != MENU_EDITOR && menu != MENU_PAGER)
+ if ((menu != MENU_EDITOR) && (menu != MENU_PAGER))
{
fprintf(fp, "\n%s\n\n", _("Generic bindings:"));
dump_menu(fp, MENU_GENERIC);
return MUTT_CMD_SUCCESS;
}
}
- else if (ptr->type == data &&
- ptr->regex.not == not&&(mutt_str_strcmp(pattern.data, ptr->regex.pattern) == 0))
+ else if ((ptr->type == data) && (ptr->regex.not == not) &&
+ (mutt_str_strcmp(pattern.data, ptr->regex.pattern) == 0))
{
if (data & (MUTT_FOLDER_HOOK | MUTT_SEND_HOOK | MUTT_SEND2_HOOK | MUTT_MESSAGE_HOOK |
MUTT_ACCOUNT_HOOK | MUTT_REPLY_HOOK | MUTT_CRYPT_HOOK |
TAILQ_FOREACH_SAFE(h, &Hooks, entries, tmp)
{
- if (type == 0 || type == h->type)
+ if ((type == 0) || (type == h->type))
{
TAILQ_REMOVE(&Hooks, h, entries);
delete_hook(h);
char buf[PATH_MAX];
mutt_safe_path(buf, sizeof(buf), addr);
mutt_path_concat(path, NONULL(C_Folder), buf, pathlen);
- if (!C_ForceName && mx_access(path, W_OK) != 0)
+ if (!C_ForceName && (mx_access(path, W_OK) != 0))
mutt_str_strfcpy(path, C_Record, pathlen);
}
else
TAILQ_FOREACH(tmp, &Hooks, entries)
{
- if ((tmp->type & hook) && ((match && regexec(tmp->regex.regex, match, 0, NULL, 0) == 0) ^
- tmp->regex.not))
+ if ((tmp->type & hook) &&
+ ((match && (regexec(tmp->regex.regex, match, 0, NULL, 0) == 0)) ^
+ tmp->regex.not))
{
mutt_list_insert_tail(matches, mutt_str_strdup(tmp->command));
}
GSS_C_NO_OID, GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG,
0, GSS_C_NO_CHANNEL_BINDINGS, sec_token, NULL,
&send_token, (unsigned int *) &cflags, NULL);
- if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
+ if ((maj_stat != GSS_S_COMPLETE) && (maj_stat != GSS_S_CONTINUE_NEEDED))
{
print_gss_error(maj_stat, min_stat);
mutt_debug(LL_DEBUG1, "Error acquiring credentials - no TGT?\n");
&min_stat, GSS_C_NO_CREDENTIAL, &context, target_name, GSS_C_NO_OID,
GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG, 0, GSS_C_NO_CHANNEL_BINDINGS,
sec_token, NULL, &send_token, (unsigned int *) &cflags, NULL);
- if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
+ if ((maj_stat != GSS_S_COMPLETE) && (maj_stat != GSS_S_CONTINUE_NEEDED))
{
print_gss_error(maj_stat, min_stat);
mutt_debug(LL_DEBUG1, "Error exchanging credentials\n");
return IMAP_AUTH_UNAVAIL;
}
- if (rc != SASL_OK && rc != SASL_CONTINUE)
+ if ((rc != SASL_OK) && (rc != SASL_CONTINUE))
{
do
{
client_start = (olen > 0);
- if (rc != SASL_OK && rc != SASL_CONTINUE)
+ if ((rc != SASL_OK) && (rc != SASL_CONTINUE))
{
if (method)
mutt_debug(LL_DEBUG2, "%s unavailable\n", method);
irc = imap_cmd_step(adata);
while (irc == IMAP_CMD_CONTINUE);
- if (irc == IMAP_CMD_BAD || irc == IMAP_CMD_NO)
+ if ((irc == IMAP_CMD_BAD) || (irc == IMAP_CMD_NO))
goto bail;
if (irc == IMAP_CMD_RESPOND)
(state->entry)[state->entrylen].name = mutt_str_strdup(tmp);
/* mark desc with delim in browser if it can have subfolders */
- if (!isparent && !noinferiors && strlen(relpath) < sizeof(relpath) - 1)
+ if (!isparent && !noinferiors && (strlen(relpath) < sizeof(relpath) - 1))
{
relpath[strlen(relpath) + 1] = '\0';
relpath[strlen(relpath)] = delim;
list.name = NULL;
rc = imap_cmd_step(adata);
- if (rc == IMAP_CMD_CONTINUE && list.name)
+ if ((rc == IMAP_CMD_CONTINUE) && list.name)
{
/* Let a parent folder never be selectable for navigation */
if (isparent)
{
list.name = 0;
rc = imap_cmd_step(adata);
- if (rc == IMAP_CMD_CONTINUE && list.name)
+ if ((rc == IMAP_CMD_CONTINUE) && list.name)
{
if (!list.noinferiors && list.name[0] &&
- (imap_mxcmp(list.name, mbox) == 0) && n < sizeof(mbox) - 1)
+ (imap_mxcmp(list.name, mbox) == 0) && (n < sizeof(mbox) - 1))
{
mbox[n++] = list.delim;
mbox[n] = '\0';
struct ImapMboxData *mdata = adata->mailbox->mdata;
- if (adata->state >= IMAP_SELECTED && (mdata->reopen & IMAP_REOPEN_ALLOW))
+ if ((adata->state >= IMAP_SELECTED) && (mdata->reopen & IMAP_REOPEN_ALLOW))
{
mx_fastclose_mailbox(adata->mailbox);
mutt_socket_close(adata->conn);
struct ImapMboxData *mdata = adata->mailbox->mdata;
- if (mutt_str_atoui(s, &exp_msn) < 0 || exp_msn < 1 || exp_msn > mdata->max_msn)
+ if ((mutt_str_atoui(s, &exp_msn) < 0) || (exp_msn < 1) || (exp_msn > mdata->max_msn))
return;
e = mdata->msn_index[exp_msn - 1];
mdata->unseen = count;
s = value;
- if (*s && *s != ')')
+ if (*s && (*s != ')'))
s = imap_next_word(s);
}
mutt_debug(LL_DEBUG3, "%s (UIDVALIDITY: %u, UIDNEXT: %u) %d messages, %d recent, %d unseen\n",
if (C_MailCheckRecent)
{
- if (olduv && olduv == mdata->uid_validity)
+ if (olduv && (olduv == mdata->uid_validity))
{
if (oldun < mdata->uid_next)
new = (mdata->unseen > 0);
struct ImapMboxData *mdata = adata->mailbox->mdata;
/* new mail arrived */
- if (!(mdata->reopen & IMAP_EXPUNGE_PENDING) && count < mdata->max_msn)
+ if (!(mdata->reopen & IMAP_EXPUNGE_PENDING) && (count < mdata->max_msn))
{
/* Notes 6.0.3 has a tendency to report fewer messages exist than
* it should. */
return IMAP_EXEC_SUCCESS;
if ((flags & IMAP_CMD_POLL) && (C_ImapPollTimeout > 0) &&
- (mutt_socket_poll(adata->conn, C_ImapPollTimeout)) == 0)
+ ((mutt_socket_poll(adata->conn, C_ImapPollTimeout)) == 0))
{
mutt_error(_("Connection to %s timed out"), adata->conn->account.host);
cmd_handle_fatal(adata);
}
// Then add new emails to it
- if (mdata->reopen & IMAP_NEWMAIL_PENDING && mdata->new_mail_count > mdata->max_msn)
+ if (mdata->reopen & IMAP_NEWMAIL_PENDING && (mdata->new_mail_count > mdata->max_msn))
{
if (!(mdata->reopen & IMAP_EXPUNGE_PENDING))
mdata->check_status = IMAP_NEWMAIL_PENDING;
return -1;
}
- if ((C_ImapPollTimeout > 0) && (mutt_socket_poll(adata->conn, C_ImapPollTimeout)) == 0)
+ if ((C_ImapPollTimeout > 0) && ((mutt_socket_poll(adata->conn, C_ImapPollTimeout)) == 0))
{
mutt_error(_("Connection to %s timed out"), adata->conn->account.host);
cmd_handle_fatal(adata);
bool started = false;
struct ImapAccountData *adata = imap_adata_get(m);
- if (!adata || adata->mailbox != m)
+ if (!adata || (adata->mailbox != m))
return -1;
struct Email **emails = m->emails;
}
/* End current set if message doesn't match or we've reached the end
* of the mailbox via inactive messages following the last match. */
- else if (setstart && (emails[n]->active || n == adata->mailbox->msg_count - 1))
+ else if (setstart && (emails[n]->active || (n == adata->mailbox->msg_count - 1)))
{
if (imap_edata_get(emails[n - 1])->uid > setstart)
mutt_buffer_add_printf(buf, ":%u", imap_edata_get(emails[n - 1])->uid);
if ((m->rights & right) == 0)
return 0;
- if (right == MUTT_ACL_WRITE && !imap_has_flag(&imap_mdata_get(m)->flags, name))
+ if ((right == MUTT_ACL_WRITE) && !imap_has_flag(&imap_mdata_get(m)->flags, name))
return 0;
snprintf(buf, sizeof(buf), "+FLAGS.SILENT (%s)", name);
{
if (do_search(clause, 0))
{
- if (pat->op == MUTT_PAT_OR && clauses > 1)
+ if ((pat->op == MUTT_PAT_OR) && (clauses > 1))
mutt_buffer_addstr(buf, "OR ");
clauses--;
adata->status = IMAP_BYE;
imap_cmd_start(adata, "LOGOUT");
- if (C_ImapPollTimeout <= 0 || mutt_socket_poll(adata->conn, C_ImapPollTimeout) != 0)
+ if ((C_ImapPollTimeout <= 0) || (mutt_socket_poll(adata->conn, C_ImapPollTimeout) != 0))
{
while (imap_cmd_step(adata) == IMAP_CMD_CONTINUE)
;
return -1;
}
- if (r && c != '\n')
+ if (r && (c != '\n'))
fputc('\r', fp);
if (c == '\r')
int flag, bool changed, bool invert)
{
struct ImapAccountData *adata = imap_adata_get(m);
- if (!adata || adata->mailbox != m)
+ if (!adata || (adata->mailbox != m))
return -1;
struct Email **emails = NULL;
struct Buffer *cmd, enum QuadOption *err_continue)
{
struct ImapAccountData *adata = imap_adata_get(m);
- if (!adata || adata->mailbox != m)
+ if (!adata || (adata->mailbox != m))
return -1;
char flags[1024];
/* try IDLE first, unless force is set */
if (!force && C_ImapIdle && (adata->capabilities & IMAP_CAP_IDLE) &&
- (adata->state != IMAP_IDLE || time(NULL) >= adata->lastread + C_ImapKeepalive))
+ ((adata->state != IMAP_IDLE) || (time(NULL) >= adata->lastread + C_ImapKeepalive)))
{
if (imap_cmd_idle(adata) < 0)
return -1;
}
}
- if ((force || (adata->state != IMAP_IDLE && time(NULL) >= adata->lastread + C_Timeout)) &&
- imap_exec(adata, "NOOP", IMAP_CMD_POLL) != IMAP_EXEC_SUCCESS)
+ if ((force || ((adata->state != IMAP_IDLE) && (time(NULL) >= adata->lastread + C_Timeout))) &&
+ (imap_exec(adata, "NOOP", IMAP_CMD_POLL) != IMAP_EXEC_SUCCESS))
{
return -1;
}
* IDLEd elsewhere.
* adata->mailbox may be NULL for connections other than the current
* mailbox's.. #3216. */
- if (adata->mailbox && adata->mailbox->mdata == mdata)
+ if (adata->mailbox && (adata->mailbox->mdata == mdata))
{
adata->mailbox->has_new = false;
return mdata->messages;
listresp.name = NULL;
rc = imap_cmd_step(adata);
- if (rc == IMAP_CMD_CONTINUE && listresp.name)
+ if ((rc == IMAP_CMD_CONTINUE) && listresp.name)
{
/* if the folder isn't selectable, append delimiter to force browse
* to enter it on second tab. */
break;
mutt_debug(LL_DEBUG3, "server suggests TRYCREATE\n");
snprintf(prompt, sizeof(prompt), _("Create %s?"), dest_mdata->name);
- if (C_Confirmcreate && mutt_yesorno(prompt, 1) != MUTT_YES)
+ if (C_Confirmcreate && (mutt_yesorno(prompt, 1) != MUTT_YES))
{
mutt_clear_error();
goto out;
char buf[PATH_MAX + 64];
snprintf(buf, sizeof(buf), _("Create %s?"), mdata->name);
- if (C_Confirmcreate && mutt_yesorno(buf, MUTT_YES) != MUTT_YES)
+ if (C_Confirmcreate && (mutt_yesorno(buf, MUTT_YES) != MUTT_YES))
return -1;
if (imap_create_mailbox(adata, mdata->name) < 0)
*/
if (m == adata->mailbox)
{
- if (adata->status != IMAP_FATAL && adata->state >= IMAP_SELECTED)
+ if ((adata->status != IMAP_FATAL) && (adata->state >= IMAP_SELECTED))
{
/* mx_mbox_close won't sync if there are no deleted messages
* and the mailbox is unchanged, so we may have to close here */
SKIPWS(checker);
while (*checker != '\0')
{
- if (*checker < 32 || *checker >= 127 || // We allow space because it's the separator
- *checker == 40 || // (
- *checker == 41 || // )
- *checker == 60 || // <
- *checker == 62 || // >
- *checker == 64 || // @
- *checker == 44 || // ,
- *checker == 59 || // ;
- *checker == 58 || // :
- *checker == 92 || // backslash
- *checker == 34 || // "
- *checker == 46 || // .
- *checker == 91 || // [
- *checker == 93) // ]
+ if ((*checker < 32) || (*checker >= 127) || // We allow space because it's the separator
+ (*checker == 40) || // (
+ (*checker == 41) || // )
+ (*checker == 60) || // <
+ (*checker == 62) || // >
+ (*checker == 64) || // @
+ (*checker == 44) || // ,
+ (*checker == 59) || // ;
+ (*checker == 58) || // :
+ (*checker == 92) || // backslash
+ (*checker == 34) || // "
+ (*checker == 46) || // .
+ (*checker == 91) || // [
+ (*checker == 93)) // ]
{
mutt_error(_("Invalid IMAP flags"));
return 0;
struct ImapAccountData *adata = imap_adata_get(m);
struct ImapMboxData *mdata = imap_mdata_get(m);
- if (!adata || adata->mailbox != m)
+ if (!adata || (adata->mailbox != m))
return NULL;
char mailbox[PATH_MAX];
struct ImapAccountData *adata = imap_adata_get(m);
struct ImapMboxData *mdata = imap_mdata_get(m);
- if (!e || !adata || adata->mailbox != m)
+ if (!e || !adata || (adata->mailbox != m))
return NULL;
mdata->bcache = msg_cache_open(m);
struct ImapAccountData *adata = imap_adata_get(m);
struct ImapMboxData *mdata = imap_mdata_get(m);
- if (!e || !adata || adata->mailbox != m)
+ if (!e || !adata || (adata->mailbox != m))
return NULL;
mdata->bcache = msg_cache_open(m);
struct ImapAccountData *adata = imap_adata_get(m);
struct ImapMboxData *mdata = imap_mdata_get(m);
- if (!e || !adata || adata->mailbox != m)
+ if (!e || !adata || (adata->mailbox != m))
return -1;
mdata->bcache = msg_cache_open(m);
return 0;
/* bad UID */
- if (uv != mdata->uid_validity || !mutt_hash_int_find(mdata->uid_hash, uid))
+ if ((uv != mdata->uid_validity) || !mutt_hash_int_find(mdata->uid_hash, uid))
mutt_bcache_del(bcache, id);
return 0;
parse_rc = msg_parse_fetch(ih, buf);
if (!parse_rc)
return 0;
- if (parse_rc != -2 || !fp)
+ if ((parse_rc != -2) || !fp)
return rc;
if (imap_get_literal_count(buf, &bytes) == 0)
struct ImapMboxData *mdata = imap_mdata_get(m);
int idx = m->msg_count;
- if (!adata || adata->mailbox != m)
+ if (!adata || (adata->mailbox != m))
return -1;
if (adata->capabilities & IMAP_CAP_IMAP4REV1)
struct ImapAccountData *adata = imap_adata_get(m);
struct ImapMboxData *mdata = imap_mdata_get(m);
- if (!adata || adata->mailbox != m)
+ if (!adata || (adata->mailbox != m))
return -1;
/* make sure context has room to hold the mailbox */
if (read_headers_fetch_new(m, msn_begin, msn_end, evalhc, &maxuid, initial_download) < 0)
goto bail;
- if (maxuid && mdata->uid_next < maxuid + 1)
+ if (maxuid && (mdata->uid_next < maxuid + 1))
mdata->uid_next = maxuid + 1;
#ifdef USE_HCACHE
mutt_hcache_store_raw(mdata->hcache, "/UIDVALIDITY", 12, &mdata->uid_validity,
sizeof(mdata->uid_validity));
- if (maxuid && mdata->uid_next < maxuid + 1)
+ if (maxuid && (mdata->uid_next < maxuid + 1))
{
mutt_debug(LL_DEBUG2, "Overriding UIDNEXT: %u -> %u\n", mdata->uid_next, maxuid + 1);
mdata->uid_next = maxuid + 1;
* Ideally we'd have a Header structure with flag info here... */
for (last = EOF, len = 0; (c = fgetc(fp)) != EOF; last = c)
{
- if (c == '\n' && last != '\r')
+ if ((c == '\n') && (last != '\r'))
len++;
len++;
for (last = EOF, sent = len = 0; (c = fgetc(fp)) != EOF; last = c)
{
- if (c == '\n' && last != '\r')
+ if ((c == '\n') && (last != '\r'))
buf[len++] = '\r';
buf[len++] = c;
break;
mutt_debug(LL_DEBUG3, "server suggests TRYCREATE\n");
snprintf(prompt, sizeof(prompt), _("Create %s?"), mbox);
- if (C_Confirmcreate && mutt_yesorno(prompt, MUTT_YES) != MUTT_YES)
+ if (C_Confirmcreate && (mutt_yesorno(prompt, MUTT_YES) != MUTT_YES))
{
mutt_clear_error();
goto out;
struct ImapAccountData *adata = imap_adata_get(m);
struct ImapMboxData *mdata = imap_mdata_get(m);
- if (!e || !adata || adata->mailbox != m)
+ if (!e || !adata || (adata->mailbox != m))
return -1;
mdata->bcache = msg_cache_open(m);
struct ImapAccountData *adata = imap_adata_get(m);
struct ImapMboxData *mdata = imap_mdata_get(m);
- if (!adata || adata->mailbox != m)
+ if (!adata || (adata->mailbox != m))
return -1;
mdata->bcache = msg_cache_open(m);
char *imap_set_flags(struct Mailbox *m, struct Email *e, char *s, bool *server_changes)
{
struct ImapAccountData *adata = imap_adata_get(m);
- if (!adata || adata->mailbox != m)
+ if (!adata || (adata->mailbox != m))
return NULL;
struct ImapHeader newh = { 0 };
struct ImapAccountData *adata = imap_adata_get(m);
- if (!adata || adata->mailbox != m)
+ if (!adata || (adata->mailbox != m))
return -1;
struct Email *e = m->emails[msgno];
u7++;
u7len--;
- if (u7len && *u7 == '-')
+ if (u7len && (*u7 == '-'))
{
*p++ = '&';
continue;
k = 10;
for (; u7len; u7++, u7len--)
{
- if ((*u7 & 0x80) || (b = Index64u[(int) *u7]) == -1)
+ if ((*u7 & 0x80) || ((b = Index64u[(int) *u7]) == -1))
break;
if (k > 0)
{
ch |= b >> (-k);
if (ch < 0x80)
{
- if (0x20 <= ch && ch < 0x7f)
+ if ((0x20 <= ch) && (ch < 0x7f))
{
/* Printable US-ASCII */
goto bail;
k += 10;
}
}
- if (ch || k < 6)
+ if (ch || (k < 6))
{
/* Non-zero or too many extra bits */
goto bail;
}
- if (!u7len || *u7 != '-')
+ if (!u7len || (*u7 != '-'))
{
/* BASE64 not properly terminated */
goto bail;
}
- if (u7len > 2 && u7[1] == '&' && u7[2] != '-')
+ if ((u7len > 2) && (u7[1] == '&') && (u7[2] != '-'))
{
/* Adjacent BASE64 sections */
goto bail;
}
}
- else if (*u7 < 0x20 || *u7 >= 0x7f)
+ else if ((*u7 < 0x20) || (*u7 >= 0x7f))
{
/* Not printable US-ASCII */
goto bail;
goto bail;
ch = (ch << 6) | (u8[i] & 0x3f);
}
- if (n > 1 && !(ch >> (n * 5 + 1)))
+ if ((n > 1) && !(ch >> (n * 5 + 1)))
goto bail;
u8 += n;
u8len -= n;
- if (ch < 0x20 || ch >= 0x7f)
+ if ((ch < 0x20) || (ch >= 0x7f))
{
if (!base64)
{
else
t = utf7_to_utf8(*s, strlen(*s), 0, 0);
- if (t && mutt_ch_convert_string(&t, "utf-8", C_Charset, 0) == 0)
+ if (t && (mutt_ch_convert_string(&t, "utf-8", C_Charset, 0) == 0))
{
FREE(s);
*s = t;
account->type = MUTT_ACCT_TYPE_IMAP;
struct Url *url = url_parse(path);
- if (url && (url->scheme == U_IMAP || url->scheme == U_IMAPS))
+ if (url && ((url->scheme == U_IMAP) || (url->scheme == U_IMAPS)))
{
- if (mutt_account_fromurl(account, url) < 0 || !*account->host)
+ if ((mutt_account_fromurl(account, url) < 0) || !*account->host)
{
url_free(&url);
return -1;
while (mailbox && *mailbox && i < plen - 1)
{
if ((C_ImapDelimChars && strchr(C_ImapDelimChars, *mailbox)) ||
- (delim && *mailbox == delim))
+ (delim && (*mailbox == delim)))
{
/* use connection delimiter if known. Otherwise use user delimiter */
if (server_delim == '\0')
}
i++;
}
- if (i && path[--i] != delim)
+ if (i && (path[--i] != delim))
i++;
path[i] = '\0';
{
*s = '/';
/* simple way to avoid collisions with UIDs */
- if (*(p + 1) >= '0' && *(p + 1) <= '9')
+ if ((*(p + 1) >= '0') && (*(p + 1) <= '9'))
{
if (--dlen)
*++s = '_';
{
struct ImapAccountData *adata = imap_adata_get(m);
struct ImapMboxData *mdata = imap_mdata_get(m);
- if (!adata || !adata->mailbox || adata->mailbox != m || !mdata)
+ if (!adata || !adata->mailbox || (adata->mailbox != m) || !mdata)
return;
mdata->reopen |= IMAP_REOPEN_ALLOW;
}
{
struct ImapAccountData *adata = imap_adata_get(m);
struct ImapMboxData *mdata = imap_mdata_get(m);
- if (!adata || !adata->mailbox || adata->mailbox != m || !mdata)
+ if (!adata || !adata->mailbox || (adata->mailbox != m) || !mdata)
return;
mdata->reopen &= ~IMAP_REOPEN_ALLOW;
}
* If C_Sort is threaded, the latest message is first if exactly one
* of C_Sort and C_SortAux are reverse.
*/
- if (((C_Sort & SORT_REVERSE) && (C_Sort & SORT_MASK) != SORT_THREADS) ||
- ((C_Sort & SORT_MASK) == SORT_THREADS && ((C_Sort ^ C_SortAux) & SORT_REVERSE)))
+ if (((C_Sort & SORT_REVERSE) && ((C_Sort & SORT_MASK) != SORT_THREADS)) ||
+ (((C_Sort & SORT_MASK) == SORT_THREADS) && ((C_Sort ^ C_SortAux) & SORT_REVERSE)))
{
return 0;
}
}
}
- if ((C_Sort & SORT_MASK) == SORT_THREADS && menu->current < 0)
+ if (((C_Sort & SORT_MASK) == SORT_THREADS) && (menu->current < 0))
menu->current = mutt_parent_message(Context, current, false);
if (menu->current < 0)
if (monitor_remove_rc == 0)
mutt_monitor_add(NULL);
#endif
- if (check == MUTT_NEW_MAIL || check == MUTT_REOPENED)
+ if ((check == MUTT_NEW_MAIL) || (check == MUTT_REOPENED))
update_index(menu, Context, check, *oldcount, *index_hint);
FREE(&new_last_folder);
MuttFormatFlags flags = MUTT_FORMAT_ARROWCURSOR | MUTT_FORMAT_INDEX;
struct MuttThread *tmp = NULL;
- if ((C_Sort & SORT_MASK) == SORT_THREADS && e->tree)
+ if (((C_Sort & SORT_MASK) == SORT_THREADS) && e->tree)
{
flags |= MUTT_FORMAT_TREE; /* display the thread tree */
if (e->display_subject)
/* if no ancestor is visible on current screen, provisionally force
* subject... */
- if (reverse ? tmp->message->msgno > edgemsgno : tmp->message->msgno < edgemsgno)
+ if (reverse ? (tmp->message->msgno > edgemsgno) : (tmp->message->msgno < edgemsgno))
{
flags |= MUTT_FORMAT_FORCESUBJ;
break;
continue;
/* ...but if a previous sibling is available, don't force it */
- if (reverse ? tmp->message->msgno > edgemsgno : tmp->message->msgno < edgemsgno)
+ if (reverse ? (tmp->message->msgno > edgemsgno) : (tmp->message->msgno < edgemsgno))
break;
else if (tmp->message->virtual >= 0)
{
if (op == OP_GET_MESSAGE)
{
buf[0] = 0;
- if (mutt_get_field(_("Enter Message-Id: "), buf, sizeof(buf), 0) != 0 ||
+ if ((mutt_get_field(_("Enter Message-Id: "), buf, sizeof(buf), 0) != 0) ||
!buf[0])
{
break;
}
else
menu->current = 0;
- if ((Context->mailbox->msg_count != 0) && (C_Sort & SORT_MASK) == SORT_THREADS)
+ if ((Context->mailbox->msg_count != 0) && ((C_Sort & SORT_MASK) == SORT_THREADS))
mutt_draw_tree(Context);
menu->redraw = REDRAW_FULL;
}
mutt_startup_shutdown_hook(MUTT_SHUTDOWN_HOOK);
- if (!Context || (check = mx_mbox_close(&Context)) == 0)
+ if (!Context || ((check = mx_mbox_close(&Context)) == 0))
done = true;
else
{
Context->last_tag);
menu->redraw |= REDRAW_STATUS;
- if (C_Resolve && menu->current < Context->mailbox->vcount - 1)
+ if (C_Resolve && (menu->current < Context->mailbox->vcount - 1))
{
menu->current++;
menu->redraw |= REDRAW_MOTION_RESYNC;
case OP_MAIN_VFOLDER_FROM_QUERY:
case OP_MAIN_VFOLDER_FROM_QUERY_READONLY:
buf[0] = '\0';
- if (mutt_get_field("Query: ", buf, sizeof(buf), MUTT_NM_QUERY) != 0 || !buf[0])
+ if ((mutt_get_field("Query: ", buf, sizeof(buf), MUTT_NM_QUERY) != 0) || !buf[0])
{
mutt_message(_("No query, aborting"));
break;
break;
if ((op != OP_FOLLOWUP) || !CUR_EMAIL->env->followup_to ||
(mutt_str_strcasecmp(CUR_EMAIL->env->followup_to, "poster") != 0) ||
- query_quadoption(C_FollowupToPoster,
- _("Reply by mail as poster prefers?")) != MUTT_YES)
+ (query_quadoption(C_FollowupToPoster,
+ _("Reply by mail as poster prefers?")) != MUTT_YES))
{
if (Context && (Context->mailbox->magic == MUTT_NNTP) &&
- !((struct NntpMboxData *) Context->mailbox->mdata)->allowed && query_quadoption(C_PostModerated, _("Posting to this group not allowed, may be moderated. Continue?")) != MUTT_YES)
+ !((struct NntpMboxData *) Context->mailbox->mdata)->allowed && (query_quadoption(C_PostModerated, _("Posting to this group not allowed, may be moderated. Continue?")) != MUTT_YES))
{
break;
}
}
else
{
- if (C_Resolve && menu->current < (Context->mailbox->vcount - 1))
+ if (C_Resolve && (menu->current < (Context->mailbox->vcount - 1)))
{
menu->current++;
menu->redraw |= REDRAW_MOTION_RESYNC;
static void add_to_stailq(struct ListHead *head, const char *str)
{
/* don't add a NULL or empty string to the list */
- if (!str || *str == '\0')
+ if (!str || (*str == '\0'))
return;
/* check to make sure the item is not already on this list */
* @param dlen Length of dest buffer
*
* Changes the dest buffer if necessary/possible to aid completion.
-*/
+ */
static void candidate(char *try, const char *src, char *dest, size_t dlen)
{
if (!dest || !try || !src)
nm_db_longrun_init(Context->mailbox, false);
/* Work out how many tags there are. */
- if (nm_get_all_tags(Context->mailbox, NULL, &tag_count_1) || tag_count_1 == 0)
+ if (nm_get_all_tags(Context->mailbox, NULL, &tag_count_1) || (tag_count_1 == 0))
goto done;
/* Free the old list, if any. */
nm_tags[tag_count_1] = NULL;
/* Get all the tags. */
- if (nm_get_all_tags(Context->mailbox, nm_tags, &tag_count_2) || tag_count_1 != tag_count_2)
+ if (nm_get_all_tags(Context->mailbox, nm_tags, &tag_count_2) || (tag_count_1 != tag_count_2))
{
FREE(&nm_tags);
nm_tags = NULL;
{
mutt_extract_token(buf, s, 0);
- if (!buf->data || *buf->data == '\0')
+ if (!buf->data || (*buf->data == '\0'))
continue;
a = mutt_mem_malloc(sizeof(struct AttachMatch));
a = (struct AttachMatch *) np->data;
mutt_debug(LL_DEBUG3, "check %s/%s [%d] : %s/%s [%d]\n", a->major,
a->minor, a->major_int, tmp, minor, major);
- if (a->major_int == major && (mutt_str_strcasecmp(minor, a->minor) == 0))
+ if ((a->major_int == major) && (mutt_str_strcasecmp(minor, a->minor) == 0))
{
mutt_debug(LL_DEBUG3, "removed %s/%s [%d]\n", a->major, a->minor, a->major_int);
regfree(&a->minor_regex);
struct ListHead *head = NULL;
mutt_extract_token(buf, s, 0);
- if (!buf->data || *buf->data == '\0')
+ if (!buf->data || (*buf->data == '\0'))
{
mutt_buffer_strcpy(err, _("attachments: no disposition"));
return MUTT_CMD_WARNING;
return MUTT_CMD_SUCCESS;
}
- if (op != '+' && op != '-')
+ if ((op != '+') && (op != '-'))
{
op = '+';
category--;
if (parse_grouplist(&gc, buf, s, data, err) == -1)
goto bail;
- if (data == MUTT_UNGROUP && (mutt_str_strcasecmp(buf->data, "*") == 0))
+ if ((data == MUTT_UNGROUP) && (mutt_str_strcasecmp(buf->data, "*") == 0))
{
mutt_grouplist_clear(&gc);
goto out;
goto warn;
case GS_RX:
- if (data == MUTT_GROUP &&
- mutt_grouplist_add_regex(&gc, buf->data, REG_ICASE, err) != 0)
+ if ((data == MUTT_GROUP) &&
+ (mutt_grouplist_add_regex(&gc, buf->data, REG_ICASE, err) != 0))
{
goto bail;
}
- else if (data == MUTT_UNGROUP && mutt_grouplist_remove_regex(&gc, buf->data) < 0)
+ else if ((data == MUTT_UNGROUP) &&
+ (mutt_grouplist_remove_regex(&gc, buf->data) < 0))
{
goto bail;
}
mutt_regexlist_remove(&Alternates, buf->data);
if ((mutt_str_strcmp(buf->data, "*") != 0) &&
- mutt_regexlist_add(&UnAlternates, buf->data, REG_ICASE, err) != 0)
+ (mutt_regexlist_add(&UnAlternates, buf->data, REG_ICASE, err) != 0))
{
return MUTT_CMD_ERROR;
}
struct ListHead *head = NULL;
mutt_extract_token(buf, s, 0);
- if (!buf->data || *buf->data == '\0')
+ if (!buf->data || (*buf->data == '\0'))
{
mutt_buffer_strcpy(err, _("unattachments: no disposition"));
return MUTT_CMD_WARNING;
p = buf->data;
op = *p++;
- if (op != '+' && op != '-')
+ if ((op != '+') && (op != '-'))
{
op = '+';
p--;
mutt_regexlist_remove(&MailLists, buf->data);
if ((mutt_str_strcmp(buf->data, "*") != 0) &&
- mutt_regexlist_add(&UnMailLists, buf->data, REG_ICASE, err) != 0)
+ (mutt_regexlist_add(&UnMailLists, buf->data, REG_ICASE, err) != 0))
{
return MUTT_CMD_ERROR;
}
STAILQ_FOREACH_SAFE(np, &UserHeader, entries, tmp)
{
- if ((mutt_str_strncasecmp(buf->data, np->data, l) == 0) && np->data[l] == ':')
+ if ((mutt_str_strncasecmp(buf->data, np->data, l) == 0) && (np->data[l] == ':'))
{
STAILQ_REMOVE(&UserHeader, np, ListNode, entries);
FREE(&np->data);
mutt_regexlist_remove(&SubscribedLists, buf->data);
if ((mutt_str_strcmp(buf->data, "*") != 0) &&
- mutt_regexlist_add(&UnSubscribedLists, buf->data, REG_ICASE, err) != 0)
+ (mutt_regexlist_add(&UnSubscribedLists, buf->data, REG_ICASE, err) != 0))
{
return MUTT_CMD_ERROR;
}
if (!qc)
{
if ((ISSPACE(ch) && !(flags & MUTT_TOKEN_SPACE)) ||
- (ch == '#' && !(flags & MUTT_TOKEN_COMMENT)) ||
- (ch == '=' && (flags & MUTT_TOKEN_EQUAL)) ||
- (ch == '?' && (flags & MUTT_TOKEN_QUESTION)) ||
- (ch == ';' && !(flags & MUTT_TOKEN_SEMICOLON)) ||
+ ((ch == '#') && !(flags & MUTT_TOKEN_COMMENT)) ||
+ ((ch == '=') && (flags & MUTT_TOKEN_EQUAL)) ||
+ ((ch == '?') && (flags & MUTT_TOKEN_QUESTION)) ||
+ ((ch == ';') && !(flags & MUTT_TOKEN_SEMICOLON)) ||
((flags & MUTT_TOKEN_PATTERN) && strchr("~%=!|", ch)))
{
break;
if (ch == qc)
qc = 0; /* end of quote */
- else if (!qc && (ch == '\'' || ch == '"') && !(flags & MUTT_TOKEN_QUOTE))
+ else if (!qc && ((ch == '\'') || (ch == '"')) && !(flags & MUTT_TOKEN_QUOTE))
qc = ch;
- else if (ch == '\\' && qc != '\'')
+ else if ((ch == '\\') && (qc != '\''))
{
if (!*tok->dptr)
return -1; /* premature end of token */
mutt_buffer_addch(dest, ch);
}
}
- else if (ch == '^' && (flags & MUTT_TOKEN_CONDENSE))
+ else if ((ch == '^') && (flags & MUTT_TOKEN_CONDENSE))
{
if (!*tok->dptr)
return -1; /* premature end of token */
mutt_buffer_addch(dest, ch);
}
}
- else if (ch == '`' && (!qc || qc == '"'))
+ else if ((ch == '`') && (!qc || (qc == '"')))
{
FILE *fp = NULL;
pid_t pid;
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)))
{
const char *env = NULL;
char *var = NULL;
int mutt_get_hook_type(const char *name)
{
for (const struct Command *c = Commands; c->name; c++)
- if (c->func == mutt_parse_hook && (mutt_str_strcasecmp(c->name, name) == 0))
+ if ((c->func == mutt_parse_hook) && (mutt_str_strcasecmp(c->name, name) == 0))
return c->data;
return MUTT_CMD_SUCCESS;
}
return 1;
}
- if (Completed[0] == 0 && UserTyped[0])
+ if ((Completed[0] == 0) && UserTyped[0])
return 0;
/* NumMatched will _always_ be at least 1 since the initial
* user-typed string is always stored */
- if (numtabs == 1 && NumMatched == 2)
+ if ((numtabs == 1) && (NumMatched == 2))
snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
- else if (numtabs > 1 && NumMatched > 2)
+ else if ((numtabs > 1) && (NumMatched > 2))
{
/* cycle through all the matches */
snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
return 1;
}
- if (Completed[0] == 0 && UserTyped[0])
+ if ((Completed[0] == 0) && UserTyped[0])
return 0;
/* NumMatched will _always_ be at least 1 since the initial
* user-typed string is always stored */
- if (numtabs == 1 && NumMatched == 2)
+ if ((numtabs == 1) && (NumMatched == 2))
snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
- else if (numtabs > 1 && NumMatched > 2)
+ else if ((numtabs > 1) && (NumMatched > 2))
{
/* cycle through all the matches */
snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
{
const struct Binding *menu = km_get_table(CurrentMenu);
- if (!menu && CurrentMenu != MENU_PAGER)
+ if (!menu && (CurrentMenu != MENU_PAGER))
menu = OpGeneric;
pt++;
for (num = 0; menu[num].name; num++)
candidate(UserTyped, menu[num].name, Completed, sizeof(Completed));
/* try the generic menu */
- if (Completed[0] == 0 && CurrentMenu != MENU_PAGER)
+ if ((Completed[0] == 0) && (CurrentMenu != MENU_PAGER))
{
menu = OpGeneric;
for (num = 0; menu[num].name; num++)
return 1;
}
- if (Completed[0] == 0 && UserTyped[0])
+ if ((Completed[0] == 0) && UserTyped[0])
return 0;
/* NumMatched will _always_ be at least 1 since the initial
* user-typed string is always stored */
- if (numtabs == 1 && NumMatched == 2)
+ if ((numtabs == 1) && (NumMatched == 2))
snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
- else if (numtabs > 1 && NumMatched > 2)
+ else if ((numtabs > 1) && (NumMatched > 2))
{
/* cycle through all the matches */
snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
return 1;
}
- if (Completed[0] == 0 && UserTyped[0])
+ if ((Completed[0] == 0) && UserTyped[0])
return 0;
/* NumMatched will _always_ be at least 1 since the initial
* user-typed string is always stored */
- if (numtabs == 1 && NumMatched == 2)
+ if ((numtabs == 1) && (NumMatched == 2))
snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
- else if (numtabs > 1 && NumMatched > 2)
+ else if ((numtabs > 1) && (NumMatched > 2))
{
/* cycle through all the matches */
snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
return true;
}
- if (Completed[0] == 0 && UserTyped[0])
+ if ((Completed[0] == 0) && UserTyped[0])
return false;
/* NumMatched will _always_ be at least 1 since the initial
* user-typed string is always stored */
- if (numtabs == 1 && NumMatched == 2)
+ if ((numtabs == 1) && (NumMatched == 2))
snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
- else if (numtabs > 1 && NumMatched > 2)
+ else if ((numtabs > 1) && (NumMatched > 2))
{
/* cycle through all the matches */
snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
return true;
}
- if (Completed[0] == 0 && UserTyped[0])
+ if ((Completed[0] == 0) && UserTyped[0])
return false;
/* NumMatched will _always_ be at least 1 since the initial
* user-typed string is always stored */
- if (numtabs == 1 && NumMatched == 2)
+ if ((numtabs == 1) && (NumMatched == 2))
snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
- else if (numtabs > 1 && NumMatched > 2)
+ else if ((numtabs > 1) && (NumMatched > 2))
{
/* cycle through all the matches */
snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
char *t = NULL;
int n = 0;
- if (s[0] != '<' || tolower(s[1]) != 'f')
+ if ((s[0] != '<') || (tolower(s[1]) != 'f'))
return -1;
for (t = s + 2; *t && isdigit((unsigned char) *t); t++)
while (ISSPACE(*end_char))
end_char++;
/* negative keycodes don't make sense, also detect overflow */
- if (*end_char != '>' || result < 0 || result == LONG_MAX)
+ if ((*end_char != '>') || (result < 0) || (result == LONG_MAX))
{
return -1;
}
while (*s && len)
{
*d = '\0';
- if (*s == '<' && (t = strchr(s, '>')))
+ if ((*s == '<') && (t = strchr(s, '>')))
{
t++;
c = *t;
while (tmp)
{
- if (pos >= len || pos >= tmp->len)
+ if ((pos >= len) || (pos >= tmp->len))
{
/* map and tmp match so overwrite */
do
{
/* Don't warn on overwriting a 'noop' binding */
- if (tmp->len != len && tmp->op != OP_NULL)
+ if ((tmp->len != len) && (tmp->op != OP_NULL))
{
/* Overwrite with the different lengths, warn */
/* TODO: MAX_SEQ here is wrong */
for (int i = 0; bindings[i].name; i++)
{
if ((mutt_str_strncasecmp(start, bindings[i].name, len) == 0) &&
- mutt_str_strlen(bindings[i].name) == len)
+ (mutt_str_strlen(bindings[i].name) == len))
{
return bindings[i].op;
}
*/
static int retry_generic(int menu, keycode_t *keys, int keyslen, int lastkey)
{
- if (menu != MENU_EDITOR && menu != MENU_GENERIC && menu != MENU_PAGER)
+ if ((menu != MENU_EDITOR) && (menu != MENU_GENERIC) && (menu != MENU_PAGER))
{
if (lastkey)
mutt_unget_event(lastkey, 0);
* $timeout seconds.
*/
#ifdef USE_INOTIFY
- if (tmp.ch != -2 || SigWinch || MonitorFilesChanged)
+ if ((tmp.ch != -2) || SigWinch || MonitorFilesChanged)
#else
- if (tmp.ch != -2 || SigWinch)
+ if ((tmp.ch != -2) || SigWinch)
#endif
goto gotkey;
i -= C_ImapKeepalive;
gotkey:
#endif
/* hide timeouts, but not window resizes, from the line editor. */
- if (menu == MENU_EDITOR && tmp.ch == -2 && !SigWinch)
+ if ((menu == MENU_EDITOR) && (tmp.ch == -2) && !SigWinch)
continue;
LastKey = tmp.ch;
if ((bindings = km_get_table(menu)) && (func = mutt_get_func(bindings, tmp.op)))
return tmp.op;
- if (menu == MENU_EDITOR && mutt_get_func(OpEditor, tmp.op))
+ if ((menu == MENU_EDITOR) && mutt_get_func(OpEditor, tmp.op))
return tmp.op;
- if (menu != MENU_EDITOR && menu != MENU_PAGER)
+ if ((menu != MENU_EDITOR) && (menu != MENU_PAGER))
{
/* check generic menu */
bindings = OpGeneric;
/* Nope. Business as usual */
while (LastKey > map->keys[pos])
{
- if (pos > map->eq || !map->next)
+ if ((pos > map->eq) || !map->next)
return retry_generic(menu, map->keys, pos, LastKey);
map = map->next;
}
if (p)
return p;
- if (c < 256 && c > -128 && iscntrl((unsigned char) c))
+ if ((c < 256) && (c > -128) && iscntrl((unsigned char) c))
{
if (c < 0)
c += 256;
else
snprintf(buf, sizeof(buf), "\\%d%d%d", c >> 6, (c >> 3) & 7, c & 7);
}
- else if (c >= KEY_F0 && c < KEY_F(256)) /* this maximum is just a guess */
+ else if ((c >= KEY_F0) && (c < KEY_F(256))) /* this maximum is just a guess */
sprintf(buf, "<F%d>", c - KEY_F0);
else if (IsPrint(c))
snprintf(buf, sizeof(buf), "%c", (unsigned char) c);
const size_t l = mutt_str_strlen(s);
len -= l;
- if (++p >= map->len || !len)
+ if ((++p >= map->len) || !len)
return 1;
s += l;
if (keyname)
{
char *s = tigetstr((char *) keyname);
- if (s && (long) (s) != -1)
+ if (s && ((long) (s) != -1))
{
int code = key_defined(s);
if (code > 0)
bindings = OpGeneric;
ops[nops] = get_op(bindings, function, mutt_str_strlen(function));
- if (ops[nops] == OP_NULL && CurrentMenu != MENU_PAGER)
+ if ((ops[nops] == OP_NULL) && (CurrentMenu != MENU_PAGER))
ops[nops] = get_op(OpGeneric, function, mutt_str_strlen(function));
if (ops[nops] == OP_NULL)
do
{
ch = getch();
- if (ch != ERR && ch != ctrl('G'))
+ if ((ch != ERR) && (ch != ctrl('G')))
{
mutt_message(_("Char = %s, Octal = %o, Decimal = %d"), km_keyname(ch), ch, ch);
}
default:
m_check->has_new = false;
- if (stat(m_check->path, &sb) != 0 || (S_ISREG(sb.st_mode) && sb.st_size == 0) ||
+ if ((stat(m_check->path, &sb) != 0) || (S_ISREG(sb.st_mode) && (sb.st_size == 0)) ||
((m_check->magic == MUTT_UNKNOWN) &&
- (m_check->magic = mx_path_probe(m_check->path, NULL)) <= 0))
+ ((m_check->magic = mx_path_probe(m_check->path, NULL)) <= 0)))
{
/* if the mailbox still doesn't exist, set the newly created flag to be
* ready for when it does. */
/* check to see if the folder is the currently selected folder before polling */
if (!m_cur || (m_cur->path[0] == '\0') ||
- ((m_check->magic == MUTT_IMAP || m_check->magic == MUTT_NNTP ||
- m_check->magic == MUTT_NOTMUCH || m_check->magic == MUTT_POP) ?
+ (((m_check->magic == MUTT_IMAP) || (m_check->magic == MUTT_NNTP) ||
+ (m_check->magic == MUTT_NOTMUCH) || (m_check->magic == MUTT_POP)) ?
(mutt_str_strcmp(m_check->path, m_cur->path) != 0) :
- (sb.st_dev != ctx_sb->st_dev || sb.st_ino != ctx_sb->st_ino)))
+ ((sb.st_dev != ctx_sb->st_dev) || (sb.st_ino != ctx_sb->st_ino))))
{
switch (m_check->magic)
{
struct MailboxNode *np = NULL;
STAILQ_FOREACH(np, &AllMailboxes, entries)
{
- if (np->mailbox->desc && mutt_str_strcmp(np->mailbox->desc, desc) == 0)
+ if (np->mailbox->desc && (mutt_str_strcmp(np->mailbox->desc, desc) == 0))
return np->mailbox;
}
*/
if (check_new && C_MailCheckRecent)
{
- if (stat(mutt_b2s(path), &sb) == 0 &&
- mutt_file_stat_timespec_compare(&sb, MUTT_STAT_MTIME, &m->last_visited) < 0)
+ if ((stat(mutt_b2s(path), &sb) == 0) &&
+ (mutt_file_stat_timespec_compare(&sb, MUTT_STAT_MTIME, &m->last_visited) < 0))
{
check_new = false;
}
{
mutt_buffer_printf(msgpath, "%s/%s", mutt_b2s(path), de->d_name);
/* ensure this message was received since leaving this m */
- if (stat(mutt_b2s(msgpath), &sb) == 0 &&
+ if ((stat(mutt_b2s(msgpath), &sb) == 0) &&
(mutt_file_stat_timespec_compare(&sb, MUTT_STAT_CTIME, &m->last_visited) <= 0))
{
continue;
/* when $mail_check_recent is set and the .mh_sequences file hasn't changed
* since the last m visit, there is no "new mail" */
- if (C_MailCheckRecent && mh_sequences_changed(m) <= 0)
+ if (C_MailCheckRecent && (mh_sequences_changed(m) <= 0))
{
rc = false;
check_new = false;
{
/* if the first unseen message we encounter was in the m during the
last visit, don't notify about it */
- if (!C_MailCheckRecent || mh_already_notified(m, i) == 0)
+ if (!C_MailCheckRecent || (mh_already_notified(m, i) == 0))
{
m->has_new = true;
rc = true;
}
}
- if (i == -1 && stat(buf, &st_cur) == -1)
+ if ((i == -1) && (stat(buf, &st_cur) == -1))
modified = true;
if ((mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &m->mtime) > 0) ||
return list;
}
- if (len != (size_t)(-1) && len <= INS_SORT_THRESHOLD)
+ if ((len != (size_t)(-1)) && (len <= INS_SORT_THRESHOLD))
return maildir_ins_sort(list, cmp);
list = list->next;
void *data = mutt_hcache_fetch(hc, key, keylen);
struct timeval *when = data;
- if (data && !ret && lastchanged.st_mtime <= when->tv_sec)
+ if (data && !ret && (lastchanged.st_mtime <= when->tv_sec))
{
struct Email *e = mutt_hcache_restore((unsigned char *) data);
e->old = p->email->old;
* lose flag modifications.
*/
- if (m->magic == MUTT_MH && rc == 0)
+ if ((m->magic == MUTT_MH) && (rc == 0))
{
char newpath[PATH_MAX];
snprintf(newpath, sizeof(newpath), "%s/%s", m->path, e->path);
else
mx_msg_close(m, &dest);
- if (rc == -1 && restore)
+ if ((rc == -1) && restore)
{
e->content->offset = old_body_offset;
e->content->length = old_body_length;
const int old_count = m->msg_count;
for (int i = 0, j = 0; i < old_count; i++)
{
- if (m->emails[i]->active && index_hint && *index_hint == i)
+ if (m->emails[i]->active && index_hint && (*index_hint == i))
*index_hint = j;
if (m->emails[i]->active)
struct Email *e = m->emails[msgno];
- if (e->deleted && (m->magic != MUTT_MAILDIR || !C_MaildirTrash))
+ if (e->deleted && ((m->magic != MUTT_MAILDIR) || !C_MaildirTrash))
{
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s/%s", m->path, e->path);
- if (m->magic == MUTT_MAILDIR || (C_MhPurge && m->magic == MUTT_MH))
+ if ((m->magic == MUTT_MAILDIR) || (C_MhPurge && (m->magic == MUTT_MH)))
{
#ifdef USE_HCACHE
if (hc)
}
}
else if (e->changed || e->attach_del ||
- (m->magic == MUTT_MAILDIR && (C_MaildirTrash || e->trash) &&
+ ((m->magic == MUTT_MAILDIR) && (C_MaildirTrash || e->trash) &&
(e->deleted != e->trash)))
{
if (m->magic == MUTT_MAILDIR)
new_hits > cur_hits ? "new" : "cur", newname);
if (fp || (errno != ENOENT))
{
- if (new_hits < UINT_MAX && cur_hits < UINT_MAX)
+ if ((new_hits < UINT_MAX) && (cur_hits < UINT_MAX))
{
new_hits += (new_hits > cur_hits ? 1 : 0);
cur_hits += (new_hits > cur_hits ? 0 : 1);
new_hits > cur_hits ? "cur" : "new", newname);
if (fp || (errno != ENOENT))
{
- if (new_hits < UINT_MAX && cur_hits < UINT_MAX)
+ if ((new_hits < UINT_MAX) && (cur_hits < UINT_MAX))
{
new_hits += (new_hits > cur_hits ? 0 : 1);
cur_hits += (new_hits > cur_hits ? 1 : 0);
*/
int maildir_ac_add(struct Account *a, struct Mailbox *m)
{
- if (!a || !m || (m->magic != MUTT_MAILDIR && m->magic != MUTT_MH))
+ if (!a || !m || ((m->magic != MUTT_MAILDIR) && (m->magic != MUTT_MH)))
return -1;
return 0;
}
return i;
#ifdef USE_HCACHE
- if (m->magic == MUTT_MAILDIR || m->magic == MUTT_MH)
+ if ((m->magic == MUTT_MAILDIR) || (m->magic == MUTT_MH))
hc = mutt_hcache_open(C_HeaderCache, m->path, NULL);
#endif
}
#ifdef USE_HCACHE
- if (m->magic == MUTT_MAILDIR || m->magic == MUTT_MH)
+ if ((m->magic == MUTT_MAILDIR) || (m->magic == MUTT_MH))
mutt_hcache_close(hc);
#endif
{
for (i = 0, j = 0; i < m->msg_count; i++)
{
- if (!m->emails[i]->deleted || (m->magic == MUTT_MAILDIR && C_MaildirTrash))
+ if (!m->emails[i]->deleted || ((m->magic == MUTT_MAILDIR) && C_MaildirTrash))
m->emails[i]->index = j++;
}
}
err:
#ifdef USE_HCACHE
- if (m->magic == MUTT_MAILDIR || m->magic == MUTT_MH)
+ if ((m->magic == MUTT_MAILDIR) || (m->magic == MUTT_MH))
mutt_hcache_close(hc);
#endif
return -1;
goto main_curses;
}
else if (subject || msg || sendflags || draft_file || include_file ||
- !STAILQ_EMPTY(&attach) || optind < argc)
+ !STAILQ_EMPTY(&attach) || (optind < argc))
{
FILE *fp_in = NULL;
FILE *fp_out = NULL;
if (loc < 0)
return -1;
- if (e->content->length > 0 && e->lines > 0)
+ if ((e->content->length > 0) && (e->lines > 0))
{
tmploc = loc + e->content->length;
if ((tmploc > 0) && (tmploc < m->size))
{
- if (fseeko(adata->fp, tmploc, SEEK_SET) != 0 ||
+ if ((fseeko(adata->fp, tmploc, SEEK_SET) != 0) ||
!fgets(buf, sizeof(buf) - 1, adata->fp) ||
(mutt_str_strcmp(MMDF_SEP, buf) != 0))
{
/* check to see if the content-length looks valid. we expect to
* to see a valid message separator at this point in the stream
*/
- if (fseeko(adata->fp, tmploc, SEEK_SET) != 0 ||
+ if ((fseeko(adata->fp, tmploc, SEEK_SET) != 0) ||
!fgets(buf, sizeof(buf), adata->fp) ||
!mutt_str_startswith(buf, "From ", CASE_MATCH))
{
if (found)
{
/* this is best done here */
- if (index_hint && *index_hint == j)
+ if (index_hint && (*index_hint == j))
*index_hint = i;
if (old_hdrs[j]->changed)
/* When $mbox_check_recent is set, existing new mail is ignored, so do not
* reset the atime to mtime-1 to signal new mail.
*/
- if (!C_MailCheckRecent && utimebuf.actime >= utimebuf.modtime && mbox_has_new(m))
+ if (!C_MailCheckRecent && (utimebuf.actime >= utimebuf.modtime) && mbox_has_new(m))
{
utimebuf.actime = utimebuf.modtime - 1;
}
*/
int mbox_ac_add(struct Account *a, struct Mailbox *m)
{
- if (!a || !m || m->magic != MUTT_MBOX)
+ if (!a || !m || (m->magic != MUTT_MBOX))
return -1;
return 0;
}
if (stat(m->path, &st) == 0)
{
if ((mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &m->mtime) == 0) &&
- st.st_size == m->size)
+ (st.st_size == m->size))
{
return 0;
}
mutt_debug(LL_DEBUG1, "#1 fseek() failed\n");
if (fgets(buf, sizeof(buf), adata->fp))
{
- if ((m->magic == MUTT_MBOX && mutt_str_startswith(buf, "From ", CASE_MATCH)) ||
- (m->magic == MUTT_MMDF && (mutt_str_strcmp(buf, MMDF_SEP) == 0)))
+ if (((m->magic == MUTT_MBOX) && mutt_str_startswith(buf, "From ", CASE_MATCH)) ||
+ ((m->magic == MUTT_MMDF) && (mutt_str_strcmp(buf, MMDF_SEP) == 0)))
{
if (fseeko(adata->fp, m->size, SEEK_SET) != 0)
mutt_debug(LL_DEBUG1, "#2 fseek() failed\n");
return -1;
}
- if (fseeko(adata->fp, offset, SEEK_SET) != 0 || /* seek the append location */
+ if ((fseeko(adata->fp, offset, SEEK_SET) != 0) || /* seek the append location */
/* do a sanity check to make sure the mailbox looks ok */
!fgets(buf, sizeof(buf), adata->fp) ||
- (m->magic == MUTT_MBOX && !mutt_str_startswith(buf, "From ", CASE_MATCH)) ||
- (m->magic == MUTT_MMDF && (mutt_str_strcmp(MMDF_SEP, buf) != 0)))
+ ((m->magic == MUTT_MBOX) && !mutt_str_startswith(buf, "From ", CASE_MATCH)) ||
+ ((m->magic == MUTT_MMDF) && (mutt_str_strcmp(MMDF_SEP, buf) != 0)))
{
mutt_debug(LL_DEBUG1, "message not in expected position.\n");
mutt_debug(LL_DEBUG1, "\tLINE: %s\n", buf);
fp = NULL;
mbox_unlock_mailbox(m);
- if (mutt_file_fclose(&adata->fp) != 0 || i == -1)
+ if ((mutt_file_fclose(&adata->fp) != 0) || (i == -1))
{
/* error occurred while writing the mailbox back, so keep the temp copy
* around
mutt_file_fclose(&fp);
/* restore offsets, as far as they are valid */
- if (first >= 0 && old_offset)
+ if ((first >= 0) && old_offset)
{
for (i = first; (i < m->msg_count) && old_offset[i - first].valid; i++)
{
m->size = (off_t) sb.st_size;
}
- if (m->newly_created && (sb.st_ctime != sb.st_mtime || sb.st_ctime != sb.st_atime))
+ if (m->newly_created && ((sb.st_ctime != sb.st_mtime) || (sb.st_ctime != sb.st_atime)))
m->newly_created = false;
if (mutt_file_stat_timespec_compare(&sb, MUTT_STAT_MTIME, &m->stats_last_checked) > 0)
int c = MIN(C_MenuContext, menu->pagelen / 2);
int old_top = menu->top;
- if (!C_MenuMoveOff && menu->max <= menu->pagelen) /* less entries than lines */
+ if (!C_MenuMoveOff && (menu->max <= menu->pagelen)) /* less entries than lines */
{
if (menu->top != 0)
{
mutt_unget_event(LastKey, 0);
char buf[128];
buf[0] = '\0';
- if (mutt_get_field(_("Jump to: "), buf, sizeof(buf), 0) == 0 && buf[0])
+ if ((mutt_get_field(_("Jump to: "), buf, sizeof(buf), 0) == 0) && buf[0])
{
- if (mutt_str_atoi(buf, &n) == 0 && n > 0 && n < menu->max + 1)
+ if ((mutt_str_atoi(buf, &n) == 0) && (n > 0) && (n < menu->max + 1))
{
n--; /* msg numbers are 0-based */
menu->current = n;
{
int c = MIN(C_MenuContext, menu->pagelen / 2);
- if (menu->top + 1 < menu->max - c &&
- (C_MenuMoveOff || (menu->max > menu->pagelen && menu->top < menu->max - menu->pagelen)))
+ if ((menu->top + 1 < menu->max - c) &&
+ (C_MenuMoveOff ||
+ ((menu->max > menu->pagelen) && (menu->top < menu->max - menu->pagelen))))
{
menu->top++;
- if (menu->current < menu->top + c && menu->current < menu->max - 1)
+ if ((menu->current < menu->top + c) && (menu->current < menu->max - 1))
menu->current++;
menu->redraw = REDRAW_INDEX;
}
int c = MIN(C_MenuContext, menu->pagelen / 2);
menu->top--;
- if (menu->current >= menu->top + menu->pagelen - c && menu->current > 1)
+ if ((menu->current >= menu->top + menu->pagelen - c) && (menu->current > 1))
menu->current--;
menu->redraw = REDRAW_INDEX;
}
menu->top += jumplen;
/* jumped too long? */
- if ((neg || !C_MenuMoveOff) && DIRECTION * menu->top > tmp)
+ if ((neg || !C_MenuMoveOff) && (DIRECTION * menu->top > tmp))
menu->top = tmp;
/* need to move the cursor? */
menu->redraw = REDRAW_INDEX;
}
- else if (menu->current != (neg ? 0 : menu->max - 1) && !menu->dialog)
+ else if ((menu->current != (neg ? 0 : menu->max - 1)) && !menu->dialog)
{
menu->current += jumplen;
menu->redraw = REDRAW_MOTION;
char *search_buf =
menu->menu >= 0 && menu->menu < MENU_MAX ? SearchBuffers[menu->menu] : NULL;
- if (!(search_buf && *search_buf) || (op != OP_SEARCH_NEXT && op != OP_SEARCH_OPPOSITE))
+ if (!(search_buf && *search_buf) || ((op != OP_SEARCH_NEXT) && (op != OP_SEARCH_OPPOSITE)))
{
mutt_str_strfcpy(buf, search_buf && *search_buf ? search_buf : "", sizeof(buf));
- if (mutt_get_field((op == OP_SEARCH || op == OP_SEARCH_NEXT) ?
- _("Search for: ") :
- _("Reverse search for: "),
- buf, sizeof(buf), MUTT_CLEAR) != 0 ||
+ if ((mutt_get_field(((op == OP_SEARCH) || (op == OP_SEARCH_NEXT)) ?
+ _("Search for: ") :
+ _("Reverse search for: "),
+ buf, sizeof(buf), MUTT_CLEAR) != 0) ||
!buf[0])
{
return -1;
}
- if (menu->menu >= 0 && menu->menu < MENU_MAX)
+ if ((menu->menu >= 0) && (menu->menu < MENU_MAX))
{
mutt_str_replace(&SearchBuffers[menu->menu], buf);
search_buf = SearchBuffers[menu->menu];
rc += search_dir;
}
- if (C_WrapSearch && wrap++ == 0)
+ if (C_WrapSearch && (wrap++ == 0))
{
rc = search_dir == 1 ? 0 : menu->max - 1;
goto search_next;
/* Clear the tag prefix unless we just started it. Don't clear
* the prefix on a timeout (i==-2), but do clear on an abort (i==-1)
*/
- if (menu->tagprefix && i != OP_TAG_PREFIX && i != OP_TAG_PREFIX_COND && i != -2)
+ if (menu->tagprefix && (i != OP_TAG_PREFIX) && (i != OP_TAG_PREFIX_COND) && (i != -2))
menu->tagprefix = false;
mutt_curs_set(0);
mutt_refresh();
/* try to catch dialog keys before ops */
- if (menu->dialog && menu_dialog_dokey(menu, &i) == 0)
+ if (menu->dialog && (menu_dialog_dokey(menu, &i) == 0))
return i;
i = km_dokey(menu->menu);
- if (i == OP_TAG_PREFIX || i == OP_TAG_PREFIX_COND)
+ if ((i == OP_TAG_PREFIX) || (i == OP_TAG_PREFIX_COND))
{
if (menu->tagprefix)
{
{
int j = menu->menu_tag(menu, menu->current, -1);
menu->tagged += j;
- if (j && C_Resolve && menu->current < menu->max - 1)
+ if (j && C_Resolve && (menu->current < menu->max - 1))
{
menu->current++;
menu->redraw |= REDRAW_MOTION_RESYNC;
uint32_t mask = info.isdir ? INOTIFY_MASK_DIR : INOTIFY_MASK_FILE;
if (((INotifyFd == -1) && (monitor_init() == -1)) ||
- (desc = inotify_add_watch(INotifyFd, info.path, mask)) == -1)
+ ((desc = inotify_add_watch(INotifyFd, info.path, mask)) == -1))
{
mutt_debug(LL_DEBUG2, "inotify_add_watch failed for '%s', errno=%d %s\n",
info.path, errno, strerror(errno));
/* catch some common iso-8859-something misspellings */
size_t plen;
- if ((plen = mutt_str_startswith(in, "8859", CASE_IGNORE)) && in[plen] != '-')
+ if ((plen = mutt_str_startswith(in, "8859", CASE_IGNORE)) && (in[plen] != '-'))
snprintf(scratch, sizeof(scratch), "iso-8859-%s", in + plen);
else if ((plen = mutt_str_startswith(in, "8859-", CASE_IGNORE)))
snprintf(scratch, sizeof(scratch), "iso-8859-%s", in + plen);
- else if ((plen = mutt_str_startswith(in, "iso8859", CASE_IGNORE)) && in[plen] != '-')
+ else if ((plen = mutt_str_startswith(in, "iso8859", CASE_IGNORE)) && (in[plen] != '-'))
snprintf(scratch, sizeof(scratch), "iso_8859-%s", in + plen);
else if ((plen = mutt_str_startswith(in, "iso8859-", CASE_IGNORE)))
snprintf(scratch, sizeof(scratch), "iso_8859-%s", in + plen);
if (iconverrno)
*iconverrno = errno;
- if (ibl && obl && errno == EILSEQ)
+ if (ibl && obl && (errno == EILSEQ))
{
if (inrepls)
{
* ask why it had stopped converting ... */
/* Try to read some more */
- if (fc->ibl == sizeof(fc->bufi) ||
- (fc->ibl && fc->ib + fc->ibl < fc->bufi + sizeof(fc->bufi)))
+ if ((fc->ibl == sizeof(fc->bufi)) ||
+ (fc->ibl && (fc->ib + fc->ibl < fc->bufi + sizeof(fc->bufi))))
{
fc->p = 0;
return EOF;
/* The leap years are 1972 and every 4. year until 2096,
* but this algorithm will fail after year 2099 */
g += t->tm_mday;
- if ((t->tm_year % 4) || t->tm_mon < 2)
+ if ((t->tm_year % 4) || (t->tm_mon < 2))
g--;
t->tm_yday = g;
*/
ptz = uncomment_timezone(tzstr, sizeof(tzstr), t);
- if (*ptz == '+' || *ptz == '-')
+ if ((*ptz == '+') || (*ptz == '-'))
{
if (ptz[1] && ptz[2] && ptz[3] && ptz[4] &&
isdigit((unsigned char) ptz[1]) && isdigit((unsigned char) ptz[2]) &&
while (envp && *envp)
{
size_t len = mutt_str_startswith(*envp, name, CASE_MATCH);
- if ((len != 0) && (*envp)[len] == '=')
+ if ((len != 0) && ((*envp)[len] == '='))
{
if (!overwrite)
return false;
while (envp && *envp)
{
size_t len = mutt_str_startswith(*envp, name, CASE_MATCH);
- if ((len != 0) && (*envp)[len] == '=')
+ if ((len != 0) && ((*envp)[len] == '='))
{
/* shuffle down */
char **save = envp++;
/* FUSE may return ENOSYS. VFAT may return EPERM. FreeBSD's
* msdosfs may return EOPNOTSUPP. ENOTSUP can also appear. */
- if (errno == EXDEV || errno == ENOSYS || errno == EPERM
+ if ((errno == EXDEV) || (errno == ENOSYS) || errno == EPERM
#ifdef ENOTSUP
|| errno == ENOTSUP
#endif
return fd;
/* make sure the file is not symlink */
- if ((lstat(path, &osb) < 0 || fstat(fd, &nsb) < 0) || !compare_stat(&osb, &nsb))
+ if (((lstat(path, &osb) < 0) || (fstat(fd, &nsb) < 0)) || !compare_stat(&osb, &nsb))
{
close(fd);
return -1;
return;
}
- if (fstat(fd, &sb) == 0 && sb.st_size == 0)
+ if ((fstat(fd, &sb) == 0) && (sb.st_size == 0))
unlink(path);
mutt_file_unlock(fd);
while (ptr)
{
- if ((data == ptr->data || !data) && table->cmp_key(ptr->key, key) == 0)
+ if (((data == ptr->data) || !data) && (table->cmp_key(ptr->key, key) == 0))
{
*last = ptr->next;
if (table->elem_free)
line = 0;
while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, 0)))
{
- if (sscanf(linebuf, "%d:%n", &hclass, &read) < 1 || read == 0 ||
- *(p = linebuf + strlen(linebuf) - 1) != '|' || hclass < 0)
+ if ((sscanf(linebuf, "%d:%n", &hclass, &read) < 1) || (read == 0) ||
+ (*(p = linebuf + strlen(linebuf) - 1) != '|') || (hclass < 0))
{
mutt_error(_("Bad history file format (line %d)"), line);
goto cleanup;
line = 0;
while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, 0)))
{
- if (sscanf(linebuf, "%d:%n", &hclass, &read) < 1 || read == 0 ||
- *(p = linebuf + strlen(linebuf) - 1) != '|' || hclass < 0)
+ if ((sscanf(linebuf, "%d:%n", &hclass, &read) < 1) || (read == 0) ||
+ (*(p = linebuf + strlen(linebuf) - 1) != '|') || (hclass < 0))
{
mutt_error(_("Bad history file format (line %d)"), line);
goto cleanup;
while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, 0)))
{
read = 0;
- if (sscanf(linebuf, "%d:%n", &hclass, &read) < 1 || read == 0 ||
- *(p = linebuf + strlen(linebuf) - 1) != '|' || hclass < 0)
+ if ((sscanf(linebuf, "%d:%n", &hclass, &read) < 1) || (read == 0) ||
+ (*(p = linebuf + strlen(linebuf) - 1) != '|') || (hclass < 0))
{
mutt_error(_("Bad history file format (line %d)"), line);
break;
struct ListNode *np = NULL;
STAILQ_FOREACH(np, h, entries)
{
- if (np->data == data || mutt_str_strcmp(np->data, data) == 0)
+ if ((np->data == data) || (mutt_str_strcmp(np->data, data) == 0))
{
return np;
}
l = 1;
/* correctly calc tab stop, even for sending as the
* line should look pretty on the receiving end */
- if (wc == L'\t' || (nl && wc == L' '))
+ if ((wc == L'\t') || (nl && (wc == L' ')))
{
nl = 0;
l = 8 - (col % 8);
int mutt_mb_wcwidth(wchar_t wc)
{
int n = wcwidth(wc);
- if (IsWPrint(wc) && n > 0)
+ if (IsWPrint(wc) && (n > 0))
return n;
if (!(wc & ~0x7f))
return 2;
}
wbuf[i++] = wc;
}
- if (*buf && (k == (size_t) -1 || k == (size_t) -2))
+ if (*buf && ((k == (size_t) -1) || (k == (size_t) -2)))
{
if (i >= wbuflen)
{
if (len == 0)
return false;
- if (buf[len] != '/' && buf[len] != '\0')
+ if ((buf[len] != '/') && (buf[len] != '\0'))
return false;
buf[0] = '~';
{
const char *fmt = "%s/%s";
- if (!*fname || (*dir && dir[strlen(dir) - 1] == '/'))
+ if (!*fname || (*dir && (dir[strlen(dir) - 1] == '/')))
fmt = "%s%s";
snprintf(d, l, fmt, dir, fname);
if (buf && buflen)
buf[0] = '\0';
- if (!str || *str == '\0' || (buf && !buflen))
+ if (!str || (*str == '\0') || (buf && !buflen))
return buf;
twinbuf[0][0] = '\0';
/* Ensure that the integer conversion succeeded (e!=p) and bounds check. The upper bound check
* should not strictly be necessary since add_to_spam_list() finds the largest value, and
* the static array above is always large enough based on that value. */
- if (e != p && n >= 0 && n <= np->nmatch && pmatch[n].rm_so != -1)
+ if ((e != p) && (n >= 0) && (n <= np->nmatch) && (pmatch[n].rm_so != -1))
{
/* copy as much of the substring match as will fit in the output buffer, saving space for
* the terminating nul char */
}
}
- if (len != 0 && strchr("\r\n", *(p - 1))) /* LWS doesn't end with CRLF */
+ if ((len != 0) && strchr("\r\n", *(p - 1))) /* LWS doesn't end with CRLF */
len = 0;
return len;
}
mutt_file_fclose(&fp);
mutt_wait_filter(pid);
- if (!token || *token == '\0')
+ if (!token || (*token == '\0'))
{
mutt_error(_("Command returned empty string"));
FREE(&token);
if (r == -1)
mutt_error(_("Error running \"%s\""), cmd);
- if (r != -1 && entry->composetypecommand)
+ if ((r != -1) && entry->composetypecommand)
{
struct Body *b = NULL;
char tempfile[PATH_MAX];
STAILQ_FOREACH(np, &MimeLookupList, entries)
{
const int i = mutt_str_strlen(np->data) - 1;
- if ((i > 0 && np->data[i - 1] == '/' && np->data[i] == '*' &&
+ if (((i > 0) && (np->data[i - 1] == '/') && (np->data[i] == '*') &&
(mutt_str_strncasecmp(type, np->data, i) == 0)) ||
(mutt_str_strcasecmp(type, np->data) == 0))
{
if (mutt_wait_filter(pid) != 0)
rc = 0;
- if (rc == 0 || C_WaitKey)
+ if ((rc == 0) || C_WaitKey)
mutt_any_key_to_continue(NULL);
return rc;
}
{
/* recv mode */
- if (e && m->email && m->encoding != ENC_BASE64 && m->encoding != ENC_QUOTED_PRINTABLE &&
- mutt_is_message_type(m->type, m->subtype))
+ if (e && m->email && (m->encoding != ENC_BASE64) &&
+ (m->encoding != ENC_QUOTED_PRINTABLE) && mutt_is_message_type(m->type, m->subtype))
{
/* message type attachments are written to mail folders. */
mutt_file_fclose(&fp_out);
mutt_file_fclose(&fp_in);
- if (mutt_wait_filter(pid) != 0 || C_WaitKey)
+ if ((mutt_wait_filter(pid) != 0) || C_WaitKey)
mutt_any_key_to_continue(NULL);
rc = 1;
}
a = (struct AttachMatch *) np->data;
mutt_debug(LL_DEBUG3, "%s %d/%s ?? %s/%s [%d]... ", dflt ? "[OK] " : "[EXCL] ",
b->type, b->subtype ? b->subtype : "*", a->major, a->minor, a->major_int);
- if ((a->major_int == TYPE_ANY || a->major_int == b->type) &&
+ if (((a->major_int == TYPE_ANY) || (a->major_int == b->type)) &&
(!b->subtype || !regexec(&a->minor_regex, b->subtype, 0, NULL, 0)))
{
mutt_debug(LL_DEBUG3, "yes\n");
shallcount = false; /* top-level multipart */
}
- if (bp->disposition == DISP_INLINE && bp->type != TYPE_MULTIPART &&
- bp->type != TYPE_MESSAGE && bp == body)
+ if ((bp->disposition == DISP_INLINE) && (bp->type != TYPE_MULTIPART) &&
+ (bp->type != TYPE_MESSAGE) && (bp == body))
{
shallcount = false; /* ignore fundamental inlines */
}
tree = ctx->tree;
while (true)
{
- if (!tree->visible && tree->deep && tree->subtree_visible < 2 &&
+ if (!tree->visible && tree->deep && (tree->subtree_visible < 2) &&
((tree->message && hide_top_limited) || (!tree->message && hide_top_missing)))
{
tree->deep = false;
if (depth)
{
myarrow = arrow + (depth - start_depth - (start_depth ? 0 : 1)) * width;
- if (depth && start_depth == depth)
+ if (depth && (start_depth == depth))
myarrow[0] = nextdisp ? MUTT_TREE_LTEE : corner;
else if (parent->message && !C_HideLimited)
myarrow[0] = MUTT_TREE_HIDDEN;
if (dateptr)
{
thisdate = C_ThreadReceived ? cur->message->received : cur->message->date_sent;
- if (!*dateptr || thisdate < *dateptr)
+ if (!*dateptr || (thisdate < *dateptr))
*dateptr = thisdate;
}
for (ptr = mutt_hash_find_bucket(m->subj_hash, np->data); ptr; ptr = ptr->next)
{
tmp = ((struct Email *) ptr->data)->thread;
- if (tmp != cur && /* don't match the same message */
+ if ((tmp != cur) && /* don't match the same message */
!tmp->fake_thread && /* don't match pseudo threads */
tmp->message->subject_changed && /* only match interesting replies */
!is_descendant(tmp, cur) && /* don't match in the same thread */
* but only do this if they have the same real subject as the
* parent, since otherwise they rightly belong to the message
* we're attaching. */
- if (tmp == cur || (mutt_str_strcmp(tmp->message->env->real_subj,
- parent->message->env->real_subj) == 0))
+ if ((tmp == cur) || (mutt_str_strcmp(tmp->message->env->real_subj,
+ parent->message->env->real_subj) == 0))
{
tmp->message->subject_changed = false;
unlink_message(&top.child, thread);
insert_message(&new->child, new, thread);
thread = new;
- if (thread->message || (thread->parent && thread->parent != &top))
+ if (thread->message || (thread->parent && (thread->parent != &top)))
break;
}
int min_unread_msgno = INT_MAX, min_unread = cur->virtual;
#define CHECK_LIMIT (!ctx->pattern || cur->limited)
- if ((C_Sort & SORT_MASK) != SORT_THREADS && !(flag & MUTT_THREAD_GET_HIDDEN))
+ if (((C_Sort & SORT_MASK) != SORT_THREADS) && !(flag & MUTT_THREAD_GET_HIDDEN))
{
mutt_error(_("Threading is not enabled"));
return cur->virtual;
if (cur->flagged && CHECK_LIMIT)
flagged = true;
- if (cur->virtual == -1 && CHECK_LIMIT)
+ if ((cur->virtual == -1) && CHECK_LIMIT)
num_hidden++;
if (flag & (MUTT_THREAD_COLLAPSE | MUTT_THREAD_UNCOLLAPSE))
if (cur->flagged && CHECK_LIMIT)
flagged = true;
- if (cur->virtual == -1 && CHECK_LIMIT)
+ if ((cur->virtual == -1) && CHECK_LIMIT)
num_hidden++;
}
struct MuttThread *threads[2];
int rc;
- if ((C_Sort & SORT_MASK) != SORT_THREADS || !e->thread)
+ if (((C_Sort & SORT_MASK) != SORT_THREADS) || !e->thread)
return 1;
threads[0] = e->thread;
mutt_buffer_printf(buf, "%s/%s", NONULL(C_Tmpdir), mutt_b2s(prefix));
struct stat sb;
- if (lstat(mutt_b2s(buf), &sb) == -1 && errno == ENOENT)
+ if ((lstat(mutt_b2s(buf), &sb) == -1) && (errno == ENOENT))
goto out;
char *suffix = strrchr(prefix->data, '.');
mutt_file_sanitize_filename(prefix, true);
snprintf(buf, buflen, "%s/%s", NONULL(C_Tmpdir), prefix);
struct stat sb;
- if (lstat(buf, &sb) == -1 && errno == ENOENT)
+ if ((lstat(buf, &sb) == -1) && (errno == ENOENT))
return;
char *suffix = strrchr(prefix, '.');
{
case '~':
{
- if (*(buf + 1) == '/' || *(buf + 1) == 0)
+ if ((*(buf + 1) == '/') || (*(buf + 1) == 0))
{
mutt_str_strfcpy(p, HomeDir, sizeof(p));
tail = buf + 1;
enum MailboxType mb_type = mx_path_probe(C_Folder, NULL);
/* if folder = {host} or imap[s]://host/: don't append slash */
- if ((mb_type == MUTT_IMAP) && (C_Folder[strlen(C_Folder) - 1] == '}' ||
- C_Folder[strlen(C_Folder) - 1] == '/'))
+ if ((mb_type == MUTT_IMAP) && ((C_Folder[strlen(C_Folder) - 1] == '}') ||
+ (C_Folder[strlen(C_Folder) - 1] == '/')))
{
mutt_str_strfcpy(p, C_Folder, sizeof(p));
}
else if (mb_type == MUTT_NOTMUCH)
mutt_str_strfcpy(p, C_Folder, sizeof(p));
- else if (C_Folder && *C_Folder && C_Folder[strlen(C_Folder) - 1] == '/')
+ else if (C_Folder && *C_Folder && (C_Folder[strlen(C_Folder) - 1] == '/'))
mutt_str_strfcpy(p, C_Folder, sizeof(p));
else
snprintf(p, sizeof(p), "%s/", NONULL(C_Folder));
return true;
}
- if (((WithCrypto & APPLICATION_PGP) != 0) && t == TYPE_APPLICATION)
+ if (((WithCrypto & APPLICATION_PGP) != 0) && (t == TYPE_APPLICATION))
{
if (mutt_str_strcasecmp("pgp-keys", s) == 0)
return true;
NONULL(C_Hostname), (int) getuid(), (int) getpid(),
random(), random(), suffix ? "." : "", NONULL(suffix));
mutt_debug(LL_DEBUG3, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, mutt_b2s(buf));
- if (unlink(mutt_b2s(buf)) && errno != ENOENT)
+ if (unlink(mutt_b2s(buf)) && (errno != ENOENT))
{
mutt_debug(LL_DEBUG1, "%s:%d: ERROR: unlink(\"%s\"): %s (errno %d)\n", src,
line, mutt_b2s(buf), strerror(errno), errno);
src, line, buflen, n);
}
mutt_debug(LL_DEBUG3, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, buf);
- if (unlink(buf) && errno != ENOENT)
+ if (unlink(buf) && (errno != ENOENT))
{
mutt_debug(LL_DEBUG1, "%s:%d: ERROR: unlink(\"%s\"): %s (errno %d)\n", src,
line, buf, strerror(errno), errno);
scheme = url_check_scheme(buf);
- if (scheme == U_IMAP || scheme == U_IMAPS)
+ if ((scheme == U_IMAP) || (scheme == U_IMAPS))
{
imap_pretty_mailbox(buf, C_Folder);
return;
*/
while (*p)
{
- if (*p == '/' && p[1] == '/')
+ if ((*p == '/') && (p[1] == '/'))
{
*q++ = '/';
p += 2;
}
- else if (p[0] == '/' && p[1] == '.' && p[2] == '/')
+ else if ((p[0] == '/') && (p[1] == '.') && (p[2] == '/'))
{
*q++ = '/';
p += 3;
}
*q = 0;
}
- else if (strstr(p, "..") && (scheme == U_UNKNOWN || scheme == U_FILE) && realpath(p, tmp))
+ else if (strstr(p, "..") && ((scheme == U_UNKNOWN) || (scheme == U_FILE)) &&
+ realpath(p, tmp))
mutt_str_strfcpy(p, tmp, buflen - (p - buf));
- if ((len = mutt_str_startswith(buf, C_Folder, CASE_MATCH)) && buf[len] == '/')
+ if ((len = mutt_str_startswith(buf, C_Folder, CASE_MATCH)) && (buf[len] == '/'))
{
*buf++ = '=';
memmove(buf, buf + len, mutt_str_strlen(buf + len) + 1);
}
- else if ((len = mutt_str_startswith(buf, HomeDir, CASE_MATCH)) && buf[len] == '/')
+ else if ((len = mutt_str_startswith(buf, HomeDir, CASE_MATCH)) && (buf[len] == '/'))
{
*buf++ = '~';
memmove(buf, buf + len - 1, mutt_str_strlen(buf + len - 1) + 1);
char tmp[PATH_MAX];
mutt_str_strfcpy(tmp, mutt_path_basename(NONULL(attname)), sizeof(tmp));
- if (mutt_get_field(_("File under directory: "), tmp, sizeof(tmp),
- MUTT_FILE | MUTT_CLEAR) != 0 ||
+ if ((mutt_get_field(_("File under directory: "), tmp, sizeof(tmp),
+ MUTT_FILE | MUTT_CLEAR) != 0) ||
!tmp[0])
{
return -1;
mutt_path_concat(fname, path, tmp, flen);
}
- if ((*opt == MUTT_SAVE_NO_FLAGS) && access(fname, F_OK) == 0)
+ if ((*opt == MUTT_SAVE_NO_FLAGS) && (access(fname, F_OK) == 0))
{
switch (
mutt_multi_choice(_("File exists, (o)verwrite, (a)ppend, or (c)ancel?"),
/* Do not consider filters if no pipe at end */
int n = mutt_str_strlen(src);
- if (n > 1 && src[n - 1] == '|')
+ if ((n > 1) && (src[n - 1] == '|'))
{
/* Scan backwards for backslashes */
off = n;
/* If number of backslashes is even, the pipe is real. */
/* n-off is the number of backslashes. */
- if (off > 0 && ((n - off) % 2) == 0)
+ if ((off > 0) && (((n - off) % 2) == 0))
{
char srccopy[1024];
int i = 0;
* generated %-tokens that neomutt can expand. Eliminate the '%'
* marker and recycle the string through mutt_expando_format().
* To literally end with "%", use "%%". */
- if ((n > 0) && buf[n - 1] == '%')
+ if ((n > 0) && (buf[n - 1] == '%'))
{
n--;
buf[n] = '\0'; /* remove '%' */
- if ((n > 0) && buf[n - 1] != '%')
+ if ((n > 0) && (buf[n - 1] != '%'))
{
recycler = mutt_str_strdup(buf);
if (recycler)
}
/* handle generic cases first */
- if (ch == '>' || ch == '*')
+ if ((ch == '>') || (ch == '*'))
{
/* %>X: right justify to EOL, left takes precedence
* %*X: right justify to EOL, right takes precedence */
}
/* see if there's room to add content, else ignore */
- if ((col < cols && wlen < buflen) || soft)
+ if (((col < cols) && (wlen < buflen)) || soft)
{
int pad;
}
/* see if there's room to add content, else ignore */
- if (col < cols && wlen < buflen)
+ if ((col < cols) && (wlen < buflen))
{
int c = (cols - col) / pw;
- if (c > 0 && wlen + (c * pl) > buflen)
+ if ((c > 0) && (wlen + (c * pl) > buflen))
c = ((signed) (buflen - wlen)) / pl;
while (c > 0)
{
int mutt_inbox_cmp(const char *a, const char *b)
{
/* fast-track in case the paths have been mutt_pretty_mailbox'ified */
- if (a[0] == '+' && b[0] == '+')
+ if ((a[0] == '+') && (b[0] == '+'))
{
return (mutt_str_strcasecmp(a + 1, "inbox") == 0) ?
-1 :
{
if (m->magic == MUTT_MAILBOX_ERROR)
mutt_perror(m->path);
- else if (m->magic == MUTT_UNKNOWN || !m->mx_ops)
+ else if ((m->magic == MUTT_UNKNOWN) || !m->mx_ops)
mutt_error(_("%s is not a mailbox"), m->path);
mx_fastclose_mailbox(m);
struct stat st, stc;
int opt_confappend, rc;
- if (!C_Trash || (m->msg_deleted == 0) || (m->magic == MUTT_MAILDIR && C_MaildirTrash))
+ if (!C_Trash || (m->msg_deleted == 0) || ((m->magic == MUTT_MAILDIR) && C_MaildirTrash))
{
return 0;
}
return -1;
}
- if (lstat(m->path, &stc) == 0 && stc.st_ino == st.st_ino &&
- stc.st_dev == st.st_dev && stc.st_rdev == st.st_rdev)
+ if ((lstat(m->path, &stc) == 0) && (stc.st_ino == st.st_ino) &&
+ (stc.st_dev == st.st_dev) && (stc.st_rdev == st.st_rdev))
{
return 0; /* we are in the trash folder: simple sync */
}
#ifdef USE_IMAP
- if (m->magic == MUTT_IMAP && (imap_path_probe(C_Trash, NULL) == MUTT_IMAP))
+ if ((m->magic == MUTT_IMAP) && (imap_path_probe(C_Trash, NULL) == MUTT_IMAP))
{
if (imap_fast_trash(m, C_Trash) == 0)
return 0;
/* There is no point in asking whether or not to purge if we are
* just marking messages as "trash".
*/
- if ((m->msg_deleted != 0) && !(m->magic == MUTT_MAILDIR && C_MaildirTrash))
+ if ((m->msg_deleted != 0) && !((m->magic == MUTT_MAILDIR) && C_MaildirTrash))
{
snprintf(buf, sizeof(buf),
ngettext("Purge %d deleted message?", "Purge %d deleted messages?", m->msg_deleted),
{
if (!m->quiet)
mutt_message(_("Mailbox is unchanged"));
- if (m->magic == MUTT_MBOX || m->magic == MUTT_MMDF)
+ if ((m->magic == MUTT_MBOX) || (m->magic == MUTT_MMDF))
mbox_reset_atime(m, NULL);
mx_fastclose_mailbox(m);
FREE(ptr);
if (rc == 0)
{
#ifdef USE_IMAP
- if (m->magic == MUTT_IMAP && !purge)
+ if ((m->magic == MUTT_IMAP) && !purge)
{
if (!m->quiet)
mutt_message(_("Mailbox checkpointed"));
* MH and maildir are safe. mbox-style seems to need re-sorting,
* at least with the new threading code.
*/
- if (purge || (m->magic != MUTT_MAILDIR && m->magic != MUTT_MH))
+ if (purge || ((m->magic != MUTT_MAILDIR) && (m->magic != MUTT_MH)))
{
/* IMAP does this automatically after handling EXPUNGE */
if (m->magic != MUTT_IMAP)
if (m->magic == MUTT_MMDF)
fputs(MMDF_SEP, msg->fp);
- if ((m->magic == MUTT_MBOX || m->magic == MUTT_MMDF) && flags & MUTT_ADD_FROM)
+ if (((m->magic == MUTT_MBOX) || (m->magic == MUTT_MMDF)) && flags & MUTT_ADD_FROM)
{
if (e)
{
return -1;
int rc = m->mx_ops->mbox_check(m, index_hint);
- if (rc == MUTT_NEW_MAIL || rc == MUTT_REOPENED)
+ if ((rc == MUTT_NEW_MAIL) || (rc == MUTT_REOPENED))
mutt_mailbox_changed(m, MBN_INVALID);
return rc;
goto bail;
}
/* free tmp_body if messages was signed AND encrypted ... */
- if (tmp_smime_pbody != msg->content && tmp_smime_pbody != tmp_pbody)
+ if ((tmp_smime_pbody != msg->content) && (tmp_smime_pbody != tmp_pbody))
{
/* detach and don't delete msg->content,
which tmp_smime_pbody->parts after signing. */
char *p = NULL;
- if (!b || b->type != TYPE_MULTIPART || !b->subtype ||
+ if (!b || (b->type != TYPE_MULTIPART) || !b->subtype ||
(mutt_str_strcasecmp(b->subtype, "encrypted") != 0) ||
!(p = mutt_param_get(&b->parameter, "protocol")) ||
(mutt_str_strcasecmp(p, "application/pgp-encrypted") != 0))
return 0;
b = b->parts;
- if (!b || b->type != TYPE_APPLICATION || !b->subtype ||
+ if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
(mutt_str_strcasecmp(b->subtype, "pgp-encrypted") != 0))
{
return 0;
}
b = b->next;
- if (!b || b->type != TYPE_APPLICATION || !b->subtype ||
+ if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
(mutt_str_strcasecmp(b->subtype, "octet-stream") != 0))
{
return 0;
if (!(WithCrypto & APPLICATION_PGP))
return 0;
- if (!b || b->type != TYPE_MULTIPART || !b->subtype ||
+ if (!b || (b->type != TYPE_MULTIPART) || !b->subtype ||
(mutt_str_strcasecmp(b->subtype, "mixed") != 0))
{
return 0;
}
b = b->parts;
- if (!b || b->type != TYPE_TEXT || !b->subtype ||
- (mutt_str_strcasecmp(b->subtype, "plain") != 0) || b->length != 0)
+ if (!b || (b->type != TYPE_TEXT) || !b->subtype ||
+ (mutt_str_strcasecmp(b->subtype, "plain") != 0) || (b->length != 0))
{
return 0;
}
b = b->next;
- if (!b || b->type != TYPE_APPLICATION || !b->subtype ||
+ if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
(mutt_str_strcasecmp(b->subtype, "pgp-encrypted") != 0))
{
return 0;
}
b = b->next;
- if (!b || b->type != TYPE_APPLICATION || !b->subtype ||
+ if (!b || (b->type != TYPE_APPLICATION) || !b->subtype ||
(mutt_str_strcasecmp(b->subtype, "octet-stream") != 0))
{
return 0;
if (mutt_str_strcasecmp(m->subtype, "pgp-keys") == 0)
t |= PGP_KEY;
}
- else if (m->type == TYPE_TEXT && (mutt_str_strcasecmp("plain", m->subtype) == 0))
+ else if ((m->type == TYPE_TEXT) && (mutt_str_strcasecmp("plain", m->subtype) == 0))
{
if (((p = mutt_param_get(&m->parameter, "x-mutt-action")) ||
(p = mutt_param_get(&m->parameter, "x-action")) ||
return SEC_NO_FLAGS;
}
/* Netscape 4.7 uses
- * Content-Description: S/MIME Encrypted Message
- * instead of Content-Type parameter
- */
+ * Content-Description: S/MIME Encrypted Message
+ * instead of Content-Type parameter
+ */
if (mutt_str_strcasecmp(m->description, "S/MIME Encrypted Message") == 0)
return SMIME_ENCRYPT;
complain = true;
/* no .p7c, .p10 support yet. */
int len = mutt_str_strlen(t) - 4;
- if (len > 0 && *(t + len) == '.')
+ if ((len > 0) && (*(t + len) == '.'))
{
len++;
if (mutt_str_strcasecmp((t + len), "p7m") == 0)
t |= SEC_BADSIGN;
}
}
- else if (((WithCrypto & APPLICATION_PGP) != 0) && m->type == TYPE_TEXT)
+ else if (((WithCrypto & APPLICATION_PGP) != 0) && (m->type == TYPE_TEXT))
{
t |= mutt_is_application_pgp(m);
if (t && m->goodsig)
t |= SEC_GOODSIGN;
}
- if (m->type == TYPE_MULTIPART || m->type == TYPE_MESSAGE)
+ if ((m->type == TYPE_MULTIPART) || (m->type == TYPE_MESSAGE))
{
int u = m->parts ? 0xffffffff : 0; /* Bits set in all parts */
int w = 0; /* Bits set in any part */
hadcr = true;
else
{
- if (c == '\n' && !hadcr)
+ if ((c == '\n') && !hadcr)
fputc('\r', fp);
hadcr = false;
else if (((WithCrypto & APPLICATION_PGP) != 0) && C_PgpStrictEnc)
crypt_convert_to_7bit(a->parts);
}
- else if (a->type == TYPE_MESSAGE &&
+ else if ((a->type == TYPE_MESSAGE) &&
(mutt_str_strcasecmp(a->subtype, "delivery-status") != 0))
{
if (a->encoding != ENC_7BIT)
a->encoding = ENC_QUOTED_PRINTABLE;
else if (a->encoding == ENC_BINARY)
a->encoding = ENC_BASE64;
- else if (a->content && a->encoding != ENC_BASE64 &&
+ else if (a->content && (a->encoding != ENC_BASE64) &&
(a->content->from || (a->content->space && C_PgpStrictEnc)))
{
a->encoding = ENC_QUOTED_PRINTABLE;
switch (signed_type)
{
case SEC_SIGN:
- if (a->next->type != TYPE_MULTIPART ||
+ if ((a->next->type != TYPE_MULTIPART) ||
(mutt_str_strcasecmp(a->next->subtype, "mixed") != 0))
{
inconsistent = true;
}
break;
case PGP_SIGN:
- if (a->next->type != TYPE_APPLICATION ||
+ if ((a->next->type != TYPE_APPLICATION) ||
(mutt_str_strcasecmp(a->next->subtype, "pgp-signature") != 0))
{
inconsistent = true;
}
break;
case SMIME_SIGN:
- if (a->next->type != TYPE_APPLICATION ||
+ if ((a->next->type != TYPE_APPLICATION) ||
((mutt_str_strcasecmp(a->next->subtype, "x-pkcs7-signature") != 0) &&
(mutt_str_strcasecmp(a->next->subtype, "pkcs7-signature") != 0)))
{
{
for (int i = 0; i < sigcnt; i++)
{
- if (((WithCrypto & APPLICATION_PGP) != 0) && signatures[i]->type == TYPE_APPLICATION &&
+ if (((WithCrypto & APPLICATION_PGP) != 0) &&
+ (signatures[i]->type == TYPE_APPLICATION) &&
(mutt_str_strcasecmp(signatures[i]->subtype, "pgp-signature") == 0))
{
if (crypt_pgp_verify_one(signatures[i], s, tempfile) != 0)
continue;
}
- if (((WithCrypto & APPLICATION_SMIME) != 0) && signatures[i]->type == TYPE_APPLICATION &&
+ if (((WithCrypto & APPLICATION_SMIME) != 0) &&
+ (signatures[i]->type == TYPE_APPLICATION) &&
((mutt_str_strcasecmp(signatures[i]->subtype,
"x-pkcs7-signature") == 0) ||
(mutt_str_strcasecmp(signatures[i]->subtype,
do
{
c = *(s1++);
- if (('0' <= c && c <= '9') || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f'))
+ if ((('0' <= c) && (c <= '9')) || (('A' <= c) && (c <= 'F')) ||
+ (('a' <= c) && (c <= 'f')))
{
hexdigits++;
if (isid == 2)
else if (c)
{
isid = 0; /* not an ID */
- if (c == ' ' && ((hexdigits % 4) == 0))
+ if ((c == ' ') && ((hexdigits % 4) == 0))
; /* skip blank before or after 4 hex digits */
else
break; /* any other character or position */
{
int val = 0;
- if (*s == '0' && digit(s + 1))
+ if ((*s == '0') && digit(s + 1))
return NULL; /* Leading zeros are not allowed. */
for (; digit(s); s++)
{
for (; *a_plvl && *b_plvl; a_plvl++, b_plvl++)
{
- if (*a_plvl == '.' && *b_plvl == '.')
+ if ((*a_plvl == '.') && (*b_plvl == '.'))
{
r = strcmp(a_plvl, b_plvl);
if (!r)
hadcr = 1;
else
{
- if (c == '\n' && !hadcr)
+ if ((c == '\n') && !hadcr)
{
buf[0] = '\r';
gpgme_data_write(data, buf, 1);
buf[i] = 0;
if (*buf)
{
- if (i > 1 && buf[i - 1] == '!')
+ if ((i > 1) && (buf[i - 1] == '!'))
{
/* The user selected to override the validity of that
key. */
if (C_CryptUsePka)
{
- if (sig->pka_trust == 1 && sig->pka_address)
+ if ((sig->pka_trust == 1) && sig->pka_address)
{
state_puts(_("WARNING: PKA entry does not match "
"signer's address: "),
state_puts(sig->pka_address, s);
state_puts("\n", s);
}
- else if (sig->pka_trust == 2 && sig->pka_address)
+ else if ((sig->pka_trust == 2) && sig->pka_address)
{
state_puts(_("PKA verified signer's address is: "), s);
state_puts(sig->pka_address, s);
buf = mutt_mem_malloc(strlen(prefix) + strlen(s) * 4 + 2);
strcpy(buf, prefix);
p = buf + strlen(buf);
- if (is_pgp && strlen(s) == 40)
+ if (is_pgp && (strlen(s) == 40))
{ /* PGP v4 style formatted. */
for (int i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++)
{
*p++ = s[0];
*p++ = s[1];
*p++ = is_pgp ? ' ' : ':';
- if (is_pgp && i == 7)
+ if (is_pgp && (i == 7))
*p++ = ' ';
}
}
gpgme_data_release(ciphertext);
if (err)
{
- if (is_smime && !maybe_signed && gpg_err_code(err) == GPG_ERR_NO_DATA)
+ if (is_smime && !maybe_signed && (gpg_err_code(err) == GPG_ERR_NO_DATA))
{
/* Check whether this might be a signed message despite what
the mime header told us. Retry then. gpgsm returns the
if (mutt_str_strncmp(a, b, n) == 0)
{
/* at this point we know that 'b' is at least 'n' chars long */
- if (b[n] == '\n' || (b[n] == '\r' && b[n + 1] == '\n'))
+ if ((b[n] == '\n') || ((b[n] == '\r') && (b[n + 1] == '\n')))
return true;
}
return false;
if (s->prefix)
state_puts(s->prefix, s);
- if (buf[0] == '-' && buf[1] == ' ')
+ if ((buf[0] == '-') && (buf[1] == ' '))
state_puts(buf + 2, s);
else
state_puts(buf, s);
while ((c = mutt_ch_fgetconv(fc)) != EOF)
{
state_putc(c, s);
- if (c == '\n' && s->prefix)
+ if ((c == '\n') && s->prefix)
state_puts(s->prefix, s);
}
mutt_ch_fgetconv_close(&fc);
/* key = pkey; */
KeyFlags kflags = (key->flags /* | (pkey->flags & KEYFLAG_RESTRICTIONS)
- | uid->flags */);
+ | uid->flags */);
switch (tolower(op))
{
if (*s == '\\')
{ /* pair */
s++;
- if (*s == ',' || *s == '=' || *s == '+' || *s == '<' || *s == '>' ||
- *s == '#' || *s == ';' || *s == '\\' || *s == '\"' || *s == ' ')
+ if ((*s == ',') || (*s == '=') || (*s == '+') || (*s == '<') || (*s == '>') ||
+ (*s == '#') || (*s == ';') || (*s == '\\') || (*s == '\"') || (*s == ' '))
{
n++;
}
}
else if (*s == '\"')
return NULL; /* invalid encoding */
- else if (*s == ',' || *s == '=' || *s == '+' || *s == '<' || *s == '>' ||
- *s == '#' || *s == ';')
+ else if ((*s == ',') || (*s == '=') || (*s == '+') || (*s == '<') ||
+ (*s == '>') || (*s == '#') || (*s == ';'))
{
break;
}
goto failure;
while (*string == ' ')
string++;
- if (*string && *string != ',' && *string != ';' && *string != '+')
+ if (*string && (*string != ',') && (*string != ';') && (*string != '+'))
goto failure; /* invalid delimiter */
if (*string)
string++;
{
s = key->subkeys->fpr;
fprintf(fp, "%*s", KeyInfoPadding[KIP_FINGERPRINT], _(KeyInfoPrompts[KIP_FINGERPRINT]));
- if (is_pgp && strlen(s) == 40)
+ if (is_pgp && (strlen(s) == 40))
{
for (int i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++)
{
putc(*s, fp);
putc(s[1], fp);
putc(is_pgp ? ' ' : ':', fp);
- if (is_pgp && i == 7)
+ if (is_pgp && (i == 7))
putc(' ', fp);
}
}
{
for (s = np->data; *s; s++)
{
- if (*s == '%' || *s == '+')
+ if ((*s == '%') || (*s == '+'))
n += 2;
n++;
}
{
if (validity & CRYPT_KV_STRONGID)
{
- if (the_strong_valid_key && the_strong_valid_key->kobj != k->kobj)
+ if (the_strong_valid_key && (the_strong_valid_key->kobj != k->kobj))
multi = true;
this_key_has_strong = true;
}
for (s = uid, d = uid; *s;)
{
- if (*s == '\\' && *(s + 1) == 'x' && isxdigit((unsigned char) *(s + 2)) &&
- isxdigit((unsigned char) *(s + 3)))
+ if ((*s == '\\') && (*(s + 1) == 'x') &&
+ isxdigit((unsigned char) *(s + 2)) && isxdigit((unsigned char) *(s + 3)))
{
*d++ = hexval(*(s + 2)) << 4 | hexval(*(s + 3));
s += 4;
}
*d = '\0';
- if (chs && (cd = mutt_ch_iconv_open(chs, "utf-8", 0)) != (iconv_t) -1)
+ if (chs && ((cd = mutt_ch_iconv_open(chs, "utf-8", 0)) != (iconv_t) -1))
{
int n = s - uid + 1; /* chars available in original buffer */
memcpy(uid, buf, ob - buf);
uid[ob - buf] = '\0';
}
- else if (n >= 0 && ob - buf == n && (buf[n] = 0, strlen(buf) < (size_t) n))
+ else if ((n >= 0) && (ob - buf == n) && (buf[n] = 0, (strlen(buf) < (size_t) n)))
memcpy(uid, buf, n);
}
FREE(&buf);
{
mutt_debug(LL_DEBUG2, "key len: %s\n", p);
- if (!(*is_subkey && C_PgpIgnoreSubkeys) && mutt_str_atos(p, &tmp.keylen) < 0)
+ if (!(*is_subkey && C_PgpIgnoreSubkeys) && (mutt_str_atos(p, &tmp.keylen) < 0))
{
goto bail;
}
if (s->prefix)
state_puts(s->prefix, s);
- if (buf[0] == '-' && buf[1] == ' ')
+ if ((buf[0] == '-') && (buf[1] == ' '))
state_puts(buf + 2, s);
else
state_puts(buf, s);
* Sig _is_ correct if
* gpg_good_sign="" && pgp_decode_command returned 0
*/
- if (rc == -1 || rv)
+ if ((rc == -1) || rv)
maybe_goodsig = false;
state_attach_puts(_("[-- End of PGP output --]\n\n"), s);
c = fgetc(fp_pgp_out);
ungetc(c, fp_pgp_out);
}
- if (!clearsign && (!fp_pgp_out || c == EOF))
+ if (!clearsign && (!fp_pgp_out || (c == EOF)))
{
could_not_decrypt = true;
pgp_class_void_passphrase();
while (fgets(buf, sizeof(buf) - 1, fp_pgp_out))
{
size_t len = mutt_str_strlen(buf);
- if (len > 1 && buf[len - 2] == '\r')
+ if ((len > 1) && (buf[len - 2] == '\r'))
strcpy(buf + len - 2, "\n");
fputs(buf, fp_out);
}
if (s->flags & MUTT_DISPLAY)
{
rewind(fp_pgp_err);
- if (pgp_copy_checksig(fp_pgp_err, s->fp_out) == 0 && !rv)
+ if ((pgp_copy_checksig(fp_pgp_err, s->fp_out) == 0) && !rv)
p->goodsig = true;
else
p->goodsig = false;
{
if (validity & PGP_KV_STRONGID)
{
- if (the_strong_valid_key && the_strong_valid_key != k)
+ if (the_strong_valid_key && (the_strong_valid_key != k))
multi = true;
the_strong_valid_key = k;
}
struct PgpKeyInfo **last = NULL;
struct PgpKeyInfo *p = NULL, *q = NULL, *r = NULL;
- if (key->parent && key->parent != key)
+ if (key->parent && (key->parent != key))
key = key->parent;
last = klist;
struct PgpKeyInfo *p = NULL, *q = NULL, *r = NULL;
- if ((*kpp)->parent && (*kpp)->parent != *kpp)
+ if ((*kpp)->parent && ((*kpp)->parent != *kpp))
*kpp = (*kpp)->parent;
/* Order is important here:
while ((r = fgets(line, sizeof(line), fp_in)))
{
- if (*line == '=' || (strncmp(line, "-----END", 8) == 0))
+ if ((*line == '=') || (strncmp(line, "-----END", 8) == 0))
break;
}
if (!r)
return -1;
}
- if (len >= 18 && p[1] == 3)
+ if ((len >= 18) && (p[1] == 3))
{
/* version 3 signature */
return (short) p[17];
}
- else if (len >= 5 && p[1] == 4)
+ else if ((len >= 5) && (p[1] == 4))
{
/* version 4 signature */
return (short) p[4];
mutt_expand_path(path, sizeof(path));
mutt_file_quote_filename(path, buf1, sizeof(buf1));
- if (stat(path, &sb) != 0 || !S_ISDIR(sb.st_mode))
+ if ((stat(path, &sb) != 0) || !S_ISDIR(sb.st_mode))
snprintf(buf2, sizeof(buf2), "-CAfile %s", buf1);
else
snprintf(buf2, sizeof(buf2), "-CApath %s", buf1);
FILE *fp_smime_in = NULL;
if ((type & SEC_ENCRYPT) &&
- (pid = smime_invoke_decrypt(&fp_smime_in, NULL, NULL, -1, fileno(fp_smime_out),
- fileno(fp_smime_err), tmpfname)) == -1)
+ ((pid = smime_invoke_decrypt(&fp_smime_in, NULL, NULL, -1, fileno(fp_smime_out),
+ fileno(fp_smime_err), tmpfname)) == -1))
{
mutt_file_fclose(&fp_smime_out);
mutt_file_unlink(tmpfname);
return NULL;
}
else if ((type & SEC_SIGNOPAQUE) &&
- (pid = smime_invoke_verify(&fp_smime_in, NULL, NULL, -1,
- fileno(fp_smime_out), fileno(fp_smime_err),
- NULL, tmpfname, SEC_SIGNOPAQUE)) == -1)
+ ((pid = smime_invoke_verify(&fp_smime_in, NULL, NULL, -1,
+ fileno(fp_smime_out), fileno(fp_smime_err),
+ NULL, tmpfname, SEC_SIGNOPAQUE)) == -1))
{
mutt_file_fclose(&fp_smime_out);
mutt_file_unlink(tmpfname);
while (fgets(buf, sizeof(buf) - 1, fp_smime_out))
{
const size_t len = mutt_str_strlen(buf);
- if (len > 1 && buf[len - 2] == '\r')
+ if ((len > 1) && (buf[len - 2] == '\r'))
{
buf[len - 2] = '\n';
buf[len - 1] = '\0';
break;
case 'n':
- if (Context && Context->mailbox->mdata == folder->ff->nd)
+ if (Context && (Context->mailbox->mdata == folder->ff->nd))
{
snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context->mailbox->msg_new);
}
- else if (C_MarkOld && folder->ff->nd->last_cached >= folder->ff->nd->first_message &&
- folder->ff->nd->last_cached <= folder->ff->nd->last_message)
+ else if (C_MarkOld && (folder->ff->nd->last_cached >= folder->ff->nd->first_message) &&
+ (folder->ff->nd->last_cached <= folder->ff->nd->last_message))
{
snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, folder->ff->nd->last_message - folder->ff->nd->last_cached);
group_index_format_str, data, flags);
}
}
- else if (Context && Context->mailbox->mdata == folder->ff->nd)
+ else if (Context && (Context->mailbox->mdata == folder->ff->nd))
{
snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context->mailbox->msg_unread);
void nntp_group_unread_stat(struct NntpMboxData *mdata)
{
mdata->unread = 0;
- if (mdata->last_message == 0 || mdata->first_message > mdata->last_message)
+ if ((mdata->last_message == 0) || (mdata->first_message > mdata->last_message))
return;
mdata->unread = mdata->last_message - mdata->first_message + 1;
return -1;
}
- if (adata->size == sb.st_size && adata->mtime == sb.st_mtime)
+ if ((adata->size == sb.st_size) && (adata->mtime == sb.st_mtime))
return 0;
adata->size = sb.st_size;
else
h = b;
- if (sscanf(b, ANUM, &mdata->newsrc_ent[j].first) == 1 &&
- sscanf(h, ANUM, &mdata->newsrc_ent[j].last) == 1)
+ if ((sscanf(b, ANUM, &mdata->newsrc_ent[j].first) == 1) &&
+ (sscanf(h, ANUM, &mdata->newsrc_ent[j].last) == 1))
{
j++;
}
/* We don't actually check sequential order, since we mark
* "missing" entries as read/deleted */
last = nntp_edata_get(m->emails[i])->article_num;
- if (last >= mdata->first_message && !m->emails[i]->deleted &&
+ if ((last >= mdata->first_message) && !m->emails[i]->deleted &&
!m->emails[i]->read)
{
if (mdata->newsrc_len >= entries)
}
}
- if (series && first <= mdata->last_loaded)
+ if (series && (first <= mdata->last_loaded))
{
if (mdata->newsrc_len >= entries)
{
/* newrc being fully rewritten */
mutt_debug(LL_DEBUG1, "Updating %s\n", adata->newsrc_file);
- if (adata->newsrc_file && update_file(adata->newsrc_file, buf) == 0)
+ if (adata->newsrc_file && (update_file(adata->newsrc_file, buf) == 0))
{
struct stat sb;
mutt_str_replace(&mdata->desc, desc);
if (mdata->newsrc_ent || mdata->last_cached)
nntp_group_unread_stat(mdata);
- else if (mdata->last_message && mdata->first_message <= mdata->last_message)
+ else if (mdata->last_message && (mdata->first_message <= mdata->last_message))
mdata->unread = mdata->last_message - mdata->first_message + 1;
else
mdata->unread = 0;
/* clean removed headers from cache */
for (anum_t current = first; current <= last; current++)
{
- if (current >= mdata->first_message && current <= mdata->last_message)
+ if ((current >= mdata->first_message) && (current <= mdata->last_message))
continue;
snprintf(buf, sizeof(buf), "%u", current);
}
/* store current values of first and last */
- if (!old || mdata->first_message != first || mdata->last_message != last)
+ if (!old || (mdata->first_message != first) || (mdata->last_message != last))
{
snprintf(buf, sizeof(buf), "%u %u", mdata->first_message, mdata->last_message);
mutt_debug(LL_DEBUG2, "mutt_hcache_store index: %s\n", buf);
anum_t anum;
char c;
- if (!mdata || sscanf(id, ANUM "%c", &anum, &c) != 1 ||
- anum < mdata->first_message || anum > mdata->last_message)
+ if (!mdata || (sscanf(id, ANUM "%c", &anum, &c) != 1) ||
+ (anum < mdata->first_message) || (anum > mdata->last_message))
{
if (mdata)
mutt_debug(LL_DEBUG2, "mutt_bcache_del %s\n", id);
if (S_ISREG(sb.st_mode))
{
char *ext = group + strlen(group) - 7;
- if (strlen(group) < 8 || (mutt_str_strcmp(ext, ".hcache") != 0))
+ if ((strlen(group) < 8) || (mutt_str_strcmp(ext, ".hcache") != 0))
continue;
*ext = '\0';
}
snprintf(file, sizeof(file), "%s%s", strstr(server, "://") ? "" : "news://", server);
struct Url *url = url_parse(file);
if (!url || (url->path && *url->path) ||
- !(url->scheme == U_NNTP || url->scheme == U_NNTPS) || !url->host ||
- mutt_account_fromurl(&acct, url) < 0)
+ !((url->scheme == U_NNTP) || (url->scheme == U_NNTPS)) || !url->host ||
+ (mutt_account_fromurl(&acct, url) < 0))
{
url_free(&url);
mutt_error(_("%s is an invalid news server specification"), server);
return NULL;
/* check for new newsgroups */
- if (!leave_lock && nntp_check_new_groups(m, adata) < 0)
+ if (!leave_lock && (nntp_check_new_groups(m, adata) < 0))
rc = -1;
/* .newsrc has been externally modified */
if (rc > 0)
nntp_clear_cache(adata);
- if (rc < 0 || !leave_lock)
+ if ((rc < 0) || !leave_lock)
nntp_newsrc_close(adata);
return (rc < 0) ? NULL : adata;
}
/* try to create cache directory and enable caching */
adata->cacheable = false;
- if (rc >= 0 && C_NewsCacheDir && *C_NewsCacheDir)
+ if ((rc >= 0) && C_NewsCacheDir && *C_NewsCacheDir)
{
cache_expand(file, sizeof(file), &conn->account, NULL);
if (mutt_file_mkdir(file, S_IRWXU) < 0)
if (rc >= 0)
{
/* try to load list of newsgroups from cache */
- if (adata->cacheable && active_get_cache(adata) == 0)
+ if (adata->cacheable && (active_get_cache(adata) == 0))
rc = nntp_check_new_groups(m, adata);
/* load list of newsgroups from server */
#ifdef USE_HCACHE
/* check cache files */
- if (rc >= 0 && adata->cacheable)
+ if ((rc >= 0) && adata->cacheable)
{
struct dirent *entry = NULL;
DIR *dp = opendir(file);
char *group = entry->d_name;
p = group + strlen(group) - 7;
- if (strlen(group) < 8 || (strcmp(p, ".hcache") != 0))
+ if ((strlen(group) < 8) || (strcmp(p, ".hcache") != 0))
continue;
*p = '\0';
struct NntpMboxData *mdata = mutt_hash_find(adata->groups_hash, group);
mdata->first_message = first;
mdata->last_message = last;
}
- if (last >= mdata->first_message && last <= mdata->last_message)
+ if ((last >= mdata->first_message) && (last <= mdata->last_message))
{
mdata->last_cached = last;
mutt_debug(LL_DEBUG2, "%s last_cached=%u\n", mdata->group, last);
}
#endif
- if (rc < 0 || !leave_lock)
+ if ((rc < 0) || !leave_lock)
nntp_newsrc_close(adata);
if (rc < 0)
mdata->newsrc_ent[0].first = 1;
mdata->newsrc_ent[0].last = mdata->first_message - 1;
}
- if (m && m->mdata == mdata)
+ if (m && (m->mdata == mdata))
{
mdata->unread = m->msg_count;
for (unsigned int i = 0; i < m->msg_count; i++)
adata->hasOVER = false;
FREE(&adata->authenticators);
- if (mutt_socket_send(conn, "CAPABILITIES\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "CAPABILITIES\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
if (p)
{
p += 11;
- if (*p == '\0' || *p == ' ')
+ if ((*p == '\0') || (*p == ' '))
adata->hasLIST_NEWSGROUPS = true;
}
}
/* no CAPABILITIES, trying DATE, LISTGROUP, LIST NEWSGROUPS */
if (!adata->hasCAPABILITIES)
{
- if (mutt_socket_send(conn, "DATE\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "DATE\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
if (!mutt_str_startswith(buf, "500", CASE_MATCH))
adata->hasDATE = true;
- if (mutt_socket_send(conn, "LISTGROUP\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "LISTGROUP\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
if (!mutt_str_startswith(buf, "500", CASE_MATCH))
adata->hasLISTGROUP = true;
- if (mutt_socket_send(conn, "LIST NEWSGROUPS +\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "LIST NEWSGROUPS +\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
/* no LIST NEWSGROUPS, trying XGTITLE */
if (!adata->hasLIST_NEWSGROUPS)
{
- if (mutt_socket_send(conn, "XGTITLE\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "XGTITLE\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
/* no OVER, trying XOVER */
if (!adata->hasOVER)
{
- if (mutt_socket_send(conn, "XOVER\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "XOVER\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
/* trying LIST OVERVIEW.FMT */
if (adata->hasOVER || adata->hasXOVER)
{
- if (mutt_socket_send(conn, "LIST OVERVIEW.FMT\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "LIST OVERVIEW.FMT\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
m = strcasestr(adata->authenticators, method);
if (!m)
continue;
- if (m > adata->authenticators && *(m - 1) != ' ')
+ if ((m > adata->authenticators) && (*(m - 1) != ' '))
continue;
m += strlen(method);
- if (*m != '\0' && *m != ' ')
+ if ((*m != '\0') && (*m != ' '))
continue;
}
mutt_debug(LL_DEBUG1, "trying method %s\n", method);
{
mutt_message(_("Authenticating (%s)..."), method);
snprintf(buf, sizeof(buf), "AUTHINFO USER %s\r\n", conn->account.user);
- if (mutt_socket_send(conn, buf) < 0 ||
- mutt_socket_readln_d(buf, sizeof(buf), conn, MUTT_SOCK_LOG_FULL) < 0)
+ if ((mutt_socket_send(conn, buf) < 0) ||
+ (mutt_socket_readln_d(buf, sizeof(buf), conn, MUTT_SOCK_LOG_FULL) < 0))
{
break;
}
{
mutt_debug(MUTT_SOCK_LOG_FULL, "%d> AUTHINFO PASS *\n", conn->fd);
snprintf(buf, sizeof(buf), "AUTHINFO PASS %s\r\n", conn->account.pass);
- if (mutt_socket_send_d(conn, buf, MUTT_SOCK_LOG_FULL) < 0 ||
- mutt_socket_readln_d(buf, sizeof(buf), conn, MUTT_SOCK_LOG_FULL) < 0)
+ if ((mutt_socket_send_d(conn, buf, MUTT_SOCK_LOG_FULL) < 0) ||
+ (mutt_socket_readln_d(buf, sizeof(buf), conn, MUTT_SOCK_LOG_FULL) < 0))
{
break;
}
break;
mutt_sasl_interact(interaction);
}
- if (rc != SASL_OK && rc != SASL_CONTINUE)
+ if ((rc != SASL_OK) && (rc != SASL_CONTINUE))
{
sasl_dispose(&saslconn);
mutt_debug(LL_DEBUG1,
else
mutt_debug(MUTT_SOCK_LOG_CMD, "%d> sasl_data\n", conn->fd);
client_len = 0;
- if (mutt_socket_send_d(conn, buf, MUTT_SOCK_LOG_FULL) < 0 ||
- mutt_socket_readln_d(inbuf, sizeof(inbuf), conn, MUTT_SOCK_LOG_FULL) < 0)
+ if ((mutt_socket_send_d(conn, buf, MUTT_SOCK_LOG_FULL) < 0) ||
+ (mutt_socket_readln_d(inbuf, sizeof(inbuf), conn, MUTT_SOCK_LOG_FULL) < 0))
{
break;
}
*buf = '\0';
} /* looping protocol */
- if (rc == SASL_OK && client_len == 0 && *inbuf == '2')
+ if ((rc == SASL_OK) && (client_len == 0) && (*inbuf == '2'))
{
mutt_sasl_setup_conn(conn, saslconn);
return 0;
break;
if (mutt_str_startswith(inbuf, "383 ", CASE_MATCH))
{
- if (mutt_socket_send(conn, "*\r\n") < 0 ||
- mutt_socket_readln(inbuf, sizeof(inbuf), conn) < 0)
+ if ((mutt_socket_send(conn, "*\r\n") < 0) ||
+ (mutt_socket_readln(inbuf, sizeof(inbuf), conn) < 0))
{
break;
}
if (mdata->group)
{
snprintf(buf, sizeof(buf), "GROUP %s\r\n", mdata->group);
- if (mutt_socket_send(adata->conn, buf) < 0 ||
- mutt_socket_readln(buf, sizeof(buf), adata->conn) < 0)
+ if ((mutt_socket_send(adata->conn, buf) < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), adata->conn) < 0))
{
return nntp_connect_error(adata);
}
}
p = buf;
- if (!off && buf[0] == '.')
+ if (!off && (buf[0] == '.'))
{
if (buf[1] == '\0')
{
if (msg)
mutt_progress_update(&progress, ++lines, -1);
- if (rc == 0 && func(line, data) < 0)
+ if ((rc == 0) && (func(line, data) < 0))
rc = -2;
off = 0;
}
if (!line)
rewind(fp);
- else if (fputs(line, fp) == EOF || fputc('\n', fp) == EOF)
+ else if ((fputs(line, fp) == EOF) || (fputc('\n', fp) == EOF))
return -1;
return 0;
}
return 0;
if (sscanf(line, ANUM, &anum) != 1)
return 0;
- if (anum < fc->first || anum > fc->last)
+ if ((anum < fc->first) || (anum > fc->last))
return 0;
fc->messages[anum - fc->first] = 1;
return 0;
mutt_debug(LL_DEBUG2, "" ANUM "\n", anum);
/* out of bounds */
- if (anum < fc->first || anum > fc->last)
+ if ((anum < fc->first) || (anum > fc->last))
return 0;
/* not in LISTGROUP */
field = strchr(field, '\t');
if (field)
*field++ = '\0';
- if (fputs(b, fp) == EOF || fputc('\n', fp) == EOF)
+ if ((fputs(b, fp) == EOF) || (fputc('\n', fp) == EOF))
{
mutt_file_fclose(&fp);
return -1;
#endif
/* if empty group or nothing to do */
- if (!last || first > last)
+ if (!last || (first > last))
return 0;
/* init fetch context */
current = first_over;
/* fetch overview information */
- if (current <= last && rc == 0 && !mdata->deleted)
+ if ((current <= last) && (rc == 0) && !mdata->deleted)
{
char *cmd = mdata->adata->hasOVER ? "OVER" : "XOVER";
snprintf(buf, sizeof(buf), "%s %u-%u\r\n", cmd, current, last);
return -1;
if (sscanf(buf, "211 " ANUM " " ANUM " " ANUM, &count, &first, &last) != 3)
return 0;
- if (first == mdata->first_message && last == mdata->last_message)
+ if ((first == mdata->first_message) && (last == mdata->last_message))
return 0;
/* articles have been renumbered */
if (mdata->last_message < mdata->last_loaded)
{
mdata->last_loaded = mdata->first_message - 1;
- if (C_NntpContext && mdata->last_message - mdata->last_loaded > C_NntpContext)
+ if (C_NntpContext && (mdata->last_message - mdata->last_loaded > C_NntpContext))
mdata->last_loaded = mdata->last_message - C_NntpContext;
}
rc = MUTT_REOPENED;
struct Email *e = NULL;
anum_t first = mdata->first_message;
- if (C_NntpContext && mdata->last_message - first + 1 > C_NntpContext)
+ if (C_NntpContext && (mdata->last_message - first + 1 > C_NntpContext))
first = mdata->last_message - C_NntpContext + 1;
messages = mutt_mem_calloc(mdata->last_loaded - first + 1, sizeof(unsigned char));
hc = nntp_hcache_open(mdata);
/* check hcache for flagged and deleted flags */
if (hc)
{
- if (anum >= first && anum <= mdata->last_loaded)
+ if ((anum >= first) && (anum <= mdata->last_loaded))
messages[anum - first] = 1;
snprintf(buf, sizeof(buf), "%u", anum);
mutt_mailbox_changed(m, MBN_INVALID);
mdata->last_loaded = mdata->last_message;
}
- if (rc == 0 && m->msg_count > oldmsgcount)
+ if ((rc == 0) && (m->msg_count > oldmsgcount))
rc = MUTT_NEW_MAIL;
}
struct ChildCtx *cc = data;
anum_t anum;
- if (!line || sscanf(line, ANUM, &anum) != 1)
+ if (!line || (sscanf(line, ANUM, &anum) != 1))
return 0;
for (unsigned int i = 0; i < cc->mailbox->msg_count; i++)
if (nntp_edata_get(cc->mailbox->emails[i])->article_num == anum)
/* tell news server to switch to mode reader if it isn't so */
if (cap > 0)
{
- if (mutt_socket_send(conn, "MODE READER\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "MODE READER\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
#ifdef USE_SSL
/* Attempt STARTTLS if available and desired. */
- if (adata->use_tls != 1 && (adata->hasSTARTTLS || C_SslForceTls))
+ if ((adata->use_tls != 1) && (adata->hasSTARTTLS || C_SslForceTls))
{
if (adata->use_tls == 0)
{
}
if (adata->use_tls == 2)
{
- if (mutt_socket_send(conn, "STARTTLS\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "STARTTLS\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
}
else
{
- if (mutt_socket_send(conn, "STAT\r\n") < 0 ||
- mutt_socket_readln(buf, sizeof(buf), conn) < 0)
+ if ((mutt_socket_send(conn, "STAT\r\n") < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), conn) < 0))
{
return nntp_connect_error(adata);
}
}
/* authenticate */
- if (auth && nntp_auth(adata) < 0)
+ if (auth && (nntp_auth(adata) < 0))
return -1;
/* get final capabilities after authentication */
- if (adata->hasCAPABILITIES && (auth || cap > 0))
+ if (adata->hasCAPABILITIES && (auth || (cap > 0)))
{
cap = nntp_capabilities(adata);
if (cap < 0)
len++;
buf[len] = '\0';
}
- if (mutt_socket_send_d(mdata->adata->conn, buf[1] == '.' ? buf : buf + 1,
+ if (mutt_socket_send_d(mdata->adata->conn, (buf[1] == '.') ? buf : buf + 1,
MUTT_SOCK_LOG_FULL) < 0)
{
mutt_file_fclose(&fp);
}
mutt_file_fclose(&fp);
- if ((buf[strlen(buf) - 1] != '\n' &&
- mutt_socket_send_d(mdata->adata->conn, "\r\n", MUTT_SOCK_LOG_FULL) < 0) ||
- mutt_socket_send_d(mdata->adata->conn, ".\r\n", MUTT_SOCK_LOG_FULL) < 0 ||
- mutt_socket_readln(buf, sizeof(buf), mdata->adata->conn) < 0)
+ if (((buf[strlen(buf) - 1] != '\n') &&
+ (mutt_socket_send_d(mdata->adata->conn, "\r\n", MUTT_SOCK_LOG_FULL) < 0)) ||
+ (mutt_socket_send_d(mdata->adata->conn, ".\r\n", MUTT_SOCK_LOG_FULL) < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), mdata->adata->conn) < 0))
{
return nntp_connect_error(mdata->adata);
}
*/
int nntp_ac_add(struct Account *a, struct Mailbox *m)
{
- if (!a || !m || m->magic != MUTT_NNTP)
+ if (!a || !m || (m->magic != MUTT_NNTP))
return -1;
return 0;
}
anum_t first, last, count = 0;
struct Url *url = url_parse(m->path);
- if (!url || !url->host || !url->path || !(url->scheme == U_NNTP || url->scheme == U_NNTPS))
+ if (!url || !url->host || !url->path ||
+ !((url->scheme == U_NNTP) || (url->scheme == U_NNTPS)))
{
url_free(&url);
mutt_error(_("%s is an invalid newsgroup specification"), m->path);
/* strip off extra articles if adding context is greater than $nntp_context */
first = mdata->first_message;
- if (C_NntpContext && mdata->last_message - first + 1 > C_NntpContext)
+ if (C_NntpContext && (mdata->last_message - first + 1 > C_NntpContext))
first = mdata->last_message - C_NntpContext + 1;
mdata->last_loaded = first ? first - 1 : 0;
count = mdata->first_message;
return 0;
tmp_mdata = mutt_hash_find(mdata->adata->groups_hash, mdata->group);
- if (!tmp_mdata || tmp_mdata != mdata)
+ if (!tmp_mdata || (tmp_mdata != mdata))
nntp_mdata_free((void **) &mdata);
return 0;
}
notmuch_query_destroy(q);
mutt_debug(LL_DEBUG1, "nm: count '%s', result=%d\n", qstr, res);
- if (limit > 0 && res > limit)
+ if ((limit > 0) && (res > limit))
res = limit;
return res;
goto done;
}
- if (st == NOTMUCH_STATUS_SUCCESS && msg)
+ if ((st == NOTMUCH_STATUS_SUCCESS) && msg)
{
notmuch_message_maildir_flags_to_tags(msg);
if (e)
*/
int nm_ac_add(struct Account *a, struct Mailbox *m)
{
- if (!a || !m || m->magic != MUTT_NOTMUCH)
+ if (!a || !m || (m->magic != MUTT_NOTMUCH))
return -1;
if (!a->adata)
else
def_color = ColorDefs[line_info[m].type];
- if ((flags & MUTT_SHOWCOLOR) && line_info[m].type == MT_COLOR_QUOTED)
+ if ((flags & MUTT_SHOWCOLOR) && (line_info[m].type == MT_COLOR_QUOTED))
{
struct QClass *class = line_info[m].quote;
pmatch = pmatch_internal;
if (C_QuoteRegex && C_QuoteRegex->regex &&
- regexec(C_QuoteRegex->regex, line, 1, pmatch, 0) == 0)
+ (regexec(C_QuoteRegex->regex, line, 1, pmatch, 0) == 0))
{
- if (C_Smileys && C_Smileys->regex && regexec(C_Smileys->regex, line, 1, smatch, 0) == 0)
+ if (C_Smileys && C_Smileys->regex &&
+ (regexec(C_Smileys->regex, line, 1, smatch, 0) == 0))
{
if (smatch[0].rm_so > 0)
{
bool null_rx;
int offset, i = 0;
- if (n == 0 || ISHEADER(line_info[n - 1].type) || (check_protected_header_marker(raw) == 0))
+ if ((n == 0) || ISHEADER(line_info[n - 1].type) ||
+ (check_protected_header_marker(raw) == 0))
{
if (buf[0] == '\n') /* end of header */
{
{
/* if this is a continuation of the previous line, use the previous
* line's color as default. */
- if (n > 0 && (buf[0] == ' ' || buf[0] == '\t'))
+ if ((n > 0) && ((buf[0] == ' ') || (buf[0] == '\t')))
{
line_info[n].type = line_info[n - 1].type; /* wrapped line */
if (!C_HeaderColorPartial)
else if (mutt_is_quote_line(buf, pmatch))
{
- if (q_classify && line_info[n].quote == NULL)
+ if (q_classify && (line_info[n].quote == NULL))
{
line_info[n].quote = classify_quote(quote_list, buf + pmatch[0].rm_so,
pmatch[0].rm_eo - pmatch[0].rm_so,
line_info[n].type = MT_COLOR_NORMAL;
/* body patterns */
- if (line_info[n].type == MT_COLOR_NORMAL || line_info[n].type == MT_COLOR_QUOTED ||
- (line_info[n].type == MT_COLOR_HDEFAULT && C_HeaderColorPartial))
+ if ((line_info[n].type == MT_COLOR_NORMAL) || (line_info[n].type == MT_COLOR_QUOTED) ||
+ ((line_info[n].type == MT_COLOR_HDEFAULT) && C_HeaderColorPartial))
{
size_t nl;
null_rx = false;
STAILQ_FOREACH(color_line, head, entries)
{
- if (!color_line->stop_matching && regexec(&color_line->regex, buf + offset, 1, pmatch,
- (offset ? REG_NOTBOL : 0)) == 0)
+ if (!color_line->stop_matching && (regexec(&color_line->regex, buf + offset, 1, pmatch,
+ (offset ? REG_NOTBOL : 0)) == 0))
{
if (pmatch[0].rm_eo != pmatch[0].rm_so)
{
i = line_info[n].chunks - 1;
pmatch[0].rm_so += offset;
pmatch[0].rm_eo += offset;
- if (!found || pmatch[0].rm_so < (line_info[n].syntax)[i].first ||
- (pmatch[0].rm_so == (line_info[n].syntax)[i].first &&
- pmatch[0].rm_eo > (line_info[n].syntax)[i].last))
+ if (!found || (pmatch[0].rm_so < (line_info[n].syntax)[i].first) ||
+ ((pmatch[0].rm_so == (line_info[n].syntax)[i].first) &&
+ (pmatch[0].rm_eo > (line_info[n].syntax)[i].last)))
{
(line_info[n].syntax)[i].color = color_line->pair;
(line_info[n].syntax)[i].first = pmatch[0].rm_so;
i = line_info[n].chunks - 1;
pmatch[0].rm_so += offset;
pmatch[0].rm_eo += offset;
- if (!found || pmatch[0].rm_so < (line_info[n].syntax)[i].first ||
- (pmatch[0].rm_so == (line_info[n].syntax)[i].first &&
- pmatch[0].rm_eo > (line_info[n].syntax)[i].last))
+ if (!found || (pmatch[0].rm_so < (line_info[n].syntax)[i].first) ||
+ ((pmatch[0].rm_so == (line_info[n].syntax)[i].first) &&
+ (pmatch[0].rm_eo > (line_info[n].syntax)[i].last)))
{
(line_info[n].syntax)[i].color = color_line->pair;
(line_info[n].syntax)[i].first = pmatch[0].rm_so;
}
while (pos < x)
{
- if (buf[pos] == '1' && (pos + 1 == x || buf[pos + 1] == ';'))
+ if ((buf[pos] == '1') && ((pos + 1 == x) || (buf[pos + 1] == ';')))
{
a->attr |= ANSI_BOLD;
pos += 2;
}
- else if (buf[pos] == '4' && (pos + 1 == x || buf[pos + 1] == ';'))
+ else if ((buf[pos] == '4') && ((pos + 1 == x) || (buf[pos + 1] == ';')))
{
a->attr |= ANSI_UNDERLINE;
pos += 2;
}
- else if (buf[pos] == '5' && (pos + 1 == x || buf[pos + 1] == ';'))
+ else if ((buf[pos] == '5') && ((pos + 1 == x) || (buf[pos + 1] == ';')))
{
a->attr |= ANSI_BLINK;
pos += 2;
}
- else if (buf[pos] == '7' && (pos + 1 == x || buf[pos + 1] == ';'))
+ else if ((buf[pos] == '7') && ((pos + 1 == x) || (buf[pos + 1] == ';')))
{
a->attr |= ANSI_REVERSE;
pos += 2;
}
- else if (buf[pos] == '0' && (pos + 1 == x || buf[pos + 1] == ';'))
+ else if ((buf[pos] == '0') && ((pos + 1 == x) || (buf[pos + 1] == ';')))
{
#ifdef HAVE_COLOR
if (a->pair != -1)
a->pair = -1;
pos += 2;
}
- else if (buf[pos] == '3' && isdigit(buf[pos + 1]))
+ else if ((buf[pos] == '3') && isdigit(buf[pos + 1]))
{
#ifdef HAVE_COLOR
if (a->pair != -1)
a->fg = buf[pos + 1] - '0';
pos += 3;
}
- else if (buf[pos] == '4' && isdigit(buf[pos + 1]))
+ else if ((buf[pos] == '4') && isdigit(buf[pos + 1]))
{
#ifdef HAVE_COLOR
if (a->pair != -1)
q = *fmt;
while (*p)
{
- if (*p == '\010' && (p > *buf))
+ if ((*p == '\010') && (p > *buf))
{
if (*(p + 1) == '_') /* underline */
p += 2;
- else if (*(p + 1) && q > *fmt) /* bold or overstrike */
+ else if (*(p + 1) && (q > *fmt)) /* bold or overstrike */
{
*(q - 1) = *(p + 1);
p += 2;
else /* ^H */
*q++ = *p++;
}
- else if (*p == '\033' && *(p + 1) == '[' && is_ansi(p + 2))
+ else if ((*p == '\033') && (*(p + 1) == '[') && is_ansi(p + 2))
{
while (*p++ != 'm') /* skip ANSI sequence */
;
}
- else if (*p == '\033' && *(p + 1) == ']' &&
+ else if ((*p == '\033') && (*(p + 1) == ']') &&
((check_attachment_marker((char *) p) == 0) ||
(check_protected_header_marker((char *) p) == 0)))
{
break;
k = mbrtowc(&wc, (char *) buf + ch, cnt - ch, &mbstate);
- if (k == (size_t)(-2) || k == (size_t)(-1))
+ if ((k == (size_t)(-2)) || (k == (size_t)(-1)))
{
if (k == (size_t)(-1))
memset(&mbstate, 0, sizeof(mbstate));
if (CharsetIsUtf8)
{
/* zero width space, zero width no-break space */
- if (wc == 0x200B || wc == 0xFEFF)
+ if ((wc == 0x200B) || (wc == 0xFEFF))
{
mutt_debug(LL_DEBUG3, "skip zero-width character U+%04X\n", (unsigned short) wc);
continue;
{
special |= (wc == '_' && special & A_UNDERLINE) ? A_UNDERLINE : A_BOLD;
}
- else if (wc == '_' || wc1 == '_')
+ else if ((wc == '_') || (wc1 == '_'))
{
special |= A_UNDERLINE;
wc = (wc1 == '_') ? wc : wc1;
}
/* no-break space, narrow no-break space */
- if (IsWPrint(wc) || (CharsetIsUtf8 && (wc == 0x00A0 || wc == 0x202F)))
+ if (IsWPrint(wc) || (CharsetIsUtf8 && ((wc == 0x00A0) || (wc == 0x202F))))
{
if (wc == ' ')
{
else
col = t;
}
- else if (wc < 0x20 || wc == 0x7f)
+ else if ((wc < 0x20) || (wc == 0x7f))
{
if (col + 2 > wrap_cols)
break;
}
/* this also prevents searching through the hidden lines */
- if ((flags & MUTT_HIDE) && (*line_info)[n].type == MT_COLOR_QUOTED)
+ if ((flags & MUTT_HIDE) && ((*line_info)[n].type == MT_COLOR_QUOTED))
flags = 0; /* MUTT_NOSHOW */
}
goto out;
}
if (C_QuoteRegex && C_QuoteRegex->regex &&
- regexec(C_QuoteRegex->regex, (char *) fmt, 1, pmatch, 0) == 0)
+ (regexec(C_QuoteRegex->regex, (char *) fmt, 1, pmatch, 0) == 0))
{
(*line_info)[n].quote =
classify_quote(quote_list, (char *) fmt + pmatch[0].rm_so,
}
if ((flags & MUTT_SEARCH) && !(*line_info)[n].continuation &&
- (*line_info)[n].search_cnt == -1)
+ ((*line_info)[n].search_cnt == -1))
{
if (fill_buffer(fp, last_pos, (*line_info)[n].offset, &buf, &fmt, &buflen, &buf_ready) < 0)
{
}
}
- if (!(flags & MUTT_SHOW) && (*line_info)[n + 1].offset > 0)
+ if (!(flags & MUTT_SHOW) && ((*line_info)[n + 1].offset > 0))
{
/* we've already scanned this line, so just exit */
rc = 0;
goto out;
}
- if ((flags & MUTT_SHOWCOLOR) && *force_redraw && (*line_info)[n + 1].offset > 0)
+ if ((flags & MUTT_SHOWCOLOR) && *force_redraw && ((*line_info)[n + 1].offset > 0))
{
/* no need to try to display this line... */
rc = 1;
if (*buf_ptr == '\n')
buf_ptr++;
- if ((int) (buf_ptr - buf) < b_read && !(*line_info)[n + 1].continuation)
+ if (((int) (buf_ptr - buf) < b_read) && !(*line_info)[n + 1].continuation)
append_line(*line_info, n, (int) (buf_ptr - buf));
(*line_info)[n + 1].offset = (*line_info)[n].offset + (long) (buf_ptr - buf);
#endif
/* end the last color pattern (needed by S-Lang) */
- if (special || (col != pager_window->cols && (flags & (MUTT_SHOWCOLOR | MUTT_SEARCH))))
+ if (special || ((col != pager_window->cols) && (flags & (MUTT_SHOWCOLOR | MUTT_SEARCH))))
resolve_color(*line_info, n, vch, flags, 0, &a);
/* Fill the blank space at the end of the line with the prevailing color.
while (cur > 0 && nlines > 0)
{
cur--;
- if (!hiding || info[cur].type != MT_COLOR_QUOTED)
+ if (!hiding || (info[cur].type != MT_COLOR_QUOTED))
nlines--;
}
&rd->quote_list, &rd->q_level, &rd->force_redraw,
&rd->search_re, rd->pager_window) == 0)
{
- if (!rd->line_info[i].continuation && ++j == rd->lines)
+ if (!rd->line_info[i].continuation && (++j == rd->lines))
{
rd->topline = i;
if (!rd->search_flag)
}
#endif
- if ((pager_menu->redraw & REDRAW_BODY) || rd->topline != rd->oldtopline)
+ if ((pager_menu->redraw & REDRAW_BODY) || (rd->topline != rd->oldtopline))
{
do
{
int i;
for (i = wrapped ? 0 : rd.topline + searchctx + 1; i < rd.last_line; i++)
{
- if ((!rd.hide_quoted || rd.line_info[i].type != MT_COLOR_QUOTED) &&
- !rd.line_info[i].continuation && rd.line_info[i].search_cnt > 0)
+ if ((!rd.hide_quoted || (rd.line_info[i].type != MT_COLOR_QUOTED)) &&
+ !rd.line_info[i].continuation && (rd.line_info[i].search_cnt > 0))
{
break;
}
int i;
for (i = wrapped ? rd.last_line : rd.topline + searchctx - 1; i >= 0; i--)
{
- if ((!rd.hide_quoted || (rd.has_types && rd.line_info[i].type != MT_COLOR_QUOTED)) &&
- !rd.line_info[i].continuation && rd.line_info[i].search_cnt > 0)
+ if ((!rd.hide_quoted ||
+ (rd.has_types && (rd.line_info[i].type != MT_COLOR_QUOTED))) &&
+ !rd.line_info[i].continuation && (rd.line_info[i].search_cnt > 0))
{
break;
}
case OP_POST:
CHECK_MODE(IsEmail(extra) && !IsAttach(extra));
CHECK_ATTACH;
- if (extra->ctx && extra->ctx->mailbox->magic == MUTT_NNTP &&
- !((struct NntpMboxData *) extra->ctx->mailbox->mdata)->allowed && query_quadoption(C_PostModerated, _("Posting to this group not allowed, may be moderated. Continue?")) != MUTT_YES)
+ if (extra->ctx && (extra->ctx->mailbox->magic == MUTT_NNTP) &&
+ !((struct NntpMboxData *) extra->ctx->mailbox->mdata)->allowed && (query_quadoption(C_PostModerated, _("Posting to this group not allowed, may be moderated. Continue?")) != MUTT_YES))
{
break;
}
case OP_FORWARD_TO_GROUP:
CHECK_MODE(IsEmail(extra) || IsMsgAttach(extra));
CHECK_ATTACH;
- if (extra->ctx && extra->ctx->mailbox->magic == MUTT_NNTP &&
- !((struct NntpMboxData *) extra->ctx->mailbox->mdata)->allowed && query_quadoption(C_PostModerated, _("Posting to this group not allowed, may be moderated. Continue?")) != MUTT_YES)
+ if (extra->ctx && (extra->ctx->mailbox->magic == MUTT_NNTP) &&
+ !((struct NntpMboxData *) extra->ctx->mailbox->mdata)->allowed && (query_quadoption(C_PostModerated, _("Posting to this group not allowed, may be moderated. Continue?")) != MUTT_YES))
{
break;
}
followup_to = extra->email->env->followup_to;
if (!followup_to || (mutt_str_strcasecmp(followup_to, "poster") != 0) ||
- query_quadoption(C_FollowupToPoster,
- _("Reply by mail as poster prefers?")) != MUTT_YES)
+ (query_quadoption(C_FollowupToPoster,
+ _("Reply by mail as poster prefers?")) != MUTT_YES))
{
if (extra->ctx && (extra->ctx->mailbox->magic == MUTT_NNTP) &&
- !((struct NntpMboxData *) extra->ctx->mailbox->mdata)->allowed && query_quadoption(C_PostModerated, _("Posting to this group not allowed, may be moderated. Continue?")) != MUTT_YES)
+ !((struct NntpMboxData *) extra->ctx->mailbox->mdata)->allowed && (query_quadoption(C_PostModerated, _("Posting to this group not allowed, may be moderated. Continue?")) != MUTT_YES))
{
break;
}
mutt_buffer_init(&buf);
char *pexpr = s->dptr;
- if (mutt_extract_token(&buf, s, MUTT_TOKEN_PATTERN | MUTT_TOKEN_COMMENT) != 0 || !buf.data)
+ if ((mutt_extract_token(&buf, s, MUTT_TOKEN_PATTERN | MUTT_TOKEN_COMMENT) != 0) || !buf.data)
{
mutt_buffer_printf(err, _("Error in expression: %s"), pexpr);
FREE(&buf.data);
mutt_buffer_init(&tok_buf);
char *pexpr = s->dptr;
- if (mutt_extract_token(&tok_buf, s, MUTT_TOKEN_PATTERN | MUTT_TOKEN_COMMENT) != 0 ||
+ if ((mutt_extract_token(&tok_buf, s, MUTT_TOKEN_PATTERN | MUTT_TOKEN_COMMENT) != 0) ||
!tok_buf.data)
{
mutt_buffer_printf(err, _("Error in expression: %s"), pexpr);
{
char *ps = NULL;
int offset = strtol(s, &ps, 0);
- if ((sign < 0 && offset > 0) || (sign > 0 && offset < 0))
+ if (((sign < 0) && (offset > 0)) || ((sign > 0) && (offset < 0)))
offset = -offset;
switch (*ps)
struct tm *tm = localtime(&now);
t->tm_mday = strtol(s, &p, 10);
- if (t->tm_mday < 1 || t->tm_mday > 31)
+ if ((t->tm_mday < 1) || (t->tm_mday > 31))
{
mutt_buffer_printf(err, _("Invalid day of month: %s"), s);
return NULL;
}
p++;
t->tm_mon = strtol(p, &p, 10) - 1;
- if (t->tm_mon < 0 || t->tm_mon > 11)
+ if ((t->tm_mon < 0) || (t->tm_mon > 11))
{
mutt_buffer_printf(err, _("Invalid month: %s"), p);
return NULL;
else
{
pc = pt;
- if (flag == MUTT_PDR_NO_FLAGS && !have_min)
+ if ((flag == MUTT_PDR_NO_FLAGS) && !have_min)
{ /* the very first "-3d" without a previous absolute date */
max->tm_year = min->tm_year;
max->tm_mon = min->tm_mon;
*/
static void adjust_date_range(struct tm *min, struct tm *max)
{
- if (min->tm_year > max->tm_year ||
- (min->tm_year == max->tm_year && min->tm_mon > max->tm_mon) ||
- (min->tm_year == max->tm_year && min->tm_mon == max->tm_mon && min->tm_mday > max->tm_mday))
+ if ((min->tm_year > max->tm_year) ||
+ ((min->tm_year == max->tm_year) && (min->tm_mon > max->tm_mon)) ||
+ ((min->tm_year == max->tm_year) && (min->tm_mon == max->tm_mon) &&
+ (min->tm_mday > max->tm_mday)))
{
int tmp;
else
pat->max = MUTT_MAXRANGE;
- if (skip_quote && *tmp == '"')
+ if (skip_quote && (*tmp == '"'))
tmp++;
SKIPWS(tmp);
if (thread_op)
{
ps.dptr++; /* skip ~ */
- if (thread_op == MUTT_PAT_PARENT || thread_op == MUTT_PAT_CHILDREN)
+ if ((thread_op == MUTT_PAT_PARENT) || (thread_op == MUTT_PAT_CHILDREN))
ps.dptr++;
p = find_matching_paren(ps.dptr + 1);
if (*p != ')')
mutt_pattern_free(&curlist);
return NULL;
}
- if (entry->class && (flags & entry->class) == 0)
+ if (entry->class && ((flags & entry->class) == 0))
{
mutt_buffer_printf(err, _("%c: not supported in this mode"), *ps.dptr);
mutt_pattern_free(&curlist);
return 0;
#ifdef USE_IMAP
/* IMAP search sets e->matched at search compile time */
- if (m->magic == MUTT_IMAP && pat->stringmatch)
+ if ((m->magic == MUTT_IMAP) && pat->stringmatch)
return e->matched;
#endif
return pat->not^msg_search(m, pat, e->msgno);
buf[i++] = '"';
while (*str && i < buflen - 3)
{
- if (*str == '\\' || *str == '"')
+ if ((*str == '\\') || (*str == '"'))
buf[i++] = '\\';
buf[i++] = *str++;
}
for (char *p = s; p && *p; p++)
{
- if (*p == '\\' && *(p + 1))
+ if ((*p == '\\') && *(p + 1))
p++;
- else if (*p == '~' || *p == '=' || *p == '%')
+ else if ((*p == '~') || (*p == '=') || (*p == '%'))
{
do_simple = false;
break;
struct Progress progress;
mutt_str_strfcpy(buf, Context->pattern, sizeof(buf));
- if (prompt || op != MUTT_LIMIT)
- if (mutt_get_field(prompt, buf, sizeof(buf), MUTT_PATTERN | MUTT_CLEAR) != 0 || !buf[0])
+ if (prompt || (op != MUTT_LIMIT))
+ if ((mutt_get_field(prompt, buf, sizeof(buf), MUTT_PATTERN | MUTT_CLEAR) != 0) ||
+ !buf[0])
return -1;
mutt_message(_("Compiling search pattern..."));
}
#ifdef USE_IMAP
- if (Context->mailbox->magic == MUTT_IMAP && imap_search(Context->mailbox, pat) < 0)
+ if ((Context->mailbox->magic == MUTT_IMAP) && (imap_search(Context->mailbox, pat) < 0))
goto bail;
#endif
{
struct Progress progress;
- if (!*LastSearch || (op != OP_SEARCH_NEXT && op != OP_SEARCH_OPPOSITE))
+ if (!*LastSearch || ((op != OP_SEARCH_NEXT) && (op != OP_SEARCH_OPPOSITE)))
{
char buf[256];
mutt_str_strfcpy(buf, *LastSearch ? LastSearch : "", sizeof(buf));
- if (mutt_get_field((op == OP_SEARCH || op == OP_SEARCH_NEXT) ?
- _("Search for: ") :
- _("Reverse search for: "),
- buf, sizeof(buf), MUTT_CLEAR | MUTT_PATTERN) != 0 ||
+ if ((mutt_get_field(((op == OP_SEARCH) || (op == OP_SEARCH_NEXT)) ?
+ _("Search for: ") :
+ _("Reverse search for: "),
+ buf, sizeof(buf), MUTT_CLEAR | MUTT_PATTERN) != 0) ||
!buf[0])
{
return -1;
}
- if (op == OP_SEARCH || op == OP_SEARCH_NEXT)
+ if ((op == OP_SEARCH) || (op == OP_SEARCH_NEXT))
OptSearchReverse = false;
else
OptSearchReverse = true;
for (int i = 0; i < Context->mailbox->msg_count; i++)
Context->mailbox->emails[i]->searched = false;
#ifdef USE_IMAP
- if (Context->mailbox->magic == MUTT_IMAP &&
- imap_search(Context->mailbox, SearchPattern) < 0)
+ if ((Context->mailbox->magic == MUTT_IMAP) &&
+ (imap_search(Context->mailbox, SearchPattern) < 0))
return -1;
#endif
OptSearchInvalid = false;
mutt_debug(LL_DEBUG1, "set UIDL capability\n");
}
- if (rc == -2 && adata->cmd_uidl == 2)
+ if ((rc == -2) && (adata->cmd_uidl == 2))
{
adata->cmd_uidl = 0;
sscanf(buf, "+OK %d %d", &msgs, &bytes);
/* only get unread messages */
- if (msgs > 0 && C_PopLast)
+ if ((msgs > 0) && C_PopLast)
{
mutt_str_strfcpy(buf, "LAST\r\n", sizeof(buf));
ret = pop_query(adata, buf, sizeof(buf));
if (ret == -3)
rset = 1;
- if (ret == 0 && mx_msg_commit(ctx->mailbox, msg) != 0)
+ if ((ret == 0) && (mx_msg_commit(ctx->mailbox, msg) != 0))
{
rset = 1;
ret = -3;
*/
int pop_ac_add(struct Account *a, struct Mailbox *m)
{
- if (!a || !m || m->magic != MUTT_POP)
+ if (!a || !m || (m->magic != MUTT_POP))
return -1;
if (!a->adata)
for (i = 0, j = 0, rc = 0; (rc == 0) && (i < m->msg_count); i++)
{
struct PopEmailData *edata = m->emails[i]->edata;
- if (m->emails[i]->deleted && m->emails[i]->refno != -1)
+ if (m->emails[i]->deleted && (m->emails[i]->refno != -1))
{
j++;
if (!m->quiet)
break;
if (mutt_str_startswith(inbuf, "+ ", CASE_MATCH) &&
- sasl_decode64(inbuf + 2, strlen(inbuf + 2), buf, bufsize - 1, &len) != SASL_OK)
+ (sasl_decode64(inbuf + 2, strlen(inbuf + 2), buf, bufsize - 1, &len) != SASL_OK))
{
mutt_debug(LL_DEBUG1, "error base64-decoding server response.\n");
goto bail;
struct Url *url = url_parse(path);
if (!url || ((url->scheme != U_POP) && (url->scheme != U_POPS)) ||
- !url->host || mutt_account_fromurl(acct, url) < 0)
+ !url->host || (mutt_account_fromurl(acct, url) < 0))
{
url_free(&url);
mutt_error(_("Invalid POP URL: %s"), path);
* @retval 0 Successful
* @retval -1 Connection lost
* @retval -2 Invalid response
-*/
+ */
int pop_connect(struct PopAccountData *adata)
{
char buf[1024];
adata->status = POP_NONE;
- if (mutt_socket_open(adata->conn) < 0 ||
- mutt_socket_readln(buf, sizeof(buf), adata->conn) < 0)
+ if ((mutt_socket_open(adata->conn) < 0) ||
+ (mutt_socket_readln(buf, sizeof(buf), adata->conn) < 0))
{
mutt_error(_("Error connecting to server: %s"), adata->conn->account.host);
return -1;
}
char *p = buf;
- if (!lenbuf && buf[0] == '.')
+ if (!lenbuf && (buf[0] == '.'))
{
if (buf[1] != '.')
break;
return 0;
// We currently are in the C_Postponed mailbox so just pick the current status
- if (m && mutt_str_strcmp(C_Postponed, m->realpath) == 0)
+ if (m && (mutt_str_strcmp(C_Postponed, m->realpath) == 0))
{
PostCount = m->msg_count - m->msg_deleted;
return PostCount;
char buf[PATH_MAX];
snprintf(buf, sizeof(buf), "%s/new", C_Postponed);
- if (access(buf, F_OK) == 0 && stat(buf, &st) == -1)
+ if ((access(buf, F_OK) == 0) && (stat(buf, &st) == -1))
{
PostCount = 0;
LastModify = 0;
mutt_set_flag(ctx->mailbox, ctx->mailbox->emails[menu->current],
MUTT_DELETE, (op == OP_DELETE));
PostCount = ctx->mailbox->msg_count - ctx->mailbox->msg_deleted;
- if (C_Resolve && menu->current < menu->max - 1)
+ if (C_Resolve && (menu->current < menu->max - 1))
{
menu->oldcurrent = menu->current;
menu->current++;
if (!results)
{
/* Prompt for Query */
- if (mutt_get_field(_("Query: "), buf, buflen, 0) == 0 && buf[0])
+ if ((mutt_get_field(_("Query: "), buf, buflen, 0) == 0) && buf[0])
{
results = run_query(buf, 0);
}
{
case OP_QUERY_APPEND:
case OP_QUERY:
- if (mutt_get_field(_("Query: "), buf, buflen, 0) == 0 && buf[0])
+ if ((mutt_get_field(_("Query: "), buf, buflen, 0) == 0) && buf[0])
{
struct Query *newresults = run_query(buf, 0);
else
actx->idx[rindex]->tree = mutt_str_strdup(buf);
- if ((2 * (actx->idx[rindex]->level + 2)) < sizeof(buf) && actx->idx[rindex]->level)
+ if (((2 * (actx->idx[rindex]->level + 2)) < sizeof(buf)) &&
+ actx->idx[rindex]->level)
{
s = buf + 2 * (actx->idx[rindex]->level - 1);
*s++ = (actx->idx[rindex]->content->next) ? '\005' : '\006';
snprintf(buf, buflen, fmt,
aptr->content->type != TYPE_TEXT || aptr->content->noconv ? 'n' : 'c');
}
- else if (aptr->content->type != TYPE_TEXT || aptr->content->noconv)
+ else if ((aptr->content->type != TYPE_TEXT) || aptr->content->noconv)
optional = 0;
break;
case 'd':
case 'f':
if (!optional)
{
- if (aptr->content->filename && *aptr->content->filename == '/')
+ if (aptr->content->filename && (*aptr->content->filename == '/'))
{
char path[PATH_MAX];
else
mutt_str_strfcpy(buf, body->filename, sizeof(buf));
}
- else if (body->email && body->encoding != ENC_BASE64 && body->encoding != ENC_QUOTED_PRINTABLE &&
+ else if (body->email && (body->encoding != ENC_BASE64) &&
+ (body->encoding != ENC_QUOTED_PRINTABLE) &&
mutt_is_message_type(body->type, body->subtype))
{
mutt_default_save(buf, sizeof(buf), body->email);
prompt = _("Save to file: ");
while (prompt)
{
- if (mutt_get_field(prompt, buf, sizeof(buf), MUTT_FILE) != 0 || !buf[0])
+ if ((mutt_get_field(prompt, buf, sizeof(buf), MUTT_FILE) != 0) || !buf[0])
{
mutt_clear_error();
return -1;
mutt_str_strfcpy(buf, mutt_path_basename(NONULL(top->filename)), sizeof(buf));
prepend_savedir(buf, sizeof(buf));
- if (mutt_get_field(_("Save to file: "), buf, sizeof(buf), MUTT_FILE) != 0 ||
+ if ((mutt_get_field(_("Save to file: "), buf, sizeof(buf), MUTT_FILE) != 0) ||
!buf[0])
{
return;
/* perform charset conversion on text attachments when piping */
state.flags = MUTT_CHARCONV;
- if (mutt_get_field((filter ? _("Filter through: ") : _("Pipe to: ")), buf,
- sizeof(buf), MUTT_CMD) != 0 ||
+ if ((mutt_get_field((filter ? _("Filter through: ") : _("Pipe to: ")), buf,
+ sizeof(buf), MUTT_CMD) != 0) ||
!buf[0])
{
return;
pid_t pid = mutt_create_filter(buf, &state.fp_out, NULL, NULL);
pipe_attachment_list(buf, actx, fp, tag, top, filter, &state);
mutt_file_fclose(&state.fp_out);
- if (mutt_wait_filter(pid) != 0 || C_WaitKey)
+ if ((mutt_wait_filter(pid) != 0) || C_WaitKey)
mutt_any_key_to_continue(NULL);
}
else
pid_t pid = mutt_create_filter(NONULL(C_PrintCommand), &state.fp_out, NULL, NULL);
print_attachment_list(actx, fp, tag, top, &state);
mutt_file_fclose(&state.fp_out);
- if (mutt_wait_filter(pid) != 0 || C_WaitKey)
+ if ((mutt_wait_filter(pid) != 0) || C_WaitKey)
mutt_any_key_to_continue(NULL);
}
else
mutt_error(_("Can't decrypt encrypted message"));
/* Strip out the top level multipart */
- if (m->type == TYPE_MULTIPART && m->parts && !need_secured &&
- (parent_type == -1 && mutt_str_strcasecmp("alternative", m->subtype)))
+ if ((m->type == TYPE_MULTIPART) && m->parts && !need_secured &&
+ ((parent_type == -1) && mutt_str_strcasecmp("alternative", m->subtype)))
{
mutt_generate_recvattach_list(actx, e, m->parts, fp, m->type, level, decrypted);
}
while ((rindex < actx->idxlen) && (actx->idx[rindex]->level > curlevel))
{
- if (C_DigestCollapse && actx->idx[rindex]->content->type == TYPE_MULTIPART &&
+ if (C_DigestCollapse && (actx->idx[rindex]->content->type == TYPE_MULTIPART) &&
!mutt_str_strcasecmp(actx->idx[rindex]->content->subtype, "digest"))
{
actx->idx[rindex]->content->collapsed = true;
mutt_save_attachment_list(actx, CURATTACH->fp, menu->tagprefix,
CURATTACH->content, e, menu);
- if (!menu->tagprefix && C_Resolve && menu->current < menu->max - 1)
+ if (!menu->tagprefix && C_Resolve && (menu->current < menu->max - 1))
menu->current++;
menu->redraw = REDRAW_MOTION_RESYNC | REDRAW_FULL;
if (CURATTACH->parent_type == TYPE_MULTIPART)
{
CURATTACH->content->deleted = true;
- if (C_Resolve && menu->current < menu->max - 1)
+ if (C_Resolve && (menu->current < menu->max - 1))
{
menu->current++;
menu->redraw = REDRAW_MOTION_RESYNC;
if (!menu->tagprefix)
{
CURATTACH->content->deleted = false;
- if (C_Resolve && menu->current < menu->max - 1)
+ if (C_Resolve && (menu->current < menu->max - 1))
{
menu->current++;
menu->redraw = REDRAW_MOTION_RESYNC;
mutt_str_strfcpy(prompt, _("Bounce tagged messages to: "), sizeof(prompt));
buf[0] = '\0';
- if (mutt_get_field(prompt, buf, sizeof(buf), MUTT_ALIAS) || buf[0] == '\0')
+ if (mutt_get_field(prompt, buf, sizeof(buf), MUTT_ALIAS) || (buf[0] == '\0'))
return;
addr = mutt_addr_parse_list(addr, buf);
* or attach them.
*/
if ((!cur || mutt_can_decode(cur)) &&
- (ans = query_quadoption(C_MimeForward, _("Forward as attachments?"))) == MUTT_YES)
+ ((ans = query_quadoption(C_MimeForward, _("Forward as attachments?"))) == MUTT_YES))
{
mime_fwd_all = true;
}
for (short i = 0; i < actx->idxlen; i++)
{
if (actx->idx[i]->content->tagged &&
- mutt_fetch_recips(env, actx->idx[i]->content->email->env, flags) == -1)
+ (mutt_fetch_recips(env, actx->idx[i]->content->email->env, flags) == -1))
{
return -1;
}
}
}
- if (nattach > 1 && !check_can_decode(actx, cur))
+ if ((nattach > 1) && !check_can_decode(actx, cur))
{
const enum QuadOption ans = query_quadoption(
C_MimeForwardRest, _("Can't decode all tagged attachments. "
for (int i = 0; i < actx->idxlen; i++)
{
if (actx->idx[i]->content->tagged &&
- mutt_fetch_recips(e_tmp->env, actx->idx[i]->content->email->env,
- SEND_TO_SENDER) == -1)
+ (mutt_fetch_recips(e_tmp->env, actx->idx[i]->content->email->env,
+ SEND_TO_SENDER) == -1))
return;
}
}
case OP_GENERIC_SELECT_ENTRY:
case OP_MIX_APPEND:
{
- if (chain->cl < MAXMIXES && c_cur < chain->cl)
+ if ((chain->cl < MAXMIXES) && (c_cur < chain->cl))
c_cur++;
}
/* fallthrough */
for (int i = c_cur; i < chain->cl; i++)
chain->ch[i] = chain->ch[i + 1];
- if (c_cur == chain->cl && c_cur)
+ if ((c_cur == chain->cl) && c_cur)
c_cur--;
mix_screen_coordinates(type2_list, &coords, chain, c_cur);
case OP_MIX_CHAIN_NEXT:
{
- if (chain->cl && c_cur < chain->cl - 1)
+ if (chain->cl && (c_cur < chain->cl - 1))
c_cur++;
else
mutt_error(_("You already have the last chain element selected"));
y += mutt_file_quote_filename(pvalue, buf + y, sizeof(buf) - y);
}
- else if (command[x] == 's' && filename)
+ else if ((command[x] == 's') && filename)
{
y += mutt_file_quote_filename(filename, buf + y, sizeof(buf) - y);
needspipe = false;
ch = get_field(buf);
if ((mutt_str_strcasecmp(buf, type) != 0) &&
((mutt_str_strncasecmp(buf, type, btlen) != 0) ||
- (buf[btlen] != 0 && /* implicit wild */
+ ((buf[btlen] != 0) && /* implicit wild */
(mutt_str_strcmp(buf + btlen, "/*") != 0)))) /* wildsubtype */
{
continue;
ps = 0;
for (i = 0; nametemplate[i]; i++)
{
- if (nametemplate[i] == '%' && nametemplate[i + 1] == 's')
+ if ((nametemplate[i] == '%') && (nametemplate[i + 1] == 's'))
{
ps = 1;
break;
/* note that the following will _not_ read beyond oldfile's end. */
- if (lmatch && nametemplate[i] != oldfile[i])
+ if (lmatch && (nametemplate[i] != oldfile[i]))
lmatch = false;
}
if for DelSp=yes only one trailing space is used, we probably
have a long word that we should break within (we leave that
up to the pager or user) */
- if (!(!fst->spaces && fst->delsp && last != ' ') && w < width &&
- w + fst->width + fst->spaces > width)
+ if (!(!fst->spaces && fst->delsp && (last != ' ')) && (w < width) &&
+ (w + fst->width + fst->spaces > width))
{
mutt_debug(LL_DEBUG3, "f=f: break line at %lu, %lu spaces left\n",
fst->width, fst->spaces);
while (fgets(buf, sizeof(buf), fp_in))
{
- if (buf[0] == ' ' || mutt_str_startswith(buf, "From ", CASE_MATCH))
+ if ((buf[0] == ' ') || mutt_str_startswith(buf, "From ", CASE_MATCH))
{
fputc(' ', fp_out);
lc++;
{
if (OptNeedRescore && C_Score)
{
- if ((C_Sort & SORT_MASK) == SORT_SCORE || (C_SortAux & SORT_MASK) == SORT_SCORE)
+ if (((C_Sort & SORT_MASK) == SORT_SCORE) || ((C_SortAux & SORT_MASK) == SORT_SCORE))
{
OptNeedResort = true;
if ((C_Sort & SORT_MASK) == SORT_THREADS)
{
if (mutt_pattern_exec(tmp->pat, MUTT_MATCH_FULL_ADDRESS, NULL, e, &cache) > 0)
{
- if (tmp->exact || tmp->val == 9999 || tmp->val == -9999)
+ if (tmp->exact || (tmp->val == 9999) || (tmp->val == -9999))
{
e->score = tmp->val;
break;
mutt_str_strfcpy(buf, en->followup_to, sizeof(buf));
else
buf[0] = 0;
- if (C_AskFollowUp && mutt_get_field("Followup-To: ", buf, sizeof(buf), 0) != 0)
+ if (C_AskFollowUp && (mutt_get_field("Followup-To: ", buf, sizeof(buf), 0) != 0))
{
return -1;
}
else
buf[0] = 0;
if (C_XCommentTo && C_AskXCommentTo &&
- mutt_get_field("X-Comment-To: ", buf, sizeof(buf), 0) != 0)
+ (mutt_get_field("X-Comment-To: ", buf, sizeof(buf), 0) != 0))
{
return -1;
}
else
#endif
{
- if (edit_address(&en->to, _("To: ")) == -1 || !en->to)
+ if ((edit_address(&en->to, _("To: ")) == -1) || !en->to)
return -1;
- if (C_Askcc && edit_address(&en->cc, _("Cc: ")) == -1)
+ if (C_Askcc && (edit_address(&en->cc, _("Cc: ")) == -1))
return -1;
- if (C_Askbcc && edit_address(&en->bcc, _("Bcc: ")) == -1)
+ if (C_Askbcc && (edit_address(&en->bcc, _("Bcc: ")) == -1))
return -1;
if (C_ReplyWithXorig && (flags & (SEND_REPLY | SEND_LIST_REPLY | SEND_GROUP_REPLY)) &&
(edit_address(&en->from, "From: ") == -1))
}
}
- if (mutt_get_field(_("Subject: "), buf, sizeof(buf), 0) != 0 ||
- (!buf[0] && query_quadoption(C_AbortNosubject, _("No subject, abort?")) != MUTT_NO))
+ if ((mutt_get_field(_("Subject: "), buf, sizeof(buf), 0) != 0) ||
+ (!buf[0] &&
+ (query_quadoption(C_AbortNosubject, _("No subject, abort?")) != MUTT_NO)))
{
mutt_message(_("No subject, aborting"));
return -1;
{
char prompt[256];
- if (flags && env->mail_followup_to && hmfupto == MUTT_YES)
+ if (flags && env->mail_followup_to && (hmfupto == MUTT_YES))
{
mutt_addr_append(to, env->mail_followup_to, true);
return 0;
mutt_addr_append(to, env->from, false);
}
else if (!(mutt_addr_cmp(env->from, env->reply_to) && !env->reply_to->next) &&
- C_ReplyTo != MUTT_YES)
+ (C_ReplyTo != MUTT_YES))
{
/* There are quite a few mailing lists which set the Reply-To:
* header field to the list address, which makes it quite impossible
mutt_addr_free(&tmp);
if (in->mail_followup_to && (hmfupto == MUTT_YES) &&
- default_to(&out->cc, in, flags & SEND_LIST_REPLY, (hmfupto == MUTT_YES)) == MUTT_ABORT)
+ (default_to(&out->cc, in, flags & SEND_LIST_REPLY, (hmfupto == MUTT_YES)) == MUTT_ABORT))
{
return -1; /* abort */
}
return -1; /* abort */
if ((flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) &&
- (!in->mail_followup_to || hmfupto != MUTT_YES))
+ (!in->mail_followup_to || (hmfupto != MUTT_YES)))
{
/* if(!mutt_addr_is_user(in->to)) */
if (flags & SEND_GROUP_REPLY)
{
fgets(inputline, 1024, fp_att);
if (!mutt_is_quote_line(inputline, NULL) &&
- regexec(C_AbortNoattachRegex->regex, inputline, 0, NULL, 0) == 0)
+ (regexec(C_AbortNoattachRegex->regex, inputline, 0, NULL, 0) == 0))
{
found = true;
break;
(mutt_str_strcmp(msg->content->subtype, "signed") == 0)))
{
if ((clear_content->type == TYPE_MULTIPART) &&
- query_quadoption(C_FccAttach, _("Save attachments in Fcc?")) == MUTT_NO)
+ (query_quadoption(C_FccAttach, _("Save attachments in Fcc?")) == MUTT_NO))
{
if (!(msg->security & SEC_ENCRYPT) && (msg->security & SEC_SIGN))
{
OptNewsSend = false;
#endif
- if (!flags && !msg && C_Recall != MUTT_NO &&
+ if (!flags && !msg && (C_Recall != MUTT_NO) &&
mutt_num_postponed(ctx ? ctx->mailbox : NULL, true))
{
/* If the user is composing a new message, check to see if there
!((flags & SEND_DRAFT_FILE) && C_ResumeDraftFiles))
{
if ((flags & (SEND_REPLY | SEND_FORWARD | SEND_TO_SENDER)) && ctx &&
- envelope_defaults(msg->env, ctx->mailbox, el, flags) == -1)
+ (envelope_defaults(msg->env, ctx->mailbox, el, flags) == -1))
{
goto cleanup;
}
if (!(flags & SEND_KEY))
{
- if (C_TextFlowed && msg->content->type == TYPE_TEXT &&
+ if (C_TextFlowed && (msg->content->type == TYPE_TEXT) &&
(mutt_str_strcasecmp(msg->content->subtype, "plain") == 0))
{
mutt_param_set(&msg->content->parameter, "format", "flowed");
/* include replies/forwarded messages, unless we are given a template */
if (!tempfile && (ctx || !(flags & (SEND_REPLY | SEND_FORWARD))) &&
- generate_body(fp_tmp, msg, flags, ctx->mailbox, el) == -1)
+ (generate_body(fp_tmp, msg, flags, ctx->mailbox, el) == -1))
{
goto cleanup;
}
* recipients.
*/
if (!(flags & SEND_KEY) &&
- ((flags & SEND_FORWARD) == 0 || (C_EditHeaders && C_Autoedit) ||
- query_quadoption(C_ForwardEdit, _("Edit forwarded message?")) == MUTT_YES))
+ (((flags & SEND_FORWARD) == 0) || (C_EditHeaders && C_Autoedit) ||
+ (query_quadoption(C_ForwardEdit, _("Edit forwarded message?")) == MUTT_YES)))
{
/* If the this isn't a text message, look for a mailcap edit command */
if (mutt_needs_mailcap(msg->content))
* performed. If it has already been performed, the format=flowed
* parameter will be present.
*/
- if (C_TextFlowed && msg->content->type == TYPE_TEXT &&
+ if (C_TextFlowed && (msg->content->type == TYPE_TEXT) &&
(mutt_str_strcasecmp("plain", msg->content->subtype) == 0))
{
char *p = mutt_param_get(&msg->content->parameter, "format");
if (stat(msg->content->filename, &st) == 0)
{
/* if the file was not modified, bail out now */
- if (mtime == st.st_mtime && !msg->content->next &&
- query_quadoption(C_AbortUnmodified,
- _("Abort unmodified message?")) == MUTT_YES)
+ if ((mtime == st.st_mtime) && !msg->content->next &&
+ (query_quadoption(C_AbortUnmodified,
+ _("Abort unmodified message?")) == MUTT_YES))
{
mutt_message(_("Aborted unmodified message"));
goto cleanup;
!msg->content->next && (msg->content->type == TYPE_TEXT) &&
(mutt_str_strcasecmp(msg->content->subtype, "plain") == 0) &&
search_attach_keyword(msg->content->filename) &&
- query_quadoption(C_AbortNoattach, _("No attachments, cancel sending?")) != MUTT_NO)
+ (query_quadoption(C_AbortNoattach,
+ _("No attachments, cancel sending?")) != MUTT_NO))
{
/* if the abort is automatic, print an error message */
if (C_AbortNoattach == MUTT_YES)
/* save the decrypted attachments */
clear_content = msg->content;
- if ((crypt_get_keys(msg, &pgpkeylist, 0) == -1) || mutt_protect(msg, pgpkeylist) == -1)
+ if ((crypt_get_keys(msg, &pgpkeylist, 0) == -1) ||
+ (mutt_protect(msg, pgpkeylist) == -1))
{
msg->content = mutt_remove_multipart(msg->content);
if (!WithCrypto)
;
else if ((msg->security & SEC_ENCRYPT) ||
- ((msg->security & SEC_SIGN) && msg->content->type == TYPE_APPLICATION))
+ ((msg->security & SEC_SIGN) && (msg->content->type == TYPE_APPLICATION)))
{
mutt_body_free(&msg->content); /* destroy PGP data */
msg->content = clear_content; /* restore clear text. */
}
- else if ((msg->security & SEC_SIGN) && msg->content->type == TYPE_MULTIPART)
+ else if ((msg->security & SEC_SIGN) && (msg->content->type == TYPE_MULTIPART))
{
mutt_body_free(&msg->content->parts->next); /* destroy sig */
msg->content = mutt_remove_multipart(msg->content);
while ((c = mutt_ch_fgetconv(fc)) != EOF)
{
/* Wrap the line if needed. */
- if (linelen == 76 && ((istext && c != '\n') || !istext))
+ if ((linelen == 76) && ((istext && (c != '\n')) || !istext))
{
/* If the last character is "quoted", then be sure to move all three
* characters to the next line. Otherwise, just move the last
}
/* Escape lines that begin with/only contain "the message separator". */
- if (linelen == 4 && mutt_str_startswith(line, "From", CASE_MATCH))
+ if ((linelen == 4) && mutt_str_startswith(line, "From", CASE_MATCH))
{
mutt_str_strfcpy(line, "=46rom", sizeof(line));
linelen = 6;
}
- else if (linelen == 4 && mutt_str_startswith(line, "from", CASE_MATCH))
+ else if ((linelen == 4) && mutt_str_startswith(line, "from", CASE_MATCH))
{
mutt_str_strfcpy(line, "=66rom", sizeof(line));
linelen = 6;
}
- else if (linelen == 1 && line[0] == '.')
+ else if ((linelen == 1) && (line[0] == '.'))
{
mutt_str_strfcpy(line, "=2E", sizeof(line));
linelen = 3;
}
- if (c == '\n' && istext)
+ if ((c == '\n') && istext)
{
/* Check to make sure there is no trailing space on this line. */
- if (linelen > 0 && (line[linelen - 1] == ' ' || line[linelen - 1] == '\t'))
+ if ((linelen > 0) && ((line[linelen - 1] == ' ') || (line[linelen - 1] == '\t')))
{
if (linelen < 74)
{
fputc('\n', fp_out);
linelen = 0;
}
- else if (c != 9 && (c < 32 || c > 126 || c == '='))
+ else if ((c != 9) && ((c < 32) || (c > 126) || (c == '=')))
{
/* Check to make sure there is enough room for the quoted character.
* If not, wrap to the next line.
/* Take care of anything left in the buffer */
if (linelen > 0)
{
- if (line[linelen - 1] == ' ' || line[linelen - 1] == '\t')
+ if ((line[linelen - 1] == ' ') || (line[linelen - 1] == '\t'))
{
/* take care of trailing whitespace */
if (linelen < 74)
SigInt = 0;
return;
}
- if (istext && ch == '\n' && ch1 != '\r')
+ if (istext && (ch == '\n') && (ch1 != '\r'))
b64_putc(&bctx, '\r', fp_out);
b64_putc(&bctx, ch, fp_out);
ch1 = ch;
}
/* This is pretty gross, but it's the best solution for now... */
- if (((WithCrypto & APPLICATION_PGP) != 0) && a->type == TYPE_APPLICATION &&
+ if (((WithCrypto & APPLICATION_PGP) != 0) && (a->type == TYPE_APPLICATION) &&
(mutt_str_strcmp(a->subtype, "pgp-encrypted") == 0))
{
fputs("Version: 1\n", fp);
return -1;
}
- if (a->type == TYPE_TEXT && (!a->noconv))
+ if ((a->type == TYPE_TEXT) && (!a->noconv))
{
char send_charset[128];
fc = mutt_ch_fgetconv_open(
encode_quoted(fc, fp, write_as_text_part(a));
else if (a->encoding == ENC_BASE64)
encode_base64(fc, fp, write_as_text_part(a));
- else if (a->type == TYPE_TEXT && (!a->noconv))
+ else if ((a->type == TYPE_TEXT) && (!a->noconv))
encode_8bit(fc, fp);
else
mutt_file_copy_stream(fp_in, fp);
}
else if (ch & 0x80)
info->hibin++;
- else if (ch == '\t' || ch == '\f')
+ else if ((ch == '\t') || (ch == '\f'))
{
info->ascii++;
whitespace++;
info->nulbin++;
info->lobin++;
}
- else if (ch < 32 || ch == 127)
+ else if ((ch < 32) || (ch == 127))
info->lobin++;
else
{
}
else if (from)
{
- if (linelen == 2 && ch != 'r')
+ if ((linelen == 2) && (ch != 'r'))
from = false;
- else if (linelen == 3 && ch != 'o')
+ else if ((linelen == 3) && (ch != 'o'))
from = false;
else if (linelen == 4)
{
if (linelen > 1)
dot = false;
- if (ch != ' ' && ch != '\t')
+ if ((ch != ' ') && (ch != '\t'))
whitespace = 0;
}
size_t obl = sizeof(bufu);
n = iconv(cd1, (ICONV_CONST char **) (ibl ? &ib : 0), &ibl, &ob, &obl);
/* assert(n == (size_t)(-1) || !n); */
- if (n == (size_t)(-1) && ((errno != EINVAL && errno != E2BIG) || ib == bufi))
+ if ((n == (size_t)(-1)) && (((errno != EINVAL) && (errno != E2BIG)) || (ib == bufi)))
{
/* assert(errno == EILSEQ || (errno == EINVAL && ib == bufi && ibl < sizeof(bufi))); */
ret = (size_t)(-1);
/* Convert from UTF-8 */
for (int i = 0; i < ncodes; i++)
{
- if (cd[i] != (iconv_t)(-1) && score[i] != (size_t)(-1))
+ if ((cd[i] != (iconv_t)(-1)) && (score[i] != (size_t)(-1)))
{
const char *ub = bufu;
size_t ubl = ubl1;
update_content_info(&infos[i], &states[i], bufo, ob - bufo);
}
}
- else if (cd[i] == (iconv_t)(-1) && score[i] == (size_t)(-1))
+ else if ((cd[i] == (iconv_t)(-1)) && (score[i] == (size_t)(-1)))
{
/* Special case for conversion to UTF-8 */
update_content_info(&infos[i], &states[i], bufu, ubl1);
/* Save unused input */
memmove(bufi, ib, ibl);
}
- else if (!ubl1 && ib < bufi + sizeof(bufi))
+ else if (!ubl1 && (ib < bufi + sizeof(bufi)))
{
ret = 0;
break;
ret = (size_t)(-1);
for (int i = 0; i < ncodes; i++)
{
- if (cd[i] == (iconv_t)(-1) && score[i] == (size_t)(-1))
+ if ((cd[i] == (iconv_t)(-1)) && (score[i] == (size_t)(-1)))
{
/* Special case for conversion to UTF-8 */
*tocode = i;
ret = 0;
break;
}
- else if (cd[i] == (iconv_t)(-1) || score[i] == (size_t)(-1))
+ else if ((cd[i] == (iconv_t)(-1)) || (score[i] == (size_t)(-1)))
continue;
- else if (ret == (size_t)(-1) || score[i] < ret)
+ else if ((ret == (size_t)(-1)) || (score[i] < ret))
{
*tocode = i;
ret = score[i];
info = mutt_mem_calloc(1, sizeof(struct Content));
- if (b && b->type == TYPE_TEXT && (!b->noconv && !b->force_charset))
+ if (b && (b->type == TYPE_TEXT) && (!b->noconv && !b->force_charset))
{
char *chs = mutt_param_get(&b->parameter, "charset");
char *fchs = b->use_disp ?
((C_AttachCharset && *C_AttachCharset) ? C_AttachCharset : C_Charset) :
C_Charset;
if (C_Charset && (chs || C_SendCharset) &&
- convert_file_from_to(fp, fchs, chs ? chs : C_SendCharset, &fromcode,
- &tocode, info) != (size_t)(-1))
+ (convert_file_from_to(fp, fchs, chs ? chs : C_SendCharset, &fromcode,
+ &tocode, info) != (size_t)(-1)))
{
if (!chs)
{
mutt_file_fclose(&fp);
- if (b && b->type == TYPE_TEXT && (!b->noconv && !b->force_charset))
+ if (b && (b->type == TYPE_TEXT) && (!b->noconv && !b->force_charset))
{
mutt_param_set(&b->parameter, "charset",
(!info->hibin ?
if ((sze > cur_sze) && (szf >= sze) &&
((mutt_str_strcasecmp(path + szf - sze, p) == 0) ||
(mutt_str_strcasecmp(path + szf - sze, p) == 0)) &&
- (szf == sze || path[szf - sze - 1] == '.'))
+ ((szf == sze) || (path[szf - sze - 1] == '.')))
{
/* get the content-type */
mutt_error(_("Could not find any mime.types file."));
}
- if (type != TYPE_OTHER || *xtype != '\0')
+ if ((type != TYPE_OTHER) || (*xtype != '\0'))
{
att->type = type;
mutt_str_replace(&att->subtype, subtype);
cleanup:
FREE(&line);
- if (fp_in && fp_in != fp)
+ if (fp_in && (fp_in != fp))
mutt_file_fclose(&fp_in);
if (fp_out)
mutt_file_fclose(&fp_out);
char send_charset[128];
char *chsname = mutt_body_get_charset(b, send_charset, sizeof(send_charset));
if ((info->lobin && !mutt_str_startswith(chsname, "iso-2022", CASE_IGNORE)) ||
- info->linemax > 990 || (info->from && C_EncodeFrom))
+ (info->linemax > 990) || (info->from && C_EncodeFrom))
{
b->encoding = ENC_QUOTED_PRINTABLE;
}
b->encoding = ENC_7BIT;
}
}
- else if (b->type == TYPE_MESSAGE || b->type == TYPE_MULTIPART)
+ else if ((b->type == TYPE_MESSAGE) || (b->type == TYPE_MULTIPART))
{
if (info->lobin || info->hibin)
{
else
b->encoding = ENC_7BIT;
}
- else if (b->type == TYPE_APPLICATION &&
+ else if ((b->type == TYPE_APPLICATION) &&
(mutt_str_strcasecmp(b->subtype, "pgp-keys") == 0))
{
b->encoding = ENC_7BIT;
if (!att->subtype)
{
if ((info->nulbin == 0) &&
- (info->lobin == 0 || (info->lobin + info->hibin + info->ascii) / info->lobin >= 10))
+ ((info->lobin == 0) || ((info->lobin + info->hibin + info->ascii) / info->lobin >= 10)))
{
/* Statistically speaking, there should be more than 10% "lobin"
* chars if this is really a binary file...
buf[0] = 0;
mutt_addr_write(buf, sizeof(buf), addr, display);
size_t len = mutt_str_strlen(buf);
- if (count && linelen + len > 74)
+ if (count && (linelen + len > 74))
{
fputs("\n\t", fp);
linelen = len + 8; /* tab is usually about 8 spaces... */
return -1;
/* corner-case: break words longer than 998 chars by force,
* mandated by RFC5322 */
- if (!(chflags & CH_DISPLAY) && ++col >= 998)
+ if (!(chflags & CH_DISPLAY) && (++col >= 998))
{
if (fputs("\n ", fp) < 0)
return -1;
}
if (*value == '\n')
{
- if (*(value + 1) && pfx && *pfx && fputs(pfx, fp) == EOF)
+ if (*(value + 1) && pfx && *pfx && (fputs(pfx, fp) == EOF))
return -1;
/* for display, turn folding spaces into folding tabs */
- if ((chflags & CH_DISPLAY) && (*(value + 1) == ' ' || *(value + 1) == '\t'))
+ if ((chflags & CH_DISPLAY) && ((*(value + 1) == ' ') || (*(value + 1) == '\t')))
{
value++;
while (*value && (*value == ' ' || *value == '\t'))
mutt_debug(5, "pfx=[%s], tag=[%s], flags=%d value=[%s]\n", pfx, tag, chflags,
NONULL(value));
- if (tag && *tag && fprintf(fp, "%s%s: ", NONULL(pfx), tag) < 0)
+ if (tag && *tag && (fprintf(fp, "%s%s: ", NONULL(pfx), tag) < 0))
return -1;
col = mutt_str_strlen(tag) + (tag && *tag ? 2 : 0) + mutt_str_strlen(pfx);
/* insert a folding \n before the current word's lwsp except for
* header name, first word on a line (word longer than wrap width)
* and encoded words */
- if (!first && !enc && col && col + w >= wraplen)
+ if (!first && !enc && col && (col + w >= wraplen))
{
col = mutt_str_strlen(pfx);
fold = 1;
/* if we have printed something but didn't \n-terminate it, do it
* except the last word we printed ended in \n already */
- if (col && (l == 0 || buf[l - 1] != '\n'))
+ if (col && ((l == 0) || (buf[l - 1] != '\n')))
if (putc('\n', fp) == EOF)
return -1;
while (p && *p)
{
/* remove CRLF prior to FWSP, turn \t into ' ' */
- if (*p == '\r' && *(p + 1) && *(p + 1) == '\n' && *(p + 2) &&
- (*(p + 2) == ' ' || *(p + 2) == '\t'))
+ if ((*p == '\r') && *(p + 1) && (*(p + 1) == '\n') && *(p + 2) &&
+ ((*(p + 2) == ' ') || (*(p + 2) == '\t')))
{
*q++ = ' ';
p += 3;
continue;
}
/* remove LF prior to FWSP, turn \t into ' ' */
- else if (*p == '\n' && *(p + 1) && (*(p + 1) == ' ' || *(p + 1) == '\t'))
+ else if ((*p == '\n') && *(p + 1) && ((*(p + 1) == ' ') || (*(p + 1) == '\t')))
{
*q++ = ' ';
p += 2;
/* only pass through folding machinery if necessary for sending,
never wrap From_ headers on sending */
- if (!(chflags & CH_DISPLAY) && (pfxw + max <= wraplen || is_from))
+ if (!(chflags & CH_DISPLAY) && ((pfxw + max <= wraplen) || is_from))
{
valbuf = mutt_str_substr_dup(start, end);
mutt_debug(5, "buf[%s%s] short enough, max width = %d <= %d\n", NONULL(pfx),
else
{
t = strchr(start, ':');
- if (!t || t > end)
+ if (!t || (t > end))
{
mutt_debug(LL_DEBUG1, "#2 warning: header not in 'key: value' format!\n");
return 0;
/* when not displaying, use sane wrap value */
if (!display)
{
- if (C_WrapHeaders < 78 || C_WrapHeaders > 998)
+ if ((C_WrapHeaders < 78) || (C_WrapHeaders > 998))
wraplen = 78;
else
wraplen = C_WrapHeaders;
}
- else if (wraplen <= 0 || wraplen > MuttIndexWindow->cols)
+ else if ((wraplen <= 0) || (wraplen > MuttIndexWindow->cols))
wraplen = MuttIndexWindow->cols;
if (tag)
{
/* if header is short enough, simply print it */
- if (!display && mutt_strwidth(tag) + 2 + pfxw + mutt_strwidth(v) <= wraplen)
+ if (!display && (mutt_strwidth(tag) + 2 + pfxw + mutt_strwidth(v) <= wraplen))
{
mutt_debug(5, "buf[%s%s: %s] is short enough\n", NONULL(pfx), tag, v);
if (fprintf(fp, "%s%s: %s\n", NONULL(pfx), tag, v) <= 0)
break;
line = ++p;
- if (*p != ' ' && *p != '\t')
+ if ((*p != ' ') && (*p != '\t'))
{
if (write_one_header(fp, pfxw, max, wraplen, pfx, last, p, chflags) < 0)
goto out;
char *p = NULL, *q = NULL;
bool has_agent = false; /* user defined user-agent header field exists */
- if (mode == MUTT_WRITE_HEADER_NORMAL && !privacy)
+ if ((mode == MUTT_WRITE_HEADER_NORMAL) && !privacy)
fputs(mutt_date_make_date(buf, sizeof(buf)), fp);
/* UseFrom is not consulted here so that we can still write a From:
if (env->bcc)
{
- if (mode == MUTT_WRITE_HEADER_POSTPONE || mode == MUTT_WRITE_HEADER_EDITHDRS ||
- (mode == MUTT_WRITE_HEADER_NORMAL && C_WriteBcc))
+ if ((mode == MUTT_WRITE_HEADER_POSTPONE) || (mode == MUTT_WRITE_HEADER_EDITHDRS) ||
+ ((mode == MUTT_WRITE_HEADER_NORMAL) && C_WriteBcc))
{
fputs("Bcc: ", fp);
mutt_write_address_list(env->bcc, fp, 5, 0);
#ifdef USE_NNTP
if (env->newsgroups)
fprintf(fp, "Newsgroups: %s\n", env->newsgroups);
- else if (mode == MUTT_WRITE_HEADER_EDITHDRS && OptNewsSend)
+ else if ((mode == MUTT_WRITE_HEADER_EDITHDRS) && OptNewsSend)
fputs("Newsgroups:\n", fp);
if (env->followup_to)
fprintf(fp, "Followup-To: %s\n", env->followup_to);
- else if (mode == MUTT_WRITE_HEADER_EDITHDRS && OptNewsSend)
+ else if ((mode == MUTT_WRITE_HEADER_EDITHDRS) && OptNewsSend)
fputs("Followup-To:\n", fp);
if (env->x_comment_to)
fprintf(fp, "X-Comment-To: %s\n", env->x_comment_to);
- else if (mode == MUTT_WRITE_HEADER_EDITHDRS && OptNewsSend && C_XCommentTo)
+ else if ((mode == MUTT_WRITE_HEADER_EDITHDRS) && OptNewsSend && C_XCommentTo)
fputs("X-Comment-To:\n", fp);
#endif
if (env->subject)
{
if (hide_protected_subject &&
- (mode == MUTT_WRITE_HEADER_NORMAL || mode == MUTT_WRITE_HEADER_POSTPONE))
+ ((mode == MUTT_WRITE_HEADER_NORMAL) || (mode == MUTT_WRITE_HEADER_POSTPONE)))
mutt_write_one_header(fp, "Subject", C_CryptProtectedHeadersSubject, NULL, 0, 0);
else
mutt_write_one_header(fp, "Subject", env->subject, NULL, 0, 0);
mutt_write_address_list(env->mail_followup_to, fp, 18, 0);
}
- if (mode == MUTT_WRITE_HEADER_NORMAL || mode == MUTT_WRITE_HEADER_POSTPONE)
+ if ((mode == MUTT_WRITE_HEADER_NORMAL) || (mode == MUTT_WRITE_HEADER_POSTPONE))
{
if (!STAILQ_EMPTY(&env->references))
{
}
}
- if (mode == MUTT_WRITE_HEADER_NORMAL && !privacy && C_UserAgent && !has_agent)
+ if ((mode == MUTT_WRITE_HEADER_NORMAL) && !privacy && C_UserAgent && !has_agent)
{
/* Add a vanity header */
fprintf(fp, "User-Agent: NeoMutt/%s%s\n", PACKAGE_VERSION, GitVer);
sigaddset(&set, SIGTSTP);
sigprocmask(SIG_BLOCK, &set, NULL);
- if (C_SendmailWait >= 0 && tempfile)
+ if ((C_SendmailWait >= 0) && tempfile)
{
char tmp[PATH_MAX];
}
unlink(msg);
- if (C_SendmailWait >= 0 && tempfile && *tempfile)
+ if ((C_SendmailWait >= 0) && tempfile && *tempfile)
{
/* *tempfile will be opened as stdout */
if (open(*tempfile, O_WRONLY | O_APPEND | O_CREAT | O_EXCL, 0600) < 0)
if (waitpid(pid, &st, 0) > 0)
{
st = WIFEXITED(st) ? WEXITSTATUS(st) : S_ERR;
- if (C_SendmailWait && st == (0xff & EX_OK) && tempfile && *tempfile)
+ if (C_SendmailWait && (st == (0xff & EX_OK)) && tempfile && *tempfile)
{
unlink(*tempfile); /* no longer needed */
FREE(tempfile);
else
{
st = (C_SendmailWait > 0 && errno == EINTR && SigAlrm) ? S_BKG : S_ERR;
- if (C_SendmailWait > 0 && tempfile && *tempfile)
+ if ((C_SendmailWait > 0) && tempfile && *tempfile)
{
unlink(*tempfile);
FREE(tempfile);
sigaction(SIGALRM, &oldalrm, NULL);
}
- if (kill(ppid, 0) == -1 && errno == ESRCH && tempfile && *tempfile)
+ if ((kill(ppid, 0) == -1) && (errno == ESRCH) && tempfile && *tempfile)
{
/* the parent is already dead */
unlink(*tempfile);
sigprocmask(SIG_UNBLOCK, &set, NULL);
- if (pid != -1 && waitpid(pid, &st, 0) > 0)
+ if ((pid != -1) && (waitpid(pid, &st, 0) > 0))
st = WIFEXITED(st) ? WEXITSTATUS(st) : S_ERR; /* return child status */
else
st = S_ERR; /* error */
{
struct stat st;
- if (stat(childout, &st) == 0 && st.st_size > 0)
+ if ((stat(childout, &st) == 0) && (st.st_size > 0))
mutt_do_pager(_("Output of the delivery process"), childout, 0, NULL);
}
}
{
for (; b; b = b->next)
{
- if (b->type == TYPE_MESSAGE || b->type == TYPE_MULTIPART)
+ if ((b->type == TYPE_MESSAGE) || (b->type == TYPE_MULTIPART))
set_noconv_flags(b->parts, flag);
- else if (b->type == TYPE_TEXT && b->noconv)
+ else if ((b->type == TYPE_TEXT) && b->noconv)
{
if (flag)
mutt_param_set(&b->parameter, "x-mutt-noconv", "yes");
snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, c ? Context->mailbox->vcount : m->msg_count);
}
- else if ((c && Context->mailbox->vcount == m->msg_count) || !c)
+ else if ((c && (Context->mailbox->vcount == m->msg_count)) || !c)
optional = 0;
break;
{
int entry = HilIndex;
- if (!EntryCount || HilIndex < 0)
+ if (!EntryCount || (HilIndex < 0))
return false;
do
{
int entry = HilIndex;
- if (!EntryCount || HilIndex < 0)
+ if (!EntryCount || (HilIndex < 0))
return false;
do
{
int entry = HilIndex;
- if (!EntryCount || HilIndex < 0)
+ if (!EntryCount || (HilIndex < 0))
return false;
do
{
int entry = HilIndex;
- if (!EntryCount || HilIndex < 0)
+ if (!EntryCount || (HilIndex < 0))
return false;
do
{
int orig_hil_index = HilIndex;
- if (!EntryCount || BotIndex < 0)
+ if (!EntryCount || (BotIndex < 0))
return 0;
HilIndex = BotIndex;
{
int orig_hil_index = HilIndex;
- if (!EntryCount || TopIndex < 0)
+ if (!EntryCount || (TopIndex < 0))
return 0;
HilIndex = TopIndex;
FREE(&Entries[del_index]);
EntryCount--;
- if (TopIndex > del_index || TopIndex == EntryCount)
+ if ((TopIndex > del_index) || (TopIndex == EntryCount))
TopIndex--;
if (OpnIndex == del_index)
OpnIndex = -1;
else if (OpnIndex > del_index)
OpnIndex--;
- if (HilIndex > del_index || HilIndex == EntryCount)
+ if ((HilIndex > del_index) || (HilIndex == EntryCount))
HilIndex--;
- if (BotIndex > del_index || BotIndex == EntryCount)
+ if ((BotIndex > del_index) || (BotIndex == EntryCount))
BotIndex--;
for (; del_index < EntryCount; del_index++)
} while (buf[3] == '-');
- if (smtp_success(n) || n == SMTP_CONTINUE)
+ if (smtp_success(n) || (n == SMTP_CONTINUE))
return 0;
mutt_error(_("SMTP session failed: %s"), buf);
{
buflen = mutt_str_strlen(buf);
term = buflen && buf[buflen - 1] == '\n';
- if (term && (buflen == 1 || buf[buflen - 2] != '\r'))
+ if (term && ((buflen == 1) || (buf[buflen - 2] != '\r')))
snprintf(buf + buflen - 1, sizeof(buf) - buflen + 1, "\r\n");
if (buf[0] == '.')
{
}
mutt_progress_update(&progress, ftell(fp), -1);
}
- if (!term && buflen && mutt_socket_send_d(conn, "\r\n", MUTT_SOCK_LOG_FULL) == -1)
+ if (!term && buflen && (mutt_socket_send_d(conn, "\r\n", MUTT_SOCK_LOG_FULL) == -1))
{
mutt_file_fclose(&fp);
return SMTP_ERR_WRITE;
account->type = MUTT_ACCT_TYPE_SMTP;
struct Url *url = url_parse(C_SmtpUrl);
- if (!url || (url->scheme != U_SMTP && url->scheme != U_SMTPS) || !url->host ||
- mutt_account_fromurl(account, url) < 0)
+ if (!url || ((url->scheme != U_SMTP) && (url->scheme != U_SMTPS)) ||
+ !url->host || (mutt_account_fromurl(account, url) < 0))
{
url_free(&url);
mutt_error(_("Invalid SMTP URL: %s"), C_SmtpUrl);
if (conn->account.flags & MUTT_ACCT_USER)
esmtp = true;
#ifdef USE_SSL
- if (C_SslForceTls || C_SslStarttls != MUTT_NO)
+ if (C_SslForceTls || (C_SslStarttls != MUTT_NO))
esmtp = true;
#endif
}
mutt_sasl_interact(interaction);
} while (rc == SASL_INTERACT);
- if (rc != SASL_OK && rc != SASL_CONTINUE)
+ if ((rc != SASL_OK) && (rc != SASL_CONTINUE))
{
mutt_debug(LL_DEBUG2, "%s unavailable\n", mech);
sasl_dispose(&saslconn);
#endif
}
- if (r == SMTP_AUTH_FAIL && delim)
+ if ((r == SMTP_AUTH_FAIL) && delim)
{
mutt_error(_("%s authentication failed, trying next method"), method);
}
else if (C_SslForceTls)
ans = MUTT_YES;
else if ((Capabilities & SMTP_CAP_STARTTLS) &&
- (ans = query_quadoption(C_SslStarttls,
- _("Secure connection with TLS?"))) == MUTT_ABORT)
+ ((ans = query_quadoption(C_SslStarttls,
+ _("Secure connection with TLS?"))) == MUTT_ABORT))
{
return -1;
}
for (int i = 0; i < ctx->mailbox->msg_count; i++)
{
struct Email *cur = ctx->mailbox->emails[i];
- if (cur->virtual != -1 || (cur->collapsed && (!ctx->pattern || cur->limited)))
+ if ((cur->virtual != -1) || (cur->collapsed && (!ctx->pattern || cur->limited)))
{
cur->virtual = ctx->mailbox->vcount;
ctx->mailbox->v2r[ctx->mailbox->vcount] = i;
while (*t)
{
state_putc(*t, s);
- if (*t++ == '\n' && *t)
+ if ((*t++ == '\n') && *t)
if (*t != '\n')
state_mark_attach(s);
}
/* If tsl is set, then terminfo says that status lines work. */
char *tcaps = tigetstr("tsl");
- if (tcaps && tcaps != (char *) -1 && *tcaps)
+ if (tcaps && (tcaps != (char *) -1) && *tcaps)
{
/* update the static definitions of tsl/fsl from terminfo */
tsl = tcaps;
projects / neomutt / commitdiff