X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=score.c;h=7bf381192fd26dc663fdcfaa4f16244682f8afea;hp=fba01f826b443edc62bcb186ee586bdfc7c73682;hb=8f75834aeadb902879602a82a259f4d3bf9c569c;hpb=96d53ff49c308769efbf708e1e65819077cb7af6

diff --git a/score.c b/score.c
index fba01f8..7bf3811 100644
--- a/score.c
+++ b/score.c
@@ -7,18 +7,11 @@
  * please see the file GPL in the top level source directory.
  */
 
-#if HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include <lib-lib/lib-lib.h>
 
 #include "mutt.h"
 #include "sort.h"
-
-#include "lib/mem.h"
-#include "lib/intl.h"
-
-#include <string.h>
-#include <stdlib.h>
+#include "pattern.h"
 
 typedef struct score_t {
   char *str;
@@ -26,9 +19,18 @@ typedef struct score_t {
   int val;
   int exact;                    /* if this rule matches, don't evaluate any more */
   struct score_t *next;
-} SCORE;
+} score_t;
+DO_INIT(score_t, score);
+static void score_wipe(score_t *sc)
+{
+    pattern_list_wipe(&sc->pat);
+    p_delete(&sc->str);
+}
+DO_NEW(score_t, score);
+DO_DELETE(score_t, score);
+DO_SLIST(score_t, score, score_delete);
 
-SCORE *Score = NULL;
+static score_t *Score = NULL;
 
 void mutt_check_rescore (CONTEXT * ctx)
 {
@@ -54,62 +56,57 @@ void mutt_check_rescore (CONTEXT * ctx)
   unset_option (OPTNEEDRESCORE);
 }
 
-int mutt_parse_score (BUFFER * buf, BUFFER * s, unsigned long data,
+int mutt_parse_score (BUFFER * buf, BUFFER * s,
+                      unsigned long data __attribute__ ((unused)),
                       BUFFER * err)
 {
-  SCORE *ptr, *last;
   char *pattern, *pc;
   struct pattern_t *pat;
+  score_t **last;
 
   mutt_extract_token (buf, s, 0);
   if (!MoreArgs (s)) {
-    strfcpy (err->data, _("score: too few arguments"), err->dsize);
+    m_strcpy(err->data, err->dsize, _("score: too few arguments"));
     return (-1);
   }
   pattern = buf->data;
-  memset (buf, 0, sizeof (BUFFER));
+  p_clear(buf, 1);
   mutt_extract_token (buf, s, 0);
   if (MoreArgs (s)) {
-    FREE (&pattern);
-    strfcpy (err->data, _("score: too many arguments"), err->dsize);
+    p_delete(&pattern);
+    m_strcpy(err->data, err->dsize, _("score: too many arguments"));
     return (-1);
   }
 
   /* look for an existing entry and update the value, else add it to the end
      of the list */
-  for (ptr = Score, last = NULL; ptr; last = ptr, ptr = ptr->next)
-    if (mutt_strcmp (pattern, ptr->str) == 0)
+  for (last = &Score; *last; last = &(*last)->next) {
+    if (m_strcmp(pattern, (*last)->str) == 0)
       break;
-  if (!ptr) {
-    if ((pat = mutt_pattern_comp (pattern, 0, err)) == NULL) {
-      FREE (&pattern);
+  }
+  if (!*last) {
+    if (!(pat = mutt_pattern_comp(pattern, 0, err))) {
+      p_delete(&pattern);
       return (-1);
     }
-    ptr = safe_calloc (1, sizeof (SCORE));
-    if (last)
-      last->next = ptr;
-    else
-      Score = ptr;
-    ptr->pat = pat;
-    ptr->str = pattern;
+    *last = score_new();
+    (*last)->pat = pat;
+    (*last)->str = pattern;
   }
   pc = buf->data;
-  if (*pc == '=') {
-    ptr->exact = 1;
-    pc++;
-  }
-  ptr->val = atoi (pc);
-  set_option (OPTNEEDRESCORE);
+  pc += (*last)->exact = (*pc == '=');
+  (*last)->val = atoi(pc);
+  set_option(OPTNEEDRESCORE);
   return 0;
 }
 
 void mutt_score_message (CONTEXT * ctx, HEADER * hdr, int upd_ctx)
 {
-  SCORE *tmp;
+  score_t *tmp;
 
   hdr->score = 0;               /* in case of re-scoring */
   for (tmp = Score; tmp; tmp = tmp->next) {
-    if (mutt_pattern_exec (tmp->pat, 0, NULL, hdr) > 0) {
+    if (mutt_pattern_exec (tmp->pat, M_MATCH_FULL_ADDRESS, NULL, hdr) > 0) {
       if (tmp->exact || tmp->val == 9999 || tmp->val == -9999) {
         hdr->score = tmp->val;
         break;
@@ -128,37 +125,26 @@ void mutt_score_message (CONTEXT * ctx, HEADER * hdr, int upd_ctx)
     _mutt_set_flag (ctx, hdr, M_FLAG, 1, upd_ctx);
 }
 
-int mutt_parse_unscore (BUFFER * buf, BUFFER * s, unsigned long data,
-                        BUFFER * err)
+int mutt_parse_unscore(BUFFER * buf, BUFFER * s,
+                       unsigned long data __attribute__ ((unused)),
+                       BUFFER * err __attribute__ ((unused)))
 {
-  SCORE *tmp, *last = NULL;
-
-  while (MoreArgs (s)) {
-    mutt_extract_token (buf, s, 0);
-    if (!mutt_strcmp ("*", buf->data)) {
-      for (tmp = Score; tmp;) {
-        last = tmp;
-        tmp = tmp->next;
-        mutt_pattern_free (&last->pat);
-        FREE (&last);
-      }
-      Score = NULL;
-    }
-    else {
-      for (tmp = Score; tmp; last = tmp, tmp = tmp->next) {
-        if (!mutt_strcmp (buf->data, tmp->str)) {
-          if (last)
-            last->next = tmp->next;
-          else
-            Score = tmp->next;
-          mutt_pattern_free (&tmp->pat);
-          FREE (&tmp);
-          /* there should only be one score per pattern, so we can stop here */
-          break;
+    while (MoreArgs(s)) {
+        mutt_extract_token(buf, s, 0);
+        if (!m_strcmp("*", buf->data)) {
+            score_list_wipe(&Score);
+        } else {
+            score_t **last;
+
+            for (last = &Score; *last; last = &(*last)->next) {
+                if (!m_strcmp(buf->data, (*last)->str)) {
+                    score_t *tmp = score_list_pop(last);
+                    score_delete(&tmp);
+                    break;
+                }
+            }
         }
-      }
     }
-  }
-  set_option (OPTNEEDRESCORE);
-  return 0;
+    set_option (OPTNEEDRESCORE);
+    return 0;
 }