X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=21bdd4f255773d36d7a38fa66c6f712797a8ac92;hp=ad55667709b0fad0c263e3575d0bda471470c25f;hb=f3cbb9f51357972f6e74244494236a41dc4d84cd;hpb=5a4df9d0e93209aeade80f632158036799f3e9bc

diff --git a/init.c b/init.c
index ad55667..21bdd4f 100644
--- a/init.c
+++ b/init.c
@@ -18,6 +18,7 @@
 
 #include <lib-ui/curses.h>
 #include <lib-ui/history.h>
+#include <lib-mx/mx.h>
 
 #include "mutt.h"
 #include "keymap.h"
@@ -31,11 +32,8 @@
 #endif
 
 #include "alias.h"
-#include "mx.h"
 #include "init.h"
 
-#include "lib/list.h"
-
 /*
  * prototypes
  */
@@ -47,15 +45,24 @@ static int parse_sort (struct option_t* dst, const char *s,
 static HASH *ConfigOptions = NULL;
 
 /* for synonym warning reports: synonym found during parsing */
-typedef struct {
+typedef struct syn_t {
+  struct syn_t *next;
   char* f;              /* file */
   int l;                /* line */
   struct option_t* n;   /* new */
   struct option_t* o;   /* old */
 } syn_t;
 
+DO_INIT(syn_t, syn);
+static void syn_wipe(syn_t *syn) {
+    p_delete(&syn->f);
+}
+DO_NEW(syn_t, syn);
+DO_DELETE(syn_t, syn);
+DO_SLIST(syn_t, syn, syn_delete);
+
 /* for synonym warning reports: list of synonyms found */
-static list2_t* Synonyms;
+static syn_t *Synonyms = NULL;
 /* for synonym warning reports: current rc file */
 static const char* CurRCFile = NULL;
 /* for synonym warning reports: current rc line */
@@ -199,7 +206,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);
@@ -258,7 +265,7 @@ static void sys_to_string (char* dst, ssize_t dstlen,
                                       Maildirlength) == 0 &&
        m_strlen(CurrentFolder) > Maildirlength) {
      val = CurrentFolder + Maildirlength;
-     if (Maildir[strlen(Maildir)-1]!='/')
+     if (Maildir[Maildirlength]!='/')
        val += 1;
      /* if not $folder, just use everything after last / */
     } else if ((t = strrchr (CurrentFolder, '/')) != NULL)
@@ -282,7 +289,7 @@ static int path_from_string (struct option_t* dst, const char* val,
   if (!dst)
     return (0);
 
-  if (!val || !*val) {
+  if (m_strisempty(val)) {
     p_delete((char**) dst->data);
     return (1);
   }
@@ -416,7 +423,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)
@@ -469,7 +476,7 @@ static int magic_from_string (struct option_t* dst, const char* val,
                               char* errbuf __attribute__ ((unused)), ssize_t errlen __attribute__ ((unused))) {
   int flag = -1;
 
-  if (!dst || !val || !*val)
+  if (!dst || m_strisempty(val))
     return (0);
   if (ascii_strncasecmp (val, "mbox", 4) == 0)
     flag = M_MBOX;
@@ -535,22 +542,6 @@ int mutt_option_value (const char* val, char* dst, ssize_t dstlen) {
   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);
-}
-
 static void toggle_quadoption (int opt)
 {
   int n = opt / 4;
@@ -630,7 +621,7 @@ add_to_rx_list(rx_t **list, const char *s, int flags, BUFFER *err)
 {
     rx_t* rx;
 
-    if (!s || !*s)
+    if (m_strisempty(s))
         return 0;
 
     if (rx_lookup(list, s))
@@ -646,101 +637,46 @@ add_to_rx_list(rx_t **list, const char *s, int flags, BUFFER *err)
     return 0;
 }
 
-static int add_to_spam_list (SPAM_LIST ** list, const char *pat,
+static int add_to_spam_list(rx_t **list, const char *pat,
                              const char *templ, BUFFER * err)
 {
-  SPAM_LIST *t = NULL, *last = NULL;
-  rx_t* rx;
-  int n;
-  const char *p;
+    rx_t **last, *rx;
 
-  if (!pat || !*pat || !templ)
-    return 0;
-
-  if (!(rx = rx_compile (pat, REG_ICASE))) {
-    snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat);
-    return -1;
-  }
+    if (m_strisempty(pat) || !templ)
+        return 0;
 
-  /* check to make sure the item is not already on this list */
-  for (last = *list; last; last = last->next) {
-    if (ascii_strcasecmp (rx->pattern, last->rx->pattern) == 0) {
-      /* Already on the list. Formerly we just skipped this case, but
-       * now we're supporting removals, which means we're supporting
-       * re-adds conceptually. So we probably want this to imply a
-       * removal, then do an add. We can achieve the removal by freeing
-       * the template, and leaving t pointed at the current item.
-       */
-      t = last;
-      p_delete(&t->template);
-      break;
+    if (!(rx = rx_compile (pat, REG_ICASE))) {
+        snprintf (err->data, err->dsize, _("Bad regexp: %s"), pat);
+        return -1;
     }
-    if (!last->next)
-      break;
-  }
 
-  /* If t is set, it's pointing into an extant SPAM_LIST* that we want to
-   * update. Otherwise we want to make a new one to link at the list's end.
-   */
-  if (!t) {
-    t = mutt_new_spam_list ();
-    t->rx = rx;
-    if (last)
-      last->next = t;
-    else
-      *list = t;
-  }
-
-  /* Now t is the SPAM_LIST* that we want to modify. It is prepared. */
-  t->template = m_strdup(templ);
-
-  /* Find highest match number in template string */
-  t->nmatch = 0;
-  for (p = templ; *p;) {
-    if (*p == '%') {
-      n = atoi (++p);
-      if (n > t->nmatch)
-        t->nmatch = n;
-      while (*p && isdigit ((int) *p))
-        ++p;
+    /* check to make sure the item is not already on this list */
+    for (last = list; *last; last = &(*last)->next) {
+        if (!ascii_strcasecmp(rx->pattern, (*last)->pattern) == 0) {
+            rx_t *tmp = rx_list_pop(last);
+            rx_delete(&tmp);
+            last = rx_list_last(last);
+            break;
+        }
     }
-    else
-      ++p;
-  }
-  t->nmatch++;                  /* match 0 is always the whole expr */
 
-  return 0;
+    *last = rx;
+    rx_set_template(rx, templ);
+    return 0;
 }
 
-static int remove_from_spam_list (SPAM_LIST ** list, const char *pat)
+static int remove_from_spam_list (rx_t ** list, const char *pat)
 {
-  SPAM_LIST *spam, *prev;
   int nremoved = 0;
 
-  /* Being first is a special case. */
-  spam = *list;
-  if (!spam)
-    return 0;
-  if (spam->rx && !m_strcmp(spam->rx->pattern, pat)) {
-    *list = spam->next;
-    rx_delete(&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_delete(&spam->rx);
-      p_delete(&spam->template);
-      p_delete(&spam);
-      spam = prev->next;
-      ++nremoved;
-    }
-    else
-      spam = spam->next;
+  while (*list) {
+      if (!m_strcmp((*list)->pattern, pat)) {
+          rx_t *spam = rx_list_pop(list);
+          rx_delete(&spam);
+          nremoved++;
+      } else {
+          list = &(*list)->next;
+      }
   }
 
   return nremoved;
@@ -862,7 +798,7 @@ static int parse_unignore (BUFFER * buf, BUFFER * s,
     mutt_extract_token (buf, s, 0);
 
     /* don't add "*" to the unignore list */
-    if (strcmp (buf->data, "*"))
+    if (m_strcmp (buf->data, "*"))
       add_to_list (&UnIgnore, buf->data);
 
     remove_from_list (&Ignore, buf->data);
@@ -992,7 +928,7 @@ static int parse_spam_list (BUFFER * buf, BUFFER * s, unsigned long data,
 
     /* "*" is a special case. */
     if (!m_strcmp(buf->data, "*")) {
-      mutt_free_spam_list (&SpamList);
+      rx_list_wipe(&SpamList);
       rx_list_wipe(&NoSpamList);
       return 0;
     }
@@ -1098,7 +1034,7 @@ static int parse_attach_list (BUFFER *buf, BUFFER *s, string_list_t **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';
@@ -1675,32 +1611,29 @@ static int check_dsn_return (const char* option __attribute__ ((unused)), unsign
 }
 
 /* check whether value for $dsn_notify would be valid */
-static int check_dsn_notify (const char* option __attribute__ ((unused)), unsigned long p,
-                             char* errbuf, ssize_t errlen) {
-  list2_t* list = NULL;
-  ssize_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);
+static int
+check_dsn_notify (const char* option __attribute__ ((unused)),
+                  unsigned long val, char* errbuf, ssize_t errlen)
+{
+    const char *p = (const char*)val;
+
+    while (p && *p) {
+        const char *q = m_strchrnul(p, ',');
+        int len = q - p;
+
+        if (!m_strncmp(p, "never", len)   && !m_strncmp(p, "delay", len)
+        &&  !m_strncmp(p, "failure", len) && !m_strncmp(p, "success", len))
+        {
+            if (errbuf)
+                snprintf(errbuf, errlen, _("'%.*s' is invalid for $%s"),
+                         len, p, "dsn_notify");
+            return 0;
+        }
 
-  for (i = 0; i < list->length; i++)
-    if (m_strncmp(list->data[i], "never", 5) != 0 &&
-        m_strncmp(list->data[i], "failure", 7) != 0 &&
-        m_strncmp(list->data[i], "delay", 5) != 0 &&
-        m_strncmp(list->data[i], "success", 7) != 0) {
-      if (errbuf)
-        snprintf (errbuf, errlen, _("'%s' is invalid for $%s"),
-                  (char*) list->data[i], "dsn_notify");
-      rc = 0;
-      break;
+        p = q + 1;
     }
-  list_del (&list, (list_del_t*)xmemfree);
-  return (rc);
+
+    return 1;
 }
 
 static int check_num (const char* option, unsigned long p,
@@ -1801,9 +1734,15 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
 
     /* resolve synonyms */
     if ((option = hash_find (ConfigOptions, tmp->data)) != NULL &&
-        DTYPE (option->type == DT_SYN)) {
+        DTYPE (option->type == DT_SYN))
+    {
       struct option_t* newopt = hash_find (ConfigOptions, (char*) option->data);
-      syn_add (newopt, option);
+      syn_t* syn = syn_new();
+      syn->f = m_strdup(CurRCFile);
+      syn->l = CurRCLine;
+      syn->n = newopt;
+      syn->o = option;
+      syn_list_push(&Synonyms, syn);
       option = newopt;
     }
 
@@ -2056,7 +1995,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) {
@@ -2566,7 +2505,7 @@ void mutt_init (int skip_sys_rc, string_list_t * commands)
   else
   if (*buffer != '@') {
     Fqdn = p_new(char, m_strlen(buffer) + m_strlen(Hostname) + 2);
-    sprintf (Fqdn, "%s.%s", NONULL(Hostname), buffer); /* __SPRINTF_CHECKED__ */
+    sprintf (Fqdn, "%s.%s", NONULL(Hostname), buffer);
   }
   else
     Fqdn = m_strdup(NONULL (Hostname));
@@ -2585,7 +2524,7 @@ void mutt_init (int skip_sys_rc, string_list_t * commands)
         q++;
       *q = '\0';
       NewsServer = m_strdup(p);
-      fclose (f);
+      m_fclose(&f);
     }
   }
   if ((p = getenv ("NNTPSERVER")))
@@ -2658,18 +2597,8 @@ void mutt_init (int skip_sys_rc, string_list_t * commands)
   mutt_init_history ();
 
   if (!Muttrc) {
-#if 0
-    snprintf (buffer, sizeof(buffer), "%s/.madmuttrc-%s", NONULL (Homedir),
-              MUTT_VERSION);
-    if (access (buffer, F_OK) == -1)
-#endif
       snprintf (buffer, sizeof(buffer), "%s/.madmuttrc", NONULL (Homedir));
     if (access (buffer, F_OK) == -1)
-#if 0
-      snprintf (buffer, sizeof(buffer), "%s/.madmutt/madmuttrc-%s",
-                NONULL (Homedir), MUTT_VERSION);
-    if (access (buffer, F_OK) == -1)
-#endif
       snprintf (buffer, sizeof(buffer), "%s/.madmutt/madmuttrc",
                 NONULL (Homedir));
 
@@ -2727,22 +2656,20 @@ void mutt_init (int skip_sys_rc, string_list_t * commands)
     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;
   }
 
@@ -2750,10 +2677,6 @@ void mutt_init (int skip_sys_rc, string_list_t * 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)
@@ -2766,61 +2689,30 @@ 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];
+/* dump out the value of all the variables we have */
+int mutt_dump_variables (int full) {
+    ssize_t i = 0;
 
-  if (DTYPE (option->type) == DT_SYN)
-    return;
+    /* get all non-synonyms into list... */
+    for (i = 0; MuttVars[i].option; i++) {
+        struct option_t *option = MuttVars + i;
+        char buf[LONG_STRING];
 
-  mutt_option_value (option->option, buf, sizeof(buf));
-  if (m_strcmp(buf, option->init) != 0)
-    list_push_back (l, option);
-}
+        if (DTYPE(option->type) == DT_SYN)
+            continue;
 
-/* dump out the value of all the variables we have */
-int mutt_dump_variables (int full) {
-  ssize_t i = 0;
-  char outbuf[STRING];
-  list2_t* tmp = NULL;
-  struct option_t* option = NULL;
+        if (!full) {
+            mutt_option_value(option->option, buf, sizeof(buf));
+            if (!m_strcmp(buf, option->init))
+                continue;
+        }
 
-  /* get all non-synonyms into list... */
-  hash_map (ConfigOptions, full ? opt_sel_full : opt_sel_diff,
-            (unsigned long) &tmp);
-
-  if (!list_empty(tmp)) {
-    /* ...and dump list sorted */
-    qsort (tmp->data, tmp->length, sizeof(void*), opt_cmp);
-    for (i = 0; i < tmp->length; i++) {
-      option = (struct option_t*) tmp->data[i];
-      FuncTable[DTYPE (option->type)].opt_to_string
-        (outbuf, sizeof(outbuf), option);
-      printf ("%s\n", outbuf);
+        printf("set ");
+        FuncTable[DTYPE(option->type)].opt_to_string
+            (buf, sizeof(buf), option);
+        printf ("%s\n", buf);
     }
-  }
-  list_del (&tmp, NULL);
-  return 0;
+
+    printf ("\n# vi""m:set ft=muttrc:\n");
+    return 0;
 }