From: Richard Russon <rich@flatcap.org>
Date: Sun, 26 Nov 2017 02:28:55 +0000 (+0000)
Subject: rename format parameters/variables
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=cdab3c5543b8daf2fafb4d1c6ba9f79342642672;p=neomutt

rename format parameters/variables
---

diff --git a/addrbook.c b/addrbook.c
index 8eac5c9a9..55bc9d581 100644
--- a/addrbook.c
+++ b/addrbook.c
@@ -47,46 +47,46 @@ static const struct Mapping AliasHelp[] = {
   { 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);
 }
 
diff --git a/browser.c b/browser.c
index 82c9999d0..b59a97e9e 100644
--- a/browser.c
+++ b/browser.c
@@ -273,12 +273,12 @@ static int link_is_dir(const char *folder, const char *path)
     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;
@@ -289,8 +289,8 @@ static const char *folder_format_str(char *dest, size_t destlen, size_t col, int
   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':
@@ -321,10 +321,10 @@ static const char *folder_format_str(char *dest, size_t destlen, size_t col, int
         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':
@@ -352,7 +352,7 @@ static const char *folder_format_str(char *dest, size_t destlen, size_t col, int
                              ((folder->ff->mode & S_IXUSR) != 0 ? "*" : ""))) :
                    "");
 
-      mutt_format_s(dest, destlen, fmt, fn);
+      mutt_format_s(buf, buflen, prec, fn);
       break;
     }
     case 'F':
@@ -375,7 +375,7 @@ static const char *folder_format_str(char *dest, size_t destlen, size_t col, int
                  (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)
@@ -383,36 +383,36 @@ static const char *folder_format_str(char *dest, size_t destlen, size_t col, int
         /* 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':
@@ -420,19 +420,19 @@ static const char *folder_format_str(char *dest, size_t destlen, size_t col, int
       {
         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':
@@ -440,11 +440,11 @@ static const char *folder_format_str(char *dest, size_t destlen, size_t col, int
       {
         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;
@@ -454,145 +454,143 @@ static const char *folder_format_str(char *dest, size_t destlen, size_t col, int
       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;
   }
@@ -898,7 +896,7 @@ static int select_vfolder_search(struct Menu *menu, regex_t *re, int n)
 }
 #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;
 
@@ -907,24 +905,25 @@ static void folder_entry(char *s, size_t slen, struct Menu *menu, int num)
 
 #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
diff --git a/compose.c b/compose.c
index eaa3681f8..7c0dcbe74 100644
--- a/compose.c
+++ b/compose.c
@@ -224,11 +224,11 @@ static void init_header_padding(void)
   }
 }
 
-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);
 }
@@ -691,8 +691,8 @@ static unsigned long cum_attachs_size(struct Menu *menu)
  * 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];
@@ -703,17 +703,17 @@ static const char *compose_format_str(char *buf, size_t buflen, size_t col, int
   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;
@@ -728,14 +728,14 @@ static const char *compose_format_str(char *buf, size_t buflen, size_t col, int
       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;
 }
diff --git a/compress.c b/compress.c
index c4684f826..ada3011ed 100644
--- a/compress.c
+++ b/compress.c
@@ -330,15 +330,15 @@ static char *escape_path(char *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)
@@ -346,12 +346,12 @@ static char *escape_path(char *src)
  * 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;
@@ -360,11 +360,11 @@ static const char *compress_format_str(char *dest, size_t destlen, size_t col, i
   {
     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;
diff --git a/curs_lib.c b/curs_lib.c
index a32830150..3b1057273 100644
--- a/curs_lib.c
+++ b/curs_lib.c
@@ -1157,8 +1157,8 @@ int mutt_addwch(wchar_t wc)
  * 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;
@@ -1170,8 +1170,8 @@ void mutt_simple_format(char *dest, size_t destlen, int min_width, int max_width
 
   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))
@@ -1209,25 +1209,25 @@ void mutt_simple_format(char *dest, size_t destlen, int min_width, int max_width
     }
     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 */
   {
@@ -1237,22 +1237,22 @@ void mutt_simple_format(char *dest, size_t destlen, int min_width, int max_width
     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';
   }
 }
@@ -1261,50 +1261,49 @@ void mutt_simple_format(char *dest, size_t destlen, int min_width, int max_width
  * 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);
 }
 
 /**
diff --git a/curs_main.c b/curs_main.c
index 3bf6fd785..686cc99b7 100644
--- a/curs_main.c
+++ b/curs_main.c
@@ -594,7 +594,7 @@ void mutt_ts_icon(char *str)
   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;
@@ -659,7 +659,7 @@ void index_make_entry(char *s, size_t l, struct Menu *menu, int num)
     }
   }
 
-  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)
diff --git a/format_flags.h b/format_flags.h
index 3ddb41b9f..1adb636c3 100644
--- a/format_flags.h
+++ b/format_flags.h
@@ -40,12 +40,12 @@ enum FormatFlag
   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);
 
diff --git a/hdrline.c b/hdrline.c
index dd08f80f7..d281870e0 100644
--- a/hdrline.c
+++ b/hdrline.c
@@ -458,15 +458,15 @@ static bool thread_is_old(struct Context *ctx, struct Header *hdr)
  * | \%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);
@@ -480,7 +480,7 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
 
   if (!hdr || !hdr->env)
     return src;
-  dest[0] = 0;
+  buf[0] = 0;
   switch (op)
   {
     case 'A':
@@ -489,46 +489,46 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       {
         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')
@@ -545,28 +545,28 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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':
@@ -589,7 +589,7 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
           tm = localtime(&T);
           T -= (op == '(') ? hdr->received : hdr->date_sent;
 
-          is = (char *) prefix;
+          is = (char *) prec;
           if (*is == '>')
           {
             invert = 1;
@@ -673,7 +673,7 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
           break;
         }
 
-        p = dest;
+        p = buf;
 
         cp = (op == 'd' || op == 'D') ? (NONULL(DateFormat)) : src;
         if (*cp == '!')
@@ -684,7 +684,7 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
         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 != '>')))
@@ -747,13 +747,13 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
 
         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;
@@ -761,33 +761,33 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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;
@@ -797,9 +797,9 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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;
@@ -820,9 +820,9 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
         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++;
@@ -830,7 +830,7 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       else
       {
         format[0] = op;
-        format[1] = *prefix;
+        format[1] = *prec;
         format[2] = 0;
 
         tag = mutt_hash_find(TagFormats, format);
@@ -850,14 +850,13 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
         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':
@@ -885,22 +884,22 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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;
@@ -909,10 +908,10 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
     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))
@@ -924,37 +923,37 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
     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
       {
@@ -966,8 +965,8 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
     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
       {
@@ -979,10 +978,10 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
     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))
@@ -992,29 +991,29 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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':
@@ -1030,20 +1029,20 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       {
         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;
@@ -1066,28 +1065,28 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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] :
                    " ");
@@ -1096,35 +1095,35 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
     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;
@@ -1133,7 +1132,7 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
 #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;
@@ -1148,8 +1147,8 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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;
 
@@ -1157,9 +1156,9 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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':
@@ -1183,13 +1182,12 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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':
@@ -1219,7 +1217,7 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
             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 */
@@ -1236,7 +1234,7 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
         else
           ch = " ";
 
-        snprintf(buf2, sizeof(buf2), "%s", ch);
+        snprintf(tmp, sizeof(tmp), "%s", ch);
         src++;
       }
       else if (src[0] == 't') /* tagged, flagged, recipient */
@@ -1249,15 +1247,15 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
         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':
@@ -1309,30 +1307,30 @@ static const char *index_format_str(char *dest, size_t destlen, size_t col, int
       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;
@@ -1341,12 +1339,12 @@ void mutt_make_string_flags(char *dest, size_t destlen, const char *s,
   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);
 }
diff --git a/menu.c b/menu.c
index 661a46c0e..5e5641566 100644
--- a/menu.c
+++ b/menu.c
@@ -286,14 +286,15 @@ static void menu_make_entry(char *s, int l, struct Menu *menu, int i)
     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);
 }
 
diff --git a/mutt_menu.h b/mutt_menu.h
index 4eb968d6b..363aebd9f 100644
--- a/mutt_menu.h
+++ b/mutt_menu.h
@@ -76,7 +76,7 @@ struct Menu
   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);
diff --git a/muttlib.c b/muttlib.c
index 07289879d..1b01f0a63 100644
--- a/muttlib.c
+++ b/muttlib.c
@@ -891,12 +891,11 @@ char *mutt_apply_replace(char *dbuf, size_t dlen, char *sbuf, struct ReplaceList
  * @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;
@@ -908,7 +907,7 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
   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;
 
@@ -957,9 +956,9 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
         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
@@ -977,44 +976,44 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
       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);
               }
@@ -1042,7 +1041,7 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
     }
   }
 
-  while (*src && wlen < destlen)
+  while (*src && wlen < buflen)
   {
     if (*src == '%')
     {
@@ -1121,10 +1120,10 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
         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] == '>'))
           {
@@ -1160,9 +1159,9 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
         /* 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] == '>'))
           {
@@ -1213,27 +1212,27 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
           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++;
@@ -1253,25 +1252,25 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
             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;
@@ -1288,11 +1287,11 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
           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);
@@ -1321,26 +1320,26 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
         }
 
         /* 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 == '\\')
@@ -1375,23 +1374,26 @@ void mutt_expando_format(char *dest, size_t destlen, size_t col, int cols,
     }
     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;
       }
     }
   }
diff --git a/ncrypt/crypt_gpgme.c b/ncrypt/crypt_gpgme.c
index aebfcbfe3..f40a95b4f 100644
--- a/ncrypt/crypt_gpgme.c
+++ b/ncrypt/crypt_gpgme.c
@@ -2911,9 +2911,9 @@ int smime_gpgme_application_handler(struct Body *a, struct State *s)
  * * \%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];
@@ -2943,7 +2943,7 @@ static const char *crypt_format_str(char *dest, size_t destlen, size_t col, int
       struct tm *tm = NULL;
       size_t len;
 
-      p = dest;
+      p = buf;
 
       cp = src;
       if (*cp == '!')
@@ -2954,7 +2954,7 @@ static const char *crypt_format_str(char *dest, size_t destlen, size_t col, int
       else
         do_locales = 1;
 
-      len = destlen - 1;
+      len = buflen - 1;
       while (len > 0 && *cp != ']')
       {
         if (*cp == '%')
@@ -2989,12 +2989,12 @@ static const char *crypt_format_str(char *dest, size_t destlen, size_t col, int
 
       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;
     }
@@ -3002,8 +3002,8 @@ static const char *crypt_format_str(char *dest, size_t destlen, size_t col, int
     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':
@@ -3011,44 +3011,44 @@ static const char *crypt_format_str(char *dest, size_t destlen, size_t col, int
       {
         /* 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;
@@ -3056,8 +3056,8 @@ static const char *crypt_format_str(char *dest, size_t destlen, size_t col, int
     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;
@@ -3090,29 +3090,29 @@ static const char *crypt_format_str(char *dest, size_t destlen, size_t col, int
             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;
@@ -3120,7 +3120,7 @@ static void crypt_entry(char *s, size_t l, struct Menu *menu, int num)
   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);
 }
 
diff --git a/ncrypt/pgpinvoke.c b/ncrypt/pgpinvoke.c
index 2dfbc40bb..df7108438 100644
--- a/ncrypt/pgpinvoke.c
+++ b/ncrypt/pgpinvoke.c
@@ -57,9 +57,9 @@ struct PgpCommandContext
   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];
@@ -72,8 +72,8 @@ static const char *fmt_pgp_command(char *dest, size_t destlen, size_t col, int c
     {
       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;
@@ -84,8 +84,8 @@ static const char *fmt_pgp_command(char *dest, size_t destlen, size_t col, int c
     {
       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;
@@ -96,8 +96,8 @@ static const char *fmt_pgp_command(char *dest, size_t destlen, size_t col, int c
     {
       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;
@@ -108,8 +108,8 @@ static const char *fmt_pgp_command(char *dest, size_t destlen, size_t col, int c
     {
       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;
@@ -120,8 +120,8 @@ static const char *fmt_pgp_command(char *dest, size_t destlen, size_t col, int c
     {
       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;
@@ -129,25 +129,25 @@ static const char *fmt_pgp_command(char *dest, size_t destlen, size_t col, int c
     }
     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);
 }
 
 /*
diff --git a/ncrypt/pgpkey.c b/ncrypt/pgpkey.c
index 0c9b46de5..cf1a06fcd 100644
--- a/ncrypt/pgpkey.c
+++ b/ncrypt/pgpkey.c
@@ -139,9 +139,9 @@ struct PgpEntry
   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];
@@ -172,7 +172,7 @@ static const char *pgp_entry_fmt(char *dest, size_t destlen, size_t col, int col
       struct tm *tm = NULL;
       size_t len;
 
-      p = dest;
+      p = buf;
 
       cp = src;
       if (*cp == '!')
@@ -183,7 +183,7 @@ static const char *pgp_entry_fmt(char *dest, size_t destlen, size_t col, int col
       else
         do_locales = 1;
 
-      len = destlen - 1;
+      len = buflen - 1;
       while (len > 0 && *cp != ']')
       {
         if (*cp == '%')
@@ -211,12 +211,12 @@ static const char *pgp_entry_fmt(char *dest, size_t destlen, size_t col, int col
 
       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;
     }
@@ -224,43 +224,43 @@ static const char *pgp_entry_fmt(char *dest, size_t destlen, size_t col, int col
     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;
@@ -268,8 +268,8 @@ static const char *pgp_entry_fmt(char *dest, size_t destlen, size_t col, int col
     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;
@@ -277,25 +277,25 @@ static const char *pgp_entry_fmt(char *dest, size_t destlen, size_t col, int col
     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;
@@ -303,7 +303,7 @@ static void pgp_entry(char *s, size_t l, struct Menu *menu, int num)
   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);
 }
 
diff --git a/ncrypt/smime.c b/ncrypt/smime.c
index baad3d5ca..aa3934e41 100644
--- a/ncrypt/smime.c
+++ b/ncrypt/smime.c
@@ -159,9 +159,9 @@ int smime_valid_passphrase(void)
  *
  * 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];
@@ -187,8 +187,8 @@ static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int
         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;
@@ -199,8 +199,8 @@ static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int
     { /* 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;
@@ -211,8 +211,8 @@ static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int
     { /* 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;
@@ -223,8 +223,8 @@ static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int
     { /* 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;
@@ -235,8 +235,8 @@ static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int
     { /* 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;
@@ -247,8 +247,8 @@ static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int
     { /* 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;
@@ -259,8 +259,8 @@ static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int
     { /* 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;
@@ -271,8 +271,8 @@ static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int
     { /* 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;
@@ -280,24 +280,24 @@ static const char *fmt_smime_command(char *dest, size_t destlen, size_t col, int
     }
 
     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,
@@ -351,7 +351,7 @@ static char *smime_key_flags(int flags)
   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];
@@ -379,7 +379,7 @@ static void smime_entry(char *s, size_t l, struct Menu *menu, int 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);
 }
 
diff --git a/newsrc.c b/newsrc.c
index 33b40bd51..7d1c56906 100644
--- a/newsrc.c
+++ b/newsrc.c
@@ -867,15 +867,14 @@ void nntp_clear_cache(struct NntpServer *nserv)
  * %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)
   {
@@ -885,26 +884,26 @@ const char *nntp_format_str(char *dest, size_t destlen, size_t col, int cols,
       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);
@@ -912,12 +911,12 @@ const char *nntp_format_str(char *dest, size_t destlen, size_t col, int cols,
       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;
diff --git a/nntp.h b/nntp.h
index d8b034135..6b211ea3b 100644
--- a/nntp.h
+++ b/nntp.h
@@ -177,7 +177,7 @@ void nntp_expand_path(char *line, size_t len, struct Account *acct);
 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;
diff --git a/postpone.c b/postpone.c
index 5ab68f20b..8e95cbe9b 100644
--- a/postpone.c
+++ b/postpone.c
@@ -172,11 +172,11 @@ void mutt_update_num_postponed(void)
   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);
 }
 
diff --git a/protos.h b/protos.h
index 8b7081d95..367bb4bdb 100644
--- a/protos.h
+++ b/protos.h
@@ -120,9 +120,9 @@ struct Envelope *mutt_read_rfc822_header(FILE *f, struct Header *hdr, short user
 
 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);
@@ -184,10 +184,10 @@ void mutt_expand_file_fmt(char *dest, size_t destlen, const char *fmt, const cha
 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);
diff --git a/query.c b/query.c
index 988872ec2..011cc70c6 100644
--- a/query.c
+++ b/query.c
@@ -206,65 +206,65 @@ static int query_search(struct Menu *m, regex_t *re, int n)
   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);
 }
 
diff --git a/recvattach.c b/recvattach.c
index 5ae6c4cd4..4c9404269 100644
--- a/recvattach.c
+++ b/recvattach.c
@@ -160,9 +160,9 @@ void mutt_update_tree(struct AttachCtx *actx)
  * | \%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];
@@ -180,10 +180,10 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
         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))
@@ -195,8 +195,8 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
       /* 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)
@@ -207,7 +207,7 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
       {
         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) &&
@@ -219,13 +219,13 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
               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;
         }
       }
@@ -241,7 +241,7 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
       {
         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;
         }
       }
@@ -260,23 +260,23 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
 
           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)
@@ -291,24 +291,24 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
           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':
@@ -316,8 +316,8 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
         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':
@@ -333,7 +333,7 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
       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;
@@ -341,19 +341,19 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
       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;
@@ -362,27 +362,26 @@ const char *attach_format_str(char *dest, size_t destlen, size_t col, int cols,
         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);
 }
diff --git a/remailer.c b/remailer.c
index 939bea513..2781d00a6 100644
--- a/remailer.c
+++ b/remailer.c
@@ -357,9 +357,9 @@ static const char *mix_format_caps(struct Remailer *r)
  * * %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];
@@ -371,22 +371,22 @@ static const char *mix_format_str(char *dest, size_t destlen, size_t col, int co
     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;
@@ -394,28 +394,29 @@ static const char *mix_format_str(char *dest, size_t destlen, size_t col, int co
     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);
 }
 
diff --git a/sidebar.c b/sidebar.c
index f0cdcf4f1..4d4b9646d 100644
--- a/sidebar.c
+++ b/sidebar.c
@@ -96,8 +96,8 @@ enum SidebarSrc
  * @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)
@@ -108,19 +108,19 @@ enum SidebarSrc
  * '%!' : 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)
@@ -133,14 +133,14 @@ static const char *sidebar_format_str(char *dest, size_t destlen, size_t col, in
   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;
@@ -149,8 +149,8 @@ static const char *sidebar_format_str(char *dest, size_t destlen, size_t col, in
     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;
@@ -159,8 +159,8 @@ static const char *sidebar_format_str(char *dest, size_t destlen, size_t col, in
     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;
@@ -169,8 +169,8 @@ static const char *sidebar_format_str(char *dest, size_t destlen, size_t col, in
     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;
@@ -179,8 +179,8 @@ static const char *sidebar_format_str(char *dest, size_t destlen, size_t col, in
     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;
@@ -189,8 +189,8 @@ static const char *sidebar_format_str(char *dest, size_t destlen, size_t col, in
     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;
@@ -199,8 +199,8 @@ static const char *sidebar_format_str(char *dest, size_t destlen, size_t col, in
     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;
@@ -208,24 +208,24 @@ static const char *sidebar_format_str(char *dest, size_t destlen, size_t col, in
 
     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 */
diff --git a/status.c b/status.c
index fec9e5016..f1a063658 100644
--- a/status.c
+++ b/status.c
@@ -74,8 +74,8 @@ static void status_line(char *buf, size_t buflen, size_t col, int cols,
  * | \%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;
@@ -88,7 +88,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     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))
@@ -98,7 +98,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     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)
@@ -129,14 +129,14 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
       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)
@@ -144,14 +144,14 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
       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);
       }
@@ -162,7 +162,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     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);
       }
@@ -173,7 +173,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     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)
@@ -183,7 +183,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     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)
@@ -193,7 +193,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     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)
@@ -203,7 +203,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     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))
@@ -214,7 +214,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
       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)
@@ -232,7 +232,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
         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;
 
@@ -268,7 +268,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
 
       if (!optional)
       {
-        snprintf(fmt, sizeof(fmt), "%%%sd", prefix);
+        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
         snprintf(buf, buflen, fmt, read);
       }
       else if (!read)
@@ -277,19 +277,19 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     }
 
     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)
@@ -299,7 +299,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     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)
@@ -314,7 +314,7 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
     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)
@@ -326,14 +326,14 @@ static const char *status_format_str(char *buf, size_t buflen, size_t col, int c
       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;
 }