diff --git a/src/cron/expression/c/expression.c b/src/cron/expression/c/expression.c deleted file mode 100644 index 3f65b6a..0000000 --- a/src/cron/expression/c/expression.c +++ /dev/null @@ -1,90 +0,0 @@ -#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; -} diff --git a/src/cron/expression/c/expression.h b/src/cron/expression/c/expression.h index 7abb189..5b8e4f9 100644 --- a/src/cron/expression/c/expression.h +++ b/src/cron/expression/c/expression.h @@ -3,13 +3,6 @@ #include #include -typedef enum parse_error { - ParseOk = 0, - ParseInvalidExpression = 1, - ParseInvalidNumber = 2, - ParseOutOfRange = 3 -} ParseError; - typedef struct cron_expression { uint8_t *minutes; uint8_t *hours; @@ -21,17 +14,9 @@ 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(SimpleTime *out, CronExpression *ce, SimpleTime *ref); +int ce_next(struct tm *out, struct tm *ref); -ParseError ce_parse_expression(CronExpression *out, char *s); +int ce_parse(CronExpression *out, char *s); diff --git a/src/cron/expression/c/parse.c b/src/cron/expression/c/parse.c index cb97373..17d416f 100644 --- a/src/cron/expression/c/parse.c +++ b/src/cron/expression/c/parse.c @@ -3,6 +3,13 @@ const uint8_t min[4] = {0, 0, 1, 1}; const uint8_t max[4] = {59, 23, 31, 12}; +typedef enum parse_error { + ParseOk = 0, + ParseInvalidExpression = 1, + ParseInvalidNumber = 2, + ParseOutOfRange = 3 +} ParseError; + #define SAFE_ATOI(v,s,min,max) \ int _##v = atoi(s); \ if ((_##v) == 0 && strcmp((s), "0") != 0) { \ @@ -118,41 +125,11 @@ ParseError ce_parse_part(uint64_t *out, char *s, uint8_t min, uint8_t max) { return ParseOk; } -uint8_t bf_to_nums(uint8_t **out, uint64_t bf, uint8_t min, uint8_t max) { - uint8_t capacity = 8; - uint8_t size = 0; - - uint8_t *buf = malloc(capacity * sizeof(uint8_t)); - - for (uint8_t i = 0; i <= max - min; i++) { - if ((1 << i) & bf) { - // Resize buffer if needed - if (size == capacity) { - capacity *= 2; - buf = realloc(buf, capacity * sizeof(uint8_t)); - } - - buf[size] = min + i; - size++; - } - } - - // Resize buffer once more to remove any trailing unused bytes - if (size < capacity) { - buf = realloc(buf, size * sizeof(uint8_t)); - } - - *out = buf; - - return size; -} - -ParseError ce_parse_expression(CronExpression *out, char *s) { +ParseError ce_parse_expression(uint64_t *out, char *s) { uint8_t part_count = 0; char *next; ParseError res; - uint64_t bfs[4]; // Skip leading spaces while (s[0] == ' ') { @@ -161,7 +138,7 @@ ParseError ce_parse_expression(CronExpression *out, char *s) { while (part_count < 4 && (next = strchr(s, ' ')) != NULL) { next[0] = '\0'; - res = ce_parse_part(&bfs[part_count], s, min[part_count], max[part_count]); + res = ce_parse_part(&out[part_count], s, min[part_count], max[part_count]); if (res != ParseOk) { return res; @@ -182,7 +159,7 @@ ParseError ce_parse_expression(CronExpression *out, char *s) { // Parse final trailing part if (part_count < 4 && s[0] != '\0') { // Make sure to parse the final range as well - res = ce_parse_part(&bfs[part_count], s, min[part_count], max[part_count]); + res = ce_parse_part(&out[part_count], s, min[part_count], max[part_count]); if (res != ParseOk) { return res; @@ -191,22 +168,12 @@ ParseError ce_parse_expression(CronExpression *out, char *s) { part_count++; } - // At least two parts need to be provided - if (part_count < 2) { - return ParseInvalidExpression; - } - // Ensure there's always 4 parts, as expressions can have between 2 and 4 parts while (part_count < 4) { // Expression is augmented with '*' expressions - bfs[part_count] = ~0; + out[part_count] = ~0; part_count++; } - out->minute_count = bf_to_nums(&out->minutes, bfs[0], min[0], max[0]); - out->hour_count = bf_to_nums(&out->hours, bfs[1], min[1], max[1]); - out->day_count = bf_to_nums(&out->days, bfs[2], min[2], max[2]); - out->month_count = bf_to_nums(&out->months, bfs[3], min[3], max[3]); - return ParseOk; } diff --git a/src/cron/expression/expression.c.v b/src/cron/expression/expression.c.v deleted file mode 100644 index ec39fd6..0000000 --- a/src/cron/expression/expression.c.v +++ /dev/null @@ -1,18 +0,0 @@ -module expression - -#flag -I @VMODROOT/c -#flag @VMODROOT/c/parse.o -#include "expression.h" - -pub struct C.CronExpression { - minutes &u8 - hours &u8 - days &u8 - months &u8 - minute_count u8 - hour_count u8 - day_count u8 - month_count u8 -} - -/* pub type CronExpression = C.CronExpression */ diff --git a/src/cron/expression/v.mod b/src/cron/expression/v.mod deleted file mode 100644 index e69de29..0000000