# include "config.h"
#endif
+#include <lib-lib/mem.h>
+
#include "mutt.h"
#include "buffer.h"
#include "ascii.h"
/* get some $muttng_ values dynamically */
if (ascii_strcmp ("muttng_pwd", option->option) == 0) {
- val = mem_malloc (_POSIX_PATH_MAX);
+ val = p_new(char, _POSIX_PATH_MAX);
val = getcwd (val, _POSIX_PATH_MAX-1);
clean = 1;
} else if (ascii_strcmp ("muttng_folder_path", option->option) == 0 &&
snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (val));
if (clean)
- mem_free (&val);
+ p_delete(&val);
}
static int path_from_string (struct option_t* dst, const char* val,
return (0);
if (!val || !*val) {
- mem_free ((char**) dst->data);
+ p_delete((char**) dst->data);
return (1);
}
}
if (!((rx_t*) dst->data))
- *((rx_t**) dst->data) = mem_calloc (1, sizeof(rx_t));
+ *((rx_t**) dst->data) = p_new(rx_t, 1);
p = (rx_t*) dst->data;
s++;
}
- rx = mem_malloc (sizeof(regex_t));
+ rx = p_new(regex_t, 1);
if ((e = REGCOMP (rx, s, flags)) != 0) {
regerror (e, rx, errbuf, errlen);
regfree (rx);
- mem_free (&rx);
+ p_delete(&rx);
return (0);
}
if (p->rx) {
regfree (p->rx);
- mem_free (&p->rx);
+ p_delete(&p->rx);
}
str_replace (&p->pattern, val);
*dst = '\0';
return (0);
}
- tmp = mem_malloc (dstlen+1);
+ tmp = p_new(char, dstlen+1);
FuncTable[DTYPE (option->type)].opt_to_string (tmp, dstlen, option);
/* as we get things of type $var=value and don't want to bloat the
}
}
memcpy (dst, t, l+1);
- mem_free (&tmp);
+ p_delete(&tmp);
debug_print (1, ("stripped == '%s'\n", dst));
return (1);
/* for synonym warning reports: adds synonym to end of list */
static void syn_add (struct option_t* n, struct option_t* o) {
- syn_t* tmp = mem_malloc (sizeof(syn_t));
+ syn_t* tmp = p_new(syn_t, 1);
tmp->f = str_dup (CurRCFile);
tmp->l = CurRCLine;
tmp->n = n;
/* for synonym warning reports: free single item (for list_del()) */
static void syn_del (void** p) {
- mem_free(&(*(syn_t**) p)->f);
- mem_free(p);
+ p_delete(&(*(syn_t**) p)->f);
+ p_delete(p);
}
void toggle_quadoption (int opt)
}
if (!*list || last) {
- t = (LIST *) mem_calloc (1, sizeof(LIST));
+ t = p_new(LIST, 1);
t->data = str_dup (str);
if (last) {
last->next = t;
* the template, and leaving t pointed at the current item.
*/
t = last;
- mem_free(t->template);
+ p_delete(&t->template);
break;
}
if (!last->next)
if (spam->rx && !str_cmp (spam->rx->pattern, pat)) {
*list = spam->next;
rx_free (&spam->rx);
- mem_free(&spam->template);
- mem_free(&spam);
+ p_delete(&spam->template);
+ p_delete(&spam);
return 1;
}
if (!str_cmp (spam->rx->pattern, pat)) {
prev->next = spam->next;
rx_free (&spam->rx);
- mem_free(spam->template);
- mem_free(spam);
+ p_delete(&spam->template);
+ p_delete(&spam);
spam = prev->next;
++nremoved;
}
last = NULL;
while (p) {
if (ascii_strcasecmp (str, p->data) == 0) {
- mem_free (&p->data);
+ p_delete(&p->data);
if (last)
last->next = p->next;
else
(*l) = p->next;
- mem_free (&p);
+ p_delete(&p);
}
else {
last = p;
if (data == res) {
if (mutt_parse_rc_line (tmp->data, &token, err) == -1) {
mutt_error ("Error: %s", err->data);
- mem_free (&token.data);
+ p_delete(&token.data);
return (-1);
}
- mem_free (&token.data);
+ p_delete(&token.data);
}
return 0;
}
/* Add to the spam list. */
if (add_to_spam_list (&SpamList, buf->data, templ.data, err) != 0) {
- mem_free (&templ.data);
+ p_delete(&templ.data);
return -1;
}
- mem_free (&templ.data);
+ p_delete(&templ.data);
}
/* If not, try to remove from the nospam list. */
/* Find the last item in the list that data points to. */
lastp = NULL;
- debug_print (5, ("parse_attach_list: ldata = %08x, *ldata = %08x\n",
- (unsigned int)ldata, (unsigned int)*ldata));
+ debug_print (5, ("parse_attach_list: ldata = %p, *ldata = %p\n",
+ ldata, *ldata));
for (listp = *ldata; listp; listp = listp->next) {
a = (ATTACH_MATCH *)listp->data;
debug_print (5, ("parse_attach_list: skipping %s/%s\n", a->major, a->minor));
if (!buf->data || *buf->data == '\0')
continue;
- a = mem_malloc(sizeof(ATTACH_MATCH));
+ a = p_new(ATTACH_MATCH, 1);
/* some cheap hacks that I expect to remove */
if (!str_casecmp(buf->data, "any"))
}
len = str_len (a->minor);
- tmpminor = mem_malloc(len+3);
+ tmpminor = p_new(char, len + 3);
strcpy(&tmpminor[1], a->minor); /* __STRCPY_CHECKED__ */
tmpminor[0] = '^';
tmpminor[len+1] = '$';
a->major_int = mutt_check_mime_type(a->major);
regcomp(&a->minor_rx, tmpminor, REG_ICASE|REG_EXTENDED);
- mem_free (&tmpminor);
+ p_delete(&tmpminor);
debug_print (5, ("parse_attach_list: added %s/%s [%d]\n",
a->major, a->minor, a->major_int));
- listp = mem_malloc(sizeof(LIST));
+ listp = p_new(LIST, 1);
listp->data = (char *)a;
listp->next = NULL;
if (lastp) {
debug_print(5, ("parse_unattach_list: removed %s/%s [%d]\n",
a->major, a->minor, a->major_int));
regfree(&a->minor_rx);
- mem_free(&a->major);
+ p_delete(&a->major);
/* Relink backward */
if (lastp)
*ldata = lp->next;
newlp = lp->next;
- mem_free(&lp->data); /* same as a */
- mem_free(&lp);
+ p_delete(&lp->data); /* same as a */
+ p_delete(&lp);
lp = newlp;
continue;
}
}
while (MoreArgs (s));
- mem_free (&tmp);
+ p_delete(&tmp);
_attachments_clean();
return 0;
}
if (!tmp) {
/* create a new alias */
- tmp = (ALIAS *) mem_calloc (1, sizeof(ALIAS));
+ tmp = p_new(ALIAS, 1);
tmp->self = tmp;
tmp->name = str_dup (buf->data);
/* give the main addressbook code a chance */
/* see if there is already a field by this name */
if (ascii_strncasecmp (buf->data, tmp->data, keylen) == 0) {
/* replace the old value */
- mem_free (&tmp->data);
+ p_delete(&tmp->data);
tmp->data = buf->data;
memset (buf, 0, sizeof(BUFFER));
return 0;
static struct option_t* add_option (const char* name, const char* init,
short type, short dodup) {
- struct option_t* option = mem_calloc (1, sizeof(struct option_t));
+ struct option_t* option = p_new(struct option_t, 1);
debug_print (1, ("adding $%s\n", name));
struct option_t* ptr = (struct option_t*) p;
char* s = (char*) ptr->data;
debug_print (1, ("removing option '%s' from table\n", NONULL (ptr->option)));
- mem_free (&ptr->option);
- mem_free (&s);
- mem_free (&ptr->init);
- mem_free (&ptr);
+ p_delete(&ptr->option);
+ p_delete(&s);
+ p_delete(&ptr->init);
+ p_delete(&ptr);
}
static int init_expand (char** dst, struct option_t* src) {
BUFFER token, in;
size_t len = 0;
- mem_free (dst);
+ p_delete(dst);
if (DTYPE(src->type) == DT_STR ||
DTYPE(src->type) == DT_PATH) {
memset (&token, 0, sizeof(BUFFER));
memset (&in, 0, sizeof(BUFFER));
len = str_len (src->init) + 2;
- in.data = mem_malloc (len+1);
+ in.data = p_new(char, len + 1);
snprintf (in.data, len, "\"%s\"", src->init);
in.dptr = in.data;
in.dsize = len;
*dst = str_dup (token.data);
else
*dst = str_dup ("");
- mem_free (&in.data);
- mem_free (&token.data);
+ p_delete(&in.data);
+ p_delete(&token.data);
} else
*dst = str_dup ("");
} else
ptr->option, NONULL (init), errbuf);
exit (1);
}
- mem_free (&init);
+ p_delete(&init);
}
if (ptr->flags & R_INDEX)
rc = 0;
break;
}
- list_del (&list, (list_del_t*) _mem_free);
+ list_del (&list, (list_del_t*)xmemfree);
return (rc);
}
hash_delete (ConfigOptions, option->option,
option, del_option);
else
- mem_free ((void *) option->data);
+ p_delete((void **)&option->data);
break;
}
}
mutt_error (_("Error in %s, line %d: %s"), rcfile, line, err->data);
if (--rc < -MAXERRS) {
if (conv)
- mem_free (¤tline);
+ p_delete(¤tline);
break;
}
}
rc = -1;
}
if (conv)
- mem_free (¤tline);
+ p_delete(¤tline);
}
- mem_free (&token.data);
- mem_free (&linebuf);
+ p_delete(&token.data);
+ p_delete(&linebuf);
fclose (f);
if (pid != -1)
mutt_wait_filter (pid);
r = 0;
finish:
if (expn.destroy)
- mem_free (&expn.data);
+ p_delete(&expn.data);
return (r);
}
snprintf (command, sizeof(command), "set ?%s\n", p->data);
if (mutt_parse_rc_line (command, &token, &err) == -1) {
fprintf (stderr, "%s\n", err.data);
- mem_free (&token.data);
+ p_delete(&token.data);
return 1;
}
printf ("%s\n", err.data);
}
- mem_free (&token.data);
+ p_delete(&token.data);
return 0;
}
for (; p; p = p->next) {
if (mutt_parse_rc_line (p->data, &token, &err) != 0) {
fprintf (stderr, _("Error in command line: %s\n"), err.data);
- mem_free (&token.data);
+ p_delete(&token.data);
return (-1);
}
}
- mem_free (&token.data);
+ p_delete(&token.data);
return 0;
}
else
#endif /* DOMAIN */
if (*DOMAIN != '@') {
- Fqdn = mem_malloc (str_len (DOMAIN) + str_len (Hostname) + 2);
+ Fqdn = p_new(char, str_len(DOMAIN) + str_len(Hostname) + 2);
sprintf (Fqdn, "%s.%s", NONULL (Hostname), DOMAIN); /* __SPRINTF_CHECKED__ */
}
else
memset (&token, 0, sizeof(token));
parse_my_hdr (&token, &buf, 0, &err);
- mem_free (&token.data);
+ p_delete(&token.data);
}
if ((p = getenv ("EMAIL")) != NULL)
}
else {
strfcpy (buffer, Muttrc, sizeof(buffer));
- mem_free (&Muttrc);
+ p_delete(&Muttrc);
mutt_expand_path (buffer, sizeof(buffer));
Muttrc = str_dup (buffer);
}
- mem_free (&AliasFile);
+ p_delete(&AliasFile);
AliasFile = str_dup (NONULL (Muttrc));
/* Process the global rc file if it exists and the user hasn't explicity
projects / apps / madmutt.git / blobdiff