*/
void mutt_format_string (char *dest, size_t destlen,
- int min_width, int max_width,
+ unsigned int min_width, int max_width,
int right_justify, char m_pad_char,
const char *s, size_t n, int arboreal)
{
destlen -= k2;
}
}
- w = (int) destlen < min_width ? destlen : min_width;
+ w = destlen < min_width ? destlen : min_width;
if (w <= 0)
*p = '\0';
else if (right_justify) {
return 0;
}
-static void update_index (MUTTMENU * menu, CONTEXT * ctx, int check,
+static void update_index (MUTTMENU * menu, CONTEXT * ctx __attribute__ ((unused)), int check,
int oldcount, int index_hint)
{
/* store pointers to the newly added messages */
/* uncollapse threads with new mail */
if ((Sort & SORT_MASK) == SORT_THREADS) {
if (check == M_REOPENED) {
- THREAD *h, *j;
+ THREAD *h, *c;
Context->collapsed = 0;
for (h = Context->tree; h; h = h->next) {
- for (j = h; !j->message; j = j->child);
- mutt_uncollapse_thread (Context, j->message);
+ for (c = h; !c->message; c = c->child);
+ mutt_uncollapse_thread (Context, c->message);
}
mutt_set_virtual (Context);
}
char *cp; /* temporary variable. */
int index_hint; /* used to restore cursor position */
int do_buffy_notify = 1;
- int close = 0; /* did we OP_QUIT or OP_EXIT out of this menu? */
+ int closed = 0; /* did we OP_QUIT or OP_EXIT out of this menu? */
int attach_msg = option (OPTATTACHMSG);
menu = mutt_new_menu ();
menu->menu = MENU_MAIN;
menu->offset = 1;
menu->pagelen = LINES - 3;
- menu->make_entry = index_make_entry;
+ menu->make_entry = (void *) index_make_entry;
menu->color = index_color;
menu->current = ci_first_message ();
menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_MAIN,
mutt_message (_("No limit pattern is in effect."));
else {
- char buf[STRING];
+ char buffer[STRING];
/* i18n: ask for a limit to apply */
- snprintf (buf, sizeof (buf), _("Limit: %s"), Context->pattern);
- mutt_message ("%s", buf);
+ snprintf (buffer, sizeof (buffer), _("Limit: %s"), Context->pattern);
+ mutt_message ("%s", buffer);
}
break;
&& menu->current <
Context->vcount) ? CURHDR->index : -1;
if (op == OP_TOGGLE_READ) {
- char buf[LONG_STRING];
+ char buffer[LONG_STRING];
if (!Context->pattern
|| strncmp (Context->pattern, "!~R!~D~s", 8) != 0) {
- snprintf (buf, sizeof (buf), "!~R!~D~s%s",
+ snprintf (buffer, sizeof (buffer), "!~R!~D~s%s",
Context->pattern ? Context->pattern : ".*");
set_option (OPTHIDEREAD);
}
case OP_QUIT:
- close = op;
+ closed = op;
if (attach_msg) {
done = 1;
break;
CHECK_READONLY;
{
int oldvcount = Context->vcount;
- int oldcount = Context->msgcount;
+ oldcount = Context->msgcount;
int dcount = 0;
int check;
case OP_EXIT:
- close = op;
+ closed = op;
if (menu->menu == MENU_MAIN && attach_msg) {
done = 1;
break;
}
mutt_menuDestroy (&menu);
- return (close);
+ return (closed);
}
void mutt_set_header_color (CONTEXT * ctx, HEADER * curhdr)
#endif
static int dotlock_deference_symlink (char *, size_t, const char *);
-static int dotlock_prepare (char *, size_t, const char *, int fd);
+static int dotlock_prepare (char *, ssize_t, const char *, int fd);
static int dotlock_check_stats (struct stat *, struct stat *);
static int dotlock_dispatch (const char *, int fd);
static int dotlock_dispatch (const char *f, int fd)
{
- char realpath[_POSIX_PATH_MAX];
+ char frealpath[_POSIX_PATH_MAX];
/* If dotlock_prepare () succeeds [return value == 0],
* realpath contains the basename of f, and we have
* lengthy comment below.
*/
- if (dotlock_prepare (realpath, sizeof (realpath), f, fd) != 0)
+ if (dotlock_prepare (frealpath, sizeof (frealpath), f, fd) != 0)
return DL_EX_ERROR;
/* Actually perform the locking operation. */
if (DotlockFlags & DL_FL_TRY)
return dotlock_try ();
else if (DotlockFlags & DL_FL_UNLOCK)
- return dotlock_unlock (realpath);
+ return dotlock_unlock (frealpath);
else if (DotlockFlags & DL_FL_UNLINK)
- return dotlock_unlink (realpath);
+ return dotlock_unlink (frealpath);
else /* lock */
- return dotlock_lock (realpath);
+ return dotlock_lock (frealpath);
}
return 0;
}
-static int dotlock_prepare (char *bn, size_t l, const char *f, int _fd)
+static int dotlock_prepare (char *bn, ssize_t l, const char *f, int _fd)
{
struct stat fsb, lsb;
- char realpath[_POSIX_PATH_MAX];
- char *basename, *dirname;
+ char frealpath[_POSIX_PATH_MAX];
+ char *fbasename, *dirname;
char *p;
int fd;
int r;
- if (dotlock_deference_symlink (realpath, sizeof (realpath), f) == -1)
+ if (dotlock_deference_symlink (frealpath, sizeof (frealpath), f) == -1)
return -1;
- if ((p = strrchr (realpath, '/'))) {
+ if ((p = strrchr (frealpath, '/'))) {
*p = '\0';
- basename = p + 1;
- dirname = realpath;
+ fbasename = p + 1;
+ dirname = frealpath;
}
else {
- basename = realpath;
- dirname = ".";
+ fbasename = frealpath;
+ dirname = m_strdup(".");
}
- if (m_strlen(basename) + 1 > l)
+ if (m_strlen(fbasename) + 1 > l)
return -1;
- m_strcpy(bn, l, basename);
+ m_strcpy(bn, l, fbasename);
if (chdir (dirname) == -1)
return -1;
if (_fd != -1)
fd = _fd;
- else if ((fd = open (basename, O_RDONLY)) == -1)
+ else if ((fd = open (fbasename, O_RDONLY)) == -1)
return -1;
r = fstat (fd, &fsb);
if (r == -1)
return -1;
- if (lstat (basename, &lsb) == -1)
+ if (lstat (fbasename, &lsb) == -1)
return -1;
if (dotlock_check_stats (&fsb, &lsb) == -1)
*/
static void
-dotlock_expand_link (char *newpath, const char *path, const char *link)
+dotlock_expand_link (char *newpath, const char *path, const char *flink)
{
const char *lb = NULL;
size_t len;
/* link is full path */
- if (*link == '/') {
- m_strcpy(newpath, _POSIX_PATH_MAX, link);
+ if (*flink == '/') {
+ m_strcpy(newpath, _POSIX_PATH_MAX, flink);
return;
}
if ((lb = strrchr (path, '/')) == NULL) {
/* no path in link */
- m_strcpy(newpath, _POSIX_PATH_MAX, link);
+ m_strcpy(newpath, _POSIX_PATH_MAX, flink);
return;
}
len = lb - path + 1;
memcpy (newpath, path, len);
- m_strcpy(newpath + len, _POSIX_PATH_MAX - len, link);
+ m_strcpy(newpath + len, _POSIX_PATH_MAX - len, flink);
}
static int dotlock_deference_symlink (char *d, size_t l, const char *path)
{
struct stat sb;
- char realpath[_POSIX_PATH_MAX];
+ char frealpath[_POSIX_PATH_MAX];
const char *pathptr = path;
int count = 0;
linkfile[len] = '\0';
dotlock_expand_link (linkpath, pathptr, linkfile);
- m_strcpy(realpath, sizeof(realpath), linkpath);
- pathptr = realpath;
+ m_strcpy(frealpath, sizeof(frealpath), linkpath);
+ pathptr = frealpath;
}
else
break;
#define HARDMAXATTEMPTS 10
-static int dotlock_lock (const char *realpath)
+static int dotlock_lock (const char *frealpath)
{
char lockfile[_POSIX_PATH_MAX + LONG_STRING];
char nfslockfile[_POSIX_PATH_MAX + LONG_STRING];
time_t t;
snprintf (nfslockfile, sizeof (nfslockfile), "%s.%s.%d",
- realpath, Hostname, (int) getpid ());
- snprintf (lockfile, sizeof (lockfile), "%s.lock", realpath);
+ frealpath, Hostname, (int) getpid ());
+ snprintf (lockfile, sizeof (lockfile), "%s.lock", frealpath);
BEGIN_PRIVILEGED ();
*
*/
-static int dotlock_unlock (const char *realpath)
+static int dotlock_unlock (const char *frealpath)
{
char lockfile[_POSIX_PATH_MAX + LONG_STRING];
int i;
- snprintf (lockfile, sizeof (lockfile), "%s.lock", realpath);
+ snprintf (lockfile, sizeof (lockfile), "%s.lock", frealpath);
BEGIN_PRIVILEGED ();
i = unlink (lockfile);
/* remove an empty file */
-static int dotlock_unlink (const char *realpath)
+static int dotlock_unlink (const char *frealpath)
{
struct stat lsb;
int i = -1;
- if (dotlock_lock (realpath) != DL_EX_OK)
+ if (dotlock_lock (frealpath) != DL_EX_OK)
return DL_EX_ERROR;
- if ((i = lstat (realpath, &lsb)) == 0 && lsb.st_size == 0)
- unlink (realpath);
+ if ((i = lstat (frealpath, &lsb)) == 0 && lsb.st_size == 0)
+ unlink (frealpath);
- dotlock_unlock (realpath);
+ dotlock_unlock (frealpath);
return (i == 0) ? DL_EX_OK : DL_EX_ERROR;
}
char **buf = NULL;
int bufmax = 0, buflen = 0;
char tmp[LONG_STRING];
- int abort = 0;
+ int aborted = 0;
int done = 0;
int i;
char *p;
be_barf_file (*p ? p : path, buf, buflen);
break;
case 'x':
- abort = 1;
+ aborted = 1;
done = 1;
break;
default:
tmp[0] = 0;
}
- if (!abort)
+ if (!aborted)
be_barf_file (path, buf, buflen);
be_free_memory (buf, buflen);
- return (abort ? -1 : 0);
+ return (aborted ? -1 : 0);
}
return s - s0;
}
-static void my_wcstombs (char *dest, size_t dlen, const wchar_t * src,
+static void my_wcstombs (char *dest, ssize_t dlen, const wchar_t * src,
size_t slen)
{
mbstate_t st;
char *buf;
const char *ib;
char *ob;
- size_t ibl, obl;
+ ssize_t ibl, obl;
buf = p_new(char, n + 1);
ib = uid, ibl = d - uid + 1, ob = buf, obl = n;
case 6: /* timestamp (1998-02-28) */
{
char tstr[11];
- struct tm time;
+ struct tm st_time;
debug_print (2, ("time stamp: %s\n", p));
if (!p)
break;
- time.tm_sec = 0;
- time.tm_min = 0;
- time.tm_hour = 12;
+ st_time.tm_sec = 0;
+ st_time.tm_min = 0;
+ st_time.tm_hour = 12;
m_strcpy(tstr, sizeof(tstr), p);
tstr[4] = '\0';
- time.tm_year = atoi (tstr) - 1900;
+ st_time.tm_year = atoi (tstr) - 1900;
tstr[7] = '\0';
- time.tm_mon = (atoi (tstr + 5)) - 1;
- time.tm_mday = atoi (tstr + 8);
- k->gen_time = mutt_mktime (&time, 0);
+ st_time.tm_mon = (atoi (tstr + 5)) - 1;
+ st_time.tm_mday = atoi (tstr + 8);
+ k->gen_time = mutt_mktime (&st_time, 0);
break;
}
case 7: /* valid for n days */
keep = 0;
}
else if (ascii_strncasecmp ("attach:", cur->data, 7) == 0) {
- BODY *body;
+ BODY *bbody;
BODY *parts;
char *q;
else
m_strcpy(path, sizeof(path), p);
mutt_expand_path (path, sizeof (path));
- if ((body = mutt_make_file_attach (path))) {
- body->description = m_strdup(q);
+ if ((bbody = mutt_make_file_attach (path))) {
+ bbody->description = m_strdup(q);
for (parts = msg->content; parts->next; parts = parts->next);
- parts->next = body;
+ parts->next = bbody;
}
else {
mutt_pretty_mailbox (path);
#define ERROR_STOP 0
typedef struct hook {
- int type; /* hook type */
+ unsigned long type; /* hook type */
rx_t rx; /* regular expression */
char *command; /* filename, command or pattern to execute */
pattern_t *pattern; /* used for fcc,save,send-hook */
static HOOK *Hooks = NULL;
-static int current_hook_type = 0;
+static unsigned long current_hook_type = 0;
-int mutt_parse_hook (BUFFER * buf, BUFFER * s, unsigned long data,
+int mutt_parse_hook (BUFFER * buf __attribute__ ((unused)), BUFFER * s, unsigned long data,
BUFFER * err)
{
HOOK *ptr;
}
/* Deletes all hooks of type ``type'', or all defined hooks if ``type'' is 0 */
-static void delete_hooks (int type)
+static void delete_hooks (unsigned long type)
{
HOOK *h;
HOOK *prev;
}
}
-int mutt_parse_unhook (BUFFER * buf, BUFFER * s, unsigned long data,
+int mutt_parse_unhook (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
while (MoreArgs (s)) {
delete_hooks (0);
}
else {
- int type = mutt_get_hook_type (buf->data);
+ unsigned long type = mutt_get_hook_type (buf->data);
if (!type) {
snprintf (err->data, err->dsize,
current_hook_type = 0;
}
-char *mutt_find_hook (int type, const char *pat)
+char *mutt_find_hook (unsigned long type, const char *pat)
{
HOOK *tmp = Hooks;
return (NULL);
}
-void mutt_message_hook (CONTEXT * ctx, HEADER * hdr, int type)
+void mutt_message_hook (CONTEXT * ctx, HEADER * hdr, unsigned long type)
{
BUFFER err, token;
HOOK *hook;
}
static int
-mutt_addr_hook (char *path, size_t pathlen, int type, CONTEXT * ctx,
+mutt_addr_hook (char *path, size_t pathlen, unsigned long type, CONTEXT * ctx,
HEADER * hdr)
{
HOOK *hook;
}
static int bool_from_string (struct option_t* dst, const char* val,
- char* errbuf, size_t errlen) {
+ char* errbuf __attribute__ ((unused)),
+ size_t errlen __attribute__ ((unused))) {
int flag = -1;
if (!dst)
} else if (ascii_strcmp ("muttng_folder_name", option->option) == 0 &&
CurrentFolder && *CurrentFolder) {
- size_t Maildirlength = m_strlen(Maildir);
+ ssize_t Maildirlength = m_strlen(Maildir);
/*
* if name starts with $folder, just strip it to keep hierarchy
val = t+1;
/* default: use as-is */
else
- val = CurrentFolder;
+ val = (char *) CurrentFolder;
} else
- val = option->init;
+ val = (char *) option->init;
snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (val));
if (clean)
}
static int path_from_string (struct option_t* dst, const char* val,
- char* errbuf, size_t errlen) {
+ char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
char path[_POSIX_PATH_MAX];
if (!dst)
}
static int user_from_string (struct option_t* dst, const char* val,
- char* errbuf, size_t errlen) {
+ char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
/* if dst == NULL, we may get here in case the user did unset it,
* see parse_set() where item is free()'d before coming here; so
* just silently ignore it */
}
static int quad_from_string (struct option_t* dst, const char* val,
- char* errbuf, size_t errlen) {
+ char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
int flag = -1;
if (!dst)
}
static int magic_from_string (struct option_t* dst, const char* val,
- char* errbuf, size_t errlen) {
+ char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
int flag = -1;
if (!dst || !val || !*val)
}
static int addr_from_string (struct option_t* dst, const char* val,
- char* errbuf, size_t errlen) {
+ char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
if (!dst)
return (0);
address_delete ((address_t**) dst->data);
static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
BUFFER * err)
{
- int i, j, res = 0;
+ int i, j;
+ unsigned long res = 0;
BUFFER token;
struct option_t* option = NULL;
return 0;
}
-static int parse_unignore (BUFFER * buf, BUFFER * s, unsigned long data,
- BUFFER * err)
+static int parse_unignore (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER * err __attribute__ ((unused)))
{
do {
mutt_extract_token (buf, s, 0);
return 0;
}
-static int parse_ignore (BUFFER * buf, BUFFER * s, unsigned long data,
- BUFFER * err)
+static int parse_ignore (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER * err __attribute__ ((unused)))
{
do {
mutt_extract_token (buf, s, 0);
return 0;
}
-static int parse_list (BUFFER * buf, BUFFER * s, unsigned long data,
- BUFFER * err)
+static int parse_list (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER * err __attribute__ ((unused)))
{
do {
mutt_extract_token (buf, s, 0);
}
}
-static int parse_alternates (BUFFER * buf, BUFFER * s, unsigned long data,
- BUFFER * err)
+static int parse_alternates (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER * err __attribute__ ((unused)))
{
_alternates_clean ();
do {
return 0;
}
-static int parse_unalternates (BUFFER * buf, BUFFER * s, unsigned long data,
- BUFFER * err)
+static int parse_unalternates (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER * err __attribute__ ((unused)))
{
_alternates_clean ();
do {
}
static int parse_unlist (BUFFER * buf, BUFFER * s, unsigned long data,
- BUFFER * err)
+ BUFFER * err __attribute__ ((unused)))
{
do {
mutt_extract_token (buf, s, 0);
return 0;
}
-static int parse_lists (BUFFER * buf, BUFFER * s, unsigned long data,
+static int parse_lists (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
do {
}
static int parse_attach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
- BUFFER *err) {
+ BUFFER *err __attribute__ ((unused))) {
ATTACH_MATCH *a;
LIST *listp, *lastp;
char *p;
return 0;
}
-static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata, BUFFER *err) {
+static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
+ BUFFER *err __attribute__ ((unused))) {
ATTACH_MATCH *a;
LIST *lp, *lastp, *newlp;
char *tmp;
*minor = '\0';
++minor;
} else {
- minor = "unknown";
+ minor = m_strdup("unknown");
}
major = mutt_check_mime_type(tmp);
return 0;
}
-static int parse_attachments (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) {
+static int parse_attachments (BUFFER *buf, BUFFER *s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER *err) {
char op, *category;
LIST **listp;
return parse_attach_list(buf, s, listp, err);
}
-static int parse_unattachments (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) {
+static int parse_unattachments (BUFFER *buf, BUFFER *s, unsigned long data __attribute__ ((unused)), BUFFER *err) {
char op, *p;
LIST **listp;
return parse_unattach_list(buf, s, listp, err);
}
-static int parse_unlists (BUFFER * buf, BUFFER * s, unsigned long data,
- BUFFER * err)
+static int parse_unlists (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER * err __attribute__ ((unused)))
{
do {
mutt_extract_token (buf, s, 0);
return 0;
}
-static int parse_subscribe (BUFFER * buf, BUFFER * s, unsigned long data,
+static int parse_subscribe (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
do {
return 0;
}
-static int parse_unsubscribe (BUFFER * buf, BUFFER * s, unsigned long data,
- BUFFER * err)
+static int parse_unsubscribe (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER * err __attribute__ ((unused)))
{
do {
mutt_extract_token (buf, s, 0);
return 0;
}
-static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data,
- BUFFER * err)
+static int parse_unalias (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER * err __attribute__ ((unused)))
{
ALIAS *tmp, *last = NULL;
return 0;
}
-static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data,
+static int parse_alias (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
ALIAS *tmp = Aliases;
}
static int
-parse_unmy_hdr (BUFFER * buf, BUFFER * s, unsigned long data, BUFFER * err)
+parse_unmy_hdr (BUFFER * buf, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
+ BUFFER * err __attribute__ ((unused)))
{
LIST *last = NULL;
LIST *tmp = UserHeader;
return 0;
}
-static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data,
+static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
LIST *tmp;
}
/* if additional data more == 1, we want to resolve synonyms */
-static void mutt_set_default(const char *name, void* p, unsigned long more)
+static void mutt_set_default(const char *name __attribute__ ((unused)), void* p, unsigned long more)
{
char buf[LONG_STRING];
struct option_t *ptr = p;
}
/* if additional data more == 1, we want to resolve synonyms */
-static void mutt_restore_default (const char* name, void* p,
- unsigned long more) {
+static void mutt_restore_default (const char* name __attribute__ ((unused)),
+ void* p, unsigned long more) {
char errbuf[STRING];
struct option_t* ptr = (struct option_t*) p;
char* init = NULL;
}
/* check whether value for $dsn_return would be valid */
-static int check_dsn_return (const char* option, unsigned long p,
+static int check_dsn_return (const char* option __attribute__ ((unused)), unsigned long p,
char* errbuf, size_t errlen) {
char* val = (char*) p;
if (val && *val && m_strncmp(val, "hdrs", 4) != 0 &&
static int check_dsn_notify (const char* option, unsigned long p,
char* errbuf, size_t errlen) {
list2_t* list = NULL;
- int i = 0, rc = 1;
+ size_t i = 0;
+ int rc = 1;
char* val = (char*) p;
if (!val || !*val)
}
#endif
-static int check_history (const char* option, unsigned long p,
+static int check_history (const char* option __attribute__ ((unused)), unsigned long p,
char* errbuf, size_t errlen) {
if (!check_num ("history", p, errbuf, errlen))
return (0);
#undef MAXERRS
-static int parse_source (BUFFER * tmp, BUFFER * s, unsigned long data,
+static int parse_source (BUFFER * tmp, BUFFER * s,
+ unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
char path[_POSIX_PATH_MAX];
else
return 0;
- for (s = tmp, d = tmp2; *s && (d - tmp2) < sizeof(tmp2) - 2;) {
+ for (s = tmp, d = tmp2; *s && (d - tmp2) < ssizeof(tmp2) - 2;) {
if (*s == '\\' || *s == '"')
*d++ = '\\';
*d++ = *s++;
struct utsname utsname;
const char *p;
char buffer[STRING], error[STRING];
- int i, default_rc = 0, need_pause = 0;
+ int default_rc = 0, need_pause = 0;
+ unsigned int i;
BUFFER err;
p_clear(&err, 1);
/* warn about synonym variables */
if (!list_empty(Synonyms)) {
- int i = 0;
+ i = 0;
fprintf (stderr, _("Warning: the following synonym variables were found:\n"));
for (i = 0; i < Synonyms->length; i++) {
struct option_t* newopt = NULL, *oldopt = NULL;
}
/* callback for hash_map() to put all non-synonym vars into list */
-static void opt_sel_full (const char* key, void* data,
+static void opt_sel_full (const char* key __attribute__ ((unused)),
+ void* data,
unsigned long more) {
list2_t** l = (list2_t**) more;
struct option_t* option = (struct option_t*) data;
}
/* callback for hash_map() to put all changed non-synonym vars into list */
-static void opt_sel_diff (const char* key, void* data,
+static void opt_sel_diff (const char* key __attribute__ ((unused)),
+ void* data,
unsigned long more) {
list2_t** l = (list2_t**) more;
struct option_t* option = (struct option_t*) data;
/* dump out the value of all the variables we have */
int mutt_dump_variables (int full) {
- int i = 0;
+ size_t i = 0;
char outbuf[STRING];
list2_t* tmp = NULL;
struct option_t* option = NULL;
char *mutt_iconv_hook (const char *);
char *mutt_expand_path (char *, size_t);
char *_mutt_expand_path (char *, size_t, int);
-char *mutt_find_hook (int, const char *);
+char *mutt_find_hook (unsigned long, const char *);
char *mutt_gecos_name (char *, size_t, struct passwd *);
char *mutt_gen_msgid (void);
char *mutt_get_body_charset (char *, size_t, BODY *);
void mutt_expand_link (char *, const char *, const char *);
void mutt_fix_reply_recipients (ENVELOPE * env);
void mutt_folder_hook (char *);
-void mutt_format_string (char *, size_t, int, int, int, char, const char *,
+void mutt_format_string (char *, size_t, unsigned int, int, int, char, const char *,
size_t, int);
void mutt_format_s (char *, size_t, const char *, const char *);
void mutt_format_s_tree (char *, size_t, const char *, const char *);
#define mutt_select_file(A,B,C) _mutt_select_file(A,B,C,NULL,NULL)
void _mutt_select_file (char *, size_t, int, char ***, int *);
-void mutt_message_hook (CONTEXT *, HEADER *, int);
+void mutt_message_hook (CONTEXT *, HEADER *, unsigned long);
void _mutt_set_flag (CONTEXT *, HEADER *, int, int, int);
#define mutt_set_flag(a,b,c,d) _mutt_set_flag(a,b,c,d,1)