X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=e153736027dabf272942d859b9880ac497348f2b;hp=94e1707e2031260d4edbd6d83bd1972a8ec72e9a;hb=a83b73d30397ee8e5c33668bcc0f1712ac74ff29;hpb=c88f8ebd5e7542e4ee2ac2c24dfd5f358dbb4235

diff --git a/init.c b/init.c
index 94e1707..e153736 100644
--- a/init.c
+++ b/init.c
@@ -10,71 +10,59 @@
  * please see the file GPL in the top level source directory.
  */
 
-#if HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include <lib-lib/lib-lib.h>
+#include <sys/utsname.h>
 
-#include <lib-lib/mem.h>
-#include <lib-lib/str.h>
-#include <lib-lib/file.h>
-#include <lib-lib/ascii.h>
-#include <lib-lib/macros.h>
-#include <lib-lib/buffer.h>
-#include <lib-lib/mapping.h>
+#include <lib-lua/lib-lua.h>
+#include <lib-sys/unix.h>
+#include <lib-sys/mutt_ssl.h>
+#include <lib-ui/curses.h>
+#include <lib-ui/history.h>
+#include <lib-mx/mx.h>
+#include <lib-crypt/crypt.h>
 
 #include "mutt.h"
-#include "mutt_curses.h"
-#include "history.h"
 #include "keymap.h"
-#include "mbyte.h"
 #include "charset.h"
 #include "thread.h"
-#include "mutt_crypt.h"
 #include "mutt_idna.h"
 
-#if defined(USE_SSL) || defined(USE_GNUTLS)
-#include "mutt_ssl.h"
-#endif
-
 #if defined (USE_LIBESMTP) && (defined (USE_SSL) || defined (USE_GNUTLS))
 #include "mutt_libesmtp.h"
 #endif
 
-#include "mx.h"
+#include "alias.h"
 #include "init.h"
 
-#include "lib/rx.h"
-#include "lib/list.h"
-#include "lib/debug.h"
-
-#include <ctype.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/utsname.h>
-#include <errno.h>
-#include <sys/wait.h>
-
 /*
  * prototypes
  */
 static const struct mapping_t* get_sortmap (struct option_t* option);
 static int parse_sort (struct option_t* dst, const char *s,
                        const struct mapping_t *map,
-                       char* errbuf, size_t errlen);
+                       char* errbuf, ssize_t errlen);
 
 static HASH *ConfigOptions = NULL;
 
 /* for synonym warning reports: synonym found during parsing */
-typedef struct {
+typedef struct syn_t {
+  struct syn_t *next;
   char* f;              /* file */
   int l;                /* line */
   struct option_t* n;   /* new */
   struct option_t* o;   /* old */
 } syn_t;
 
+DO_INIT(syn_t, syn);
+static void syn_wipe(syn_t *syn) {
+    p_delete(&syn->f);
+}
+DO_NEW(syn_t, syn);
+DO_DELETE(syn_t, syn);
+DO_SLIST(syn_t, syn, syn_delete);
+
 /* for synonym warning reports: list of synonyms found */
-static list2_t* Synonyms;
+static syn_t *Synonyms = NULL;
 /* for synonym warning reports: current rc file */
 static const char* CurRCFile = NULL;
 /* for synonym warning reports: current rc line */
@@ -82,22 +70,18 @@ static int CurRCLine = 0;
 
 /* prototypes for checking for special vars */
 static int check_dsn_return (const char* option, unsigned long val,
-                             char* errbuf, size_t errlen);
+                             char* errbuf, ssize_t errlen);
 static int check_dsn_notify (const char* option, unsigned long val,
-                             char* errbuf, size_t errlen);
+                             char* errbuf, ssize_t errlen);
 static int check_history    (const char* option, unsigned long val,
-                             char* errbuf, size_t errlen);
+                             char* errbuf, ssize_t errlen);
 /* this checks that numbers are >= 0 */
 static int check_num        (const char* option, unsigned long val,
-                             char* errbuf, size_t errlen);
-#ifdef DEBUG
-static int check_debug      (const char* option, unsigned long val,
-                             char* errbuf, size_t errlen);
-#endif
+                             char* errbuf, ssize_t errlen);
 
 /* use this to check only */
 static int check_special (const char* option, unsigned long val,
-                          char* errbuf, size_t errlen);
+                          char* errbuf, ssize_t errlen);
 
 /* variable <-> sanity check function mappings
  * when changing these, make sure the proper _from_string handler
@@ -106,7 +90,7 @@ static int check_special (const char* option, unsigned long val,
 static struct {
   const char* name;
   int (*check) (const char* option, unsigned long val,
-                char* errbuf, size_t errlen);
+                char* errbuf, ssize_t errlen);
 } SpecialVars[] = {
   { "dsn_notify",               check_dsn_notify },
   { "dsn_return",               check_dsn_return },
@@ -115,52 +99,45 @@ static struct {
 #endif
   { "history",                  check_history },
   { "pager_index_lines",        check_num },
-#ifdef DEBUG
-  { "debug_level",              check_debug },
-#endif
   /* last */
   { NULL,         NULL }
 };
 
 /* protos for config type handles: convert value to string */
-static void bool_to_string  (char* dst, size_t dstlen, struct option_t* option);
-static void num_to_string   (char* dst, size_t dstlen, struct option_t* option);
-static void str_to_string   (char* dst, size_t dstlen, struct option_t* option);
-static void quad_to_string  (char* dst, size_t dstlen, struct option_t* option);
-static void sort_to_string  (char* dst, size_t dstlen, struct option_t* option);
-static void rx_to_string    (char* dst, size_t dstlen, struct option_t* option);
-static void magic_to_string (char* dst, size_t dstlen, struct option_t* option);
-static void addr_to_string  (char* dst, size_t dstlen, struct option_t* option);
-static void user_to_string  (char* dst, size_t dstlen, struct option_t* option);
-static void sys_to_string   (char* dst, size_t dstlen, struct option_t* option);
+static void bool_to_string  (char* dst, ssize_t dstlen, struct option_t* option);
+static void num_to_string   (char* dst, ssize_t dstlen, struct option_t* option);
+static void str_to_string   (char* dst, ssize_t dstlen, struct option_t* option);
+static void quad_to_string  (char* dst, ssize_t dstlen, struct option_t* option);
+static void sort_to_string  (char* dst, ssize_t dstlen, struct option_t* option);
+static void rx_to_string    (char* dst, ssize_t dstlen, struct option_t* option);
+static void magic_to_string (char* dst, ssize_t dstlen, struct option_t* option);
+static void addr_to_string  (char* dst, ssize_t dstlen, struct option_t* option);
 
 /* protos for config type handles: convert to value from string */
 static int bool_from_string  (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
+                              char* errbuf, ssize_t errlen);
 static int num_from_string   (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
+                              char* errbuf, ssize_t errlen);
 static int str_from_string   (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
+                              char* errbuf, ssize_t errlen);
 static int path_from_string  (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
+                              char* errbuf, ssize_t errlen);
 static int quad_from_string  (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
+                              char* errbuf, ssize_t errlen);
 static int sort_from_string  (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
+                              char* errbuf, ssize_t errlen);
 static int rx_from_string    (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
+                              char* errbuf, ssize_t errlen);
 static int magic_from_string (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
+                              char* errbuf, ssize_t errlen);
 static int addr_from_string  (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
-static int user_from_string  (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
+                              char* errbuf, ssize_t errlen);
 
 static struct {
   unsigned short type;
-  void (*opt_to_string) (char* dst, size_t dstlen, struct option_t* option);
-  int (*opt_from_string) (struct option_t* dst, const char* val,
-                          char* errbuf, size_t errlen);
+  void (*opt_tostr) (char* dst, ssize_t dstlen, struct option_t* option);
+  int (*opt_fromstr) (struct option_t* dst, const char* val,
+                          char* errbuf, ssize_t errlen);
 } FuncTable[] = {
   { 0,          NULL,             NULL }, /* there's no DT_ type with 0 */
   { DT_BOOL,    bool_to_string,   bool_from_string },
@@ -175,18 +152,17 @@ static struct {
    * but must define it as DT_ is used for indexing */
   { DT_SYN,     NULL,             NULL },
   { DT_ADDR,    addr_to_string,   addr_from_string },
-  { DT_USER,    user_to_string,   user_from_string },
-  { DT_SYS,     sys_to_string,    NULL },
 };
 
-static void bool_to_string (char* dst, size_t dstlen,
+static void bool_to_string (char* dst, ssize_t dstlen,
                             struct option_t* option) {
   snprintf (dst, dstlen, "%s=%s", option->option,
             option (option->data) ? "yes" : "no");
 }
 
 static int bool_from_string (struct option_t* dst, const char* val,
-                             char* errbuf, size_t errlen) {
+                             char* errbuf __attribute__ ((unused)),
+                             ssize_t errlen __attribute__ ((unused))) {
   int flag = -1;
 
   if (!dst)
@@ -205,7 +181,7 @@ static int bool_from_string (struct option_t* dst, const char* val,
   return (1);
 }
 
-static void num_to_string (char* dst, size_t dstlen,
+static void num_to_string (char* dst, ssize_t dstlen,
                            struct option_t* option) {
   /* XXX puke */
   const char* fmt = (m_strcmp(option->option, "umask") == 0) ?
@@ -215,7 +191,7 @@ static void num_to_string (char* dst, size_t dstlen,
 }
 
 static int num_from_string (struct option_t* dst, const char* val,
-                            char* errbuf, size_t errlen) {
+                            char* errbuf, ssize_t errlen) {
   int num = 0, old = 0;
   char* t = NULL;
 
@@ -224,7 +200,7 @@ static int num_from_string (struct option_t* dst, const char* val,
 
   num = strtol (val, &t, 0);
 
-  if (!*val || *t || (short) num != num) {
+  if (m_strisempty(val) || *t || (short) num != num) {
     if (errbuf) {
       snprintf (errbuf, errlen, _("'%s' is invalid for $%s"),
                 val, dst->option);
@@ -245,69 +221,20 @@ static int num_from_string (struct option_t* dst, const char* val,
   return (1);
 }
 
-static void str_to_string (char* dst, size_t dstlen,
+static void str_to_string (char* dst, ssize_t dstlen,
                            struct option_t* option) {
   snprintf (dst, dstlen, "%s=\"%s\"", option->option,
             NONULL (*((char**) option->data)));
 }
 
-static void user_to_string (char* dst, size_t dstlen,
-                            struct option_t* option) {
-  snprintf (dst, dstlen, "%s=\"%s\"", option->option,
-            NONULL (((char*) option->data)));
-}
-
-static void sys_to_string (char* dst, size_t dstlen,
-                           struct option_t* option) {
-  char *val = NULL, *t = NULL;
-  int clean = 0;
-
-  /* get some $muttng_ values dynamically */
-  if (ascii_strcmp ("muttng_pwd", option->option) == 0) {
-    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 &&
-             CurrentFolder && *CurrentFolder) {
-    val = CurrentFolder;
-  } else if (ascii_strcmp ("muttng_folder_name", option->option) == 0 &&
-             CurrentFolder && *CurrentFolder) {
-
-    size_t Maildirlength = m_strlen(Maildir);
-
-    /*
-     * if name starts with $folder, just strip it to keep hierarchy
-     * $folder=imap://host, path=imap://host/inbox/b -> inbox/b
-     */
-    if (Maildirlength > 0 && m_strncmp(CurrentFolder, Maildir,
-                                      Maildirlength) == 0 &&
-       m_strlen(CurrentFolder) > Maildirlength) {
-     val = CurrentFolder + Maildirlength;
-     if (Maildir[strlen(Maildir)-1]!='/')
-       val += 1;
-     /* if not $folder, just use everything after last / */
-    } else if ((t = strrchr (CurrentFolder, '/')) != NULL)
-      val = t+1;
-    /* default: use as-is */
-    else
-      val = CurrentFolder;
-
-  } else
-    val = option->init;
-
-  snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (val));
-  if (clean)
-    p_delete(&val);
-}
-
 static int path_from_string (struct option_t* dst, const char* val,
-                             char* errbuf, size_t errlen) {
+                             char* errbuf __attribute__ ((unused)), ssize_t errlen __attribute__ ((unused))) {
   char path[_POSIX_PATH_MAX];
 
   if (!dst)
     return (0);
 
-  if (!val || !*val) {
+  if (m_strisempty(val)) {
     p_delete((char**) dst->data);
     return (1);
   }
@@ -315,41 +242,23 @@ static int path_from_string (struct option_t* dst, const char* val,
   path[0] = '\0';
   m_strcpy(path, sizeof(path), val);
   mutt_expand_path (path, sizeof(path));
-  str_replace ((char **) dst->data, path);
+  m_strreplace((char **) dst->data, path);
   return (1);
 }
 
 static int str_from_string (struct option_t* dst, const char* val,
-                            char* errbuf, size_t errlen) {
+                            char* errbuf, ssize_t errlen) {
   if (!dst)
     return (0);
 
   if (!check_special (dst->option, (unsigned long) val, errbuf, errlen))
     return (0);
 
-  str_replace ((char**) dst->data, val);
-  return (1);
-}
-
-static int user_from_string (struct option_t* dst, const char* val,
-                             char* errbuf, size_t errlen) {
-  /* 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 */
-  if (!dst)
-    return (1);
-  if (m_strlen((char*) dst->data) == 0)
-    dst->data = (unsigned long) m_strdup(val);
-  else {
-    char* s = (char*) dst->data;
-    str_replace (&s, val);
-  }
-  if (m_strlen(dst->init) == 0)
-    dst->init = m_strdup((char*) dst->data);
+  m_strreplace((char**) dst->data, val);
   return (1);
 }
 
-static void quad_to_string (char* dst, size_t dstlen,
+static void quad_to_string (char* dst, ssize_t dstlen,
                             struct option_t* option) {
   const char *vals[] = { "no", "yes", "ask-no", "ask-yes" };
   snprintf (dst, dstlen, "%s=%s", option->option,
@@ -357,7 +266,7 @@ static void quad_to_string (char* dst, size_t dstlen,
 }
 
 static int quad_from_string (struct option_t* dst, const char* val,
-                             char* errbuf, size_t errlen) {
+                             char* errbuf __attribute__ ((unused)), ssize_t errlen __attribute__ ((unused))) {
   int flag = -1;
 
   if (!dst)
@@ -378,7 +287,7 @@ static int quad_from_string (struct option_t* dst, const char* val,
   return (1);
 }
 
-static void sort_to_string (char* dst, size_t dstlen,
+static void sort_to_string (char* dst, ssize_t dstlen,
                             struct option_t* option) {
   const struct mapping_t *map = get_sortmap (option);
   const char *p = NULL;
@@ -398,7 +307,7 @@ static void sort_to_string (char* dst, size_t dstlen,
 }
 
 static int sort_from_string (struct option_t* dst, const char* val,
-                             char* errbuf, size_t errlen) {
+                             char* errbuf, ssize_t errlen) {
   const struct mapping_t *map = NULL;
   if (!(map = get_sortmap (dst))) {
     if (errbuf)
@@ -411,7 +320,7 @@ static int sort_from_string (struct option_t* dst, const char* val,
   return (1);
 }
 
-static void rx_to_string (char* dst, size_t dstlen,
+static void rx_to_string (char* dst, ssize_t dstlen,
                           struct option_t* option) {
   rx_t* p = (rx_t*) option->data;
   snprintf (dst, dstlen, "%s=\"%s\"", option->option,
@@ -419,7 +328,7 @@ static void rx_to_string (char* dst, size_t dstlen,
 }
 
 static int rx_from_string (struct option_t* dst, const char* val,
-                           char* errbuf, size_t errlen) {
+                           char* errbuf, ssize_t errlen) {
   rx_t* p = NULL;
   regex_t* rx = NULL;
   int flags = 0, e = 0, not = 0;
@@ -441,7 +350,7 @@ static int rx_from_string (struct option_t* dst, const char* val,
   p = (rx_t*) dst->data;
 
   /* something to do? */
-  if (!val || !*val || (p->pattern && m_strcmp(p->pattern, val) == 0))
+  if (m_strisempty(val) || (p->pattern && m_strcmp(p->pattern, val) == 0))
     return (1);
 
   if (m_strcmp(dst->option, "mask") != 0)
@@ -467,7 +376,7 @@ static int rx_from_string (struct option_t* dst, const char* val,
     p_delete(&p->rx);
   }
 
-  str_replace (&p->pattern, val);
+  m_strreplace(&p->pattern, val);
   p->rx = rx;
   p->not = not;
 
@@ -477,7 +386,7 @@ static int rx_from_string (struct option_t* dst, const char* val,
   return (1);
 }
 
-static void magic_to_string (char* dst, size_t dstlen,
+static void magic_to_string (char* dst, ssize_t dstlen,
                              struct option_t* option) {
   const char* s = NULL;
   switch (option->data) {
@@ -491,10 +400,10 @@ static void magic_to_string (char* dst, size_t dstlen,
 }
 
 static int magic_from_string (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen) {
+                              char* errbuf __attribute__ ((unused)), ssize_t errlen __attribute__ ((unused))) {
   int flag = -1;
 
-  if (!dst || !val || !*val)
+  if (!dst || m_strisempty(val))
     return (0);
   if (ascii_strncasecmp (val, "mbox", 4) == 0)
     flag = M_MBOX;
@@ -513,40 +422,38 @@ static int magic_from_string (struct option_t* dst, const char* val,
 
 }
 
-static void addr_to_string (char* dst, size_t dstlen,
+static void addr_to_string (char* dst, ssize_t dstlen,
                             struct option_t* option) {
   char s[HUGE_STRING];
   s[0] = '\0';
-  rfc822_write_address (s, sizeof(s), *((address_t**) option->data), 0);
+  rfc822_addrcat(s, sizeof(s), *((address_t**) option->data), 0);
   snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (s));
 }
 
 static int addr_from_string (struct option_t* dst, const char* val,
-                             char* errbuf, size_t errlen) {
+                             char* errbuf __attribute__ ((unused)), ssize_t errlen __attribute__ ((unused))) {
   if (!dst)
     return (0);
-  rfc822_free_address ((address_t**) dst->data);
+  address_list_wipe((address_t**) dst->data);
   if (val && *val)
     *((address_t**) dst->data) = rfc822_parse_adrlist (NULL, val);
   return (1);
 }
 
-int mutt_option_value (const char* val, char* dst, size_t dstlen) {
+int mutt_option_value (const char* val, char* dst, ssize_t dstlen) {
   struct option_t* option = NULL;
   char* tmp = NULL, *t = NULL;
-  size_t l = 0;
+  ssize_t l = 0;
 
   if (!(option = hash_find (ConfigOptions, val))) {
-    debug_print (1, ("var '%s' not found\n", val));
     *dst = '\0';
     return (0);
   }
   tmp = p_new(char, dstlen+1);
-  FuncTable[DTYPE (option->type)].opt_to_string (tmp, dstlen, option);
+  FuncTable[DTYPE(option->type)].opt_tostr (tmp, dstlen, option);
 
   /* as we get things of type $var=value and don't want to bloat the
    * above "just" for expansion, we do the stripping here */
-  debug_print (1, ("orig == '%s'\n", tmp));
   t = strchr (tmp, '=');
   t++;
   l = m_strlen(t);
@@ -558,28 +465,11 @@ int mutt_option_value (const char* val, char* dst, size_t dstlen) {
   }
   memcpy (dst, t, l+1);
   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 = p_new(syn_t, 1);
-  tmp->f = m_strdup(CurRCFile);
-  tmp->l = CurRCLine;
-  tmp->n = n;
-  tmp->o = o;
-  list_push_back (&Synonyms, tmp);
-}
-
-/* for synonym warning reports: free single item (for list_del()) */
-static void syn_del (void** p) {
-  p_delete(&(*(syn_t**) p)->f);
-  p_delete(p);
-}
-
-void toggle_quadoption (int opt)
+static void toggle_quadoption (int opt)
 {
   int n = opt / 4;
   int b = (opt % 4) * 2;
@@ -604,6 +494,22 @@ int quadoption (int opt)
   return (QuadOptions[n] >> b) & 0x3;
 }
 
+int query_quadoption2(int opt, const char *prompt)
+{
+  int v = mlua_reggeti(opt);
+
+  switch (v) {
+  case M_YES:
+  case M_NO:
+    return (v);
+
+  default:
+    v = mutt_yesorno(prompt, (v == M_ASKYES));
+    CLEARLINE (LINES - 1);
+    return (v);
+  }
+}
+
 int query_quadoption (int opt, const char *prompt)
 {
   int v = quadoption (opt);
@@ -622,307 +528,160 @@ int query_quadoption (int opt, const char *prompt)
   /* not reached */
 }
 
-static void add_to_list (LIST ** list, const char *str)
+static void add_to_list(string_list_t **list, const char *str)
 {
-  LIST *t, *last = NULL;
-
-  /* don't add a NULL or empty string to the list */
-  if (!str || *str == '\0')
-    return;
+    /* don't add a NULL or empty string to the list */
+    if (m_strisempty(str))
+        return;
 
-  /* check to make sure the item is not already on this list */
-  for (last = *list; last; last = last->next) {
-    if (ascii_strcasecmp (str, last->data) == 0) {
-      /* already on the list, so just ignore it */
-      last = NULL;
-      break;
+    /* check to make sure the item is not already on this list */
+    while (*list) {
+        if (!ascii_strcasecmp(str, (*list)->data))
+            return;
+        list = &(*list)->next;
     }
-    if (!last->next)
-      break;
-  }
 
-  if (!*list || last) {
-    t = p_new(LIST, 1);
-    t->data = m_strdup(str);
-    if (last) {
-      last->next = t;
-      last = last->next;
-    }
-    else
-      *list = last = t;
-  }
+    *list = p_new(string_list_t, 1);
+    (*list)->data = m_strdup(str);
 }
 
-static int add_to_rx_list (list2_t** list, const char *s, int flags,
-                           BUFFER * err)
+static int
+add_to_rx_list(rx_t **list, const char *s, int flags, BUFFER *err)
 {
-  rx_t* rx;
-  int i = 0;
+    rx_t *rx;
 
-  if (!s || !*s)
-    return 0;
+    if (m_strisempty(s))
+        return 0;
 
-  if (!(rx = rx_compile (s, flags))) {
-    snprintf (err->data, err->dsize, "Bad regexp: %s\n", s);
-    return -1;
-  }
+    if (rx_lookup(list, s))
+        return 0;
 
-  i = rx_lookup ((*list), rx->pattern);
-  if (i >= 0)
-    rx_free (&rx);
-  else
-    list_push_back (list, rx);
-  return 0;
+    rx = rx_compile(s, flags);
+    if (!rx) {
+        snprintf(err->data, err->dsize, "Bad regexp: %s\n", s);
+        return -1;
+    }
+
+    rx_list_append(list, rx);
+    return 0;
 }
 
-static int add_to_spam_list (SPAM_LIST ** list, const char *pat,
+static int add_to_spam_list(rx_t **list, const char *pat,
                              const char *templ, BUFFER * err)
 {
-  SPAM_LIST *t = NULL, *last = NULL;
-  rx_t* rx;
-  int n;
-  const char *p;
-
-  if (!pat || !*pat || !templ)
-    return 0;
+    rx_t *rx;
 
-  if (!(rx = rx_compile (pat, REG_ICASE))) {
-    snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat);
-    return -1;
-  }
+    if (m_strisempty(pat) || !templ)
+        return 0;
 
-  /* check to make sure the item is not already on this list */
-  for (last = *list; last; last = last->next) {
-    if (ascii_strcasecmp (rx->pattern, last->rx->pattern) == 0) {
-      /* Already on the list. Formerly we just skipped this case, but
-       * now we're supporting removals, which means we're supporting
-       * re-adds conceptually. So we probably want this to imply a
-       * removal, then do an add. We can achieve the removal by freeing
-       * the template, and leaving t pointed at the current item.
-       */
-      t = last;
-      p_delete(&t->template);
-      break;
+    if (!(rx = rx_compile (pat, REG_ICASE))) {
+        snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat);
+        return -1;
     }
-    if (!last->next)
-      break;
-  }
-
-  /* If t is set, it's pointing into an extant SPAM_LIST* that we want to
-   * update. Otherwise we want to make a new one to link at the list's end.
-   */
-  if (!t) {
-    t = mutt_new_spam_list ();
-    t->rx = rx;
-    if (last)
-      last->next = t;
-    else
-      *list = t;
-  }
-
-  /* Now t is the SPAM_LIST* that we want to modify. It is prepared. */
-  t->template = m_strdup(templ);
 
-  /* Find highest match number in template string */
-  t->nmatch = 0;
-  for (p = templ; *p;) {
-    if (*p == '%') {
-      n = atoi (++p);
-      if (n > t->nmatch)
-        t->nmatch = n;
-      while (*p && isdigit ((int) *p))
-        ++p;
+    /* check to make sure the item is not already on this list */
+    while (*list) {
+        if (!ascii_strcasecmp(rx->pattern, (*list)->pattern)) {
+            rx_t *tmp = rx_list_pop(list);
+            rx_delete(&tmp);
+        } else {
+            list = &(*list)->next;
+        }
     }
-    else
-      ++p;
-  }
-  t->nmatch++;                  /* match 0 is always the whole expr */
 
-  return 0;
+    *list = rx;
+    rx_set_template(rx, templ);
+    return 0;
 }
 
-static int remove_from_spam_list (SPAM_LIST ** list, const char *pat)
+static int remove_from_spam_list (rx_t ** list, const char *pat)
 {
-  SPAM_LIST *spam, *prev;
-  int nremoved = 0;
-
-  /* Being first is a special case. */
-  spam = *list;
-  if (!spam)
-    return 0;
-  if (spam->rx && !m_strcmp(spam->rx->pattern, pat)) {
-    *list = spam->next;
-    rx_free (&spam->rx);
-    p_delete(&spam->template);
-    p_delete(&spam);
-    return 1;
-  }
-
-  prev = spam;
-  for (spam = prev->next; spam;) {
-    if (!m_strcmp(spam->rx->pattern, pat)) {
-      prev->next = spam->next;
-      rx_free (&spam->rx);
-      p_delete(&spam->template);
-      p_delete(&spam);
-      spam = prev->next;
-      ++nremoved;
+    int nremoved = 0;
+
+    while (*list) {
+        if (!m_strcmp((*list)->pattern, pat)) {
+            rx_t *spam = rx_list_pop(list);
+            rx_delete(&spam);
+            nremoved++;
+        } else {
+            list = &(*list)->next;
+        }
     }
-    else
-      spam = spam->next;
-  }
 
-  return nremoved;
+    return nremoved;
 }
 
 
-static void remove_from_list (LIST ** l, const char *str)
+static void remove_from_list(string_list_t **l, const char *str)
 {
-  LIST *p, *last = NULL;
-
-  if (m_strcmp("*", str) == 0)
-    mutt_free_list (l);         /* ``unCMD *'' means delete all current entries */
-  else {
-    p = *l;
-    last = NULL;
-    while (p) {
-      if (ascii_strcasecmp (str, p->data) == 0) {
-        p_delete(&p->data);
-        if (last)
-          last->next = p->next;
-        else
-          (*l) = p->next;
-        p_delete(&p);
-      }
-      else {
-        last = p;
-        p = p->next;
-      }
+    if (!m_strcmp("*", str)) {
+        string_list_wipe(l);  /* ``unCMD *'' means delete all current entries */
+        return;
     }
-  }
-}
 
-static int remove_from_rx_list (list2_t** l, const char *str)
-{
-  int i = 0;
-
-  if (m_strcmp("*", str) == 0) {
-    list_del (l, (list_del_t*) rx_free);
-    return (0);
-  }
-  else {
-    i = rx_lookup ((*l), str);
-    if (i >= 0) {
-      rx_t* r = list_pop_idx ((*l), i);
-      rx_free (&r);
-      return (0);
+    while (*l) {
+        if (!ascii_strcasecmp(str, (*l)->data)) {
+            string_list_t *it = string_list_pop(l);
+            string_item_delete(&it);
+        } else {
+            l = &(*l)->next;
+        }
     }
-  }
-  return (-1);
 }
 
-static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
-                        BUFFER * err)
+static int remove_from_rx_list(rx_t **l, const char *str)
 {
-  int i, j, res = 0;
-  BUFFER token;
-  struct option_t* option = NULL;
-
-  p_clear(&token, 1);
-  mutt_extract_token (tmp, s, 0);
-
-  /* is the item defined as a variable or a function? */
-  if ((option = hash_find (ConfigOptions, tmp->data)) != NULL)
-    res = 1;
-  else {
-    for (i = 0; !res && i < MENU_MAX; i++) {
-      struct binding_t *b = km_get_table (Menus[i].value);
-
-      if (!b)
-        continue;
-
-      for (j = 0; b[j].name; j++)
-        if (!ascii_strncasecmp (tmp->data, b[j].name, m_strlen(tmp->data))
-            && (m_strlen(b[j].name) == m_strlen(tmp->data))) {
-          res = 1;
-          break;
-        }
-    }
-  }
-  /* check for feature_* */
-  if (!res && ascii_strncasecmp (tmp->data, "feature_", 8) == 0 &&
-      (j = m_strlen(tmp->data)) > 8) {
-    i = 0;
-    while (Features[i]) {
-      if (m_strlen(Features[i]) == j-8 &&
-          ascii_strncasecmp (Features[i], tmp->data+8, j-8) == 0) {
-        res = 1;
-        break;
-      }
-      i++;
+    if (m_strcmp("*", str) == 0) {
+        rx_list_wipe(l);
+        return 0;
     }
-  }
-
-  if (!MoreArgs (s)) {
-    if (data)
-      snprintf (err->data, err->dsize, _("ifdef: too few arguments"));
-    else
-      snprintf (err->data, err->dsize, _("ifndef: too few arguments"));
-    return (-1);
-  }
-
-  mutt_extract_token (tmp, s, M_TOKEN_SPACE);
 
-  if (data == res) {
-    if (mutt_parse_rc_line (tmp->data, &token, err) == -1) {
-      mutt_error ("Error: %s", err->data);
-      p_delete(&token.data);
-      return (-1);
+    l = rx_lookup(l, str);
+    if (l) {
+        rx_t *r = rx_list_pop(l);
+        rx_delete(&r);
+        return 0;
     }
-    p_delete(&token.data);
-  }
-  return 0;
+
+    return -1;
 }
 
-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);
 
     /* don't add "*" to the unignore list */
-    if (strcmp (buf->data, "*"))
+    if (m_strcmp (buf->data, "*"))
       add_to_list (&UnIgnore, buf->data);
 
     remove_from_list (&Ignore, buf->data);
-  }
-  while (MoreArgs (s));
+  } while (MoreArgs (s));
 
   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);
     remove_from_list (&UnIgnore, buf->data);
     add_to_list (&Ignore, buf->data);
-  }
-  while (MoreArgs (s));
-
+  } while (MoreArgs(s));
   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,
+                      BUFFER * err __attribute__ ((unused)))
 {
   do {
     mutt_extract_token (buf, s, 0);
-    add_to_list ((LIST **) data, buf->data);
-  }
-  while (MoreArgs (s));
-
+    add_to_list ((string_list_t **) data, buf->data);
+  } while (MoreArgs(s));
   return 0;
 }
 
@@ -936,8 +695,9 @@ static void _alternates_clean (void)
   }
 }
 
-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 {
@@ -952,8 +712,9 @@ static int parse_alternates (BUFFER * buf, BUFFER * s, unsigned long data,
   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 {
@@ -1017,8 +778,8 @@ static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data,
 
     /* "*" is a special case. */
     if (!m_strcmp(buf->data, "*")) {
-      mutt_free_spam_list (&SpamList);
-      list_del (&NoSpamList, (list_del_t*) rx_free);
+      rx_list_wipe(&SpamList);
+      rx_list_wipe(&NoSpamList);
       return 0;
     }
 
@@ -1039,7 +800,7 @@ static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data,
 }
 
 static int parse_unlist (BUFFER * buf, BUFFER * s, unsigned long data,
-                         BUFFER * err)
+                         BUFFER * err __attribute__ ((unused)))
 {
   do {
     mutt_extract_token (buf, s, 0);
@@ -1047,17 +808,18 @@ static int parse_unlist (BUFFER * buf, BUFFER * s, unsigned long data,
      * Check for deletion of entire list
      */
     if (m_strcmp(buf->data, "*") == 0) {
-      mutt_free_list ((LIST **) data);
+      string_list_wipe((string_list_t **) data);
       break;
     }
-    remove_from_list ((LIST **) data, buf->data);
+    remove_from_list ((string_list_t **) data, buf->data);
   }
   while (MoreArgs (s));
 
   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 {
@@ -1081,21 +843,18 @@ static void _attachments_clean (void) {
   }
 }
 
-static int parse_attach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
-                              BUFFER *err) {
+static int parse_attach_list (BUFFER *buf, BUFFER *s, string_list_t **ldata,
+                              BUFFER *err __attribute__ ((unused))) {
   ATTACH_MATCH *a;
-  LIST *listp, *lastp;
+  string_list_t *listp, *lastp;
   char *p;
   char *tmpminor;
   int len;
 
   /* Find the last item in the list that data points to. */
   lastp = NULL;
-  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));
     lastp = listp;
   }
 
@@ -1125,7 +884,7 @@ static int parse_attach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
 
     len = m_strlen(a->minor);
     tmpminor = p_new(char, len + 3);
-    strcpy(&tmpminor[1], a->minor); /* __STRCPY_CHECKED__ */
+    m_strcpy(&tmpminor[1], len + 3, a->minor);
     tmpminor[0] = '^';
     tmpminor[len+1] = '$';
     tmpminor[len+2] = '\0';
@@ -1135,10 +894,7 @@ static int parse_attach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
 
     p_delete(&tmpminor);
 
-    debug_print (5, ("parse_attach_list: added %s/%s [%d]\n",
-                     a->major, a->minor, a->major_int));
-
-    listp = p_new(LIST, 1);
+    listp = p_new(string_list_t, 1);
     listp->data = (char *)a;
     listp->next = NULL;
     if (lastp) {
@@ -1154,9 +910,10 @@ static int parse_attach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
   return 0;
 }
 
-static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata, BUFFER *err) {
+static int parse_unattach_list (BUFFER *buf, BUFFER *s, string_list_t **ldata,
+                                BUFFER *err __attribute__ ((unused))) {
   ATTACH_MATCH *a;
-  LIST *lp, *lastp, *newlp;
+  string_list_t *lp, *lastp, *newlp;
   char *tmp;
   int major;
   char *minor;
@@ -1175,20 +932,16 @@ static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata, BUFFER *er
       *minor = '\0';
       ++minor;
     } else {
-      minor = "unknown";
+      minor = m_strdup("unknown");
     }
     major = mutt_check_mime_type(tmp);
 
     /* We must do our own walk here because remove_from_list() will only
-     * remove the LIST->data, not anything pointed to by the LIST->data. */
+     * remove the string_list_t->data, not anything pointed to by the string_list_t->data. */
     lastp = NULL;
     for(lp = *ldata; lp; ) {
       a = (ATTACH_MATCH *)lp->data;
-      debug_print(5, ("parse_unattach_list: check %s/%s [%d] : %s/%s [%d]\n",
-                      a->major, a->minor, a->major_int, tmp, minor, major));
       if (a->major_int == major && !m_strcasecmp(minor, a->minor)) {
-        debug_print(5, ("parse_unattach_list: removed %s/%s [%d]\n",
-                        a->major, a->minor, a->major_int));
         regfree(&a->minor_rx);
         p_delete(&a->major);
 
@@ -1216,7 +969,7 @@ static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata, BUFFER *er
   return 0;
 }
 
-static int print_attach_list (LIST *lp, char op, const char *name) {
+static int print_attach_list (string_list_t *lp, char op, const char *name) {
   while (lp) {
     printf("attachments %c%s %s/%s\n", op, name,
            ((ATTACH_MATCH *)lp->data)->major,
@@ -1227,9 +980,11 @@ static int print_attach_list (LIST *lp, char op, const char *name) {
   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;
+  string_list_t **listp;
 
   mutt_extract_token(buf, s, 0);
   if (!buf->data || *buf->data == '\0') {
@@ -1277,9 +1032,9 @@ static int parse_attachments (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER
   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;
+  string_list_t **listp;
 
   mutt_extract_token(buf, s, 0);
   if (!buf->data || *buf->data == '\0') {
@@ -1313,8 +1068,9 @@ static int parse_unattachments (BUFFER *buf, BUFFER *s, unsigned long data, BUFF
   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);
@@ -1330,7 +1086,7 @@ static int parse_unlists (BUFFER * buf, BUFFER * s, unsigned long data,
   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 {
@@ -1348,8 +1104,9 @@ static int parse_subscribe (BUFFER * buf, BUFFER * s, unsigned long data,
   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);
@@ -1364,164 +1121,128 @@ static int parse_unsubscribe (BUFFER * buf, BUFFER * s, unsigned long data,
   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;
-
-  do {
-    mutt_extract_token (buf, s, 0);
-
-    if (m_strcmp("*", buf->data) == 0) {
-      if (CurrentMenu == MENU_ALIAS) {
-        for (tmp = Aliases; tmp; tmp = tmp->next)
-          tmp->del = 1;
-        set_option (OPTFORCEREDRAWINDEX);
-      }
-      else
-        mutt_free_alias (&Aliases);
-      break;
-    }
-    else
-      for (tmp = Aliases; tmp; tmp = tmp->next) {
-        if (m_strcasecmp(buf->data, tmp->name) == 0) {
-          if (CurrentMenu == MENU_ALIAS) {
-            tmp->del = 1;
-            set_option (OPTFORCEREDRAWINDEX);
+    alias_t *tmp, **last;
+
+    do {
+        mutt_extract_token (buf, s, 0);
+
+        if (!m_strcmp("*", buf->data) == 0) {
+            if (CurrentMenu == MENU_ALIAS) {
+                for (tmp = Aliases; tmp; tmp = tmp->next)
+                    tmp->del = 1;
+                set_option(OPTFORCEREDRAWINDEX);
+            } else {
+                alias_list_wipe(&Aliases);
+            }
             break;
-          }
+        }
 
-          if (last)
-            last->next = tmp->next;
-          else
-            Aliases = tmp->next;
-          tmp->next = NULL;
-          mutt_free_alias (&tmp);
-          break;
+        last = &Aliases;
+        for (last = &Aliases; *last; last = &(*last)->next) {
+            if (!m_strcasecmp(buf->data, (*last)->name)) {
+                if (CurrentMenu == MENU_ALIAS) {
+                    (*last)->del = 1;
+                    set_option (OPTFORCEREDRAWINDEX);
+                } else {
+                    tmp = alias_list_pop(last);
+                    alias_delete(&tmp);
+                }
+                break;
+            }
         }
-        last = tmp;
-      }
-  }
-  while (MoreArgs (s));
-  return 0;
+    } while (MoreArgs(s));
+
+    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;
-  ALIAS *last = NULL;
-  char *estr = NULL;
-
-  if (!MoreArgs (s)) {
-    m_strcpy(err->data, err->dsize, _("alias: no address"));
-    return (-1);
-  }
+    alias_t **last;
+    char *estr = NULL;
 
-  mutt_extract_token (buf, s, 0);
-
-  debug_print (2, ("first token is '%s'.\n", buf->data));
+    if (!MoreArgs (s)) {
+        m_strcpy(err->data, err->dsize, _("alias: no address"));
+        return (-1);
+    }
 
-  /* check to see if an alias with this name already exists */
-  for (; tmp; tmp = tmp->next) {
-    if (!m_strcasecmp(tmp->name, buf->data))
-      break;
-    last = tmp;
-  }
+    mutt_extract_token (buf, s, 0);
 
-  if (!tmp) {
-    /* create a new alias */
-    tmp = p_new(ALIAS, 1);
-    tmp->self = tmp;
-    tmp->name = m_strdup(buf->data);
-    /* give the main addressbook code a chance */
-    if (CurrentMenu == MENU_ALIAS)
-      set_option (OPTMENUCALLER);
-  }
-  else {
-    /* override the previous value */
-    rfc822_free_address (&tmp->addr);
-    if (CurrentMenu == MENU_ALIAS)
-      set_option (OPTFORCEREDRAWINDEX);
-  }
+    /* check to see if an alias with this name already exists */
+    for (last = &Aliases; *last; last = &(*last)->next) {
+        if (!m_strcasecmp((*last)->name, buf->data))
+            break;
+    }
 
-  mutt_extract_token (buf, s,
-                      M_TOKEN_QUOTE | M_TOKEN_SPACE | M_TOKEN_SEMICOLON);
-  debug_print (2, ("second token is '%s'.\n", buf->data));
-  tmp->addr = mutt_parse_adrlist (tmp->addr, buf->data);
-  if (last)
-    last->next = tmp;
-  else
-    Aliases = tmp;
-  if (mutt_addrlist_to_idna (tmp->addr, &estr)) {
-    snprintf (err->data, err->dsize,
-              _("Warning: Bad IDN '%s' in alias '%s'.\n"), estr, tmp->name);
-    return -1;
-  }
-#ifdef DEBUG
-  if (DebugLevel >= 2) {
-    address_t *a;
+    if (!*last) {
+        /* create a new alias */
+        *last = alias_new();
+        (*last)->name = m_strdup(buf->data);
+        /* give the main addressbook code a chance */
+        if (CurrentMenu == MENU_ALIAS)
+            set_option (OPTMENUCALLER);
+    } else {
+        /* override the previous value */
+        address_list_wipe(&(*last)->addr);
+        if (CurrentMenu == MENU_ALIAS)
+            set_option (OPTFORCEREDRAWINDEX);
+    }
 
-    /* A group is terminated with an empty address, so check a->mailbox */
-    for (a = tmp->addr; a && a->mailbox; a = a->next) {
-      if (!a->group)
-        debug_print (2, ("%s\n", a->mailbox));
-      else
-        debug_print (2, ("group %s\n", a->mailbox));
+    mutt_extract_token(buf, s, M_TOKEN_QUOTE | M_TOKEN_SPACE);
+    (*last)->addr = mutt_parse_adrlist((*last)->addr, buf->data);
+    if (mutt_addrlist_to_idna((*last)->addr, &estr)) {
+        snprintf (err->data, err->dsize,
+                  _("Warning: Bad IDN '%s' in alias '%s'.\n"), estr, (*last)->name);
+        p_delete(&estr);
+        return -1;
     }
-  }
-#endif
-  return 0;
+
+    return 0;
 }
 
 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;
-  LIST *ptr;
-  size_t l;
-
-  do {
-    mutt_extract_token (buf, s, 0);
-    if (m_strcmp("*", buf->data) == 0)
-      mutt_free_list (&UserHeader);
-    else {
-      tmp = UserHeader;
-      last = NULL;
-
-      l = m_strlen(buf->data);
-      if (buf->data[l - 1] == ':')
-        l--;
-
-      while (tmp) {
-        if (ascii_strncasecmp (buf->data, tmp->data, l) == 0
-            && tmp->data[l] == ':') {
-          ptr = tmp;
-          if (last)
-            last->next = tmp->next;
-          else
-            UserHeader = tmp->next;
-          tmp = tmp->next;
-          ptr->next = NULL;
-          mutt_free_list (&ptr);
-        }
-        else {
-          last = tmp;
-          tmp = tmp->next;
+    do {
+        mutt_extract_token (buf, s, 0);
+
+        if (!m_strcmp("*", buf->data)) {
+            string_list_wipe(&UserHeader);
+        } else {
+            string_list_t **last = &UserHeader;
+            ssize_t l = m_strlen(buf->data);
+
+            if (buf->data[l - 1] == ':')
+                l--;
+
+            while (*last) {
+                if (!ascii_strncasecmp(buf->data, (*last)->data, l)
+                && (*last)->data[l] == ':')
+                {
+                    string_list_t *tmp = string_list_pop(last);
+                    string_item_delete(&tmp);
+                } else {
+                    last = &(*last)->next;
+                }
+            }
         }
-      }
-    }
-  }
-  while (MoreArgs (s));
-  return 0;
+    } while (MoreArgs(s));
+
+    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;
-  size_t keylen;
+  string_list_t *tmp;
+  ssize_t keylen;
   char *p;
 
   mutt_extract_token (buf, s, M_TOKEN_SPACE | M_TOKEN_QUOTE);
@@ -1544,11 +1265,11 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data,
       if (!tmp->next)
         break;
     }
-    tmp->next = mutt_new_list ();
+    tmp->next = string_item_new();
     tmp = tmp->next;
   }
   else {
-    tmp = mutt_new_list ();
+    tmp = string_item_new();
     UserHeader = tmp;
   }
   tmp->data = buf->data;
@@ -1558,7 +1279,7 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data,
 
 static int
 parse_sort (struct option_t* dst, const char *s, const struct mapping_t *map,
-            char* errbuf, size_t errlen) {
+            char* errbuf, ssize_t errlen) {
   int i, flags = 0;
 
   if (m_strncmp("reverse-", s, 8) == 0) {
@@ -1582,7 +1303,7 @@ parse_sort (struct option_t* dst, const char *s, const struct mapping_t *map,
 }
 
 /* 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;
@@ -1592,7 +1313,7 @@ static void mutt_set_default(const char *name, void* p, unsigned long more)
             return;
         ptr = hash_find(ConfigOptions, (const char *)ptr->data);
     }
-    if (!ptr || *ptr->init || !FuncTable[DTYPE (ptr->type)].opt_from_string)
+    if (!ptr || *ptr->init || !FuncTable[DTYPE (ptr->type)].opt_fromstr)
         return;
 
     mutt_option_value(ptr->option, buf, sizeof(buf));
@@ -1600,38 +1321,9 @@ static void mutt_set_default(const char *name, void* p, unsigned long more)
         ptr->init = m_strdup(buf);
 }
 
-static struct option_t* add_option (const char* name, const char* init,
-                                    short type, short dodup) {
-  struct option_t* option = p_new(struct option_t, 1);
-
-  debug_print (1, ("adding $%s\n", name));
-
-  option->option = m_strdup(name);
-  option->type = type;
-  if (init)
-    option->init = dodup ? m_strdup(init) : (char*) init;
-  return (option);
-}
-
-/* creates new option_t* of type DT_USER for $user_ var */
-static struct option_t* add_user_option (const char* name) {
-  return (add_option (name, NULL, DT_USER, 1));
-}
-
-/* free()'s option_t* */
-static void del_option (void* p) {
-  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)));
-  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;
+  ssize_t len = 0;
 
   p_delete(dst);
 
@@ -1663,8 +1355,8 @@ static int init_expand (char** dst, struct option_t* src) {
 }
 
 /* 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;
@@ -1676,9 +1368,9 @@ static void mutt_restore_default (const char* name, void* p,
   }
   if (!ptr)
     return;
-  if (FuncTable[DTYPE (ptr->type)].opt_from_string) {
+  if (FuncTable[DTYPE (ptr->type)].opt_fromstr) {
     init_expand (&init, ptr);
-    if (!FuncTable[DTYPE (ptr->type)].opt_from_string (ptr, init, errbuf,
+    if (!FuncTable[DTYPE (ptr->type)].opt_fromstr (ptr, init, errbuf,
                                                        sizeof(errbuf))) {
       if (!option (OPTNOCURSES))
         mutt_endwin (NULL);
@@ -1705,8 +1397,8 @@ static void mutt_restore_default (const char* name, void* p,
 }
 
 /* check whether value for $dsn_return would be valid */
-static int check_dsn_return (const char* option, unsigned long p,
-                             char* errbuf, size_t errlen) {
+static int check_dsn_return (const char* option __attribute__ ((unused)), unsigned long p,
+                             char* errbuf, ssize_t errlen) {
   char* val = (char*) p;
   if (val && *val && m_strncmp(val, "hdrs", 4) != 0 &&
       m_strncmp(val, "full", 4) != 0) {
@@ -1718,35 +1410,33 @@ static int check_dsn_return (const char* option, unsigned long p,
 }
 
 /* check whether value for $dsn_notify would be valid */
-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;
-  char* val = (char*) p;
-
-  if (!val || !*val)
-    return (1);
-  list = list_from_str (val, ",");
-  if (list_empty (list))
-    return (1);
+static int
+check_dsn_notify (const char* option __attribute__ ((unused)),
+                  unsigned long val, char* errbuf, ssize_t errlen)
+{
+    const char *p = (const char*)val;
+
+    while (p && *p) {
+        const char *q = m_strchrnul(p, ',');
+        int len = q - p;
+
+        if (!m_strncmp(p, "never", len)   && !m_strncmp(p, "delay", len)
+        &&  !m_strncmp(p, "failure", len) && !m_strncmp(p, "success", len))
+        {
+            if (errbuf)
+                snprintf(errbuf, errlen, _("'%.*s' is invalid for $%s"),
+                         len, p, "dsn_notify");
+            return 0;
+        }
 
-  for (i = 0; i < list->length; i++)
-    if (m_strncmp(list->data[i], "never", 5) != 0 &&
-        m_strncmp(list->data[i], "failure", 7) != 0 &&
-        m_strncmp(list->data[i], "delay", 5) != 0 &&
-        m_strncmp(list->data[i], "success", 7) != 0) {
-      if (errbuf)
-        snprintf (errbuf, errlen, _("'%s' is invalid for $%s"),
-                  (char*) list->data[i], "dsn_notify");
-      rc = 0;
-      break;
+        p = q + 1;
     }
-  list_del (&list, (list_del_t*)xmemfree);
-  return (rc);
+
+    return 1;
 }
 
 static int check_num (const char* option, unsigned long p,
-                      char* errbuf, size_t errlen) {
+                      char* errbuf, ssize_t errlen) {
   if ((int) p < 0) {
     if (errbuf)
       snprintf (errbuf, errlen, _("'%d' is invalid for $%s"), (int) p, option);
@@ -1755,21 +1445,8 @@ static int check_num (const char* option, unsigned long p,
   return (1);
 }
 
-#ifdef DEBUG
-static int check_debug (const char* option, unsigned long p,
-                        char* errbuf, size_t errlen) {
-  if ((int) p <= DEBUG_MAX_LEVEL &&
-      (int) p >= DEBUG_MIN_LEVEL)
-    return (1);
-
-  if (errbuf)
-    snprintf (errbuf, errlen, _("'%d' is invalid for $%s"), (int) p, option);
-  return (0);
-}
-#endif
-
-static int check_history (const char* option, unsigned long p,
-                          char* errbuf, size_t errlen) {
+static int check_history (const char* option __attribute__ ((unused)), unsigned long p,
+                          char* errbuf, ssize_t errlen) {
   if (!check_num ("history", p, errbuf, errlen))
     return (0);
   mutt_init_history ();
@@ -1777,7 +1454,7 @@ static int check_history (const char* option, unsigned long p,
 }
 
 static int check_special (const char* name, unsigned long val,
-                          char* errbuf, size_t errlen) {
+                          char* errbuf, ssize_t errlen) {
   int i = 0;
 
   for (i = 0; SpecialVars[i].name; i++) {
@@ -1800,8 +1477,7 @@ static const struct mapping_t* get_sortmap (struct option_t* option) {
     map = SortBrowserMethods;
     break;
   case DT_SORT_KEYS:
-    if ((WithCrypto & APPLICATION_PGP))
-      map = SortKeyMethods;
+    map = SortKeyMethods;
     break;
   case DT_SORT_AUX:
     map = SortAuxMethods;
@@ -1857,23 +1533,18 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
 
     /* resolve synonyms */
     if ((option = hash_find (ConfigOptions, tmp->data)) != NULL &&
-        DTYPE (option->type == DT_SYN)) {
+        DTYPE (option->type == DT_SYN))
+    {
       struct option_t* newopt = hash_find (ConfigOptions, (char*) option->data);
-      syn_add (newopt, option);
+      syn_t* syn = syn_new();
+      syn->f = m_strdup(CurRCFile);
+      syn->l = CurRCLine;
+      syn->n = newopt;
+      syn->o = option;
+      syn_list_push(&Synonyms, syn);
       option = newopt;
     }
 
-    /* see if we need to add $user_ var */
-    if (!option && ascii_strncmp ("user_", tmp->data, 5) == 0) {
-      /* there's no option named like this yet so only add one
-       * if the action isn't any of: reset, unset, query */
-      if (!(reset || unset || query || *s->dptr != '=')) {
-        debug_print (1, ("adding user option '%s'\n", tmp->data));
-        option = add_user_option (tmp->data);
-        hash_insert (ConfigOptions, option->option, option, 0);
-      }
-    }
-
     if (!option && !(reset && m_strcmp("all", tmp->data) == 0)) {
       snprintf (err->data, err->dsize, _("%s: unknown variable"), tmp->data);
       return (-1);
@@ -1904,11 +1575,6 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         set_option (OPTRESORTINIT);
         set_option (OPTREDRAWTREE);
         return (0);
-      }
-      else if (!FuncTable[DTYPE (option->type)].opt_from_string) {
-        snprintf (err->data, err->dsize, _("$%s is read-only"), option->option);
-        r = -1;
-        break;
       } else {
         CHECK_PAGER;
         mutt_restore_default (NULL, option, 1);
@@ -1954,55 +1620,35 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
              DTYPE (option->type) == DT_MAGIC ||
              DTYPE (option->type) == DT_NUM ||
              DTYPE (option->type) == DT_SORT ||
-             DTYPE (option->type) == DT_RX ||
-             DTYPE (option->type) == DT_USER ||
-             DTYPE (option->type) == DT_SYS) {
-
+             DTYPE (option->type) == DT_RX)
+    {
       /* XXX maybe we need to get unset into handlers? */
       if (DTYPE (option->type) == DT_STR ||
           DTYPE (option->type) == DT_PATH ||
-          DTYPE (option->type) == DT_ADDR ||
-          DTYPE (option->type) == DT_USER ||
-          DTYPE (option->type) == DT_SYS) {
+          DTYPE (option->type) == DT_ADDR)
+      {
         if (unset) {
           CHECK_PAGER;
-          if (!FuncTable[DTYPE (option->type)].opt_from_string) {
-            snprintf (err->data, err->dsize, _("$%s is read-only"),
-                      option->option);
-            r = -1;
-            break;
-          } else if (DTYPE (option->type) == DT_ADDR)
-            rfc822_free_address ((address_t **) option->data);
-          else if (DTYPE (option->type) == DT_USER)
-            /* to unset $user_ means remove */
-            hash_delete (ConfigOptions, option->option,
-                         option, del_option);
+          if (DTYPE (option->type) == DT_ADDR)
+            address_list_wipe((address_t **) option->data);
           else
-            p_delete((void **)&option->data);
+            p_delete((void **)(void *)&option->data);
           break;
         }
       }
 
       if (query || *s->dptr != '=') {
-        FuncTable[DTYPE (option->type)].opt_to_string
+        FuncTable[DTYPE (option->type)].opt_tostr
           (err->data, err->dsize, option);
         break;
       }
 
-      /* the $muttng_ variables are read-only */
-      if (!FuncTable[DTYPE (option->type)].opt_from_string) {
-        snprintf (err->data, err->dsize, _("$%s is read-only"),
-                  option->option);
+      CHECK_PAGER;
+      s->dptr++;
+      mutt_extract_token (tmp, s, 0);
+      if (!FuncTable[DTYPE (option->type)].opt_fromstr
+          (option, tmp->data, err->data, err->dsize))
         r = -1;
-        break;
-      } else {
-        CHECK_PAGER;
-        s->dptr++;
-        mutt_extract_token (tmp, s, 0);
-        if (!FuncTable[DTYPE (option->type)].opt_from_string
-            (option, tmp->data, err->data, err->dsize))
-          r = -1;
-      }
     }
     else if (DTYPE (option->type) == DT_QUAD) {
 
@@ -2073,18 +1719,16 @@ static int source_rc (const char *rcfile, BUFFER * err)
   BUFFER token;
   char *linebuf = NULL;
   char *currentline = NULL;
-  size_t buflen;
+  ssize_t buflen;
   pid_t pid;
 
-  debug_print (2, ("reading configuration file '%s'.\n", rcfile));
-
   if ((f = mutt_open_read (rcfile, &pid)) == NULL) {
     snprintf (err->data, err->dsize, "%s: %s", rcfile, strerror (errno));
     return (-1);
   }
 
   p_clear(&token, 1);
-  while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) {
+  while ((linebuf = mutt_read_line(linebuf, &buflen, f, &line)) != NULL) {
     conv = ConfigCharset && (*ConfigCharset) && Charset;
     if (conv) {
       currentline = m_strdup(linebuf);
@@ -2115,7 +1759,7 @@ static int source_rc (const char *rcfile, BUFFER * err)
   }
   p_delete(&token.data);
   p_delete(&linebuf);
-  fclose (f);
+  m_fclose(&f);
   if (pid != -1)
     mutt_wait_filter (pid);
   if (rc) {
@@ -2131,7 +1775,8 @@ static int source_rc (const char *rcfile, BUFFER * err)
 
 #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];
@@ -2163,7 +1808,7 @@ static int parse_source (BUFFER * tmp, BUFFER * s, unsigned long data,
 		every call to this function.
 
    err		where to write error messages */
-int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err)
+int mutt_parse_rc_line (const char *line, BUFFER * token, BUFFER * err)
 {
   int i, r = -1;
   BUFFER expn;
@@ -2174,8 +1819,6 @@ int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err)
 
   *err->data = 0;
 
-  debug_print (1, ("expand '%s'\n", line));
-
   expn.dptr = vskipspaces(expn.dptr);
   while (*expn.dptr) {
     if (*expn.dptr == '#')
@@ -2238,7 +1881,7 @@ static void candidate (char *dest, char *try, const char *src, int len)
   }
 }
 
-int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs)
+int mutt_command_complete (char *buffer, ssize_t len, int pos, int numtabs)
 {
   char *pt = buffer;
   int num;
@@ -2256,8 +1899,8 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs)
     if (numtabs == 1) {
       Num_matched = 0;
       m_strcpy(User_typed, sizeof(User_typed), pt);
-      p_clear(Matches, sizeof(Matches));
-      p_clear(Completed, sizeof(Completed));
+      p_clear(Matches, countof(Matches));
+      p_clear(Completed, countof(Completed));
       for (num = 0; Commands[num].name; num++)
         candidate (Completed, User_typed, Commands[num].name,
                    sizeof(Completed));
@@ -2305,8 +1948,8 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs)
     if (numtabs == 1) {
       Num_matched = 0;
       m_strcpy(User_typed, sizeof(User_typed), pt);
-      p_clear(Matches, sizeof(Matches));
-      p_clear(Completed, sizeof(Completed));
+      p_clear(Matches, countof(Matches));
+      p_clear(Completed, countof(Completed));
       for (num = 0; MuttVars[num].option; num++)
         candidate(Completed, User_typed, MuttVars[num].option,
                   sizeof(Completed));
@@ -2343,8 +1986,8 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs)
     if (numtabs == 1) {
       Num_matched = 0;
       m_strcpy(User_typed, sizeof(User_typed), pt);
-      p_clear(Matches, sizeof(Matches));
-      p_clear(Completed, sizeof(Completed));
+      p_clear(Matches, countof(Matches));
+      p_clear(Completed, countof(Completed));
       for (num = 0; menu[num].name; num++)
         candidate (Completed, User_typed, menu[num].name, sizeof(Completed));
       /* try the generic menu */
@@ -2382,7 +2025,7 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs)
   return 1;
 }
 
-int mutt_var_value_complete (char *buffer, size_t len, int pos)
+int mutt_var_value_complete (char *buffer, ssize_t len, int pos)
 {
   char var[STRING], *pt = buffer;
   int spaces;
@@ -2410,7 +2053,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
     else {
       char tmp[LONG_STRING], tmp2[LONG_STRING];
       char *s, *d;
-      size_t dlen = buffer + len - pt - spaces;
+      ssize_t dlen = buffer + len - pt - spaces;
       const char *vals[] = { "no", "yes", "ask-no", "ask-yes" };
 
       tmp[0] = '\0';
@@ -2423,8 +2066,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
           mutt_pretty_mailbox (tmp);
       }
       else if (DTYPE (option->type) == DT_ADDR) {
-        rfc822_write_address (tmp, sizeof(tmp),
-                              *((address_t **) option->data), 0);
+        rfc822_addrcat(tmp, sizeof(tmp), *((address_t **) option->data), 0);
       }
       else if (DTYPE (option->type) == DT_QUAD)
         m_strcpy(tmp, sizeof(tmp), vals[quadoption(option->data)]);
@@ -2442,10 +2084,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
           map = SortBrowserMethods;
           break;
         case DT_SORT_KEYS:
-          if ((WithCrypto & APPLICATION_PGP))
-            map = SortKeyMethods;
-          else
-            map = SortMethods;
+          map = SortKeyMethods;
           break;
         default:
           map = SortMethods;
@@ -2481,7 +2120,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
       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++;
@@ -2498,9 +2137,9 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
 }
 
 /* Implement the -Q command line flag */
-int mutt_query_variables (LIST * queries)
+int mutt_query_variables (string_list_t * queries)
 {
-  LIST *p;
+  string_list_t *p;
 
   char errbuff[STRING];
   char command[STRING];
@@ -2527,10 +2166,10 @@ int mutt_query_variables (LIST * queries)
   return 0;
 }
 
-static int mutt_execute_commands (LIST * p)
+static int mutt_execute_commands (string_list_t * p)
 {
   BUFFER err, token;
-  char errstr[SHORT_STRING];
+  char errstr[STRING];
 
   p_clear(&err, 1);
   err.data = errstr;
@@ -2547,29 +2186,23 @@ static int mutt_execute_commands (LIST * p)
   return 0;
 }
 
-void mutt_init (int skip_sys_rc, LIST * commands)
+void mutt_init (int skip_sys_rc, string_list_t * commands)
 {
   struct passwd *pw;
   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;
+  int i;
   BUFFER err;
 
   p_clear(&err, 1);
   err.data = error;
   err.dsize = sizeof(error);
 
-  /* use 3*sizeof(muttvars) instead of 2*sizeof()
-   * to have some room for $user_ vars */
-  ConfigOptions = hash_create (sizeof(MuttVars) * 3);
+  ConfigOptions = hash_create (sizeof(MuttVars) * 2);
   for (i = 0; MuttVars[i].option; i++) {
-    if (DTYPE (MuttVars[i].type) != DT_SYS)
-      hash_insert (ConfigOptions, MuttVars[i].option, &MuttVars[i], 0);
-    else
-      hash_insert (ConfigOptions, MuttVars[i].option,
-                   add_option (MuttVars[i].option, MuttVars[i].init,
-                               DT_SYS, 0), 0);
+    hash_insert (ConfigOptions, MuttVars[i].option, &MuttVars[i], 0);
   }
 
   /*
@@ -2591,8 +2224,8 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     if (!Homedir)
       Homedir = m_strdup(pw->pw_dir);
 
-    Realname = m_strdup(mutt_gecos_name (rnbuf, sizeof(rnbuf), pw));
-    Shell = m_strdup(pw->pw_shell);
+    mutt_gecos_name(rnbuf, sizeof(rnbuf), pw, GecosMask.rx);
+    Realname = m_strdup(rnbuf);
     endpwent ();
   }
   else {
@@ -2608,31 +2241,25 @@ void mutt_init (int skip_sys_rc, LIST * commands)
       fputs (_("unable to determine username"), stderr);
       exit (1);
     }
-    Shell = m_strdup((p = getenv ("SHELL")) ? p : "/bin/sh");
   }
 
-  debug_start(Homedir);
-
   /* And about the host... */
   uname (&utsname);
   /* some systems report the FQDN instead of just the hostname */
   if ((p = strchr (utsname.nodename, '.'))) {
-    Hostname = str_substrdup (utsname.nodename, p);
+    Hostname = p_dupstr(utsname.nodename, p - utsname.nodename);
     p++;
     m_strcpy(buffer, sizeof(buffer), p);       /* save the domain for below */
   }
   else
     Hostname = m_strdup(utsname.nodename);
 
-#ifndef DOMAIN
-#define DOMAIN buffer
-  if (!p && getdnsdomainname (buffer, sizeof(buffer)) == -1)
+  if (!p && getdnsdomainname(buffer, sizeof(buffer)) == -1)
     Fqdn = m_strdup("@");
   else
-#endif /* DOMAIN */
-  if (*DOMAIN != '@') {
-    Fqdn = p_new(char, m_strlen(DOMAIN) + m_strlen(Hostname) + 2);
-    sprintf (Fqdn, "%s.%s", NONULL (Hostname), DOMAIN); /* __SPRINTF_CHECKED__ */
+  if (*buffer != '@') {
+    Fqdn = p_new(char, m_strlen(buffer) + m_strlen(Hostname) + 2);
+    sprintf (Fqdn, "%s.%s", NONULL(Hostname), buffer);
   }
   else
     Fqdn = m_strdup(NONULL (Hostname));
@@ -2651,7 +2278,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
         q++;
       *q = '\0';
       NewsServer = m_strdup(p);
-      fclose (f);
+      m_fclose(&f);
     }
   }
   if ((p = getenv ("NNTPSERVER")))
@@ -2682,15 +2309,6 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
   Tempdir = m_strdup((p = getenv ("TMPDIR")) ? p : "/tmp");
 
-  p = getenv ("VISUAL");
-  if (!p) {
-    p = getenv ("EDITOR");
-    if (!p)
-      p = "vi";
-  }
-  Editor = m_strdup(p);
-  Visual = m_strdup(p);
-
   if ((p = getenv ("REPLYTO")) != NULL) {
     BUFFER buf, token;
 
@@ -2708,9 +2326,8 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   if ((p = getenv ("EMAIL")) != NULL)
     From = rfc822_parse_adrlist (NULL, p);
 
-  mutt_set_langinfo_charset ();
-  mutt_set_charset (Charset);
-
+  charset_initialize();
+  mlua_initialize();
 
   /* Set standard defaults */
   hash_map (ConfigOptions, mutt_set_default, 0);
@@ -2718,15 +2335,6 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
   CurrentMenu = MENU_MAIN;
 
-
-#ifndef LOCALES_HACK
-  /* Do we have a locale definition? */
-  if (((p = getenv ("LC_ALL")) != NULL && p[0]) ||
-      ((p = getenv ("LANG")) != NULL && p[0]) ||
-      ((p = getenv ("LC_CTYPE")) != NULL && p[0]))
-    set_option (OPTLOCALES);
-#endif
-
 #ifdef HAVE_GETSID
   /* Unset suspend by default if we're the session leader */
   if (getsid (0) == getpid ())
@@ -2735,36 +2343,10 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
   mutt_init_history ();
 
-
-
-
-  /*
-   *
-   *                       BIG FAT WARNING
-   *
-   * When changing the code which looks for a configuration file,
-   * please also change the corresponding code in muttbug.sh.in.
-   *
-   *
-   */
-
-
-
-
   if (!Muttrc) {
-#if 0
-    snprintf (buffer, sizeof(buffer), "%s/.muttngrc-%s", NONULL (Homedir),
-              MUTT_VERSION);
-    if (access (buffer, F_OK) == -1)
-#endif
-      snprintf (buffer, sizeof(buffer), "%s/.muttngrc", NONULL (Homedir));
+      snprintf (buffer, sizeof(buffer), "%s/.madmuttrc", NONULL (Homedir));
     if (access (buffer, F_OK) == -1)
-#if 0
-      snprintf (buffer, sizeof(buffer), "%s/.muttng/muttngrc-%s",
-                NONULL (Homedir), MUTT_VERSION);
-    if (access (buffer, F_OK) == -1)
-#endif
-      snprintf (buffer, sizeof(buffer), "%s/.muttng/muttngrc",
+      snprintf (buffer, sizeof(buffer), "%s/.madmutt/madmuttrc",
                 NONULL (Homedir));
 
     default_rc = 1;
@@ -2782,15 +2364,15 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   /* Process the global rc file if it exists and the user hasn't explicity
      requested not to via "-n".  */
   if (!skip_sys_rc) {
-    snprintf (buffer, sizeof(buffer), "%s/Muttngrc-%s", SYSCONFDIR,
+    snprintf (buffer, sizeof(buffer), "%s/Madmuttrc-%s", SYSCONFDIR,
               MUTT_VERSION);
     if (access (buffer, F_OK) == -1)
-      snprintf (buffer, sizeof(buffer), "%s/Muttngrc", SYSCONFDIR);
+      snprintf (buffer, sizeof(buffer), "%s/Madmuttrc", SYSCONFDIR);
     if (access (buffer, F_OK) == -1)
-      snprintf (buffer, sizeof(buffer), "%s/Muttngrc-%s", PKGDATADIR,
+      snprintf (buffer, sizeof(buffer), "%s/Madmuttrc-%s", PKGDATADIR,
                 MUTT_VERSION);
     if (access (buffer, F_OK) == -1)
-      snprintf (buffer, sizeof(buffer), "%s/Muttngrc", PKGDATADIR);
+      snprintf (buffer, sizeof(buffer), "%s/Madmuttrc", PKGDATADIR);
     if (access (buffer, F_OK) != -1) {
       if (source_rc (buffer, &err) != 0) {
         fputs (err.data, stderr);
@@ -2817,26 +2399,33 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     exit (1);
   }
 
+  /* LUA {{{ */
+  snprintf(buffer, sizeof(buffer), "%s/.madmutt.lua", NONULL(Homedir));
+  if (access(buffer, F_OK) < 0)
+      snprintf(buffer, sizeof(buffer), "%s/.madmutt/cfg.lua", NONULL(Homedir));
+  if (!access(buffer, F_OK)) {
+      need_pause = mlua_wrap(mutt_error, mlua_dofile(buffer));
+  }
+  /* }}} */
+
   if (mutt_execute_commands (commands) != 0)
     need_pause = 1;
 
   /* warn about synonym variables */
-  if (!list_empty(Synonyms)) {
-    int i = 0;
+  if (Synonyms) {
+    syn_t *syn;
+
     fprintf (stderr, _("Warning: the following synonym variables were found:\n"));
-    for (i = 0; i < Synonyms->length; i++) {
-      struct option_t* newopt = NULL, *oldopt = NULL;
-      newopt = (struct option_t*) ((syn_t*) Synonyms->data[i])->n;
-      oldopt = (struct option_t*) ((syn_t*) Synonyms->data[i])->o;
-      fprintf (stderr, "$%s ($%s should be used) (%s:%d)\n",
-               oldopt ? NONULL (oldopt->option) : "",
-               newopt ? NONULL (newopt->option) : "",
-               NONULL(((syn_t*) Synonyms->data[i])->f),
-               ((syn_t*) Synonyms->data[i])->l);
+
+    for (syn = Synonyms; syn; syn = syn->next) {
+      fprintf(stderr, "$%s ($%s should be used) (%s:%d)\n",
+              syn->o ? NONULL(syn->o->option) : "",
+              syn->n ? NONULL(syn->n->option) : "",
+              NONULL(syn->f), syn->l);
     }
     fprintf (stderr, _("Warning: synonym variables are scheduled"
                        " for removal.\n"));
-    list_del (&Synonyms, syn_del);
+    syn_list_wipe(&Synonyms);
     need_pause = 1;
   }
 
@@ -2844,10 +2433,6 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     if (mutt_any_key_to_continue (NULL) == -1)
       mutt_exit (1);
   }
-
-#if 0
-  set_option (OPTWEED);         /* turn weeding on by default */
-#endif
 }
 
 int mutt_get_hook_type (const char *name)
@@ -2860,59 +2445,29 @@ int mutt_get_hook_type (const char *name)
   return 0;
 }
 
-/* compare two option_t*'s for sorting -t/-T output */
-static int opt_cmp (const void* a, const void* b) {
-  return (m_strcmp((*(struct option_t**) a)->option,
-                       (*(struct option_t**) b)->option));
-}
-
-/* callback for hash_map() to put all non-synonym vars into list */
-static void opt_sel_full (const char* key, void* data,
-                          unsigned long more) {
-  list2_t** l = (list2_t**) more;
-  struct option_t* option = (struct option_t*) data;
-
-  if (DTYPE (option->type) == DT_SYN)
-    return;
-  list_push_back (l, option);
-}
-
-/* callback for hash_map() to put all changed non-synonym vars into list */
-static void opt_sel_diff (const char* key, void* data,
-                          unsigned long more) {
-  list2_t** l = (list2_t**) more;
-  struct option_t* option = (struct option_t*) data;
-  char buf[LONG_STRING];
+/* dump out the value of all the variables we have */
+int mutt_dump_variables (int full) {
+    ssize_t i = 0;
 
-  if (DTYPE (option->type) == DT_SYN)
-    return;
+    /* get all non-synonyms into list... */
+    for (i = 0; MuttVars[i].option; i++) {
+        struct option_t *option = MuttVars + i;
+        char buf[LONG_STRING];
 
-  mutt_option_value (option->option, buf, sizeof(buf));
-  if (m_strcmp(buf, option->init) != 0)
-    list_push_back (l, option);
-}
+        if (DTYPE(option->type) == DT_SYN)
+            continue;
 
-/* dump out the value of all the variables we have */
-int mutt_dump_variables (int full) {
-  int i = 0;
-  char outbuf[STRING];
-  list2_t* tmp = NULL;
-  struct option_t* option = NULL;
+        if (!full) {
+            mutt_option_value(option->option, buf, sizeof(buf));
+            if (!m_strcmp(buf, option->init))
+                continue;
+        }
 
-  /* get all non-synonyms into list... */
-  hash_map (ConfigOptions, full ? opt_sel_full : opt_sel_diff,
-            (unsigned long) &tmp);
-
-  if (!list_empty(tmp)) {
-    /* ...and dump list sorted */
-    qsort (tmp->data, tmp->length, sizeof(void*), opt_cmp);
-    for (i = 0; i < tmp->length; i++) {
-      option = (struct option_t*) tmp->data[i];
-      FuncTable[DTYPE (option->type)].opt_to_string
-        (outbuf, sizeof(outbuf), option);
-      printf ("%s\n", outbuf);
+        printf("set ");
+        FuncTable[DTYPE(option->type)].opt_tostr(buf, sizeof(buf), option);
+        printf ("%s\n", buf);
     }
-  }
-  list_del (&tmp, NULL);
-  return 0;
+
+    printf ("\n# vi""m:set ft=muttrc:\n");
+    return 0;
 }