X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=eab1c5724446f06a21a589781e032c73486d7199;hp=ffd58e32836b368f696c73b1b5dbbe08247ad05e;hb=5cafd011a192128264e2656dd2ee036ac4634afa;hpb=c3e57678c8be193fc137854020f3a90887be97c9

diff --git a/init.c b/init.c
index ffd58e3..eab1c57 100644
--- a/init.c
+++ b/init.c
@@ -14,7 +14,6 @@
 #include "mutt.h"
 #include "mapping.h"
 #include "mutt_curses.h"
-#include "mutt_regex.h"
 #include "history.h"
 #include "keymap.h"
 #include "mbyte.h"
@@ -26,11 +25,14 @@
 #include "mutt_ssl.h"
 #endif
 
-
-
 #include "mx.h"
 #include "init.h"
-#include "mailbox.h"
+
+#include "lib/mem.h"
+#include "lib/intl.h"
+#include "lib/str.h"
+#include "lib/rx.h"
+#include "lib/debug.h"
 
 #include <ctype.h>
 #include <stdlib.h>
@@ -40,6 +42,37 @@
 #include <errno.h>
 #include <sys/wait.h>
 
+/* 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) */
+} syn_t;
+
+/* for synonym warning reports: list of synonyms found */
+list2_t* Synonyms;
+/* for synonym warning reports: current rc file */
+char* CurRCFile = NULL;
+/* for synonym warning reports: current rc line */
+int CurRCLine = 0;
+
+/* for synonym warning reports: adds synonym to end of list */
+static void syn_add (int n, int o) {
+  syn_t* tmp = safe_malloc (sizeof (syn_t));
+  tmp->f = safe_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) {
+  FREE(&(*(syn_t**) p)->f);
+  FREE(p);
+}
+
 void toggle_quadoption (int opt)
 {
   int n = opt / 4;
@@ -90,9 +123,12 @@ int mutt_option_index (char *s)
   int i;
 
   for (i = 0; MuttVars[i].option; i++)
-    if (mutt_strcmp (s, MuttVars[i].option) == 0)
+    if (safe_strcmp (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);
 }
 
@@ -195,14 +231,12 @@ int mutt_extract_token (BUFFER * dest, BUFFER * tok, int flags)
         }
       } while (pc && *pc != '`');
       if (!pc) {
-        dprint (1, (debugfile, "mutt_get_token: mismatched backtics\n"));
+        debug_print (1, ("mismatched backtics\n"));
         return (-1);
       }
-      cmd = mutt_substrdup (tok->dptr, pc);
+      cmd = str_substrdup (tok->dptr, pc);
       if ((pid = mutt_create_filter (cmd, NULL, &fp, NULL)) < 0) {
-        dprint (1,
-                (debugfile, "mutt_get_token: unable to fork command: %s",
-                 cmd));
+        debug_print (1, ("unable to fork command: %s\n", cmd));
         FREE (&cmd);
         return (-1);
       }
@@ -225,8 +259,8 @@ int mutt_extract_token (BUFFER * dest, BUFFER * tok, int flags)
         FREE (&expn.data);
       }
       else if (expn.data) {
-        expnlen = mutt_strlen (expn.data);
-        tok->dsize = expnlen + mutt_strlen (tok->dptr) + 1;
+        expnlen = safe_strlen (expn.data);
+        tok->dsize = expnlen + safe_strlen (tok->dptr) + 1;
         ptr = safe_malloc (tok->dsize);
         memcpy (ptr, expn.data, expnlen);
         strcpy (ptr + expnlen, tok->dptr);      /* __STRCPY_CHECKED__ */
@@ -246,14 +280,14 @@ int mutt_extract_token (BUFFER * dest, BUFFER * tok, int flags)
       if (*tok->dptr == '{') {
         tok->dptr++;
         if ((pc = strchr (tok->dptr, '}'))) {
-          var = mutt_substrdup (tok->dptr, pc);
+          var = str_substrdup (tok->dptr, pc);
           tok->dptr = pc + 1;
         }
       }
       else {
         for (pc = tok->dptr; isalpha ((unsigned char) *pc) || *pc == '_';
              pc++);
-        var = mutt_substrdup (tok->dptr, pc);
+        var = str_substrdup (tok->dptr, pc);
         tok->dptr = pc;
       }
       if (var && (env = getenv (var)))
@@ -299,44 +333,25 @@ static void add_to_list (LIST ** list, const char *str)
   }
 }
 
-static int add_to_rx_list (RX_LIST ** list, const char *s, int flags,
+static int add_to_rx_list (list2_t** list, const char *s, int flags,
                            BUFFER * err)
 {
-  RX_LIST *t, *last = NULL;
-  REGEXP *rx;
+  rx_t* rx;
+  int i = 0;
 
   if (!s || !*s)
     return 0;
 
-  if (!(rx = mutt_compile_regexp (s, flags))) {
+  if (!(rx = rx_compile (s, flags))) {
     snprintf (err->data, err->dsize, "Bad regexp: %s\n", s);
     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, so just ignore it */
-      last = NULL;
-      break;
-    }
-    if (!last->next)
-      break;
-  }
-
-  if (!*list || last) {
-    t = mutt_new_rx_list ();
-    t->rx = rx;
-    if (last) {
-      last->next = t;
-      last = last->next;
-    }
-    else
-      *list = last = t;
-  }
-  else                          /* duplicate */
-    mutt_free_regexp (&rx);
-
+  i = rx_lookup ((*list), rx->pattern);
+  if (i >= 0)
+    rx_free (&rx);
+  else
+    list_push_back (list, rx);
   return 0;
 }
 
@@ -344,14 +359,14 @@ static int add_to_spam_list (SPAM_LIST ** list, const char *pat,
                              const char *templ, BUFFER * err)
 {
   SPAM_LIST *t = NULL, *last = NULL;
-  REGEXP *rx;
+  rx_t* rx;
   int n;
   const char *p;
 
   if (!pat || !*pat || !templ)
     return 0;
 
-  if (!(rx = mutt_compile_regexp (pat, REG_ICASE))) {
+  if (!(rx = rx_compile (pat, REG_ICASE))) {
     snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat);
     return -1;
   }
@@ -366,7 +381,7 @@ static int add_to_spam_list (SPAM_LIST ** list, const char *pat,
        * the template, and leaving t pointed at the current item.
        */
       t = last;
-      safe_free (&t->template);
+      FREE(t->template);
       break;
     }
     if (!last->next)
@@ -413,21 +428,21 @@ static int remove_from_spam_list (SPAM_LIST ** list, const char *pat)
 
   /* Being first is a special case. */
   spam = *list;
-  if (spam->rx && !mutt_strcmp (spam->rx->pattern, pat)) {
+  if (spam->rx && !safe_strcmp (spam->rx->pattern, pat)) {
     *list = spam->next;
-    mutt_free_regexp (&spam->rx);
-    safe_free (&spam->template);
-    safe_free (&spam);
+    rx_free (&spam->rx);
+    FREE(&spam->template);
+    FREE(&spam);
     return 1;
   }
 
   prev = spam;
   for (spam = prev->next; spam;) {
-    if (!mutt_strcmp (spam->rx->pattern, pat)) {
+    if (!safe_strcmp (spam->rx->pattern, pat)) {
       prev->next = spam->next;
-      mutt_free_regexp (&spam->rx);
-      safe_free (&spam->template);
-      safe_free (&spam);
+      rx_free (&spam->rx);
+      FREE(spam->template);
+      FREE(spam);
       spam = prev->next;
       ++nremoved;
     }
@@ -443,7 +458,7 @@ static void remove_from_list (LIST ** l, const char *str)
 {
   LIST *p, *last = NULL;
 
-  if (mutt_strcmp ("*", str) == 0)
+  if (safe_strcmp ("*", str) == 0)
     mutt_free_list (l);         /* ``unCMD *'' means delete all current entries */
   else {
     p = *l;
@@ -465,35 +480,23 @@ static void remove_from_list (LIST ** l, const char *str)
   }
 }
 
-static int remove_from_rx_list (RX_LIST ** l, const char *str)
+static int remove_from_rx_list (list2_t** l, const char *str)
 {
-  RX_LIST *p, *last = NULL;
-  int rv = -1;
+  int i = 0;
 
-  if (mutt_strcmp ("*", str) == 0) {
-    mutt_free_rx_list (l);      /* ``unCMD *'' means delete all current entries */
-    rv = 0;
+  if (safe_strcmp ("*", str) == 0) {
+    list_del (l, rx_free);
+    return (0);
   }
   else {
-    p = *l;
-    last = NULL;
-    while (p) {
-      if (ascii_strcasecmp (str, p->rx->pattern) == 0) {
-        mutt_free_regexp (&p->rx);
-        if (last)
-          last->next = p->next;
-        else
-          (*l) = p->next;
-        FREE (&p);
-        rv = 0;
-      }
-      else {
-        last = p;
-        p = p->next;
-      }
+    i = rx_lookup ((*l), str);
+    if (i >= 0) {
+      rx_t* r = list_pop_idx ((*l), i);
+      rx_free (&r);
+      return (0);
     }
   }
-  return (rv);
+  return (-1);
 }
 
 static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
@@ -514,8 +517,8 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
         continue;
 
       for (j = 0; b[j].name; j++)
-        if (!ascii_strncasecmp (tmp->data, b[j].name, mutt_strlen (tmp->data))
-            && (mutt_strlen (b[j].name) == mutt_strlen (tmp->data))) {
+        if (!ascii_strncasecmp (tmp->data, b[j].name, safe_strlen (tmp->data))
+            && (safe_strlen (b[j].name) == safe_strlen (tmp->data))) {
           res = 1;
           break;
         }
@@ -525,13 +528,13 @@ static int parse_ifdef (BUFFER * tmp, BUFFER * s, unsigned long data,
     char *p = NULL;
 
     i = 0;
-    j = mutt_strlen (tmp->data);
+    j = safe_strlen (tmp->data);
     /* need at least input of 'feature_X' */
     if (j >= 7) {
       p = tmp->data + 7;
       j -= 7;
       while (Features[i].name) {
-        if (mutt_strlen (Features[i].name) == j &&
+        if (safe_strlen (Features[i].name) == j &&
             ascii_strncasecmp (Features[i].name, p, j)) {
           res = 1;
           break;
@@ -603,44 +606,6 @@ static int parse_list (BUFFER * buf, BUFFER * s, unsigned long data,
   return 0;
 }
 
-#if 0
-static int _parse_rx_list (BUFFER * buf, BUFFER * s, unsigned long data,
-                           BUFFER * err, int flags)
-{
-  do {
-    mutt_extract_token (buf, s, 0);
-    if (add_to_rx_list ((RX_LIST **) data, buf->data, flags, err) != 0)
-      return -1;
-
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
-
-static int parse_rx_list (BUFFER * buf, BUFFER * s, unsigned long data,
-                          BUFFER * err)
-{
-  return _parse_rx_list (buf, s, data, err, REG_ICASE);
-}
-
-static int parse_rx_unlist (BUFFER * buf, BUFFER * s, unsigned long data,
-                            BUFFER * err)
-{
-  do {
-    mutt_extract_token (buf, s, 0);
-    if (mutt_strcmp (buf->data, "*") == 0) {
-      mutt_free_rx_list ((RX_LIST **) data);
-      break;
-    }
-    remove_from_rx_list ((RX_LIST **) data, buf->data);
-  }
-  while (MoreArgs (s));
-
-  return 0;
-}
-#endif
-
 static void _alternates_clean (void)
 {
   int i;
@@ -675,7 +640,7 @@ static int parse_unalternates (BUFFER * buf, BUFFER * s, unsigned long data,
     mutt_extract_token (buf, s, 0);
     remove_from_rx_list (&Alternates, buf->data);
 
-    if (mutt_strcmp (buf->data, "*") &&
+    if (safe_strcmp (buf->data, "*") &&
         add_to_rx_list (&UnAlternates, buf->data, REG_ICASE, err) != 0)
       return -1;
 
@@ -731,9 +696,9 @@ static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data,
     /* nospam only ever has one parameter. */
 
     /* "*" is a special case. */
-    if (!mutt_strcmp (buf->data, "*")) {
+    if (!safe_strcmp (buf->data, "*")) {
       mutt_free_spam_list (&SpamList);
-      mutt_free_rx_list (&NoSpamList);
+      list_del (&NoSpamList, rx_free);
       return 0;
     }
 
@@ -761,7 +726,7 @@ static int parse_unlist (BUFFER * buf, BUFFER * s, unsigned long data,
     /*
      * Check for deletion of entire list
      */
-    if (mutt_strcmp (buf->data, "*") == 0) {
+    if (safe_strcmp (buf->data, "*") == 0) {
       mutt_free_list ((LIST **) data);
       break;
     }
@@ -795,7 +760,7 @@ static int parse_unlists (BUFFER * buf, BUFFER * s, unsigned long data,
     remove_from_rx_list (&SubscribedLists, buf->data);
     remove_from_rx_list (&MailLists, buf->data);
 
-    if (mutt_strcmp (buf->data, "*") &&
+    if (safe_strcmp (buf->data, "*") &&
         add_to_rx_list (&UnMailLists, buf->data, REG_ICASE, err) != 0)
       return -1;
   }
@@ -829,7 +794,7 @@ static int parse_unsubscribe (BUFFER * buf, BUFFER * s, unsigned long data,
     mutt_extract_token (buf, s, 0);
     remove_from_rx_list (&SubscribedLists, buf->data);
 
-    if (mutt_strcmp (buf->data, "*") &&
+    if (safe_strcmp (buf->data, "*") &&
         add_to_rx_list (&UnSubscribedLists, buf->data, REG_ICASE, err) != 0)
       return -1;
   }
@@ -846,7 +811,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data,
   do {
     mutt_extract_token (buf, s, 0);
 
-    if (mutt_strcmp ("*", buf->data) == 0) {
+    if (safe_strcmp ("*", buf->data) == 0) {
       if (CurrentMenu == MENU_ALIAS) {
         for (tmp = Aliases; tmp; tmp = tmp->next)
           tmp->del = 1;
@@ -858,7 +823,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data,
     }
     else
       for (tmp = Aliases; tmp; tmp = tmp->next) {
-        if (mutt_strcasecmp (buf->data, tmp->name) == 0) {
+        if (safe_strcasecmp (buf->data, tmp->name) == 0) {
           if (CurrentMenu == MENU_ALIAS) {
             tmp->del = 1;
             set_option (OPTFORCEREDRAWINDEX);
@@ -894,11 +859,11 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data,
 
   mutt_extract_token (buf, s, 0);
 
-  dprint (2, (debugfile, "parse_alias: First token is '%s'.\n", buf->data));
+  debug_print (2, ("first token is '%s'.\n", buf->data));
 
   /* check to see if an alias with this name already exists */
   for (; tmp; tmp = tmp->next) {
-    if (!mutt_strcasecmp (tmp->name, buf->data))
+    if (!safe_strcasecmp (tmp->name, buf->data))
       break;
     last = tmp;
   }
@@ -921,7 +886,7 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data,
 
   mutt_extract_token (buf, s,
                       M_TOKEN_QUOTE | M_TOKEN_SPACE | M_TOKEN_SEMICOLON);
-  dprint (2, (debugfile, "parse_alias: Second token is '%s'.\n", buf->data));
+  debug_print (2, ("second token is '%s'.\n", buf->data));
   tmp->addr = mutt_parse_adrlist (tmp->addr, buf->data);
   if (last)
     last->next = tmp;
@@ -933,14 +898,14 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data,
     return -1;
   }
 #ifdef DEBUG
-  if (debuglevel >= 2) {
+  if (DebugLevel >= 2) {
     ADDRESS *a;
 
     for (a = tmp->addr; a; a = a->next) {
       if (!a->group)
-        dprint (2, (debugfile, "parse_alias:   %s\n", a->mailbox));
+        debug_print (2, ("%s\n", a->mailbox));
       else
-        dprint (2, (debugfile, "parse_alias:   Group %s\n", a->mailbox));
+        debug_print (2, ("group %s\n", a->mailbox));
     }
   }
 #endif
@@ -957,13 +922,13 @@ parse_unmy_hdr (BUFFER * buf, BUFFER * s, unsigned long data, BUFFER * err)
 
   do {
     mutt_extract_token (buf, s, 0);
-    if (mutt_strcmp ("*", buf->data) == 0)
+    if (safe_strcmp ("*", buf->data) == 0)
       mutt_free_list (&UserHeader);
     else {
       tmp = UserHeader;
       last = NULL;
 
-      l = mutt_strlen (buf->data);
+      l = safe_strlen (buf->data);
       if (buf->data[l - 1] == ':')
         l--;
 
@@ -1035,12 +1000,12 @@ parse_sort (short *val, const char *s, const struct mapping_t *map,
 {
   int i, flags = 0;
 
-  if (mutt_strncmp ("reverse-", s, 8) == 0) {
+  if (safe_strncmp ("reverse-", s, 8) == 0) {
     s += 8;
     flags = SORT_REVERSE;
   }
 
-  if (mutt_strncmp ("last-", s, 5) == 0) {
+  if (safe_strncmp ("last-", s, 5) == 0) {
     s += 5;
     flags |= SORT_LAST;
   }
@@ -1081,7 +1046,7 @@ static void mutt_set_default (struct option_t *p)
     break;
   case DT_RX:
     {
-      REGEXP *pp = (REGEXP *) p->data;
+      rx_t* pp = (rx_t*) p->data;
 
       if (!p->init && pp->pattern)
         p->init = (unsigned long) safe_strdup (pp->pattern);
@@ -1095,7 +1060,7 @@ static void mutt_restore_default (struct option_t *p)
   switch (p->type & DT_MASK) {
   case DT_STR:
     if (p->init)
-      mutt_str_replace ((char **) p->data, (char *) p->init);
+      str_replace ((char **) p->data, (char *) p->init);
     break;
   case DT_PATH:
     if (p->init) {
@@ -1103,7 +1068,7 @@ static void mutt_restore_default (struct option_t *p)
 
       strfcpy (path, (char *) p->init, sizeof (path));
       mutt_expand_path (path, sizeof (path));
-      mutt_str_replace ((char **) p->data, path);
+      str_replace ((char **) p->data, path);
     }
     break;
   case DT_ADDR:
@@ -1128,7 +1093,7 @@ static void mutt_restore_default (struct option_t *p)
     break;
   case DT_RX:
     {
-      REGEXP *pp = (REGEXP *) p->data;
+      rx_t *pp = (rx_t *) p->data;
       int flags = 0;
 
       FREE (&pp->pattern);
@@ -1141,9 +1106,9 @@ static void mutt_restore_default (struct option_t *p)
         char *s = (char *) p->init;
 
         pp->rx = safe_calloc (1, sizeof (regex_t));
-        if (mutt_strcmp (p->option, "mask") != 0)
+        if (safe_strcmp (p->option, "mask") != 0)
           flags |= mutt_which_case ((const char *) p->init);
-        if (mutt_strcmp (p->option, "mask") == 0 && *s == '!') {
+        if (safe_strcmp (p->option, "mask") == 0 && *s == '!') {
           s++;
           pp->not = 1;
         }
@@ -1156,7 +1121,7 @@ static void mutt_restore_default (struct option_t *p)
           FREE (&pp->rx);
         }
         else
-          mutt_str_replace (&pp->pattern, (char *) p->init);
+          str_replace (&pp->pattern, (char *) p->init);
       }
     }
     break;
@@ -1193,11 +1158,11 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       query = 1;
       s->dptr++;
     }
-    else if (mutt_strncmp ("no", s->dptr, 2) == 0) {
+    else if (safe_strncmp ("no", s->dptr, 2) == 0) {
       s->dptr += 2;
       unset = !unset;
     }
-    else if (mutt_strncmp ("inv", s->dptr, 3) == 0) {
+    else if (safe_strncmp ("inv", s->dptr, 3) == 0) {
       s->dptr += 3;
       inv = !inv;
     }
@@ -1210,7 +1175,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
     mutt_extract_token (tmp, s, M_TOKEN_EQUAL);
 
     if ((idx = mutt_option_index (tmp->data)) == -1 &&
-        !(reset && !mutt_strcmp ("all", tmp->data))) {
+        !(reset && !safe_strcmp ("all", tmp->data))) {
       snprintf (err->data, err->dsize, _("%s: unknown variable"), tmp->data);
       return (-1);
     }
@@ -1227,7 +1192,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         return (-1);
       }
 
-      if (!mutt_strcmp ("all", tmp->data)) {
+      if (!safe_strcmp ("all", tmp->data)) {
         for (idx = 0; MuttVars[idx].option; idx++)
           mutt_restore_default (&MuttVars[idx]);
         return 0;
@@ -1311,7 +1276,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         }
         else if (DTYPE (MuttVars[idx].type) == DT_STR) {
           *((char **) MuttVars[idx].data) = safe_strdup (tmp->data);
-          if (mutt_strcmp (MuttVars[idx].option, "charset") == 0)
+          if (safe_strcmp (MuttVars[idx].option, "charset") == 0)
             mutt_set_charset (Charset);
         }
         else {
@@ -1321,7 +1286,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       }
     }
     else if (DTYPE (MuttVars[idx].type) == DT_RX) {
-      REGEXP *ptr = (REGEXP *) MuttVars[idx].data;
+      rx_t *ptr = (rx_t *) MuttVars[idx].data;
       regex_t *rx;
       int e, flags = 0;
 
@@ -1333,7 +1298,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       }
 
       if (option (OPTATTACHMSG)
-          && !mutt_strcmp (MuttVars[idx].option, "reply_regexp")) {
+          && !safe_strcmp (MuttVars[idx].option, "reply_regexp")) {
         snprintf (err->data, err->dsize,
                   "Operation not permitted when in attach-message mode.");
         r = -1;
@@ -1345,15 +1310,15 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       /* copy the value of the string */
       mutt_extract_token (tmp, s, 0);
 
-      if (!ptr->pattern || mutt_strcmp (ptr->pattern, tmp->data) != 0) {
+      if (!ptr->pattern || safe_strcmp (ptr->pattern, tmp->data) != 0) {
         int not = 0;
 
         /* $mask is case-sensitive */
-        if (mutt_strcmp (MuttVars[idx].option, "mask") != 0)
+        if (safe_strcmp (MuttVars[idx].option, "mask") != 0)
           flags |= mutt_which_case (tmp->data);
 
         p = tmp->data;
-        if (mutt_strcmp (MuttVars[idx].option, "mask") == 0) {
+        if (safe_strcmp (MuttVars[idx].option, "mask") == 0) {
           if (*p == '!') {
             not = 1;
             p++;
@@ -1382,7 +1347,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         /* $reply_regexp and $alterantes require special treatment */
 
         if (Context && Context->msgcount &&
-            mutt_strcmp (MuttVars[idx].option, "reply_regexp") == 0) {
+            safe_strcmp (MuttVars[idx].option, "reply_regexp") == 0) {
           regmatch_t pmatch[1];
           int i;
 
@@ -1458,12 +1423,12 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         *ptr = (short) val;
 
       /* these ones need a sanity check */
-      if (mutt_strcmp (MuttVars[idx].option, "history") == 0) {
+      if (safe_strcmp (MuttVars[idx].option, "history") == 0) {
         if (*ptr < 0)
           *ptr = 0;
         mutt_init_history ();
       }
-      else if (mutt_strcmp (MuttVars[idx].option, "pager_index_lines") == 0) {
+      else if (safe_strcmp (MuttVars[idx].option, "pager_index_lines") == 0) {
         if (*ptr < 0)
           *ptr = 0;
       }
@@ -1590,7 +1555,9 @@ static int source_rc (const char *rcfile, BUFFER * err)
   size_t buflen;
   pid_t pid;
 
-  dprint (2, (debugfile, "Reading configuration file '%s'.\n", rcfile));
+  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));
@@ -1599,6 +1566,7 @@ 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 = safe_strdup (linebuf);
@@ -1681,7 +1649,7 @@ int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err)
 
   memset (&expn, 0, sizeof (expn));
   expn.data = expn.dptr = line;
-  expn.dsize = mutt_strlen (line);
+  expn.dsize = safe_strlen (line);
 
   *err->data = 0;
 
@@ -1695,7 +1663,7 @@ int mutt_parse_rc_line ( /* const */ char *line, BUFFER * token, BUFFER * err)
     }
     mutt_extract_token (token, &expn, 0);
     for (i = 0; Commands[i].name; i++) {
-      if (!mutt_strcmp (token->data, Commands[i].name)) {
+      if (!safe_strcmp (token->data, Commands[i].name)) {
         if (Commands[i].func (token, &expn, Commands[i].data, err) != 0)
           goto finish;
         break;
@@ -1793,18 +1761,18 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs)
     /* return the completed command */
     strncpy (buffer, Completed, len - spaces);
   }
-  else if (!mutt_strncmp (buffer, "set", 3)
-           || !mutt_strncmp (buffer, "unset", 5)
-           || !mutt_strncmp (buffer, "reset", 5)
-           || !mutt_strncmp (buffer, "toggle", 6)) {    /* complete variables */
+  else if (!safe_strncmp (buffer, "set", 3)
+           || !safe_strncmp (buffer, "unset", 5)
+           || !safe_strncmp (buffer, "reset", 5)
+           || !safe_strncmp (buffer, "toggle", 6)) {    /* complete variables */
     char *prefixes[] = { "no", "inv", "?", "&", 0 };
 
     pt++;
     /* loop through all the possible prefixes (no, inv, ...) */
-    if (!mutt_strncmp (buffer, "set", 3)) {
+    if (!safe_strncmp (buffer, "set", 3)) {
       for (num = 0; prefixes[num]; num++) {
-        if (!mutt_strncmp (pt, prefixes[num], mutt_strlen (prefixes[num]))) {
-          pt += mutt_strlen (prefixes[num]);
+        if (!safe_strncmp (pt, prefixes[num], safe_strlen (prefixes[num]))) {
+          pt += safe_strlen (prefixes[num]);
           break;
         }
       }
@@ -1841,7 +1809,7 @@ int mutt_command_complete (char *buffer, size_t len, int pos, int numtabs)
 
     strncpy (pt, Completed, buffer + len - pt - spaces);
   }
-  else if (!mutt_strncmp (buffer, "exec", 4)) {
+  else if (!safe_strncmp (buffer, "exec", 4)) {
     struct binding_t *menu = km_get_table (CurrentMenu);
 
     if (!menu && CurrentMenu != MENU_PAGER)
@@ -1909,12 +1877,12 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
   if (*pt == '=')               /* abort if no var before the '=' */
     return 0;
 
-  if (mutt_strncmp (buffer, "set", 3) == 0) {
+  if (safe_strncmp (buffer, "set", 3) == 0) {
     int idx;
 
     strfcpy (var, pt, sizeof (var));
     /* ignore the trailing '=' when comparing */
-    var[mutt_strlen (var) - 1] = 0;
+    var[safe_strlen (var) - 1] = 0;
     if ((idx = mutt_option_index (var)) == -1)
       return 0;                 /* no such variable. */
     else {
@@ -2042,31 +2010,6 @@ int mutt_getvaluebyname (const char *name, const struct mapping_t *map)
   return (-1);
 }
 
-#ifdef DEBUG
-static void start_debug (void)
-{
-  time_t t;
-  int i;
-  char buf[_POSIX_PATH_MAX];
-  char buf2[_POSIX_PATH_MAX];
-
-  /* rotate the old debug logs */
-  for (i = 3; i >= 0; i--) {
-    snprintf (buf, sizeof (buf), "%s/.muttdebug%d", NONULL (Homedir), i);
-    snprintf (buf2, sizeof (buf2), "%s/.muttdebug%d", NONULL (Homedir),
-              i + 1);
-    rename (buf, buf2);
-  }
-  if ((debugfile = safe_fopen (buf, "w")) != NULL) {
-    t = time (0);
-    setbuf (debugfile, NULL);   /* don't buffer the debugging output! */
-    fprintf (debugfile,
-             "Mutt-ng %s started at %s.\nDebugging at level %d.\n\n",
-             MUTT_VERSION, asctime (localtime (&t)), debuglevel);
-  }
-}
-#endif
-
 static int mutt_execute_commands (LIST * p)
 {
   BUFFER err, token;
@@ -2137,17 +2080,13 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     Shell = safe_strdup ((p = getenv ("SHELL")) ? p : "/bin/sh");
   }
 
-#ifdef DEBUG
-  /* Start up debugging mode if requested */
-  if (debuglevel > 0)
-    start_debug ();
-#endif
+  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 = mutt_substrdup (utsname.nodename, p);
+    Hostname = str_substrdup (utsname.nodename, p);
     p++;
     strfcpy (buffer, p, sizeof (buffer));       /* save the domain for below */
   }
@@ -2161,7 +2100,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   else
 #endif /* DOMAIN */
   if (*DOMAIN != '@') {
-    Fqdn = safe_malloc (mutt_strlen (DOMAIN) + mutt_strlen (Hostname) + 2);
+    Fqdn = safe_malloc (safe_strlen (DOMAIN) + safe_strlen (Hostname) + 2);
     sprintf (Fqdn, "%s.%s", NONULL (Hostname), DOMAIN); /* __SPRINTF_CHECKED__ */
   }
   else
@@ -2175,7 +2114,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
     if ((f = safe_fopen (SYSCONFDIR "/nntpserver", "r"))) {
       buffer[0] = '\0';
       fgets (buffer, sizeof (buffer), f);
-      p = &buffer;
+      p = (char*) &buffer;
       SKIPWS (p);
       i = p;
       while (*i && (*i != ' ') && (*i != '\t') && (*i != '\r')
@@ -2230,7 +2169,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
     memset (&buf, 0, sizeof (buf));
     buf.data = buf.dptr = buffer;
-    buf.dsize = mutt_strlen (buffer);
+    buf.dsize = safe_strlen (buffer);
 
     memset (&token, 0, sizeof (token));
     parse_my_hdr (&token, &buf, 0, &err);
@@ -2350,6 +2289,23 @@ void mutt_init (int skip_sys_rc, LIST * commands)
   if (mutt_execute_commands (commands) != 0)
     need_pause = 1;
 
+  /* warn about synonym variables */
+  if (!list_empty(Synonyms)) {
+    int i = 0;
+    fprintf (stderr, _("Warning: the following synonym variables were found:\n"));
+    for (i = 0; i < Synonyms->length; i++)
+      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,
+               NONULL(((syn_t*) Synonyms->data[i])->f),
+               ((syn_t*) Synonyms->data[i])->l);
+    fprintf (stderr, _("Warning: Synonym variables are scheduled for removal.\n"));
+    list_del (&Synonyms, syn_del);
+    need_pause = 1;
+  }
+  /* this is not needed during runtime */
+  FREE(&CurRCFile);
+
   if (need_pause && !option (OPTNOCURSES)) {
     if (mutt_any_key_to_continue (NULL) == -1)
       mutt_exit (1);