/* Generated by re2c 1.0.3 on Wed Jan 14 14:21:53 2026 */

#line 1 "ext/date/lib/parse_date.re"

/*

 * The MIT License (MIT)

 *

 * Copyright (c) 2015-2023 Derick Rethans

 * Copyright (c) 2018 MongoDB, Inc.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "timelib.h"

#include "timelib_private.h"

#include <ctype.h>

#include <errno.h>

#include <math.h>

#include <assert.h>

#include <limits.h>

#if defined(_MSC_VER)

# define strtoll(s, f, b) _atoi64(s)

#elif !defined(HAVE_STRTOLL)

# if defined(HAVE_ATOLL)

#  define strtoll(s, f, b) atoll(s)

# else

#  define strtoll(s, f, b) strtol(s, f, b)

# endif

#endif

#define EOI      257

#define TIME     258

#define DATE     259

#define TIMELIB_XMLRPC_SOAP    260

#define TIMELIB_TIME12         261

#define TIMELIB_TIME24         262

#define TIMELIB_GNU_NOCOLON    263

#define TIMELIB_GNU_NOCOLON_TZ 264

#define TIMELIB_ISO_NOCOLON    265

#define TIMELIB_AMERICAN       266

#define TIMELIB_ISO_DATE       267

#define TIMELIB_DATE_FULL      268

#define TIMELIB_DATE_TEXT      269

#define TIMELIB_DATE_NOCOLON   270

#define TIMELIB_PG_YEARDAY     271

#define TIMELIB_PG_TEXT        272

#define TIMELIB_PG_REVERSE     273

#define TIMELIB_CLF            274

#define TIMELIB_DATE_NO_DAY    275

#define TIMELIB_SHORTDATE_WITH_TIME 276

#define TIMELIB_DATE_FULL_POINTED 277

#define TIMELIB_TIME24_WITH_ZONE 278

#define TIMELIB_ISO_WEEK       279

#define TIMELIB_LF_DAY_OF_MONTH 280

#define TIMELIB_WEEK_DAY_OF_MONTH 281

#define TIMELIB_TIMEZONE       300

#define TIMELIB_AGO            301

#define TIMELIB_RELATIVE       310

#define TIMELIB_ERROR          999

/* Some compilers like AIX, defines uchar in sys/types.h */

#undef uchar

typedef unsigned char uchar;

#define   BSIZE    8192

#define   YYCTYPE      uchar

#define   YYCURSOR     cursor

#define   YYLIMIT      s->lim

#define   YYMARKER     s->ptr

#define   YYFILL(n)    return EOI;

#define   RET(i)       {s->cur = cursor; return i;}

#define timelib_string_free timelib_free

#define TIMELIB_HAVE_TIME() { if (s->time->have_time) { add_error(s, TIMELIB_ERR_DOUBLE_TIME, "Double time specification"); timelib_string_free(str); return TIMELIB_ERROR; } else { s->time->have_time = 1; s->time->h = 0; s->time->i = 0; s->time->s = 0; s->time->us = 0; } }

#define TIMELIB_UNHAVE_TIME() { s->time->have_time = 0; s->time->h = 0; s->time->i = 0; s->time->s = 0; s->time->us = 0; }

#define TIMELIB_HAVE_DATE() { if (s->time->have_date) { add_error(s, TIMELIB_ERR_DOUBLE_DATE, "Double date specification"); timelib_string_free(str); return TIMELIB_ERROR; } else { s->time->have_date = 1; } }

#define TIMELIB_UNHAVE_DATE() { s->time->have_date = 0; s->time->d = 0; s->time->m = 0; s->time->y = 0; }

#define TIMELIB_HAVE_RELATIVE() { s->time->have_relative = 1; }

#define TIMELIB_HAVE_WEEKDAY_RELATIVE() { s->time->have_relative = 1; s->time->relative.have_weekday_relative = 1; }

#define TIMELIB_HAVE_SPECIAL_RELATIVE() { s->time->have_relative = 1; s->time->relative.have_special_relative = 1; }

#define TIMELIB_HAVE_TZ() { s->cur = cursor; if (s->time->have_zone) { s->time->have_zone > 1 ? add_error(s, TIMELIB_ERR_DOUBLE_TZ, "Double timezone specification") : add_warning(s, TIMELIB_WARN_DOUBLE_TZ, "Double timezone specification"); timelib_string_free(str); s->time->have_zone++; return TIMELIB_ERROR; } else { s->time->have_zone++; } }

#define TIMELIB_INIT  s->cur = cursor; str = timelib_string(s); ptr = str

#define TIMELIB_DEINIT timelib_string_free(str)

#define TIMELIB_ADJUST_RELATIVE_WEEKDAY() if (in->time.have_weekday_relative && (in.rel.d > 0)) { in.rel.d -= 7; }

#define TIMELIB_PROCESS_YEAR(x, l) { \

  if (((x) == TIMELIB_UNSET) || ((l) >= 4)) { \

  /*  (x) = 0; */          \

  } else if ((x) < 100) {  \

    if ((x) < 70) {      \

      (x) += 2000;     \

    } else {             \

      (x) += 1900;     \

    }                    \

  }                        \

}

#ifdef DEBUG_PARSER

#define DEBUG_OUTPUT(s) printf("%s\n", s);

#define YYDEBUG(s,c) { if (s != -1) { printf("state: %d ", s); printf("[%c]\n", c); } }

#else

#define DEBUG_OUTPUT(s)

#define YYDEBUG(s,c)

#endif

typedef struct _timelib_elems {

  unsigned int   c; /* Number of elements */

  char         **v; /* Values */

} timelib_elems;

typedef struct _Scanner {

  int           fd;

  uchar        *lim, *str, *ptr, *cur, *tok, *pos;

  unsigned int  line, len;

  timelib_error_container *errors;

  timelib_time        *time;

  const timelib_tzdb  *tzdb;

} Scanner;

typedef struct _timelib_lookup_table {

  const char *name;

  int         type;

  int         value;

} timelib_lookup_table;

typedef struct _timelib_relunit {

  const char *name;

  int         unit;

  int         multiplier;

} timelib_relunit;

/* The timezone table. */

static const timelib_tz_lookup_table timelib_timezone_lookup[] = {

#include "timezonemap.h"

  { NULL, 0, 0, NULL },

};

static const timelib_tz_lookup_table timelib_timezone_fallbackmap[] = {

#include "fallbackmap.h"

  { NULL, 0, 0, NULL },

};

static const timelib_tz_lookup_table timelib_timezone_utc[] = {

  { "utc", 0, 0, "UTC" },

};

#if defined(_POSIX_TZNAME_MAX)

/* Solaris exposes _POSIX_TZNAME_MAX = 3 unless _XPG6 is defined.

 * That is too small for real-world timezone abbreviations ("EDT", "CEST", ...).

 */

# if defined(__sun__) && _POSIX_TZNAME_MAX < 6

#  define MAX_ABBR_LEN 6

# else

#  define MAX_ABBR_LEN _POSIX_TZNAME_MAX

# endif

#elif defined(TZNAME_MAX)

# define MAX_ABBR_LEN TZNAME_MAX

#else

# define MAX_ABBR_LEN 6

#endif

static timelib_relunit const timelib_relunit_lookup[] = {

  { "ms",           TIMELIB_MICROSEC, 1000 },

  { "msec",         TIMELIB_MICROSEC, 1000 },

  { "msecs",        TIMELIB_MICROSEC, 1000 },

  { "millisecond",  TIMELIB_MICROSEC, 1000 },

  { "milliseconds", TIMELIB_MICROSEC, 1000 },

  { "µs",           TIMELIB_MICROSEC,    1 },

  { "usec",         TIMELIB_MICROSEC,    1 },

  { "usecs",        TIMELIB_MICROSEC,    1 },

  { "µsec",         TIMELIB_MICROSEC,    1 },

  { "µsecs",        TIMELIB_MICROSEC,    1 },

  { "microsecond",  TIMELIB_MICROSEC,    1 },

  { "microseconds", TIMELIB_MICROSEC,    1 },

  { "sec",         TIMELIB_SECOND,  1 },

  { "secs",        TIMELIB_SECOND,  1 },

  { "second",      TIMELIB_SECOND,  1 },

  { "seconds",     TIMELIB_SECOND,  1 },

  { "min",         TIMELIB_MINUTE,  1 },

  { "mins",        TIMELIB_MINUTE,  1 },

  { "minute",      TIMELIB_MINUTE,  1 },

  { "minutes",     TIMELIB_MINUTE,  1 },

  { "hour",        TIMELIB_HOUR,    1 },

  { "hours",       TIMELIB_HOUR,    1 },

  { "day",         TIMELIB_DAY,     1 },

  { "days",        TIMELIB_DAY,     1 },

  { "week",        TIMELIB_DAY,     7 },

  { "weeks",       TIMELIB_DAY,     7 },

  { "fortnight",   TIMELIB_DAY,    14 },

  { "fortnights",  TIMELIB_DAY,    14 },

  { "forthnight",  TIMELIB_DAY,    14 },

  { "forthnights", TIMELIB_DAY,    14 },

  { "month",       TIMELIB_MONTH,   1 },

  { "months",      TIMELIB_MONTH,   1 },

  { "year",        TIMELIB_YEAR,    1 },

  { "years",       TIMELIB_YEAR,    1 },

  { "mondays",     TIMELIB_WEEKDAY, 1 },

  { "monday",      TIMELIB_WEEKDAY, 1 },

  { "mon",         TIMELIB_WEEKDAY, 1 },

  { "tuesdays",    TIMELIB_WEEKDAY, 2 },

  { "tuesday",     TIMELIB_WEEKDAY, 2 },

  { "tue",         TIMELIB_WEEKDAY, 2 },

  { "wednesdays",  TIMELIB_WEEKDAY, 3 },

  { "wednesday",   TIMELIB_WEEKDAY, 3 },

  { "wed",         TIMELIB_WEEKDAY, 3 },

  { "thursdays",   TIMELIB_WEEKDAY, 4 },

  { "thursday",    TIMELIB_WEEKDAY, 4 },

  { "thu",         TIMELIB_WEEKDAY, 4 },

  { "fridays",     TIMELIB_WEEKDAY, 5 },

  { "friday",      TIMELIB_WEEKDAY, 5 },

  { "fri",         TIMELIB_WEEKDAY, 5 },

  { "saturdays",   TIMELIB_WEEKDAY, 6 },

  { "saturday",    TIMELIB_WEEKDAY, 6 },

  { "sat",         TIMELIB_WEEKDAY, 6 },

  { "sundays",     TIMELIB_WEEKDAY, 0 },

  { "sunday",      TIMELIB_WEEKDAY, 0 },

  { "sun",         TIMELIB_WEEKDAY, 0 },

  { "weekday",     TIMELIB_SPECIAL, TIMELIB_SPECIAL_WEEKDAY },

  { "weekdays",    TIMELIB_SPECIAL, TIMELIB_SPECIAL_WEEKDAY },

  { NULL,          0,          0 }

};

/* The relative text table. */

static timelib_lookup_table const timelib_reltext_lookup[] = {

  { "first",    0,  1 },

  { "next",     0,  1 },

  { "second",   0,  2 },

  { "third",    0,  3 },

  { "fourth",   0,  4 },

  { "fifth",    0,  5 },

  { "sixth",    0,  6 },

  { "seventh",  0,  7 },

  { "eight",    0,  8 },

  { "eighth",   0,  8 },

  { "ninth",    0,  9 },

  { "tenth",    0, 10 },

  { "eleventh", 0, 11 },

  { "twelfth",  0, 12 },

  { "last",     0, -1 },

  { "previous", 0, -1 },

  { "this",     1,  0 },

  { NULL,       1,  0 }

};

/* The month table. */

static timelib_lookup_table const timelib_month_lookup[] = {

  { "jan",  0,  1 },

  { "feb",  0,  2 },

  { "mar",  0,  3 },

  { "apr",  0,  4 },

  { "may",  0,  5 },

  { "jun",  0,  6 },

  { "jul",  0,  7 },

  { "aug",  0,  8 },

  { "sep",  0,  9 },

  { "sept", 0,  9 },

  { "oct",  0, 10 },

  { "nov",  0, 11 },

  { "dec",  0, 12 },

  { "i",    0,  1 },

  { "ii",   0,  2 },

  { "iii",  0,  3 },

  { "iv",   0,  4 },

  { "v",    0,  5 },

  { "vi",   0,  6 },

  { "vii",  0,  7 },

  { "viii", 0,  8 },

  { "ix",   0,  9 },

  { "x",    0, 10 },

  { "xi",   0, 11 },

  { "xii",  0, 12 },

  { "january",   0,  1 },

  { "february",  0,  2 },

  { "march",     0,  3 },

  { "april",     0,  4 },

  { "may",       0,  5 },

  { "june",      0,  6 },

  { "july",      0,  7 },

  { "august",    0,  8 },

  { "september", 0,  9 },

  { "october",   0, 10 },

  { "november",  0, 11 },

  { "december",  0, 12 },

  {  NULL,       0,  0 }

};

#if 0

static char* timelib_ltrim(char *s)

{

  char *ptr = s;

  while (ptr[0] == ' ' || ptr[0] == '\t') {

    ptr++;

  }

  return ptr;

}

#endif

#if 0

uchar *fill(Scanner *s, uchar *cursor){

  if(!s->eof){

    unsigned int cnt = s->tok - s->bot;

    if(cnt){

      memcpy(s->bot, s->tok, s->lim - s->tok);

      s->tok = s->bot;

      s->ptr -= cnt;

      cursor -= cnt;

      s->pos -= cnt;

      s->lim -= cnt;

    }

    if((s->top - s->lim) < BSIZE){

      uchar *buf = (uchar*) timelib_malloc(((s->lim - s->bot) + BSIZE)*sizeof(uchar));

      memcpy(buf, s->tok, s->lim - s->tok);

      s->tok = buf;

      s->ptr = &buf[s->ptr - s->bot];

      cursor = &buf[cursor - s->bot];

      s->pos = &buf[s->pos - s->bot];

      s->lim = &buf[s->lim - s->bot];

      s->top = &s->lim[BSIZE];

      timelib_free(s->bot);

      s->bot = buf;

    }

    if((cnt = read(s->fd, (char*) s->lim, BSIZE)) != BSIZE){

      s->eof = &s->lim[cnt]; *(s->eof)++ = '\n';

    }

    s->lim += cnt;

  }

  return cursor;

}

#endif

static timelib_error_message *alloc_error_message(timelib_error_message **messages, int *count)

{

  /* Realloc in power of two increments */

  int is_pow2 = (*count & (*count - 1)) == 0;

  if (is_pow2) {

    size_t alloc_size = *count ? (*count * 2) : 1;

    *messages = timelib_realloc(*messages, alloc_size * sizeof(timelib_error_message));

  }

  return *messages + (*count)++;

}

static void add_warning(Scanner *s, int error_code, const char *error)

{

  timelib_error_message *message = alloc_error_message(&s->errors->warning_messages, &s->errors->warning_count);

  message->error_code = error_code;

  message->position = s->tok ? s->tok - s->str : 0;

  message->character = s->tok ? *s->tok : 0;

  message->message = timelib_strdup(error);

}

static void add_error(Scanner *s, int error_code, const char *error)

{

  timelib_error_message *message = alloc_error_message(&s->errors->error_messages, &s->errors->error_count);

  message->error_code = error_code;

  message->position = s->tok ? s->tok - s->str : 0;

  message->character = s->tok ? *s->tok : 0;

  message->message = timelib_strdup(error);

}

static void add_pbf_warning(Scanner *s, int error_code, const char *error, const char *sptr, const char *cptr)

{

  timelib_error_message *message = alloc_error_message(&s->errors->warning_messages, &s->errors->warning_count);

  message->error_code = error_code;

  message->position = cptr - sptr;

  message->character = *cptr;

  message->message = timelib_strdup(error);

}

static void add_pbf_error(Scanner *s, int error_code, const char *error, const char *sptr, const char *cptr)

{

  timelib_error_message *message = alloc_error_message(&s->errors->error_messages, &s->errors->error_count);

  message->error_code = error_code;

  message->position = cptr - sptr;

  message->character = *cptr;

  message->message = timelib_strdup(error);

}

static timelib_sll timelib_meridian(const char **ptr, timelib_sll h)

{

  timelib_sll retval = 0;

  while (!strchr("AaPp", **ptr)) {

    ++*ptr;

  }

  if (**ptr == 'a' || **ptr == 'A') {

    if (h == 12) {

      retval = -12;

    }

  } else if (h != 12) {

    retval = 12;

  }

  ++*ptr;

  if (**ptr == '.') {

    ++*ptr;

  }

  if (**ptr == 'M' || **ptr == 'm') {

    ++*ptr;

  }

  if (**ptr == '.') {

    ++*ptr;

  }

  return retval;

}

static timelib_sll timelib_meridian_with_check(const char **ptr, timelib_sll h)

{

  timelib_sll retval = 0;

  while (**ptr && !strchr("AaPp", **ptr)) {

    ++*ptr;

  }

  if(!**ptr) {

    return TIMELIB_UNSET;

  }

  if (**ptr == 'a' || **ptr == 'A') {

    if (h == 12) {

      retval = -12;

    }

  } else if (h != 12) {

    retval = 12;

  }

  ++*ptr;

  if (**ptr == '.') {

    ++*ptr;

    if (**ptr != 'm' && **ptr != 'M') {

      return TIMELIB_UNSET;

    }

    ++*ptr;

    if (**ptr != '.' ) {

      return TIMELIB_UNSET;

    }

    ++*ptr;

  } else if (**ptr == 'm' || **ptr == 'M') {

    ++*ptr;

  } else {

    return TIMELIB_UNSET;

  }

  return retval;

}

static char *timelib_string(Scanner *s)

{

  char *tmp = timelib_calloc(1, s->cur - s->tok + 1);

  memcpy(tmp, s->tok, s->cur - s->tok);

  return tmp;

}

static timelib_sll timelib_get_nr_ex(const char **ptr, int max_length, int *scanned_length)

{

  const char *begin, *end;

  char *str;

  timelib_sll tmp_nr = TIMELIB_UNSET;

  int len = 0;

  while ((**ptr < '0') || (**ptr > '9')) {

    if (**ptr == '\0') {

      return TIMELIB_UNSET;

    }

    ++*ptr;

  }

  begin = *ptr;

  while ((**ptr >= '0') && (**ptr <= '9') && len < max_length) {

    ++*ptr;

    ++len;

  }

  end = *ptr;

  if (scanned_length) {

    *scanned_length = end - begin;

  }

  str = timelib_calloc(1, end - begin + 1);

  memcpy(str, begin, end - begin);

  tmp_nr = strtoll(str, NULL, 10);

  timelib_free(str);

  return tmp_nr;

}

static timelib_sll timelib_get_nr(const char **ptr, int max_length)

{

  return timelib_get_nr_ex(ptr, max_length, NULL);

}

static void timelib_skip_day_suffix(const char **ptr)

{

  if (isspace((unsigned char)**ptr)) {

    return;

  }

  if (!timelib_strncasecmp(*ptr, "nd", 2) || !timelib_strncasecmp(*ptr, "rd", 2) ||!timelib_strncasecmp(*ptr, "st", 2) || !timelib_strncasecmp(*ptr, "th", 2)) {

    *ptr += 2;

  }

}

static timelib_sll timelib_get_frac_nr(const char **ptr)

{

  const char *begin, *end;

  char *str;

  double tmp_nr = TIMELIB_UNSET;

  while ((**ptr != '.') && (**ptr != ':') && ((**ptr < '0') || (**ptr > '9'))) {

    if (**ptr == '\0') {

      return TIMELIB_UNSET;

    }

    ++*ptr;

  }

  begin = *ptr;

  while ((**ptr == '.') || (**ptr == ':') || ((**ptr >= '0') && (**ptr <= '9'))) {

    ++*ptr;

  }

  end = *ptr;

  str = timelib_calloc(1, end - begin);

  memcpy(str, begin + 1, end - begin - 1);

  tmp_nr = strtod(str, NULL) * pow(10, 7 - (end - begin));

  timelib_free(str);

  return tmp_nr;

}

static timelib_ull timelib_get_signed_nr(Scanner *s, const char **ptr, int max_length)

{

  char *str, *str_ptr;

  timelib_sll tmp_nr = 0;

  int len = 0;

  /* Skip over non-numeric chars */

  while (((**ptr < '0') || (**ptr > '9')) && (**ptr != '+') && (**ptr != '-')) {

    if (**ptr == '\0') {

      add_error(s, TIMELIB_ERR_UNEXPECTED_DATA, "Found unexpected data");

      return 0;

    }

    ++*ptr;

  }

  /* Allocate string to feed to strtoll(): sign + length + '\0' */

  str = timelib_calloc(1, max_length + 2);

  str[0] = '+'; /* First position is the sign */

  str_ptr = str + 1;

  while ((**ptr == '+') || (**ptr == '-')) {

    if (**ptr == '-') {

      str[0] = str[0] == '+' ? '-' : '+';

    }

    ++*ptr;

  }

  while (((**ptr < '0') || (**ptr > '9'))) {

    if (**ptr == '\0') {

      timelib_free(str);

      add_error(s, TIMELIB_ERR_UNEXPECTED_DATA, "Found unexpected data");

      return 0;

    }

    ++*ptr;

  }

  while ((**ptr >= '0') && (**ptr <= '9') && len < max_length) {

    *str_ptr = **ptr;

    ++*ptr;

    ++str_ptr;

    ++len;

  }

  errno = 0;

  tmp_nr = strtoll(str, NULL, 10);

  if (errno == ERANGE) {

    timelib_free(str);

    add_error(s, TIMELIB_ERR_NUMBER_OUT_OF_RANGE, "Number out of range");

    return 0;

  }

  timelib_free(str);

  return tmp_nr;

}

static timelib_sll timelib_lookup_relative_text(const char **ptr, int *behavior)

{

  char *word;

  const char *begin = *ptr, *end;

  timelib_sll  value = 0;

  const timelib_lookup_table *tp;

  while ((**ptr >= 'A' && **ptr <= 'Z') || (**ptr >= 'a' && **ptr <= 'z')) {

    ++*ptr;

  }

  end = *ptr;

  word = timelib_calloc(1, end - begin + 1);

  memcpy(word, begin, end - begin);

  for (tp = timelib_reltext_lookup; tp->name; tp++) {

    if (timelib_strcasecmp(word, tp->name) == 0) {

      value = tp->value;

      *behavior = tp->type;

    }

  }

  timelib_free(word);

  return value;

}

static timelib_sll timelib_get_relative_text(const char **ptr, int *behavior)

{

  while (**ptr == ' ' || **ptr == '\t' || **ptr == '-' || **ptr == '/') {

    ++*ptr;

  }

  return timelib_lookup_relative_text(ptr, behavior);

}

static timelib_long timelib_lookup_month(const char **ptr)

{

  char *word;

  const char *begin = *ptr, *end;

  timelib_long  value = 0;

  const timelib_lookup_table *tp;

  while ((**ptr >= 'A' && **ptr <= 'Z') || (**ptr >= 'a' && **ptr <= 'z')) {

    ++*ptr;

  }

  end = *ptr;

  word = timelib_calloc(1, end - begin + 1);

  memcpy(word, begin, end - begin);

  for (tp = timelib_month_lookup; tp->name; tp++) {

    if (timelib_strcasecmp(word, tp->name) == 0) {

      value = tp->value;

    }

  }

  timelib_free(word);

  return value;

}

static timelib_long timelib_get_month(const char **ptr)

{

  while (**ptr == ' ' || **ptr == '\t' || **ptr == '-' || **ptr == '.' || **ptr == '/') {

    ++*ptr;

  }

  return timelib_lookup_month(ptr);

}

static void timelib_eat_spaces(const char **ptr)

{

  do {

    if (**ptr == ' ' || **ptr == '\t') {

      ++*ptr;

      continue;

    }

    if ((*ptr)[0] == '\xe2' && (*ptr)[1] == '\x80' && (*ptr)[2] == '\xaf') { // NNBSP

      *ptr += 3;

      continue;

    }

    if ((*ptr)[0] == '\xc2' && (*ptr)[1] == '\xa0') { // NBSP

      *ptr += 2;

      continue;

    }

    break;

  } while (true);

}

static void timelib_eat_until_separator(const char **ptr)

{

  ++*ptr;

  while (strchr(" \t.,:;/-0123456789", **ptr) == NULL) {

    ++*ptr;

  }

}

static const timelib_relunit* timelib_lookup_relunit(const char **ptr)

{

  char *word;

  const char *begin = *ptr, *end;

  const timelib_relunit *tp, *value = NULL;

  while (**ptr != '\0' && **ptr != ' ' && **ptr != ',' && **ptr != '\t' && **ptr != ';' && **ptr != ':' &&

    **ptr != '/' && **ptr != '.' && **ptr != '-' && **ptr != '(' && **ptr != ')' ) {

    ++*ptr;

  }

  end = *ptr;

  word = timelib_calloc(1, end - begin + 1);

  memcpy(word, begin, end - begin);

  for (tp = timelib_relunit_lookup; tp->name; tp++) {

    if (timelib_strcasecmp(word, tp->name) == 0) {

      value = tp;

      break;

    }

  }

  timelib_free(word);

  return value;

}

static void add_with_overflow(Scanner *s, timelib_sll *e, timelib_sll amount, int multiplier)

{

#if TIMELIB_HAVE_BUILTIN_SADDLL_OVERFLOW

  if (__builtin_saddll_overflow(*e, amount * multiplier, e)) {

    add_error(s, TIMELIB_ERR_NUMBER_OUT_OF_RANGE, "Number out of range");

  }

#else

  *e += (amount * multiplier);

#endif

}

/**

 * The time_part parameter is a flag. It can be TIMELIB_TIME_PART_KEEP in case

 * the time portion should not be reset to midnight, or

 * TIMELIB_TIME_PART_DONT_KEEP in case it does need to be reset. This is used

 * for not overwriting the time portion for 'X weekday'.

 */

static void timelib_set_relative(const char **ptr, timelib_sll amount, int behavior, Scanner *s, int time_part)

{

  const timelib_relunit* relunit;

  if (!(relunit = timelib_lookup_relunit(ptr))) {

    return;

  }

  switch (relunit->unit) {

    case TIMELIB_MICROSEC: add_with_overflow(s, &s->time->relative.us, amount, relunit->multiplier); break;

    case TIMELIB_SECOND:   add_with_overflow(s, &s->time->relative.s, amount, relunit->multiplier); break;

    case TIMELIB_MINUTE:   add_with_overflow(s, &s->time->relative.i, amount, relunit->multiplier); break;

    case TIMELIB_HOUR:     add_with_overflow(s, &s->time->relative.h, amount, relunit->multiplier); break;

    case TIMELIB_DAY:      add_with_overflow(s, &s->time->relative.d, amount, relunit->multiplier); break;

    case TIMELIB_MONTH:    add_with_overflow(s, &s->time->relative.m, amount, relunit->multiplier); break;

    case TIMELIB_YEAR:     add_with_overflow(s, &s->time->relative.y, amount, relunit->multiplier); break;

    case TIMELIB_WEEKDAY:

      TIMELIB_HAVE_WEEKDAY_RELATIVE();

      if (time_part != TIMELIB_TIME_PART_KEEP) {

        TIMELIB_UNHAVE_TIME();

      }

      s->time->relative.d += (amount > 0 ? amount - 1 : amount) * 7;

      s->time->relative.weekday = relunit->multiplier;

      s->time->relative.weekday_behavior = behavior;

      break;

    case TIMELIB_SPECIAL:

      TIMELIB_HAVE_SPECIAL_RELATIVE();

      if (time_part != TIMELIB_TIME_PART_KEEP) {

        TIMELIB_UNHAVE_TIME();

      }

      s->time->relative.special.type = relunit->multiplier;

      s->time->relative.special.amount = amount;

  }

}

static const timelib_tz_lookup_table* abbr_search(const char *word, timelib_long gmtoffset, int isdst)

{

  int first_found = 0;

  const timelib_tz_lookup_table  *tp, *first_found_elem = NULL;

  const timelib_tz_lookup_table  *fmp;

  if (timelib_strcasecmp("utc", word) == 0 || timelib_strcasecmp("gmt", word) == 0) {

    return timelib_timezone_utc;

  }

  for (tp = timelib_timezone_lookup; tp->name; tp++) {

    if (timelib_strcasecmp(word, tp->name) == 0) {

      if (!first_found) {

        first_found = 1;

        first_found_elem = tp;

        if (gmtoffset == -1) {

          return tp;

        }

      }

      if (tp->gmtoffset == gmtoffset) {

        return tp;

      }

    }

  }

  if (first_found) {

    return first_found_elem;

  }

  /* Still didn't find anything, let's find the zone solely based on

   * offset/isdst then */

  for (fmp = timelib_timezone_fallbackmap; fmp->name; fmp++) {

    if (fmp->gmtoffset == gmtoffset && fmp->type == isdst) {

      return fmp;

    }

  }

  return NULL;

}

static timelib_long timelib_lookup_abbr(const char **ptr, int *dst, char **tz_abbr, int *found)

{

  char *word;

  const char *begin = *ptr, *end;

  timelib_long  value = 0;

  const timelib_tz_lookup_table *tp;

  /* Only include A-Z, a-z, 0-9, /, _, and - in abbreviations/TZ IDs */

  while (

    (**ptr >= 'A' && **ptr <= 'Z') ||

    (**ptr >= 'a' && **ptr <= 'z') ||

    (**ptr >= '0' && **ptr <= '9') ||

    **ptr == '/' || **ptr == '_' || **ptr == '-' || **ptr == '+'

  ) {

    ++*ptr;

  }

  end = *ptr;

  word = timelib_calloc(1, end - begin + 1);

  memcpy(word, begin, end - begin);

  if (end - begin < MAX_ABBR_LEN && (tp = abbr_search(word, -1, 0))) {

    value = tp->gmtoffset;

    *dst = tp->type;

    value -= tp->type * 3600;

    *found = 1;

  } else {

    *found = 0;

  }

  *tz_abbr = word;

  return value;

}

#define sHOUR(a) (int)(a * 3600)

#define sMIN(a) (int)(a * 60)

static timelib_long timelib_parse_tz_cor(const char **ptr, int *tz_not_found)

{

  const char *begin = *ptr, *end;

  timelib_long  tmp;

  *tz_not_found = 1;

  while (isdigit((unsigned char)**ptr) || **ptr == ':') {

    ++*ptr;

  }

  end = *ptr;

  switch (end - begin) {

    case 1: /* H */

    case 2: /* HH */

      *tz_not_found = 0;

      return sHOUR(strtol(begin, NULL, 10));

    case 3: /* H:M */

    case 4: /* H:MM, HH:M, HHMM */

      if (begin[1] == ':') {

        *tz_not_found = 0;

        tmp = sHOUR(strtol(begin, NULL, 10)) + sMIN(strtol(begin + 2, NULL, 10));

        return tmp;

      } else if (begin[2] == ':') {

        *tz_not_found = 0;

        tmp = sHOUR(strtol(begin, NULL, 10)) + sMIN(strtol(begin + 3, NULL, 10));

        return tmp;

      } else {

        *tz_not_found = 0;

        tmp = strtol(begin, NULL, 10);

        return sHOUR(tmp / 100) + sMIN(tmp % 100);

      }

    case 5: /* HH:MM */

      if (begin[2] != ':') {

        break;

      }

      *tz_not_found = 0;

      tmp = sHOUR(strtol(begin, NULL, 10)) + sMIN(strtol(begin + 3, NULL, 10));

      return tmp;

    case 6: /* HHMMSS */

      *tz_not_found = 0;

      tmp = strtol(begin, NULL, 10);

      tmp = sHOUR(tmp / 10000) + sMIN((tmp / 100) % 100) + (tmp % 100);

      return tmp;

    case 8: /* HH:MM:SS */

      if (begin[2] != ':' || begin[5] != ':') {

        break;

      }

      *tz_not_found = 0;

      tmp = sHOUR(strtol(begin, NULL, 10)) + sMIN(strtol(begin + 3, NULL, 10)) + strtol(begin + 6, NULL, 10);

      return tmp;

  }

  return 0;

}

static timelib_long timelib_parse_tz_minutes(const char **ptr, timelib_time *t)

{

  timelib_long retval = TIMELIB_UNSET;

  const char *begin = *ptr;

  /* First character must be +/- */

  if (**ptr != '+' && **ptr != '-') {

    return retval;

  }

  ++*ptr;

  while (isdigit((unsigned char)**ptr)) {

    ++*ptr;

  }

  if (*begin == '+') {

    t->is_localtime = 1;

    t->zone_type = TIMELIB_ZONETYPE_OFFSET;

    t->dst = 0;

    retval = sMIN(strtol(begin + 1, NULL, 10));

  } else if (*begin == '-') {

    t->is_localtime = 1;

    t->zone_type = TIMELIB_ZONETYPE_OFFSET;

    t->dst = 0;

    retval = -1 * sMIN(strtol(begin + 1, NULL, 10));

  }

  return retval;

}

timelib_long timelib_parse_zone(const char **ptr, int *dst, timelib_time *t, int *tz_not_found, const timelib_tzdb *tzdb, timelib_tz_get_wrapper tz_wrapper)

{

  timelib_tzinfo *res;

  timelib_long            retval = 0;

  size_t paren_count = 0;

  *tz_not_found = 0;

  while (**ptr == ' ' || **ptr == '\t' || **ptr == '(') {

    paren_count += **ptr == '(';

    ++*ptr;

  }

  if ((*ptr)[0] == 'G' && (*ptr)[1] == 'M' && (*ptr)[2] == 'T' && ((*ptr)[3] == '+' || (*ptr)[3] == '-')) {

    *ptr += 3;

  }

  if (**ptr == '+') {

    ++*ptr;

    t->is_localtime = 1;

    t->zone_type = TIMELIB_ZONETYPE_OFFSET;

    t->dst = 0;

    retval = timelib_parse_tz_cor(ptr, tz_not_found);

  } else if (**ptr == '-') {

    ++*ptr;

    t->is_localtime = 1;

    t->zone_type = TIMELIB_ZONETYPE_OFFSET;

    t->dst = 0;

    retval = -1 * timelib_parse_tz_cor(ptr, tz_not_found);

  } else {

    int found = 0;

    timelib_long offset = 0;

    char *tz_abbr;

    t->is_localtime = 1;

    /* First, we lookup by abbreviation only */

    offset = timelib_lookup_abbr(ptr, dst, &tz_abbr, &found);

    if (found) {

      t->zone_type = TIMELIB_ZONETYPE_ABBR;

      t->dst = *dst;

      timelib_time_tz_abbr_update(t, tz_abbr);

    }

    /* Otherwise, we look if we have a TimeZone identifier */

    if (!found || strcmp("UTC", tz_abbr) == 0) {

      int dummy_error_code;

      if ((res = tz_wrapper(tz_abbr, tzdb, &dummy_error_code)) != NULL) {

        t->tz_info = res;

        t->zone_type = TIMELIB_ZONETYPE_ID;

        found++;

      }

    }

    timelib_free(tz_abbr);

    *tz_not_found = (found == 0);

    retval = offset;

  }

  while (paren_count > 0 && **ptr == ')') {

    ++*ptr;

    paren_count--;

  }

  return retval;

}