%{

/* Parse a string into an internal timestamp.

   Copyright (C) 1999-2000, 2002-2018 Free Software Foundation, Inc.

   This program is free software: you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

/* Originally written by Steven M. Bellovin <smb@research.att.com> while

   at the University of North Carolina at Chapel Hill.  Later tweaked by

   a couple of people on Usenet.  Completely overhauled by Rich $alz

   <rsalz@bbn.com> and Jim Berets <jberets@bbn.com> in August, 1990.

   Modified by Assaf Gordon <assafgordon@gmail.com> in 2016 to add

   debug output.

   Modified by Paul Eggert <eggert@twinsun.com> in 1999 to do the

   right thing about local DST.  Also modified by Paul Eggert

   <eggert@cs.ucla.edu> in 2004 to support nanosecond-resolution

   timestamps, in 2004 to support TZ strings in dates, and in 2017 to

   check for integer overflow and to support longer-than-'long'

   'time_t' and 'tv_nsec'.  */

#include <config.h>

#include "parse-datetime.h"

#include "intprops.h"

#include "timespec.h"

#include "verify.h"

#include "strftime.h"

/* There's no need to extend the stack, so there's no need to involve

   alloca.  */

#define YYSTACK_USE_ALLOCA 0

/* Tell Bison how much stack space is needed.  20 should be plenty for

   this grammar, which is not right recursive.  Beware setting it too

   high, since that might cause problems on machines whose

   implementations have lame stack-overflow checking.  */

#define YYMAXDEPTH 20

#define YYINITDEPTH YYMAXDEPTH

/* Since the code of parse-datetime.y is not included in the Emacs executable

   itself, there is no need to #define static in this file.  Even if

   the code were included in the Emacs executable, it probably

   wouldn't do any harm to #undef it here; this will only cause

   problems if we try to write to a static variable, which I don't

   think this code needs to do.  */

#ifdef emacs

# undef static

#endif

#include <inttypes.h>

#include <c-ctype.h>

#include <limits.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "gettext.h"

#define _(str) gettext (str)

/* Bison's skeleton tests _STDLIB_H, while some stdlib.h headers

   use _STDLIB_H_ as witness.  Map the latter to the one bison uses.  */

/* FIXME: this is temporary.  Remove when we have a mechanism to ensure

   that the version we're using is fixed, too.  */

#ifdef _STDLIB_H_

# undef _STDLIB_H

# define _STDLIB_H 1

#endif

/* The __attribute__ feature is available in gcc versions 2.5 and later.

   The __-protected variants of the attributes 'format' and 'printf' are

   accepted by gcc versions 2.6.4 (effectively 2.7) and later.

   Enable _GL_ATTRIBUTE_FORMAT only if these are supported too, because

   gnulib and libintl do '#define printf __printf__' when they override

   the 'printf' function.  */

#if 2 < __GNUC__ + (7 <= __GNUC_MINOR__)

# define _GL_ATTRIBUTE_FORMAT(spec) __attribute__ ((__format__ spec))

#else

# define _GL_ATTRIBUTE_FORMAT(spec) /* empty */

#endif

/* Shift A right by B bits portably, by dividing A by 2**B and

   truncating towards minus infinity.  A and B should be free of side

   effects, and B should be in the range 0 <= B <= INT_BITS - 2, where

   INT_BITS is the number of useful bits in an int.  GNU code can

   assume that INT_BITS is at least 32.

   ISO C99 says that A >> B is implementation-defined if A < 0.  Some

   implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift

   right in the usual way when A < 0, so SHR falls back on division if

   ordinary A >> B doesn't seem to be the usual signed shift.  */

#define SHR(a, b)       \

  (-1 >> 1 == -1        \

   ? (a) >> (b)         \

   : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))

#define HOUR(x) (60 * 60 * (x))

#define STREQ(a, b) (strcmp (a, b) == 0)

/* Verify that time_t is an integer as POSIX requires, and that every

   time_t value fits in intmax_t.  Please file a bug report if these

   assumptions are false on your platform.  */

verify (TYPE_IS_INTEGER (time_t));

verify (!TYPE_SIGNED (time_t) || INTMAX_MIN <= TYPE_MINIMUM (time_t));

verify (TYPE_MAXIMUM (time_t) <= INTMAX_MAX);

/* True if N is out of range for time_t.  */

static bool

time_overflow (intmax_t n)

{

  return ! ((TYPE_SIGNED (time_t) ? TYPE_MINIMUM (time_t) <= n : 0 <= n)

            && n <= TYPE_MAXIMUM (time_t));

}

/* Convert a possibly-signed character to an unsigned character.  This is

   a bit safer than casting to unsigned char, since it catches some type

   errors that the cast doesn't.  */

static unsigned char to_uchar (char ch) { return ch; }

static void _GL_ATTRIBUTE_FORMAT ((__printf__, 1, 2))

dbg_printf (char const *msg, ...)

{

  va_list args;

  /* TODO: use gnulib's 'program_name' instead?  */

  fputs ("date: ", stderr);

  va_start (args, msg);

  vfprintf (stderr, msg, args);

  va_end (args);

}

/* An integer value, and the number of digits in its textual

   representation.  */

typedef struct

{

  bool negative;

  intmax_t value;

  ptrdiff_t digits;

} textint;

/* An entry in the lexical lookup table.  */

typedef struct

{

  char const *name;

  int type;

  int value;

} table;

/* Meridian: am, pm, or 24-hour style.  */

enum { MERam, MERpm, MER24 };

/* A reasonable upper bound for the buffer used in debug output.  */

enum { DBGBUFSIZE = 100 };

enum { BILLION = 1000000000, LOG10_BILLION = 9 };

/* Relative times.  */

typedef struct

{

  /* Relative year, month, day, hour, minutes, seconds, and nanoseconds.  */

  intmax_t year;

  intmax_t month;

  intmax_t day;

  intmax_t hour;

  intmax_t minutes;

  intmax_t seconds;

  int ns;

} relative_time;

#if HAVE_COMPOUND_LITERALS

# define RELATIVE_TIME_0 ((relative_time) { 0, 0, 0, 0, 0, 0, 0 })

#else

static relative_time const RELATIVE_TIME_0;

#endif

/* Information passed to and from the parser.  */

typedef struct

{

  /* The input string remaining to be parsed.  */

  const char *input;

  /* N, if this is the Nth Tuesday.  */

  intmax_t day_ordinal;

  /* Day of week; Sunday is 0.  */

  int day_number;

  /* tm_isdst flag for the local zone.  */

  int local_isdst;

  /* Time zone, in seconds east of UT.  */

  int time_zone;

  /* Style used for time.  */

  int meridian;

  /* Gregorian year, month, day, hour, minutes, seconds, and nanoseconds.  */

  textint year;

  intmax_t month;

  intmax_t day;

  intmax_t hour;

  intmax_t minutes;

  struct timespec seconds; /* includes nanoseconds */

  /* Relative year, month, day, hour, minutes, seconds, and nanoseconds.  */

  relative_time rel;

  /* Presence or counts of nonterminals of various flavors parsed so far.  */

  bool timespec_seen;

  bool rels_seen;

  ptrdiff_t dates_seen;

  ptrdiff_t days_seen;

  ptrdiff_t local_zones_seen;

  ptrdiff_t dsts_seen;

  ptrdiff_t times_seen;

  ptrdiff_t zones_seen;

  bool year_seen;

  /* Print debugging output to stderr.  */

  bool parse_datetime_debug;

  /* Which of the 'seen' parts have been printed when debugging.  */

  bool debug_dates_seen;

  bool debug_days_seen;

  bool debug_local_zones_seen;

  bool debug_times_seen;

  bool debug_zones_seen;

  bool debug_year_seen;

  /* The user specified explicit ordinal day value.  */

  bool debug_ordinal_day_seen;

  /* Table of local time zone abbreviations, terminated by a null entry.  */

  table local_time_zone_table[3];

} parser_control;

union YYSTYPE;

static int yylex (union YYSTYPE *, parser_control *);

static int yyerror (parser_control const *, char const *);

static bool time_zone_hhmm (parser_control *, textint, intmax_t);

/* Extract into *PC any date and time info from a string of digits

   of the form e.g., YYYYMMDD, YYMMDD, HHMM, HH (and sometimes YYY,

   YYYY, ...).  */

static void

digits_to_date_time (parser_control *pc, textint text_int)

{

  if (pc->dates_seen && ! pc->year.digits

      && ! pc->rels_seen && (pc->times_seen || 2 < text_int.digits))

    {

      pc->year_seen = true;

      pc->year = text_int;

    }

  else

    {

      if (4 < text_int.digits)

        {

          pc->dates_seen++;

          pc->day = text_int.value % 100;

          pc->month = (text_int.value / 100) % 100;

          pc->year.value = text_int.value / 10000;

          pc->year.digits = text_int.digits - 4;

        }

      else

        {

          pc->times_seen++;

          if (text_int.digits <= 2)

            {

              pc->hour = text_int.value;

              pc->minutes = 0;

            }

          else

            {

              pc->hour = text_int.value / 100;

              pc->minutes = text_int.value % 100;

            }

          pc->seconds.tv_sec = 0;

          pc->seconds.tv_nsec = 0;

          pc->meridian = MER24;

        }

    }

}

/* Increment PC->rel by FACTOR * REL (FACTOR is 1 or -1).  Return true

   if successful, false if an overflow occurred.  */

static bool

apply_relative_time (parser_control *pc, relative_time rel, int factor)

{

  if (factor < 0

      ? (INT_SUBTRACT_WRAPV (pc->rel.ns, rel.ns, &pc->rel.ns)

         | INT_SUBTRACT_WRAPV (pc->rel.seconds, rel.seconds, &pc->rel.seconds)

         | INT_SUBTRACT_WRAPV (pc->rel.minutes, rel.minutes, &pc->rel.minutes)

         | INT_SUBTRACT_WRAPV (pc->rel.hour, rel.hour, &pc->rel.hour)

         | INT_SUBTRACT_WRAPV (pc->rel.day, rel.day, &pc->rel.day)

         | INT_SUBTRACT_WRAPV (pc->rel.month, rel.month, &pc->rel.month)

         | INT_SUBTRACT_WRAPV (pc->rel.year, rel.year, &pc->rel.year))

      : (INT_ADD_WRAPV (pc->rel.ns, rel.ns, &pc->rel.ns)

         | INT_ADD_WRAPV (pc->rel.seconds, rel.seconds, &pc->rel.seconds)

         | INT_ADD_WRAPV (pc->rel.minutes, rel.minutes, &pc->rel.minutes)

         | INT_ADD_WRAPV (pc->rel.hour, rel.hour, &pc->rel.hour)

         | INT_ADD_WRAPV (pc->rel.day, rel.day, &pc->rel.day)

         | INT_ADD_WRAPV (pc->rel.month, rel.month, &pc->rel.month)

         | INT_ADD_WRAPV (pc->rel.year, rel.year, &pc->rel.year)))

    return false;

  pc->rels_seen = true;

  return true;

}

/* Set PC-> hour, minutes, seconds and nanoseconds members from arguments.  */

static void

set_hhmmss (parser_control *pc, intmax_t hour, intmax_t minutes,

            time_t sec, int nsec)

{

  pc->hour = hour;

  pc->minutes = minutes;

  pc->seconds.tv_sec = sec;

  pc->seconds.tv_nsec = nsec;

}

/* Return a textual representation of the day ordinal/number values

   in the parser_control struct (e.g., "last wed", "this tues", "thu").  */

static const char *

str_days (parser_control *pc, char *buffer, int n)

{

  /* TODO: use relative_time_table for reverse lookup.  */

  static char const ordinal_values[][11] = {

     "last",

     "this",

     "next/first",

     "(SECOND)", /* SECOND is commented out in relative_time_table.  */

     "third",

     "fourth",

     "fifth",

     "sixth",

     "seventh",

     "eight",

     "ninth",

     "tenth",

     "eleventh",

     "twelfth"

  };

  static char const days_values[][4] = {

     "Sun",

     "Mon",

     "Tue",

     "Wed",

     "Thu",

     "Fri",

     "Sat"

  };

  int len;

  /* Don't add an ordinal prefix if the user didn't specify it

     (e.g., "this wed" vs "wed").  */

  if (pc->debug_ordinal_day_seen)

    {

      /* Use word description if possible (e.g., -1 = last, 3 = third).  */

      len = (-1 <= pc->day_ordinal && pc->day_ordinal <= 12

             ? snprintf (buffer, n, "%s", ordinal_values[pc->day_ordinal + 1])

             : snprintf (buffer, n, "%"PRIdMAX, pc->day_ordinal));

    }

  else

    {

      buffer[0] = '\0';

      len = 0;

    }

  /* Add the day name */

  if (0 <= pc->day_number && pc->day_number <= 6 && 0 <= len && len < n)

    snprintf (buffer + len, n - len, &" %s"[len == 0],

              days_values[pc->day_number]);

  else

    {

      /* invalid day_number value - should never happen */

    }

  return buffer;

}

/* Convert a time zone to its string representation.  */

enum { TIME_ZONE_BUFSIZE = INT_STRLEN_BOUND (intmax_t) + sizeof ":MM:SS" } ;

static char const *

time_zone_str (int time_zone, char time_zone_buf[TIME_ZONE_BUFSIZE])

{

  char *p = time_zone_buf;

  char sign = time_zone < 0 ? '-' : '+';

  int hour = abs (time_zone / (60 * 60));

  p += sprintf (time_zone_buf, "%c%02d", sign, hour);

  int offset_from_hour = abs (time_zone % (60 * 60));

  if (offset_from_hour != 0)

    {

      int mm = offset_from_hour / 60;

      int ss = offset_from_hour % 60;

      *p++ = ':';

      *p++ = '0' + mm / 10;

      *p++ = '0' + mm % 10;

      if (ss)

        {

          *p++ = ':';

          *p++ = '0' + ss / 10;

          *p++ = '0' + ss % 10;

        }

      *p = '\0';

    }

  return time_zone_buf;

}

/* debugging: print the current time in the parser_control structure.

   The parser will increment "*_seen" members for those which were parsed.

   This function will print only newly seen parts.  */

static void

debug_print_current_time (char const *item, parser_control *pc)

{

  bool space = false;

  if (!pc->parse_datetime_debug)

    return;

  /* no newline, more items printed below */

  dbg_printf (_("parsed %s part: "), item);

  if (pc->dates_seen && !pc->debug_dates_seen)

    {

      /*TODO: use pc->year.negative?  */

      fprintf (stderr, "(Y-M-D) %04"PRIdMAX"-%02"PRIdMAX"-%02"PRIdMAX,

              pc->year.value, pc->month, pc->day);

      pc->debug_dates_seen = true;

      space = true;

    }

  if (pc->year_seen != pc->debug_year_seen)

    {

      if (space)

        fputc (' ', stderr);

      fprintf (stderr, _("year: %04"PRIdMAX), pc->year.value);

      pc->debug_year_seen = pc->year_seen;

      space = true;

    }

  if (pc->times_seen && !pc->debug_times_seen)

    {

      intmax_t sec = pc->seconds.tv_sec;

      fprintf (stderr, &" %02"PRIdMAX":%02"PRIdMAX":%02"PRIdMAX[!space],

               pc->hour, pc->minutes, sec);

      if (pc->seconds.tv_nsec != 0)

        {

          int nsec = pc->seconds.tv_nsec;

          fprintf (stderr, ".%09d", nsec);

        }

      if (pc->meridian == MERpm)

        fputs ("pm", stderr);

      pc->debug_times_seen = true;

      space = true;

    }

  if (pc->days_seen && !pc->debug_days_seen)

    {

      if (space)

        fputc (' ', stderr);

      char tmp[DBGBUFSIZE];

      fprintf (stderr, _("%s (day ordinal=%"PRIdMAX" number=%d)"),

               str_days (pc, tmp, sizeof tmp),

               pc->day_ordinal, pc->day_number);

      pc->debug_days_seen = true;

      space = true;

    }

  /* local zone strings only change the DST settings,

     not the timezone value.  If seen, inform about the DST.  */

  if (pc->local_zones_seen && !pc->debug_local_zones_seen)

    {

      fprintf (stderr, &" isdst=%d%s"[!space],

               pc->local_isdst, pc->dsts_seen ? " DST" : "");

      pc->debug_local_zones_seen = true;

      space = true;

    }

  if (pc->zones_seen && !pc->debug_zones_seen)

    {

      char time_zone_buf[TIME_ZONE_BUFSIZE];

      fprintf (stderr, &" UTC%s"[!space],

               time_zone_str (pc->time_zone, time_zone_buf));

      pc->debug_zones_seen = true;

      space = true;

    }

  if (pc->timespec_seen)

    {

      intmax_t sec = pc->seconds.tv_sec;

      if (space)

        fputc (' ', stderr);

      fprintf (stderr, _("number of seconds: %"PRIdMAX), sec);

    }

  fputc ('\n', stderr);

}

/* Debugging: print the current relative values.  */

static bool

print_rel_part (bool space, intmax_t val, char const *name)

{

  if (val == 0)

    return space;

  fprintf (stderr, &" %+"PRIdMAX" %s"[!space], val, name);

  return true;

}

static void

debug_print_relative_time (char const *item, parser_control const *pc)

{

  bool space = false;

  if (!pc->parse_datetime_debug)

    return;

  /* no newline, more items printed below */

  dbg_printf (_("parsed %s part: "), item);

  if (pc->rel.year == 0 && pc->rel.month == 0 && pc->rel.day == 0

      && pc->rel.hour == 0 && pc->rel.minutes == 0 && pc->rel.seconds == 0

      && pc->rel.ns == 0)

    {

      /* Special case: relative time of this/today/now */

      fputs (_("today/this/now\n"), stderr);

      return;

    }

  space = print_rel_part (space, pc->rel.year, "year(s)");

  space = print_rel_part (space, pc->rel.month, "month(s)");

  space = print_rel_part (space, pc->rel.day, "day(s)");

  space = print_rel_part (space, pc->rel.hour, "hour(s)");

  space = print_rel_part (space, pc->rel.minutes, "minutes");

  space = print_rel_part (space, pc->rel.seconds, "seconds");

  print_rel_part (space, pc->rel.ns, "nanoseconds");

  fputc ('\n', stderr);

}

%}

/* We want a reentrant parser, even if the TZ manipulation and the calls to

   localtime and gmtime are not reentrant.  */

%pure-parser

%parse-param { parser_control *pc }

%lex-param { parser_control *pc }

/* This grammar has 31 shift/reduce conflicts.  */

%expect 31

%union

{

  intmax_t intval;

  textint textintval;

  struct timespec timespec;

  relative_time rel;

}

%token <intval> tAGO

%token tDST

%token tYEAR_UNIT tMONTH_UNIT tHOUR_UNIT tMINUTE_UNIT tSEC_UNIT

%token <intval> tDAY_UNIT tDAY_SHIFT

%token <intval> tDAY tDAYZONE tLOCAL_ZONE tMERIDIAN

%token <intval> tMONTH tORDINAL tZONE

%token <textintval> tSNUMBER tUNUMBER

%token <timespec> tSDECIMAL_NUMBER tUDECIMAL_NUMBER

%type <intval> o_colon_minutes

%type <timespec> seconds signed_seconds unsigned_seconds

%type <rel> relunit relunit_snumber dayshift

%%

spec:

    timespec

  | items

  ;

timespec:

    '@' seconds

      {

        pc->seconds = $2;

        pc->timespec_seen = true;

        debug_print_current_time (_("number of seconds"), pc);

      }

  ;

items:

    /* empty */

  | items item

  ;

item:

    datetime

      {

        pc->times_seen++; pc->dates_seen++;

        debug_print_current_time (_("datetime"), pc);

      }

  | time

      {

        pc->times_seen++;

        debug_print_current_time (_("time"), pc);

      }

  | local_zone

      {

        pc->local_zones_seen++;

        debug_print_current_time (_("local_zone"), pc);

      }

  | zone

      {

        pc->zones_seen++;

        debug_print_current_time (_("zone"), pc);

      }

  | date

      {

        pc->dates_seen++;

        debug_print_current_time (_("date"), pc);

      }

  | day

      {

        pc->days_seen++;

        debug_print_current_time (_("day"), pc);

      }

  | rel

      {

        debug_print_relative_time (_("relative"), pc);

      }

  | number

      {

        debug_print_current_time (_("number"), pc);

      }

  | hybrid

      {

        debug_print_relative_time (_("hybrid"), pc);

      }

  ;

datetime:

    iso_8601_datetime

  ;

iso_8601_datetime:

    iso_8601_date 'T' iso_8601_time

  ;

time:

    tUNUMBER tMERIDIAN

      {

        set_hhmmss (pc, $1.value, 0, 0, 0);

        pc->meridian = $2;

      }

  | tUNUMBER ':' tUNUMBER tMERIDIAN

      {

        set_hhmmss (pc, $1.value, $3.value, 0, 0);

        pc->meridian = $4;

      }

  | tUNUMBER ':' tUNUMBER ':' unsigned_seconds tMERIDIAN

      {

        set_hhmmss (pc, $1.value, $3.value, $5.tv_sec, $5.tv_nsec);

        pc->meridian = $6;

      }

  | iso_8601_time

  ;

iso_8601_time:

    tUNUMBER zone_offset

      {

        set_hhmmss (pc, $1.value, 0, 0, 0);

        pc->meridian = MER24;

      }

  | tUNUMBER ':' tUNUMBER o_zone_offset

      {

        set_hhmmss (pc, $1.value, $3.value, 0, 0);

        pc->meridian = MER24;

      }

  | tUNUMBER ':' tUNUMBER ':' unsigned_seconds o_zone_offset

      {

        set_hhmmss (pc, $1.value, $3.value, $5.tv_sec, $5.tv_nsec);

        pc->meridian = MER24;

      }

  ;

o_zone_offset:

  /* empty */

  | zone_offset

  ;

zone_offset:

    tSNUMBER o_colon_minutes

      {

        pc->zones_seen++;

        if (! time_zone_hhmm (pc, $1, $2)) YYABORT;

      }

  ;

/* Local zone strings affect only the DST setting, and take effect

   only if the current TZ setting is relevant.

   Example 1:

   'EEST' is parsed as tLOCAL_ZONE, as it relates to the effective TZ:

        TZ='Europe/Helsinki' date -d '2016-06-30 EEST'

   Example 2:

   'EEST' is parsed as tDAYZONE:

        TZ='Asia/Tokyo' date -d '2016-06-30 EEST'

   This is implemented by probing the next three calendar quarters

   of the effective timezone and looking for DST changes -

   if found, the timezone name (EEST) is inserted into

   the lexical lookup table with type tLOCAL_ZONE.

   (Search for 'quarter' comment in  'parse_datetime2'.)

*/

local_zone:

    tLOCAL_ZONE

      { pc->local_isdst = $1; }

  | tLOCAL_ZONE tDST

      {

        pc->local_isdst = 1;

        pc->dsts_seen++;

      }

  ;

/* Note 'T' is a special case, as it is used as the separator in ISO

   8601 date and time of day representation.  */

zone:

    tZONE

      { pc->time_zone = $1; }

  | 'T'

      { pc->time_zone = HOUR (7); }

  | tZONE relunit_snumber

      { pc->time_zone = $1;

        if (! apply_relative_time (pc, $2, 1)) YYABORT;

        debug_print_relative_time (_("relative"), pc);

      }

  | 'T' relunit_snumber

      { pc->time_zone = HOUR (7);

        if (! apply_relative_time (pc, $2, 1)) YYABORT;

        debug_print_relative_time (_("relative"), pc);

      }

  | tZONE tSNUMBER o_colon_minutes

      { if (! time_zone_hhmm (pc, $2, $3)) YYABORT;

        if (INT_ADD_WRAPV (pc->time_zone, $1, &pc->time_zone)) YYABORT; }

  | tDAYZONE

      { pc->time_zone = $1 + 60 * 60; }

  | tZONE tDST

      { pc->time_zone = $1 + 60 * 60; }

  ;

day:

    tDAY

      {

        pc->day_ordinal = 0;

        pc->day_number = $1;

      }

  | tDAY ','

      {

        pc->day_ordinal = 0;

        pc->day_number = $1;

      }

  | tORDINAL tDAY

      {

        pc->day_ordinal = $1;

        pc->day_number = $2;

        pc->debug_ordinal_day_seen = true;

      }

  | tUNUMBER tDAY

      {

        pc->day_ordinal = $1.value;

        pc->day_number = $2;

        pc->debug_ordinal_day_seen = true;

      }

  ;

date:

    tUNUMBER '/' tUNUMBER

      {

        pc->month = $1.value;

        pc->day = $3.value;

      }

  | tUNUMBER '/' tUNUMBER '/' tUNUMBER

      {

        /* Interpret as YYYY/MM/DD if the first value has 4 or more digits,

           otherwise as MM/DD/YY.

           The goal in recognizing YYYY/MM/DD is solely to support legacy

           machine-generated dates like those in an RCS log listing.  If

           you want portability, use the ISO 8601 format.  */

        if (4 <= $1.digits)

          {

            if (pc->parse_datetime_debug)

              {

                intmax_t digits = $1.digits;

                dbg_printf (_("warning: value %"PRIdMAX" has %"PRIdMAX" digits. "

                              "Assuming YYYY/MM/DD\n"),

                            $1.value, digits);

              }

            pc->year = $1;

            pc->month = $3.value;

            pc->day = $5.value;

          }

        else

          {

            if (pc->parse_datetime_debug)

              dbg_printf (_("warning: value %"PRIdMAX" has less than 4 digits. "

                            "Assuming MM/DD/YY[YY]\n"),

                          $1.value);

            pc->month = $1.value;

            pc->day = $3.value;

            pc->year = $5;

          }

      }

  | tUNUMBER tMONTH tSNUMBER

      {

        /* E.g., 17-JUN-1992.  */

        pc->day = $1.value;

        pc->month = $2;

        if (INT_SUBTRACT_WRAPV (0, $3.value, &pc->year.value)) YYABORT;

        pc->year.digits = $3.digits;

      }

  | tMONTH tSNUMBER tSNUMBER

      {

        /* E.g., JUN-17-1992.  */

        pc->month = $1;

        if (INT_SUBTRACT_WRAPV (0, $2.value, &pc->day)) YYABORT;

        if (INT_SUBTRACT_WRAPV (0, $3.value, &pc->year.value)) YYABORT;

        pc->year.digits = $3.digits;

      }

  | tMONTH tUNUMBER

      {

        pc->month = $1;

        pc->day = $2.value;

      }

  | tMONTH tUNUMBER ',' tUNUMBER

      {

        pc->month = $1;

        pc->day = $2.value;

        pc->year = $4;

      }

  | tUNUMBER tMONTH

      {

        pc->day = $1.value;

        pc->month = $2;

      }

  | tUNUMBER tMONTH tUNUMBER

      {

        pc->day = $1.value;

        pc->month = $2;

        pc->year = $3;

      }

  | iso_8601_date

  ;