libvieter/src/cron/vieter_cron_parse.c

#include "vieter_cron_parse.h"
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <time.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 vieter_cron_parse_invalid_number;                                   \
  }                                                                            \
  if (((_##v) < (min)) || ((_##v) > (max))) {                                  \
    return vieter_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
 */
vieter_cron_parse_error vieter_cron_expr_parse_range(uint64_t *out, char *s,
                                                     uint8_t min, uint8_t max) {
  size_t slash_index = 0, dash_index = 0;
  size_t s_index = 0;
  char cur_char;
  bool is_valid_character;

  while ((cur_char = s[s_index]) != '\0') {
    is_valid_character = cur_char == '/' || cur_char == '-' ||
                         cur_char == '*' ||
                         (cur_char >= '0' && cur_char <= '9');

    if (!is_valid_character) {
      return vieter_cron_parse_invalid_expression;
    }

    if (cur_char == '/') {
      if (s_index == 0 || slash_index != 0) {
        return vieter_cron_parse_invalid_expression;
      }

      slash_index = s_index;

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

      dash_index = s_index;

      s[s_index] = '\0';
    }

    s_index++;
  }

  uint8_t start;
  uint8_t end = max;
  uint8_t interval = 0;

  if (s[0] == '*') {
    if (s[1] != '\0' || dash_index != 0) {
      return vieter_cron_parse_invalid_expression;
    }

    start = min;
    interval = 1;
  } 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 vieter_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.
 */
vieter_cron_parse_error vieter_cron_expr_parse_part(uint64_t *out, char *s,
                                                    uint8_t min, uint8_t max) {
  *out = 0;

  char *next;
  vieter_cron_parse_error res;

  while ((next = strchr(s, ',')) != NULL) {
    next[0] = '\0';

    res = vieter_cron_expr_parse_range(out, s, min, max);

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

    s = next + 1;
  }

  // Make sure to parse the final range as well
  return vieter_cron_expr_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 set_bits = 0;

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

    set_bits++;
  }

  return set_bits;
}

/*
 * 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 bit_index = 0, buf_index = 0;

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

    bit_index++;
  }

  *out = buf;

  return size;
}

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

  vieter_cron_parse_error res = vieter_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_space;

  // Skip leading spaces
  size_t offset = 0;

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

  s += offset;

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

    parts[part_count] = s;
    part_count++;

    // Skip multiple spaces
    offset = 1;
    while (next_space[offset] == ' ') {
      offset++;
    }
    s = next_space + 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 = vieter_cron_parse_too_many_parts;
      goto end;
    }

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

  if (part_count < min_parts) {
    res = vieter_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 = vieter_cron_expr_parse_part(&bit_field, parts[3], min[3], max[3]);

    if (res != vieter_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 = vieter_cron_expr_parse_part(&bit_field, parts[2], min[2],
                                      max_day_value);

    if (res != vieter_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 = vieter_cron_expr_parse_part(&bit_field, parts[1], min[1], max[1]);

  if (res != vieter_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 = vieter_cron_expr_parse_part(&bit_field, parts[0], min[0], max[0]);

  if (res != vieter_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;
}