LCOV - code coverage report
Current view: top level - source3/modules - getdate.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 0 231 0.0 %
Date: 2021-09-23 10:06:22 Functions: 0 2 0.0 %

          Line data    Source code
       1             : /* A Bison parser, made by GNU Bison 3.0.4.  */
       2             : 
       3             : /* Bison implementation for Yacc-like parsers in C
       4             : 
       5             :    Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
       6             : 
       7             :    This program is free software: you can redistribute it and/or modify
       8             :    it under the terms of the GNU General Public License as published by
       9             :    the Free Software Foundation, either version 3 of the License, or
      10             :    (at your option) any later version.
      11             : 
      12             :    This program is distributed in the hope that it will be useful,
      13             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :    GNU General Public License for more details.
      16             : 
      17             :    You should have received a copy of the GNU General Public License
      18             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
      19             : 
      20             : /* As a special exception, you may create a larger work that contains
      21             :    part or all of the Bison parser skeleton and distribute that work
      22             :    under terms of your choice, so long as that work isn't itself a
      23             :    parser generator using the skeleton or a modified version thereof
      24             :    as a parser skeleton.  Alternatively, if you modify or redistribute
      25             :    the parser skeleton itself, you may (at your option) remove this
      26             :    special exception, which will cause the skeleton and the resulting
      27             :    Bison output files to be licensed under the GNU General Public
      28             :    License without this special exception.
      29             : 
      30             :    This special exception was added by the Free Software Foundation in
      31             :    version 2.2 of Bison.  */
      32             : 
      33             : /* C LALR(1) parser skeleton written by Richard Stallman, by
      34             :    simplifying the original so-called "semantic" parser.  */
      35             : 
      36             : /* All symbols defined below should begin with yy or YY, to avoid
      37             :    infringing on user name space.  This should be done even for local
      38             :    variables, as they might otherwise be expanded by user macros.
      39             :    There are some unavoidable exceptions within include files to
      40             :    define necessary library symbols; they are noted "INFRINGES ON
      41             :    USER NAME SPACE" below.  */
      42             : 
      43             : /* Identify Bison output.  */
      44             : #define YYBISON 1
      45             : 
      46             : /* Bison version.  */
      47             : #define YYBISON_VERSION "3.0.4"
      48             : 
      49             : /* Skeleton name.  */
      50             : #define YYSKELETON_NAME "yacc.c"
      51             : 
      52             : /* Pure parsers.  */
      53             : #define YYPURE 1
      54             : 
      55             : /* Push parsers.  */
      56             : #define YYPUSH 0
      57             : 
      58             : /* Pull parsers.  */
      59             : #define YYPULL 1
      60             : 
      61             : 
      62             : 
      63             : 
      64             : /* Copy the first part of user declarations.  */
      65             : #line 1 "source3/modules/getdate.y" /* yacc.c:339  */
      66             : 
      67             : /* Parse a string into an internal time stamp.
      68             :    Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
      69             : 
      70             :    This program is free software; you can redistribute it and/or modify
      71             :    it under the terms of the GNU General Public License as published by
      72             :    the Free Software Foundation; either version 2, or (at your option)
      73             :    any later version.
      74             : 
      75             :    This program is distributed in the hope that it will be useful,
      76             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      77             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      78             :    GNU General Public License for more details.
      79             : 
      80             :    You should have received a copy of the GNU General Public License
      81             :    along with this program; if not, see <http://www.gnu.org/licenses/>.  */
      82             : 
      83             : /* Originally written by Steven M. Bellovin <smb@research.att.com> while
      84             :    at the University of North Carolina at Chapel Hill.  Later tweaked by
      85             :    a couple of people on Usenet.  Completely overhauled by Rich $alz
      86             :    <rsalz@bbn.com> and Jim Berets <jberets@bbn.com> in August, 1990.
      87             : 
      88             :    Modified by Paul Eggert <eggert@twinsun.com> in August 1999 to do
      89             :    the right thing about local DST.  Unlike previous versions, this
      90             :    version is reentrant.  */
      91             : 
      92             : #ifdef HAVE_CONFIG_H
      93             : # include <config.h>
      94             : # ifdef HAVE_ALLOCA_H
      95             : #  include <alloca.h>
      96             : # endif
      97             : #endif
      98             : 
      99             : /* Since the code of getdate.y is not included in the Emacs executable
     100             :    itself, there is no need to #define static in this file.  Even if
     101             :    the code were included in the Emacs executable, it probably
     102             :    wouldn't do any harm to #undef it here; this will only cause
     103             :    problems if we try to write to a static variable, which I don't
     104             :    think this code needs to do.  */
     105             : #ifdef emacs
     106             : # undef static
     107             : #endif
     108             : 
     109             : #include <ctype.h>
     110             : #include <string.h>
     111             : 
     112             : #ifdef HAVE_STDLIB_H
     113             : # include <stdlib.h> /* for `free'; used by Bison 1.27 */
     114             : #endif
     115             : 
     116             : #if STDC_HEADERS || (! defined isascii && ! HAVE_ISASCII)
     117             : # define IN_CTYPE_DOMAIN(c) 1
     118             : #else
     119             : # define IN_CTYPE_DOMAIN(c) isascii (c)
     120             : #endif
     121             : 
     122             : #define ISSPACE(c) (IN_CTYPE_DOMAIN (c) && isspace (c))
     123             : #define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha (c))
     124             : #define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower (c))
     125             : #define ISDIGIT_LOCALE(c) (IN_CTYPE_DOMAIN (c) && isdigit (c))
     126             : 
     127             : /* ISDIGIT differs from ISDIGIT_LOCALE, as follows:
     128             :    - Its arg may be any int or unsigned int; it need not be an unsigned char.
     129             :    - It's guaranteed to evaluate its argument exactly once.
     130             :    - It's typically faster.
     131             :    POSIX says that only '0' through '9' are digits.  Prefer ISDIGIT to
     132             :    ISDIGIT_LOCALE unless it's important to use the locale's definition
     133             :    of `digit' even when the host does not conform to POSIX.  */
     134             : #define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
     135             : 
     136             : #if STDC_HEADERS || HAVE_STRING_H
     137             : # include <string.h>
     138             : #endif
     139             : 
     140             : #ifndef HAVE___ATTRIBUTE__
     141             : # define __attribute__(x)
     142             : #endif
     143             : 
     144             : #ifndef ATTRIBUTE_UNUSED
     145             : # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
     146             : #endif
     147             : 
     148             : #define EPOCH_YEAR 1970
     149             : #define TM_YEAR_BASE 1900
     150             : 
     151             : #define HOUR(x) ((x) * 60)
     152             : 
     153             : /* An integer value, and the number of digits in its textual
     154             :    representation.  */
     155             : typedef struct
     156             : {
     157             :   int value;
     158             :   int digits;
     159             : } textint;
     160             : 
     161             : /* An entry in the lexical lookup table.  */
     162             : typedef struct
     163             : {
     164             :   char const *name;
     165             :   int type;
     166             :   int value;
     167             : } table;
     168             : 
     169             : /* Meridian: am, pm, or 24-hour style.  */
     170             : enum { MERam, MERpm, MER24 };
     171             : 
     172             : /* Information passed to and from the parser.  */
     173             : struct parser_control
     174             : {
     175             :   /* The input string remaining to be parsed. */
     176             :   const char *input;
     177             : 
     178             :   /* N, if this is the Nth Tuesday.  */
     179             :   int day_ordinal;
     180             : 
     181             :   /* Day of week; Sunday is 0.  */
     182             :   int day_number;
     183             : 
     184             :   /* tm_isdst flag for the local zone.  */
     185             :   int local_isdst;
     186             : 
     187             :   /* Time zone, in minutes east of UTC.  */
     188             :   int time_zone;
     189             : 
     190             :   /* Style used for time.  */
     191             :   int meridian;
     192             : 
     193             :   /* Gregorian year, month, day, hour, minutes, and seconds.  */
     194             :   textint year;
     195             :   int month;
     196             :   int day;
     197             :   int hour;
     198             :   int minutes;
     199             :   int seconds;
     200             : 
     201             :   /* Relative year, month, day, hour, minutes, and seconds.  */
     202             :   int rel_year;
     203             :   int rel_month;
     204             :   int rel_day;
     205             :   int rel_hour;
     206             :   int rel_minutes;
     207             :   int rel_seconds;
     208             : 
     209             :   /* Counts of nonterminals of various flavors parsed so far.  */
     210             :   int dates_seen;
     211             :   int days_seen;
     212             :   int local_zones_seen;
     213             :   int rels_seen;
     214             :   int times_seen;
     215             :   int zones_seen;
     216             : 
     217             :   /* Table of local time zone abbrevations, terminated by a null entry.  */
     218             :   table local_time_zone_table[3];
     219             : };
     220             : 
     221             : 
     222             : #line 223 "source3/modules/getdate.c" /* yacc.c:339  */
     223             : 
     224             : # ifndef YY_NULLPTR
     225             : #  if defined __cplusplus && 201103L <= __cplusplus
     226             : #   define YY_NULLPTR nullptr
     227             : #  else
     228             : #   define YY_NULLPTR 0
     229             : #  endif
     230             : # endif
     231             : 
     232             : /* Enabling verbose error messages.  */
     233             : #ifdef YYERROR_VERBOSE
     234             : # undef YYERROR_VERBOSE
     235             : # define YYERROR_VERBOSE 1
     236             : #else
     237             : # define YYERROR_VERBOSE 0
     238             : #endif
     239             : 
     240             : 
     241             : /* Debug traces.  */
     242             : #ifndef YYDEBUG
     243             : # define YYDEBUG 0
     244             : #endif
     245             : #if YYDEBUG
     246             : extern int yydebug;
     247             : #endif
     248             : 
     249             : /* Token type.  */
     250             : #ifndef YYTOKENTYPE
     251             : # define YYTOKENTYPE
     252             :   enum yytokentype
     253             :   {
     254             :     tAGO = 258,
     255             :     tDST = 259,
     256             :     tDAY = 260,
     257             :     tDAY_UNIT = 261,
     258             :     tDAYZONE = 262,
     259             :     tHOUR_UNIT = 263,
     260             :     tLOCAL_ZONE = 264,
     261             :     tMERIDIAN = 265,
     262             :     tMINUTE_UNIT = 266,
     263             :     tMONTH = 267,
     264             :     tMONTH_UNIT = 268,
     265             :     tSEC_UNIT = 269,
     266             :     tYEAR_UNIT = 270,
     267             :     tZONE = 271,
     268             :     tSNUMBER = 272,
     269             :     tUNUMBER = 273
     270             :   };
     271             : #endif
     272             : 
     273             : /* Value type.  */
     274             : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
     275             : 
     276             : union YYSTYPE
     277             : {
     278             : #line 168 "source3/modules/getdate.y" /* yacc.c:355  */
     279             : 
     280             :   int intval;
     281             :   textint textintval;
     282             : 
     283             : #line 284 "source3/modules/getdate.c" /* yacc.c:355  */
     284             : };
     285             : 
     286             : typedef union YYSTYPE YYSTYPE;
     287             : # define YYSTYPE_IS_TRIVIAL 1
     288             : # define YYSTYPE_IS_DECLARED 1
     289             : #endif
     290             : 
     291             : 
     292             : 
     293             : int yyparse (struct parser_control *pc);
     294             : 
     295             : 
     296             : 
     297             : /* Copy the second part of user declarations.  */
     298             : #line 173 "source3/modules/getdate.y" /* yacc.c:358  */
     299             : 
     300             : 
     301             : static int yyerror(struct parser_control *, const char *);
     302             : static int yylex(YYSTYPE *, struct parser_control *);
     303             : 
     304             : 
     305             : #line 306 "source3/modules/getdate.c" /* yacc.c:358  */
     306             : 
     307             : #ifdef short
     308             : # undef short
     309             : #endif
     310             : 
     311             : #ifdef YYTYPE_UINT8
     312             : typedef YYTYPE_UINT8 yytype_uint8;
     313             : #else
     314             : typedef unsigned char yytype_uint8;
     315             : #endif
     316             : 
     317             : #ifdef YYTYPE_INT8
     318             : typedef YYTYPE_INT8 yytype_int8;
     319             : #else
     320             : typedef signed char yytype_int8;
     321             : #endif
     322             : 
     323             : #ifdef YYTYPE_UINT16
     324             : typedef YYTYPE_UINT16 yytype_uint16;
     325             : #else
     326             : typedef unsigned short int yytype_uint16;
     327             : #endif
     328             : 
     329             : #ifdef YYTYPE_INT16
     330             : typedef YYTYPE_INT16 yytype_int16;
     331             : #else
     332             : typedef short int yytype_int16;
     333             : #endif
     334             : 
     335             : #ifndef YYSIZE_T
     336             : # ifdef __SIZE_TYPE__
     337             : #  define YYSIZE_T __SIZE_TYPE__
     338             : # elif defined size_t
     339             : #  define YYSIZE_T size_t
     340             : # elif ! defined YYSIZE_T
     341             : #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
     342             : #  define YYSIZE_T size_t
     343             : # else
     344             : #  define YYSIZE_T unsigned int
     345             : # endif
     346             : #endif
     347             : 
     348             : #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
     349             : 
     350             : #ifndef YY_
     351             : # if defined YYENABLE_NLS && YYENABLE_NLS
     352             : #  if ENABLE_NLS
     353             : #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
     354             : #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
     355             : #  endif
     356             : # endif
     357             : # ifndef YY_
     358             : #  define YY_(Msgid) Msgid
     359             : # endif
     360             : #endif
     361             : 
     362             : #ifndef YY_ATTRIBUTE
     363             : # if (defined __GNUC__                                               \
     364             :       && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
     365             :      || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
     366             : #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
     367             : # else
     368             : #  define YY_ATTRIBUTE(Spec) /* empty */
     369             : # endif
     370             : #endif
     371             : 
     372             : #ifndef YY_ATTRIBUTE_PURE
     373             : # define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
     374             : #endif
     375             : 
     376             : #ifndef YY_ATTRIBUTE_UNUSED
     377             : # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
     378             : #endif
     379             : 
     380             : #if !defined _Noreturn \
     381             :      && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
     382             : # if defined _MSC_VER && 1200 <= _MSC_VER
     383             : #  define _Noreturn __declspec (noreturn)
     384             : # else
     385             : #  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
     386             : # endif
     387             : #endif
     388             : 
     389             : /* Suppress unused-variable warnings by "using" E.  */
     390             : #if ! defined lint || defined __GNUC__
     391             : # define YYUSE(E) ((void) (E))
     392             : #else
     393             : # define YYUSE(E) /* empty */
     394             : #endif
     395             : 
     396             : #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
     397             : /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
     398             : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     399             :     _Pragma ("GCC diagnostic push") \
     400             :     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
     401             :     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
     402             : # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
     403             :     _Pragma ("GCC diagnostic pop")
     404             : #else
     405             : # define YY_INITIAL_VALUE(Value) Value
     406             : #endif
     407             : #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
     408             : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
     409             : # define YY_IGNORE_MAYBE_UNINITIALIZED_END
     410             : #endif
     411             : #ifndef YY_INITIAL_VALUE
     412             : # define YY_INITIAL_VALUE(Value) /* Nothing. */
     413             : #endif
     414             : 
     415             : 
     416             : #if ! defined yyoverflow || YYERROR_VERBOSE
     417             : 
     418             : /* The parser invokes alloca or malloc; define the necessary symbols.  */
     419             : 
     420             : # ifdef YYSTACK_USE_ALLOCA
     421             : #  if YYSTACK_USE_ALLOCA
     422             : #   ifdef __GNUC__
     423             : #    define YYSTACK_ALLOC __builtin_alloca
     424             : #   elif defined __BUILTIN_VA_ARG_INCR
     425             : #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
     426             : #   elif defined _AIX
     427             : #    define YYSTACK_ALLOC __alloca
     428             : #   elif defined _MSC_VER
     429             : #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
     430             : #    define alloca _alloca
     431             : #   else
     432             : #    define YYSTACK_ALLOC alloca
     433             : #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
     434             : #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
     435             :       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
     436             : #     ifndef EXIT_SUCCESS
     437             : #      define EXIT_SUCCESS 0
     438             : #     endif
     439             : #    endif
     440             : #   endif
     441             : #  endif
     442             : # endif
     443             : 
     444             : # ifdef YYSTACK_ALLOC
     445             :    /* Pacify GCC's 'empty if-body' warning.  */
     446             : #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
     447             : #  ifndef YYSTACK_ALLOC_MAXIMUM
     448             :     /* The OS might guarantee only one guard page at the bottom of the stack,
     449             :        and a page size can be as small as 4096 bytes.  So we cannot safely
     450             :        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
     451             :        to allow for a few compiler-allocated temporary stack slots.  */
     452             : #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
     453             : #  endif
     454             : # else
     455             : #  define YYSTACK_ALLOC YYMALLOC
     456             : #  define YYSTACK_FREE YYFREE
     457             : #  ifndef YYSTACK_ALLOC_MAXIMUM
     458             : #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
     459             : #  endif
     460             : #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
     461             :        && ! ((defined YYMALLOC || defined malloc) \
     462             :              && (defined YYFREE || defined free)))
     463             : #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
     464             : #   ifndef EXIT_SUCCESS
     465             : #    define EXIT_SUCCESS 0
     466             : #   endif
     467             : #  endif
     468             : #  ifndef YYMALLOC
     469             : #   define YYMALLOC malloc
     470             : #   if ! defined malloc && ! defined EXIT_SUCCESS
     471             : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
     472             : #   endif
     473             : #  endif
     474             : #  ifndef YYFREE
     475             : #   define YYFREE free
     476             : #   if ! defined free && ! defined EXIT_SUCCESS
     477             : void free (void *); /* INFRINGES ON USER NAME SPACE */
     478             : #   endif
     479             : #  endif
     480             : # endif
     481             : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
     482             : 
     483             : 
     484             : #if (! defined yyoverflow \
     485             :      && (! defined __cplusplus \
     486             :          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
     487             : 
     488             : /* A type that is properly aligned for any stack member.  */
     489             : union yyalloc
     490             : {
     491             :   yytype_int16 yyss_alloc;
     492             :   YYSTYPE yyvs_alloc;
     493             : };
     494             : 
     495             : /* The size of the maximum gap between one aligned stack and the next.  */
     496             : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
     497             : 
     498             : /* The size of an array large to enough to hold all stacks, each with
     499             :    N elements.  */
     500             : # define YYSTACK_BYTES(N) \
     501             :      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
     502             :       + YYSTACK_GAP_MAXIMUM)
     503             : 
     504             : # define YYCOPY_NEEDED 1
     505             : 
     506             : /* Relocate STACK from its old location to the new one.  The
     507             :    local variables YYSIZE and YYSTACKSIZE give the old and new number of
     508             :    elements in the stack, and YYPTR gives the new location of the
     509             :    stack.  Advance YYPTR to a properly aligned location for the next
     510             :    stack.  */
     511             : # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
     512             :     do                                                                  \
     513             :       {                                                                 \
     514             :         YYSIZE_T yynewbytes;                                            \
     515             :         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
     516             :         Stack = &yyptr->Stack_alloc;                                    \
     517             :         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
     518             :         yyptr += yynewbytes / sizeof (*yyptr);                          \
     519             :       }                                                                 \
     520             :     while (0)
     521             : 
     522             : #endif
     523             : 
     524             : #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
     525             : /* Copy COUNT objects from SRC to DST.  The source and destination do
     526             :    not overlap.  */
     527             : # ifndef YYCOPY
     528             : #  if defined __GNUC__ && 1 < __GNUC__
     529             : #   define YYCOPY(Dst, Src, Count) \
     530             :       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
     531             : #  else
     532             : #   define YYCOPY(Dst, Src, Count)              \
     533             :       do                                        \
     534             :         {                                       \
     535             :           YYSIZE_T yyi;                         \
     536             :           for (yyi = 0; yyi < (Count); yyi++)   \
     537             :             (Dst)[yyi] = (Src)[yyi];            \
     538             :         }                                       \
     539             :       while (0)
     540             : #  endif
     541             : # endif
     542             : #endif /* !YYCOPY_NEEDED */
     543             : 
     544             : /* YYFINAL -- State number of the termination state.  */
     545             : #define YYFINAL  2
     546             : /* YYLAST -- Last index in YYTABLE.  */
     547             : #define YYLAST   52
     548             : 
     549             : /* YYNTOKENS -- Number of terminals.  */
     550             : #define YYNTOKENS  22
     551             : /* YYNNTS -- Number of nonterminals.  */
     552             : #define YYNNTS  12
     553             : /* YYNRULES -- Number of rules.  */
     554             : #define YYNRULES  54
     555             : /* YYNSTATES -- Number of states.  */
     556             : #define YYNSTATES  64
     557             : 
     558             : /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
     559             :    by yylex, with out-of-bounds checking.  */
     560             : #define YYUNDEFTOK  2
     561             : #define YYMAXUTOK   273
     562             : 
     563             : #define YYTRANSLATE(YYX)                                                \
     564             :   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
     565             : 
     566             : /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
     567             :    as returned by yylex, without out-of-bounds checking.  */
     568             : static const yytype_uint8 yytranslate[] =
     569             : {
     570             :        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     571             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     572             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     573             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     574             :        2,     2,     2,     2,    20,     2,     2,    21,     2,     2,
     575             :        2,     2,     2,     2,     2,     2,     2,     2,    19,     2,
     576             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     577             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     578             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     579             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     580             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     581             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     582             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     583             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     584             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     585             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     586             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     587             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     588             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     589             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     590             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     591             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     592             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     593             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     594             :        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     595             :        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
     596             :        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
     597             :       15,    16,    17,    18
     598             : };
     599             : 
     600             : #if YYDEBUG
     601             :   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
     602             : static const yytype_uint16 yyrline[] =
     603             : {
     604             :        0,   191,   191,   193,   197,   199,   201,   203,   205,   207,
     605             :      209,   213,   220,   227,   235,   242,   254,   256,   261,   263,
     606             :      265,   270,   275,   280,   288,   293,   313,   320,   328,   333,
     607             :      339,   344,   353,   362,   366,   368,   370,   372,   374,   376,
     608             :      378,   380,   382,   384,   386,   388,   390,   392,   394,   396,
     609             :      398,   400,   405,   442,   443
     610             : };
     611             : #endif
     612             : 
     613             : #if YYDEBUG || YYERROR_VERBOSE || 0
     614             : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
     615             :    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
     616             : static const char *const yytname[] =
     617             : {
     618             :   "$end", "error", "$undefined", "tAGO", "tDST", "tDAY", "tDAY_UNIT",
     619             :   "tDAYZONE", "tHOUR_UNIT", "tLOCAL_ZONE", "tMERIDIAN", "tMINUTE_UNIT",
     620             :   "tMONTH", "tMONTH_UNIT", "tSEC_UNIT", "tYEAR_UNIT", "tZONE", "tSNUMBER",
     621             :   "tUNUMBER", "':'", "','", "'/'", "$accept", "spec", "item", "time",
     622             :   "local_zone", "zone", "day", "date", "rel", "relunit", "number",
     623             :   "o_merid", YY_NULLPTR
     624             : };
     625             : #endif
     626             : 
     627             : # ifdef YYPRINT
     628             : /* YYTOKNUM[NUM] -- (External) token number corresponding to the
     629             :    (internal) symbol number NUM (which must be that of a token).  */
     630             : static const yytype_uint16 yytoknum[] =
     631             : {
     632             :        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     633             :      265,   266,   267,   268,   269,   270,   271,   272,   273,    58,
     634             :       44,    47
     635             : };
     636             : # endif
     637             : 
     638             : #define YYPACT_NINF -17
     639             : 
     640             : #define yypact_value_is_default(Yystate) \
     641             :   (!!((Yystate) == (-17)))
     642             : 
     643             : #define YYTABLE_NINF -1
     644             : 
     645             : #define yytable_value_is_error(Yytable_value) \
     646             :   0
     647             : 
     648             :   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
     649             :      STATE-NUM.  */
     650             : static const yytype_int8 yypact[] =
     651             : {
     652             :      -17,     0,   -17,     1,   -17,   -17,   -17,    19,   -17,   -14,
     653             :      -17,   -17,   -17,    32,    26,    14,   -17,   -17,   -17,   -17,
     654             :      -17,   -17,   -17,    27,   -17,   -17,   -17,    22,   -17,   -17,
     655             :      -17,   -17,   -17,   -17,   -17,   -17,   -17,   -17,   -17,   -17,
     656             :      -16,   -17,   -17,   -17,    29,    25,    30,   -17,    31,   -17,
     657             :      -17,   -17,    28,    23,   -17,   -17,   -17,    33,   -17,    34,
     658             :       -7,   -17,   -17,   -17
     659             : };
     660             : 
     661             :   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
     662             :      Performed when YYTABLE does not specify something else to do.  Zero
     663             :      means the default is an error.  */
     664             : static const yytype_uint8 yydefact[] =
     665             : {
     666             :        2,     0,     1,    21,    42,    19,    45,    16,    48,     0,
     667             :       39,    51,    36,    18,     0,    52,     3,     4,     5,     6,
     668             :        8,     7,     9,    33,    10,    22,    17,    28,    20,    41,
     669             :       44,    47,    38,    50,    35,    23,    40,    43,    11,    46,
     670             :       30,    37,    49,    34,     0,     0,     0,    32,     0,    27,
     671             :       31,    26,    53,    24,    29,    54,    13,     0,    12,     0,
     672             :       53,    25,    15,    14
     673             : };
     674             : 
     675             :   /* YYPGOTO[NTERM-NUM].  */
     676             : static const yytype_int8 yypgoto[] =
     677             : {
     678             :      -17,   -17,   -17,   -17,   -17,   -17,   -17,   -17,   -17,   -17,
     679             :      -17,   -10
     680             : };
     681             : 
     682             :   /* YYDEFGOTO[NTERM-NUM].  */
     683             : static const yytype_int8 yydefgoto[] =
     684             : {
     685             :       -1,     1,    16,    17,    18,    19,    20,    21,    22,    23,
     686             :       24,    58
     687             : };
     688             : 
     689             :   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
     690             :      positive, shift that token.  If negative, reduce the rule whose
     691             :      number is the opposite.  If YYTABLE_NINF, syntax error.  */
     692             : static const yytype_uint8 yytable[] =
     693             : {
     694             :        2,    49,    50,    55,    27,     3,     4,     5,     6,     7,
     695             :       62,     8,     9,    10,    11,    12,    13,    14,    15,    35,
     696             :       36,    25,    37,    26,    38,    39,    40,    41,    42,    43,
     697             :       47,    44,    29,    45,    30,    46,    28,    31,    55,    32,
     698             :       33,    34,    48,    52,    59,    56,    51,    57,    53,    54,
     699             :       63,    60,    61
     700             : };
     701             : 
     702             : static const yytype_uint8 yycheck[] =
     703             : {
     704             :        0,    17,    18,    10,    18,     5,     6,     7,     8,     9,
     705             :       17,    11,    12,    13,    14,    15,    16,    17,    18,     5,
     706             :        6,    20,     8,     4,    10,    11,    12,    13,    14,    15,
     707             :        3,    17,     6,    19,     8,    21,     4,    11,    10,    13,
     708             :       14,    15,    20,    18,    21,    17,    17,    19,    18,    18,
     709             :       60,    18,    18
     710             : };
     711             : 
     712             :   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
     713             :      symbol of state STATE-NUM.  */
     714             : static const yytype_uint8 yystos[] =
     715             : {
     716             :        0,    23,     0,     5,     6,     7,     8,     9,    11,    12,
     717             :       13,    14,    15,    16,    17,    18,    24,    25,    26,    27,
     718             :       28,    29,    30,    31,    32,    20,     4,    18,     4,     6,
     719             :        8,    11,    13,    14,    15,     5,     6,     8,    10,    11,
     720             :       12,    13,    14,    15,    17,    19,    21,     3,    20,    17,
     721             :       18,    17,    18,    18,    18,    10,    17,    19,    33,    21,
     722             :       18,    18,    17,    33
     723             : };
     724             : 
     725             :   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
     726             : static const yytype_uint8 yyr1[] =
     727             : {
     728             :        0,    22,    23,    23,    24,    24,    24,    24,    24,    24,
     729             :       24,    25,    25,    25,    25,    25,    26,    26,    27,    27,
     730             :       27,    28,    28,    28,    29,    29,    29,    29,    29,    29,
     731             :       29,    29,    30,    30,    31,    31,    31,    31,    31,    31,
     732             :       31,    31,    31,    31,    31,    31,    31,    31,    31,    31,
     733             :       31,    31,    32,    33,    33
     734             : };
     735             : 
     736             :   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
     737             : static const yytype_uint8 yyr2[] =
     738             : {
     739             :        0,     2,     0,     2,     1,     1,     1,     1,     1,     1,
     740             :        1,     2,     4,     4,     6,     6,     1,     2,     1,     1,
     741             :        2,     1,     2,     2,     3,     5,     3,     3,     2,     4,
     742             :        2,     3,     2,     1,     2,     2,     1,     2,     2,     1,
     743             :        2,     2,     1,     2,     2,     1,     2,     2,     1,     2,
     744             :        2,     1,     1,     0,     1
     745             : };
     746             : 
     747             : 
     748             : #define yyerrok         (yyerrstatus = 0)
     749             : #define yyclearin       (yychar = YYEMPTY)
     750             : #define YYEMPTY         (-2)
     751             : #define YYEOF           0
     752             : 
     753             : #define YYACCEPT        goto yyacceptlab
     754             : #define YYABORT         goto yyabortlab
     755             : #define YYERROR         goto yyerrorlab
     756             : 
     757             : 
     758             : #define YYRECOVERING()  (!!yyerrstatus)
     759             : 
     760             : #define YYBACKUP(Token, Value)                                  \
     761             : do                                                              \
     762             :   if (yychar == YYEMPTY)                                        \
     763             :     {                                                           \
     764             :       yychar = (Token);                                         \
     765             :       yylval = (Value);                                         \
     766             :       YYPOPSTACK (yylen);                                       \
     767             :       yystate = *yyssp;                                         \
     768             :       goto yybackup;                                            \
     769             :     }                                                           \
     770             :   else                                                          \
     771             :     {                                                           \
     772             :       yyerror (pc, YY_("syntax error: cannot back up")); \
     773             :       YYERROR;                                                  \
     774             :     }                                                           \
     775             : while (0)
     776             : 
     777             : /* Error token number */
     778             : #define YYTERROR        1
     779             : #define YYERRCODE       256
     780             : 
     781             : 
     782             : 
     783             : /* Enable debugging if requested.  */
     784             : #if YYDEBUG
     785             : 
     786             : # ifndef YYFPRINTF
     787             : #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
     788             : #  define YYFPRINTF fprintf
     789             : # endif
     790             : 
     791             : # define YYDPRINTF(Args)                        \
     792             : do {                                            \
     793             :   if (yydebug)                                  \
     794             :     YYFPRINTF Args;                             \
     795             : } while (0)
     796             : 
     797             : /* This macro is provided for backward compatibility. */
     798             : #ifndef YY_LOCATION_PRINT
     799             : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
     800             : #endif
     801             : 
     802             : 
     803             : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
     804             : do {                                                                      \
     805             :   if (yydebug)                                                            \
     806             :     {                                                                     \
     807             :       YYFPRINTF (stderr, "%s ", Title);                                   \
     808             :       yy_symbol_print (stderr,                                            \
     809             :                   Type, Value, pc); \
     810             :       YYFPRINTF (stderr, "\n");                                           \
     811             :     }                                                                     \
     812             : } while (0)
     813             : 
     814             : 
     815             : /*----------------------------------------.
     816             : | Print this symbol's value on YYOUTPUT.  |
     817             : `----------------------------------------*/
     818             : 
     819             : static void
     820             : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_control *pc)
     821             : {
     822             :   FILE *yyo = yyoutput;
     823             :   YYUSE (yyo);
     824             :   YYUSE (pc);
     825             :   if (!yyvaluep)
     826             :     return;
     827             : # ifdef YYPRINT
     828             :   if (yytype < YYNTOKENS)
     829             :     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
     830             : # endif
     831             :   YYUSE (yytype);
     832             : }
     833             : 
     834             : 
     835             : /*--------------------------------.
     836             : | Print this symbol on YYOUTPUT.  |
     837             : `--------------------------------*/
     838             : 
     839             : static void
     840             : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_control *pc)
     841             : {
     842             :   YYFPRINTF (yyoutput, "%s %s (",
     843             :              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
     844             : 
     845             :   yy_symbol_value_print (yyoutput, yytype, yyvaluep, pc);
     846             :   YYFPRINTF (yyoutput, ")");
     847             : }
     848             : 
     849             : /*------------------------------------------------------------------.
     850             : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
     851             : | TOP (included).                                                   |
     852             : `------------------------------------------------------------------*/
     853             : 
     854             : static void
     855             : yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
     856             : {
     857             :   YYFPRINTF (stderr, "Stack now");
     858             :   for (; yybottom <= yytop; yybottom++)
     859             :     {
     860             :       int yybot = *yybottom;
     861             :       YYFPRINTF (stderr, " %d", yybot);
     862             :     }
     863             :   YYFPRINTF (stderr, "\n");
     864             : }
     865             : 
     866             : # define YY_STACK_PRINT(Bottom, Top)                            \
     867             : do {                                                            \
     868             :   if (yydebug)                                                  \
     869             :     yy_stack_print ((Bottom), (Top));                           \
     870             : } while (0)
     871             : 
     872             : 
     873             : /*------------------------------------------------.
     874             : | Report that the YYRULE is going to be reduced.  |
     875             : `------------------------------------------------*/
     876             : 
     877             : static void
     878             : yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, struct parser_control *pc)
     879             : {
     880             :   unsigned long int yylno = yyrline[yyrule];
     881             :   int yynrhs = yyr2[yyrule];
     882             :   int yyi;
     883             :   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
     884             :              yyrule - 1, yylno);
     885             :   /* The symbols being reduced.  */
     886             :   for (yyi = 0; yyi < yynrhs; yyi++)
     887             :     {
     888             :       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
     889             :       yy_symbol_print (stderr,
     890             :                        yystos[yyssp[yyi + 1 - yynrhs]],
     891             :                        &(yyvsp[(yyi + 1) - (yynrhs)])
     892             :                                               , pc);
     893             :       YYFPRINTF (stderr, "\n");
     894             :     }
     895             : }
     896             : 
     897             : # define YY_REDUCE_PRINT(Rule)          \
     898             : do {                                    \
     899             :   if (yydebug)                          \
     900             :     yy_reduce_print (yyssp, yyvsp, Rule, pc); \
     901             : } while (0)
     902             : 
     903             : /* Nonzero means print parse trace.  It is left uninitialized so that
     904             :    multiple parsers can coexist.  */
     905             : int yydebug;
     906             : #else /* !YYDEBUG */
     907             : # define YYDPRINTF(Args)
     908             : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
     909             : # define YY_STACK_PRINT(Bottom, Top)
     910             : # define YY_REDUCE_PRINT(Rule)
     911             : #endif /* !YYDEBUG */
     912             : 
     913             : 
     914             : /* YYINITDEPTH -- initial size of the parser's stacks.  */
     915             : #ifndef YYINITDEPTH
     916             : # define YYINITDEPTH 200
     917             : #endif
     918             : 
     919             : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
     920             :    if the built-in stack extension method is used).
     921             : 
     922             :    Do not make this value too large; the results are undefined if
     923             :    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
     924             :    evaluated with infinite-precision integer arithmetic.  */
     925             : 
     926             : #ifndef YYMAXDEPTH
     927             : # define YYMAXDEPTH 10000
     928             : #endif
     929             : 
     930             : 
     931             : #if YYERROR_VERBOSE
     932             : 
     933             : # ifndef yystrlen
     934             : #  if defined __GLIBC__ && defined _STRING_H
     935             : #   define yystrlen strlen
     936             : #  else
     937             : /* Return the length of YYSTR.  */
     938             : static YYSIZE_T
     939             : yystrlen (const char *yystr)
     940             : {
     941             :   YYSIZE_T yylen;
     942             :   for (yylen = 0; yystr[yylen]; yylen++)
     943             :     continue;
     944             :   return yylen;
     945             : }
     946             : #  endif
     947             : # endif
     948             : 
     949             : # ifndef yystpcpy
     950             : #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
     951             : #   define yystpcpy stpcpy
     952             : #  else
     953             : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
     954             :    YYDEST.  */
     955             : static char *
     956             : yystpcpy (char *yydest, const char *yysrc)
     957             : {
     958             :   char *yyd = yydest;
     959             :   const char *yys = yysrc;
     960             : 
     961             :   while ((*yyd++ = *yys++) != '\0')
     962             :     continue;
     963             : 
     964             :   return yyd - 1;
     965             : }
     966             : #  endif
     967             : # endif
     968             : 
     969             : # ifndef yytnamerr
     970             : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
     971             :    quotes and backslashes, so that it's suitable for yyerror.  The
     972             :    heuristic is that double-quoting is unnecessary unless the string
     973             :    contains an apostrophe, a comma, or backslash (other than
     974             :    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
     975             :    null, do not copy; instead, return the length of what the result
     976             :    would have been.  */
     977             : static YYSIZE_T
     978             : yytnamerr (char *yyres, const char *yystr)
     979             : {
     980             :   if (*yystr == '"')
     981             :     {
     982             :       YYSIZE_T yyn = 0;
     983             :       char const *yyp = yystr;
     984             : 
     985             :       for (;;)
     986             :         switch (*++yyp)
     987             :           {
     988             :           case '\'':
     989             :           case ',':
     990             :             goto do_not_strip_quotes;
     991             : 
     992             :           case '\\':
     993             :             if (*++yyp != '\\')
     994             :               goto do_not_strip_quotes;
     995             :             /* Fall through.  */
     996             :           default:
     997             :             if (yyres)
     998             :               yyres[yyn] = *yyp;
     999             :             yyn++;
    1000             :             break;
    1001             : 
    1002             :           case '"':
    1003             :             if (yyres)
    1004             :               yyres[yyn] = '\0';
    1005             :             return yyn;
    1006             :           }
    1007             :     do_not_strip_quotes: ;
    1008             :     }
    1009             : 
    1010             :   if (! yyres)
    1011             :     return yystrlen (yystr);
    1012             : 
    1013             :   return yystpcpy (yyres, yystr) - yyres;
    1014             : }
    1015             : # endif
    1016             : 
    1017             : /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
    1018             :    about the unexpected token YYTOKEN for the state stack whose top is
    1019             :    YYSSP.
    1020             : 
    1021             :    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
    1022             :    not large enough to hold the message.  In that case, also set
    1023             :    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
    1024             :    required number of bytes is too large to store.  */
    1025             : static int
    1026             : yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
    1027             :                 yytype_int16 *yyssp, int yytoken)
    1028             : {
    1029             :   YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
    1030             :   YYSIZE_T yysize = yysize0;
    1031             :   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
    1032             :   /* Internationalized format string. */
    1033             :   const char *yyformat = YY_NULLPTR;
    1034             :   /* Arguments of yyformat. */
    1035             :   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
    1036             :   /* Number of reported tokens (one for the "unexpected", one per
    1037             :      "expected"). */
    1038             :   int yycount = 0;
    1039             : 
    1040             :   /* There are many possibilities here to consider:
    1041             :      - If this state is a consistent state with a default action, then
    1042             :        the only way this function was invoked is if the default action
    1043             :        is an error action.  In that case, don't check for expected
    1044             :        tokens because there are none.
    1045             :      - The only way there can be no lookahead present (in yychar) is if
    1046             :        this state is a consistent state with a default action.  Thus,
    1047             :        detecting the absence of a lookahead is sufficient to determine
    1048             :        that there is no unexpected or expected token to report.  In that
    1049             :        case, just report a simple "syntax error".
    1050             :      - Don't assume there isn't a lookahead just because this state is a
    1051             :        consistent state with a default action.  There might have been a
    1052             :        previous inconsistent state, consistent state with a non-default
    1053             :        action, or user semantic action that manipulated yychar.
    1054             :      - Of course, the expected token list depends on states to have
    1055             :        correct lookahead information, and it depends on the parser not
    1056             :        to perform extra reductions after fetching a lookahead from the
    1057             :        scanner and before detecting a syntax error.  Thus, state merging
    1058             :        (from LALR or IELR) and default reductions corrupt the expected
    1059             :        token list.  However, the list is correct for canonical LR with
    1060             :        one exception: it will still contain any token that will not be
    1061             :        accepted due to an error action in a later state.
    1062             :   */
    1063             :   if (yytoken != YYEMPTY)
    1064             :     {
    1065             :       int yyn = yypact[*yyssp];
    1066             :       yyarg[yycount++] = yytname[yytoken];
    1067             :       if (!yypact_value_is_default (yyn))
    1068             :         {
    1069             :           /* Start YYX at -YYN if negative to avoid negative indexes in
    1070             :              YYCHECK.  In other words, skip the first -YYN actions for
    1071             :              this state because they are default actions.  */
    1072             :           int yyxbegin = yyn < 0 ? -yyn : 0;
    1073             :           /* Stay within bounds of both yycheck and yytname.  */
    1074             :           int yychecklim = YYLAST - yyn + 1;
    1075             :           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
    1076             :           int yyx;
    1077             : 
    1078             :           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
    1079             :             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
    1080             :                 && !yytable_value_is_error (yytable[yyx + yyn]))
    1081             :               {
    1082             :                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
    1083             :                   {
    1084             :                     yycount = 1;
    1085             :                     yysize = yysize0;
    1086             :                     break;
    1087             :                   }
    1088             :                 yyarg[yycount++] = yytname[yyx];
    1089             :                 {
    1090             :                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
    1091             :                   if (! (yysize <= yysize1
    1092             :                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
    1093             :                     return 2;
    1094             :                   yysize = yysize1;
    1095             :                 }
    1096             :               }
    1097             :         }
    1098             :     }
    1099             : 
    1100             :   switch (yycount)
    1101             :     {
    1102             : # define YYCASE_(N, S)                      \
    1103             :       case N:                               \
    1104             :         yyformat = S;                       \
    1105             :       break
    1106             :       YYCASE_(0, YY_("syntax error"));
    1107             :       YYCASE_(1, YY_("syntax error, unexpected %s"));
    1108             :       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
    1109             :       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
    1110             :       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
    1111             :       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
    1112             : # undef YYCASE_
    1113             :     }
    1114             : 
    1115             :   {
    1116             :     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
    1117             :     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
    1118             :       return 2;
    1119             :     yysize = yysize1;
    1120             :   }
    1121             : 
    1122             :   if (*yymsg_alloc < yysize)
    1123             :     {
    1124             :       *yymsg_alloc = 2 * yysize;
    1125             :       if (! (yysize <= *yymsg_alloc
    1126             :              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
    1127             :         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
    1128             :       return 1;
    1129             :     }
    1130             : 
    1131             :   /* Avoid sprintf, as that infringes on the user's name space.
    1132             :      Don't have undefined behavior even if the translation
    1133             :      produced a string with the wrong number of "%s"s.  */
    1134             :   {
    1135             :     char *yyp = *yymsg;
    1136             :     int yyi = 0;
    1137             :     while ((*yyp = *yyformat) != '\0')
    1138             :       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
    1139             :         {
    1140             :           yyp += yytnamerr (yyp, yyarg[yyi++]);
    1141             :           yyformat += 2;
    1142             :         }
    1143             :       else
    1144             :         {
    1145             :           yyp++;
    1146             :           yyformat++;
    1147             :         }
    1148             :   }
    1149             :   return 0;
    1150             : }
    1151             : #endif /* YYERROR_VERBOSE */
    1152             : 
    1153             : /*-----------------------------------------------.
    1154             : | Release the memory associated to this symbol.  |
    1155             : `-----------------------------------------------*/
    1156             : 
    1157             : static void
    1158           0 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_control *pc)
    1159             : {
    1160             :   YYUSE (yyvaluep);
    1161             :   YYUSE (pc);
    1162           0 :   if (!yymsg)
    1163           0 :     yymsg = "Deleting";
    1164             :   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
    1165             : 
    1166             :   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    1167             :   YYUSE (yytype);
    1168             :   YY_IGNORE_MAYBE_UNINITIALIZED_END
    1169           0 : }
    1170             : 
    1171             : 
    1172             : 
    1173             : 
    1174             : /*----------.
    1175             : | yyparse.  |
    1176             : `----------*/
    1177             : 
    1178             : int
    1179           0 : yyparse (struct parser_control *pc)
    1180             : {
    1181             : /* The lookahead symbol.  */
    1182             : int yychar;
    1183             : 
    1184             : 
    1185             : /* The semantic value of the lookahead symbol.  */
    1186             : /* Default value used for initialization, for pacifying older GCCs
    1187             :    or non-GCC compilers.  */
    1188             : YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
    1189             : YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
    1190             : 
    1191             :     /* Number of syntax errors so far.  */
    1192             :     int yynerrs;
    1193             : 
    1194             :     int yystate;
    1195             :     /* Number of tokens to shift before error messages enabled.  */
    1196             :     int yyerrstatus;
    1197             : 
    1198             :     /* The stacks and their tools:
    1199             :        'yyss': related to states.
    1200             :        'yyvs': related to semantic values.
    1201             : 
    1202             :        Refer to the stacks through separate pointers, to allow yyoverflow
    1203             :        to reallocate them elsewhere.  */
    1204             : 
    1205             :     /* The state stack.  */
    1206             :     yytype_int16 yyssa[YYINITDEPTH];
    1207             :     yytype_int16 *yyss;
    1208             :     yytype_int16 *yyssp;
    1209             : 
    1210             :     /* The semantic value stack.  */
    1211             :     YYSTYPE yyvsa[YYINITDEPTH];
    1212             :     YYSTYPE *yyvs;
    1213             :     YYSTYPE *yyvsp;
    1214             : 
    1215             :     YYSIZE_T yystacksize;
    1216             : 
    1217             :   int yyn;
    1218             :   int yyresult;
    1219             :   /* Lookahead token as an internal (translated) token number.  */
    1220           0 :   int yytoken = 0;
    1221             :   /* The variables used to return semantic value and location from the
    1222             :      action routines.  */
    1223             :   YYSTYPE yyval;
    1224             : 
    1225             : #if YYERROR_VERBOSE
    1226             :   /* Buffer for error messages, and its allocated size.  */
    1227             :   char yymsgbuf[128];
    1228             :   char *yymsg = yymsgbuf;
    1229             :   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
    1230             : #endif
    1231             : 
    1232             : #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
    1233             : 
    1234             :   /* The number of symbols on the RHS of the reduced rule.
    1235             :      Keep to zero when no symbol should be popped.  */
    1236           0 :   int yylen = 0;
    1237             : 
    1238           0 :   yyssp = yyss = yyssa;
    1239           0 :   yyvsp = yyvs = yyvsa;
    1240           0 :   yystacksize = YYINITDEPTH;
    1241             : 
    1242             :   YYDPRINTF ((stderr, "Starting parse\n"));
    1243             : 
    1244           0 :   yystate = 0;
    1245           0 :   yyerrstatus = 0;
    1246           0 :   yynerrs = 0;
    1247           0 :   yychar = YYEMPTY; /* Cause a token to be read.  */
    1248           0 :   goto yysetstate;
    1249             : 
    1250             : /*------------------------------------------------------------.
    1251             : | yynewstate -- Push a new state, which is found in yystate.  |
    1252             : `------------------------------------------------------------*/
    1253           0 :  yynewstate:
    1254             :   /* In all cases, when you get here, the value and location stacks
    1255             :      have just been pushed.  So pushing a state here evens the stacks.  */
    1256           0 :   yyssp++;
    1257             : 
    1258           0 :  yysetstate:
    1259           0 :   *yyssp = yystate;
    1260             : 
    1261           0 :   if (yyss + yystacksize - 1 <= yyssp)
    1262             :     {
    1263             :       /* Get the current used size of the three stacks, in elements.  */
    1264           0 :       YYSIZE_T yysize = yyssp - yyss + 1;
    1265             : 
    1266             : #ifdef yyoverflow
    1267             :       {
    1268             :         /* Give user a chance to reallocate the stack.  Use copies of
    1269             :            these so that the &'s don't force the real ones into
    1270             :            memory.  */
    1271             :         YYSTYPE *yyvs1 = yyvs;
    1272             :         yytype_int16 *yyss1 = yyss;
    1273             : 
    1274             :         /* Each stack pointer address is followed by the size of the
    1275             :            data in use in that stack, in bytes.  This used to be a
    1276             :            conditional around just the two extra args, but that might
    1277             :            be undefined if yyoverflow is a macro.  */
    1278             :         yyoverflow (YY_("memory exhausted"),
    1279             :                     &yyss1, yysize * sizeof (*yyssp),
    1280             :                     &yyvs1, yysize * sizeof (*yyvsp),
    1281             :                     &yystacksize);
    1282             : 
    1283             :         yyss = yyss1;
    1284             :         yyvs = yyvs1;
    1285             :       }
    1286             : #else /* no yyoverflow */
    1287             : # ifndef YYSTACK_RELOCATE
    1288             :       goto yyexhaustedlab;
    1289             : # else
    1290             :       /* Extend the stack our own way.  */
    1291           0 :       if (YYMAXDEPTH <= yystacksize)
    1292           0 :         goto yyexhaustedlab;
    1293           0 :       yystacksize *= 2;
    1294           0 :       if (YYMAXDEPTH < yystacksize)
    1295           0 :         yystacksize = YYMAXDEPTH;
    1296             : 
    1297             :       {
    1298           0 :         yytype_int16 *yyss1 = yyss;
    1299           0 :         union yyalloc *yyptr =
    1300           0 :           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
    1301           0 :         if (! yyptr)
    1302           0 :           goto yyexhaustedlab;
    1303           0 :         YYSTACK_RELOCATE (yyss_alloc, yyss);
    1304           0 :         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
    1305             : #  undef YYSTACK_RELOCATE
    1306           0 :         if (yyss1 != yyssa)
    1307           0 :           YYSTACK_FREE (yyss1);
    1308             :       }
    1309             : # endif
    1310             : #endif /* no yyoverflow */
    1311             : 
    1312           0 :       yyssp = yyss + yysize - 1;
    1313           0 :       yyvsp = yyvs + yysize - 1;
    1314             : 
    1315             :       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
    1316             :                   (unsigned long int) yystacksize));
    1317             : 
    1318           0 :       if (yyss + yystacksize - 1 <= yyssp)
    1319           0 :         YYABORT;
    1320             :     }
    1321             : 
    1322             :   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
    1323             : 
    1324           0 :   if (yystate == YYFINAL)
    1325           0 :     YYACCEPT;
    1326             : 
    1327           0 :   goto yybackup;
    1328             : 
    1329             : /*-----------.
    1330             : | yybackup.  |
    1331             : `-----------*/
    1332           0 : yybackup:
    1333             : 
    1334             :   /* Do appropriate processing given the current state.  Read a
    1335             :      lookahead token if we need one and don't already have one.  */
    1336             : 
    1337             :   /* First try to decide what to do without reference to lookahead token.  */
    1338           0 :   yyn = yypact[yystate];
    1339           0 :   if (yypact_value_is_default (yyn))
    1340           0 :     goto yydefault;
    1341             : 
    1342             :   /* Not known => get a lookahead token if don't already have one.  */
    1343             : 
    1344             :   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
    1345           0 :   if (yychar == YYEMPTY)
    1346             :     {
    1347             :       YYDPRINTF ((stderr, "Reading a token: "));
    1348           0 :       yychar = yylex (&yylval, pc);
    1349             :     }
    1350             : 
    1351           0 :   if (yychar <= YYEOF)
    1352             :     {
    1353           0 :       yychar = yytoken = YYEOF;
    1354             :       YYDPRINTF ((stderr, "Now at end of input.\n"));
    1355             :     }
    1356             :   else
    1357             :     {
    1358           0 :       yytoken = YYTRANSLATE (yychar);
    1359             :       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    1360             :     }
    1361             : 
    1362             :   /* If the proper action on seeing token YYTOKEN is to reduce or to
    1363             :      detect an error, take that action.  */
    1364           0 :   yyn += yytoken;
    1365           0 :   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    1366             :     goto yydefault;
    1367           0 :   yyn = yytable[yyn];
    1368           0 :   if (yyn <= 0)
    1369             :     {
    1370             :       if (yytable_value_is_error (yyn))
    1371             :         goto yyerrlab;
    1372           0 :       yyn = -yyn;
    1373           0 :       goto yyreduce;
    1374             :     }
    1375             : 
    1376             :   /* Count tokens shifted since error; after three, turn off error
    1377             :      status.  */
    1378           0 :   if (yyerrstatus)
    1379           0 :     yyerrstatus--;
    1380             : 
    1381             :   /* Shift the lookahead token.  */
    1382             :   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
    1383             : 
    1384             :   /* Discard the shifted token.  */
    1385           0 :   yychar = YYEMPTY;
    1386             : 
    1387           0 :   yystate = yyn;
    1388             :   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    1389           0 :   *++yyvsp = yylval;
    1390             :   YY_IGNORE_MAYBE_UNINITIALIZED_END
    1391             : 
    1392           0 :   goto yynewstate;
    1393             : 
    1394             : 
    1395             : /*-----------------------------------------------------------.
    1396             : | yydefault -- do the default action for the current state.  |
    1397             : `-----------------------------------------------------------*/
    1398           0 : yydefault:
    1399           0 :   yyn = yydefact[yystate];
    1400           0 :   if (yyn == 0)
    1401           0 :     goto yyerrlab;
    1402           0 :   goto yyreduce;
    1403             : 
    1404             : 
    1405             : /*-----------------------------.
    1406             : | yyreduce -- Do a reduction.  |
    1407             : `-----------------------------*/
    1408           0 : yyreduce:
    1409             :   /* yyn is the number of a rule to reduce with.  */
    1410           0 :   yylen = yyr2[yyn];
    1411             : 
    1412             :   /* If YYLEN is nonzero, implement the default value of the action:
    1413             :      '$$ = $1'.
    1414             : 
    1415             :      Otherwise, the following line sets YYVAL to garbage.
    1416             :      This behavior is undocumented and Bison
    1417             :      users should not rely upon it.  Assigning to YYVAL
    1418             :      unconditionally makes the parser a bit smaller, and it avoids a
    1419             :      GCC warning that YYVAL may be used uninitialized.  */
    1420           0 :   yyval = yyvsp[1-yylen];
    1421             : 
    1422             : 
    1423             :   YY_REDUCE_PRINT (yyn);
    1424           0 :   switch (yyn)
    1425             :     {
    1426           0 :         case 4:
    1427             : #line 198 "source3/modules/getdate.y" /* yacc.c:1646  */
    1428             :     { pc->times_seen++; }
    1429             : #line 1430 "source3/modules/getdate.c" /* yacc.c:1646  */
    1430           0 :     break;
    1431             : 
    1432           0 :   case 5:
    1433             : #line 200 "source3/modules/getdate.y" /* yacc.c:1646  */
    1434             :     { pc->local_zones_seen++; }
    1435             : #line 1436 "source3/modules/getdate.c" /* yacc.c:1646  */
    1436           0 :     break;
    1437             : 
    1438           0 :   case 6:
    1439             : #line 202 "source3/modules/getdate.y" /* yacc.c:1646  */
    1440             :     { pc->zones_seen++; }
    1441             : #line 1442 "source3/modules/getdate.c" /* yacc.c:1646  */
    1442           0 :     break;
    1443             : 
    1444           0 :   case 7:
    1445             : #line 204 "source3/modules/getdate.y" /* yacc.c:1646  */
    1446             :     { pc->dates_seen++; }
    1447             : #line 1448 "source3/modules/getdate.c" /* yacc.c:1646  */
    1448           0 :     break;
    1449             : 
    1450           0 :   case 8:
    1451             : #line 206 "source3/modules/getdate.y" /* yacc.c:1646  */
    1452             :     { pc->days_seen++; }
    1453             : #line 1454 "source3/modules/getdate.c" /* yacc.c:1646  */
    1454           0 :     break;
    1455             : 
    1456           0 :   case 9:
    1457             : #line 208 "source3/modules/getdate.y" /* yacc.c:1646  */
    1458             :     { pc->rels_seen++; }
    1459             : #line 1460 "source3/modules/getdate.c" /* yacc.c:1646  */
    1460           0 :     break;
    1461             : 
    1462           0 :   case 11:
    1463             : #line 214 "source3/modules/getdate.y" /* yacc.c:1646  */
    1464             :     {
    1465             :         pc->hour = (yyvsp[-1].textintval).value;
    1466             :         pc->minutes = 0;
    1467             :         pc->seconds = 0;
    1468             :         pc->meridian = (yyvsp[0].intval);
    1469             :       }
    1470             : #line 1471 "source3/modules/getdate.c" /* yacc.c:1646  */
    1471           0 :     break;
    1472             : 
    1473           0 :   case 12:
    1474             : #line 221 "source3/modules/getdate.y" /* yacc.c:1646  */
    1475             :     {
    1476             :         pc->hour = (yyvsp[-3].textintval).value;
    1477             :         pc->minutes = (yyvsp[-1].textintval).value;
    1478             :         pc->seconds = 0;
    1479             :         pc->meridian = (yyvsp[0].intval);
    1480             :       }
    1481             : #line 1482 "source3/modules/getdate.c" /* yacc.c:1646  */
    1482           0 :     break;
    1483             : 
    1484           0 :   case 13:
    1485             : #line 228 "source3/modules/getdate.y" /* yacc.c:1646  */
    1486             :     {
    1487             :         pc->hour = (yyvsp[-3].textintval).value;
    1488             :         pc->minutes = (yyvsp[-1].textintval).value;
    1489             :         pc->meridian = MER24;
    1490             :         pc->zones_seen++;
    1491             :         pc->time_zone = (yyvsp[0].textintval).value % 100 + ((yyvsp[0].textintval).value / 100) * 60;
    1492             :       }
    1493             : #line 1494 "source3/modules/getdate.c" /* yacc.c:1646  */
    1494           0 :     break;
    1495             : 
    1496           0 :   case 14:
    1497             : #line 236 "source3/modules/getdate.y" /* yacc.c:1646  */
    1498             :     {
    1499             :         pc->hour = (yyvsp[-5].textintval).value;
    1500             :         pc->minutes = (yyvsp[-3].textintval).value;
    1501             :         pc->seconds = (yyvsp[-1].textintval).value;
    1502             :         pc->meridian = (yyvsp[0].intval);
    1503             :       }
    1504             : #line 1505 "source3/modules/getdate.c" /* yacc.c:1646  */
    1505           0 :     break;
    1506             : 
    1507           0 :   case 15:
    1508             : #line 243 "source3/modules/getdate.y" /* yacc.c:1646  */
    1509             :     {
    1510             :         pc->hour = (yyvsp[-5].textintval).value;
    1511             :         pc->minutes = (yyvsp[-3].textintval).value;
    1512             :         pc->seconds = (yyvsp[-1].textintval).value;
    1513             :         pc->meridian = MER24;
    1514             :         pc->zones_seen++;
    1515             :         pc->time_zone = (yyvsp[0].textintval).value % 100 + ((yyvsp[0].textintval).value / 100) * 60;
    1516             :       }
    1517             : #line 1518 "source3/modules/getdate.c" /* yacc.c:1646  */
    1518           0 :     break;
    1519             : 
    1520           0 :   case 16:
    1521             : #line 255 "source3/modules/getdate.y" /* yacc.c:1646  */
    1522             :     { pc->local_isdst = (yyvsp[0].intval); }
    1523             : #line 1524 "source3/modules/getdate.c" /* yacc.c:1646  */
    1524           0 :     break;
    1525             : 
    1526           0 :   case 17:
    1527             : #line 257 "source3/modules/getdate.y" /* yacc.c:1646  */
    1528             :     { pc->local_isdst = (yyvsp[-1].intval) < 0 ? 1 : (yyvsp[-1].intval) + 1; }
    1529             : #line 1530 "source3/modules/getdate.c" /* yacc.c:1646  */
    1530           0 :     break;
    1531             : 
    1532           0 :   case 18:
    1533             : #line 262 "source3/modules/getdate.y" /* yacc.c:1646  */
    1534             :     { pc->time_zone = (yyvsp[0].intval); }
    1535             : #line 1536 "source3/modules/getdate.c" /* yacc.c:1646  */
    1536           0 :     break;
    1537             : 
    1538           0 :   case 19:
    1539             : #line 264 "source3/modules/getdate.y" /* yacc.c:1646  */
    1540             :     { pc->time_zone = (yyvsp[0].intval) + 60; }
    1541             : #line 1542 "source3/modules/getdate.c" /* yacc.c:1646  */
    1542           0 :     break;
    1543             : 
    1544           0 :   case 20:
    1545             : #line 266 "source3/modules/getdate.y" /* yacc.c:1646  */
    1546             :     { pc->time_zone = (yyvsp[-1].intval) + 60; }
    1547             : #line 1548 "source3/modules/getdate.c" /* yacc.c:1646  */
    1548           0 :     break;
    1549             : 
    1550           0 :   case 21:
    1551             : #line 271 "source3/modules/getdate.y" /* yacc.c:1646  */
    1552             :     {
    1553             :         pc->day_ordinal = 1;
    1554             :         pc->day_number = (yyvsp[0].intval);
    1555             :       }
    1556             : #line 1557 "source3/modules/getdate.c" /* yacc.c:1646  */
    1557           0 :     break;
    1558             : 
    1559           0 :   case 22:
    1560             : #line 276 "source3/modules/getdate.y" /* yacc.c:1646  */
    1561             :     {
    1562             :         pc->day_ordinal = 1;
    1563             :         pc->day_number = (yyvsp[-1].intval);
    1564             :       }
    1565             : #line 1566 "source3/modules/getdate.c" /* yacc.c:1646  */
    1566           0 :     break;
    1567             : 
    1568           0 :   case 23:
    1569             : #line 281 "source3/modules/getdate.y" /* yacc.c:1646  */
    1570             :     {
    1571             :         pc->day_ordinal = (yyvsp[-1].textintval).value;
    1572             :         pc->day_number = (yyvsp[0].intval);
    1573             :       }
    1574             : #line 1575 "source3/modules/getdate.c" /* yacc.c:1646  */
    1575           0 :     break;
    1576             : 
    1577           0 :   case 24:
    1578             : #line 289 "source3/modules/getdate.y" /* yacc.c:1646  */
    1579             :     {
    1580             :         pc->month = (yyvsp[-2].textintval).value;
    1581             :         pc->day = (yyvsp[0].textintval).value;
    1582             :       }
    1583             : #line 1584 "source3/modules/getdate.c" /* yacc.c:1646  */
    1584           0 :     break;
    1585             : 
    1586           0 :   case 25:
    1587             : #line 294 "source3/modules/getdate.y" /* yacc.c:1646  */
    1588             :     {
    1589             :         /* Interpret as YYYY/MM/DD if the first value has 4 or more digits,
    1590             :            otherwise as MM/DD/YY.
    1591             :            The goal in recognizing YYYY/MM/DD is solely to support legacy
    1592             :            machine-generated dates like those in an RCS log listing.  If
    1593             :            you want portability, use the ISO 8601 format.  */
    1594             :         if (4 <= (yyvsp[-4].textintval).digits)
    1595             :           {
    1596             :             pc->year = (yyvsp[-4].textintval);
    1597             :             pc->month = (yyvsp[-2].textintval).value;
    1598             :             pc->day = (yyvsp[0].textintval).value;
    1599             :           }
    1600             :         else
    1601             :           {
    1602             :             pc->month = (yyvsp[-4].textintval).value;
    1603             :             pc->day = (yyvsp[-2].textintval).value;
    1604             :             pc->year = (yyvsp[0].textintval);
    1605             :           }
    1606             :       }
    1607             : #line 1608 "source3/modules/getdate.c" /* yacc.c:1646  */
    1608           0 :     break;
    1609             : 
    1610           0 :   case 26:
    1611             : #line 314 "source3/modules/getdate.y" /* yacc.c:1646  */
    1612             :     {
    1613             :         /* ISO 8601 format.  YYYY-MM-DD.  */
    1614             :         pc->year = (yyvsp[-2].textintval);
    1615             :         pc->month = -(yyvsp[-1].textintval).value;
    1616             :         pc->day = -(yyvsp[0].textintval).value;
    1617             :       }
    1618             : #line 1619 "source3/modules/getdate.c" /* yacc.c:1646  */
    1619           0 :     break;
    1620             : 
    1621           0 :   case 27:
    1622             : #line 321 "source3/modules/getdate.y" /* yacc.c:1646  */
    1623             :     {
    1624             :         /* e.g. 17-JUN-1992.  */
    1625             :         pc->day = (yyvsp[-2].textintval).value;
    1626             :         pc->month = (yyvsp[-1].intval);
    1627             :         pc->year.value = -(yyvsp[0].textintval).value;
    1628             :         pc->year.digits = (yyvsp[0].textintval).digits;
    1629             :       }
    1630             : #line 1631 "source3/modules/getdate.c" /* yacc.c:1646  */
    1631           0 :     break;
    1632             : 
    1633           0 :   case 28:
    1634             : #line 329 "source3/modules/getdate.y" /* yacc.c:1646  */
    1635             :     {
    1636             :         pc->month = (yyvsp[-1].intval);
    1637             :         pc->day = (yyvsp[0].textintval).value;
    1638             :       }
    1639             : #line 1640 "source3/modules/getdate.c" /* yacc.c:1646  */
    1640           0 :     break;
    1641             : 
    1642           0 :   case 29:
    1643             : #line 334 "source3/modules/getdate.y" /* yacc.c:1646  */
    1644             :     {
    1645             :         pc->month = (yyvsp[-3].intval);
    1646             :         pc->day = (yyvsp[-2].textintval).value;
    1647             :         pc->year = (yyvsp[0].textintval);
    1648             :       }
    1649             : #line 1650 "source3/modules/getdate.c" /* yacc.c:1646  */
    1650           0 :     break;
    1651             : 
    1652           0 :   case 30:
    1653             : #line 340 "source3/modules/getdate.y" /* yacc.c:1646  */
    1654             :     {
    1655             :         pc->day = (yyvsp[-1].textintval).value;
    1656             :         pc->month = (yyvsp[0].intval);
    1657             :       }
    1658             : #line 1659 "source3/modules/getdate.c" /* yacc.c:1646  */
    1659           0 :     break;
    1660             : 
    1661           0 :   case 31:
    1662             : #line 345 "source3/modules/getdate.y" /* yacc.c:1646  */
    1663             :     {
    1664             :         pc->day = (yyvsp[-2].textintval).value;
    1665             :         pc->month = (yyvsp[-1].intval);
    1666             :         pc->year = (yyvsp[0].textintval);
    1667             :       }
    1668             : #line 1669 "source3/modules/getdate.c" /* yacc.c:1646  */
    1669           0 :     break;
    1670             : 
    1671           0 :   case 32:
    1672             : #line 354 "source3/modules/getdate.y" /* yacc.c:1646  */
    1673             :     {
    1674             :         pc->rel_seconds = -pc->rel_seconds;
    1675             :         pc->rel_minutes = -pc->rel_minutes;
    1676             :         pc->rel_hour = -pc->rel_hour;
    1677             :         pc->rel_day = -pc->rel_day;
    1678             :         pc->rel_month = -pc->rel_month;
    1679             :         pc->rel_year = -pc->rel_year;
    1680             :       }
    1681             : #line 1682 "source3/modules/getdate.c" /* yacc.c:1646  */
    1682           0 :     break;
    1683             : 
    1684           0 :   case 34:
    1685             : #line 367 "source3/modules/getdate.y" /* yacc.c:1646  */
    1686             :     { pc->rel_year += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1687             : #line 1688 "source3/modules/getdate.c" /* yacc.c:1646  */
    1688           0 :     break;
    1689             : 
    1690           0 :   case 35:
    1691             : #line 369 "source3/modules/getdate.y" /* yacc.c:1646  */
    1692             :     { pc->rel_year += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1693             : #line 1694 "source3/modules/getdate.c" /* yacc.c:1646  */
    1694           0 :     break;
    1695             : 
    1696           0 :   case 36:
    1697             : #line 371 "source3/modules/getdate.y" /* yacc.c:1646  */
    1698             :     { pc->rel_year += (yyvsp[0].intval); }
    1699             : #line 1700 "source3/modules/getdate.c" /* yacc.c:1646  */
    1700           0 :     break;
    1701             : 
    1702           0 :   case 37:
    1703             : #line 373 "source3/modules/getdate.y" /* yacc.c:1646  */
    1704             :     { pc->rel_month += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1705             : #line 1706 "source3/modules/getdate.c" /* yacc.c:1646  */
    1706           0 :     break;
    1707             : 
    1708           0 :   case 38:
    1709             : #line 375 "source3/modules/getdate.y" /* yacc.c:1646  */
    1710             :     { pc->rel_month += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1711             : #line 1712 "source3/modules/getdate.c" /* yacc.c:1646  */
    1712           0 :     break;
    1713             : 
    1714           0 :   case 39:
    1715             : #line 377 "source3/modules/getdate.y" /* yacc.c:1646  */
    1716             :     { pc->rel_month += (yyvsp[0].intval); }
    1717             : #line 1718 "source3/modules/getdate.c" /* yacc.c:1646  */
    1718           0 :     break;
    1719             : 
    1720           0 :   case 40:
    1721             : #line 379 "source3/modules/getdate.y" /* yacc.c:1646  */
    1722             :     { pc->rel_day += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1723             : #line 1724 "source3/modules/getdate.c" /* yacc.c:1646  */
    1724           0 :     break;
    1725             : 
    1726           0 :   case 41:
    1727             : #line 381 "source3/modules/getdate.y" /* yacc.c:1646  */
    1728             :     { pc->rel_day += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1729             : #line 1730 "source3/modules/getdate.c" /* yacc.c:1646  */
    1730           0 :     break;
    1731             : 
    1732           0 :   case 42:
    1733             : #line 383 "source3/modules/getdate.y" /* yacc.c:1646  */
    1734             :     { pc->rel_day += (yyvsp[0].intval); }
    1735             : #line 1736 "source3/modules/getdate.c" /* yacc.c:1646  */
    1736           0 :     break;
    1737             : 
    1738           0 :   case 43:
    1739             : #line 385 "source3/modules/getdate.y" /* yacc.c:1646  */
    1740             :     { pc->rel_hour += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1741             : #line 1742 "source3/modules/getdate.c" /* yacc.c:1646  */
    1742           0 :     break;
    1743             : 
    1744           0 :   case 44:
    1745             : #line 387 "source3/modules/getdate.y" /* yacc.c:1646  */
    1746             :     { pc->rel_hour += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1747             : #line 1748 "source3/modules/getdate.c" /* yacc.c:1646  */
    1748           0 :     break;
    1749             : 
    1750           0 :   case 45:
    1751             : #line 389 "source3/modules/getdate.y" /* yacc.c:1646  */
    1752             :     { pc->rel_hour += (yyvsp[0].intval); }
    1753             : #line 1754 "source3/modules/getdate.c" /* yacc.c:1646  */
    1754           0 :     break;
    1755             : 
    1756           0 :   case 46:
    1757             : #line 391 "source3/modules/getdate.y" /* yacc.c:1646  */
    1758             :     { pc->rel_minutes += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1759             : #line 1760 "source3/modules/getdate.c" /* yacc.c:1646  */
    1760           0 :     break;
    1761             : 
    1762           0 :   case 47:
    1763             : #line 393 "source3/modules/getdate.y" /* yacc.c:1646  */
    1764             :     { pc->rel_minutes += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1765             : #line 1766 "source3/modules/getdate.c" /* yacc.c:1646  */
    1766           0 :     break;
    1767             : 
    1768           0 :   case 48:
    1769             : #line 395 "source3/modules/getdate.y" /* yacc.c:1646  */
    1770             :     { pc->rel_minutes += (yyvsp[0].intval); }
    1771             : #line 1772 "source3/modules/getdate.c" /* yacc.c:1646  */
    1772           0 :     break;
    1773             : 
    1774           0 :   case 49:
    1775             : #line 397 "source3/modules/getdate.y" /* yacc.c:1646  */
    1776             :     { pc->rel_seconds += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1777             : #line 1778 "source3/modules/getdate.c" /* yacc.c:1646  */
    1778           0 :     break;
    1779             : 
    1780           0 :   case 50:
    1781             : #line 399 "source3/modules/getdate.y" /* yacc.c:1646  */
    1782             :     { pc->rel_seconds += (yyvsp[-1].textintval).value * (yyvsp[0].intval); }
    1783             : #line 1784 "source3/modules/getdate.c" /* yacc.c:1646  */
    1784           0 :     break;
    1785             : 
    1786           0 :   case 51:
    1787             : #line 401 "source3/modules/getdate.y" /* yacc.c:1646  */
    1788             :     { pc->rel_seconds += (yyvsp[0].intval); }
    1789             : #line 1790 "source3/modules/getdate.c" /* yacc.c:1646  */
    1790           0 :     break;
    1791             : 
    1792           0 :   case 52:
    1793             : #line 406 "source3/modules/getdate.y" /* yacc.c:1646  */
    1794             :     {
    1795             :         if (pc->dates_seen
    1796             :             && ! pc->rels_seen && (pc->times_seen || 2 < (yyvsp[0].textintval).digits))
    1797             :           pc->year = (yyvsp[0].textintval);
    1798             :         else
    1799             :           {
    1800             :             if (4 < (yyvsp[0].textintval).digits)
    1801             :               {
    1802             :                 pc->dates_seen++;
    1803             :                 pc->day = (yyvsp[0].textintval).value % 100;
    1804             :                 pc->month = ((yyvsp[0].textintval).value / 100) % 100;
    1805             :                 pc->year.value = (yyvsp[0].textintval).value / 10000;
    1806             :                 pc->year.digits = (yyvsp[0].textintval).digits - 4;
    1807             :               }
    1808             :             else
    1809             :               {
    1810             :                 pc->times_seen++;
    1811             :                 if ((yyvsp[0].textintval).digits <= 2)
    1812             :                   {
    1813             :                     pc->hour = (yyvsp[0].textintval).value;
    1814             :                     pc->minutes = 0;
    1815             :                   }
    1816             :                 else
    1817             :                   {
    1818             :                     pc->hour = (yyvsp[0].textintval).value / 100;
    1819             :                     pc->minutes = (yyvsp[0].textintval).value % 100;
    1820             :                   }
    1821             :                 pc->seconds = 0;
    1822             :                 pc->meridian = MER24;
    1823             :               }
    1824             :           }
    1825             :       }
    1826             : #line 1827 "source3/modules/getdate.c" /* yacc.c:1646  */
    1827           0 :     break;
    1828             : 
    1829           0 :   case 53:
    1830             : #line 442 "source3/modules/getdate.y" /* yacc.c:1646  */
    1831             :     { (yyval.intval) = MER24; }
    1832             : #line 1833 "source3/modules/getdate.c" /* yacc.c:1646  */
    1833           0 :     break;
    1834             : 
    1835           0 :   case 54:
    1836             : #line 444 "source3/modules/getdate.y" /* yacc.c:1646  */
    1837             :     { (yyval.intval) = (yyvsp[0].intval); }
    1838             : #line 1839 "source3/modules/getdate.c" /* yacc.c:1646  */
    1839           0 :     break;
    1840             : 
    1841             : 
    1842             : #line 1843 "source3/modules/getdate.c" /* yacc.c:1646  */
    1843           0 :       default: break;
    1844             :     }
    1845             :   /* User semantic actions sometimes alter yychar, and that requires
    1846             :      that yytoken be updated with the new translation.  We take the
    1847             :      approach of translating immediately before every use of yytoken.
    1848             :      One alternative is translating here after every semantic action,
    1849             :      but that translation would be missed if the semantic action invokes
    1850             :      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
    1851             :      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
    1852             :      incorrect destructor might then be invoked immediately.  In the
    1853             :      case of YYERROR or YYBACKUP, subsequent parser actions might lead
    1854             :      to an incorrect destructor call or verbose syntax error message
    1855             :      before the lookahead is translated.  */
    1856             :   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
    1857             : 
    1858           0 :   YYPOPSTACK (yylen);
    1859           0 :   yylen = 0;
    1860             :   YY_STACK_PRINT (yyss, yyssp);
    1861             : 
    1862           0 :   *++yyvsp = yyval;
    1863             : 
    1864             :   /* Now 'shift' the result of the reduction.  Determine what state
    1865             :      that goes to, based on the state we popped back to and the rule
    1866             :      number reduced by.  */
    1867             : 
    1868           0 :   yyn = yyr1[yyn];
    1869             : 
    1870           0 :   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
    1871           0 :   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    1872           0 :     yystate = yytable[yystate];
    1873             :   else
    1874           0 :     yystate = yydefgoto[yyn - YYNTOKENS];
    1875             : 
    1876           0 :   goto yynewstate;
    1877             : 
    1878             : 
    1879             : /*--------------------------------------.
    1880             : | yyerrlab -- here on detecting error.  |
    1881             : `--------------------------------------*/
    1882           0 : yyerrlab:
    1883             :   /* Make sure we have latest lookahead translation.  See comments at
    1884             :      user semantic actions for why this is necessary.  */
    1885           0 :   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
    1886             : 
    1887             :   /* If not already recovering from an error, report this error.  */
    1888           0 :   if (!yyerrstatus)
    1889             :     {
    1890           0 :       ++yynerrs;
    1891             : #if ! YYERROR_VERBOSE
    1892           0 :       yyerror (pc, YY_("syntax error"));
    1893             : #else
    1894             : # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
    1895             :                                         yyssp, yytoken)
    1896             :       {
    1897             :         char const *yymsgp = YY_("syntax error");
    1898             :         int yysyntax_error_status;
    1899             :         yysyntax_error_status = YYSYNTAX_ERROR;
    1900             :         if (yysyntax_error_status == 0)
    1901             :           yymsgp = yymsg;
    1902             :         else if (yysyntax_error_status == 1)
    1903             :           {
    1904             :             if (yymsg != yymsgbuf)
    1905             :               YYSTACK_FREE (yymsg);
    1906             :             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
    1907             :             if (!yymsg)
    1908             :               {
    1909             :                 yymsg = yymsgbuf;
    1910             :                 yymsg_alloc = sizeof yymsgbuf;
    1911             :                 yysyntax_error_status = 2;
    1912             :               }
    1913             :             else
    1914             :               {
    1915             :                 yysyntax_error_status = YYSYNTAX_ERROR;
    1916             :                 yymsgp = yymsg;
    1917             :               }
    1918             :           }
    1919             :         yyerror (pc, yymsgp);
    1920             :         if (yysyntax_error_status == 2)
    1921             :           goto yyexhaustedlab;
    1922             :       }
    1923             : # undef YYSYNTAX_ERROR
    1924             : #endif
    1925             :     }
    1926             : 
    1927             : 
    1928             : 
    1929           0 :   if (yyerrstatus == 3)
    1930             :     {
    1931             :       /* If just tried and failed to reuse lookahead token after an
    1932             :          error, discard it.  */
    1933             : 
    1934           0 :       if (yychar <= YYEOF)
    1935             :         {
    1936             :           /* Return failure if at end of input.  */
    1937           0 :           if (yychar == YYEOF)
    1938           0 :             YYABORT;
    1939             :         }
    1940             :       else
    1941             :         {
    1942           0 :           yydestruct ("Error: discarding",
    1943             :                       yytoken, &yylval, pc);
    1944           0 :           yychar = YYEMPTY;
    1945             :         }
    1946             :     }
    1947             : 
    1948             :   /* Else will try to reuse lookahead token after shifting the error
    1949             :      token.  */
    1950           0 :   goto yyerrlab1;
    1951             : 
    1952             : 
    1953             : /*---------------------------------------------------.
    1954             : | yyerrorlab -- error raised explicitly by YYERROR.  |
    1955             : `---------------------------------------------------*/
    1956             : yyerrorlab:
    1957             : 
    1958             :   /* Pacify compilers like GCC when the user code never invokes
    1959             :      YYERROR and the label yyerrorlab therefore never appears in user
    1960             :      code.  */
    1961             :   if (/*CONSTCOND*/ 0)
    1962             :      goto yyerrorlab;
    1963             : 
    1964             :   /* Do not reclaim the symbols of the rule whose action triggered
    1965             :      this YYERROR.  */
    1966             :   YYPOPSTACK (yylen);
    1967             :   yylen = 0;
    1968             :   YY_STACK_PRINT (yyss, yyssp);
    1969             :   yystate = *yyssp;
    1970             :   goto yyerrlab1;
    1971             : 
    1972             : 
    1973             : /*-------------------------------------------------------------.
    1974             : | yyerrlab1 -- common code for both syntax error and YYERROR.  |
    1975             : `-------------------------------------------------------------*/
    1976           0 : yyerrlab1:
    1977           0 :   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
    1978             : 
    1979             :   for (;;)
    1980             :     {
    1981           0 :       yyn = yypact[yystate];
    1982           0 :       if (!yypact_value_is_default (yyn))
    1983             :         {
    1984           0 :           yyn += YYTERROR;
    1985           0 :           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
    1986             :             {
    1987           0 :               yyn = yytable[yyn];
    1988           0 :               if (0 < yyn)
    1989           0 :                 break;
    1990             :             }
    1991             :         }
    1992             : 
    1993             :       /* Pop the current state because it cannot handle the error token.  */
    1994           0 :       if (yyssp == yyss)
    1995           0 :         YYABORT;
    1996             : 
    1997             : 
    1998           0 :       yydestruct ("Error: popping",
    1999           0 :                   yystos[yystate], yyvsp, pc);
    2000           0 :       YYPOPSTACK (1);
    2001           0 :       yystate = *yyssp;
    2002             :       YY_STACK_PRINT (yyss, yyssp);
    2003             :     }
    2004             : 
    2005             :   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    2006           0 :   *++yyvsp = yylval;
    2007             :   YY_IGNORE_MAYBE_UNINITIALIZED_END
    2008             : 
    2009             : 
    2010             :   /* Shift the error token.  */
    2011             :   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
    2012             : 
    2013           0 :   yystate = yyn;
    2014           0 :   goto yynewstate;
    2015             : 
    2016             : 
    2017             : /*-------------------------------------.
    2018             : | yyacceptlab -- YYACCEPT comes here.  |
    2019             : `-------------------------------------*/
    2020           0 : yyacceptlab:
    2021           0 :   yyresult = 0;
    2022           0 :   goto yyreturn;
    2023             : 
    2024             : /*-----------------------------------.
    2025             : | yyabortlab -- YYABORT comes here.  |
    2026             : `-----------------------------------*/
    2027           0 : yyabortlab:
    2028           0 :   yyresult = 1;
    2029           0 :   goto yyreturn;
    2030             : 
    2031             : #if !defined yyoverflow || YYERROR_VERBOSE
    2032             : /*-------------------------------------------------.
    2033             : | yyexhaustedlab -- memory exhaustion comes here.  |
    2034             : `-------------------------------------------------*/
    2035           0 : yyexhaustedlab:
    2036           0 :   yyerror (pc, YY_("memory exhausted"));
    2037           0 :   yyresult = 2;
    2038             :   /* Fall through.  */
    2039             : #endif
    2040             : 
    2041           0 : yyreturn:
    2042           0 :   if (yychar != YYEMPTY)
    2043             :     {
    2044             :       /* Make sure we have latest lookahead translation.  See comments at
    2045             :          user semantic actions for why this is necessary.  */
    2046           0 :       yytoken = YYTRANSLATE (yychar);
    2047           0 :       yydestruct ("Cleanup: discarding lookahead",
    2048             :                   yytoken, &yylval, pc);
    2049             :     }
    2050             :   /* Do not reclaim the symbols of the rule whose action triggered
    2051             :      this YYABORT or YYACCEPT.  */
    2052           0 :   YYPOPSTACK (yylen);
    2053             :   YY_STACK_PRINT (yyss, yyssp);
    2054           0 :   while (yyssp != yyss)
    2055             :     {
    2056           0 :       yydestruct ("Cleanup: popping",
    2057           0 :                   yystos[*yyssp], yyvsp, pc);
    2058           0 :       YYPOPSTACK (1);
    2059             :     }
    2060             : #ifndef yyoverflow
    2061           0 :   if (yyss != yyssa)
    2062           0 :     YYSTACK_FREE (yyss);
    2063             : #endif
    2064             : #if YYERROR_VERBOSE
    2065             :   if (yymsg != yymsgbuf)
    2066             :     YYSTACK_FREE (yymsg);
    2067             : #endif
    2068           0 :   return yyresult;
    2069             : }
    2070             : #line 447 "source3/modules/getdate.y" /* yacc.c:1906  */
    2071             : 
    2072             : 
    2073             : /* Include this file down here because bison inserts code above which
    2074             :    may define-away `const'.  We want the prototype for get_date to have
    2075             :    the same signature as the function definition.  */
    2076             : #include "modules/getdate.h"
    2077             : 
    2078             : #ifndef gmtime
    2079             : struct tm *gmtime (const time_t *);
    2080             : #endif
    2081             : #ifndef localtime
    2082             : struct tm *localtime (const time_t *);
    2083             : #endif
    2084             : #ifndef mktime
    2085             : time_t mktime (struct tm *);
    2086             : #endif
    2087             : 
    2088             : static table const meridian_table[] =
    2089             : {
    2090             :   { "AM",   tMERIDIAN, MERam },
    2091             :   { "A.M.", tMERIDIAN, MERam },
    2092             :   { "PM",   tMERIDIAN, MERpm },
    2093             :   { "P.M.", tMERIDIAN, MERpm },
    2094             :   { 0, 0, 0 }
    2095             : };
    2096             : 
    2097             : static table const dst_table[] =
    2098             : {
    2099             :   { "DST", tDST, 0 }
    2100             : };
    2101             : 
    2102             : static table const month_and_day_table[] =
    2103             : {
    2104             :   { "JANUARY",        tMONTH,  1 },
    2105             :   { "FEBRUARY",       tMONTH,  2 },
    2106             :   { "MARCH",  tMONTH,  3 },
    2107             :   { "APRIL",  tMONTH,  4 },
    2108             :   { "MAY",    tMONTH,  5 },
    2109             :   { "JUNE",   tMONTH,  6 },
    2110             :   { "JULY",   tMONTH,  7 },
    2111             :   { "AUGUST", tMONTH,  8 },
    2112             :   { "SEPTEMBER",tMONTH,        9 },
    2113             :   { "SEPT",   tMONTH,  9 },
    2114             :   { "OCTOBER",        tMONTH, 10 },
    2115             :   { "NOVEMBER",       tMONTH, 11 },
    2116             :   { "DECEMBER",       tMONTH, 12 },
    2117             :   { "SUNDAY", tDAY,    0 },
    2118             :   { "MONDAY", tDAY,    1 },
    2119             :   { "TUESDAY",        tDAY,    2 },
    2120             :   { "TUES",   tDAY,    2 },
    2121             :   { "WEDNESDAY",tDAY,  3 },
    2122             :   { "WEDNES", tDAY,    3 },
    2123             :   { "THURSDAY",       tDAY,    4 },
    2124             :   { "THUR",   tDAY,    4 },
    2125             :   { "THURS",  tDAY,    4 },
    2126             :   { "FRIDAY", tDAY,    5 },
    2127             :   { "SATURDAY",       tDAY,    6 },
    2128             :   { 0, 0, 0 }
    2129             : };
    2130             : 
    2131             : static table const time_units_table[] =
    2132             : {
    2133             :   { "YEAR",   tYEAR_UNIT,      1 },
    2134             :   { "MONTH",  tMONTH_UNIT,     1 },
    2135             :   { "FORTNIGHT",tDAY_UNIT,    14 },
    2136             :   { "WEEK",   tDAY_UNIT,       7 },
    2137             :   { "DAY",    tDAY_UNIT,       1 },
    2138             :   { "HOUR",   tHOUR_UNIT,      1 },
    2139             :   { "MINUTE", tMINUTE_UNIT,    1 },
    2140             :   { "MIN",    tMINUTE_UNIT,    1 },
    2141             :   { "SECOND", tSEC_UNIT,       1 },
    2142             :   { "SEC",    tSEC_UNIT,       1 },
    2143             :   { 0, 0, 0 }
    2144             : };
    2145             : 
    2146             : /* Assorted relative-time words. */
    2147             : static table const relative_time_table[] =
    2148             : {
    2149             :   { "TOMORROW",       tMINUTE_UNIT,   24 * 60 },
    2150             :   { "YESTERDAY",tMINUTE_UNIT, - (24 * 60) },
    2151             :   { "TODAY",  tMINUTE_UNIT,    0 },
    2152             :   { "NOW",    tMINUTE_UNIT,    0 },
    2153             :   { "LAST",   tUNUMBER,       -1 },
    2154             :   { "THIS",   tUNUMBER,        0 },
    2155             :   { "NEXT",   tUNUMBER,        1 },
    2156             :   { "FIRST",  tUNUMBER,        1 },
    2157             : /*{ "SECOND", tUNUMBER,        2 }, */
    2158             :   { "THIRD",  tUNUMBER,        3 },
    2159             :   { "FOURTH", tUNUMBER,        4 },
    2160             :   { "FIFTH",  tUNUMBER,        5 },
    2161             :   { "SIXTH",  tUNUMBER,        6 },
    2162             :   { "SEVENTH",        tUNUMBER,        7 },
    2163             :   { "EIGHTH", tUNUMBER,        8 },
    2164             :   { "NINTH",  tUNUMBER,        9 },
    2165             :   { "TENTH",  tUNUMBER,       10 },
    2166             :   { "ELEVENTH",       tUNUMBER,       11 },
    2167             :   { "TWELFTH",        tUNUMBER,       12 },
    2168             :   { "AGO",    tAGO,            1 },
    2169             :   { 0, 0, 0 }
    2170             : };
    2171             : 
    2172             : /* The time zone table.  This table is necessarily incomplete, as time
    2173             :    zone abbreviations are ambiguous; e.g. Australians interpret "EST"
    2174             :    as Eastern time in Australia, not as US Eastern Standard Time.
    2175             :    You cannot rely on getdate to handle arbitrary time zone
    2176             :    abbreviations; use numeric abbreviations like `-0500' instead.  */
    2177             : static table const time_zone_table[] =
    2178             : {
    2179             :   { "GMT",    tZONE,     HOUR ( 0) }, /* Greenwich Mean */
    2180             :   { "UT",     tZONE,     HOUR ( 0) }, /* Universal (Coordinated) */
    2181             :   { "UTC",    tZONE,     HOUR ( 0) },
    2182             :   { "WET",    tZONE,     HOUR ( 0) }, /* Western European */
    2183             :   { "WEST",   tDAYZONE,  HOUR ( 0) }, /* Western European Summer */
    2184             :   { "BST",    tDAYZONE,  HOUR ( 0) }, /* British Summer */
    2185             :   { "ART",    tZONE,    -HOUR ( 3) }, /* Argentina */
    2186             :   { "BRT",    tZONE,    -HOUR ( 3) }, /* Brazil */
    2187             :   { "BRST",   tDAYZONE, -HOUR ( 3) }, /* Brazil Summer */
    2188             :   { "NST",    tZONE,   -(HOUR ( 3) + 30) },   /* Newfoundland Standard */
    2189             :   { "NDT",    tDAYZONE,-(HOUR ( 3) + 30) },   /* Newfoundland Daylight */
    2190             :   { "AST",    tZONE,    -HOUR ( 4) }, /* Atlantic Standard */
    2191             :   { "ADT",    tDAYZONE, -HOUR ( 4) }, /* Atlantic Daylight */
    2192             :   { "CLT",    tZONE,    -HOUR ( 4) }, /* Chile */
    2193             :   { "CLST",   tDAYZONE, -HOUR ( 4) }, /* Chile Summer */
    2194             :   { "EST",    tZONE,    -HOUR ( 5) }, /* Eastern Standard */
    2195             :   { "EDT",    tDAYZONE, -HOUR ( 5) }, /* Eastern Daylight */
    2196             :   { "CST",    tZONE,    -HOUR ( 6) }, /* Central Standard */
    2197             :   { "CDT",    tDAYZONE, -HOUR ( 6) }, /* Central Daylight */
    2198             :   { "MST",    tZONE,    -HOUR ( 7) }, /* Mountain Standard */
    2199             :   { "MDT",    tDAYZONE, -HOUR ( 7) }, /* Mountain Daylight */
    2200             :   { "PST",    tZONE,    -HOUR ( 8) }, /* Pacific Standard */
    2201             :   { "PDT",    tDAYZONE, -HOUR ( 8) }, /* Pacific Daylight */
    2202             :   { "AKST",   tZONE,    -HOUR ( 9) }, /* Alaska Standard */
    2203             :   { "AKDT",   tDAYZONE, -HOUR ( 9) }, /* Alaska Daylight */
    2204             :   { "HST",    tZONE,    -HOUR (10) }, /* Hawaii Standard */
    2205             :   { "HAST",   tZONE,    -HOUR (10) }, /* Hawaii-Aleutian Standard */
    2206             :   { "HADT",   tDAYZONE, -HOUR (10) }, /* Hawaii-Aleutian Daylight */
    2207             :   { "SST",    tZONE,    -HOUR (12) }, /* Samoa Standard */
    2208             :   { "WAT",    tZONE,     HOUR ( 1) }, /* West Africa */
    2209             :   { "CET",    tZONE,     HOUR ( 1) }, /* Central European */
    2210             :   { "CEST",   tDAYZONE,  HOUR ( 1) }, /* Central European Summer */
    2211             :   { "MET",    tZONE,     HOUR ( 1) }, /* Middle European */
    2212             :   { "MEZ",    tZONE,     HOUR ( 1) }, /* Middle European */
    2213             :   { "MEST",   tDAYZONE,  HOUR ( 1) }, /* Middle European Summer */
    2214             :   { "MESZ",   tDAYZONE,  HOUR ( 1) }, /* Middle European Summer */
    2215             :   { "EET",    tZONE,     HOUR ( 2) }, /* Eastern European */
    2216             :   { "EEST",   tDAYZONE,  HOUR ( 2) }, /* Eastern European Summer */
    2217             :   { "CAT",    tZONE,     HOUR ( 2) }, /* Central Africa */
    2218             :   { "SAST",   tZONE,     HOUR ( 2) }, /* South Africa Standard */
    2219             :   { "EAT",    tZONE,     HOUR ( 3) }, /* East Africa */
    2220             :   { "MSK",    tZONE,     HOUR ( 3) }, /* Moscow */
    2221             :   { "MSD",    tDAYZONE,  HOUR ( 3) }, /* Moscow Daylight */
    2222             :   { "IST",    tZONE,    (HOUR ( 5) + 30) },   /* India Standard */
    2223             :   { "SGT",    tZONE,     HOUR ( 8) }, /* Singapore */
    2224             :   { "KST",    tZONE,     HOUR ( 9) }, /* Korea Standard */
    2225             :   { "JST",    tZONE,     HOUR ( 9) }, /* Japan Standard */
    2226             :   { "GST",    tZONE,     HOUR (10) }, /* Guam Standard */
    2227             :   { "NZST",   tZONE,     HOUR (12) }, /* New Zealand Standard */
    2228             :   { "NZDT",   tDAYZONE,  HOUR (12) }, /* New Zealand Daylight */
    2229             :   { 0, 0, 0  }
    2230             : };
    2231             : 
    2232             : /* Military time zone table. */
    2233             : static table const military_table[] =
    2234             : {
    2235             :   { "A", tZONE,       -HOUR ( 1) },
    2236             :   { "B", tZONE,       -HOUR ( 2) },
    2237             :   { "C", tZONE,       -HOUR ( 3) },
    2238             :   { "D", tZONE,       -HOUR ( 4) },
    2239             :   { "E", tZONE,       -HOUR ( 5) },
    2240             :   { "F", tZONE,       -HOUR ( 6) },
    2241             :   { "G", tZONE,       -HOUR ( 7) },
    2242             :   { "H", tZONE,       -HOUR ( 8) },
    2243             :   { "I", tZONE,       -HOUR ( 9) },
    2244             :   { "K", tZONE,       -HOUR (10) },
    2245             :   { "L", tZONE,       -HOUR (11) },
    2246             :   { "M", tZONE,       -HOUR (12) },
    2247             :   { "N", tZONE,        HOUR ( 1) },
    2248             :   { "O", tZONE,        HOUR ( 2) },
    2249             :   { "P", tZONE,        HOUR ( 3) },
    2250             :   { "Q", tZONE,        HOUR ( 4) },
    2251             :   { "R", tZONE,        HOUR ( 5) },
    2252             :   { "S", tZONE,        HOUR ( 6) },
    2253             :   { "T", tZONE,        HOUR ( 7) },
    2254             :   { "U", tZONE,        HOUR ( 8) },
    2255             :   { "V", tZONE,        HOUR ( 9) },
    2256             :   { "W", tZONE,        HOUR (10) },
    2257             :   { "X", tZONE,        HOUR (11) },
    2258             :   { "Y", tZONE,        HOUR (12) },
    2259             :   { "Z", tZONE,        HOUR ( 0) },
    2260             :   { 0, 0, 0 }
    2261             : };
    2262             : 
    2263             : 
    2264             : 
    2265             : static int
    2266             : to_hour (int hours, int meridian)
    2267             : {
    2268             :   switch (meridian)
    2269             :     {
    2270             :     case MER24:
    2271             :       return 0 <= hours && hours < 24 ? hours : -1;
    2272             :     case MERam:
    2273             :       return 0 < hours && hours < 12 ? hours : hours == 12 ? 0 : -1;
    2274             :     case MERpm:
    2275             :       return 0 < hours && hours < 12 ? hours + 12 : hours == 12 ? 12 : -1;
    2276             :     default:
    2277             :       abort ();
    2278             :     }
    2279             :   /* NOTREACHED */
    2280             :     return 0;
    2281             : }
    2282             : 
    2283             : static int
    2284             : to_year (textint textyear)
    2285             : {
    2286             :   int year = textyear.value;
    2287             : 
    2288             :   if (year < 0)
    2289             :     year = -year;
    2290             : 
    2291             :   /* XPG4 suggests that years 00-68 map to 2000-2068, and
    2292             :      years 69-99 map to 1969-1999.  */
    2293             :   if (textyear.digits == 2)
    2294             :     year += year < 69 ? 2000 : 1900;
    2295             : 
    2296             :   return year;
    2297             : }
    2298             : 
    2299             : static table const *
    2300             : lookup_zone (struct parser_control const *pc, char const *name)
    2301             : {
    2302             :   table const *tp;
    2303             : 
    2304             :   /* Try local zone abbreviations first; they're more likely to be right.  */
    2305             :   for (tp = pc->local_time_zone_table; tp->name; tp++)
    2306             :     if (strcmp (name, tp->name) == 0)
    2307             :       return tp;
    2308             : 
    2309             :   for (tp = time_zone_table; tp->name; tp++)
    2310             :     if (strcmp (name, tp->name) == 0)
    2311             :       return tp;
    2312             : 
    2313             :   return 0;
    2314             : }
    2315             : 
    2316             : #if ! HAVE_TM_GMTOFF
    2317             : /* Yield the difference between *A and *B,
    2318             :    measured in seconds, ignoring leap seconds.
    2319             :    The body of this function is taken directly from the GNU C Library;
    2320             :    see src/strftime.c.  */
    2321             : static int
    2322             : tm_diff (struct tm const *a, struct tm const *b)
    2323             : {
    2324             :   /* Compute intervening leap days correctly even if year is negative.
    2325             :      Take care to avoid int overflow in leap day calculations,
    2326             :      but it's OK to assume that A and B are close to each other.  */
    2327             :   int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
    2328             :   int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
    2329             :   int a100 = a4 / 25 - (a4 % 25 < 0);
    2330             :   int b100 = b4 / 25 - (b4 % 25 < 0);
    2331             :   int a400 = a100 >> 2;
    2332             :   int b400 = b100 >> 2;
    2333             :   int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
    2334             :   int years = a->tm_year - b->tm_year;
    2335             :   int days = (365 * years + intervening_leap_days
    2336             :               + (a->tm_yday - b->tm_yday));
    2337             :   return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
    2338             :                 + (a->tm_min - b->tm_min))
    2339             :           + (a->tm_sec - b->tm_sec));
    2340             : }
    2341             : #endif /* ! HAVE_TM_GMTOFF */
    2342             : 
    2343             : static table const *
    2344             : lookup_word (struct parser_control const *pc, char *word)
    2345             : {
    2346             :   char *p;
    2347             :   char *q;
    2348             :   size_t wordlen;
    2349             :   table const *tp;
    2350             :   int i;
    2351             :   int abbrev;
    2352             : 
    2353             :   /* Make it uppercase.  */
    2354             :   for (p = word; *p; p++)
    2355             :     if (ISLOWER ((unsigned char) *p))
    2356             :       *p = toupper ((unsigned char) *p);
    2357             : 
    2358             :   for (tp = meridian_table; tp->name; tp++)
    2359             :     if (strcmp (word, tp->name) == 0)
    2360             :       return tp;
    2361             : 
    2362             :   /* See if we have an abbreviation for a month. */
    2363             :   wordlen = strlen (word);
    2364             :   abbrev = wordlen == 3 || (wordlen == 4 && word[3] == '.');
    2365             : 
    2366             :   for (tp = month_and_day_table; tp->name; tp++)
    2367             :     if ((abbrev ? strncmp (word, tp->name, 3) : strcmp (word, tp->name)) == 0)
    2368             :       return tp;
    2369             : 
    2370             :   if ((tp = lookup_zone (pc, word)))
    2371             :     return tp;
    2372             : 
    2373             :   if (strcmp (word, dst_table[0].name) == 0)
    2374             :     return dst_table;
    2375             : 
    2376             :   for (tp = time_units_table; tp->name; tp++)
    2377             :     if (strcmp (word, tp->name) == 0)
    2378             :       return tp;
    2379             : 
    2380             :   /* Strip off any plural and try the units table again. */
    2381             :   if (word[wordlen - 1] == 'S')
    2382             :     {
    2383             :       word[wordlen - 1] = '\0';
    2384             :       for (tp = time_units_table; tp->name; tp++)
    2385             :         if (strcmp (word, tp->name) == 0)
    2386             :           return tp;
    2387             :       word[wordlen - 1] = 'S';  /* For "this" in relative_time_table.  */
    2388             :     }
    2389             : 
    2390             :   for (tp = relative_time_table; tp->name; tp++)
    2391             :     if (strcmp (word, tp->name) == 0)
    2392             :       return tp;
    2393             : 
    2394             :   /* Military time zones. */
    2395             :   if (wordlen == 1)
    2396             :     for (tp = military_table; tp->name; tp++)
    2397             :       if (word[0] == tp->name[0])
    2398             :         return tp;
    2399             : 
    2400             :   /* Drop out any periods and try the time zone table again. */
    2401             :   for (i = 0, p = q = word; (*p = *q); q++)
    2402             :     if (*q == '.')
    2403             :       i = 1;
    2404             :     else
    2405             :       p++;
    2406             :   if (i && (tp = lookup_zone (pc, word)))
    2407             :     return tp;
    2408             : 
    2409             :   return 0;
    2410             : }
    2411             : 
    2412             : static int
    2413             : yylex (YYSTYPE *lvalp, struct parser_control *pc)
    2414             : {
    2415             :   unsigned char c;
    2416             :   size_t count;
    2417             : 
    2418             :   for (;;)
    2419             :     {
    2420             :       while (c = *pc->input, ISSPACE (c))
    2421             :         pc->input++;
    2422             : 
    2423             :       if (ISDIGIT (c) || c == '-' || c == '+')
    2424             :         {
    2425             :           char const *p;
    2426             :           int sign;
    2427             :           int value;
    2428             :           if (c == '-' || c == '+')
    2429             :             {
    2430             :               sign = c == '-' ? -1 : 1;
    2431             :               c = *++pc->input;
    2432             :               if (! ISDIGIT (c))
    2433             :                 /* skip the '-' sign */
    2434             :                 continue;
    2435             :             }
    2436             :           else
    2437             :             sign = 0;
    2438             :           p = pc->input;
    2439             :           value = 0;
    2440             :           do
    2441             :             {
    2442             :               value = 10 * value + c - '0';
    2443             :               c = *++p;
    2444             :             }
    2445             :           while (ISDIGIT (c));
    2446             :           lvalp->textintval.value = sign < 0 ? -value : value;
    2447             :           lvalp->textintval.digits = p - pc->input;
    2448             :           pc->input = p;
    2449             :           return sign ? tSNUMBER : tUNUMBER;
    2450             :         }
    2451             : 
    2452             :       if (ISALPHA (c))
    2453             :         {
    2454             :           char buff[20];
    2455             :           size_t i = 0;
    2456             :           table const *tp;
    2457             : 
    2458             :           do
    2459             :             {
    2460             :               if (i < 20)
    2461             :                 buff[i++] = c;
    2462             :               c = *++pc->input;
    2463             :             }
    2464             :           while (ISALPHA (c) || c == '.');
    2465             : 
    2466             :           buff[i] = '\0';
    2467             :           tp = lookup_word (pc, buff);
    2468             :           if (! tp)
    2469             :             return '?';
    2470             :           lvalp->intval = tp->value;
    2471             :           return tp->type;
    2472             :         }
    2473             : 
    2474             :       if (c != '(')
    2475             :         return *pc->input++;
    2476             :       count = 0;
    2477             :       do
    2478             :         {
    2479             :           c = *pc->input++;
    2480             :           if (c == '\0')
    2481             :             return c;
    2482             :           if (c == '(')
    2483             :             count++;
    2484             :           else if (c == ')')
    2485             :             count--;
    2486             :         }
    2487             :       while (count > 0);
    2488             :     }
    2489             : }
    2490             : 
    2491             : /* Do nothing if the parser reports an error.  */
    2492             : static int
    2493             : yyerror (struct parser_control *pc ATTRIBUTE_UNUSED, const char *s ATTRIBUTE_UNUSED)
    2494             : {
    2495             :   return 0;
    2496             : }
    2497             : 
    2498             : /* Parse a date/time string P.  Return the corresponding time_t value,
    2499             :    or (time_t) -1 if there is an error.  P can be an incomplete or
    2500             :    relative time specification; if so, use *NOW as the basis for the
    2501             :    returned time.  */
    2502             : time_t
    2503             : get_date (const char *p, const time_t *now)
    2504             : {
    2505             :   time_t Start = now ? *now : time (0);
    2506             :   struct tm *tmp = localtime (&Start);
    2507             :   struct tm tm;
    2508             :   struct tm tm0;
    2509             :   struct parser_control pc;
    2510             : 
    2511             :   if (! tmp)
    2512             :     return -1;
    2513             : 
    2514             :   pc.input = p;
    2515             :   pc.year.value = tmp->tm_year + TM_YEAR_BASE;
    2516             :   pc.year.digits = 4;
    2517             :   pc.month = tmp->tm_mon + 1;
    2518             :   pc.day = tmp->tm_mday;
    2519             :   pc.hour = tmp->tm_hour;
    2520             :   pc.minutes = tmp->tm_min;
    2521             :   pc.seconds = tmp->tm_sec;
    2522             :   tm.tm_isdst = tmp->tm_isdst;
    2523             : 
    2524             :   pc.meridian = MER24;
    2525             :   pc.rel_seconds = 0;
    2526             :   pc.rel_minutes = 0;
    2527             :   pc.rel_hour = 0;
    2528             :   pc.rel_day = 0;
    2529             :   pc.rel_month = 0;
    2530             :   pc.rel_year = 0;
    2531             :   pc.dates_seen = 0;
    2532             :   pc.days_seen = 0;
    2533             :   pc.rels_seen = 0;
    2534             :   pc.times_seen = 0;
    2535             :   pc.local_zones_seen = 0;
    2536             :   pc.zones_seen = 0;
    2537             : 
    2538             : #ifdef HAVE_STRUCT_TM_TM_ZONE
    2539             :   pc.local_time_zone_table[0].name = tmp->tm_zone;
    2540             :   pc.local_time_zone_table[0].type = tLOCAL_ZONE;
    2541             :   pc.local_time_zone_table[0].value = tmp->tm_isdst;
    2542             :   pc.local_time_zone_table[1].name = 0;
    2543             : 
    2544             :   /* Probe the names used in the next three calendar quarters, looking
    2545             :      for a tm_isdst different from the one we already have.  */
    2546             :   {
    2547             :     int quarter;
    2548             :     for (quarter = 1; quarter <= 3; quarter++)
    2549             :       {
    2550             :         time_t probe = Start + quarter * (90 * 24 * 60 * 60);
    2551             :         struct tm *probe_tm = localtime (&probe);
    2552             :         if (probe_tm && probe_tm->tm_zone
    2553             :             && probe_tm->tm_isdst != pc.local_time_zone_table[0].value)
    2554             :           {
    2555             :               {
    2556             :                 pc.local_time_zone_table[1].name = probe_tm->tm_zone;
    2557             :                 pc.local_time_zone_table[1].type = tLOCAL_ZONE;
    2558             :                 pc.local_time_zone_table[1].value = probe_tm->tm_isdst;
    2559             :                 pc.local_time_zone_table[2].name = 0;
    2560             :               }
    2561             :             break;
    2562             :           }
    2563             :       }
    2564             :   }
    2565             : #else
    2566             : #ifdef HAVE_TZNAME
    2567             :   {
    2568             : # ifndef tzname
    2569             :     extern char *tzname[];
    2570             : # endif
    2571             :     int i;
    2572             :     for (i = 0; i < 2; i++)
    2573             :       {
    2574             :         pc.local_time_zone_table[i].name = tzname[i];
    2575             :         pc.local_time_zone_table[i].type = tLOCAL_ZONE;
    2576             :         pc.local_time_zone_table[i].value = i;
    2577             :       }
    2578             :     pc.local_time_zone_table[i].name = 0;
    2579             :   }
    2580             : #else
    2581             :   pc.local_time_zone_table[0].name = 0;
    2582             : #endif
    2583             : #endif
    2584             : 
    2585             :   if (pc.local_time_zone_table[0].name && pc.local_time_zone_table[1].name
    2586             :       && ! strcmp (pc.local_time_zone_table[0].name,
    2587             :                    pc.local_time_zone_table[1].name))
    2588             :     {
    2589             :       /* This locale uses the same abbrevation for standard and
    2590             :          daylight times.  So if we see that abbreviation, we don't
    2591             :          know whether it's daylight time.  */
    2592             :       pc.local_time_zone_table[0].value = -1;
    2593             :       pc.local_time_zone_table[1].name = 0;
    2594             :     }
    2595             : 
    2596             :   if (yyparse (&pc) != 0
    2597             :       || 1 < pc.times_seen || 1 < pc.dates_seen || 1 < pc.days_seen
    2598             :       || 1 < (pc.local_zones_seen + pc.zones_seen)
    2599             :       || (pc.local_zones_seen && 1 < pc.local_isdst))
    2600             :     return -1;
    2601             : 
    2602             :   tm.tm_year = to_year (pc.year) - TM_YEAR_BASE + pc.rel_year;
    2603             :   tm.tm_mon = pc.month - 1 + pc.rel_month;
    2604             :   tm.tm_mday = pc.day + pc.rel_day;
    2605             :   if (pc.times_seen || (pc.rels_seen && ! pc.dates_seen && ! pc.days_seen))
    2606             :     {
    2607             :       tm.tm_hour = to_hour (pc.hour, pc.meridian);
    2608             :       if (tm.tm_hour < 0)
    2609             :         return -1;
    2610             :       tm.tm_min = pc.minutes;
    2611             :       tm.tm_sec = pc.seconds;
    2612             :     }
    2613             :   else
    2614             :     {
    2615             :       tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
    2616             :     }
    2617             : 
    2618             :   /* Let mktime deduce tm_isdst if we have an absolute time stamp,
    2619             :      or if the relative time stamp mentions days, months, or years.  */
    2620             :   if (pc.dates_seen | pc.days_seen | pc.times_seen | pc.rel_day
    2621             :       | pc.rel_month | pc.rel_year)
    2622             :     tm.tm_isdst = -1;
    2623             : 
    2624             :   /* But if the input explicitly specifies local time with or without
    2625             :      DST, give mktime that information.  */
    2626             :   if (pc.local_zones_seen)
    2627             :     tm.tm_isdst = pc.local_isdst;
    2628             : 
    2629             :   tm0 = tm;
    2630             : 
    2631             :   Start = mktime (&tm);
    2632             : 
    2633             :   if (Start == (time_t) -1)
    2634             :     {
    2635             : 
    2636             :       /* Guard against falsely reporting errors near the time_t boundaries
    2637             :          when parsing times in other time zones.  For example, if the min
    2638             :          time_t value is 1970-01-01 00:00:00 UTC and we are 8 hours ahead
    2639             :          of UTC, then the min localtime value is 1970-01-01 08:00:00; if
    2640             :          we apply mktime to 1970-01-01 00:00:00 we will get an error, so
    2641             :          we apply mktime to 1970-01-02 08:00:00 instead and adjust the time
    2642             :          zone by 24 hours to compensate.  This algorithm assumes that
    2643             :          there is no DST transition within a day of the time_t boundaries.  */
    2644             :       if (pc.zones_seen)
    2645             :         {
    2646             :           tm = tm0;
    2647             :           if (tm.tm_year <= EPOCH_YEAR - TM_YEAR_BASE)
    2648             :             {
    2649             :               tm.tm_mday++;
    2650             :               pc.time_zone += 24 * 60;
    2651             :             }
    2652             :           else
    2653             :             {
    2654             :               tm.tm_mday--;
    2655             :               pc.time_zone -= 24 * 60;
    2656             :             }
    2657             :           Start = mktime (&tm);
    2658             :         }
    2659             : 
    2660             :       if (Start == (time_t) -1)
    2661             :         return Start;
    2662             :     }
    2663             : 
    2664             :   if (pc.days_seen && ! pc.dates_seen)
    2665             :     {
    2666             :       tm.tm_mday += ((pc.day_number - tm.tm_wday + 7) % 7
    2667             :                      + 7 * (pc.day_ordinal - (0 < pc.day_ordinal)));
    2668             :       tm.tm_isdst = -1;
    2669             :       Start = mktime (&tm);
    2670             :       if (Start == (time_t) -1)
    2671             :         return Start;
    2672             :     }
    2673             : 
    2674             :   if (pc.zones_seen)
    2675             :     {
    2676             :       int delta = pc.time_zone * 60;
    2677             : #ifdef HAVE_TM_GMTOFF
    2678             :       delta -= tm.tm_gmtoff;
    2679             : #else
    2680             :       struct tm *gmt = gmtime (&Start);
    2681             :       if (! gmt)
    2682             :         return -1;
    2683             :       delta -= tm_diff (&tm, gmt);
    2684             : #endif
    2685             :       if ((Start < Start - delta) != (delta < 0))
    2686             :         return -1;      /* time_t overflow */
    2687             :       Start -= delta;
    2688             :     }
    2689             : 
    2690             :   /* Add relative hours, minutes, and seconds.  Ignore leap seconds;
    2691             :      i.e. "+ 10 minutes" means 600 seconds, even if one of them is a
    2692             :      leap second.  Typically this is not what the user wants, but it's
    2693             :      too hard to do it the other way, because the time zone indicator
    2694             :      must be applied before relative times, and if mktime is applied
    2695             :      again the time zone will be lost.  */
    2696             :   {
    2697             :     time_t t0 = Start;
    2698             :     long d1 = 60 * 60 * (long) pc.rel_hour;
    2699             :     time_t t1 = t0 + d1;
    2700             :     long d2 = 60 * (long) pc.rel_minutes;
    2701             :     time_t t2 = t1 + d2;
    2702             :     int d3 = pc.rel_seconds;
    2703             :     time_t t3 = t2 + d3;
    2704             :     if ((d1 / (60 * 60) ^ pc.rel_hour)
    2705             :         | (d2 / 60 ^ pc.rel_minutes)
    2706             :         | ((t0 + d1 < t0) ^ (d1 < 0))
    2707             :         | ((t1 + d2 < t1) ^ (d2 < 0))
    2708             :         | ((t2 + d3 < t2) ^ (d3 < 0)))
    2709             :       return -1;
    2710             :     Start = t3;
    2711             :   }
    2712             : 
    2713             :   return Start;
    2714             : }
    2715             : 
    2716             : #if TEST
    2717             : 
    2718             : #include <stdio.h>
    2719             : 
    2720             : int
    2721             : main (int ac, char **av)
    2722             : {
    2723             :   char buff[BUFSIZ];
    2724             :   time_t d;
    2725             : 
    2726             :   printf ("Enter date, or blank line to exit.\n\t> ");
    2727             :   fflush (stdout);
    2728             : 
    2729             :   buff[BUFSIZ - 1] = 0;
    2730             :   while (fgets (buff, BUFSIZ - 1, stdin) && buff[0])
    2731             :     {
    2732             :       d = get_date (buff, 0);
    2733             :       if (d == (time_t) -1)
    2734             :         printf ("Bad format - couldn't convert.\n");
    2735             :       else
    2736             :         printf ("%s", ctime (&d));
    2737             :       printf ("\t> ");
    2738             :       fflush (stdout);
    2739             :     }
    2740             :   return 0;
    2741             : }
    2742             : #endif /* defined TEST */

Generated by: LCOV version 1.13