X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=40a488a5e4a64a22e89da5ea4d7b06fe7dde6e33;hp=3e34dc8a7f5b371e1709e9469af546f2df585dd1;hb=169f101dc43f0581d8c52bcf8131d9eecb7cdeb0;hpb=364bf52ada05bf7d7158dba9d2391f63b71258f6

diff --git a/init.c b/init.c
index 3e34dc8..40a488a 100644
--- a/init.c
+++ b/init.c
@@ -2,6 +2,9 @@
  * Copyright notice from original mutt:
  * Copyright (C) 1996-2002 Michael R. Elkins <me@mutt.org>
  *
+ * Parts were written/modified by:
+ * Rocco Rutte <pdmef@cs.tu-berlin.de>
+ *
  * This file is part of mutt-ng, see http://www.muttng.org/.
  * It's licensed under the GNU General Public License,
  * please see the file GPL in the top level source directory.
@@ -20,6 +23,7 @@
 #include "keymap.h"
 #include "mbyte.h"
 #include "charset.h"
+#include "thread.h"
 #include "mutt_crypt.h"
 #include "mutt_idna.h"
 
@@ -49,40 +53,499 @@
 #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);
+
+static HASH* ConfigOptions = NULL;
+
 /* for synonym warning reports: synonym found during parsing */
 typedef struct {
-  char* f;      /* file */
-  int l;        /* line */
-  int n;        /* new name (index) */
-  int o;        /* old name (index) */
+  char* f;              /* file */
+  int l;                /* line */
+  struct option_t* n;   /* new */
+  struct option_t* o;   /* old */
 } syn_t;
 
 /* for synonym warning reports: list of synonyms found */
-list2_t* Synonyms;
+static list2_t* Synonyms;
 /* for synonym warning reports: current rc file */
-char* CurRCFile = NULL;
+static const char* CurRCFile = NULL;
 /* for synonym warning reports: current rc line */
-int CurRCLine = 0;
+static int CurRCLine = 0;
 
 /* prototypes for checking for special vars */
-static int check_dsn_return (const char*);
-static int check_dsn_notify (const char*);
+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);
+/* 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
+
+/* use this to check only */
+static int check_special (const char* option, unsigned long val,
+                          char* errbuf, size_t errlen);
 
+/* variable <-> sanity check function mappings
+ * when changing these, make sure the proper _from_string handler
+ * does this checking!
+ */
 static struct {
   const char* name;
-  int (*check) (const char*);
+  int (*check) (const char* option, unsigned long val,
+                char* errbuf, size_t errlen);
 } SpecialVars[] = {
-  { "dsn_notify", check_dsn_notify },
-  { "dsn_return", check_dsn_return },
+  { "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 },
+  { "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,
+                            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) {
+  int flag = -1;
+
+  if (!dst)
+    return (0);
+  if (ascii_strncasecmp (val, "yes", 3) == 0)
+    flag = 1;
+  else if (ascii_strncasecmp (val, "no", 2) == 0)
+    flag = 0;
+
+  if (flag < 0)
+    return (0);
+  if (flag)
+    set_option (dst->data);
+  else
+    unset_option (dst->data);
+  return (0);
+}
+
+static void num_to_string (char* dst, size_t dstlen,
+                           struct option_t* option) {
+  /* XXX puke */
+  const char* fmt = (str_cmp (option->option, "umask") == 0) ? 
+                    "%s=%04o" : "%s=%d";
+  snprintf (dst, dstlen, fmt, option->option,
+            *((short*) option->data));
+}
+
+static int num_from_string (struct option_t* dst, const char* val,
+                            char* errbuf, size_t errlen) {
+  int num = 0, old = 0;
+  char* t = NULL;
+
+  if (!dst)
+    return (0);
+
+  num = strtol (val, &t, 0);
+
+  if (!*val || *t || (short) num != num) {
+    if (errbuf) {
+      snprintf (errbuf, errlen, _("'%s' is invalid for $%s"),
+                val, dst->option);
+    }
+    return (0);
+  }
+
+  /* just temporarily accept new val so that check_special for
+   * $history already has it when doing history's init() */
+  old = *((short*) dst->data);
+  *((short*) dst->data) = (short) num;
+
+  if (!check_special (dst->option, (unsigned long) num, errbuf, errlen)) {
+    *((short*) dst->data) = old;
+    return (0);
+  }
+
+  return (1);
+}
+
+static void str_to_string (char* dst, size_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 = mem_malloc (_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) {
+    if ((t = strrchr (CurrentFolder, '/')) != NULL)
+      val = t+1;
+    else
+      val = CurrentFolder;
+  } else
+    val = option->init;
+
+  snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (val));
+  if (clean)
+    mem_free (&val);
+}
+
+static int path_from_string (struct option_t* dst, const char* val,
+                             char* errbuf, size_t errlen) {
+  char path[_POSIX_PATH_MAX];
+
+  if (!dst)
+    return (0);
+
+  if (!val || !*val) {
+    mem_free ((char**) dst->data);
+    return (1);
+  }
+
+  path[0] = '\0';
+  strfcpy (path, val, sizeof (path));
+  mutt_expand_path (path, sizeof (path));
+  str_replace ((char **) dst->data, path);
+  return (1);
+}
+
+static int str_from_string (struct option_t* dst, const char* val,
+                            char* errbuf, size_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 (str_len ((char*) dst->data) == 0)
+    dst->data = (unsigned long) str_dup (val);
+  else {
+    char* s = (char*) dst->data;
+    str_replace (&s, val);
+  }
+  if (str_len (dst->init) == 0)
+    dst->init = str_dup ((char*) dst->data);
+  return (1);
+}
+
+static void quad_to_string (char* dst, size_t dstlen,
+                            struct option_t* option) {
+  char *vals[] = { "no", "yes", "ask-no", "ask-yes" };
+  snprintf (dst, dstlen, "%s=%s", option->option,
+            vals[quadoption (option->data)]);
+}
+
+static int quad_from_string (struct option_t* dst, const char* val,
+                             char* errbuf, size_t errlen) {
+  int flag = -1;
+
+  if (!dst)
+    return (0);
+  if (ascii_strncasecmp (val, "yes", 3) == 0)
+    flag = M_YES;
+  else if (ascii_strncasecmp (val, "no", 2) == 0)
+    flag = M_NO;
+  else if (ascii_strncasecmp (val, "ask-yes", 7) == 0)
+    flag = M_ASKYES;
+  else if (ascii_strncasecmp (val, "ask-no", 6) == 0)
+    flag = M_ASKNO;
+
+  if (flag < 0)
+    return (0);
+
+  set_quadoption (dst->data, flag);
+  return (1);
+}
+
+static void sort_to_string (char* dst, size_t dstlen,
+                            struct option_t* option) {
+  const struct mapping_t *map = get_sortmap (option);
+  char* p = NULL;
+
+  if (!map) {
+    snprintf (dst, sizeof (dst), "%s=unknown", option->option);
+    return;
+  }
+
+  p = mutt_getnamebyvalue (*((short *) option->data) & SORT_MASK,
+                           map);
+
+  snprintf (dst, dstlen, "%s=%s%s%s", option->option,
+            (*((short *) option->data) & SORT_REVERSE) ?
+            "reverse-" : "",
+            (*((short *) option->data) & SORT_LAST) ? "last-" :
+            "", NONULL (p));
+}
+
+static int sort_from_string (struct option_t* dst, const char* val,
+                             char* errbuf, size_t errlen) {
+  const struct mapping_t *map = NULL;
+  if (!(map = get_sortmap (dst))) {
+    if (errbuf)
+      snprintf (errbuf, errlen, _("%s: Unknown type."),
+                dst->option);
+    return (0);
+  }
+  if (parse_sort (dst, val, map, errbuf, errlen) == -1)
+    return (0);
+  return (1);
+}
+
+static void rx_to_string (char* dst, size_t dstlen,
+                          struct option_t* option) {
+  rx_t* p = (rx_t*) option->data;
+  snprintf (dst, dstlen, "%s=\"%s\"", option->option,
+            NONULL (p->pattern));
+}
+
+static int rx_from_string (struct option_t* dst, const char* val,
+                           char* errbuf, size_t errlen) {
+  rx_t* p = NULL;
+  regex_t* rx = NULL;
+  int flags = 0, e = 0, not = 0;
+  char* s = NULL;
+
+  if (!dst)
+    return (0);
+
+  if (option (OPTATTACHMSG) && !str_cmp (dst->option, "reply_regexp")) {
+    if (errbuf)
+      snprintf (errbuf, errlen,
+                "Operation not permitted when in attach-message mode.");
+    return (0);
+  }
+
+  if (!((rx_t*) dst->data))
+    *((rx_t**) dst->data) = mem_calloc (1, sizeof (rx_t));
+
+  p = (rx_t*) dst->data;
+
+  /* something to do? */
+  if (!val || !*val || (p->pattern && str_cmp (p->pattern, val) == 0))
+    return (1);
+
+  if (str_cmp (dst->option, "mask") != 0)
+    flags |= mutt_which_case (val);
+
+  s = (char*) val;
+  if (str_cmp (dst->option, "mask") == 0 && *s == '!') {
+    not = 1;
+    s++;
+  }
+
+  rx = mem_malloc (sizeof (regex_t));
+
+  if ((e = REGCOMP (rx, s, flags)) != 0) {
+    regerror (e, rx, errbuf, errlen);
+    regfree (rx);
+    mem_free (&rx);
+  }
+
+  if (p->pattern) {
+    regfree (p->rx);
+    mem_free (&p->rx);
+  }
+
+  str_replace (&p->pattern, val);
+  p->rx = rx;
+  p->not = not;
+
+  if (str_cmp (dst->option, "reply_regexp") == 0)
+    mutt_adjust_all_subjects ();
+
+  return (1);
+}
+
+static void magic_to_string (char* dst, size_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;
+  }
+  snprintf (dst, dstlen, "%s=%s", option->option, s);
+}
+
+static int magic_from_string (struct option_t* dst, const char* val,
+                              char* errbuf, size_t errlen) {
+  int flag = -1;
+
+  if (!dst || !val || !*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)
+    flag = M_MAILDIR;
+
+  if (flag < 0)
+    return (0);
+
+  *((short*) dst->data) = flag;
+  return (1);
+
+}
+
+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**) 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) {
+  if (!dst || !val || !*val)
+    return (0);
+  rfc822_free_address ((ADDRESS**) dst->data);
+  *((ADDRESS**) dst->data) = rfc822_parse_adrlist (NULL, val);
+  return (1);
+}
+
+int mutt_option_value (const char* val, char* dst, size_t dstlen) {
+  struct option_t* option = NULL;
+  char* tmp = NULL, *t = NULL;
+  size_t l = 0;
+
+  if (!(option = hash_find (ConfigOptions, val))) {
+    debug_print (1, ("var '%s' not found\n", val));
+    *dst = '\0';
+    return (0);
+  }
+  tmp = mem_malloc (dstlen+1);
+  FuncTable[DTYPE (option->type)].opt_to_string (tmp, dstlen, option);
+
+  /* as we get things of type $var=value and don't want to bloat the
+   * above "just" for expansion, we do the stripping here */
+  debug_print (1, ("orig == '%s'\n", tmp));
+  t = strchr (tmp, '=');
+  t++;
+  l = str_len (t);
+  if (l >= 2) {
+    if (t[l-1] == '"' && *t == '"') {
+      t[l-1] = '\0';
+      t++;
+    }
+  }
+  memcpy (dst, t, l+1);
+  mem_free (&tmp);
+  debug_print (1, ("stripped == '%s'\n", dst));
+
+  return (1);
+}
+
 /* for synonym warning reports: adds synonym to end of list */
-static void syn_add (int n, int o) {
+static void syn_add (struct option_t* n, struct option_t* o) {
   syn_t* tmp = mem_malloc (sizeof (syn_t));
   tmp->f = str_dup (CurRCFile);
   tmp->l = CurRCLine;
@@ -140,22 +603,6 @@ int query_quadoption (int opt, const char *prompt)
   /* not reached */
 }
 
-/* given the variable ``s'', return the index into the rc_vars array which
-   matches, or -1 if the variable is not found.  */
-int mutt_option_index (char *s)
-{
-  int i;
-
-  for (i = 0; MuttVars[i].option; i++)
-    if (str_cmp (s, MuttVars[i].option) == 0) {
-      if (MuttVars[i].type == DT_SYN)
-        syn_add (mutt_option_index ((char *) MuttVars[i].data), i);
-      return (MuttVars[i].type ==
-              DT_SYN ? mutt_option_index ((char *) MuttVars[i].data) : i);
-    }
-  return (-1);
-}
-
 static void add_to_list (LIST ** list, const char *str)
 {
   LIST *t, *last = NULL;
@@ -360,12 +807,15 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
 {
   int i, j, res = 0;
   BUFFER token;
+  struct option_t* option = NULL;
 
   memset (&token, 0, sizeof (token));
   mutt_extract_token (tmp, s, 0);
 
   /* is the item defined as a variable or a function? */
-  if (!(res = (mutt_option_index (tmp->data) != -1)))
+  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);
 
@@ -379,24 +829,18 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
           break;
         }
     }
+  }
   /* check for feature_* */
-  if (!res) {
-    char *p = NULL;
-
+  if (!res && ascii_strncasecmp (tmp->data, "feature_", 8) == 0 &&
+      (j = str_len (tmp->data)) > 8) {
     i = 0;
-    j = str_len (tmp->data);
-    /* need at least input of 'feature_X' */
-    if (j >= 7) {
-      p = tmp->data + 7;
-      j -= 7;
-      while (Features[i].name) {
-        if (str_len (Features[i].name) == j &&
-            ascii_strncasecmp (Features[i].name, p, j)) {
-          res = 1;
-          break;
-        }
-        i++;
+    while (Features[i]) {
+      if (str_len (Features[i]) == j-8 &&
+          ascii_strncasecmp (Features[i], tmp->data+8, j-8) == 0) {
+        res = 1;
+        break;
       }
+      i++;
     }
   }
 
@@ -407,9 +851,10 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
       snprintf (err->data, err->dsize, _("ifndef: too few arguments"));
     return (-1);
   }
+
   mutt_extract_token (tmp, s, M_TOKEN_SPACE);
 
-  if ((data && res) || (!data && !res)) {
+  if (data == res) {
     if (mutt_parse_rc_line (tmp->data, &token, err) == -1) {
       mutt_error ("Error: %s", err->data);
       mem_free (&token.data);
@@ -851,9 +1296,8 @@ static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data,
 }
 
 static int
-parse_sort (short *val, const char *s, const struct mapping_t *map,
-            BUFFER * err)
-{
+parse_sort (struct option_t* dst, const char *s, const struct mapping_t *map,
+            char* errbuf, size_t errlen) {
   int i, flags = 0;
 
   if (str_ncmp ("reverse-", s, 8) == 0) {
@@ -867,148 +1311,116 @@ parse_sort (short *val, const char *s, const struct mapping_t *map,
   }
 
   if ((i = mutt_getvaluebyname (s, map)) == -1) {
-    snprintf (err->data, err->dsize, _("%s: unknown sorting method"), s);
+    if (errbuf)
+      snprintf (errbuf, errlen, _("'%s' is invalid for $%s"), s, dst->option);
     return (-1);
   }
 
-  *val = i | flags;
-
+  *((short*) dst->data) = i | flags;
   return 0;
 }
 
-static void mutt_set_default (struct option_t *p)
-{
-  switch (p->type & DT_MASK) {
-  case DT_STR:
-    if (!p->init && *((char **) p->data))
-      p->init = (unsigned long) str_dup (*((char **) p->data));
-    break;
-  case DT_PATH:
-    if (!p->init && *((char **) p->data)) {
-      char *cp = str_dup (*((char **) p->data));
+/* if additional data more == 1, we want to resolve synonyms */
+static void mutt_set_default (const char* name, void* p, unsigned long more) {
+  char buf[LONG_STRING];
+  struct option_t* ptr = (struct option_t*) p;
 
-      /* mutt_pretty_mailbox (cp); */
-      p->init = (unsigned long) cp;
-    }
-    break;
-  case DT_ADDR:
-    if (!p->init && *((ADDRESS **) p->data)) {
-      char tmp[HUGE_STRING];
+  if (DTYPE (ptr->type) == DT_SYN) {
+    if (!more)
+      return;
+    ptr = hash_find (ConfigOptions, (char*) ptr->data);
+  }
+  if (!ptr || *ptr->init || !FuncTable[DTYPE (ptr->type)].opt_from_string)
+    return;
+  mutt_option_value (ptr->option, buf, sizeof (buf));
+  if (str_len (ptr->init) == 0 && buf && *buf)
+    ptr->init = str_dup (buf);
+}
 
-      *tmp = '\0';
-      rfc822_write_address (tmp, sizeof (tmp), *((ADDRESS **) p->data), 0);
-      p->init = (unsigned long) str_dup (tmp);
-    }
-    break;
-  case DT_RX:
-    {
-      rx_t* pp = (rx_t*) p->data;
+static struct option_t* add_option (const char* name, const char* init,
+                                    short type, short dup) {
+  struct option_t* option = mem_calloc (1, sizeof (struct option_t));
 
-      if (!p->init && pp->pattern)
-        p->init = (unsigned long) str_dup (pp->pattern);
-      break;
-    }
-  }
+  debug_print (1, ("adding $%s\n", name));
+
+  option->option = str_dup (name);
+  option->type = type;
+  if (init)
+    option->init = dup ? str_dup (init) : (char*) init;
+  return (option);
 }
 
-static void mutt_restore_default (struct option_t *p)
-{
-  switch (p->type & DT_MASK) {
-  case DT_STR:
-    if (p->init)
-      str_replace ((char **) p->data, (char *) p->init);
-    break;
-  case DT_PATH:
-    if (p->init) {
-      char path[_POSIX_PATH_MAX];
+/* 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));
+}
 
-      strfcpy (path, (char *) p->init, sizeof (path));
-      mutt_expand_path (path, sizeof (path));
-      str_replace ((char **) p->data, path);
-    }
-    break;
-  case DT_ADDR:
-    if (p->init) {
-      rfc822_free_address ((ADDRESS **) p->data);
-      *((ADDRESS **) p->data) = rfc822_parse_adrlist (NULL, (char *) p->init);
-    }
-    break;
-  case DT_BOOL:
-    if (p->init)
-      set_option (p->data);
-    else
-      unset_option (p->data);
-    break;
-  case DT_QUAD:
-    set_quadoption (p->data, p->init);
-    break;
-  case DT_NUM:
-  case DT_SORT:
-  case DT_MAGIC:
-    *((short *) p->data) = p->init;
-    break;
-  case DT_RX:
-    {
-      rx_t *pp = (rx_t *) p->data;
-      int flags = 0;
-
-      mem_free (&pp->pattern);
-      if (pp->rx) {
-        regfree (pp->rx);
-        mem_free (&pp->rx);
-      }
+/* 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)));
+  mem_free (&ptr->option);
+  mem_free (&s);
+  mem_free (&ptr->init);
+  mem_free (&ptr);
+}
 
-      if (p->init) {
-        char *s = (char *) p->init;
+/* if additional data more == 1, we want to resolve synonyms */
+static void mutt_restore_default (const char* name, void* p,
+                                  unsigned long more) {
+  char errbuf[STRING];
+  struct option_t* ptr = (struct option_t*) p;
 
-        pp->rx = mem_calloc (1, sizeof (regex_t));
-        if (str_cmp (p->option, "mask") != 0)
-          flags |= mutt_which_case ((const char *) p->init);
-        if (str_cmp (p->option, "mask") == 0 && *s == '!') {
-          s++;
-          pp->not = 1;
-        }
-        if (REGCOMP (pp->rx, s, flags) != 0) {
-          fprintf (stderr,
-                   _("mutt_restore_default(%s): error in regexp: %s\n"),
-                   p->option, pp->pattern);
-          mem_free (&pp->pattern);
-          regfree (pp->rx);
-          mem_free (&pp->rx);
-        }
-        else
-          str_replace (&pp->pattern, (char *) p->init);
-      }
-    }
-    break;
+  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 &&
+      FuncTable[DTYPE (ptr->type)].opt_from_string (ptr, ptr->init, errbuf,
+                                                    sizeof (errbuf)) < 0) {
+    mutt_endwin (NULL);
+    fprintf (stderr, _("Invalid default setting found. Please report this "
+                       "error:\n\"%s\"\n"), errbuf);
+    exit (1);
   }
 
-  if (p->flags & R_INDEX)
+  if (ptr->flags & R_INDEX)
     set_option (OPTFORCEREDRAWINDEX);
-  if (p->flags & R_PAGER)
+  if (ptr->flags & R_PAGER)
     set_option (OPTFORCEREDRAWPAGER);
-  if (p->flags & R_RESORT_SUB)
+  if (ptr->flags & R_RESORT_SUB)
     set_option (OPTSORTSUBTHREADS);
-  if (p->flags & R_RESORT)
+  if (ptr->flags & R_RESORT)
     set_option (OPTNEEDRESORT);
-  if (p->flags & R_RESORT_INIT)
+  if (ptr->flags & R_RESORT_INIT)
     set_option (OPTRESORTINIT);
-  if (p->flags & R_TREE)
+  if (ptr->flags & R_TREE)
     set_option (OPTREDRAWTREE);
 }
 
 /* check whether value for $dsn_return would be valid */
-static int check_dsn_return (const char* val) {
+static int check_dsn_return (const char* option, unsigned long p,
+                             char* errbuf, size_t errlen) {
+  char* val = (char*) p;
   if (val && *val && str_ncmp (val, "hdrs", 4) != 0 &&
-      str_ncmp (val, "full", 4) != 0)
+      str_ncmp (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* val) {
+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);
@@ -1021,6 +1433,9 @@ static int check_dsn_notify (const char* val) {
         str_ncmp (list->data[i], "failure", 7) != 0 &&
         str_ncmp (list->data[i], "delay", 5) != 0 &&
         str_ncmp (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;
     }
@@ -1028,21 +1443,79 @@ static int check_dsn_notify (const char* val) {
   return (rc);
 }
 
-static int check_special (const char* name, const char* val) {
+static int check_num (const char* option, unsigned long p,
+                      char* errbuf, size_t errlen) {
+  if ((int) p < 0) {
+    if (errbuf)
+      snprintf (errbuf, errlen, _("'%d' is invalid for $%s"), (int) p, option);
+    return (0);
+  }
+  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) {
+  if (!check_num ("history", p, errbuf, errlen))
+    return (0);
+  mutt_init_history ();
+  return (1);
+}
+
+static int check_special (const char* name, unsigned long val,
+                          char* errbuf, size_t errlen) {
   int i = 0;
 
   for (i = 0; SpecialVars[i].name; i++) {
-    if (str_cmp (SpecialVars[i].name, name) == 0)
-      return (SpecialVars[i].check (val));
+    if (str_cmp (SpecialVars[i].name, name) == 0) {
+      return (SpecialVars[i].check (SpecialVars[i].name,
+                                    val, errbuf, errlen));
+    }
   }
   return (1);
 }
 
+static const struct mapping_t* get_sortmap (struct option_t* option) {
+  const struct mapping_t* map = NULL;
+
+  switch (option->type & DT_SUBTYPE_MASK) {
+  case DT_SORT_ALIAS:
+    map = SortAliasMethods;
+    break;
+  case DT_SORT_BROWSER:
+    map = SortBrowserMethods;
+    break;
+  case DT_SORT_KEYS:
+    if ((WithCrypto & APPLICATION_PGP))
+      map = SortKeyMethods;
+    break;
+  case DT_SORT_AUX:
+    map = SortAuxMethods;
+    break;
+  default:
+    map = SortMethods;
+    break;
+  }
+  return (map);
+}
+
 static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
                       BUFFER * err)
 {
-  int idx, query, unset, inv, reset, r = 0;
-  char *p, scratch[_POSIX_PATH_MAX];
+  int query, unset, inv, reset, r = 0;
+  struct option_t* option = NULL;
 
   while (MoreArgs (s)) {
     /* reset state variables */
@@ -1071,8 +1544,26 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
     /* get the variable name */
     mutt_extract_token (tmp, s, M_TOKEN_EQUAL);
 
-    if ((idx = mutt_option_index (tmp->data)) == -1 &&
-        !(reset && !str_cmp ("all", tmp->data))) {
+    /* 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);
+      }
+    }
+
+    if (!option && !(reset && str_cmp ("all", tmp->data) == 0)) {
       snprintf (err->data, err->dsize, _("%s: unknown variable"), tmp->data);
       return (-1);
     }
@@ -1090,14 +1581,19 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       }
 
       if (!str_cmp ("all", tmp->data)) {
-        for (idx = 0; MuttVars[idx].option; idx++)
-          mutt_restore_default (&MuttVars[idx]);
-        return 0;
+        hash_map (ConfigOptions, mutt_restore_default, 1);
+        return (0);
       }
-      else
-        mutt_restore_default (&MuttVars[idx]);
+      else if (!FuncTable[DTYPE (option->type)].opt_from_string) {
+        snprintf (err->data, err->dsize, _("$%s is read-only"), option->option);
+        r = -1;
+        break;
+      } else
+        mutt_restore_default (NULL, option, 1);
     }
-    else if (DTYPE (MuttVars[idx].type) == DT_BOOL) {
+    else if (DTYPE (option->type) == DT_BOOL) {
+      /* XXX this currently ignores the function table
+       * as we don't get invert and stuff into it */
       if (s && *s->dptr == '=') {
         if (unset || inv || query) {
           snprintf (err->data, err->dsize, "Usage: set variable=yes|no");
@@ -1117,233 +1613,75 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       }
 
       if (query) {
-        snprintf (err->data, err->dsize, option (MuttVars[idx].data)
-                  ? _("%s is set") : _("%s is unset"), tmp->data);
+        bool_to_string (err->data, err->dsize, option);
         return 0;
       }
 
       if (unset)
-        unset_option (MuttVars[idx].data);
+        unset_option (option->data);
       else if (inv)
-        toggle_option (MuttVars[idx].data);
+        toggle_option (option->data);
       else
-        set_option (MuttVars[idx].data);
+        set_option (option->data);
     }
-    else if (DTYPE (MuttVars[idx].type) == DT_STR ||
-             DTYPE (MuttVars[idx].type) == DT_PATH ||
-             DTYPE (MuttVars[idx].type) == DT_ADDR) {
-      if (unset) {
-        if (DTYPE (MuttVars[idx].type) == DT_ADDR)
-          rfc822_free_address ((ADDRESS **) MuttVars[idx].data);
-        else
-          mem_free ((void *) MuttVars[idx].data);
-      }
-      else if (query || *s->dptr != '=') {
-        char _tmp[STRING];
-        char *val = NULL;
-
-        if (DTYPE (MuttVars[idx].type) == DT_ADDR) {
-          _tmp[0] = '\0';
-          rfc822_write_address (_tmp, sizeof (_tmp),
-                                *((ADDRESS **) MuttVars[idx].data), 0);
-          val = _tmp;
-        }
-        else
-          val = *((char **) MuttVars[idx].data);
-
-        /* user requested the value of this variable */
-        snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option,
-                  NONULL (val));
-        break;
-      }
-      else {
-        s->dptr++;
-
-        /* copy the value of the string */
-        if (DTYPE (MuttVars[idx].type) == DT_ADDR)
-          rfc822_free_address ((ADDRESS **) MuttVars[idx].data);
-        else
-          mem_free ((void *) MuttVars[idx].data);
-
-        mutt_extract_token (tmp, s, 0);
-        if (DTYPE (MuttVars[idx].type) == DT_PATH) {
-          strfcpy (scratch, tmp->data, sizeof (scratch));
-          mutt_expand_path (scratch, sizeof (scratch));
-          *((char **) MuttVars[idx].data) = str_dup (scratch);
-        }
-        else if (DTYPE (MuttVars[idx].type) == DT_STR) {
-          /* see if the value may only be a certain value... */
-          if (check_special (MuttVars[idx].option, tmp->data)) {
-            *((char **) MuttVars[idx].data) = str_dup (tmp->data);
-            if (str_cmp (MuttVars[idx].option, "charset") == 0)
-              mutt_set_charset (Charset);
-          } else {
-            /* ... and abort if it fails */
-            snprintf (err->data, err->dsize, "'%s' is invalid for $%s",
-                      tmp->data, MuttVars[idx].option);
-            return (-1);
-          }
-        }
-        else {
-          *((ADDRESS **) MuttVars[idx].data) =
-            rfc822_parse_adrlist (NULL, tmp->data);
-        }
-      }
-    }
-    else if (DTYPE (MuttVars[idx].type) == DT_RX) {
-      rx_t *ptr = (rx_t *) MuttVars[idx].data;
-      regex_t *rx;
-      int e, flags = 0;
-
-      if (query || *s->dptr != '=') {
-        /* user requested the value of this variable */
-        snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option,
-                  NONULL (ptr->pattern));
-        break;
-      }
-
-      if (option (OPTATTACHMSG)
-          && !str_cmp (MuttVars[idx].option, "reply_regexp")) {
-        snprintf (err->data, err->dsize,
-                  "Operation not permitted when in attach-message mode.");
-        r = -1;
-        break;
-      }
-
-      s->dptr++;
-
-      /* copy the value of the string */
-      mutt_extract_token (tmp, s, 0);
-
-      if (!ptr->pattern || str_cmp (ptr->pattern, tmp->data) != 0) {
-        int not = 0;
-
-        /* $mask is case-sensitive */
-        if (str_cmp (MuttVars[idx].option, "mask") != 0)
-          flags |= mutt_which_case (tmp->data);
-
-        p = tmp->data;
-        if (str_cmp (MuttVars[idx].option, "mask") == 0) {
-          if (*p == '!') {
-            not = 1;
-            p++;
-          }
-        }
-
-        rx = (regex_t *) mem_malloc (sizeof (regex_t));
-        if ((e = REGCOMP (rx, p, flags)) != 0) {
-          regerror (e, rx, err->data, err->dsize);
-          regfree (rx);
-          mem_free (&rx);
-          break;
-        }
-
-        /* get here only if everything went smootly */
-        if (ptr->pattern) {
-          mem_free (&ptr->pattern);
-          regfree ((regex_t *) ptr->rx);
-          mem_free (&ptr->rx);
-        }
-
-        ptr->pattern = str_dup (tmp->data);
-        ptr->rx = rx;
-        ptr->not = not;
-
-        /* $reply_regexp and $alterantes require special treatment */
-
-        if (Context && Context->msgcount &&
-            str_cmp (MuttVars[idx].option, "reply_regexp") == 0) {
-          regmatch_t pmatch[1];
-          int i;
-
-#define CUR_ENV Context->hdrs[i]->env
-          for (i = 0; i < Context->msgcount; i++) {
-            if (CUR_ENV && CUR_ENV->subject) {
-              CUR_ENV->real_subj = (regexec (ReplyRegexp.rx,
-                                             CUR_ENV->subject, 1, pmatch,
-                                             0)) ? CUR_ENV->
-                subject : CUR_ENV->subject + pmatch[0].rm_eo;
-            }
-          }
-#undef CUR_ENV
-        }
-      }
-    }
-    else if (DTYPE (MuttVars[idx].type) == DT_MAGIC) {
-      if (query || *s->dptr != '=') {
-        switch (DefaultMagic) {
-        case M_MBOX:
-          p = "mbox";
-          break;
-        case M_MMDF:
-          p = "MMDF";
-          break;
-        case M_MH:
-          p = "MH";
-          break;
-        case M_MAILDIR:
-          p = "Maildir";
-          break;
-        default:
-          p = "unknown";
+    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) {
+
+      /* 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 (unset) {
+          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 **) option->data);
+          else if (DTYPE (option->type) == DT_USER)
+            /* to unset $user_ means remove */
+            hash_delete (ConfigOptions, option->option,
+                         option, del_option);
+          else
+            mem_free ((void *) option->data);
           break;
         }
-        snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option, p);
-        break;
       }
 
-      s->dptr++;
-
-      /* copy the value of the string */
-      mutt_extract_token (tmp, s, 0);
-      if (mx_set_magic (tmp->data)) {
-        snprintf (err->data, err->dsize, _("%s: invalid mailbox type"),
-                  tmp->data);
-        r = -1;
-        break;
-      }
-    }
-    else if (DTYPE (MuttVars[idx].type) == DT_NUM) {
-      short *ptr = (short *) MuttVars[idx].data;
-      int val;
-      char *t;
-
       if (query || *s->dptr != '=') {
-        /* user requested the value of this variable */
-        snprintf (err->data, err->dsize, "%s=%d", MuttVars[idx].option, *ptr);
+        FuncTable[DTYPE (option->type)].opt_to_string
+          (err->data, err->dsize, option);
         break;
       }
 
-      s->dptr++;
-
-      mutt_extract_token (tmp, s, 0);
-      val = strtol (tmp->data, &t, 0);
-
-      if (!*tmp->data || *t || (short) val != val) {
-        snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data);
+      /* 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);
         r = -1;
         break;
-      }
-      else
-        *ptr = (short) val;
-
-      /* these ones need a sanity check */
-      if (str_cmp (MuttVars[idx].option, "history") == 0) {
-        if (*ptr < 0)
-          *ptr = 0;
-        mutt_init_history ();
-      }
-      else if (str_cmp (MuttVars[idx].option, "pager_index_lines") == 0) {
-        if (*ptr < 0)
-          *ptr = 0;
+      } else {
+        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 (MuttVars[idx].type) == DT_QUAD) {
-      if (query) {
-        char *vals[] = { "no", "yes", "ask-no", "ask-yes" };
+    else if (DTYPE (option->type) == DT_QUAD) {
 
-        snprintf (err->data, err->dsize, "%s=%s", MuttVars[idx].option,
-                  vals[quadoption (MuttVars[idx].data)]);
+      if (query) {
+        quad_to_string (err->data, err->dsize, option);
         break;
       }
 
@@ -1351,96 +1689,47 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         s->dptr++;
         mutt_extract_token (tmp, s, 0);
         if (ascii_strcasecmp ("yes", tmp->data) == 0)
-          set_quadoption (MuttVars[idx].data, M_YES);
+          set_quadoption (option->data, M_YES);
         else if (ascii_strcasecmp ("no", tmp->data) == 0)
-          set_quadoption (MuttVars[idx].data, M_NO);
+          set_quadoption (option->data, M_NO);
         else if (ascii_strcasecmp ("ask-yes", tmp->data) == 0)
-          set_quadoption (MuttVars[idx].data, M_ASKYES);
+          set_quadoption (option->data, M_ASKYES);
         else if (ascii_strcasecmp ("ask-no", tmp->data) == 0)
-          set_quadoption (MuttVars[idx].data, M_ASKNO);
+          set_quadoption (option->data, M_ASKNO);
         else {
-          snprintf (err->data, err->dsize, _("%s: invalid value"), tmp->data);
+          snprintf (err->data, err->dsize, _("'%s' is invalid for $%s\n"),
+                    tmp->data, option->option);
           r = -1;
           break;
         }
       }
       else {
         if (inv)
-          toggle_quadoption (MuttVars[idx].data);
+          toggle_quadoption (option->data);
         else if (unset)
-          set_quadoption (MuttVars[idx].data, M_NO);
+          set_quadoption (option->data, M_NO);
         else
-          set_quadoption (MuttVars[idx].data, M_YES);
-      }
-    }
-    else if (DTYPE (MuttVars[idx].type) == DT_SORT) {
-      const struct mapping_t *map = NULL;
-
-      switch (MuttVars[idx].type & DT_SUBTYPE_MASK) {
-      case DT_SORT_ALIAS:
-        map = SortAliasMethods;
-        break;
-      case DT_SORT_BROWSER:
-        map = SortBrowserMethods;
-        break;
-      case DT_SORT_KEYS:
-        if ((WithCrypto & APPLICATION_PGP))
-          map = SortKeyMethods;
-        break;
-      case DT_SORT_AUX:
-        map = SortAuxMethods;
-        break;
-      default:
-        map = SortMethods;
-        break;
-      }
-
-      if (!map) {
-        snprintf (err->data, err->dsize, _("%s: Unknown type."),
-                  MuttVars[idx].option);
-        r = -1;
-        break;
-      }
-
-      if (query || *s->dptr != '=') {
-        p =
-          mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK,
-                               map);
-
-        snprintf (err->data, err->dsize, "%s=%s%s%s", MuttVars[idx].option,
-                  (*((short *) MuttVars[idx].data) & SORT_REVERSE) ?
-                  "reverse-" : "",
-                  (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" :
-                  "", p);
-        return 0;
-      }
-      s->dptr++;
-      mutt_extract_token (tmp, s, 0);
-
-      if (parse_sort ((short *) MuttVars[idx].data, tmp->data, map, err) ==
-          -1) {
-        r = -1;
-        break;
+          set_quadoption (option->data, M_YES);
       }
     }
     else {
       snprintf (err->data, err->dsize, _("%s: unknown type"),
-                MuttVars[idx].option);
+                option->option);
       r = -1;
       break;
     }
 
-    if (MuttVars[idx].flags & R_INDEX)
+    if (option->flags & R_INDEX)
       set_option (OPTFORCEREDRAWINDEX);
-    if (MuttVars[idx].flags & R_PAGER)
+    if (option->flags & R_PAGER)
       set_option (OPTFORCEREDRAWPAGER);
-    if (MuttVars[idx].flags & R_RESORT_SUB)
+    if (option->flags & R_RESORT_SUB)
       set_option (OPTSORTSUBTHREADS);
-    if (MuttVars[idx].flags & R_RESORT)
+    if (option->flags & R_RESORT)
       set_option (OPTNEEDRESORT);
-    if (MuttVars[idx].flags & R_RESORT_INIT)
+    if (option->flags & R_RESORT_INIT)
       set_option (OPTRESORTINIT);
-    if (MuttVars[idx].flags & R_TREE)
+    if (option->flags & R_TREE)
       set_option (OPTREDRAWTREE);
   }
   return (r);
@@ -1461,8 +1750,6 @@ static int source_rc (const char *rcfile, BUFFER * err)
   pid_t pid;
 
   debug_print (2, ("reading configuration file '%s'.\n", rcfile));
-  str_replace (&CurRCFile, rcfile);
-  CurRCLine = 0;
 
   if ((f = mutt_open_read (rcfile, &pid)) == NULL) {
     snprintf (err->data, err->dsize, "%s: %s", rcfile, strerror (errno));
@@ -1471,7 +1758,6 @@ static int source_rc (const char *rcfile, BUFFER * err)
 
   memset (&token, 0, sizeof (token));
   while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) {
-    CurRCLine++;
     conv = ConfigCharset && (*ConfigCharset) && Charset;
     if (conv) {
       currentline = str_dup (linebuf);
@@ -1482,6 +1768,9 @@ static int source_rc (const char *rcfile, BUFFER * err)
     else
       currentline = linebuf;
 
+    CurRCLine = line;
+    CurRCFile = rcfile;
+
     if (mutt_parse_rc_line (currentline, &token, err) == -1) {
       mutt_error (_("Error in %s, line %d: %s"), rcfile, line, err->data);
       if (--rc < -MAXERRS) {
@@ -1558,6 +1847,8 @@ int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err)
 
   *err->data = 0;
 
+  debug_print (1, ("expand '%s'\n", line));
+
   SKIPWS (expn.dptr);
   while (*expn.dptr) {
     if (*expn.dptr == '#')
@@ -1768,6 +2059,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
 {
   char var[STRING], *pt = buffer;
   int spaces;
+  struct option_t* option = NULL;
 
   if (buffer[0] == 0)
     return 0;
@@ -1783,12 +2075,10 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
     return 0;
 
   if (str_ncmp (buffer, "set", 3) == 0) {
-    int idx;
-
     strfcpy (var, pt, sizeof (var));
     /* ignore the trailing '=' when comparing */
     var[str_len (var) - 1] = 0;
-    if ((idx = mutt_option_index (var)) == -1)
+    if (!(option = hash_find (ConfigOptions, var)))
       return 0;                 /* no such variable. */
     else {
       char tmp[LONG_STRING], tmp2[LONG_STRING];
@@ -1798,26 +2088,26 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
 
       tmp[0] = '\0';
 
-      if ((DTYPE (MuttVars[idx].type) == DT_STR) ||
-          (DTYPE (MuttVars[idx].type) == DT_PATH) ||
-          (DTYPE (MuttVars[idx].type) == DT_RX)) {
-        strfcpy (tmp, NONULL (*((char **) MuttVars[idx].data)), sizeof (tmp));
-        if (DTYPE (MuttVars[idx].type) == DT_PATH)
+      if ((DTYPE (option->type) == DT_STR) ||
+          (DTYPE (option->type) == DT_PATH) ||
+          (DTYPE (option->type) == DT_RX)) {
+        strfcpy (tmp, NONULL (*((char **) option->data)), sizeof (tmp));
+        if (DTYPE (option->type) == DT_PATH)
           mutt_pretty_mailbox (tmp);
       }
-      else if (DTYPE (MuttVars[idx].type) == DT_ADDR) {
+      else if (DTYPE (option->type) == DT_ADDR) {
         rfc822_write_address (tmp, sizeof (tmp),
-                              *((ADDRESS **) MuttVars[idx].data), 0);
+                              *((ADDRESS **) option->data), 0);
       }
-      else if (DTYPE (MuttVars[idx].type) == DT_QUAD)
-        strfcpy (tmp, vals[quadoption (MuttVars[idx].data)], sizeof (tmp));
-      else if (DTYPE (MuttVars[idx].type) == DT_NUM)
-        snprintf (tmp, sizeof (tmp), "%d", (*((short *) MuttVars[idx].data)));
-      else if (DTYPE (MuttVars[idx].type) == DT_SORT) {
+      else if (DTYPE (option->type) == DT_QUAD)
+        strfcpy (tmp, vals[quadoption (option->data)], sizeof (tmp));
+      else if (DTYPE (option->type) == DT_NUM)
+        snprintf (tmp, sizeof (tmp), "%d", (*((short *) option->data)));
+      else if (DTYPE (option->type) == DT_SORT) {
         const struct mapping_t *map;
         char *p;
 
-        switch (MuttVars[idx].type & DT_SUBTYPE_MASK) {
+        switch (option->type & DT_SUBTYPE_MASK) {
         case DT_SORT_ALIAS:
           map = SortAliasMethods;
           break;
@@ -1835,15 +2125,15 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
           break;
         }
         p =
-          mutt_getnamebyvalue (*((short *) MuttVars[idx].data) & SORT_MASK,
+          mutt_getnamebyvalue (*((short *) option->data) & SORT_MASK,
                                map);
         snprintf (tmp, sizeof (tmp), "%s%s%s",
-                  (*((short *) MuttVars[idx].data) & SORT_REVERSE) ?
+                  (*((short *) option->data) & SORT_REVERSE) ?
                   "reverse-" : "",
-                  (*((short *) MuttVars[idx].data) & SORT_LAST) ? "last-" :
+                  (*((short *) option->data) & SORT_LAST) ? "last-" :
                   "", p);
       } 
-      else if (DTYPE (MuttVars[idx].type) == DT_MAGIC) {
+      else if (DTYPE (option->type) == DT_MAGIC) {
         char *p;
         switch (DefaultMagic) {
           case M_MBOX:
@@ -1863,8 +2153,8 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
         }
         strfcpy (tmp, p, sizeof (tmp));
       }
-      else if (DTYPE (MuttVars[idx].type) == DT_BOOL)
-        strfcpy (tmp, option (MuttVars[idx].data) ? "yes" : "no",
+      else if (DTYPE (option->type) == DT_BOOL)
+        strfcpy (tmp, option (option->data) ? "yes" : "no",
                  sizeof (tmp));
       else
         return 0;
@@ -1967,6 +2257,18 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   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);
+  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);
+  }
+
   /* 
    * XXX - use something even more difficult to predict?
    */
@@ -1988,6 +2290,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
     Realname = str_dup (mutt_gecos_name (rnbuf, sizeof (rnbuf), pw));
     Shell = str_dup (pw->pw_shell);
+    endpwent ();
   }
   else {
     if (!Homedir) {
@@ -2109,10 +2412,8 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
 
   /* Set standard defaults */
-  for (i = 0; MuttVars[i].option; i++) {
-    mutt_set_default (&MuttVars[i]);
-    mutt_restore_default (&MuttVars[i]);
-  }
+  hash_map (ConfigOptions, mutt_set_default, 0);
+  hash_map (ConfigOptions, mutt_restore_default, 0);
 
   CurrentMenu = MENU_MAIN;
 
@@ -2201,7 +2502,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   /* Read the user's initialization file.  */
   if (access (Muttrc, F_OK) != -1) {
     if (!option (OPTNOCURSES))
-      endwin ();
+      mutt_endwin (NULL);
     if (source_rc (Muttrc, &err) != 0) {
       fputs (err.data, stderr);
       fputc ('\n', stderr);
@@ -2222,18 +2523,21 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   if (!list_empty(Synonyms)) {
     int i = 0;
     fprintf (stderr, _("Warning: the following synonym variables were found:\n"));
-    for (i = 0; i < Synonyms->length; i++)
+    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",
-               MuttVars[((syn_t*) Synonyms->data[i])->o].option,
-               MuttVars[((syn_t*) Synonyms->data[i])->n].option,
+               oldopt ? NONULL (oldopt->option) : "",
+               newopt ? NONULL (newopt->option) : "",
                NONULL(((syn_t*) Synonyms->data[i])->f),
                ((syn_t*) Synonyms->data[i])->l);
-    fprintf (stderr, _("Warning: Synonym variables are scheduled for removal.\n"));
+    }
+    fprintf (stderr, _("Warning: synonym variables are scheduled"
+                       " for removal.\n"));
     list_del (&Synonyms, syn_del);
     need_pause = 1;
   }
-  /* this is not needed during runtime */
-  mem_free(&CurRCFile);
 
   if (need_pause && !option (OPTNOCURSES)) {
     if (mutt_any_key_to_continue (NULL) == -1)
@@ -2255,49 +2559,59 @@ 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 (str_cmp ((*(struct option_t**) a)->option,
                        (*(struct option_t**) b)->option));
 }
 
-/* dump out the value of all the variables we have */
-int mutt_dump_variables (void) {
-  int i;
+/* 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;
 
-  char errbuff[STRING];
-  char command[STRING];
-  list2_t* tmp = NULL;
+  if (DTYPE (option->type) == DT_SYN)
+    return;
+  list_push_back (l, option);
+}
 
-  BUFFER err, token;
+/* 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];
 
-  memset (&err, 0, sizeof (err));
-  memset (&token, 0, sizeof (token));
+  if (DTYPE (option->type) == DT_SYN)
+    return;
 
-  err.data = errbuff;
-  err.dsize = sizeof (errbuff);
+  mutt_option_value (option->option, buf, sizeof (buf));
+  if (str_cmp (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) {
+  int i = 0;
+  char outbuf[STRING];
+  list2_t* tmp = NULL;
+  struct option_t* option = NULL;
 
   /* get all non-synonyms into list... */
-  for (i = 0; MuttVars[i].option; i++) {
-    if (MuttVars[i].type == DT_SYN)
-      continue;
-    list_push_back (&tmp, &MuttVars[i]);
-  }
+  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++) {
-      snprintf (command, sizeof (command), "set ?%s\n",
-                ((struct option_t*) tmp->data[i])->option);
-      if (mutt_parse_rc_line (command, &token, &err) == -1) {
-        fprintf (stderr, "%s\n", err.data);
-        mem_free (&token.data);
-        list_del (&tmp, NULL);
-        return 1;
-      }
-      printf("%s\n", err.data);
+      option = (struct option_t*) tmp->data[i];
+      FuncTable[DTYPE (option->type)].opt_to_string
+        (outbuf, sizeof (outbuf), option);
+      printf ("%s\n", outbuf);
     }
   }
-  mem_free (&token.data);
   list_del (&tmp, NULL);
   return 0;
 }