{ N_("Help"), OP_HELP }, { NULL, 0 },
};
-static const char *alias_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *fmt,
- const char *ifstring, const char *elsestring,
+static const char *alias_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
- char tmp[SHORT_STRING], adr[SHORT_STRING];
+ char fmt[SHORT_STRING], adr[SHORT_STRING];
struct Alias *alias = (struct Alias *) data;
switch (op)
{
case 'f':
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, alias->del ? "D" : " ");
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, alias->del ? "D" : " ");
break;
case 'a':
- mutt_format_s(dest, destlen, fmt, alias->name);
+ mutt_format_s(buf, buflen, prec, alias->name);
break;
case 'r':
adr[0] = '\0';
rfc822_write_address(adr, sizeof(adr), alias->addr, 1);
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, adr);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, adr);
break;
case 'n':
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, alias->num + 1);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, alias->num + 1);
break;
case 't':
- dest[0] = alias->tagged ? '*' : ' ';
- dest[1] = '\0';
+ buf[0] = alias->tagged ? '*' : ' ';
+ buf[1] = '\0';
break;
}
return src;
}
-static void alias_entry(char *s, size_t slen, struct Menu *m, int num)
+static void alias_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
- mutt_expando_format(s, slen, 0, MuttIndexWindow->cols, NONULL(AliasFormat), alias_format_str,
- (unsigned long) ((struct Alias **) m->data)[num],
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(AliasFormat), alias_format_str,
+ (unsigned long) ((struct Alias **) menu->data)[num],
MUTT_FORMAT_ARROWCURSOR);
}
return 0;
}
-static const char *folder_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *fmt,
- const char *ifstring, const char *elsestring,
+static const char *folder_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
- char fn[SHORT_STRING], tmp[SHORT_STRING], permission[11];
+ char fn[SHORT_STRING], fmt[SHORT_STRING], permission[11];
char date[SHORT_STRING], *t_fmt = NULL;
time_t tnow;
struct Folder *folder = (struct Folder *) data;
switch (op)
{
case 'C':
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, folder->num + 1);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, folder->num + 1);
break;
case 'd':
if (!do_locales)
setlocale(LC_TIME, "");
- mutt_format_s(dest, destlen, fmt, date);
+ mutt_format_s(buf, buflen, prec, date);
}
else
- mutt_format_s(dest, destlen, fmt, "");
+ mutt_format_s(buf, buflen, prec, "");
break;
case 'f':
((folder->ff->mode & S_IXUSR) != 0 ? "*" : ""))) :
"");
- mutt_format_s(dest, destlen, fmt, fn);
+ mutt_format_s(buf, buflen, prec, fn);
break;
}
case 'F':
(folder->ff->mode & S_ISVTX) != 0 ?
't' :
(folder->ff->mode & S_IXOTH) != 0 ? 'x' : '-');
- mutt_format_s(dest, destlen, fmt, permission);
+ mutt_format_s(buf, buflen, prec, permission);
}
#ifdef USE_IMAP
else if (folder->ff->imap)
/* mark folders with subfolders AND mail */
snprintf(permission, sizeof(permission), "IMAP %c",
(folder->ff->inferiors && folder->ff->selectable) ? '+' : ' ');
- mutt_format_s(dest, destlen, fmt, permission);
+ mutt_format_s(buf, buflen, prec, permission);
}
#endif
else
- mutt_format_s(dest, destlen, fmt, "");
+ mutt_format_s(buf, buflen, prec, "");
break;
case 'g':
if (folder->ff->local)
{
if ((gr = getgrgid(folder->ff->gid)))
- mutt_format_s(dest, destlen, fmt, gr->gr_name);
+ mutt_format_s(buf, buflen, prec, gr->gr_name);
else
{
- snprintf(tmp, sizeof(tmp), "%%%sld", fmt);
- snprintf(dest, destlen, tmp, folder->ff->gid);
+ snprintf(fmt, sizeof(fmt), "%%%sld", prec);
+ snprintf(buf, buflen, fmt, folder->ff->gid);
}
}
else
- mutt_format_s(dest, destlen, fmt, "");
+ mutt_format_s(buf, buflen, prec, "");
break;
case 'l':
if (folder->ff->local)
{
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, folder->ff->nlink);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, folder->ff->nlink);
}
else
- mutt_format_s(dest, destlen, fmt, "");
+ mutt_format_s(buf, buflen, prec, "");
break;
case 'm':
{
if (folder->ff->has_buffy)
{
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, folder->ff->msg_count);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, folder->ff->msg_count);
}
else
- mutt_format_s(dest, destlen, fmt, "");
+ mutt_format_s(buf, buflen, prec, "");
}
else if (!folder->ff->msg_count)
optional = 0;
break;
case 'N':
- snprintf(tmp, sizeof(tmp), "%%%sc", fmt);
- snprintf(dest, destlen, tmp, folder->ff->new ? 'N' : ' ');
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, folder->ff->new ? 'N' : ' ');
break;
case 'n':
{
if (folder->ff->has_buffy)
{
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, folder->ff->msg_unread);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, folder->ff->msg_unread);
}
else
- mutt_format_s(dest, destlen, fmt, "");
+ mutt_format_s(buf, buflen, prec, "");
}
else if (!folder->ff->msg_unread)
optional = 0;
if (folder->ff->local)
{
mutt_pretty_size(fn, sizeof(fn), folder->ff->size);
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, fn);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, fn);
}
else
- mutt_format_s(dest, destlen, fmt, "");
+ mutt_format_s(buf, buflen, prec, "");
break;
case 't':
- snprintf(tmp, sizeof(tmp), "%%%sc", fmt);
- snprintf(dest, destlen, tmp, folder->ff->tagged ? '*' : ' ');
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, folder->ff->tagged ? '*' : ' ');
break;
case 'u':
if (folder->ff->local)
{
if ((pw = getpwuid(folder->ff->uid)))
- mutt_format_s(dest, destlen, fmt, pw->pw_name);
+ mutt_format_s(buf, buflen, prec, pw->pw_name);
else
{
- snprintf(tmp, sizeof(tmp), "%%%sld", fmt);
- snprintf(dest, destlen, tmp, folder->ff->uid);
+ snprintf(fmt, sizeof(fmt), "%%%sld", prec);
+ snprintf(buf, buflen, fmt, folder->ff->uid);
}
}
else
- mutt_format_s(dest, destlen, fmt, "");
+ mutt_format_s(buf, buflen, prec, "");
break;
default:
- snprintf(tmp, sizeof(tmp), "%%%sc", fmt);
- snprintf(dest, destlen, tmp, op);
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, op);
break;
}
if (optional)
- mutt_expando_format(dest, destlen, col, cols, ifstring, folder_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, if_str, folder_format_str, data, 0);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, cols, elsestring, folder_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, else_str, folder_format_str, data, 0);
return src;
}
#ifdef USE_NNTP
-static const char *group_index_format_str(char *dest, size_t destlen, size_t col,
- int cols, char op, const char *src,
- const char *fmt, const char *ifstring,
- const char *elsestring,
+static const char *group_index_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
- char fn[SHORT_STRING], tmp[SHORT_STRING];
+ char fn[SHORT_STRING], fmt[SHORT_STRING];
struct Folder *folder = (struct Folder *) data;
switch (op)
{
case 'C':
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, folder->num + 1);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, folder->num + 1);
break;
case 'f':
strncpy(fn, folder->ff->name, sizeof(fn) - 1);
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, fn);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, fn);
break;
case 'N':
- snprintf(tmp, sizeof(tmp), "%%%sc", fmt);
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
if (folder->ff->nd->subscribed)
- snprintf(dest, destlen, tmp, ' ');
+ snprintf(buf, buflen, fmt, ' ');
else
- snprintf(dest, destlen, tmp, folder->ff->new ? 'N' : 'u');
+ snprintf(buf, buflen, fmt, folder->ff->new ? 'N' : 'u');
break;
case 'M':
- snprintf(tmp, sizeof(tmp), "%%%sc", fmt);
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
if (folder->ff->nd->deleted)
- snprintf(dest, destlen, tmp, 'D');
+ snprintf(buf, buflen, fmt, 'D');
else
- snprintf(dest, destlen, tmp, folder->ff->nd->allowed ? ' ' : '-');
+ snprintf(buf, buflen, fmt, folder->ff->nd->allowed ? ' ' : '-');
break;
case 's':
if (flags & MUTT_FORMAT_OPTIONAL)
{
if (folder->ff->nd->unread != 0)
- mutt_expando_format(dest, destlen, col, cols, ifstring,
+ mutt_expando_format(buf, buflen, col, cols, if_str,
group_index_format_str, data, flags);
else
- mutt_expando_format(dest, destlen, col, cols, elsestring,
+ mutt_expando_format(buf, buflen, col, cols, else_str,
group_index_format_str, data, flags);
}
else if (Context && Context->data == folder->ff->nd)
{
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, Context->unread);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, Context->unread);
}
else
{
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, folder->ff->nd->unread);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, folder->ff->nd->unread);
}
break;
case 'n':
if (Context && Context->data == folder->ff->nd)
{
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, Context->new);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, Context->new);
}
else if (option(OPT_MARK_OLD) &&
folder->ff->nd->last_cached >= folder->ff->nd->first_message &&
folder->ff->nd->last_cached <= folder->ff->nd->last_message)
{
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp,
- folder->ff->nd->last_message - folder->ff->nd->last_cached);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, folder->ff->nd->last_message - folder->ff->nd->last_cached);
}
else
{
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, folder->ff->nd->unread);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, folder->ff->nd->unread);
}
break;
case 'd':
if (folder->ff->nd->desc)
{
- char *buf = mutt_str_strdup(folder->ff->nd->desc);
+ char *desc = mutt_str_strdup(folder->ff->nd->desc);
if (NewsgroupsCharset && *NewsgroupsCharset)
- mutt_convert_string(&buf, NewsgroupsCharset, Charset, MUTT_ICONV_HOOK_FROM);
- mutt_filter_unprintable(&buf);
+ mutt_convert_string(&desc, NewsgroupsCharset, Charset, MUTT_ICONV_HOOK_FROM);
+ mutt_filter_unprintable(&desc);
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, buf);
- FREE(&buf);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(desc, buflen, fmt, desc);
+ FREE(&desc);
}
else
{
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, "");
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, "");
}
break;
}
}
#endif
-static void folder_entry(char *s, size_t slen, struct Menu *menu, int num)
+static void folder_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
struct Folder folder;
#ifdef USE_NNTP
if (option(OPT_NEWS))
- mutt_expando_format(s, slen, 0, MuttIndexWindow->cols,
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols,
NONULL(GroupIndexFormat), group_index_format_str,
(unsigned long) &folder, MUTT_FORMAT_ARROWCURSOR);
else
#endif
- mutt_expando_format(s, slen, 0, MuttIndexWindow->cols, NONULL(FolderFormat),
- folder_format_str, (unsigned long) &folder, MUTT_FORMAT_ARROWCURSOR);
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols,
+ NONULL(FolderFormat), folder_format_str,
+ (unsigned long) &folder, MUTT_FORMAT_ARROWCURSOR);
}
#ifdef USE_NOTMUCH
-static void vfolder_entry(char *s, size_t slen, struct Menu *menu, int num)
+static void vfolder_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
struct Folder folder;
folder.ff = &((struct FolderFile *) menu->data)[num];
folder.num = num;
- mutt_expando_format(s, slen, 0, MuttIndexWindow->cols, NONULL(VfolderFormat),
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(VfolderFormat),
folder_format_str, (unsigned long) &folder, MUTT_FORMAT_ARROWCURSOR);
}
#endif
}
}
-static void snd_entry(char *b, size_t blen, struct Menu *menu, int num)
+static void snd_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
struct AttachCtx *actx = (struct AttachCtx *) menu->data;
- mutt_expando_format(b, blen, 0, MuttIndexWindow->cols, NONULL(AttachFormat),
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(AttachFormat),
attach_format_str, (unsigned long) (actx->idx[actx->v2r[num]]),
MUTT_FORMAT_STAT_FILE | MUTT_FORMAT_ARROWCURSOR);
}
* help when modifying this function.
*/
static const char *compose_format_str(char *buf, size_t buflen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
char fmt[SHORT_STRING], tmp[SHORT_STRING];
switch (op)
{
case 'a': /* total number of attachments */
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, menu->max);
break;
case 'h': /* hostname */
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
snprintf(buf, buflen, fmt, NONULL(ShortHostname));
break;
case 'l': /* approx length of current message in bytes */
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
mutt_pretty_size(tmp, sizeof(tmp), menu ? cum_attachs_size(menu) : 0);
snprintf(buf, buflen, fmt, tmp);
break;
return src;
default:
- snprintf(buf, buflen, "%%%s%c", prefix, op);
+ snprintf(buf, buflen, "%%%s%c", prec, op);
break;
}
if (optional)
- compose_status_line(buf, buflen, col, cols, menu, ifstring);
+ compose_status_line(buf, buflen, col, cols, menu, if_str);
else if (flags & MUTT_FORMAT_OPTIONAL)
- compose_status_line(buf, buflen, col, cols, menu, elsestring);
+ compose_status_line(buf, buflen, col, cols, menu, else_str);
return src;
}
/**
* compress_format_str - Expand the filenames in the command string
- * @param dest Buffer in which to save string
- * @param destlen Buffer length
+ * @param buf Buffer in which to save string
+ * @param buflen Buffer length
* @param col Starting column, UNUSED
* @param cols Number of screen columns, UNUSED
* @param op printf-like operator, e.g. 't'
* @param src printf-like format string
- * @param fmt Field formatting string, UNUSED
- * @param ifstring If condition is met, display this string, UNUSED
- * @param elsestring Otherwise, display this string, UNUSED
+ * @param prec Field formatting string, UNUSED
+ * @param if_str If condition is met, display this string, UNUSED
+ * @param else_str Otherwise, display this string, UNUSED
* @param data Pointer to the mailbox Context
* @param flags Format flags, UNUSED
* @retval src (unchanged)
* compress_format_str is a callback function for mutt_expando_format. It understands
* two operators. '%f' : 'from' filename, '%t' : 'to' filename.
*/
-static const char *compress_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *fmt,
- const char *ifstring, const char *elsestring,
+static const char *compress_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
- if (!dest || (data == 0))
+ if (!buf || (data == 0))
return src;
struct Context *ctx = (struct Context *) data;
{
case 'f':
/* Compressed file */
- snprintf(dest, destlen, "%s", NONULL(escape_path(ctx->realpath)));
+ snprintf(buf, buflen, "%s", NONULL(escape_path(ctx->realpath)));
break;
case 't':
/* Plaintext, temporary file */
- snprintf(dest, destlen, "%s", NONULL(escape_path(ctx->path)));
+ snprintf(buf, buflen, "%s", NONULL(escape_path(ctx->path)));
break;
}
return src;
* min_width, max_width, s), except that the widths refer to the number of
* character cells when printed.
*/
-void mutt_simple_format(char *dest, size_t destlen, int min_width, int max_width,
- int justify, char m_pad_char, const char *s, size_t n, int arboreal)
+void mutt_simple_format(char *buf, size_t buflen, int min_width, int max_width,
+ int justify, char pad_char, const char *s, size_t n, int arboreal)
{
char *p = NULL;
wchar_t wc;
memset(&mbstate1, 0, sizeof(mbstate1));
memset(&mbstate2, 0, sizeof(mbstate2));
- destlen--;
- p = dest;
+ buflen--;
+ p = buf;
for (; n && (k = mbrtowc(&wc, s, n, &mbstate1)); s += k, n -= k)
{
if (k == (size_t)(-1) || k == (size_t)(-2))
}
if (w >= 0)
{
- if (w > max_width || (k2 = wcrtomb(scratch, wc, &mbstate2)) > destlen)
+ if (w > max_width || (k2 = wcrtomb(scratch, wc, &mbstate2)) > buflen)
continue;
min_width -= w;
max_width -= w;
strncpy(p, scratch, k2);
p += k2;
- destlen -= k2;
+ buflen -= k2;
}
}
- w = (int) destlen < min_width ? destlen : min_width;
+ w = (int) buflen < min_width ? buflen : min_width;
if (w <= 0)
*p = '\0';
else if (justify == FMT_RIGHT) /* right justify */
{
p[w] = '\0';
- while (--p >= dest)
+ while (--p >= buf)
p[w] = *p;
while (--w >= 0)
- dest[w] = m_pad_char;
+ buf[w] = pad_char;
}
else if (justify == FMT_CENTER) /* center */
{
p[w] = '\0';
/* move str to center of buffer */
- while (--p >= dest)
+ while (--p >= buf)
p[half] = *p;
/* fill rhs */
p = savedp + half;
while (--w >= half)
- *p++ = m_pad_char;
+ *p++ = pad_char;
/* fill lhs */
while (half--)
- dest[half] = m_pad_char;
+ buf[half] = pad_char;
}
else /* left justify */
{
while (--w >= 0)
- *p++ = m_pad_char;
+ *p++ = pad_char;
*p = '\0';
}
}
* format_s_x - Format a string like snprintf()
*
* This formats a string rather like
- * snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
- * snprintf (dest, destlen, fmt, s);
+ * snprintf (fmt, sizeof (fmt), "%%%ss", prec);
+ * snprintf (buf, buflen, fmt, s);
* except that the numbers in the conversion specification refer to
* the number of character cells when printed.
*/
-static void format_s_x(char *dest, size_t destlen, const char *prefix,
- const char *s, int arboreal)
+static void format_s_x(char *buf, size_t buflen, const char *prec, const char *s, int arboreal)
{
int justify = FMT_RIGHT;
char *p = NULL;
int min_width;
int max_width = INT_MAX;
- if (*prefix == '-')
+ if (*prec == '-')
{
- prefix++;
+ prec++;
justify = FMT_LEFT;
}
- else if (*prefix == '=')
+ else if (*prec == '=')
{
- prefix++;
+ prec++;
justify = FMT_CENTER;
}
- min_width = strtol(prefix, &p, 10);
+ min_width = strtol(prec, &p, 10);
if (*p == '.')
{
- prefix = p + 1;
- max_width = strtol(prefix, &p, 10);
- if (p <= prefix)
+ prec = p + 1;
+ max_width = strtol(prec, &p, 10);
+ if (p <= prec)
max_width = INT_MAX;
}
- mutt_simple_format(dest, destlen, min_width, max_width, justify, ' ', s,
+ mutt_simple_format(buf, buflen, min_width, max_width, justify, ' ', s,
mutt_str_strlen(s), arboreal);
}
-void mutt_format_s(char *dest, size_t destlen, const char *prefix, const char *s)
+void mutt_format_s(char *buf, size_t buflen, const char *prec, const char *s)
{
- format_s_x(dest, destlen, prefix, s, 0);
+ format_s_x(buf, buflen, prec, s, 0);
}
-void mutt_format_s_tree(char *dest, size_t destlen, const char *prefix, const char *s)
+void mutt_format_s_tree(char *buf, size_t buflen, const char *prec, const char *s)
{
- format_s_x(dest, destlen, prefix, s, 1);
+ format_s_x(buf, buflen, prec, s, 1);
}
/**
fprintf(stderr, "\033]1;%s\007", str);
}
-void index_make_entry(char *s, size_t l, struct Menu *menu, int num)
+void index_make_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
if (!Context || !menu || (num < 0) || (num >= Context->hdrmax))
return;
}
}
- mutt_make_string_flags(s, l, NONULL(IndexFormat), Context, h, flag);
+ mutt_make_string_flags(buf, buflen, NONULL(IndexFormat), Context, h, flag);
}
int index_color(int index_no)
MUTT_FORMAT_NOFILTER = (1 << 7) /**< do not allow filtering on this pass */
};
-typedef const char *format_t(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+typedef const char *format_t(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags);
-void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
+void mutt_expando_format(char *buf, size_t buflen, size_t col, int cols,
const char *src, format_t *callback,
unsigned long data, enum FormatFlag flags);
* | \%zt | message tag flags
* | \%Z | combined message flags
*/
-static const char *index_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+static const char *index_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
struct HdrFormatInfo *hfi = (struct HdrFormatInfo *) data;
struct Header *hdr = NULL, *htmp = NULL;
struct Context *ctx = NULL;
- char fmt[SHORT_STRING], buf2[LONG_STRING], *p, *tags = NULL;
+ char fmt[SHORT_STRING], tmp[LONG_STRING], *p, *tags = NULL;
char *wch = NULL;
int do_locales, i;
int optional = (flags & MUTT_FORMAT_OPTIONAL);
if (!hdr || !hdr->env)
return src;
- dest[0] = 0;
+ buf[0] = 0;
switch (op)
{
case 'A':
{
if (hdr->env->reply_to && hdr->env->reply_to->mailbox)
{
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_AUTHOR);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix,
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec,
mutt_addr_for_display(hdr->env->reply_to));
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
}
}
else
{
- if (mutt_mb_get_initials(mutt_get_name(hdr->env->from), buf2, sizeof(buf2)))
+ if (mutt_mb_get_initials(mutt_get_name(hdr->env->from), tmp, sizeof(tmp)))
{
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_AUTHOR);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, buf2);
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
}
}
/* fallthrough */
case 'a':
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_AUTHOR);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
if (hdr->env->from && hdr->env->from->mailbox)
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix,
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec,
mutt_addr_for_display(hdr->env->from));
else
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, "");
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
case 'B':
case 'K':
- if (!first_mailing_list(dest, destlen, hdr->env->to) &&
- !first_mailing_list(dest, destlen, hdr->env->cc))
+ if (!first_mailing_list(buf, buflen, hdr->env->to) &&
+ !first_mailing_list(buf, buflen, hdr->env->cc))
{
- dest[0] = 0;
+ buf[0] = 0;
}
- if (dest[0])
+ if (buf[0])
{
- mutt_str_strfcpy(buf2, dest, sizeof(buf2));
- mutt_format_s(dest, destlen, prefix, buf2);
+ mutt_str_strfcpy(tmp, buf, sizeof(tmp));
+ mutt_format_s(buf, buflen, prec, tmp);
break;
}
if (op == 'K')
if (ctx)
{
if ((p = strrchr(ctx->path, '/')))
- mutt_str_strfcpy(dest, p + 1, destlen);
+ mutt_str_strfcpy(buf, p + 1, buflen);
else
- mutt_str_strfcpy(dest, ctx->path, destlen);
+ mutt_str_strfcpy(buf, ctx->path, buflen);
}
else
- mutt_str_strfcpy(dest, "(null)", destlen);
- mutt_str_strfcpy(buf2, dest, sizeof(buf2));
- mutt_format_s(dest, destlen, prefix, buf2);
+ mutt_str_strfcpy(buf, "(null)", buflen);
+ mutt_str_strfcpy(tmp, buf, sizeof(tmp));
+ mutt_format_s(buf, buflen, prec, tmp);
break;
case 'c':
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_SIZE);
- mutt_pretty_size(buf2, sizeof(buf2), (long) hdr->content->length);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, buf2);
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SIZE);
+ mutt_pretty_size(tmp, sizeof(tmp), (long) hdr->content->length);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
case 'C':
colorlen = add_index_color(fmt, sizeof(fmt), flags, MT_COLOR_INDEX_NUMBER);
- snprintf(fmt + colorlen, sizeof(fmt) - colorlen, "%%%sd", prefix);
+ snprintf(fmt + colorlen, sizeof(fmt) - colorlen, "%%%sd", prec);
add_index_color(fmt + colorlen, sizeof(fmt) - colorlen, flags, MT_COLOR_INDEX);
- snprintf(dest, destlen, fmt, hdr->msgno + 1);
+ snprintf(buf, buflen, fmt, hdr->msgno + 1);
break;
case 'd':
tm = localtime(&T);
T -= (op == '(') ? hdr->received : hdr->date_sent;
- is = (char *) prefix;
+ is = (char *) prec;
if (*is == '>')
{
invert = 1;
break;
}
- p = dest;
+ p = buf;
cp = (op == 'd' || op == 'D') ? (NONULL(DateFormat)) : src;
if (*cp == '!')
else
do_locales = 1;
- len = destlen - 1;
+ len = buflen - 1;
while (len > 0 && (((op == 'd' || op == 'D') && *cp) ||
(op == '{' && *cp != '}') || (op == '[' && *cp != ']') ||
(op == '(' && *cp != ')') || (op == '<' && *cp != '>')))
if (!do_locales)
setlocale(LC_TIME, "C");
- strftime(buf2, sizeof(buf2), dest, tm);
+ strftime(tmp, sizeof(tmp), buf, tm);
if (!do_locales)
setlocale(LC_TIME, "");
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_DATE);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, buf2);
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_DATE);
+ 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 */
src = cp + 1;
break;
case 'e':
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, mutt_messages_in_thread(ctx, hdr, 1));
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, mutt_messages_in_thread(ctx, hdr, 1));
break;
case 'E':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, mutt_messages_in_thread(ctx, hdr, 0));
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, mutt_messages_in_thread(ctx, hdr, 0));
}
else if (mutt_messages_in_thread(ctx, hdr, 0) <= 1)
optional = 0;
break;
case 'f':
- buf2[0] = 0;
- rfc822_write_address(buf2, sizeof(buf2), hdr->env->from, 1);
- mutt_format_s(dest, destlen, prefix, buf2);
+ tmp[0] = 0;
+ rfc822_write_address(tmp, sizeof(tmp), hdr->env->from, 1);
+ mutt_format_s(buf, buflen, prec, tmp);
break;
case 'F':
if (!optional)
{
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_AUTHOR);
- make_from(hdr->env, buf2, sizeof(buf2), 0);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, buf2);
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
+ make_from(hdr->env, tmp, sizeof(tmp), 0);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
}
else if (mutt_addr_is_user(hdr->env->from))
optional = 0;
tags = driver_tags_get_transformed(&hdr->tags);
if (!optional)
{
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_TAGS);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, NONULL(tags));
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAGS);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(tags));
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
}
else if (!tags)
optional = 0;
if (tag)
{
tags = driver_tags_get_transformed_for(tag, &hdr->tags);
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_TAG);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, NONULL(tags));
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAG);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(tags));
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
FREE(&tags);
}
src++;
else
{
format[0] = op;
- format[1] = *prefix;
+ format[1] = *prec;
format[2] = 0;
tag = mutt_hash_find(TagFormats, format);
optional = hdr->env->spam ? 1 : 0;
if (hdr->env->spam)
- mutt_format_s(dest, destlen, prefix, NONULL(hdr->env->spam->data));
+ mutt_format_s(buf, buflen, prec, NONULL(hdr->env->spam->data));
else
- mutt_format_s(dest, destlen, prefix, "");
+ mutt_format_s(buf, buflen, prec, "");
break;
case 'i':
- mutt_format_s(dest, destlen, prefix,
- hdr->env->message_id ? hdr->env->message_id : "<no.id>");
+ mutt_format_s(buf, buflen, prec, hdr->env->message_id ? hdr->env->message_id : "<no.id>");
break;
case 'J':
if (optional)
optional = i;
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_TAGS);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAGS);
if (i)
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, NONULL(tags));
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(tags));
else
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, "");
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
FREE(&tags);
break;
case 'l':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_SIZE);
- snprintf(dest + colorlen, destlen - colorlen, fmt, (int) hdr->lines);
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SIZE);
+ snprintf(buf + colorlen, buflen - colorlen, fmt, (int) hdr->lines);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
}
else if (hdr->lines <= 0)
optional = 0;
case 'L':
if (!optional)
{
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_AUTHOR);
- make_from(hdr->env, buf2, sizeof(buf2), 1);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, buf2);
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
+ make_from(hdr->env, tmp, sizeof(tmp), 1);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
}
else if (!check_for_mailing_list(hdr->env->to, NULL, NULL, 0) &&
!check_for_mailing_list(hdr->env->cc, NULL, NULL, 0))
case 'm':
if (ctx)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, ctx->msgcount);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, ctx->msgcount);
}
else
- mutt_str_strfcpy(dest, "(null)", destlen);
+ mutt_str_strfcpy(buf, "(null)", buflen);
break;
case 'n':
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_AUTHOR);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix,
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec,
mutt_get_name(hdr->env->from));
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
case 'M':
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
if (!optional)
{
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_COLLAPSED);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_COLLAPSED);
if (threads && is_index && hdr->collapsed && hdr->num_hidden > 1)
{
- snprintf(dest + colorlen, destlen - colorlen, fmt, hdr->num_hidden);
- add_index_color(dest, destlen - colorlen, flags, MT_COLOR_INDEX);
+ snprintf(buf + colorlen, buflen - colorlen, fmt, hdr->num_hidden);
+ add_index_color(buf, buflen - colorlen, flags, MT_COLOR_INDEX);
}
else if (is_index && threads)
{
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, " ");
- add_index_color(dest, destlen - colorlen, flags, MT_COLOR_INDEX);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, " ");
+ add_index_color(buf, buflen - colorlen, flags, MT_COLOR_INDEX);
}
else
- *dest = '\0';
+ *buf = '\0';
}
else
{
case 'N':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, hdr->score);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, hdr->score);
}
else
{
case 'O':
if (!optional)
{
- make_from_addr(hdr->env, buf2, sizeof(buf2), 1);
- if (!option(OPT_SAVE_ADDRESS) && (p = strpbrk(buf2, "%@")))
+ make_from_addr(hdr->env, tmp, sizeof(tmp), 1);
+ if (!option(OPT_SAVE_ADDRESS) && (p = strpbrk(tmp, "%@")))
*p = 0;
- mutt_format_s(dest, destlen, prefix, buf2);
+ mutt_format_s(buf, buflen, prec, tmp);
}
else if (!check_for_mailing_list_addr(hdr->env->to, NULL, 0) &&
!check_for_mailing_list_addr(hdr->env->cc, NULL, 0))
break;
case 'P':
- mutt_str_strfcpy(dest, NONULL(hfi->pager_progress), destlen);
+ mutt_str_strfcpy(buf, NONULL(hfi->pager_progress), buflen);
break;
#ifdef USE_NNTP
case 'q':
- mutt_format_s(dest, destlen, prefix, hdr->env->newsgroups ? hdr->env->newsgroups : "");
+ mutt_format_s(buf, buflen, prec, hdr->env->newsgroups ? hdr->env->newsgroups : "");
break;
#endif
case 'r':
- buf2[0] = 0;
- rfc822_write_address(buf2, sizeof(buf2), hdr->env->to, 1);
- if (optional && buf2[0] == '\0')
+ tmp[0] = 0;
+ rfc822_write_address(tmp, sizeof(tmp), hdr->env->to, 1);
+ if (optional && tmp[0] == '\0')
optional = 0;
- mutt_format_s(dest, destlen, prefix, buf2);
+ mutt_format_s(buf, buflen, prec, tmp);
break;
case 'R':
- buf2[0] = 0;
- rfc822_write_address(buf2, sizeof(buf2), hdr->env->cc, 1);
- if (optional && buf2[0] == '\0')
+ tmp[0] = 0;
+ rfc822_write_address(tmp, sizeof(tmp), hdr->env->cc, 1);
+ if (optional && tmp[0] == '\0')
optional = 0;
- mutt_format_s(dest, destlen, prefix, buf2);
+ mutt_format_s(buf, buflen, prec, tmp);
break;
case 's':
{
if (flags & MUTT_FORMAT_FORCESUBJ)
{
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_SUBJECT);
- mutt_format_s(dest + colorlen, destlen - colorlen, "", NONULL(subj));
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
- snprintf(buf2, sizeof(buf2), "%s%s", hdr->tree, dest);
- mutt_format_s_tree(dest, destlen, prefix, buf2);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SUBJECT);
+ mutt_format_s(buf + colorlen, buflen - colorlen, "", NONULL(subj));
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
+ snprintf(tmp, sizeof(tmp), "%s%s", hdr->tree, buf);
+ mutt_format_s_tree(buf, buflen, prec, tmp);
}
else
- mutt_format_s_tree(dest, destlen, prefix, hdr->tree);
+ mutt_format_s_tree(buf, buflen, prec, hdr->tree);
}
else
{
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_SUBJECT);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, NONULL(subj));
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SUBJECT);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(subj));
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
}
}
break;
else
wch = get_nth_wchar(FlagChars, FlagCharNew);
- snprintf(buf2, sizeof(buf2), "%s", wch);
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_FLAGS);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, buf2);
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ snprintf(tmp, sizeof(tmp), "%s", wch);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
case 't':
- buf2[0] = 0;
- if (!check_for_mailing_list(hdr->env->to, "To ", buf2, sizeof(buf2)) &&
- !check_for_mailing_list(hdr->env->cc, "Cc ", buf2, sizeof(buf2)))
+ tmp[0] = 0;
+ if (!check_for_mailing_list(hdr->env->to, "To ", tmp, sizeof(tmp)) &&
+ !check_for_mailing_list(hdr->env->cc, "Cc ", tmp, sizeof(tmp)))
{
if (hdr->env->to)
- snprintf(buf2, sizeof(buf2), "To %s", mutt_get_name(hdr->env->to));
+ snprintf(tmp, sizeof(tmp), "To %s", mutt_get_name(hdr->env->to));
else if (hdr->env->cc)
- snprintf(buf2, sizeof(buf2), "Cc %s", mutt_get_name(hdr->env->cc));
+ snprintf(tmp, sizeof(tmp), "Cc %s", mutt_get_name(hdr->env->cc));
}
- mutt_format_s(dest, destlen, prefix, buf2);
+ mutt_format_s(buf, buflen, prec, tmp);
break;
case 'T':
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt,
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt,
(ToChars && ((i = user_is_recipient(hdr))) < ToChars->len) ?
ToChars->chars[i] :
" ");
case 'u':
if (hdr->env->from && hdr->env->from->mailbox)
{
- mutt_str_strfcpy(buf2, mutt_addr_for_display(hdr->env->from), sizeof(buf2));
- if ((p = strpbrk(buf2, "%@")))
+ mutt_str_strfcpy(tmp, mutt_addr_for_display(hdr->env->from), sizeof(tmp));
+ if ((p = strpbrk(tmp, "%@")))
*p = 0;
}
else
- buf2[0] = 0;
- mutt_format_s(dest, destlen, prefix, buf2);
+ tmp[0] = 0;
+ mutt_format_s(buf, buflen, prec, tmp);
break;
case 'v':
if (mutt_addr_is_user(hdr->env->from))
{
if (hdr->env->to)
- mutt_format_s(buf2, sizeof(buf2), prefix, mutt_get_name(hdr->env->to));
+ mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(hdr->env->to));
else if (hdr->env->cc)
- mutt_format_s(buf2, sizeof(buf2), prefix, mutt_get_name(hdr->env->cc));
+ mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(hdr->env->cc));
else
- *buf2 = 0;
+ *tmp = 0;
}
else
- mutt_format_s(buf2, sizeof(buf2), prefix, mutt_get_name(hdr->env->from));
- if ((p = strpbrk(buf2, " %@")))
+ mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(hdr->env->from));
+ if ((p = strpbrk(tmp, " %@")))
*p = 0;
- mutt_format_s(dest, destlen, prefix, buf2);
+ mutt_format_s(buf, buflen, prec, tmp);
break;
case 'W':
if (!optional)
- mutt_format_s(dest, destlen, prefix,
+ mutt_format_s(buf, buflen, prec,
hdr->env->organization ? hdr->env->organization : "");
else if (!hdr->env->organization)
optional = 0;
#ifdef USE_NNTP
case 'x':
if (!optional)
- mutt_format_s(dest, destlen, prefix,
+ mutt_format_s(buf, buflen, prec,
hdr->env->x_comment_to ? hdr->env->x_comment_to : "");
else if (!hdr->env->x_comment_to)
optional = 0;
if (optional)
optional = count != 0;
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, count);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, count);
}
break;
if (optional)
optional = hdr->env->x_label ? 1 : 0;
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_LABEL);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, NONULL(hdr->env->x_label));
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_LABEL);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(hdr->env->x_label));
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
case 'Y':
if (optional)
optional = i;
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_LABEL);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_LABEL);
if (i)
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix,
- NONULL(hdr->env->x_label));
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(hdr->env->x_label));
else
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, "");
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
case 'z':
ch = get_nth_wchar(FlagChars, FlagCharNew);
}
- snprintf(buf2, sizeof(buf2), "%s", ch);
+ snprintf(tmp, sizeof(tmp), "%s", ch);
src++;
}
else if (src[0] == 'c') /* crypto */
else
ch = " ";
- snprintf(buf2, sizeof(buf2), "%s", ch);
+ snprintf(tmp, sizeof(tmp), "%s", ch);
src++;
}
else if (src[0] == 't') /* tagged, flagged, recipient */
else
ch = get_nth_wchar(ToChars, user_is_recipient(hdr));
- snprintf(buf2, sizeof(buf2), "%s", ch);
+ snprintf(tmp, sizeof(tmp), "%s", ch);
src++;
}
else /* fallthrough */
break;
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_FLAGS);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, buf2);
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
case 'Z':
else
third = get_nth_wchar(ToChars, user_is_recipient(hdr));
- snprintf(buf2, sizeof(buf2), "%s%s%s", first, second, third);
+ snprintf(tmp, sizeof(tmp), "%s%s%s", first, second, third);
}
- colorlen = add_index_color(dest, destlen, flags, MT_COLOR_INDEX_FLAGS);
- mutt_format_s(dest + colorlen, destlen - colorlen, prefix, buf2);
- add_index_color(dest + colorlen, destlen - colorlen, flags, MT_COLOR_INDEX);
+ colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
+ mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
+ add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
break;
default:
- snprintf(dest, destlen, "%%%s%c", prefix, op);
+ snprintf(buf, buflen, "%%%s%c", prec, op);
break;
}
if (optional)
- mutt_expando_format(dest, destlen, col, cols, ifstring, index_format_str,
+ mutt_expando_format(buf, buflen, col, cols, if_str, index_format_str,
(unsigned long) hfi, flags);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, cols, elsestring, index_format_str,
+ mutt_expando_format(buf, buflen, col, cols, else_str, index_format_str,
(unsigned long) hfi, flags);
return src;
}
-void mutt_make_string_flags(char *dest, size_t destlen, const char *s,
+void mutt_make_string_flags(char *buf, size_t buflen, const char *s,
struct Context *ctx, struct Header *hdr, enum FormatFlag flags)
{
struct HdrFormatInfo hfi;
hfi.ctx = ctx;
hfi.pager_progress = 0;
- mutt_expando_format(dest, destlen, 0, MuttIndexWindow->cols, s,
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, s,
index_format_str, (unsigned long) &hfi, flags);
}
-void mutt_make_string_info(char *dst, size_t dstlen, int cols, const char *s,
+void mutt_make_string_info(char *buf, size_t buflen, int cols, const char *s,
struct HdrFormatInfo *hfi, enum FormatFlag flags)
{
- mutt_expando_format(dst, dstlen, 0, cols, s, index_format_str, (unsigned long) hfi, flags);
+ mutt_expando_format(buf, buflen, 0, cols, s, index_format_str, (unsigned long) hfi, flags);
}
menu->make_entry(s, l, menu, i);
}
-static void menu_pad_string(struct Menu *menu, char *s, size_t n)
+static void menu_pad_string(struct Menu *menu, char *buf, size_t buflen)
{
- char *scratch = mutt_str_strdup(s);
+ char *scratch = mutt_str_strdup(buf);
int shift = option(OPT_ARROW_CURSOR) ? 3 : 0;
int cols = menu->indexwin->cols - shift;
- mutt_simple_format(s, n, cols, cols, FMT_LEFT, ' ', scratch, mutt_str_strlen(scratch), 1);
- s[n - 1] = '\0';
+ mutt_simple_format(buf, buflen, cols, cols, FMT_LEFT, ' ', scratch,
+ mutt_str_strlen(scratch), 1);
+ buf[buflen - 1] = '\0';
FREE(&scratch);
}
char *keys; /**< keys used in the prompt */
/* callback to generate an index line for the requested element */
- void (*make_entry)(char *, size_t, struct Menu *, int);
+ void (*make_entry)(char *buf, size_t buflen, struct Menu *menu, int num);
/* how to search the menu */
int (*search)(struct Menu *, regex_t *re, int n);
* @param data callback data
* @param flags callback flags
*/
-void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
- const char *src, format_t *callback,
- unsigned long data, enum FormatFlag flags)
+void mutt_expando_format(char *buf, size_t buflen, size_t col, int cols, const char *src,
+ format_t *callback, unsigned long data, enum FormatFlag flags)
{
- char prefix[SHORT_STRING], buf[LONG_STRING], *cp = NULL, *wptr = dest, ch;
- char ifstring[SHORT_STRING], elsestring[SHORT_STRING];
+ char prefix[SHORT_STRING], tmp[LONG_STRING], *cp = NULL, *wptr = buf, ch;
+ char if_str[SHORT_STRING], else_str[SHORT_STRING];
size_t wlen, count, len, wid;
pid_t pid;
FILE *filter = NULL;
src = src2;
prefix[0] = '\0';
- destlen--; /* save room for the terminal \0 */
+ buflen--; /* save room for the terminal \0 */
wlen = ((flags & MUTT_FORMAT_ARROWCURSOR) && option(OPT_ARROW_CURSOR)) ? 3 : 0;
col += wlen;
mutt_extract_token(word, srcbuf, 0);
mutt_debug(3, "fmtpipe %2d: %s\n", i++, word->data);
mutt_buffer_addch(command, '\'');
- mutt_expando_format(buf, sizeof(buf), 0, cols, word->data, callback,
+ mutt_expando_format(tmp, sizeof(tmp), 0, cols, word->data, callback,
data, flags | MUTT_FORMAT_NOFILTER);
- for (char *p = buf; p && *p; p++)
+ for (char *p = tmp; p && *p; p++)
{
if (*p == '\'')
/* shell quoting doesn't permit escaping a single quote within
mutt_debug(3, "fmtpipe > %s\n", command->data);
col -= wlen; /* reset to passed in value */
- wptr = dest; /* reset write ptr */
+ wptr = buf; /* reset write ptr */
wlen = ((flags & MUTT_FORMAT_ARROWCURSOR) && option(OPT_ARROW_CURSOR)) ? 3 : 0;
pid = mutt_create_filter(command->data, NULL, &filter, NULL);
if (pid != -1)
{
int rc;
- n = fread(dest, 1, destlen /* already decremented */, filter);
+ n = fread(buf, 1, buflen /* already decremented */, filter);
mutt_file_fclose(&filter);
rc = mutt_wait_filter(pid);
if (rc != 0)
mutt_debug(1, "format pipe command exited code %d\n", rc);
if (n > 0)
{
- dest[n] = 0;
- while ((n > 0) && (dest[n - 1] == '\n' || dest[n - 1] == '\r'))
- dest[--n] = '\0';
- mutt_debug(3, "fmtpipe < %s\n", dest);
+ buf[n] = 0;
+ while ((n > 0) && (buf[n - 1] == '\n' || buf[n - 1] == '\r'))
+ buf[--n] = '\0';
+ mutt_debug(3, "fmtpipe < %s\n", buf);
/* If the result ends with '%', this indicates that the filter
* 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) && dest[n - 1] == '%')
+ if ((n > 0) && buf[n - 1] == '%')
{
n--;
- dest[n] = '\0'; /* remove '%' */
- if ((n > 0) && dest[n - 1] != '%')
+ buf[n] = '\0'; /* remove '%' */
+ if ((n > 0) && buf[n - 1] != '%')
{
- recycler = mutt_str_strdup(dest);
+ recycler = mutt_str_strdup(buf);
if (recycler)
{
- /* destlen is decremented at the start of this function
+ /* buflen is decremented at the start of this function
* to save space for the terminal nul char. We can add
* it back for the recursive call since the expansion of
* format pipes does not try to append a nul itself.
*/
- mutt_expando_format(dest, destlen + 1, col, cols, recycler,
+ mutt_expando_format(buf, buflen + 1, col, cols, recycler,
callback, data, flags);
FREE(&recycler);
}
}
}
- while (*src && wlen < destlen)
+ while (*src && wlen < buflen)
{
if (*src == '%')
{
src++;
/* eat the `if' part of the string */
- cp = ifstring;
+ cp = if_str;
count = 0;
lrbalance = 1;
- while ((lrbalance > 0) && (count < sizeof(ifstring)) && *src)
+ while ((lrbalance > 0) && (count < sizeof(if_str)) && *src)
{
if ((src[0] == '%') && (src[1] == '>'))
{
/* eat the `else' part of the string (optional) */
if (*src == '&')
src++; /* skip the & */
- cp = elsestring;
+ cp = else_str;
count = 0;
- while ((lrbalance > 0) && (count < sizeof(elsestring)) && *src)
+ while ((lrbalance > 0) && (count < sizeof(else_str)) && *src)
{
if ((src[0] == '%') && (src[1] == '>'))
{
pl = pw = 1;
/* see if there's room to add content, else ignore */
- if ((col < cols && wlen < destlen) || soft)
+ if ((col < cols && wlen < buflen) || soft)
{
int pad;
/* get contents after padding */
- mutt_expando_format(buf, sizeof(buf), 0, cols, src + pl, callback, data, flags);
- len = mutt_str_strlen(buf);
- wid = mutt_strwidth(buf);
+ mutt_expando_format(tmp, sizeof(tmp), 0, cols, src + pl, callback, data, flags);
+ len = mutt_str_strlen(tmp);
+ wid = mutt_strwidth(tmp);
pad = (cols - col - wid) / pw;
if (pad >= 0)
{
/* try to consume as many columns as we can, if we don't have
* memory for that, use as much memory as possible */
- if (wlen + (pad * pl) + len > destlen)
- pad = (destlen > wlen + len) ? ((destlen - wlen - len) / pl) : 0;
+ if (wlen + (pad * pl) + len > buflen)
+ pad = (buflen > wlen + len) ? ((buflen - wlen - len) / pl) : 0;
else
{
/* Add pre-spacing to make multi-column pad characters and
* the contents after padding line up */
- while ((col + (pad * pw) + wid < cols) && (wlen + (pad * pl) + len < destlen))
+ while ((col + (pad * pw) + wid < cols) && (wlen + (pad * pl) + len < buflen))
{
*wptr++ = ' ';
wlen++;
int offset =
((flags & MUTT_FORMAT_ARROWCURSOR) && option(OPT_ARROW_CURSOR)) ? 3 : 0;
int avail_cols = (cols > offset) ? (cols - offset) : 0;
- /* \0-terminate dest for length computation in mutt_wstr_trunc() */
+ /* \0-terminate buf for length computation in mutt_wstr_trunc() */
*wptr = 0;
/* make sure right part is at most as wide as display */
- len = mutt_wstr_trunc(buf, destlen, avail_cols, &wid);
+ len = mutt_wstr_trunc(tmp, buflen, avail_cols, &wid);
/* truncate left so that right part fits completely in */
- wlen = mutt_wstr_trunc(dest, destlen - len, avail_cols - wid, &col);
- wptr = dest + wlen;
+ wlen = mutt_wstr_trunc(buf, buflen - len, avail_cols - wid, &col);
+ wptr = buf + wlen;
/* Multi-column characters may be truncated in the middle.
* Add spacing so the right hand side lines up. */
- while ((col + wid < avail_cols) && (wlen + len < destlen))
+ while ((col + wid < avail_cols) && (wlen + len < buflen))
{
*wptr++ = ' ';
wlen++;
col++;
}
}
- if (len + wlen > destlen)
- len = mutt_wstr_trunc(buf, destlen - wlen, cols - col, NULL);
- memcpy(wptr, buf, len);
+ if (len + wlen > buflen)
+ len = mutt_wstr_trunc(tmp, buflen - wlen, cols - col, NULL);
+ memcpy(wptr, tmp, len);
wptr += len;
wlen += len;
col += wid;
pl = pw = 1;
/* see if there's room to add content, else ignore */
- if (col < cols && wlen < destlen)
+ if (col < cols && wlen < buflen)
{
c = (cols - col) / pw;
- if (c > 0 && wlen + (c * pl) > destlen)
- c = ((signed) (destlen - wlen)) / pl;
+ if (c > 0 && wlen + (c * pl) > buflen)
+ c = ((signed) (buflen - wlen)) / pl;
while (c > 0)
{
memcpy(wptr, src, pl);
}
/* use callback function to handle this case */
- src = callback(buf, sizeof(buf), col, cols, ch, src, prefix, ifstring,
- elsestring, data, flags);
+ src = callback(tmp, sizeof(tmp), col, cols, ch, src, prefix, if_str,
+ else_str, data, flags);
if (tolower)
- mutt_str_strlower(buf);
+ mutt_str_strlower(tmp);
if (nodots)
{
- char *p = buf;
+ char *p = tmp;
for (; *p; p++)
if (*p == '.')
*p = '_';
}
- if ((len = mutt_str_strlen(buf)) + wlen > destlen)
- len = mutt_wstr_trunc(buf, destlen - wlen, cols - col, NULL);
+ if ((len = mutt_str_strlen(tmp)) + wlen > buflen)
+ len = mutt_wstr_trunc(tmp, buflen - wlen, cols - col, NULL);
- memcpy(wptr, buf, len);
+ memcpy(wptr, tmp, len);
wptr += len;
wlen += len;
- col += mutt_strwidth(buf);
+ col += mutt_strwidth(tmp);
}
}
else if (*src == '\\')
}
else
{
- int tmp, w;
+ int bytes, width;
/* in case of error, simply copy byte */
- tmp = mutt_mb_charlen(src, &w);
- if (tmp < 0)
- tmp = w = 1;
- if (tmp > 0 && wlen + tmp < destlen)
+ bytes = mutt_mb_charlen(src, &width);
+ if (bytes < 0)
{
- memcpy(wptr, src, tmp);
- wptr += tmp;
- src += tmp;
- wlen += tmp;
- col += w;
+ bytes = 1;
+ width = 1;
+ }
+ if ((bytes > 0) && ((wlen + bytes) < buflen))
+ {
+ memcpy(wptr, src, bytes);
+ wptr += bytes;
+ src += bytes;
+ wlen += bytes;
+ col += width;
}
else
{
- src += destlen - wlen;
- wlen = destlen;
+ src += buflen - wlen;
+ wlen = buflen;
}
}
}
* * \%F flags of the principal key
* * \%C capabilities of the principal key
*/
-static const char *crypt_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+static const char *crypt_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
char fmt[16];
struct tm *tm = NULL;
size_t len;
- p = dest;
+ p = buf;
cp = src;
if (*cp == '!')
else
do_locales = 1;
- len = destlen - 1;
+ len = buflen - 1;
while (len > 0 && *cp != ']')
{
if (*cp == '%')
if (!do_locales)
setlocale(LC_TIME, "C");
- strftime(buf2, sizeof(buf2), dest, tm);
+ strftime(buf2, sizeof(buf2), buf, tm);
if (!do_locales)
setlocale(LC_TIME, "");
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, buf2);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, buf2);
if (len > 0)
src = cp + 1;
}
case 'n':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, entry->num);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, entry->num);
}
break;
case 'k':
{
/* fixme: we need a way to distinguish between main and subkeys.
Store the idx in entry? */
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, crypt_keyid(key));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, crypt_keyid(key));
}
break;
case 'u':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, key->uid);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, key->uid);
}
break;
case 'a':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%s.3s", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%s.3s", prec);
if (key->kobj->subkeys)
s = gpgme_pubkey_algo_name(key->kobj->subkeys->pubkey_algo);
else
s = "?";
- snprintf(dest, destlen, fmt, s);
+ snprintf(buf, buflen, fmt, s);
}
break;
case 'l':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%slu", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%slu", prec);
if (key->kobj->subkeys)
val = key->kobj->subkeys->length;
else
val = 0;
- snprintf(dest, destlen, fmt, val);
+ snprintf(buf, buflen, fmt, val);
}
break;
case 'f':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sc", prefix);
- snprintf(dest, destlen, fmt, crypt_flags(kflags));
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, crypt_flags(kflags));
}
else if (!(kflags & (KEYFLAG_RESTRICTIONS)))
optional = 0;
case 'c':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, crypt_key_abilities(kflags));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, crypt_key_abilities(kflags));
}
else if (!(kflags & (KEYFLAG_ABILITIES)))
optional = 0;
break;
}
}
- snprintf(fmt, sizeof(fmt), "%%%sc", prefix);
- snprintf(dest, destlen, fmt, *s);
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, *s);
break;
case 'p':
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, gpgme_get_protocol_name(key->kobj->protocol));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, gpgme_get_protocol_name(key->kobj->protocol));
break;
default:
- *dest = '\0';
+ *buf = '\0';
}
if (optional)
- mutt_expando_format(dest, destlen, col, cols, ifstring, attach_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, if_str, attach_format_str, data, 0);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, cols, elsestring, attach_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, else_str, attach_format_str, data, 0);
return src;
}
/**
* crypt_entry - Used by the display function to format a line
*/
-static void crypt_entry(char *s, size_t l, struct Menu *menu, int num)
+static void crypt_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
struct CryptKeyInfo **key_table = (struct CryptKeyInfo **) menu->data;
struct CryptEntry entry;
entry.key = key_table[num];
entry.num = num + 1;
- mutt_expando_format(s, l, 0, MuttIndexWindow->cols, NONULL(PgpEntryFormat),
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(PgpEntryFormat),
crypt_format_str, (unsigned long) &entry, MUTT_FORMAT_ARROWCURSOR);
}
const char *ids; /**< %r */
};
-static const char *fmt_pgp_command(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+static const char *fmt_pgp_command(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
char fmt[16];
{
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->ids));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->ids));
}
else if (!cctx->ids)
optional = 0;
{
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->signas));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->signas));
}
else if (!cctx->signas)
optional = 0;
{
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->sig_fname));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->sig_fname));
}
else if (!cctx->sig_fname)
optional = 0;
{
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->fname));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->fname));
}
else if (!cctx->fname)
optional = 0;
{
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, cctx->need_passphrase ? "PGPPASSFD=0" : "");
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, cctx->need_passphrase ? "PGPPASSFD=0" : "");
}
else if (!cctx->need_passphrase || pgp_use_gpg_agent())
optional = 0;
}
default:
{
- *dest = '\0';
+ *buf = '\0';
break;
}
}
if (optional)
- mutt_expando_format(dest, destlen, col, cols, ifstring, fmt_pgp_command, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, if_str, fmt_pgp_command, data, 0);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, cols, elsestring, fmt_pgp_command, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, else_str, fmt_pgp_command, data, 0);
return src;
}
-static void mutt_pgp_command(char *d, size_t dlen,
+static void mutt_pgp_command(char *buf, size_t buflen,
struct PgpCommandContext *cctx, const char *fmt)
{
- mutt_expando_format(d, dlen, 0, MuttIndexWindow->cols, NONULL(fmt),
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(fmt),
fmt_pgp_command, (unsigned long) cctx, 0);
- mutt_debug(2, "mutt_pgp_command: %s\n", d);
+ mutt_debug(2, "mutt_pgp_command: %s\n", buf);
}
/*
struct PgpUid *uid;
};
-static const char *pgp_entry_fmt(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+static const char *pgp_entry_fmt(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
char fmt[16];
struct tm *tm = NULL;
size_t len;
- p = dest;
+ p = buf;
cp = src;
if (*cp == '!')
else
do_locales = 1;
- len = destlen - 1;
+ len = buflen - 1;
while (len > 0 && *cp != ']')
{
if (*cp == '%')
if (!do_locales)
setlocale(LC_TIME, "C");
- strftime(buf2, sizeof(buf2), dest, tm);
+ strftime(buf2, sizeof(buf2), buf, tm);
if (!do_locales)
setlocale(LC_TIME, "");
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, buf2);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, buf2);
if (len > 0)
src = cp + 1;
}
case 'n':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, entry->num);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, entry->num);
}
break;
case 'k':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, pgp_this_keyid(key));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, pgp_this_keyid(key));
}
break;
case 'u':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(uid->addr));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(uid->addr));
}
break;
case 'a':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, key->algorithm);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, key->algorithm);
}
break;
case 'l':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, key->keylen);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, key->keylen);
}
break;
case 'f':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sc", prefix);
- snprintf(dest, destlen, fmt, pgp_flags(kflags));
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, pgp_flags(kflags));
}
else if (!(kflags & (KEYFLAG_RESTRICTIONS)))
optional = 0;
case 'c':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, pgp_key_abilities(kflags));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, pgp_key_abilities(kflags));
}
else if (!(kflags & (KEYFLAG_ABILITIES)))
optional = 0;
case 't':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sc", prefix);
- snprintf(dest, destlen, fmt, trust_flags[uid->trust & 0x03]);
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, trust_flags[uid->trust & 0x03]);
}
else if (!(uid->trust & 0x03))
/* undefined trust */
optional = 0;
break;
default:
- *dest = '\0';
+ *buf = '\0';
}
if (optional)
- mutt_expando_format(dest, destlen, col, cols, ifstring, attach_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, if_str, attach_format_str, data, 0);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, cols, elsestring, attach_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, else_str, attach_format_str, data, 0);
return src;
}
-static void pgp_entry(char *s, size_t l, struct Menu *menu, int num)
+static void pgp_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
struct PgpUid **KeyTable = (struct PgpUid **) menu->data;
struct PgpEntry entry;
entry.uid = KeyTable[num];
entry.num = num + 1;
- mutt_expando_format(s, l, 0, MuttIndexWindow->cols, NONULL(PgpEntryFormat),
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(PgpEntryFormat),
pgp_entry_fmt, (unsigned long) &entry, MUTT_FORMAT_ARROWCURSOR);
}
*
* This is almost identical to pgp's invoking interface.
*/
-static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+static const char *fmt_smime_command(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
char fmt[16];
else
snprintf(buf2, sizeof(buf2), "-CApath %s", buf1);
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, buf2);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, buf2);
}
else if (!SmimeCALocation)
optional = 0;
{ /* certificate (list) */
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->certificates));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->certificates));
}
else if (!cctx->certificates)
optional = 0;
{ /* intermediate certificates */
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->intermediates));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->intermediates));
}
else if (!cctx->intermediates)
optional = 0;
{ /* detached signature */
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->sig_fname));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->sig_fname));
}
else if (!cctx->sig_fname)
optional = 0;
{ /* private key */
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->key));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->key));
}
else if (!cctx->key)
optional = 0;
{ /* algorithm for encryption */
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->cryptalg));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->cryptalg));
}
else if (!cctx->key)
optional = 0;
{ /* file to process */
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->fname));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->fname));
}
else if (!cctx->fname)
optional = 0;
{ /* algorithm for the signature message digest */
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(cctx->digestalg));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(cctx->digestalg));
}
else if (!cctx->key)
optional = 0;
}
default:
- *dest = '\0';
+ *buf = '\0';
break;
}
if (optional)
- mutt_expando_format(dest, destlen, col, cols, ifstring, fmt_smime_command, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, if_str, fmt_smime_command, data, 0);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, cols, elsestring, fmt_smime_command, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, else_str, fmt_smime_command, data, 0);
return src;
}
-static void smime_command(char *d, size_t dlen,
+static void smime_command(char *buf, size_t buflen,
struct SmimeCommandContext *cctx, const char *fmt)
{
- mutt_expando_format(d, dlen, 0, MuttIndexWindow->cols, NONULL(fmt),
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(fmt),
fmt_smime_command, (unsigned long) cctx, 0);
- mutt_debug(2, "smime_command: %s\n", d);
+ mutt_debug(2, "smime_command: %s\n", buf);
}
static pid_t smime_invoke(FILE **smimein, FILE **smimeout, FILE **smimeerr,
return buf;
}
-static void smime_entry(char *s, size_t l, struct Menu *menu, int num)
+static void smime_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
struct SmimeKey **Table = (struct SmimeKey **) menu->data;
struct SmimeKey *this = Table[num];
default:
truststate = N_("Unknown ");
}
- snprintf(s, l, " 0x%s %s %s %-35.35s %s", this->hash,
+ snprintf(buf, buflen, " 0x%s %s %s %-35.35s %s", this->hash,
smime_key_flags(this->flags), truststate, this->email, this->label);
}
* %S = url schema
* %u = username
*/
-const char *nntp_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *fmt,
- const char *ifstring, const char *elsestring,
- unsigned long data, enum FormatFlag flags)
+const char *nntp_format_str(char *buf, size_t buflen, size_t col, int cols, char op,
+ const char *src, const char *prec, const char *if_str,
+ const char *else_str, unsigned long data, enum FormatFlag flags)
{
struct NntpServer *nserv = (struct NntpServer *) data;
struct Account *acct = &nserv->conn->account;
struct Url url;
- char fn[SHORT_STRING], tmp[SHORT_STRING], *p = NULL;
+ char fn[SHORT_STRING], fmt[SHORT_STRING], *p = NULL;
switch (op)
{
p = strchr(fn, '/');
if (p)
*p = '\0';
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, fn);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, fn);
break;
case 'p':
- snprintf(tmp, sizeof(tmp), "%%%su", fmt);
- snprintf(dest, destlen, tmp, acct->port);
+ snprintf(fmt, sizeof(fmt), "%%%su", prec);
+ snprintf(buf, buflen, fmt, acct->port);
break;
case 'P':
- *dest = '\0';
+ *buf = '\0';
if (acct->flags & MUTT_ACCT_PORT)
{
- snprintf(tmp, sizeof(tmp), "%%%su", fmt);
- snprintf(dest, destlen, tmp, acct->port);
+ snprintf(fmt, sizeof(fmt), "%%%su", prec);
+ snprintf(buf, buflen, fmt, acct->port);
}
break;
case 's':
strncpy(fn, acct->host, sizeof(fn) - 1);
mutt_str_strlower(fn);
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, fn);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, fn);
break;
case 'S':
mutt_account_tourl(acct, &url);
p = strchr(fn, ':');
if (p)
*p = '\0';
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, fn);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, fn);
break;
case 'u':
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, acct->user);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, acct->user);
break;
}
return src;
void nntp_clear_cache(struct NntpServer *nserv);
const char *nntp_format_str(char *dest, size_t destlen, size_t col, int cols,
char op, const char *src, const char *fmt,
- const char *ifstring, const char *elsestring,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags);
struct NntpServer *CurrentNewsSrv;
UpdateNumPostponed = 1;
}
-static void post_entry(char *s, size_t slen, struct Menu *menu, int entry)
+static void post_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
struct Context *ctx = (struct Context *) menu->data;
- mutt_make_string_flags(s, slen, NONULL(IndexFormat), ctx, ctx->hdrs[entry],
+ mutt_make_string_flags(buf, buflen, NONULL(IndexFormat), ctx, ctx->hdrs[num],
MUTT_FORMAT_ARROWCURSOR);
}
int is_from(const char *s, char *path, size_t pathlen, time_t *tp);
-const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+const char *attach_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags);
char *mutt_charset_hook(const char *chs);
void mutt_expand_fmt(char *dest, size_t destlen, const char *fmt, const char *src);
void mutt_fix_reply_recipients(struct Envelope *env);
void mutt_folder_hook(const char *path);
-void mutt_simple_format(char *dest, size_t destlen, int min_width, int max_width, int justify,
+void mutt_simple_format(char *buf, size_t buflen, int min_width, int max_width, int justify,
char m_pad_char, const char *s, size_t n, int arboreal);
-void mutt_format_s(char *dest, size_t destlen, const char *prefix, const char *s);
-void mutt_format_s_tree(char *dest, size_t destlen, const char *prefix, const char *s);
+void mutt_format_s(char *buf, size_t buflen, const char *prec, const char *s);
+void mutt_format_s_tree(char *buf, size_t buflen, const char *prec, const char *s);
void mutt_forward_intro(struct Context *ctx, struct Header *cur, FILE *fp);
void mutt_forward_trailer(struct Context *ctx, struct Header *cur, FILE *fp);
void mutt_free_color(int fg, int bg);
return REG_NOMATCH;
}
-static const char *query_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *fmt,
- const char *ifstring, const char *elsestring,
+static const char *query_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
struct Entry *entry = (struct Entry *) data;
struct Query *query = entry->data;
- char tmp[SHORT_STRING];
- char buf2[STRING] = "";
+ char fmt[SHORT_STRING];
+ char tmp[STRING] = "";
int optional = (flags & MUTT_FORMAT_OPTIONAL);
switch (op)
{
case 'a':
- rfc822_write_address(buf2, sizeof(buf2), query->addr, 1);
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, buf2);
+ rfc822_write_address(tmp, sizeof(tmp), query->addr, 1);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, tmp);
break;
case 'c':
- snprintf(tmp, sizeof(tmp), "%%%sd", fmt);
- snprintf(dest, destlen, tmp, query->num + 1);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, query->num + 1);
break;
case 'e':
if (!optional)
{
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, NONULL(query->other));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(query->other));
}
else if (!query->other || !*query->other)
optional = 0;
break;
case 'n':
- snprintf(tmp, sizeof(tmp), "%%%ss", fmt);
- snprintf(dest, destlen, tmp, NONULL(query->name));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(query->name));
break;
case 't':
- snprintf(tmp, sizeof(tmp), "%%%sc", fmt);
- snprintf(dest, destlen, tmp, entry->tagged ? '*' : ' ');
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, entry->tagged ? '*' : ' ');
break;
default:
- snprintf(tmp, sizeof(tmp), "%%%sc", fmt);
- snprintf(dest, destlen, tmp, op);
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, op);
break;
}
if (optional)
- mutt_expando_format(dest, destlen, col, cols, ifstring, query_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, if_str, query_format_str, data, 0);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, cols, elsestring, query_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, else_str, query_format_str, data, 0);
return src;
}
-static void query_entry(char *s, size_t slen, struct Menu *m, int num)
+static void query_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
- struct Entry *entry = &((struct Entry *) m->data)[num];
+ struct Entry *entry = &((struct Entry *) menu->data)[num];
entry->data->num = num;
- mutt_expando_format(s, slen, 0, MuttIndexWindow->cols, NONULL(QueryFormat),
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(QueryFormat),
query_format_str, (unsigned long) entry, MUTT_FORMAT_ARROWCURSOR);
}
* | \%s | size
* | \%u | unlink
*/
-const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+const char *attach_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
char fmt[16];
if (mutt_is_text_part(aptr->content) &&
mutt_get_body_charset(charset, sizeof(charset), aptr->content))
{
- mutt_format_s(dest, destlen, prefix, charset);
+ mutt_format_s(buf, buflen, prec, charset);
}
else
- mutt_format_s(dest, destlen, prefix, "");
+ mutt_format_s(buf, buflen, prec, "");
}
else if (!mutt_is_text_part(aptr->content) ||
!mutt_get_body_charset(charset, sizeof(charset), aptr->content))
/* XXX */
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sc", prefix);
- snprintf(dest, destlen, fmt,
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt,
aptr->content->type != TYPETEXT || aptr->content->noconv ? 'n' : 'c');
}
else if (aptr->content->type != TYPETEXT || aptr->content->noconv)
{
if (aptr->content->description)
{
- mutt_format_s(dest, destlen, prefix, aptr->content->description);
+ mutt_format_s(buf, buflen, prec, aptr->content->description);
break;
}
if (mutt_is_message_type(aptr->content->type, aptr->content->subtype) &&
MUTT_FORMAT_FORCESUBJ | MUTT_FORMAT_MAKEPRINT | MUTT_FORMAT_ARROWCURSOR);
if (*s)
{
- mutt_format_s(dest, destlen, prefix, s);
+ mutt_format_s(buf, buflen, prec, s);
break;
}
}
if (!aptr->content->d_filename && !aptr->content->filename)
{
- mutt_format_s(dest, destlen, prefix, "<no description>");
+ mutt_format_s(buf, buflen, prec, "<no description>");
break;
}
}
{
if (aptr->content->d_filename)
{
- mutt_format_s(dest, destlen, prefix, aptr->content->d_filename);
+ mutt_format_s(buf, buflen, prec, aptr->content->d_filename);
break;
}
}
mutt_str_strfcpy(path, aptr->content->filename, sizeof(path));
mutt_pretty_mailbox(path, sizeof(path));
- mutt_format_s(dest, destlen, prefix, path);
+ mutt_format_s(buf, buflen, prec, path);
}
else
- mutt_format_s(dest, destlen, prefix, NONULL(aptr->content->filename));
+ mutt_format_s(buf, buflen, prec, NONULL(aptr->content->filename));
}
else if (!aptr->content->filename)
optional = 0;
break;
case 'D':
if (!optional)
- snprintf(dest, destlen, "%c", aptr->content->deleted ? 'D' : ' ');
+ snprintf(buf, buflen, "%c", aptr->content->deleted ? 'D' : ' ');
else if (!aptr->content->deleted)
optional = 0;
break;
case 'e':
if (!optional)
- mutt_format_s(dest, destlen, prefix, ENCODING(aptr->content->encoding));
+ mutt_format_s(buf, buflen, prec, ENCODING(aptr->content->encoding));
break;
case 'I':
if (!optional)
mutt_debug(1, "ERROR: invalid content-disposition %d\n", aptr->content->disposition);
ch = '!';
}
- snprintf(dest, destlen, "%c", ch);
+ snprintf(buf, buflen, "%c", ch);
}
break;
case 'm':
if (!optional)
- mutt_format_s(dest, destlen, prefix, TYPE(aptr->content));
+ mutt_format_s(buf, buflen, prec, TYPE(aptr->content));
break;
case 'M':
if (!optional)
- mutt_format_s(dest, destlen, prefix, aptr->content->subtype);
+ mutt_format_s(buf, buflen, prec, aptr->content->subtype);
else if (!aptr->content->subtype)
optional = 0;
break;
case 'n':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, aptr->num + 1);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, aptr->num + 1);
}
break;
case 'Q':
optional = aptr->content->attach_qualifies;
else
{
- snprintf(fmt, sizeof(fmt), "%%%sc", prefix);
- mutt_format_s(dest, destlen, fmt, "Q");
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ mutt_format_s(buf, buflen, fmt, "Q");
}
break;
case 's':
if (!optional)
{
mutt_pretty_size(tmp, sizeof(tmp), l);
- mutt_format_s(dest, destlen, prefix, tmp);
+ mutt_format_s(buf, buflen, prec, tmp);
}
else if (l == 0)
optional = 0;
break;
case 't':
if (!optional)
- snprintf(dest, destlen, "%c", aptr->content->tagged ? '*' : ' ');
+ snprintf(buf, buflen, "%c", aptr->content->tagged ? '*' : ' ');
else if (!aptr->content->tagged)
optional = 0;
break;
case 'T':
if (!optional)
- mutt_format_s_tree(dest, destlen, prefix, NONULL(aptr->tree));
+ mutt_format_s_tree(buf, buflen, prec, NONULL(aptr->tree));
else if (!aptr->tree)
optional = 0;
break;
case 'u':
if (!optional)
- snprintf(dest, destlen, "%c", aptr->content->unlink ? '-' : ' ');
+ snprintf(buf, buflen, "%c", aptr->content->unlink ? '-' : ' ');
else if (!aptr->content->unlink)
optional = 0;
break;
optional = (aptr->content->attach_count + aptr->content->attach_qualifies) != 0;
else
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt,
- aptr->content->attach_count + aptr->content->attach_qualifies);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, aptr->content->attach_count + aptr->content->attach_qualifies);
}
break;
default:
- *dest = 0;
+ *buf = 0;
}
if (optional)
- mutt_expando_format(dest, destlen, col, cols, ifstring, attach_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, if_str, attach_format_str, data, 0);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, cols, elsestring, attach_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, else_str, attach_format_str, data, 0);
return src;
}
-static void attach_entry(char *b, size_t blen, struct Menu *menu, int num)
+static void attach_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
struct AttachCtx *actx = (struct AttachCtx *) menu->data;
- mutt_expando_format(b, blen, 0, MuttIndexWindow->cols, NONULL(AttachFormat),
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(AttachFormat),
attach_format_str, (unsigned long) (actx->idx[actx->v2r[num]]),
MUTT_FORMAT_ARROWCURSOR);
}
* * %s short name
* * %a address
*/
-static const char *mix_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+static const char *mix_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
char fmt[16];
case 'n':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, remailer->num);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, remailer->num);
}
break;
case 'c':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, mix_format_caps(remailer));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, mix_format_caps(remailer));
}
break;
case 's':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(remailer->shortname));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(remailer->shortname));
}
else if (!remailer->shortname)
optional = 0;
case 'a':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
- snprintf(dest, destlen, fmt, NONULL(remailer->addr));
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+ snprintf(buf, buflen, fmt, NONULL(remailer->addr));
}
else if (!remailer->addr)
optional = 0;
break;
default:
- *dest = '\0';
+ *buf = '\0';
}
if (optional)
- mutt_expando_format(dest, destlen, col, cols, ifstring, attach_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, if_str, attach_format_str, data, 0);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, cols, elsestring, attach_format_str, data, 0);
+ mutt_expando_format(buf, buflen, col, cols, else_str, attach_format_str, data, 0);
return src;
}
-static void mix_entry(char *b, size_t blen, struct Menu *menu, int num)
+static void mix_entry(char *buf, size_t buflen, struct Menu *menu, int num)
{
struct Remailer **type2_list = (struct Remailer **) menu->data;
- mutt_expando_format(b, blen, 0, MuttIndexWindow->cols, NONULL(MixEntryFormat), mix_format_str,
+ mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols,
+ NONULL(MixEntryFormat), mix_format_str,
(unsigned long) type2_list[num], MUTT_FORMAT_ARROWCURSOR);
}
* @param[in] op printf-like operator, e.g. 'B'
* @param[in] src printf-like format string
* @param[in] prefix Field formatting string, UNUSED
- * @param[in] ifstring If condition is met, display this string
- * @param[in] elsestring Otherwise, display this string
+ * @param[in] if_str If condition is met, display this string
+ * @param[in] else_str Otherwise, display this string
* @param[in] data Pointer to our sidebar_entry
* @param[in] flags Format flags, e.g. MUTT_FORMAT_OPTIONAL
* @retval src (unchanged)
* '%!' : Icon denoting number of flagged messages.
* '%n' : N if folder has new mail, blank otherwise.
*/
-static const char *sidebar_format_str(char *dest, size_t destlen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+static const char *sidebar_format_str(char *buf, size_t buflen, size_t col, int cols,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
struct SbEntry *sbe = (struct SbEntry *) data;
unsigned int optional;
char fmt[STRING];
- if (!sbe || !dest)
+ if (!sbe || !buf)
return src;
- dest[0] = 0; /* Just in case there's nothing to do */
+ buf[0] = 0; /* Just in case there's nothing to do */
struct Buffy *b = sbe->buffy;
if (!b)
switch (op)
{
case 'B':
- mutt_format_s(dest, destlen, prefix, sbe->box);
+ mutt_format_s(buf, buflen, prec, sbe->box);
break;
case 'd':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, c ? Context->deleted : 0);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, c ? Context->deleted : 0);
}
else if ((c && Context->deleted == 0) || !c)
optional = 0;
case 'F':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, b->msg_flagged);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, b->msg_flagged);
}
else if (b->msg_flagged == 0)
optional = 0;
case 'L':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, c ? Context->vcount : b->msg_count);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, c ? Context->vcount : b->msg_count);
}
else if ((c && Context->vcount == b->msg_count) || !c)
optional = 0;
case 'N':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, b->msg_unread);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, b->msg_unread);
}
else if (b->msg_unread == 0)
optional = 0;
case 'n':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sc", prefix);
- snprintf(dest, destlen, fmt, b->new ? 'N' : ' ');
+ snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+ snprintf(buf, buflen, fmt, b->new ? 'N' : ' ');
}
else if (b->new == false)
optional = 0;
case 'S':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, b->msg_count);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, b->msg_count);
}
else if (b->msg_count == 0)
optional = 0;
case 't':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
- snprintf(dest, destlen, fmt, c ? Context->tagged : 0);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+ snprintf(buf, buflen, fmt, c ? Context->tagged : 0);
}
else if ((c && Context->tagged == 0) || !c)
optional = 0;
case '!':
if (b->msg_flagged == 0)
- mutt_format_s(dest, destlen, prefix, "");
+ mutt_format_s(buf, buflen, prec, "");
else if (b->msg_flagged == 1)
- mutt_format_s(dest, destlen, prefix, "!");
+ mutt_format_s(buf, buflen, prec, "!");
else if (b->msg_flagged == 2)
- mutt_format_s(dest, destlen, prefix, "!!");
+ mutt_format_s(buf, buflen, prec, "!!");
else
{
snprintf(fmt, sizeof(fmt), "%d!", b->msg_flagged);
- mutt_format_s(dest, destlen, prefix, fmt);
+ mutt_format_s(buf, buflen, prec, fmt);
}
break;
}
if (optional)
- mutt_expando_format(dest, destlen, col, SidebarWidth, ifstring,
+ mutt_expando_format(buf, buflen, col, SidebarWidth, if_str,
sidebar_format_str, (unsigned long) sbe, flags);
else if (flags & MUTT_FORMAT_OPTIONAL)
- mutt_expando_format(dest, destlen, col, SidebarWidth, elsestring,
+ mutt_expando_format(buf, buflen, col, SidebarWidth, else_str,
sidebar_format_str, (unsigned long) sbe, flags);
/* We return the format string, unchanged */
* | \%V | currently active limit pattern [option]
*/
static const char *status_format_str(char *buf, size_t buflen, size_t col, int cols,
- char op, const char *src, const char *prefix,
- const char *ifstring, const char *elsestring,
+ char op, const char *src, const char *prec,
+ const char *if_str, const char *else_str,
unsigned long data, enum FormatFlag flags)
{
char fmt[SHORT_STRING], tmp[SHORT_STRING], *cp = NULL;
case 'b':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, mutt_buffy_check(false));
}
else if (!mutt_buffy_check(false))
case 'd':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context ? Context->deleted : 0);
}
else if (!Context || !Context->deleted)
else
mutt_str_strfcpy(tmp, _("(no mailbox)"), sizeof(tmp));
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
snprintf(buf, buflen, fmt, tmp);
break;
}
case 'F':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context ? Context->flagged : 0);
}
else if (!Context || !Context->flagged)
break;
case 'h':
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
snprintf(buf, buflen, fmt, NONULL(ShortHostname));
break;
case 'l':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
mutt_pretty_size(tmp, sizeof(tmp), Context ? Context->size : 0);
snprintf(buf, buflen, fmt, tmp);
}
case 'L':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
mutt_pretty_size(tmp, sizeof(tmp), Context ? Context->vsize : 0);
snprintf(buf, buflen, fmt, tmp);
}
case 'm':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context ? Context->msgcount : 0);
}
else if (!Context || !Context->msgcount)
case 'M':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context ? Context->vcount : 0);
}
else if (!Context || !Context->pattern)
case 'n':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context ? Context->new : 0);
}
else if (!Context || !Context->new)
case 'o':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context ? Context->unread - Context->new : 0);
}
else if (!Context || !(Context->unread - Context->new))
count = mutt_num_postponed(0);
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, count);
}
else if (!count)
snprintf(tmp, sizeof(tmp), "%d%%", count);
cp = tmp;
}
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
snprintf(buf, buflen, fmt, cp);
break;
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, read);
}
else if (!read)
}
case 's':
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
snprintf(buf, buflen, fmt, get_sort_str(tmp, sizeof(tmp), Sort));
break;
case 'S':
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
snprintf(buf, buflen, fmt, get_sort_str(tmp, sizeof(tmp), SortAux));
break;
case 't':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context ? Context->tagged : 0);
}
else if (!Context || !Context->tagged)
case 'u':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%sd", prec);
snprintf(buf, buflen, fmt, Context ? Context->unread : 0);
}
else if (!Context || !Context->unread)
case 'V':
if (!optional)
{
- snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
+ snprintf(fmt, sizeof(fmt), "%%%ss", prec);
snprintf(buf, buflen, fmt, (Context && Context->pattern) ? Context->pattern : "");
}
else if (!Context || !Context->pattern)
return src;
default:
- snprintf(buf, buflen, "%%%s%c", prefix, op);
+ snprintf(buf, buflen, "%%%s%c", prec, op);
break;
}
if (optional)
- status_line(buf, buflen, col, cols, menu, ifstring);
+ status_line(buf, buflen, col, cols, menu, if_str);
else if (flags & MUTT_FORMAT_OPTIONAL)
- status_line(buf, buflen, col, cols, menu, elsestring);
+ status_line(buf, buflen, col, cols, menu, else_str);
return src;
}
projects / neomutt / commitdiff