fix partial initialisation of Regex config

diff --git a/init.c b/init.c
index 306d5008c7ab803ca28c737febf8c67b4c920c02..ca11b8ba41ac6943f88885906bfda8de62d22fae 100644 (file)
--- a/init.c
+++ b/init.c
@@ -168,62 +168,28 @@ static int toggle_quadoption(int opt)
 
 static int parse_regex(int idx, struct Buffer *tmp, struct Buffer *err)
 {
-  int e, flags = 0;
-  const char *p = NULL;
-  regex_t *rx = NULL;
-  struct Regex *ptr = *(struct Regex **) MuttVars[idx].var;
+  struct Regex **ptr = (struct Regex **) MuttVars[idx].var;
 
-  if (ptr)
+  if (*ptr)
   {
     /* Same pattern as we already have */
-    if (mutt_str_strcmp(ptr->pattern, tmp->data) == 0)
+    if (mutt_str_strcmp((*ptr)->pattern, tmp->data) == 0)
       return 0;
   }
-  else
-  {
-    ptr = mutt_mem_calloc(1, sizeof(struct Regex));
-    *(struct Regex **) MuttVars[idx].var = ptr;
-  }
-
-  bool not = false;
 
-  /* Should we use smart case matching? */
-  if (((MuttVars[idx].flags & DT_REGEX_MATCH_CASE) == 0) && mutt_mb_is_lower(tmp->data))
-    flags |= REG_ICASE;
-
-  p = tmp->data;
-  /* Is a prefix of '!' allowed? */
-  if ((MuttVars[idx].flags & DT_REGEX_ALLOW_NOT) != 0)
+  if (mutt_buffer_is_empty(tmp))
   {
-    if (*p == '!')
-    {
-      not = true;
-      p++;
-    }
-  }
-
-  rx = mutt_mem_malloc(sizeof(regex_t));
-  e = REGCOMP(rx, p, flags);
-  if (e != 0)
-  {
-    regerror(e, rx, err->data, err->dsize);
-    FREE(&rx);
+    mutt_regex_free(ptr);
     return 0;
   }
 
-  /* get here only if everything went smoothly */
-  if (ptr->pattern)
-  {
-    FREE(&ptr->pattern);
-    regfree((regex_t *) ptr->regex);
-    FREE(&ptr->regex);
-  }
-
-  ptr->pattern = mutt_str_strdup(tmp->data);
-  ptr->regex = rx;
-  ptr->not = not;
+  struct Regex *rnew = mutt_regex_create(tmp->data, MuttVars[idx].flags, err);
+  if (!rnew)
+    return 1;
 
-  return 1;
+  mutt_regex_free(ptr);
+  *ptr = rnew;
+  return 0;
 }
 
 int query_quadoption(int opt, const char *prompt)
@@ -1924,9 +1890,9 @@ static void set_default(struct Option *p)
       break;
     case DT_REGEX:
     {
-      struct Regex *pp = (struct Regex *) p->var;
-      if (!p->initial && pp->pattern)
-        p->initial = (unsigned long) mutt_str_strdup(pp->pattern);
+      struct Regex **ptr = (struct Regex **) p->var;
+      if (!p->initial && *ptr && (*ptr)->pattern)
+        p->initial = (unsigned long) mutt_str_strdup((*ptr)->pattern);
       break;
     }
   }
@@ -1982,53 +1948,14 @@ static void restore_default(struct Option *p)
       break;
     case DT_REGEX:
     {
-      struct Regex **pp = (struct Regex **) p->var;
-      if (*pp)
-      {
-        FREE(&(*pp)->pattern);
-        if ((*pp)->regex)
-        {
-          regfree((*pp)->regex);
-          FREE(&(*pp)->regex);
-        }
-      }
-      else
-      {
-        *pp = mutt_mem_calloc(1, sizeof(struct Regex));
-      }
+      struct Regex **ptr = (struct Regex **) p->var;
 
-      if (p->initial)
-      {
-        int flags = 0;
-        char *s = (char *) p->initial;
+      if (*ptr)
+        mutt_regex_free(ptr);
 
-        (*pp)->regex = mutt_mem_calloc(1, sizeof(regex_t));
-        (*pp)->pattern = mutt_str_strdup((char *) p->initial);
-        if ((mutt_str_strcmp(p->name, "mask") != 0) &&
-            (mutt_mb_is_lower((const char *) p->initial)))
-        {
-          flags |= REG_ICASE;
-        }
-        if ((mutt_str_strcmp(p->name, "mask") == 0) && *s == '!')
-        {
-          s++;
-          (*pp)->not = true;
-        }
-        int rc = REGCOMP((*pp)->regex, s, flags);
-        if (rc != 0)
-        {
-          char msgbuf[STRING];
-          regerror(rc, (*pp)->regex, msgbuf, sizeof(msgbuf));
-          fprintf(stderr, _("restore_default(%s): error in regex: %s\n"),
-                  p->name, (*pp)->pattern);
-          fprintf(stderr, "%s\n", msgbuf);
-          mutt_sleep(0);
-          FREE(&(*pp)->pattern);
-          FREE(&(*pp)->regex);
-        }
-      }
+      *ptr = mutt_regex_create((const char *) p->initial, p->flags, NULL);
+      break;
     }
-    break;
   }
 
   if (p->flags & R_INDEX)