Merge commit 'fml/master' into next
[paraslash.git] / mood.c
diff --git a/mood.c b/mood.c
index cb1534b..239911f 100644 (file)
--- a/mood.c
+++ b/mood.c
@@ -6,8 +6,11 @@
 
 /** \file mood.c Paraslash's mood handling functions. */
 
+#include <time.h>
+#include <regex.h>
 #include <fnmatch.h>
 #include <osl.h>
+
 #include "para.h"
 #include "error.h"
 #include "string.h"
@@ -63,11 +66,11 @@ typedef int mood_score_function(const char *path, const struct afs_info *afsi,
  * Some mood parsers pre-process the data given in the mood line to compute a
  * structure which depends of the particular mood_method and which is used
  * later in the mood_score_function of the mood_method. The mood_parser may
- * store a pointer to its structure via the second argument.
+ * store a pointer to its structure via the void** pointer.
  *
  * \sa mood_open(), mood_cleanup_function, mood_score_function.
  */
-typedef int mood_parser(const char *, void **);
+typedef int mood_parser(int, char **, void **);
 
 /**
  * Deallocate resources which were allocated by the mood_parser.
@@ -165,11 +168,126 @@ static uint64_t int_sqrt(uint64_t x)
        return res;
 }
 
-static int mm_no_attributes_set_parser(const char *arg, __a_unused void **ignored)
+#define MOOD_COMPARATORS \
+       MC(LESS, <) \
+       MC(LESS_OR_EQUAL, <=) \
+       MC(EQUAL, =) \
+       MC(EQUAL2, ==) \
+       MC(NOT_EQUAL, !=) \
+       MC(NOT_EQUAL2, <>) \
+       MC(GREATER, >) \
+       MC(GREATER_OR_EQUAL, >=) \
+
+#define MC(a, b) MC_ ## a,
+enum mood_comparator_id {MOOD_COMPARATORS NUM_MOOD_COMPARATORS};
+#undef MC
+#define MC(a, b) # b,
+const char const *mood_comparators[] = {MOOD_COMPARATORS};
+#undef MC
+
+static int parse_mood_comparator(const char *word)
+{
+       int i;
+
+       for (i = 0; i < NUM_MOOD_COMPARATORS; i++)
+               if (!strcmp(word, mood_comparators[i]))
+                       return i;
+       return -E_MOOD_SYNTAX;
+}
+
+static int compare_int32(int32_t a, int32_t b, enum mood_comparator_id id)
 {
-       if (arg && *arg)
-               PARA_WARNING_LOG("ignored junk at eol: %s\n", arg);
+       int res;
+
+       switch (id) {
+       case MC_LESS:
+               res = a < b; break;
+       case MC_LESS_OR_EQUAL:
+               res = a <= b; break;
+       case MC_EQUAL:
+       case MC_EQUAL2:
+               res = a == b; break;
+       case MC_NOT_EQUAL:
+       case MC_NOT_EQUAL2:
+               res = a != b; break;
+       case MC_GREATER:
+               res = a > b; break;
+       case MC_GREATER_OR_EQUAL:
+               res = a >= b; break;
+       default:
+               PARA_EMERG_LOG("BUG: invalid mood comparator\n");
+               exit(EXIT_FAILURE);
+       }
+       return res? 100 : -100;
+}
+
+struct mm_year_data {
+       /** The year given at the mood line. */
+       int32_t year;
+       /** Used to detect Y2K issues. */
+       int32_t current_year;
+       /** <, <=, =, !=, >=, or >. */
+       enum mood_comparator_id id;
+};
+
+static int mm_year_parser(int argc, char **argv, void **private)
+{
+       int ret = -E_MOOD_SYNTAX;
+       struct mm_year_data *mmyd = para_malloc(sizeof(*mmyd));
+       time_t current_time;
+       struct tm *gmt;
+
+       if (argc != 2)
+               goto err;
+       ret = parse_mood_comparator(argv[1]);
+       mmyd->id = ret;
+       if (ret < 0)
+               goto err;
+       ret = para_atoi32(argv[2], &mmyd->year);
+       if (ret < 0)
+               goto err;
+       current_time = time(NULL);
+       gmt = gmtime(&current_time);
+       /* tm_year is the number of years since 1900 */
+       mmyd->current_year = gmt->tm_year + 1900;
+       *private = mmyd;
        return 1;
+err:
+       free(mmyd);
+       return ret;
+}
+
+static int mm_year_score_function(__a_unused const char *path,
+               __a_unused const struct afs_info *afsi,
+               const struct afh_info *afhi,
+               const void *private)
+{
+       const struct mm_year_data *mmyd = private;
+       int32_t tag_year;
+       int ret = para_atoi32(afhi->tags.year, &tag_year);
+
+       if (ret < 0) /* year tag not present or not a number */
+               return -100;
+       if (tag_year < 0)
+               return -100;
+       /* try to work around Y2K issues */
+       if (tag_year < 100) {
+               tag_year += 1900;
+               if (tag_year + 100 <= mmyd->current_year)
+                       tag_year += 100; /* assume tag_year >= 2000 */
+       }
+       return compare_int32(tag_year, mmyd->year, mmyd->id);
+}
+
+static void mm_year_cleanup(void *private)
+{
+       free(private);
+}
+
+static int mm_no_attributes_set_parser(int argc, __a_unused char **argv,
+               __a_unused void **ignored)
+{
+       return argc? -E_MOOD_SYNTAX : 1;
 }
 
 static int mm_no_attributes_set_score_function(__a_unused const char *path,
@@ -198,11 +316,10 @@ static int mm_played_rarely_score_function(__a_unused const char *path,
        return -100;
 }
 
-static int mm_played_rarely_parser(const char *arg, __a_unused void **ignored)
+static int mm_played_rarely_parser(int argc, __a_unused char **argv,
+               __a_unused void **ignored)
 {
-       if (arg && *arg)
-               PARA_WARNING_LOG("ignored junk at eol: %s\n", arg);
-       return 1;
+       return argc? -E_MOOD_SYNTAX : 1;
 }
 
 static int mm_path_matches_score_function(const char *path,
@@ -215,9 +332,11 @@ static int mm_path_matches_score_function(const char *path,
        return 100;
 }
 
-static int mm_path_matches_parser(const char *arg, void **data)
+static int mm_path_matches_parser(int argc, char **argv, void **data)
 {
-       *data = para_strdup(arg);
+       if (argc != 1)
+               return -E_MOOD_SYNTAX;
+       *data = para_strdup(argv[1]);
        return 1;
 }
 
@@ -226,16 +345,20 @@ static void mm_path_matches_cleanup(void *data)
        free(data);
 }
 
-static int mm_is_set_parser(const char *arg, void **bitnum)
+static int mm_is_set_parser(int argc, char **argv, void **bitnum)
 {
-       unsigned char *c = para_malloc(1);
-       int ret = get_attribute_bitnum_by_name(arg, c);
+       int ret;
+       unsigned char c, *res;
 
-       if (ret >= 0)
-               *bitnum = c;
-       else
-               free(c);
-       return ret;
+       if (argc != 1)
+               return -E_MOOD_SYNTAX;
+       ret = get_attribute_bitnum_by_name(argv[1], &c);
+       if (ret < 0)
+               return ret;
+       res = para_malloc(1);
+       *res = c;
+       *bitnum = res;
+       return 1;
 }
 
 static int mm_is_set_score_function(__a_unused const char *path,
@@ -323,6 +446,7 @@ static const struct mood_method mood_methods[] = {
        {DEFINE_MOOD_METHOD(played_rarely)},
        {DEFINE_MOOD_METHOD(is_set)},
        {DEFINE_MOOD_METHOD_WITH_CLEANUP(path_matches)},
+       {DEFINE_MOOD_METHOD_WITH_CLEANUP(year)},
        {.parser = NULL}
 };
 
@@ -476,8 +600,8 @@ check_for_if:
        ret = -E_MOOD_SYNTAX;
        if (!mood_methods[i].parser)
                goto out;
-       w++;
-       ret = mood_methods[i].parser(*w, &mi->parser_data);
+       ret = mood_methods[i].parser(num_words - 1 - (w - argv), w,
+               &mi->parser_data);
        if (ret < 0)
                goto out;
        mi->method = &mood_methods[i];