use buffer printf

diff --git a/color.c b/color.c
index df7b26f283e63c944a044cf572886fd10bb44705..c9a7057a9af7c1f33126abaa687d04acdbc65aec 100644 (file)
--- a/color.c
+++ b/color.c
@@ -405,13 +405,13 @@ static int parse_color_name(const char *s, int *col, int *attr, int is_fg, struc
     *col = strtol(s, &eptr, 10);
     if (!*s || *eptr || *col < 0 || (*col >= COLORS && !OptNoCurses && has_colors()))
     {
-      snprintf(err->data, err->dsize, _("%s: color not supported by term"), s);
+      mutt_buffer_printf(err, _("%s: color not supported by term"), s);
       return -1;
     }
   }
   else if ((*col = mutt_map_get_value(s, Colors)) == -1)
   {
-    snprintf(err->data, err->dsize, _("%s: no such color"), s);
+    mutt_buffer_printf(err, _("%s: no such color"), s);
     return -1;
   }
 
@@ -508,7 +508,7 @@ static int parse_uncolor(struct Buffer *buf, struct Buffer *s, unsigned long dat
   object = mutt_map_get_value(buf->data, Fields);
   if (object == -1)
   {
-    snprintf(err->data, err->dsize, _("%s: no such object"), buf->data);
+    mutt_buffer_printf(err, _("%s: no such object"), buf->data);
     return -1;
   }
 
@@ -523,16 +523,14 @@ static int parse_uncolor(struct Buffer *buf, struct Buffer *s, unsigned long dat
       (mutt_str_strncmp(buf->data, "header", 6) != 0) &&
       (mutt_str_strncmp(buf->data, "index", 5) != 0))
   {
-    snprintf(err->data, err->dsize,
-             _("%s: command valid only for index, body, header objects"),
-             parse_uncolor ? "uncolor" : "unmono");
+    mutt_buffer_printf(err, _("%s: command valid only for index, body, header objects"),
+                       parse_uncolor ? "uncolor" : "unmono");
     return -1;
   }
 
   if (!MoreArgs(s))
   {
-    snprintf(err->data, err->dsize, _("%s: too few arguments"),
-             parse_uncolor ? "uncolor" : "unmono");
+    mutt_buffer_printf(err, _("%s: too few arguments"), parse_uncolor ? "uncolor" : "unmono");
     return -1;
   }
 
@@ -736,7 +734,7 @@ static int parse_object(struct Buffer *buf, struct Buffer *s, int *o, int *ql,
       *ql = strtol(buf->data + 6, &eptr, 10);
       if (*eptr || *ql < 0)
       {
-        snprintf(err->data, err->dsize, _("%s: no such object"), buf->data);
+        mutt_buffer_printf(err, _("%s: no such object"), buf->data);
         return -1;
       }
     }
@@ -758,13 +756,13 @@ static int parse_object(struct Buffer *buf, struct Buffer *s, int *o, int *ql,
     *o = mutt_map_get_value(buf->data, ComposeFields);
     if (*o == -1)
     {
-      snprintf(err->data, err->dsize, _("%s: no such object"), buf->data);
+      mutt_buffer_printf(err, _("%s: no such object"), buf->data);
       return (-1);
     }
   }
   else if ((*o = mutt_map_get_value(buf->data, Fields)) == -1)
   {
-    snprintf(err->data, err->dsize, _("%s: no such object"), buf->data);
+    mutt_buffer_printf(err, _("%s: no such object"), buf->data);
     return -1;
   }
 
@@ -836,7 +834,7 @@ static int parse_attr_spec(struct Buffer *buf, struct Buffer *s, int *fg,
     *attr = A_NORMAL; /* needs use = instead of |= to clear other bits */
   else
   {
-    snprintf(err->data, err->dsize, _("%s: no such attribute"), buf->data);
+    mutt_buffer_printf(err, _("%s: no such attribute"), buf->data);
     return -1;
   }
 

diff --git a/curs_lib.c b/curs_lib.c
index 0100d291d4e7c64378be65beac00538ec4cfce89..0e0e5fdda0b232fa7a2bf9d29f88becdd03f7641 100644 (file)
--- a/curs_lib.c
+++ b/curs_lib.c
@@ -838,9 +838,9 @@ void mutt_simple_format(char *buf, size_t buflen, int min_width, int max_width,
  * @param[in]  s        String to format
  * @param[in]  arboreal  If true, string contains graphical tree characters
  *
- * This formats a string rather like
- *   snprintf (fmt, sizeof (fmt), "%%%ss", prec);
- *   snprintf (buf, buflen, fmt, s);
+ * This formats a string rather like:
+ * - 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.
  */

diff --git a/hook.c b/hook.c
index aeb1a7aef5e7b2400bde1c9f318855ec30831d1f..d7a46bd1d310a23e69a2033ed94173c4cf3a98a3 100644 (file)
--- a/hook.c
+++ b/hook.c
@@ -335,8 +335,7 @@ int mutt_parse_unhook(struct Buffer *buf, struct Buffer *s, unsigned long data,
     {
       if (current_hook_type)
       {
-        snprintf(err->data, err->dsize, "%s",
-                 _("unhook: Can't do unhook * from within a hook."));
+        mutt_buffer_printf(err, "%s", _("unhook: Can't do unhook * from within a hook."));
         return -1;
       }
       mutt_delete_hooks(0);
@@ -348,7 +347,7 @@ int mutt_parse_unhook(struct Buffer *buf, struct Buffer *s, unsigned long data,
 
       if (!type)
       {
-        snprintf(err->data, err->dsize, _("unhook: unknown hook type: %s"), buf->data);
+        mutt_buffer_printf(err, _("unhook: unknown hook type: %s"), buf->data);
         return -1;
       }
       if (type & (MUTT_CHARSETHOOK | MUTT_ICONVHOOK))
@@ -358,8 +357,8 @@ int mutt_parse_unhook(struct Buffer *buf, struct Buffer *s, unsigned long data,
       }
       if (current_hook_type == type)
       {
-        snprintf(err->data, err->dsize, _("unhook: Can't delete a %s from within a %s."),
-                 buf->data, buf->data);
+        mutt_buffer_printf(err, _("unhook: Can't delete a %s from within a %s."),
+                           buf->data, buf->data);
         return -1;
       }
       mutt_delete_hooks(type);

diff --git a/init.c b/init.c
index b6392ae20a07b0f501e69912407d006fc01ee033..79467a74ce9b16e41f26d554b5da33a7a67654cc 100644 (file)
--- a/init.c
+++ b/init.c
@@ -69,7 +69,7 @@
 #define CHECK_PAGER                                                                  \
   if ((CurrentMenu == MENU_PAGER) && (idx >= 0) && (MuttVars[idx].flags & R_RESORT)) \
   {                                                                                  \
-    snprintf(err->data, err->dsize, "%s", _("Not available in this menu."));         \
+    mutt_buffer_printf(err, "%s", _("Not available in this menu."));                 \
     return -1;                                                                       \
   }
 
@@ -878,7 +878,7 @@ static int parse_sort(short *val, const char *s, const struct Mapping *map, stru
   i = mutt_map_get_value(s, map);
   if (i == -1)
   {
-    snprintf(err->data, err->dsize, _("%s: unknown sorting method"), s);
+    mutt_buffer_printf(err, _("%s: unknown sorting method"), s);
     return -1;
   }
 
@@ -1256,7 +1256,7 @@ static int source_rc(const char *rcfile_path, struct Buffer *err)
   f = mutt_open_read(rcfile, &pid);
   if (!f)
   {
-    snprintf(err->data, err->dsize, "%s: %s", rcfile, strerror(errno));
+    mutt_buffer_printf(err, "%s: %s", rcfile, strerror(errno));
     return -1;
   }
 
@@ -1311,11 +1311,8 @@ static int source_rc(const char *rcfile_path, struct Buffer *err)
   if (rc)
   {
     /* the neomuttrc source keyword */
-    snprintf(err->data, err->dsize,
-             rc >= -MAXERRS ?
-                 _("source: errors in %s") :
-                 _("source: reading aborted due to too many errors in %s"),
-             rcfile);
+    mutt_buffer_printf(err, (rc >= -MAXERRS) ? _("source: errors in %s") : _("source: reading aborted due to too many errors in %s"),
+                       rcfile);
     rc = -1;
   }
   else
@@ -1323,9 +1320,8 @@ static int source_rc(const char *rcfile_path, struct Buffer *err)
     /* Don't alias errors with warnings */
     if (warnings > 0)
     {
-      snprintf(err->data, err->dsize,
-               ngettext("source: %d warning in %s", "source: %d warnings in %s", warnings),
-               warnings, rcfile);
+      mutt_buffer_printf(err, ngettext("source: %d warning in %s", "source: %d warnings in %s", warnings),
+                         warnings, rcfile);
       rc = -2;
     }
   }
@@ -1425,8 +1421,7 @@ static int parse_alias(struct Buffer *buf, struct Buffer *s, unsigned long data,
 
   if (mutt_addrlist_to_intl(tmp->addr, &estr))
   {
-    snprintf(err->data, err->dsize, _("Warning: Bad IDN '%s' in alias '%s'.\n"),
-             estr, tmp->name);
+    mutt_buffer_printf(err, _("Warning: Bad IDN '%s' in alias '%s'.\n"), estr, tmp->name);
     FREE(&estr);
     goto bail;
   }
@@ -1646,8 +1641,8 @@ static int parse_group(struct Buffer *buf, struct Buffer *s, unsigned long data,
       switch (state)
       {
         case GS_NONE:
-          snprintf(err->data, err->dsize, _("%sgroup: missing -rx or -addr."),
-                   data == MUTT_UNGROUP ? "un" : "");
+          mutt_buffer_printf(err, _("%sgroup: missing -rx or -addr."),
+                             (data == MUTT_UNGROUP) ? "un" : "");
           goto bail;
 
         case GS_RX:
@@ -1669,8 +1664,8 @@ static int parse_group(struct Buffer *buf, struct Buffer *s, unsigned long data,
             goto bail;
           if (mutt_addrlist_to_intl(addr, &estr))
           {
-            snprintf(err->data, err->dsize, _("%sgroup: warning: bad IDN '%s'.\n"),
-                     data == 1 ? "un" : "", estr);
+            mutt_buffer_printf(err, _("%sgroup: warning: bad IDN '%s'.\n"),
+                               data == 1 ? "un" : "", estr);
             mutt_addr_free(&addr);
             FREE(&estr);
             goto bail;
@@ -1772,7 +1767,7 @@ static int parse_ifdef(struct Buffer *buf, struct Buffer *s, unsigned long data,
 
   if (!MoreArgs(s))
   {
-    snprintf(err->data, err->dsize, _("%s: too few arguments"), (data ? "ifndef" : "ifdef"));
+    mutt_buffer_printf(err, _("%s: too few arguments"), (data ? "ifndef" : "ifdef"));
     return -1;
   }
   mutt_extract_token(buf, s, MUTT_TOKEN_SPACE);
@@ -2017,7 +2012,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
     else if ((idx = mutt_option_index(buf->data)) == -1 &&
              !(reset && (mutt_str_strcmp("all", buf->data) == 0)))
     {
-      snprintf(err->data, err->dsize, _("%s: unknown variable"), buf->data);
+      mutt_buffer_printf(err, _("%s: unknown variable"), buf->data);
       return -1;
     }
     SKIPWS(s->dptr);
@@ -2026,13 +2021,13 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
     {
       if (query || unset || inv)
       {
-        snprintf(err->data, err->dsize, "%s", _("prefix is illegal with reset"));
+        mutt_buffer_printf(err, "%s", _("prefix is illegal with reset"));
         return -1;
       }
 
       if (*s->dptr == '=')
       {
-        snprintf(err->data, err->dsize, "%s", _("value is illegal with reset"));
+        mutt_buffer_printf(err, "%s", _("value is illegal with reset"));
         return -1;
       }
 
@@ -2040,7 +2035,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
       {
         if (CurrentMenu == MENU_PAGER)
         {
-          snprintf(err->data, err->dsize, "%s", _("Not available in this menu."));
+          mutt_buffer_printf(err, "%s", _("Not available in this menu."));
           return -1;
         }
         for (idx = 0; MuttVars[idx].name; idx++)
@@ -2067,7 +2062,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
       {
         if (unset || inv || query)
         {
-          snprintf(err->data, err->dsize, "%s", _("Usage: set variable=yes|no"));
+          mutt_buffer_printf(err, "%s", _("Usage: set variable=yes|no"));
           return -1;
         }
 
@@ -2079,16 +2074,15 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
           unset = 1;
         else
         {
-          snprintf(err->data, err->dsize, "%s", _("Usage: set variable=yes|no"));
+          mutt_buffer_printf(err, "%s", _("Usage: set variable=yes|no"));
           return -1;
         }
       }
 
       if (query)
       {
-        snprintf(err->data, err->dsize,
-                 *(bool *) MuttVars[idx].var ? _("%s is set") : _("%s is unset"),
-                 buf->data);
+        mutt_buffer_printf(err, *(bool *) MuttVars[idx].var ? _("%s is set") : _("%s is unset"),
+                           buf->data);
         return 0;
       }
 
@@ -2134,7 +2128,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
           }
           else
           {
-            snprintf(err->data, err->dsize, _("%s: unknown variable"), myvar);
+            mutt_buffer_printf(err, _("%s: unknown variable"), myvar);
             return -1;
           }
         }
@@ -2207,8 +2201,8 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
               /* $charset can't be empty, others can */
               ((strcmp(MuttVars[idx].name, "charset") == 0) && !*buf->data))
           {
-            snprintf(err->data, err->dsize, _("Invalid value for option %s: \"%s\""),
-                     MuttVars[idx].name, buf->data);
+            mutt_buffer_printf(err, _("Invalid value for option %s: \"%s\""),
+                               MuttVars[idx].name, buf->data);
             return -1;
           }
 
@@ -2221,8 +2215,8 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
                                "show_multipart_alternative") == 0) &&
               !valid_show_multipart_alternative(buf->data))
           {
-            snprintf(err->data, err->dsize, _("Invalid value for name %s: \"%s\""),
-                     MuttVars[idx].name, buf->data);
+            mutt_buffer_printf(err, _("Invalid value for name %s: \"%s\""),
+                               MuttVars[idx].name, buf->data);
             return -1;
           }
         }
@@ -2252,7 +2246,8 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
 
       if (OptAttachMsg && (mutt_str_strcmp(MuttVars[idx].name, "reply_regex") == 0))
       {
-        snprintf(err->data, err->dsize, "Operation not permitted when in attach-message mode.");
+        mutt_buffer_printf(
+            err, "Operation not permitted when in attach-message mode.");
         r = -1;
         break;
       }
@@ -2307,7 +2302,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
             p = "unknown";
             break;
         }
-        snprintf(err->data, err->dsize, "%s=%s", MuttVars[idx].name, p);
+        mutt_buffer_printf(err, "%s=%s", MuttVars[idx].name, p);
         break;
       }
 
@@ -2318,7 +2313,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
       mutt_extract_token(buf, s, MUTT_TOKEN_BACKTICK_VARS);
       if (mx_set_magic(buf->data))
       {
-        snprintf(err->data, err->dsize, _("%s: invalid mailbox type"), buf->data);
+        mutt_buffer_printf(err, _("%s: invalid mailbox type"), buf->data);
         r = -1;
         break;
       }
@@ -2337,7 +2332,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
           val = *ptr < 0 ? -*ptr : 0;
 
         /* user requested the value of this variable */
-        snprintf(err->data, err->dsize, "%s=%d", MuttVars[idx].name, val);
+        mutt_buffer_printf(err, "%s=%d", MuttVars[idx].name, val);
         break;
       }
 
@@ -2349,8 +2344,8 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
 
       if (rc < 0 || !*buf->data)
       {
-        snprintf(err->data, err->dsize, _("%s: invalid value (%s)"), buf->data,
-                 rc == -1 ? _("format error") : _("number overflow"));
+        mutt_buffer_printf(err, _("%s: invalid value (%s)"), buf->data,
+                           (rc == -1) ? _("format error") : _("number overflow"));
         r = -1;
         break;
       }
@@ -2393,8 +2388,8 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
       {
         static const char *const vals[] = { "no", "yes", "ask-no", "ask-yes" };
 
-        snprintf(err->data, err->dsize, "%s=%s", MuttVars[idx].name,
-                 vals[*(unsigned char *) MuttVars[idx].var]);
+        mutt_buffer_printf(err, "%s=%s", MuttVars[idx].name,
+                           vals[*(unsigned char *) MuttVars[idx].var]);
         break;
       }
 
@@ -2413,7 +2408,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
           *(unsigned char *) MuttVars[idx].var = MUTT_ASKNO;
         else
         {
-          snprintf(err->data, err->dsize, _("%s: invalid value"), buf->data);
+          mutt_buffer_printf(err, _("%s: invalid value"), buf->data);
           r = -1;
           break;
         }
@@ -2458,7 +2453,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
 
       if (!map)
       {
-        snprintf(err->data, err->dsize, _("%s: Unknown type."), MuttVars[idx].name);
+        mutt_buffer_printf(err, _("%s: Unknown type."), MuttVars[idx].name);
         r = -1;
         break;
       }
@@ -2467,9 +2462,10 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
       {
         p = mutt_map_get_name(*((short *) MuttVars[idx].var) & SORT_MASK, map);
 
-        snprintf(err->data, err->dsize, "%s=%s%s%s", MuttVars[idx].name,
-                 (*((short *) MuttVars[idx].var) & SORT_REVERSE) ? "reverse-" : "",
-                 (*((short *) MuttVars[idx].var) & SORT_LAST) ? "last-" : "", p);
+        mutt_buffer_printf(
+            err, "%s=%s%s%s", MuttVars[idx].name,
+            (*((short *) MuttVars[idx].var) & SORT_REVERSE) ? "reverse-" : "",
+            (*((short *) MuttVars[idx].var) & SORT_LAST) ? "last-" : "", p);
         return 0;
       }
       CHECK_PAGER;
@@ -2504,7 +2500,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
       }
       else
       {
-        snprintf(err->data, err->dsize, _("%s: invalid backend"), buf->data);
+        mutt_buffer_printf(err, _("%s: invalid backend"), buf->data);
         r = -1;
         break;
       }
@@ -2512,8 +2508,8 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
 #endif
     else
     {
-      snprintf(err->data, err->dsize, _("%s: unknown type"),
-               (idx >= 0) ? MuttVars[idx].name : "unknown");
+      mutt_buffer_printf(err, _("%s: unknown type"),
+                         (idx >= 0) ? MuttVars[idx].name : "unknown");
       r = -1;
       break;
     }
@@ -2607,7 +2603,7 @@ static int parse_setenv(struct Buffer *buf, struct Buffer *s,
       return 0;
     }
 
-    snprintf(err->data, err->dsize, _("%s is unset"), buf->data);
+    mutt_buffer_printf(err, _("%s is unset"), buf->data);
     return -1;
   }
 
@@ -2658,7 +2654,7 @@ static int parse_source(struct Buffer *buf, struct Buffer *s,
   {
     if (mutt_extract_token(buf, s, 0) != 0)
     {
-      snprintf(err->data, err->dsize, _("source: error at %s"), s->dptr);
+      mutt_buffer_printf(err, _("source: error at %s"), s->dptr);
       return -1;
     }
     mutt_str_strfcpy(path, buf->data, sizeof(path));
@@ -2666,7 +2662,7 @@ static int parse_source(struct Buffer *buf, struct Buffer *s,
 
     if (source_rc(path, err) < 0)
     {
-      snprintf(err->data, err->dsize, _("source: file %s could not be sourced."), path);
+      mutt_buffer_printf(err, _("source: file %s could not be sourced."), path);
       return -1;
     }
 
@@ -4099,7 +4095,7 @@ int mutt_option_set(const struct Option *val, struct Buffer *err)
         }
         else
         {
-          snprintf(err->data, err->dsize, _("%s: Unknown type."), MuttVars[idx].name);
+          mutt_buffer_printf(err, _("%s: Unknown type."), MuttVars[idx].name);
           return -1;
         }
         break;
@@ -4133,7 +4129,7 @@ int mutt_option_set(const struct Option *val, struct Buffer *err)
 
         if (!map)
         {
-          snprintf(err->data, err->dsize, _("%s: Unknown type."), MuttVars[idx].name);
+          mutt_buffer_printf(err, _("%s: Unknown type."), MuttVars[idx].name);
           return -1;
         }
 
@@ -4270,7 +4266,7 @@ int mutt_parse_rc_line(/* const */ char *line, struct Buffer *token, struct Buff
     }
     if (!Commands[i].name)
     {
-      snprintf(err->data, err->dsize, _("%s: unknown command"), NONULL(token->data));
+      mutt_buffer_printf(err, _("%s: unknown command"), NONULL(token->data));
       r = -1;
       break; /* Ignore the rest of the line */
     }

diff --git a/keymap.c b/keymap.c
index 095ff49049f071700f35f799a39998aee8c072b8..cb115cba021a59ff1efbe725ecfb9946e443e903 100644 (file)
--- a/keymap.c
+++ b/keymap.c
@@ -1004,7 +1004,7 @@ static char *parse_keymap(int *menu, struct Buffer *s, int maxmenus,
       menu[i] = mutt_map_get_value(p, Menus);
       if (menu[i] == -1)
       {
-        snprintf(err->data, err->dsize, _("%s: no such menu"), p);
+        mutt_buffer_printf(err, _("%s: no such menu"), p);
         goto error;
       }
       i++;
@@ -1045,8 +1045,8 @@ static int try_bind(char *key, int menu, char *func,
   }
   if (err)
   {
-    snprintf(err->data, err->dsize, _("Function '%s' not available for menu '%s'"),
-             func, mutt_map_get_name(menu, Menus));
+    mutt_buffer_printf(err, _("Function '%s' not available for menu '%s'"),
+                       func, mutt_map_get_name(menu, Menus));
   }
   return -1; /* Couldn't find an existing function with this name */
 }

diff --git a/mutt/regex.c b/mutt/regex.c
index 348059e0547ae87a8dc8bc00d96c0b0dbcbc7a02..61c1881562d97219be49fdb8aa4d5cd91a796bab 100644 (file)
--- a/mutt/regex.c
+++ b/mutt/regex.c
@@ -136,7 +136,7 @@ int mutt_regexlist_add(struct RegexList **rl, const char *str, int flags, struct
   rx = mutt_regex_compile(str, flags);
   if (!rx)
   {
-    snprintf(err->data, err->dsize, "Bad regex: %s\n", str);
+    mutt_buffer_printf(err, "Bad regex: %s\n", str);
     return -1;
   }
 
@@ -289,7 +289,7 @@ int mutt_replacelist_add(struct ReplaceList **rl, const char *pat,
   rx = mutt_regex_compile(pat, REG_ICASE);
   if (!rx)
   {
-    snprintf(err->data, err->dsize, _("Bad regex: %s"), pat);
+    mutt_buffer_printf(err, _("Bad regex: %s"), pat);
     return -1;
   }
 
@@ -349,9 +349,7 @@ int mutt_replacelist_add(struct ReplaceList **rl, const char *pat,
 
   if (t->nmatch > t->regex->regex->re_nsub)
   {
-    snprintf(err->data, err->dsize, "%s",
-             _("Not enough subexpressions for "
-               "template"));
+    mutt_buffer_printf(err, "%s", _("Not enough subexpressions for template"));
     mutt_replacelist_remove(rl, pat);
     return -1;
   }

diff --git a/mutt_lua.c b/mutt_lua.c
index 84a7920e423e8397266424b11ffad16ef4a4fe92..8b4b600cf580061dbabbc3374d5bd458c000dddd 100644 (file)
--- a/mutt_lua.c
+++ b/mutt_lua.c
@@ -407,7 +407,7 @@ int mutt_lua_parse(struct Buffer *tmp, struct Buffer *s, unsigned long data, str
   if (luaL_dostring(Lua, s->dptr))
   {
     mutt_debug(2, " * %s -> failure\n", s->dptr);
-    snprintf(err->data, err->dsize, "%s: %s", s->dptr, lua_tostring(Lua, -1));
+    mutt_buffer_printf(err, "%s: %s", s->dptr, lua_tostring(Lua, -1));
     /* pop error message from the stack */
     lua_pop(Lua, 1);
     return -1;
@@ -436,7 +436,7 @@ int mutt_lua_source_file(struct Buffer *tmp, struct Buffer *s,
 
   if (mutt_extract_token(tmp, s, 0) != 0)
   {
-    snprintf(err->data, err->dsize, _("source: error at %s"), s->dptr);
+    mutt_buffer_printf(err, _("source: error at %s"), s->dptr);
     return -1;
   }
   if (MoreArgs(s))

diff --git a/pattern.c b/pattern.c
index 973ae5d852ffa4544bd0d927b97b7c325a59caa9..40022cc0c37b9ecd5683cab8164174e1177964be 100644 (file)
--- a/pattern.c
+++ b/pattern.c
@@ -83,12 +83,12 @@ static bool eat_regex(struct Pattern *pat, struct Buffer *s, struct Buffer *err)
   char *pexpr = s->dptr;
   if (mutt_extract_token(&buf, s, MUTT_TOKEN_PATTERN | MUTT_TOKEN_COMMENT) != 0 || !buf.data)
   {
-    snprintf(err->data, err->dsize, _("Error in expression: %s"), pexpr);
+    mutt_buffer_printf(err, _("Error in expression: %s"), pexpr);
     return false;
   }
   if (!*buf.data)
   {
-    snprintf(err->data, err->dsize, "%s", _("Empty expression"));
+    mutt_buffer_printf(err, "%s", _("Empty expression"));
     return false;
   }
 
@@ -167,7 +167,7 @@ static const char *get_date(const char *s, struct tm *t, struct Buffer *err)
   t->tm_mday = strtol(s, &p, 10);
   if (t->tm_mday < 1 || t->tm_mday > 31)
   {
-    snprintf(err->data, err->dsize, _("Invalid day of month: %s"), s);
+    mutt_buffer_printf(err, _("Invalid day of month: %s"), s);
     return NULL;
   }
   if (*p != '/')
@@ -181,7 +181,7 @@ static const char *get_date(const char *s, struct tm *t, struct Buffer *err)
   t->tm_mon = strtol(p, &p, 10) - 1;
   if (t->tm_mon < 0 || t->tm_mon > 11)
   {
-    snprintf(err->data, err->dsize, _("Invalid month: %s"), p);
+    mutt_buffer_printf(err, _("Invalid month: %s"), p);
     return NULL;
   }
   if (*p != '/')
@@ -362,7 +362,7 @@ static const char *parse_date_range(const char *pc, struct tm *min, struct tm *m
   }
   if ((flag & MUTT_PDR_ERROR) && !(flag & MUTT_PDR_ABSOLUTE))
   { /* get_date has its own error message, don't overwrite it here */
-    snprintf(err->data, err->dsize, _("Invalid relative date: %s"), pc - 1);
+    mutt_buffer_printf(err, _("Invalid relative date: %s"), pc - 1);
   }
   return ((flag & MUTT_PDR_ERROR) ? NULL : pc);
 }
@@ -403,12 +403,12 @@ static bool eat_date(struct Pattern *pat, struct Buffer *s, struct Buffer *err)
   if (mutt_extract_token(&buffer, s, MUTT_TOKEN_COMMENT | MUTT_TOKEN_PATTERN) != 0 ||
       !buffer.data)
   {
-    snprintf(err->data, err->dsize, _("Error in expression: %s"), pexpr);
+    mutt_buffer_printf(err, _("Error in expression: %s"), pexpr);
     return false;
   }
   if (!*buffer.data)
   {
-    snprintf(err->data, err->dsize, "%s", _("Empty expression"));
+    mutt_buffer_printf(err, "%s", _("Empty expression"));
     return false;
   }
 
@@ -1132,7 +1132,7 @@ struct Pattern *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer
         {
           if (!curlist)
           {
-            snprintf(err->data, err->dsize, _("error in pattern at: %s"), ps.dptr);
+            mutt_buffer_printf(err, _("error in pattern at: %s"), ps.dptr);
             return NULL;
           }
           if (curlist->next)
@@ -1159,7 +1159,7 @@ struct Pattern *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer
       case '~':
         if (!*(ps.dptr + 1))
         {
-          snprintf(err->data, err->dsize, _("missing pattern: %s"), ps.dptr);
+          mutt_buffer_printf(err, _("missing pattern: %s"), ps.dptr);
           mutt_pattern_free(&curlist);
           return NULL;
         }
@@ -1178,7 +1178,7 @@ struct Pattern *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer
           p = find_matching_paren(ps.dptr + 1);
           if (*p != ')')
           {
-            snprintf(err->data, err->dsize, _("mismatched brackets: %s"), ps.dptr);
+            mutt_buffer_printf(err, _("mismatched brackets: %s"), ps.dptr);
             mutt_pattern_free(&curlist);
             return NULL;
           }
@@ -1240,13 +1240,13 @@ struct Pattern *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer
         entry = lookup_tag(*ps.dptr);
         if (!entry)
         {
-          snprintf(err->data, err->dsize, _("%c: invalid pattern modifier"), *ps.dptr);
+          mutt_buffer_printf(err, _("%c: invalid pattern modifier"), *ps.dptr);
           mutt_pattern_free(&curlist);
           return NULL;
         }
         if (entry->class && (flags & entry->class) == 0)
         {
-          snprintf(err->data, err->dsize, _("%c: not supported in this mode"), *ps.dptr);
+          mutt_buffer_printf(err, _("%c: not supported in this mode"), *ps.dptr);
           mutt_pattern_free(&curlist);
           return NULL;
         }
@@ -1259,7 +1259,7 @@ struct Pattern *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer
         {
           if (!*ps.dptr)
           {
-            snprintf(err->data, err->dsize, "%s", _("missing parameter"));
+            mutt_buffer_printf(err, "%s", _("missing parameter"));
             mutt_pattern_free(&curlist);
             return NULL;
           }
@@ -1275,7 +1275,7 @@ struct Pattern *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer
         p = find_matching_paren(ps.dptr + 1);
         if (*p != ')')
         {
-          snprintf(err->data, err->dsize, _("mismatched parenthesis: %s"), ps.dptr);
+          mutt_buffer_printf(err, _("mismatched parenthesis: %s"), ps.dptr);
           mutt_pattern_free(&curlist);
           return NULL;
         }
@@ -1303,7 +1303,7 @@ struct Pattern *mutt_pattern_comp(/* const */ char *s, int flags, struct Buffer
         ps.dptr = p + 1; /* restore location */
         break;
       default:
-        snprintf(err->data, err->dsize, _("error in pattern at: %s"), ps.dptr);
+        mutt_buffer_printf(err, _("error in pattern at: %s"), ps.dptr);
         mutt_pattern_free(&curlist);
         return NULL;
     }