X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=323d5ac2b5653c06eef3079411dc12f2644618f4;hp=f86e4650fa33a0a92b5d4a905648f82583accac4;hb=dc726add2e8fe52be1f6859ea7cbe4651498eeb8;hpb=a8808601c98c76ec8344c8e4ba5a607d72c2805e

diff --git a/init.c b/init.c
index f86e465..323d5ac 100644
--- a/init.c
+++ b/init.c
@@ -10,94 +10,67 @@
  * please see the file GPL in the top level source directory.
  */
 
-#if HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#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-lib/lib-lib.h>
+
+#include <lib-lua/lib-lua.h>
+#include <lib-sys/unix.h>
+#include <lib-ui/lib-ui.h>
+#include <lib-ui/history.h>
+#include <lib-mx/mx.h>
 
 #include "mutt.h"
-#include "mutt_curses.h"
-#include "history.h"
 #include "keymap.h"
-#include "mbyte.h"
+#include "crypt.h"
 #include "charset.h"
 #include "thread.h"
-#include <lib-crypt/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;
+static hash_t *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 */
 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);
-static int check_dsn_notify (const char* option, unsigned long val,
-                             char* errbuf, size_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,80 +79,15 @@ 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 },
-#if defined (USE_LIBESMTP) && (defined (USE_SSL) || defined (USE_GNUTLS))
-  { "smtp_use_tls",             mutt_libesmtp_check_usetls },
-#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);
-
-/* 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);
-static int num_from_string   (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
-static int str_from_string   (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
-static int path_from_string  (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
-static int quad_from_string  (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
-static int sort_from_string  (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
-static int rx_from_string    (struct option_t* dst, const char* val,
-                              char* errbuf, size_t errlen);
-static int magic_from_string (struct option_t* dst, const char* val,
-                              char* errbuf, size_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);
-
-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);
-} FuncTable[] = {
-  { 0,          NULL,             NULL }, /* there's no DT_ type with 0 */
-  { DT_BOOL,    bool_to_string,   bool_from_string },
-  { DT_NUM,     num_to_string,    num_from_string },
-  { DT_STR,     str_to_string,    str_from_string },
-  { DT_PATH,    str_to_string,    path_from_string },
-  { DT_QUAD,    quad_to_string,   quad_from_string },
-  { DT_SORT,    sort_to_string,   sort_from_string },
-  { DT_RX,      rx_to_string,     rx_from_string },
-  { DT_MAGIC,   magic_to_string,  magic_from_string },
-  /* synonyms should be resolved already so we don't need this
-   * 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");
@@ -187,7 +95,7 @@ static void bool_to_string (char* dst, size_t dstlen,
 
 static int bool_from_string (struct option_t* dst, const char* val,
                              char* errbuf __attribute__ ((unused)),
-                             size_t errlen __attribute__ ((unused))) {
+                             ssize_t errlen __attribute__ ((unused))) {
   int flag = -1;
 
   if (!dst)
@@ -206,7 +114,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) ?
@@ -216,7 +124,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;
 
@@ -225,7 +133,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);
@@ -246,69 +154,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) {
-
-    ssize_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 = (char *) CurrentFolder;
-
-  } else
-    val = (char *) 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 __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
+                             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);
   }
@@ -321,7 +180,7 @@ static int path_from_string (struct option_t* dst, const char* val,
 }
 
 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);
 
@@ -332,25 +191,7 @@ static int str_from_string (struct option_t* dst, const char* val,
   return (1);
 }
 
-static int user_from_string (struct option_t* dst, const char* val,
-                             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 */
-  if (!dst)
-    return (1);
-  if (m_strlen((char*) dst->data) == 0)
-    dst->data = (unsigned long) m_strdup(val);
-  else {
-    char* s = (char*) dst->data;
-    m_strreplace(&s, val);
-  }
-  if (m_strlen(dst->init) == 0)
-    dst->init = m_strdup((char*) dst->data);
-  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,
@@ -358,7 +199,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 __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
+                             char* errbuf __attribute__ ((unused)), ssize_t errlen __attribute__ ((unused))) {
   int flag = -1;
 
   if (!dst)
@@ -379,7 +220,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;
@@ -399,7 +240,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)
@@ -412,7 +253,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,
@@ -420,10 +261,10 @@ 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;
+  int flags = 0, e = 0, neg = 0;
   char* s = NULL;
 
   if (!dst)
@@ -442,7 +283,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)
@@ -450,7 +291,7 @@ static int rx_from_string (struct option_t* dst, const char* val,
 
   s = (char*) val;
   if (m_strcmp(dst->option, "mask") == 0 && *s == '!') {
-    not = 1;
+    neg = 1;
     s++;
   }
 
@@ -470,7 +311,7 @@ static int rx_from_string (struct option_t* dst, const char* val,
 
   m_strreplace(&p->pattern, val);
   p->rx = rx;
-  p->not = not;
+  p->neg = neg;
 
   if (m_strcmp(dst->option, "reply_regexp") == 0)
     mutt_adjust_all_subjects ();
@@ -478,12 +319,11 @@ 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) {
     case M_MBOX:    s = "mbox"; break;
-    case M_MMDF:    s = "MMDF"; break;
     case M_MH:      s = "MH"; break;
     case M_MAILDIR: s = "Maildir"; break;
     default:        s = "unknown"; break;
@@ -492,15 +332,14 @@ static void magic_to_string (char* dst, size_t dstlen,
 }
 
 static int magic_from_string (struct option_t* dst, const char* val,
-                              char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
+                              char *errbuf, ssize_t errlen)
+{
   int flag = -1;
 
-  if (!dst || !val || !*val)
+  if (!dst || m_strisempty(val))
     return (0);
   if (ascii_strncasecmp (val, "mbox", 4) == 0)
     flag = M_MBOX;
-  else if (ascii_strncasecmp (val, "mmdf", 4) == 0)
-    flag = M_MMDF;
   else if (ascii_strncasecmp (val, "mh", 2) == 0)
     flag = M_MH;
   else if (ascii_strncasecmp (val, "maildir", 7) == 0)
@@ -514,40 +353,38 @@ static int magic_from_string (struct option_t* dst, const char* val,
 
 }
 
-static void addr_to_string (char* dst, size_t dstlen,
-                            struct option_t* option) {
-  char s[HUGE_STRING];
-  s[0] = '\0';
-  rfc822_write_address (s, sizeof(s), *((address_t**) option->data), 0);
-  snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (s));
-}
+static struct {
+  unsigned short type;
+  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 },
+  { DT_NUM,     num_to_string,    num_from_string },
+  { DT_STR,     str_to_string,    str_from_string },
+  { DT_PATH,    str_to_string,    path_from_string },
+  { DT_QUAD,    quad_to_string,   quad_from_string },
+  { DT_SORT,    sort_to_string,   sort_from_string },
+  { DT_RX,      rx_to_string,     rx_from_string },
+  { DT_MAGIC,   magic_to_string,  magic_from_string },
+};
 
-static int addr_from_string (struct option_t* dst, const char* val,
-                             char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
-  if (!dst)
-    return (0);
-  address_delete ((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);
@@ -559,28 +396,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;
@@ -605,479 +425,30 @@ int quadoption (int opt)
   return (QuadOptions[n] >> b) & 0x3;
 }
 
-int query_quadoption (int opt, const char *prompt)
+int query_quadoption2(int v, const char *prompt)
 {
-  int v = quadoption (opt);
-
   switch (v) {
   case M_YES:
   case M_NO:
     return (v);
 
   default:
-    v = mutt_yesorno (prompt, (v == M_ASKYES));
-    CLEARLINE (LINES - 1);
-    return (v);
+    return mutt_yesorno(prompt, (v == M_ASKYES));
   }
-
-  /* not reached */
 }
 
-static void add_to_list (LIST ** list, const char *str)
-{
-  LIST *t, *last = NULL;
-
-  /* don't add a NULL or empty string to the list */
-  if (!str || *str == '\0')
-    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;
-    }
-    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;
-  }
-}
-
-static int add_to_rx_list (list2_t** list, const char *s, int flags,
-                           BUFFER * err)
-{
-  rx_t* rx;
-  int i = 0;
-
-  if (!s || !*s)
-    return 0;
-
-  if (!(rx = rx_compile (s, flags))) {
-    snprintf (err->data, err->dsize, "Bad regexp: %s\n", s);
-    return -1;
-  }
-
-  i = rx_lookup ((*list), rx->pattern);
-  if (i >= 0)
-    rx_free (&rx);
-  else
-    list_push_back (list, rx);
-  return 0;
-}
-
-static int add_to_spam_list (SPAM_LIST ** 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;
-
-  if (!(rx = rx_compile (pat, REG_ICASE))) {
-    snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat);
-    return -1;
-  }
-
-  /* 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 (!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;
-    }
-    else
-      ++p;
-  }
-  t->nmatch++;                  /* match 0 is always the whole expr */
-
-  return 0;
-}
-
-static int remove_from_spam_list (SPAM_LIST ** 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;
-    }
-    else
-      spam = spam->next;
-  }
-
-  return nremoved;
-}
-
-
-static void remove_from_list (LIST ** 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;
-      }
-    }
-  }
-}
-
-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);
-    }
-  }
-  return (-1);
-}
-
-static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
-                        BUFFER * err)
-{
-  int i, j;
-  unsigned long 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 (!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);
-    }
-    p_delete(&token.data);
-  }
-  return 0;
-}
-
-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, "*"))
-      add_to_list (&UnIgnore, buf->data);
-
-    remove_from_list (&Ignore, buf->data);
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
-
-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));
-
-  return 0;
-}
-
-static int parse_list (BUFFER * buf, BUFFER * s,
-                       unsigned long data __attribute__ ((unused)),
-                       BUFFER * err __attribute__ ((unused)))
-{
-  do {
-    mutt_extract_token (buf, s, 0);
-    add_to_list ((LIST **) data, buf->data);
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
-
-static void _alternates_clean (void)
-{
-  int i;
-
-  if (Context && Context->msgcount) {
-    for (i = 0; i < Context->msgcount; i++)
-      Context->hdrs[i]->recip_valid = 0;
-  }
-}
-
-static int parse_alternates (BUFFER * buf, BUFFER * s,
-                             unsigned long data __attribute__ ((unused)),
-                             BUFFER * err __attribute__ ((unused)))
-{
-  _alternates_clean ();
-  do {
-    mutt_extract_token (buf, s, 0);
-    remove_from_rx_list (&UnAlternates, buf->data);
-
-    if (add_to_rx_list (&Alternates, buf->data, REG_ICASE, err) != 0)
-      return -1;
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
-
-static int parse_unalternates (BUFFER * buf, BUFFER * s,
-                               unsigned long data __attribute__ ((unused)),
-                               BUFFER * err __attribute__ ((unused)))
-{
-  _alternates_clean ();
-  do {
-    mutt_extract_token (buf, s, 0);
-    remove_from_rx_list (&Alternates, buf->data);
-
-    if (m_strcmp(buf->data, "*") &&
-        add_to_rx_list (&UnAlternates, buf->data, REG_ICASE, err) != 0)
-      return -1;
-
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
-
-static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data,
-                            BUFFER * err)
-{
-  BUFFER templ;
-
-  p_clear(&templ, 1);
-
-  /* Insist on at least one parameter */
-  if (!MoreArgs (s)) {
-    if (data == M_SPAM)
-      m_strcpy(err->data, err->dsize, _("spam: no matching pattern"));
-    else
-      m_strcpy(err->data, err->dsize, _("nospam: no matching pattern"));
-    return -1;
-  }
-
-  /* Extract the first token, a regexp */
-  mutt_extract_token (buf, s, 0);
-
-  /* data should be either M_SPAM or M_NOSPAM. M_SPAM is for spam commands. */
-  if (data == M_SPAM) {
-    /* If there's a second parameter, it's a template for the spam tag. */
-    if (MoreArgs (s)) {
-      mutt_extract_token (&templ, s, 0);
-
-      /* Add to the spam list. */
-      if (add_to_spam_list (&SpamList, buf->data, templ.data, err) != 0) {
-        p_delete(&templ.data);
-        return -1;
-      }
-      p_delete(&templ.data);
-    }
-
-    /* If not, try to remove from the nospam list. */
-    else {
-      remove_from_rx_list (&NoSpamList, buf->data);
-    }
-
-    return 0;
-  }
-
-  /* M_NOSPAM is for nospam commands. */
-  else if (data == M_NOSPAM) {
-    /* nospam only ever has one parameter. */
-
-    /* "*" is a special case. */
-    if (!m_strcmp(buf->data, "*")) {
-      mutt_free_spam_list (&SpamList);
-      list_del (&NoSpamList, (list_del_t*) rx_free);
-      return 0;
-    }
-
-    /* If it's on the spam list, just remove it. */
-    if (remove_from_spam_list (&SpamList, buf->data) != 0)
-      return 0;
-
-    /* Otherwise, add it to the nospam list. */
-    if (add_to_rx_list (&NoSpamList, buf->data, REG_ICASE, err) != 0)
-      return -1;
-
-    return 0;
-  }
-
-  /* This should not happen. */
-  m_strcpy(err->data, err->dsize, "This is no good at all.");
-  return -1;
-}
-
-static int parse_unlist (BUFFER * buf, BUFFER * s, unsigned long data,
-                         BUFFER * err __attribute__ ((unused)))
+int query_quadoption (int opt, const char *prompt)
 {
-  do {
-    mutt_extract_token (buf, s, 0);
-    /*
-     * Check for deletion of entire list
-     */
-    if (m_strcmp(buf->data, "*") == 0) {
-      mutt_free_list ((LIST **) data);
-      break;
-    }
-    remove_from_list ((LIST **) data, buf->data);
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
+  int v = quadoption (opt);
 
-static int parse_lists (BUFFER * buf, BUFFER * s,
-                        unsigned long data __attribute__ ((unused)),
-                        BUFFER * err)
-{
-  do {
-    mutt_extract_token (buf, s, 0);
-    remove_from_rx_list (&UnMailLists, buf->data);
+  switch (v) {
+  case M_YES:
+  case M_NO:
+    return (v);
 
-    if (add_to_rx_list (&MailLists, buf->data, REG_ICASE, err) != 0)
-      return -1;
+  default:
+    return mutt_yesorno(prompt, (v == M_ASKYES));
   }
-  while (MoreArgs (s));
-
-  return 0;
 }
 
 /* always wise to do what someone else did before */
@@ -1089,21 +460,18 @@ static void _attachments_clean (void) {
   }
 }
 
-static int parse_attach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
+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;
   }
 
@@ -1133,7 +501,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';
@@ -1143,10 +511,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) {
@@ -1162,10 +527,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,
+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;
@@ -1188,16 +553,12 @@ static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
     }
     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. */
+    /* We must do our own walk here because string_list_remove() will only
+     * 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);
 
@@ -1225,7 +586,7 @@ static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
   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,
@@ -1240,7 +601,7 @@ 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') {
@@ -1290,7 +651,7 @@ static int parse_attachments (BUFFER *buf, BUFFER *s,
 
 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') {
@@ -1324,221 +685,128 @@ static int parse_unattachments (BUFFER *buf, BUFFER *s, unsigned long data __att
   return parse_unattach_list(buf, s, listp, 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);
-    remove_from_rx_list (&SubscribedLists, buf->data);
-    remove_from_rx_list (&MailLists, buf->data);
-
-    if (m_strcmp(buf->data, "*") &&
-        add_to_rx_list (&UnMailLists, buf->data, REG_ICASE, err) != 0)
-      return -1;
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
-
-static int parse_subscribe (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
-                            BUFFER * err)
-{
-  do {
-    mutt_extract_token (buf, s, 0);
-    remove_from_rx_list (&UnMailLists, buf->data);
-    remove_from_rx_list (&UnSubscribedLists, buf->data);
-
-    if (add_to_rx_list (&MailLists, buf->data, REG_ICASE, err) != 0)
-      return -1;
-    if (add_to_rx_list (&SubscribedLists, buf->data, REG_ICASE, err) != 0)
-      return -1;
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
-
-static int parse_unsubscribe (BUFFER * buf, BUFFER * s,
-                              unsigned long data __attribute__ ((unused)),
-                              BUFFER * err __attribute__ ((unused)))
-{
-  do {
-    mutt_extract_token (buf, s, 0);
-    remove_from_rx_list (&SubscribedLists, buf->data);
-
-    if (m_strcmp(buf->data, "*") &&
-        add_to_rx_list (&UnSubscribedLists, buf->data, REG_ICASE, err) != 0)
-      return -1;
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
-
 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 = tmp;
-      }
-  }
-  while (MoreArgs (s));
-  return 0;
+
+        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;
+            }
+        }
+    } while (MoreArgs(s));
+
+    return 0;
 }
 
 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);
+    if (!MoreArgs (s)) {
+        m_strcpy(err->data, err->dsize, _("alias: no address"));
+        return (-1);
+    }
 
-  debug_print (2, ("first token is '%s'.\n", buf->data));
+    mutt_extract_token (buf, s, 0);
 
-  /* 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;
-  }
+    /* 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;
+    }
 
-  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 */
-    address_delete (&tmp->addr);
-    if (CurrentMenu == MENU_ALIAS)
-      set_option (OPTFORCEREDRAWINDEX);
-  }
+    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);
+    }
 
-  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;
-
-    /* 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 __attribute__ ((unused)),
-                BUFFER * err __attribute__ ((unused)))
+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 __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);
@@ -1561,11 +829,11 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data __attribut
       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;
@@ -1575,7 +843,7 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data __attribut
 
 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) {
@@ -1604,56 +872,21 @@ static void mutt_set_default(const char *name __attribute__ ((unused)), void* p,
     char buf[LONG_STRING];
     struct option_t *ptr = p;
 
-    if (DTYPE(ptr->type) == DT_SYN) {
-        if (!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));
-    if (m_strlen(ptr->init) == 0 && buf && *buf)
+    if (m_strlen(ptr->init) == 0 && *buf)
         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);
 
-  if (DTYPE(src->type) == DT_STR ||
-      DTYPE(src->type) == DT_PATH) {
+  if (DTYPE(src->type) == DT_STR || DTYPE(src->type) == DT_PATH) {
     /* only expand for string as it's the only place where
      * we want to expand vars right now */
     if (src->init && *src->init) {
@@ -1686,16 +919,11 @@ static void mutt_restore_default (const char* name __attribute__ ((unused)),
   struct option_t* ptr = (struct option_t*) p;
   char* init = NULL;
 
-  if (DTYPE (ptr->type) == DT_SYN) {
-    if (!more)
-      return;
-    ptr = hash_find (ConfigOptions, (char*) ptr->data);
-  }
   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);
@@ -1707,64 +935,16 @@ static void mutt_restore_default (const char* name __attribute__ ((unused)),
     p_delete(&init);
   }
 
-  if (ptr->flags & R_INDEX)
-    set_option (OPTFORCEREDRAWINDEX);
-  if (ptr->flags & R_PAGER)
-    set_option (OPTFORCEREDRAWPAGER);
-  if (ptr->flags & R_RESORT_SUB)
-    set_option (OPTSORTSUBTHREADS);
-  if (ptr->flags & R_RESORT)
-    set_option (OPTNEEDRESORT);
-  if (ptr->flags & R_RESORT_INIT)
-    set_option (OPTRESORTINIT);
-  if (ptr->flags & R_TREE)
-    set_option (OPTREDRAWTREE);
-}
-
-/* check whether value for $dsn_return would be valid */
-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 &&
-      m_strncmp(val, "full", 4) != 0) {
-    if (errbuf)
-      snprintf (errbuf, errlen, _("'%s' is invalid for $%s"), val, "dsn_return");
-    return (0);
-  }
-  return (1);
-}
-
-/* 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;
-  size_t i = 0;
-  int rc = 1;
-  char* val = (char*) p;
-
-  if (!val || !*val)
-    return (1);
-  list = list_from_str (val, ",");
-  if (list_empty (list))
-    return (1);
-
-  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;
-    }
-  list_del (&list, (list_del_t*)xmemfree);
-  return (rc);
+  set_option (OPTFORCEREDRAWINDEX);
+  set_option (OPTFORCEREDRAWPAGER);
+  set_option (OPTSORTSUBTHREADS);
+  set_option (OPTNEEDRESORT);
+  set_option (OPTRESORTINIT);
+  set_option (OPTREDRAWTREE);
 }
 
 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);
@@ -1773,21 +953,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 __attribute__ ((unused)), unsigned long p,
-                          char* errbuf, size_t errlen) {
+                          char* errbuf, ssize_t errlen) {
   if (!check_num ("history", p, errbuf, errlen))
     return (0);
   mutt_init_history ();
@@ -1795,7 +962,7 @@ static int check_history (const char* option __attribute__ ((unused)), unsigned
 }
 
 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++) {
@@ -1830,15 +997,6 @@ static const struct mapping_t* get_sortmap (struct option_t* option) {
   return (map);
 }
 
-#define CHECK_PAGER \
-  if ((CurrentMenu == MENU_PAGER) && \
-      (!option || (option->flags & R_RESORT))) \
-  { \
-    snprintf (err->data, err->dsize, \
-              _("Not available in this menu.")); \
-    return (-1); \
-  }
-
 static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
                       BUFFER * err)
 {
@@ -1871,26 +1029,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
 
     /* get the variable name */
     mutt_extract_token (tmp, s, M_TOKEN_EQUAL);
-
-    /* resolve synonyms */
-    if ((option = hash_find (ConfigOptions, tmp->data)) != NULL &&
-        DTYPE (option->type == DT_SYN)) {
-      struct option_t* newopt = hash_find (ConfigOptions, (char*) option->data);
-      syn_add (newopt, option);
-      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);
-      }
-    }
-
+    option = hash_find(ConfigOptions, tmp->data);
     if (!option && !(reset && m_strcmp("all", tmp->data) == 0)) {
       snprintf (err->data, err->dsize, _("%s: unknown variable"), tmp->data);
       return (-1);
@@ -1921,13 +1060,7 @@ 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);
       }
     }
@@ -1957,7 +1090,6 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         return 0;
       }
 
-      CHECK_PAGER;
       if (unset)
         unset_option (option->data);
       else if (inv)
@@ -1967,59 +1099,30 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
     }
     else if (DTYPE (option->type) == DT_STR ||
              DTYPE (option->type) == DT_PATH ||
-             DTYPE (option->type) == DT_ADDR ||
              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) {
+      if (DTYPE (option->type) == DT_STR || DTYPE (option->type) == DT_PATH) {
         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)
-            address_delete ((address_t **) option->data);
-          else if (DTYPE (option->type) == DT_USER)
-            /* to unset $user_ means remove */
-            hash_delete (ConfigOptions, option->option,
-                         option, del_option);
-          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);
+      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) {
 
@@ -2029,7 +1132,6 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       }
 
       if (*s->dptr == '=') {
-        CHECK_PAGER;
         s->dptr++;
         mutt_extract_token (tmp, s, 0);
         if (ascii_strcasecmp ("yes", tmp->data) == 0)
@@ -2063,18 +1165,12 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       break;
     }
 
-    if (option->flags & R_INDEX)
-      set_option (OPTFORCEREDRAWINDEX);
-    if (option->flags & R_PAGER)
-      set_option (OPTFORCEREDRAWPAGER);
-    if (option->flags & R_RESORT_SUB)
-      set_option (OPTSORTSUBTHREADS);
-    if (option->flags & R_RESORT)
-      set_option (OPTNEEDRESORT);
-    if (option->flags & R_RESORT_INIT)
-      set_option (OPTRESORTINIT);
-    if (option->flags & R_TREE)
-      set_option (OPTREDRAWTREE);
+    set_option (OPTFORCEREDRAWINDEX);
+    set_option (OPTFORCEREDRAWPAGER);
+    set_option (OPTSORTSUBTHREADS);
+    set_option (OPTNEEDRESORT);
+    set_option (OPTRESORTINIT);
+    set_option (OPTREDRAWTREE);
   }
   return (r);
 }
@@ -2090,24 +1186,22 @@ 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) {
-    conv = ConfigCharset && (*ConfigCharset) && Charset;
+  while ((linebuf = mutt_read_line(linebuf, &buflen, f, &line)) != NULL) {
+    conv = ConfigCharset && (*ConfigCharset) && mod_cset.charset;
     if (conv) {
       currentline = m_strdup(linebuf);
       if (!currentline)
         continue;
-      mutt_convert_string (&currentline, ConfigCharset, Charset, 0);
+      mutt_convert_string (&currentline, ConfigCharset, mod_cset.charset, 0);
     }
     else
       currentline = linebuf;
@@ -2132,7 +1226,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) {
@@ -2181,7 +1275,7 @@ static int parse_source (BUFFER * tmp, BUFFER * s,
 		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;
@@ -2192,8 +1286,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 == '#')
@@ -2256,7 +1348,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;
@@ -2274,8 +1366,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));
@@ -2323,8 +1415,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));
@@ -2361,8 +1453,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 */
@@ -2400,7 +1492,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;
@@ -2428,7 +1520,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';
@@ -2440,10 +1532,6 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
         if (DTYPE (option->type) == DT_PATH)
           mutt_pretty_mailbox (tmp);
       }
-      else if (DTYPE (option->type) == DT_ADDR) {
-        rfc822_write_address (tmp, sizeof(tmp),
-                              *((address_t **) option->data), 0);
-      }
       else if (DTYPE (option->type) == DT_QUAD)
         m_strcpy(tmp, sizeof(tmp), vals[quadoption(option->data)]);
       else if (DTYPE (option->type) == DT_NUM)
@@ -2477,12 +1565,9 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
           case M_MBOX:
             p = "mbox";
             break;
-          case M_MMDF:
-            p = "MMDF";
-            break;
           case M_MH:
             p = "MH";
-          break;
+            break;
           case M_MAILDIR:
             p = "Maildir";
             break;
@@ -2512,40 +1597,10 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
   return 0;
 }
 
-/* Implement the -Q command line flag */
-int mutt_query_variables (LIST * queries)
-{
-  LIST *p;
-
-  char errbuff[STRING];
-  char command[STRING];
-
-  BUFFER err, token;
-
-  p_clear(&err, 1);
-  p_clear(&token, 1);
-
-  err.data = errbuff;
-  err.dsize = sizeof(errbuff);
-
-  for (p = queries; p; p = p->next) {
-    snprintf (command, sizeof(command), "set ?%s\n", p->data);
-    if (mutt_parse_rc_line (command, &token, &err) == -1) {
-      fprintf (stderr, "%s\n", err.data);
-      p_delete(&token.data);
-      return 1;
-    }
-    printf ("%s\n", err.data);
-  }
-
-  p_delete(&token.data);
-  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;
@@ -2562,30 +1617,22 @@ 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 default_rc = 0, need_pause = 0;
-  unsigned int i;
+  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_new (sizeof(MuttVars) * 2, 0);
   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]);
   }
 
   /*
@@ -2594,115 +1641,21 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   snprintf (AttachmentMarker, sizeof(AttachmentMarker),
             "\033]9;%ld\a", (long) time (NULL));
 
-  /* on one of the systems I use, getcwd() does not return the same prefix
-     as is listed in the passwd file */
-  if ((p = getenv ("HOME")))
-    Homedir = m_strdup(p);
-
+  luaM_initialize();
   /* Get some information about the user */
   if ((pw = getpwuid (getuid ()))) {
     char rnbuf[STRING];
-
-    Username = m_strdup(pw->pw_name);
-    if (!Homedir)
-      Homedir = m_strdup(pw->pw_dir);
-
-    Realname = m_strdup(mutt_gecos_name (rnbuf, sizeof(rnbuf), pw));
-    Shell = m_strdup(pw->pw_shell);
-    endpwent ();
-  }
-  else {
-    if (!Homedir) {
-      mutt_endwin (NULL);
-      fputs (_("unable to determine home directory"), stderr);
-      exit (1);
-    }
-    if ((p = getenv ("USER")))
-      Username = m_strdup(p);
-    else {
-      mutt_endwin (NULL);
-      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 = p_dupstr(utsname.nodename, p - utsname.nodename);
-    p++;
-    m_strcpy(buffer, sizeof(buffer), p);       /* save the domain for below */
+    mutt_gecos_name(rnbuf, sizeof(rnbuf), pw, mod_core.gecos_mask);
+    Realname = m_strdup(rnbuf);
   }
-  else
-    Hostname = m_strdup(utsname.nodename);
-
-  if (!p && getdnsdomainname (buffer, sizeof(buffer)) == -1)
-    Fqdn = m_strdup("@");
-  else
-  if (*buffer != '@') {
-    Fqdn = p_new(char, m_strlen(buffer) + m_strlen(Hostname) + 2);
-    sprintf (Fqdn, "%s.%s", NONULL(Hostname), buffer); /* __SPRINTF_CHECKED__ */
-  }
-  else
-    Fqdn = m_strdup(NONULL (Hostname));
-
-#ifdef USE_NNTP
-  {
-    FILE *f;
-    char *q;
-
-    if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) {
-      buffer[0] = '\0';
-      fgets (buffer, sizeof(buffer), f);
-      p = vskipspaces(buffer);
-      q = (char*)p;
-      while (*q && !isspace(*q))
-        q++;
-      *q = '\0';
-      NewsServer = m_strdup(p);
-      fclose (f);
-    }
-  }
-  if ((p = getenv ("NNTPSERVER")))
-    NewsServer = m_strdup(p);
-#endif
 
-  if ((p = getenv ("MAIL")))
-    Spoolfile = m_strdup(p);
-  else if ((p = getenv ("MAILDIR")))
+  if ((p = getenv("MAIL") ?: getenv("MAILDIR"))) {
     Spoolfile = m_strdup(p);
-  else {
-#ifdef HOMESPOOL
-    mutt_concat_path(buffer, sizeof(buffer), NONULL(Homedir), MAILPATH);
-#else
-    mutt_concat_path(buffer, sizeof(buffer), MAILPATH, NONULL(Username));
-#endif
+  } else {
+    mutt_concat_path(buffer, sizeof(buffer), NONULL(mod_core.homedir), MAILPATH);
     Spoolfile = m_strdup(buffer);
   }
 
-  if ((p = getenv ("MAILCAPS")))
-    MailcapPath = m_strdup(p);
-  else {
-    /* Default search path from RFC1524 */
-    MailcapPath =
-      m_strdup("~/.mailcap:" PKGDATADIR "/mailcap:" SYSCONFDIR
-                   "/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap");
-  }
-
-  Tempdir = m_strdup((p = getenv ("TMPDIR")) ? p : "/tmp");
-
-  p = getenv ("VISUAL");
-  if (!p) {
-    p = getenv ("EDITOR");
-    if (!p)
-      p = "vi";
-  }
-  Editor = m_strdup(p);
-
   if ((p = getenv ("REPLYTO")) != NULL) {
     BUFFER buf, token;
 
@@ -2717,64 +1670,18 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     p_delete(&token.data);
   }
 
-  if ((p = getenv ("EMAIL")) != NULL)
-    From = rfc822_parse_adrlist (NULL, p);
-
-  mutt_set_langinfo_charset ();
-  mutt_set_charset (Charset);
-
-
   /* Set standard defaults */
   hash_map (ConfigOptions, mutt_set_default, 0);
   hash_map (ConfigOptions, mutt_restore_default, 0);
 
   CurrentMenu = MENU_MAIN;
-
-  /* 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);
-
-#ifdef HAVE_GETSID
-  /* Unset suspend by default if we're the session leader */
-  if (getsid (0) == getpid ())
-    unset_option (OPTSUSPEND);
-#endif
-
   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);
+      snprintf (buffer, sizeof(buffer), "%s/.madmuttrc", NONULL(mod_core.homedir));
     if (access (buffer, F_OK) == -1)
-#endif
-      snprintf (buffer, sizeof(buffer), "%s/.muttngrc", 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",
-                NONULL (Homedir));
+      snprintf (buffer, sizeof(buffer), "%s/.madmutt/madmuttrc",
+                NONULL(mod_core.homedir));
 
     default_rc = 1;
     Muttrc = m_strdup(buffer);
@@ -2785,21 +1692,19 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     mutt_expand_path (buffer, sizeof(buffer));
     Muttrc = m_strdup(buffer);
   }
-  p_delete(&AliasFile);
-  AliasFile = m_strdup(NONULL (Muttrc));
 
   /* 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);
@@ -2826,26 +1731,33 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     exit (1);
   }
 
+  /* LUA {{{ */
+  snprintf(buffer, sizeof(buffer), "%s/.madmutt.lua", NONULL(mod_core.homedir));
+  if (access(buffer, F_OK) < 0)
+      snprintf(buffer, sizeof(buffer), "%s/.madmutt/cfg.lua", NONULL(mod_core.homedir));
+  if (!access(buffer, F_OK)) {
+      need_pause = luaM_wrap(mutt_error, luaM_dofile(buffer));
+  }
+  /* }}} */
+
   if (mutt_execute_commands (commands) != 0)
     need_pause = 1;
 
   /* warn about synonym variables */
-  if (!list_empty(Synonyms)) {
-    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;
   }
 
@@ -2853,10 +1765,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)
@@ -2869,61 +1777,3 @@ 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 __attribute__ ((unused)),
-                          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 __attribute__ ((unused)),
-                          void* data,
-                          unsigned long more) {
-  list2_t** l = (list2_t**) more;
-  struct option_t* option = (struct option_t*) data;
-  char buf[LONG_STRING];
-
-  if (DTYPE (option->type) == DT_SYN)
-    return;
-
-  mutt_option_value (option->option, buf, sizeof(buf));
-  if (m_strcmp(buf, option->init) != 0)
-    list_push_back (l, option);
-}
-
-/* dump out the value of all the variables we have */
-int mutt_dump_variables (int full) {
-  size_t i = 0;
-  char outbuf[STRING];
-  list2_t* tmp = NULL;
-  struct option_t* option = NULL;
-
-  /* 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);
-    }
-  }
-  list_del (&tmp, NULL);
-  return 0;
-}