cppcheck: match prototypes to their functions

diff --git a/attach.h b/attach.h
index f9017a076b6bf7c620bc0b170ec3cba58f30060a..5f5063f598c7df5db51b737ee151e76fa0b5b8d0 100644 (file)
--- a/attach.h
+++ b/attach.h
@@ -78,7 +78,7 @@ int mutt_view_attachment(FILE *fp, struct Body *a, int flag, struct Header *hdr,
 
 int mutt_tag_attach(struct Menu *menu, int n, int m);
 int mutt_attach_display_loop(struct Menu *menu, int op, struct Header *hdr,
-                             struct AttachCtx *acvtx, bool recv);
+                             struct AttachCtx *actx, bool recv);
 
 void mutt_save_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag,
                                struct Body *top, struct Header *hdr, struct Menu *menu);

diff --git a/copy.c b/copy.c
index 7b87703ae22023b0fbe3bfc9bafd8b84e8f34038..331b7a97a6df6908033a5ccd8907f5ccd035efd1 100644 (file)
--- a/copy.c
+++ b/copy.c
@@ -47,7 +47,7 @@
 #include "mutt_notmuch.h"
 #endif
 
-static int address_header_decode(char **str);
+static int address_header_decode(char **h);
 static int copy_delete_attach(struct Body *b, FILE *fpin, FILE *fpout, char *date);
 
 /**

diff --git a/imap/imap_private.h b/imap/imap_private.h
index 7473698a8dd6a9bd8310b942291233cee2b580c4..554f4e19468b20df253851deaa6dd44ecfa276d3 100644 (file)
--- a/imap/imap_private.h
+++ b/imap/imap_private.h
@@ -288,12 +288,12 @@ bool imap_has_flag(struct ListHead *flag_list, const char *flag);
 int imap_authenticate(struct ImapData *idata);
 
 /* command.c */
-int imap_cmd_start(struct ImapData *idata, const char *cmd);
+int imap_cmd_start(struct ImapData *idata, const char *cmdstr);
 int imap_cmd_step(struct ImapData *idata);
 void imap_cmd_finish(struct ImapData *idata);
 bool imap_code(const char *s);
 const char *imap_cmd_trailer(struct ImapData *idata);
-int imap_exec(struct ImapData *idata, const char *cmd, int flags);
+int imap_exec(struct ImapData *idata, const char *cmdstr, int flags);
 int imap_cmd_idle(struct ImapData *idata);
 
 /* message.c */
@@ -328,7 +328,7 @@ char *imap_get_qualifier(char *buf);
 int imap_mxcmp(const char *mx1, const char *mx2);
 char *imap_next_word(char *s);
 void imap_qualify_path(char *dest, size_t len, struct ImapMbox *mx, char *path);
-void imap_quote_string(char *dest, size_t slen, const char *src);
+void imap_quote_string(char *dest, size_t dlen, const char *src);
 void imap_unquote_string(char *s);
 void imap_munge_mbox_name(struct ImapData *idata, char *dest, size_t dlen, const char *src);
 void imap_unmunge_mbox_name(struct ImapData *idata, char *s);

diff --git a/init.c b/init.c
index ca00edac24f9d8f73c91cab0b5c06c05b96e8bba..57e7d50d08b0b8bf14be4f165baa6bab0862c2c3 100644 (file)
--- a/init.c
+++ b/init.c
@@ -750,7 +750,7 @@ static void add_to_stailq(struct ListHead *head, const char *str)
  *
  * If the 'finish' command is found, we should stop reading the current file.
  */
-static int finish_source(struct Buffer *tmp, struct Buffer *s,
+static int finish_source(struct Buffer *buf, struct Buffer *s,
                          unsigned long data, struct Buffer *err)
 {
   if (MoreArgs(s))
@@ -781,22 +781,22 @@ static int finish_source(struct Buffer *tmp, struct Buffer *s,
  * e.g.
  *      ifndef imap finish
  */
-static int parse_ifdef(struct Buffer *tmp, struct Buffer *s, unsigned long data,
+static int parse_ifdef(struct Buffer *buf, struct Buffer *s, unsigned long data,
                        struct Buffer *err)
 {
   bool res = 0;
   struct Buffer token;
 
   memset(&token, 0, sizeof(token));
-  mutt_extract_token(tmp, s, 0);
+  mutt_extract_token(buf, s, 0);
 
   /* is the item defined as a variable? */
-  res = (mutt_option_index(tmp->data) != -1);
+  res = (mutt_option_index(buf->data) != -1);
 
   /* is the item a compiled-in feature? */
   if (!res)
   {
-    res = feature_enabled(tmp->data);
+    res = feature_enabled(buf->data);
   }
 
   /* or a function? */
@@ -810,7 +810,7 @@ static int parse_ifdef(struct Buffer *tmp, struct Buffer *s, unsigned long data,
 
       for (int j = 0; b[j].name; j++)
       {
-        if (mutt_str_strcmp(tmp->data, b[j].name) == 0)
+        if (mutt_str_strcmp(buf->data, b[j].name) == 0)
         {
           res = true;
           break;
@@ -824,7 +824,7 @@ static int parse_ifdef(struct Buffer *tmp, struct Buffer *s, unsigned long data,
   {
     for (int i = 0; Commands[i].name; i++)
     {
-      if (mutt_str_strcmp(tmp->data, Commands[i].name) == 0)
+      if (mutt_str_strcmp(buf->data, Commands[i].name) == 0)
       {
         res = true;
         break;
@@ -835,7 +835,7 @@ static int parse_ifdef(struct Buffer *tmp, struct Buffer *s, unsigned long data,
   /* or a my_ var? */
   if (!res)
   {
-    res = !!myvar_get(tmp->data);
+    res = !!myvar_get(buf->data);
   }
 
   if (!MoreArgs(s))
@@ -843,12 +843,12 @@ static int parse_ifdef(struct Buffer *tmp, struct Buffer *s, unsigned long data,
     snprintf(err->data, err->dsize, _("%s: too few arguments"), (data ? "ifndef" : "ifdef"));
     return -1;
   }
-  mutt_extract_token(tmp, s, MUTT_TOKEN_SPACE);
+  mutt_extract_token(buf, s, MUTT_TOKEN_SPACE);
 
   /* ifdef KNOWN_SYMBOL or ifndef UNKNOWN_SYMBOL */
   if ((res && (data == 0)) || (!res && (data == 1)))
   {
-    int rc = mutt_parse_rc_line(tmp->data, &token, err);
+    int rc = mutt_parse_rc_line(buf->data, &token, err);
     if (rc == -1)
     {
       mutt_error("Error: %s", err->data);
@@ -2067,7 +2067,7 @@ static bool valid_show_multipart_alternative(const char *val)
           (mutt_str_strcmp(val, "info") == 0) || !val || (*val == 0));
 }
 
-static int parse_setenv(struct Buffer *tmp, struct Buffer *s,
+static int parse_setenv(struct Buffer *buf, struct Buffer *s,
                         unsigned long data, struct Buffer *err)
 {
   char **envp = mutt_envlist_getlist();
@@ -2088,8 +2088,8 @@ static int parse_setenv(struct Buffer *tmp, struct Buffer *s,
   }
 
   /* get variable name */
-  mutt_extract_token(tmp, s, MUTT_TOKEN_EQUAL);
-  int len = strlen(tmp->data);
+  mutt_extract_token(buf, s, MUTT_TOKEN_EQUAL);
+  int len = strlen(buf->data);
 
   if (query)
   {
@@ -2097,7 +2097,7 @@ static int parse_setenv(struct Buffer *tmp, struct Buffer *s,
     while (envp && *envp)
     {
       /* This will display all matches for "^QUERY" */
-      if (mutt_str_strncmp(tmp->data, *envp, len) == 0)
+      if (mutt_str_strncmp(buf->data, *envp, len) == 0)
       {
         if (!found)
         {
@@ -2115,13 +2115,13 @@ static int parse_setenv(struct Buffer *tmp, struct Buffer *s,
       return 0;
     }
 
-    snprintf(err->data, err->dsize, _("%s is unset"), tmp->data);
+    snprintf(err->data, err->dsize, _("%s is unset"), buf->data);
     return -1;
   }
 
   if (unset)
   {
-    if (mutt_envlist_unset(tmp->data))
+    if (mutt_envlist_unset(buf->data))
       return 0;
     return -1;
   }
@@ -2140,15 +2140,15 @@ static int parse_setenv(struct Buffer *tmp, struct Buffer *s,
     return -1;
   }
 
-  char *name = mutt_str_strdup(tmp->data);
-  mutt_extract_token(tmp, s, 0);
-  mutt_envlist_set(name, tmp->data, true);
+  char *name = mutt_str_strdup(buf->data);
+  mutt_extract_token(buf, s, 0);
+  mutt_envlist_set(name, buf->data, true);
   FREE(&name);
 
   return 0;
 }
 
-static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
+static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
                      struct Buffer *err)
 {
   int r = 0;
@@ -2185,14 +2185,14 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
     }
 
     /* get the variable name */
-    mutt_extract_token(tmp, s, MUTT_TOKEN_EQUAL);
+    mutt_extract_token(buf, s, MUTT_TOKEN_EQUAL);
 
-    if (mutt_str_strncmp("my_", tmp->data, 3) == 0)
-      myvar = tmp->data;
-    else if ((idx = mutt_option_index(tmp->data)) == -1 &&
-             !(reset && (mutt_str_strcmp("all", tmp->data) == 0)))
+    if (mutt_str_strncmp("my_", buf->data, 3) == 0)
+      myvar = buf->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"), tmp->data);
+      snprintf(err->data, err->dsize, _("%s: unknown variable"), buf->data);
       return -1;
     }
     SKIPWS(s->dptr);
@@ -2211,7 +2211,7 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
         return -1;
       }
 
-      if (mutt_str_strcmp("all", tmp->data) == 0)
+      if (mutt_str_strcmp("all", buf->data) == 0)
       {
         if (CurrentMenu == MENU_PAGER)
         {
@@ -2247,10 +2247,10 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
         }
 
         s->dptr++;
-        mutt_extract_token(tmp, s, 0);
-        if (mutt_str_strcasecmp("yes", tmp->data) == 0)
+        mutt_extract_token(buf, s, 0);
+        if (mutt_str_strcasecmp("yes", buf->data) == 0)
           unset = inv = 0;
-        else if (mutt_str_strcasecmp("no", tmp->data) == 0)
+        else if (mutt_str_strcasecmp("no", buf->data) == 0)
           unset = 1;
         else
         {
@@ -2263,7 +2263,7 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
       {
         snprintf(err->data, err->dsize,
                  *(bool *) MuttVars[idx].var ? _("%s is set") : _("%s is unset"),
-                 tmp->data);
+                 buf->data);
         return 0;
       }
 
@@ -2346,23 +2346,23 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
 
         if (myvar)
         {
-          /* myvar is a pointer to tmp and will be lost on extract_token */
+          /* myvar is a pointer to buf and will be lost on extract_token */
           myvar = mutt_str_strdup(myvar);
           myvar_del(myvar);
         }
 
-        mutt_extract_token(tmp, s, 0);
+        mutt_extract_token(buf, s, 0);
 
         if (myvar)
         {
-          myvar_set(myvar, tmp->data);
+          myvar_set(myvar, buf->data);
           FREE(&myvar);
           myvar = "don't resort";
         }
         else if ((idx >= 0) && (DTYPE(MuttVars[idx].type) == DT_PATH))
         {
           char scratch[_POSIX_PATH_MAX];
-          mutt_str_strfcpy(scratch, tmp->data, sizeof(scratch));
+          mutt_str_strfcpy(scratch, buf->data, sizeof(scratch));
           mutt_expand_path(scratch, sizeof(scratch));
           if (mutt_str_strcmp(MuttVars[idx].name, "debug_file") == 0)
           {
@@ -2379,39 +2379,39 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
         else if ((idx >= 0) && (DTYPE(MuttVars[idx].type) == DT_STRING))
         {
           if ((strstr(MuttVars[idx].name, "charset") &&
-               check_charset(&MuttVars[idx], tmp->data) < 0) |
+               check_charset(&MuttVars[idx], buf->data) < 0) |
               /* $charset can't be empty, others can */
-              ((strcmp(MuttVars[idx].name, "charset") == 0) && !*tmp->data))
+              ((strcmp(MuttVars[idx].name, "charset") == 0) && !*buf->data))
           {
             snprintf(err->data, err->dsize, _("Invalid value for option %s: \"%s\""),
-                     MuttVars[idx].name, tmp->data);
+                     MuttVars[idx].name, buf->data);
             return -1;
           }
 
           FREE((void *) MuttVars[idx].var);
-          *((char **) MuttVars[idx].var) = mutt_str_strdup(tmp->data);
+          *((char **) MuttVars[idx].var) = mutt_str_strdup(buf->data);
           if (mutt_str_strcmp(MuttVars[idx].name, "charset") == 0)
             mutt_ch_set_charset(Charset);
 
           if ((mutt_str_strcmp(MuttVars[idx].name,
                                "show_multipart_alternative") == 0) &&
-              !valid_show_multipart_alternative(tmp->data))
+              !valid_show_multipart_alternative(buf->data))
           {
             snprintf(err->data, err->dsize, _("Invalid value for name %s: \"%s\""),
-                     MuttVars[idx].name, tmp->data);
+                     MuttVars[idx].name, buf->data);
             return -1;
           }
         }
         else if (DTYPE(MuttVars[idx].type) == DT_MBTABLE)
         {
           free_mbtable((struct MbTable **) MuttVars[idx].var);
-          *((struct MbTable **) MuttVars[idx].var) = parse_mbtable(tmp->data);
+          *((struct MbTable **) MuttVars[idx].var) = parse_mbtable(buf->data);
         }
         else
         {
           mutt_addr_free((struct Address **) MuttVars[idx].var);
           *((struct Address **) MuttVars[idx].var) =
-              mutt_addr_parse_list(NULL, tmp->data);
+              mutt_addr_parse_list(NULL, buf->data);
         }
       }
     }
@@ -2438,9 +2438,9 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
       s->dptr++;
 
       /* copy the value of the string */
-      mutt_extract_token(tmp, s, 0);
+      mutt_extract_token(buf, s, 0);
 
-      if (parse_regex(idx, tmp, err))
+      if (parse_regex(idx, buf, err))
       {
         /* $reply_regex and $alternates require special treatment */
         if (Context && Context->msgcount &&
@@ -2492,10 +2492,10 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
       s->dptr++;
 
       /* copy the value of the string */
-      mutt_extract_token(tmp, s, 0);
-      if (mx_set_magic(tmp->data))
+      mutt_extract_token(buf, s, 0);
+      if (mx_set_magic(buf->data))
       {
-        snprintf(err->data, err->dsize, _("%s: invalid mailbox type"), tmp->data);
+        snprintf(err->data, err->dsize, _("%s: invalid mailbox type"), buf->data);
         r = -1;
         break;
       }
@@ -2521,12 +2521,12 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
       CHECK_PAGER;
       s->dptr++;
 
-      mutt_extract_token(tmp, s, 0);
-      rc = mutt_str_atos(tmp->data, (short *) &val);
+      mutt_extract_token(buf, s, 0);
+      rc = mutt_str_atos(buf->data, (short *) &val);
 
-      if (rc < 0 || !*tmp->data)
+      if (rc < 0 || !*buf->data)
       {
-        snprintf(err->data, err->dsize, _("%s: invalid value (%s)"), tmp->data,
+        snprintf(err->data, err->dsize, _("%s: invalid value (%s)"), buf->data,
                  rc == -1 ? _("format error") : _("number overflow"));
         r = -1;
         break;
@@ -2579,18 +2579,18 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
       if (*s->dptr == '=')
       {
         s->dptr++;
-        mutt_extract_token(tmp, s, 0);
-        if (mutt_str_strcasecmp("yes", tmp->data) == 0)
+        mutt_extract_token(buf, s, 0);
+        if (mutt_str_strcasecmp("yes", buf->data) == 0)
           *(unsigned char *) MuttVars[idx].var = MUTT_YES;
-        else if (mutt_str_strcasecmp("no", tmp->data) == 0)
+        else if (mutt_str_strcasecmp("no", buf->data) == 0)
           *(unsigned char *) MuttVars[idx].var = MUTT_NO;
-        else if (mutt_str_strcasecmp("ask-yes", tmp->data) == 0)
+        else if (mutt_str_strcasecmp("ask-yes", buf->data) == 0)
           *(unsigned char *) MuttVars[idx].var = MUTT_ASKYES;
-        else if (mutt_str_strcasecmp("ask-no", tmp->data) == 0)
+        else if (mutt_str_strcasecmp("ask-no", buf->data) == 0)
           *(unsigned char *) MuttVars[idx].var = MUTT_ASKNO;
         else
         {
-          snprintf(err->data, err->dsize, _("%s: invalid value"), tmp->data);
+          snprintf(err->data, err->dsize, _("%s: invalid value"), buf->data);
           r = -1;
           break;
         }
@@ -2651,9 +2651,9 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
       }
       CHECK_PAGER;
       s->dptr++;
-      mutt_extract_token(tmp, s, 0);
+      mutt_extract_token(buf, s, 0);
 
-      if (parse_sort((short *) MuttVars[idx].var, tmp->data, map, err) == -1)
+      if (parse_sort((short *) MuttVars[idx].var, buf->data, map, err) == -1)
       {
         r = -1;
         break;
@@ -2673,15 +2673,15 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
       s->dptr++;
 
       /* copy the value of the string */
-      mutt_extract_token(tmp, s, 0);
-      if (mutt_hcache_is_valid_backend(tmp->data))
+      mutt_extract_token(buf, s, 0);
+      if (mutt_hcache_is_valid_backend(buf->data))
       {
         FREE((void *) MuttVars[idx].var);
-        *(char **) (MuttVars[idx].var) = mutt_str_strdup(tmp->data);
+        *(char **) (MuttVars[idx].var) = mutt_str_strdup(buf->data);
       }
       else
       {
-        snprintf(err->data, err->dsize, _("%s: invalid backend"), tmp->data);
+        snprintf(err->data, err->dsize, _("%s: invalid backend"), buf->data);
         r = -1;
         break;
       }
@@ -2874,19 +2874,19 @@ static int source_rc(const char *rcfile_path, struct Buffer *err)
 
 #undef MAXERRS
 
-static int parse_source(struct Buffer *tmp, struct Buffer *token,
+static int parse_source(struct Buffer *buf, struct Buffer *s,
                         unsigned long data, struct Buffer *err)
 {
   char path[_POSIX_PATH_MAX];
 
   do
   {
-    if (mutt_extract_token(tmp, token, 0) != 0)
+    if (mutt_extract_token(buf, s, 0) != 0)
     {
-      snprintf(err->data, err->dsize, _("source: error at %s"), token->dptr);
+      snprintf(err->data, err->dsize, _("source: error at %s"), s->dptr);
       return -1;
     }
-    mutt_str_strfcpy(path, tmp->data, sizeof(path));
+    mutt_str_strfcpy(path, buf->data, sizeof(path));
     mutt_expand_path(path, sizeof(path));
 
     if (source_rc(path, err) < 0)
@@ -2895,7 +2895,7 @@ static int parse_source(struct Buffer *tmp, struct Buffer *token,
       return -1;
     }
 
-  } while (MoreArgs(token));
+  } while (MoreArgs(s));
 
   return 0;
 }
@@ -4006,10 +4006,10 @@ bail:
   return -1;
 }
 
-static int parse_tag_transforms(struct Buffer *b, struct Buffer *s,
+static int parse_tag_transforms(struct Buffer *buf, struct Buffer *s,
                                 unsigned long data, struct Buffer *err)
 {
-  if (!b || !s)
+  if (!buf || !s)
     return -1;
 
   char *tmp = NULL;
@@ -4018,14 +4018,14 @@ static int parse_tag_transforms(struct Buffer *b, struct Buffer *s,
   {
     char *tag = NULL, *transform = NULL;
 
-    mutt_extract_token(b, s, 0);
-    if (b->data && *b->data)
-      tag = mutt_str_strdup(b->data);
+    mutt_extract_token(buf, s, 0);
+    if (buf->data && *buf->data)
+      tag = mutt_str_strdup(buf->data);
     else
       continue;
 
-    mutt_extract_token(b, s, 0);
-    transform = mutt_str_strdup(b->data);
+    mutt_extract_token(buf, s, 0);
+    transform = mutt_str_strdup(buf->data);
 
     /* avoid duplicates */
     tmp = mutt_hash_find(TagTransforms, tag);
@@ -4042,10 +4042,10 @@ static int parse_tag_transforms(struct Buffer *b, struct Buffer *s,
   return 0;
 }
 
-static int parse_tag_formats(struct Buffer *b, struct Buffer *s,
+static int parse_tag_formats(struct Buffer *buf, struct Buffer *s,
                              unsigned long data, struct Buffer *err)
 {
-  if (!b || !s)
+  if (!buf || !s)
     return -1;
 
   char *tmp = NULL;
@@ -4054,14 +4054,14 @@ static int parse_tag_formats(struct Buffer *b, struct Buffer *s,
   {
     char *tag = NULL, *format = NULL;
 
-    mutt_extract_token(b, s, 0);
-    if (b->data && *b->data)
-      tag = mutt_str_strdup(b->data);
+    mutt_extract_token(buf, s, 0);
+    if (buf->data && *buf->data)
+      tag = mutt_str_strdup(buf->data);
     else
       continue;
 
-    mutt_extract_token(b, s, 0);
-    format = mutt_str_strdup(b->data);
+    mutt_extract_token(buf, s, 0);
+    format = mutt_str_strdup(buf->data);
 
     /* avoid duplicates */
     tmp = mutt_hash_find(TagFormats, format);

diff --git a/mutt/hash.h b/mutt/hash.h
index df6d4c4faf2fa979ca85fe337c1be1124263eb4d..efd0d1e84e2b0ad9f8a2dc314c319b70d8e3ed59 100644 (file)
--- a/mutt/hash.h
+++ b/mutt/hash.h
@@ -75,7 +75,7 @@ struct HashElem *mutt_hash_find_bucket(const struct Hash *table, const char *str
 void *           mutt_hash_find(const struct Hash *table, const char *strkey);
 struct HashElem *mutt_hash_find_elem(const struct Hash *table, const char *strkey);
 struct HashElem *mutt_hash_insert(struct Hash *table, const char *strkey, void *data);
-void             mutt_hash_set_destructor(struct Hash *hash, hash_destructor fn, intptr_t fn_data);
+void             mutt_hash_set_destructor(struct Hash *table, hash_destructor fn, intptr_t fn_data);
 struct HashElem *mutt_hash_typed_insert(struct Hash *table, const char *strkey, int type, void *data);
 struct Hash *    mutt_hash_int_create(int nelem, int flags);
 void             mutt_hash_int_delete(struct Hash *table, unsigned int intkey, const void *data);

diff --git a/mutt/md5.c b/mutt/md5.c
index 7444ec2edadd07f301d6d7e7ea6b9cec66fd4340..791e234581ef5744296f3fd80f42ec2d328f62e8 100644 (file)
--- a/mutt/md5.c
+++ b/mutt/md5.c
@@ -305,9 +305,9 @@ void *mutt_md5_finish_ctx(struct Md5Ctx *ctx, void *resbuf)
  * @param s      String to hash
  * @param resbuf Buffer for result
  */
-void *mutt_md5(const char *s, void *resbuf)
+void *mutt_md5(const char *string, void *resbuf)
 {
-  return mutt_md5_bytes(s, strlen(s), resbuf);
+  return mutt_md5_bytes(string, strlen(string), resbuf);
 }
 
 /**
@@ -340,9 +340,9 @@ void *mutt_md5_bytes(const void *buffer, size_t len, void *resbuf)
  * @param s    String to process
  * @param ctx  MD5 context
  */
-void mutt_md5_process(const char *s, struct Md5Ctx *ctx)
+void mutt_md5_process(const char *string, struct Md5Ctx *ctx)
 {
-  mutt_md5_process_bytes(s, strlen(s), ctx);
+  mutt_md5_process_bytes(string, strlen(string), ctx);
 }
 
 /**

diff --git a/mutt/string2.h b/mutt/string2.h
index ae1d17aa0f097677954e25238d779b22feff73b6..45226e8b7a6141ca47c581d6010a4e5058a32711 100644 (file)
--- a/mutt/string2.h
+++ b/mutt/string2.h
@@ -62,7 +62,7 @@
 #define terminate_buffer(a, b) terminate_string(a, b, sizeof(a) - 1)
 
 void        mutt_str_adjust(char **p);
-void        mutt_str_append_item(char **p, const char *item, int sep);
+void        mutt_str_append_item(char **str, const char *item, int sep);
 int         mutt_str_atoi(const char *str, int *dst);
 int         mutt_str_atol(const char *str, long *dst);
 int         mutt_str_atos(const char *str, short *dst);

diff --git a/mutt_account.h b/mutt_account.h
index 3c6bd0d59931a547bd2daa9e049ca0b0d86d71d3..786d2f9c421178bf38d14f9ddf26022426d0f74e 100644 (file)
--- a/mutt_account.h
+++ b/mutt_account.h
@@ -47,7 +47,7 @@ enum AccountType
 #define MUTT_ACCT_PASS  (1 << 3)
 #define MUTT_ACCT_SSL   (1 << 4)
 
-int mutt_account_match(const struct Account *a1, const struct Account *m2);
+int mutt_account_match(const struct Account *a1, const struct Account *a2);
 int mutt_account_fromurl(struct Account *account, struct Url *url);
 void mutt_account_tourl(struct Account *account, struct Url *url);
 int mutt_account_getuser(struct Account *account);

diff --git a/mutt_menu.h b/mutt_menu.h
index fa72d49bb056b39d741ec9263dcda1def2e1b205..3b33a66fa21c686d097d24054a44983c7d7eba79 100644 (file)
--- a/mutt_menu.h
+++ b/mutt_menu.h
@@ -134,7 +134,7 @@ void         mutt_menu_set_redraw_full(int menu_type);
 void         mutt_menu_set_redraw(int menu_type, int redraw);
 
 /* used in both the index and pager index to make an entry. */
-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);
 int index_color(int index_no);
 
 #endif /* _MUTT_MENU_H */

diff --git a/nntp.h b/nntp.h
index d4d95263f612116a69e46ee8c7d966e82ae8391f..53d2d40ffbba6cedf38e47fc425d43d8323c2322 100644 (file)
--- a/nntp.h
+++ b/nntp.h
@@ -174,10 +174,9 @@ void nntp_newsrc_close(struct NntpServer *nserv);
 void nntp_buffy(char *buf, size_t len);
 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 *if_str, const char *else_str,
-                            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 *CurrentNewsSrv;
 

diff --git a/protos.h b/protos.h
index 4ede8ca420e7ff8a334f4ad8ed71724d3b1b4d9b..3f755779b30255434fd612544566ef33d82396b4 100644 (file)
--- a/protos.h
+++ b/protos.h
@@ -54,8 +54,8 @@ struct stat;
 struct passwd;
 
 #define mutt_make_string(A, B, C, D, E) mutt_make_string_flags(A, B, C, D, E, 0)
-void mutt_make_string_flags(char *dest, size_t destlen, const char *s, struct Context *ctx,
-                       struct Header *hdr, enum FormatFlag flags);
+void mutt_make_string_flags(char *buf, size_t buflen, const char *s,
+                            struct Context *ctx, struct Header *hdr, enum FormatFlag flags);
 
 /**
  * struct HdrFormatInfo - Data passed to index_format_str()
@@ -78,7 +78,7 @@ enum XdgType
 
 int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, int 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);
 
 void mutt_free_opts(void);
@@ -171,8 +171,8 @@ 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 *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_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);
 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);

diff --git a/url.h b/url.h
index 640021e962e2c391654cfc043297d06cb27c3f7e..981b0fbe8871011cd90d8c855d29cc0cf478fa82 100644 (file)
--- a/url.h
+++ b/url.h
@@ -85,6 +85,6 @@ void url_free(struct Url *u);
 int url_tostring(struct Url *u, char *dest, size_t len, int flags);
 int url_parse_mailto(struct Envelope *e, char **body, const char *src);
 int url_pct_decode(char *s);
-void url_pct_encode(char *dest, size_t len, const char *src);
+void url_pct_encode(char *dst, size_t l, const char *src);
 
 #endif /* _MUTT_URL_H */