feat(cron): next function in C

src/cron/expression/c/expression.c

@@ -0,0 +1,90 @@
+#include "expression.h"
+
+const uint8_t month_days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+int ce_next(SimpleTime *out, CronExpression *ce, SimpleTime *ref) {
+	// For all of these values, the rule is the following: if their value is
+	// the length of their respective array in the CronExpression object, that
+	// means we've looped back around. This means that the "bigger" value has
+	// to be incremented by one. For example, if the minutes have looped
+	// around, that means that the hour has to be incremented as well.
+    uint8_t month_index = 0;
+    uint8_t day_index = 0;
+    uint8_t hour_index = 0;
+    uint8_t minute_index = 0;
+
+	// This chain is the same logic multiple times, namely that if a "bigger"
+	// value loops around, then the smaller value will always reset as well.
+	// For example, if we're going to a new day, the hour & minute will always
+	// be their smallest value again.
+    while (month_index < ce->month_count && ref->month > ce->months[month_index]) {
+        month_index++;
+    }
+
+    if (month_index < ce->month_count && ref->month == ce->months[month_index]) {
+        while (day_index < ce->day_count && ref->day > ce->days[day_index]) {
+            day_index++;
+        }
+
+        if (day_index < ce->days_count && ref->day == ce->days[day_index]) {
+            while (hour_index < ce->hour_count && ref->hour > ce->hours[hour_index]) {
+                hour_index++;
+            }
+
+            if (hour_index < ce->hours_count && ref->hour == ce->hours[hour_index]) {
+				// Minute is the only value where we explicitely make sure we
+				// can't match sref's value exactly. This is to ensure we only
+				// return values in the future.
+                while (minute_index < ce->minute_count && ref->minute > ce->minutes[minute_index]) {
+                    minute_index++;
+                }
+            }
+        }
+    }
+
+	// Here, we increment the "bigger" values by one if the smaller ones loop
+	// around. The order is important, as it allows a sort-of waterfall effect
+	// to occur which updates all values if required.
+    if (minute_index == ce->minute_count && hour_index < ce->hour_count) {
+        hour_index++;
+    }
+
+    if (hour_index == ce->hour_count && day_index < ce->day_count) {
+        day_index++;
+    }
+
+    if (day_index == ce->day_count && month_index < ce->month_count) {
+        month_index++;
+    }
+
+    out->minute = ce->minutes[minute_index % ce->minute_count];
+    out->hour = ce->hours[hour_index % ce->hour_count];
+    out->day = ce->days[day_index % ce->day_count];
+
+	// Sometimes, we end up with a day that does not exist within the selected
+	// month, e.g. day 30 in February. When this occurs, we reset day back to
+	// the smallest value & loop over to the next month that does have this
+	// day.
+    if (out->day > month_days[ce->months[month_index % ce->month_count] - 1]) {
+        out->day = ce->days[0];
+        month_index++;
+
+        while (out->day > month_days[ce->months[month_index % ce->month_count] - 1]) {
+            month_index++;
+            
+            if (month_index == 2 * ce->month_count) {
+                return 1;
+            }
+        }
+    }
+
+    out->month = ce->months[month_index * ce->month_count];
+
+    if (month_index >= ce->month_count) {
+        out->year = ref->year + 1;
+    } else {
+        out->year = ref->year;
+    }
+
+    return 0;
+}

src/cron/expression/c/expression.h

@@ -21,9 +21,17 @@ typedef struct cron_expression {
     uint8_t month_count;
 } CronExpression;
 
+typedef struct simple_time {
+    int year;
+    int month;
+    int day;
+    int hour;
+    int minute;
+} SimpleTime;
+
 /**
  * Given a 
  */
-int ce_next(struct tm *out, struct tm *ref);
+int ce_next(SimpleTime *out, CronExpression *ce, SimpleTime *ref);
 
 ParseError ce_parse_expression(CronExpression *out, char *s);