vieter/src/cron/c/parse.c

#include "expression.h"

// This prefix is needed to properly compile
const uint8_t parse_month_days[] = {31, 28, 31, 30, 31, 30,
									31, 31, 30, 31, 30, 31};

// Allowed value ranges for the minute, hour, day and month field
const uint8_t min[4] = {0, 0, 1, 1};
const uint8_t max[4] = {59, 23, 31, 12};

const uint8_t min_parts = 2;
const uint8_t max_parts = 4;

// Convert a string into a uint8_t value by parsing it using atoi and checking
// whether it's contained within the given range
#define SAFE_ATOI(v, s, min, max)                                              \
	int _##v = atoi(s);                                                        \
	if ((_##v) == 0 && strcmp((s), "0") != 0) {                                \
		return cron_parse_invalid_number;                                      \
	}                                                                          \
	if (((_##v) < (min)) || ((_##v) > (max))) {                                \
		return cron_parse_out_of_range;                                        \
	}                                                                          \
	v = (uint8_t)(_##v);

#define MAX(x, y) (((x) > (y)) ? (x) : (y))

/**
 * Given a range expression, produce a bit field defining what numbers in the
 * min-max range the expression represents. Bit 0 (starting from the
 * right) corresponds to min, the bit max - min to max. All trailing bits
 * after this should be ignored. The given bitfield is modified in-place, so
 * multiple calls of this function can be performed on the same value to create
 * the effect of ORing their values.
 *
 * A range expression has one of the following forms:
 *
 * - *
 * - a
 * - a-b
 * - a/c
 * - a-b/c
 */
cron_parse_error ce_parse_range(uint64_t *out, char *s, uint8_t min,
								uint8_t max) {
	size_t slash_index = 0;
	size_t dash_index = 0;
	size_t i = 0;

	// We first iterate over the string to determine whether it contains a slash
	// and/or a dash. We know the dash can only be valid if it appears before
	// the slash.
	while (s[i] != '\0') {
		if (s[i] == '/') {
			// At most one slash is allowed
			if (i == 0 || slash_index != 0) {
				return cron_parse_invalid_expression;
			}

			slash_index = i;

			s[i] = '\0';
		} else if (s[i] == '-') {
			// At most one dash is allowed, and it must be before the slash
			if (i == 0 || dash_index != 0 || slash_index != 0) {
				return cron_parse_invalid_expression;
			}

			dash_index = i;

			s[i] = '\0';
		} else if (s[i] != '*' && (s[i] < '0' || s[i] > '9')) {
			return cron_parse_invalid_expression;
		}

		i++;
	}

	// Parse the three possible numbers in the pattern
	uint8_t start;
	uint8_t end = max;
	uint8_t interval = 0;

	if (s[0] == '*') {
		// A star character is only allowed on its own
		if (s[1] == '\0' && dash_index == 0) {
			start = min;
			interval = 1;
		} else {
			return cron_parse_invalid_expression;
		}
	} else {
		SAFE_ATOI(start, s, min, max);

		if (dash_index > 0) {
			SAFE_ATOI(end, &s[dash_index + 1], min, max);
			interval = 1;
		}
	}

	if (slash_index > 0) {
		SAFE_ATOI(interval, &s[slash_index + 1], 1, max - min);
	}

	if (interval == 0) {
		*out |= ((uint64_t)1) << (start - min);
	} else {
		while (start <= end) {
			*out |= ((uint64_t)1) << (start - min);
			start += interval;
		}
	}

	return cron_parse_ok;
}

/*
 * Given an expression part, produce a bitfield defining what numbers in the
 * min-max range the part represents. A part consists of one or more range
 * expressions, separated by commas.
 */
cron_parse_error ce_parse_part(uint64_t *out, char *s, uint8_t min,
							   uint8_t max) {
	*out = 0;

	char *next;
	cron_parse_error res;

	while ((next = strchr(s, ',')) != NULL) {
		next[0] = '\0';
		res = ce_parse_range(out, s, min, max);

		if (res != cron_parse_ok) {
			return res;
		}

		s = next + 1;
	}

	// Make sure to parse the final range as well
	return ce_parse_range(out, s, min, max);
}

/*
 * Return how many bits are set in the bitfield, better known as popcount. I
 * added my own implementation (taken from my algorithms course) as I don't want
 * to be dependent on GCC-specific extensions.
 */
uint8_t uint64_t_popcount(uint64_t n) {
	uint8_t c = 0;

	while (n != 0) {
		// This sets the least significant bit to zero (very cool)
		n &= n - 1;
		c++;
	}

	return c;
}

/*
 * Convert a bitfield into an array containing the numbers in the min-max range
 * it represents.
 */
uint8_t bf_to_nums(uint8_t **out, uint64_t bf, uint8_t min, uint8_t max) {
	// Each bit field only has `max - min + 1` meaningful bits. All other bits
	// should be ignored, and can be any value. By shifting the bit field back
	// and forth, we set these excessive bits to zero, ensuring popcount returns
	// the correct value.
	uint8_t excess_bits = 64 - (max - min + 1);
	bf = (bf << excess_bits) >> excess_bits;
	uint8_t size = uint64_t_popcount(bf);
	uint8_t *buf = malloc(size * sizeof(uint8_t));

	uint8_t i = 0, j = 0;

	while (j < size && i <= max - min) {
		if (((uint64_t)1 << i) & bf) {
			// Resize buffer if needed
			buf[j] = min + i;
			j++;
		}

		i++;
	}

	*out = buf;

	return size;
}

/*
 * Parse a cron expression string into a cron_expression struct.
 */
cron_parse_error ce_parse_expression(cron_expression *out, char *s) {
	// The parsing functions modify the input string in-place
	s = strdup(s);
	char *orig_s = s;

	cron_parse_error res = cron_parse_ok;

	// First we divide the input string into its parts, divided by spaces.
	// Each part is delimited by a NULL byte.
	uint8_t part_count = 0;
	char *parts[max_parts];
	char *next;

	// Skip leading spaces
	size_t offset = 0;

	while (s[offset] == ' ') {
		offset++;
	}

	s += offset;

	while (part_count < max_parts && ((next = strchr(s, ' ')) != NULL)) {
		next[0] = '\0';
		parts[part_count] = s;

		part_count++;

		// Skip multiple spaces
		offset = 1;
		while (next[offset] == ' ') {
			offset++;
		}
		s = next + offset;
	}

	// Each iteration of the loop skips all trailing spaces. This means that, if
	// s[0] isn't '\0', there's still another part before the end of the string.
	if (s[0] != '\0') {
		if (part_count == max_parts) {
			res = cron_parse_too_many_parts;
			goto end;
		}

		parts[part_count] = s;
		part_count++;
	}

	if (part_count < min_parts) {
		res = cron_parse_not_enough_parts;
		goto end;
	}

	// We now parse the parts in reverse. This is because the month part
	// determines the maximum value of the day part.

	uint64_t bit_field = 0;

	// Months
	if (part_count >= 4) {
		res = ce_parse_part(&bit_field, parts[3], min[3], max[3]);

		if (res != cron_parse_ok) {
			goto end;
		}

		out->month_count = bf_to_nums(&out->months, bit_field, min[3], max[3]);
	}
	// If months aren't provided, they're replaced with a *
	else {
		out->month_count = bf_to_nums(&out->months, ~0, min[3], max[3]);
	}

	// Determine what the largest allowed day value is, given the months
	uint8_t max_day_value = 0;

	for (uint8_t i = 0; i < out->month_count; i++) {
		max_day_value =
			MAX(max_day_value, parse_month_days[out->months[i] - 1]);
	}

	// Days
	if (part_count >= 3) {
		bit_field = 0;

		res = ce_parse_part(&bit_field, parts[2], min[2], max_day_value);

		if (res != cron_parse_ok) {
			free(out->months);

			goto end;
		}

		out->day_count =
			bf_to_nums(&out->days, bit_field, min[2], max_day_value);
	}
	// If days aren't provided, they're replaced with a *
	else {
		out->day_count = bf_to_nums(&out->days, ~0, min[2], max_day_value);
	}

	// Hours
	bit_field = 0;

	res = ce_parse_part(&bit_field, parts[1], min[1], max[1]);

	if (res != cron_parse_ok) {
		free(out->months);
		free(out->days);

		goto end;
	}

	out->hour_count = bf_to_nums(&out->hours, bit_field, min[1], max[1]);

	// Minutes
	bit_field = 0;

	res = ce_parse_part(&bit_field, parts[0], min[0], max[0]);

	if (res != cron_parse_ok) {
		free(out->months);
		free(out->days);
		free(out->hours);

		goto end;
	}

	out->minute_count = bf_to_nums(&out->minutes, bit_field, min[0], max[0]);

end:
	// s is cloned
	free(orig_s);

	return res;
}