Merge branch 'mirbsd'
[alioth/cvs.git] / lib / getdate.c
1 /* A Bison parser, made by GNU Bison 2.3.  */
2
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
4
5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6    Free Software Foundation, Inc.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2, or (at your option)
11    any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
21    Boston, MA 02110-1301, USA.  */
22
23 /* As a special exception, you may create a larger work that contains
24    part or all of the Bison parser skeleton and distribute that work
25    under terms of your choice, so long as that work isn't itself a
26    parser generator using the skeleton or a modified version thereof
27    as a parser skeleton.  Alternatively, if you modify or redistribute
28    the parser skeleton itself, you may (at your option) remove this
29    special exception, which will cause the skeleton and the resulting
30    Bison output files to be licensed under the GNU General Public
31    License without this special exception.
32
33    This special exception was added by the Free Software Foundation in
34    version 2.2 of Bison.  */
35
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37    simplifying the original so-called "semantic" parser.  */
38
39 /* All symbols defined below should begin with yy or YY, to avoid
40    infringing on user name space.  This should be done even for local
41    variables, as they might otherwise be expanded by user macros.
42    There are some unavoidable exceptions within include files to
43    define necessary library symbols; they are noted "INFRINGES ON
44    USER NAME SPACE" below.  */
45
46 /* Identify Bison output.  */
47 #define YYBISON 1
48
49 /* Bison version.  */
50 #define YYBISON_VERSION "2.3"
51
52 /* Skeleton name.  */
53 #define YYSKELETON_NAME "yacc.c"
54
55 /* Pure parsers.  */
56 #define YYPURE 1
57
58 /* Using locations.  */
59 #define YYLSP_NEEDED 0
60
61
62
63 /* Tokens.  */
64 #ifndef YYTOKENTYPE
65 # define YYTOKENTYPE
66    /* Put the tokens into the symbol table, so that GDB and other debuggers
67       know about them.  */
68    enum yytokentype {
69      tAGO = 258,
70      tDST = 259,
71      tDAY = 260,
72      tDAY_UNIT = 261,
73      tDAYZONE = 262,
74      tHOUR_UNIT = 263,
75      tLOCAL_ZONE = 264,
76      tMERIDIAN = 265,
77      tMINUTE_UNIT = 266,
78      tMONTH = 267,
79      tMONTH_UNIT = 268,
80      tORDINAL = 269,
81      tSEC_UNIT = 270,
82      tYEAR_UNIT = 271,
83      tZONE = 272,
84      tSNUMBER = 273,
85      tUNUMBER = 274,
86      tSDECIMAL_NUMBER = 275,
87      tUDECIMAL_NUMBER = 276
88    };
89 #endif
90 /* Tokens.  */
91 #define tAGO 258
92 #define tDST 259
93 #define tDAY 260
94 #define tDAY_UNIT 261
95 #define tDAYZONE 262
96 #define tHOUR_UNIT 263
97 #define tLOCAL_ZONE 264
98 #define tMERIDIAN 265
99 #define tMINUTE_UNIT 266
100 #define tMONTH 267
101 #define tMONTH_UNIT 268
102 #define tORDINAL 269
103 #define tSEC_UNIT 270
104 #define tYEAR_UNIT 271
105 #define tZONE 272
106 #define tSNUMBER 273
107 #define tUNUMBER 274
108 #define tSDECIMAL_NUMBER 275
109 #define tUDECIMAL_NUMBER 276
110
111
112
113
114 /* Copy the first part of user declarations.  */
115 #line 1 "getdate.y"
116
117 /* Parse a string into an internal time stamp.
118
119    Copyright (C) 1995, 1997, 1998, 2003, 2004, 2005
120    Free Software Foundation, Inc.
121
122    Copyright (c) 2005, 2006, 2007, 2010, 2016
123    mirabilos <m@mirbsd.org>
124
125    This program is free software; you can redistribute it and/or modify
126    it under the terms of the GNU General Public License as published by
127    the Free Software Foundation; either version 2, or (at your option)
128    any later version.
129
130    This program is distributed in the hope that it will be useful,
131    but WITHOUT ANY WARRANTY; without even the implied warranty of
132    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
133    GNU General Public License for more details.
134
135    You should have received a copy of the GNU General Public License
136    along with this program; if not, write to the Free Software Foundation,
137    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
138
139 /* Originally written by Steven M. Bellovin <smb@research.att.com> while
140    at the University of North Carolina at Chapel Hill.  Later tweaked by
141    a couple of people on Usenet.  Completely overhauled by Rich $alz
142    <rsalz@bbn.com> and Jim Berets <jberets@bbn.com> in August, 1990.
143
144    Modified by Paul Eggert <eggert@twinsun.com> in August 1999 to do
145    the right thing about local DST.  Also modified by Paul Eggert
146    <eggert@cs.ucla.edu> in February 2004 to support
147    nanosecond-resolution time stamps, and in October 2004 to support
148    TZ strings in dates.  */
149
150 /* FIXME: Check for arithmetic overflow in all cases, not just
151    some of them.  */
152
153 #ifdef HAVE_CONFIG_H
154 # include <config.h>
155 #endif
156
157 #include "getdate.h"
158
159 #ifdef USE_LIBBSD
160 size_t strlcat(char *, const char *, size_t);
161 #endif
162
163 /* There's no need to extend the stack, so there's no need to involve
164    alloca.  */
165 #define YYSTACK_USE_ALLOCA 0
166
167 /* Tell Bison how much stack space is needed.  20 should be plenty for
168    this grammar, which is not right recursive.  Beware setting it too
169    high, since that might cause problems on machines whose
170    implementations have lame stack-overflow checking.  */
171 #define YYMAXDEPTH 20
172 #define YYINITDEPTH YYMAXDEPTH
173
174 /* Since the code of getdate.y is not included in the Emacs executable
175    itself, there is no need to #define static in this file.  Even if
176    the code were included in the Emacs executable, it probably
177    wouldn't do any harm to #undef it here; this will only cause
178    problems if we try to write to a static variable, which I don't
179    think this code needs to do.  */
180 #ifdef emacs
181 # undef static
182 #endif
183
184 #include <ctype.h>
185 #include <limits.h>
186 #include <stdio.h>
187 #include <stdlib.h>
188 #include <string.h>
189
190 #ifndef _STDLIB_H
191 #define _STDLIB_H 1 /* GNU bison needs this */
192 #endif
193
194 #ifndef IN_RCS
195 #include "setenv.h"
196 #include "xalloc.h"
197 #else /* IN_RCS */
198 #include <unistd.h>
199
200 #define HAVE_STRUCT_TM_TM_ZONE 1
201 #define HAVE_TM_GMTOFF  1
202
203 #define gettime(ts)     clock_gettime(CLOCK_REALTIME,(ts))
204
205 static void *
206 xmalloc(size_t s)
207 {
208         static const char xmalloc_enomem[] = "memory exhausted\n";
209         void *x;
210
211         if ((x = malloc(s)) == NULL) {
212                 write(2, xmalloc_enomem, sizeof(xmalloc_enomem) - 1);
213                 exit(1);
214         }
215
216         return (x);
217 }
218
219 static void *
220 xmemdup(void const *p, size_t s)
221 {
222         return (memcpy(xmalloc(s), p, s));
223 }
224 #endif /* IN_RCS */
225
226 #if (defined(STDC_HEADERS) && STDC_HEADERS) || \
227     (!defined(isascii) && !HAVE_ISASCII)
228 # define IN_CTYPE_DOMAIN(c) 1
229 #else
230 # define IN_CTYPE_DOMAIN(c) isascii (c)
231 #endif
232
233 #define ISSPACE(c) (IN_CTYPE_DOMAIN (c) && isspace (c))
234 #define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha (c))
235 #define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower (c))
236
237 /* ISDIGIT differs from isdigit, as follows:
238    - Its arg may be any int or unsigned int; it need not be an unsigned char.
239    - It's guaranteed to evaluate its argument exactly once.
240    - It's typically faster.
241    POSIX says that only '0' through '9' are digits.  Prefer ISDIGIT to
242    isdigit unless it's important to use the locale's definition
243    of `digit' even when the host does not conform to POSIX.  */
244 #define ISDIGIT(c) ((unsigned int) (c) - '0' <= 9)
245
246 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8) || \
247     (defined(__STRICT_ANSI__) && __STRICT_ANSI__)
248 # define __attribute__(x)
249 #endif
250
251 #ifndef ATTRIBUTE_UNUSED
252 # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
253 #endif
254
255 #ifndef __IDSTRING
256 #define __IDSTRING(varname, string) \
257         static const char varname[] __attribute__((__used__)) = \
258             "@(""#)" #varname ": " string
259 #endif
260
261 __IDSTRING(rcsid_code, "$MirOS: src/gnu/usr.bin/cvs/lib/getdate.c,v 1.17 2016/10/22 22:46:51 tg Exp $");
262 __IDSTRING(rcsid_bron, "$miros: src/gnu/usr.bin/cvs/lib/getdate.y,v 1.11 2016/10/22 22:45:50 tg Exp $");
263
264 /* Shift A right by B bits portably, by dividing A by 2**B and
265    truncating towards minus infinity.  A and B should be free of side
266    effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
267    INT_BITS is the number of useful bits in an int.  GNU code can
268    assume that INT_BITS is at least 32.
269
270    ISO C99 says that A >> B is implementation-defined if A < 0.  Some
271    implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
272    right in the usual way when A < 0, so SHR falls back on division if
273    ordinary A >> B doesn't seem to be the usual signed shift.  */
274 #define SHR(a, b)       \
275   (-1 >> 1 == -1        \
276    ? (a) >> (b)         \
277    : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
278
279 #define EPOCH_YEAR 1970
280 #define TM_YEAR_BASE 1900
281
282 #define HOUR(x) ((x) * 60)
283
284 /* An integer value, and the number of digits in its textual
285    representation.  */
286 typedef struct
287 {
288   bool negative;
289   long int value;
290   size_t digits;
291 } textint;
292
293 /* An entry in the lexical lookup table.  */
294 typedef struct
295 {
296   char const *name;
297   int type;
298   int value;
299 } table;
300
301 /* Meridian: am, pm, or 24-hour style.  */
302 enum { MERam, MERpm, MER24 };
303
304 enum { BILLION = 1000000000, LOG10_BILLION = 9 };
305
306 /* Information passed to and from the parser.  */
307 typedef struct
308 {
309   /* The input string remaining to be parsed. */
310   const char *input;
311
312   /* N, if this is the Nth Tuesday.  */
313   long int day_ordinal;
314
315   /* Day of week; Sunday is 0.  */
316   int day_number;
317
318   /* tm_isdst flag for the local zone.  */
319   int local_isdst;
320
321   /* Time zone, in minutes east of UTC.  */
322   long int time_zone;
323
324   /* Style used for time.  */
325   int meridian;
326
327   /* Gregorian year, month, day, hour, minutes, seconds, and nanoseconds.  */
328   textint year;
329   long int month;
330   long int day;
331   long int hour;
332   long int minutes;
333   struct timespec seconds; /* includes nanoseconds */
334
335   /* Relative year, month, day, hour, minutes, seconds, and nanoseconds.  */
336   long int rel_year;
337   long int rel_month;
338   long int rel_day;
339   long int rel_hour;
340   long int rel_minutes;
341   long int rel_seconds;
342   long int rel_ns;
343
344   /* Presence or counts of nonterminals of various flavors parsed so far.  */
345   bool timespec_seen;
346   bool rels_seen;
347   size_t dates_seen;
348   size_t days_seen;
349   size_t local_zones_seen;
350   size_t dsts_seen;
351   size_t times_seen;
352   size_t zones_seen;
353
354   /* Table of local time zone abbrevations, terminated by a null entry.  */
355   table local_time_zone_table[3];
356 } parser_control;
357
358 union YYSTYPE;
359 static int yylex (union YYSTYPE *, parser_control *);
360 static int yyerror (parser_control *, const char *);
361 static long int time_zone_hhmm (textint, long int);
362
363
364
365 /* Enabling traces.  */
366 #ifndef YYDEBUG
367 # define YYDEBUG 0
368 #endif
369
370 /* Enabling verbose error messages.  */
371 #ifdef YYERROR_VERBOSE
372 # undef YYERROR_VERBOSE
373 # define YYERROR_VERBOSE 1
374 #else
375 # define YYERROR_VERBOSE 0
376 #endif
377
378 /* Enabling the token table.  */
379 #ifndef YYTOKEN_TABLE
380 # define YYTOKEN_TABLE 0
381 #endif
382
383 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
384 typedef union YYSTYPE
385 #line 260 "getdate.y"
386 {
387   long int intval;
388   textint textintval;
389   struct timespec timespec;
390 }
391 /* Line 193 of yacc.c.  */
392 #line 393 "getdate.c"
393         YYSTYPE;
394 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
395 # define YYSTYPE_IS_DECLARED 1
396 # define YYSTYPE_IS_TRIVIAL 1
397 #endif
398
399
400
401 /* Copy the second part of user declarations.  */
402
403
404 /* Line 216 of yacc.c.  */
405 #line 406 "getdate.c"
406
407 #ifdef short
408 # undef short
409 #endif
410
411 #ifdef YYTYPE_UINT8
412 typedef YYTYPE_UINT8 yytype_uint8;
413 #else
414 typedef unsigned char yytype_uint8;
415 #endif
416
417 #ifdef YYTYPE_INT8
418 typedef YYTYPE_INT8 yytype_int8;
419 #elif (defined __STDC__ || defined __C99__FUNC__ \
420      || defined __cplusplus || defined _MSC_VER)
421 typedef signed char yytype_int8;
422 #else
423 typedef short int yytype_int8;
424 #endif
425
426 #ifdef YYTYPE_UINT16
427 typedef YYTYPE_UINT16 yytype_uint16;
428 #else
429 typedef unsigned short int yytype_uint16;
430 #endif
431
432 #ifdef YYTYPE_INT16
433 typedef YYTYPE_INT16 yytype_int16;
434 #else
435 typedef short int yytype_int16;
436 #endif
437
438 #ifndef YYSIZE_T
439 # ifdef __SIZE_TYPE__
440 #  define YYSIZE_T __SIZE_TYPE__
441 # elif defined size_t
442 #  define YYSIZE_T size_t
443 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
444      || defined __cplusplus || defined _MSC_VER)
445 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
446 #  define YYSIZE_T size_t
447 # else
448 #  define YYSIZE_T unsigned int
449 # endif
450 #endif
451
452 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
453
454 #ifndef YY_
455 # if defined(YYENABLE_NLS) && YYENABLE_NLS
456 #  if ENABLE_NLS
457 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
458 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
459 #  endif
460 # endif
461 # ifndef YY_
462 #  define YY_(msgid) msgid
463 # endif
464 #endif
465
466 /* Suppress unused-variable warnings by "using" E.  */
467 #if ! defined lint || defined __GNUC__
468 # define YYUSE(e) ((void) (e))
469 #else
470 # define YYUSE(e) /* empty */
471 #endif
472
473 /* Identity function, used to suppress warnings about constant conditions.  */
474 #ifndef lint
475 # define YYID(n) (n)
476 #else
477 #if (defined __STDC__ || defined __C99__FUNC__ \
478      || defined __cplusplus || defined _MSC_VER)
479 static int
480 YYID (int i)
481 #else
482 static int
483 YYID (i)
484     int i;
485 #endif
486 {
487   return i;
488 }
489 #endif
490
491 #if ! defined yyoverflow || YYERROR_VERBOSE
492
493 /* The parser invokes alloca or malloc; define the necessary symbols.  */
494
495 # ifdef YYSTACK_USE_ALLOCA
496 #  if YYSTACK_USE_ALLOCA
497 #   ifdef __GNUC__
498 #    define YYSTACK_ALLOC __builtin_alloca
499 #   elif defined __BUILTIN_VA_ARG_INCR
500 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
501 #   elif defined _AIX
502 #    define YYSTACK_ALLOC __alloca
503 #   elif defined _MSC_VER
504 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
505 #    define alloca _alloca
506 #   else
507 #    define YYSTACK_ALLOC alloca
508 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
509      || defined __cplusplus || defined _MSC_VER)
510 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
511 #     ifndef _STDLIB_H
512 #      define _STDLIB_H 1
513 #     endif
514 #    endif
515 #   endif
516 #  endif
517 # endif
518
519 # ifdef YYSTACK_ALLOC
520    /* Pacify GCC's `empty if-body' warning.  */
521 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
522 #  ifndef YYSTACK_ALLOC_MAXIMUM
523     /* The OS might guarantee only one guard page at the bottom of the stack,
524        and a page size can be as small as 4096 bytes.  So we cannot safely
525        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
526        to allow for a few compiler-allocated temporary stack slots.  */
527 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
528 #  endif
529 # else
530 #  define YYSTACK_ALLOC YYMALLOC
531 #  define YYSTACK_FREE YYFREE
532 #  ifndef YYSTACK_ALLOC_MAXIMUM
533 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
534 #  endif
535 #  if (defined __cplusplus && ! defined _STDLIB_H \
536        && ! ((defined YYMALLOC || defined malloc) \
537              && (defined YYFREE || defined free)))
538 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
539 #   ifndef _STDLIB_H
540 #    define _STDLIB_H 1
541 #   endif
542 #  endif
543 #  ifndef YYMALLOC
544 #   define YYMALLOC malloc
545 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
546      || defined __cplusplus || defined _MSC_VER)
547 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
548 #   endif
549 #  endif
550 #  ifndef YYFREE
551 #   define YYFREE free
552 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
553      || defined __cplusplus || defined _MSC_VER)
554 void free (void *); /* INFRINGES ON USER NAME SPACE */
555 #   endif
556 #  endif
557 # endif
558 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
559
560
561 #if (! defined yyoverflow \
562      && (! defined __cplusplus \
563          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
564
565 /* A type that is properly aligned for any stack member.  */
566 union yyalloc
567 {
568   yytype_int16 yyss;
569   YYSTYPE yyvs;
570   };
571
572 /* The size of the maximum gap between one aligned stack and the next.  */
573 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
574
575 /* The size of an array large to enough to hold all stacks, each with
576    N elements.  */
577 # define YYSTACK_BYTES(N) \
578      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
579       + YYSTACK_GAP_MAXIMUM)
580
581 /* Copy COUNT objects from FROM to TO.  The source and destination do
582    not overlap.  */
583 # ifndef YYCOPY
584 #  if defined __GNUC__ && 1 < __GNUC__
585 #   define YYCOPY(To, From, Count) \
586       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
587 #  else
588 #   define YYCOPY(To, From, Count)              \
589       do                                        \
590         {                                       \
591           YYSIZE_T yyi;                         \
592           for (yyi = 0; yyi < (Count); yyi++)   \
593             (To)[yyi] = (From)[yyi];            \
594         }                                       \
595       while (YYID (0))
596 #  endif
597 # endif
598
599 /* Relocate STACK from its old location to the new one.  The
600    local variables YYSIZE and YYSTACKSIZE give the old and new number of
601    elements in the stack, and YYPTR gives the new location of the
602    stack.  Advance YYPTR to a properly aligned location for the next
603    stack.  */
604 # define YYSTACK_RELOCATE(Stack)                                        \
605     do                                                                  \
606       {                                                                 \
607         YYSIZE_T yynewbytes;                                            \
608         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
609         Stack = &yyptr->Stack;                                          \
610         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
611         yyptr += yynewbytes / sizeof (*yyptr);                          \
612       }                                                                 \
613     while (YYID (0))
614
615 #endif
616
617 /* YYFINAL -- State number of the termination state.  */
618 #define YYFINAL  12
619 /* YYLAST -- Last index in YYTABLE.  */
620 #define YYLAST   88
621
622 /* YYNTOKENS -- Number of terminals.  */
623 #define YYNTOKENS  26
624 /* YYNNTS -- Number of nonterminals.  */
625 #define YYNNTS  19
626 /* YYNRULES -- Number of rules.  */
627 #define YYNRULES  78
628 /* YYNRULES -- Number of states.  */
629 #define YYNSTATES  96
630
631 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
632 #define YYUNDEFTOK  2
633 #define YYMAXUTOK   276
634
635 #define YYTRANSLATE(YYX)                                                \
636   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
637
638 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
639 static const yytype_uint8 yytranslate[] =
640 {
641        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
642        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
643        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
644        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
645        2,     2,     2,     2,    24,     2,     2,    25,     2,     2,
646        2,     2,     2,     2,     2,     2,     2,     2,    23,     2,
647        2,     2,     2,     2,    22,     2,     2,     2,     2,     2,
648        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
649        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
650        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
651        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
652        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
653        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
654        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
655        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
656        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
657        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
658        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
659        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
660        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
661        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
662        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
663        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
664        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
665        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
666        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
667        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
668       15,    16,    17,    18,    19,    20,    21
669 };
670
671 #if YYDEBUG
672 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
673    YYRHS.  */
674 static const yytype_uint8 yyprhs[] =
675 {
676        0,     0,     3,     5,     7,    10,    11,    14,    16,    18,
677       20,    22,    24,    26,    28,    31,    36,    42,    49,    57,
678       59,    62,    64,    67,    71,    73,    76,    78,    81,    84,
679       87,    91,    97,   101,   105,   109,   112,   117,   120,   124,
680      127,   129,   132,   135,   137,   140,   143,   145,   148,   151,
681      153,   156,   159,   161,   164,   167,   169,   172,   175,   178,
682      181,   183,   185,   188,   191,   194,   197,   200,   203,   205,
683      207,   209,   211,   213,   215,   217,   218,   221,   222
684 };
685
686 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
687 static const yytype_int8 yyrhs[] =
688 {
689       27,     0,    -1,    28,    -1,    29,    -1,    22,    39,    -1,
690       -1,    29,    30,    -1,    31,    -1,    32,    -1,    33,    -1,
691       35,    -1,    34,    -1,    36,    -1,    42,    -1,    19,    10,
692       -1,    19,    23,    19,    44,    -1,    19,    23,    19,    18,
693       43,    -1,    19,    23,    19,    23,    41,    44,    -1,    19,
694       23,    19,    23,    41,    18,    43,    -1,     9,    -1,     9,
695        4,    -1,    17,    -1,    17,    38,    -1,    17,    18,    43,
696       -1,     7,    -1,    17,     4,    -1,     5,    -1,     5,    24,
697       -1,    14,     5,    -1,    19,     5,    -1,    19,    25,    19,
698       -1,    19,    25,    19,    25,    19,    -1,    19,    18,    18,
699       -1,    19,    12,    18,    -1,    12,    18,    18,    -1,    12,
700       19,    -1,    12,    19,    24,    19,    -1,    19,    12,    -1,
701       19,    12,    19,    -1,    37,     3,    -1,    37,    -1,    14,
702       16,    -1,    19,    16,    -1,    16,    -1,    14,    13,    -1,
703       19,    13,    -1,    13,    -1,    14,     6,    -1,    19,     6,
704       -1,     6,    -1,    14,     8,    -1,    19,     8,    -1,     8,
705       -1,    14,    11,    -1,    19,    11,    -1,    11,    -1,    14,
706       15,    -1,    19,    15,    -1,    20,    15,    -1,    21,    15,
707       -1,    15,    -1,    38,    -1,    18,    16,    -1,    18,    13,
708       -1,    18,     6,    -1,    18,     8,    -1,    18,    11,    -1,
709       18,    15,    -1,    40,    -1,    41,    -1,    20,    -1,    18,
710       -1,    21,    -1,    19,    -1,    19,    -1,    -1,    23,    19,
711       -1,    -1,    10,    -1
712 };
713
714 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
715 static const yytype_uint16 yyrline[] =
716 {
717        0,   281,   281,   282,   286,   293,   295,   299,   301,   303,
718      305,   307,   309,   311,   315,   323,   331,   341,   348,   360,
719      365,   373,   375,   377,   379,   381,   386,   391,   396,   401,
720      409,   414,   434,   441,   449,   457,   462,   468,   473,   482,
721      492,   496,   498,   500,   502,   504,   506,   508,   510,   512,
722      514,   516,   518,   520,   522,   524,   526,   528,   530,   532,
723      534,   536,   540,   542,   544,   546,   548,   550,   554,   554,
724      557,   558,   563,   564,   569,   607,   608,   614,   615
725 };
726 #endif
727
728 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
729 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
730    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
731 static const char *const yytname[] =
732 {
733   "$end", "error", "$undefined", "tAGO", "tDST", "tDAY", "tDAY_UNIT",
734   "tDAYZONE", "tHOUR_UNIT", "tLOCAL_ZONE", "tMERIDIAN", "tMINUTE_UNIT",
735   "tMONTH", "tMONTH_UNIT", "tORDINAL", "tSEC_UNIT", "tYEAR_UNIT", "tZONE",
736   "tSNUMBER", "tUNUMBER", "tSDECIMAL_NUMBER", "tUDECIMAL_NUMBER", "'@'",
737   "':'", "','", "'/'", "$accept", "spec", "timespec", "items", "item",
738   "time", "local_zone", "zone", "day", "date", "rel", "relunit",
739   "relunit_snumber", "seconds", "signed_seconds", "unsigned_seconds",
740   "number", "o_colon_minutes", "o_merid", 0
741 };
742 #endif
743
744 # ifdef YYPRINT
745 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
746    token YYLEX-NUM.  */
747 static const yytype_uint16 yytoknum[] =
748 {
749        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
750      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
751      275,   276,    64,    58,    44,    47
752 };
753 # endif
754
755 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
756 static const yytype_uint8 yyr1[] =
757 {
758        0,    26,    27,    27,    28,    29,    29,    30,    30,    30,
759       30,    30,    30,    30,    31,    31,    31,    31,    31,    32,
760       32,    33,    33,    33,    33,    33,    34,    34,    34,    34,
761       35,    35,    35,    35,    35,    35,    35,    35,    35,    36,
762       36,    37,    37,    37,    37,    37,    37,    37,    37,    37,
763       37,    37,    37,    37,    37,    37,    37,    37,    37,    37,
764       37,    37,    38,    38,    38,    38,    38,    38,    39,    39,
765       40,    40,    41,    41,    42,    43,    43,    44,    44
766 };
767
768 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
769 static const yytype_uint8 yyr2[] =
770 {
771        0,     2,     1,     1,     2,     0,     2,     1,     1,     1,
772        1,     1,     1,     1,     2,     4,     5,     6,     7,     1,
773        2,     1,     2,     3,     1,     2,     1,     2,     2,     2,
774        3,     5,     3,     3,     3,     2,     4,     2,     3,     2,
775        1,     2,     2,     1,     2,     2,     1,     2,     2,     1,
776        2,     2,     1,     2,     2,     1,     2,     2,     2,     2,
777        1,     1,     2,     2,     2,     2,     2,     2,     1,     1,
778        1,     1,     1,     1,     1,     0,     2,     0,     1
779 };
780
781 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
782    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
783    means the default is an error.  */
784 static const yytype_uint8 yydefact[] =
785 {
786        5,     0,     0,     2,     3,    71,    73,    70,    72,     4,
787       68,    69,     1,    26,    49,    24,    52,    19,    55,     0,
788       46,     0,    60,    43,    21,     0,    74,     0,     0,     6,
789        7,     8,     9,    11,    10,    12,    40,    61,    13,    27,
790       20,     0,    35,    28,    47,    50,    53,    44,    56,    41,
791       25,    75,    22,    64,    65,    66,    63,    67,    62,    29,
792       48,    51,    14,    54,    37,    45,    57,    42,     0,     0,
793        0,    58,    59,    39,    34,     0,     0,    23,    33,    38,
794       32,    77,    30,    36,    76,    78,    75,     0,    15,     0,
795       16,    77,    31,    75,    17,    18
796 };
797
798 /* YYDEFGOTO[NTERM-NUM].  */
799 static const yytype_int8 yydefgoto[] =
800 {
801       -1,     2,     3,     4,    29,    30,    31,    32,    33,    34,
802       35,    36,    37,     9,    10,    11,    38,    77,    88
803 };
804
805 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
806    STATE-NUM.  */
807 #define YYPACT_NINF -43
808 static const yytype_int8 yypact[] =
809 {
810      -18,    48,     9,   -43,    19,   -43,   -43,   -43,   -43,   -43,
811      -43,   -43,   -43,    32,   -43,   -43,   -43,    54,   -43,    28,
812      -43,    37,   -43,   -43,    -2,    49,    -5,    57,    58,   -43,
813      -43,   -43,   -43,   -43,   -43,   -43,    60,   -43,   -43,   -43,
814      -43,    56,    51,   -43,   -43,   -43,   -43,   -43,   -43,   -43,
815      -43,     6,   -43,   -43,   -43,   -43,   -43,   -43,   -43,   -43,
816      -43,   -43,   -43,   -43,    52,   -43,   -43,   -43,    59,    61,
817       62,   -43,   -43,   -43,   -43,    63,    64,   -43,   -43,   -43,
818      -43,    31,    53,   -43,   -43,   -43,    65,    40,   -43,    66,
819      -43,     5,   -43,    65,   -43,   -43
820 };
821
822 /* YYPGOTO[NTERM-NUM].  */
823 static const yytype_int8 yypgoto[] =
824 {
825      -43,   -43,   -43,   -43,   -43,   -43,   -43,   -43,   -43,   -43,
826      -43,   -43,    55,   -43,   -43,   -11,   -43,   -42,    -7
827 };
828
829 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
830    positive, shift that token.  If negative, reduce the rule which
831    number is the opposite.  If zero, do what YYDEFACT says.
832    If YYTABLE_NINF, syntax error.  */
833 #define YYTABLE_NINF -1
834 static const yytype_uint8 yytable[] =
835 {
836       59,    60,    50,    61,     1,    62,    63,    64,    65,    12,
837       66,    67,    53,    68,    54,    85,    51,    55,    69,    56,
838       70,    57,    58,    93,    13,    14,    15,    16,    17,    76,
839       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
840       28,    85,    43,    44,    90,    45,    41,    42,    46,    86,
841       47,    95,    48,    49,    87,    53,    39,    54,    40,     6,
842       55,     8,    56,    73,    57,    58,     5,     6,     7,     8,
843       78,    79,    71,    72,    74,    75,    91,    80,    89,    52,
844       81,    82,    83,    84,    94,    92,     0,     0,    76
845 };
846
847 static const yytype_int8 yycheck[] =
848 {
849        5,     6,     4,     8,    22,    10,    11,    12,    13,     0,
850       15,    16,     6,    18,     8,    10,    18,    11,    23,    13,
851       25,    15,    16,    18,     5,     6,     7,     8,     9,    23,
852       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
853       21,    10,     5,     6,    86,     8,    18,    19,    11,    18,
854       13,    93,    15,    16,    23,     6,    24,     8,     4,    19,
855       11,    21,    13,     3,    15,    16,    18,    19,    20,    21,
856       18,    19,    15,    15,    18,    24,    87,    18,    25,    24,
857       19,    19,    19,    19,    91,    19,    -1,    -1,    23
858 };
859
860 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
861    symbol of state STATE-NUM.  */
862 static const yytype_uint8 yystos[] =
863 {
864        0,    22,    27,    28,    29,    18,    19,    20,    21,    39,
865       40,    41,     0,     5,     6,     7,     8,     9,    11,    12,
866       13,    14,    15,    16,    17,    18,    19,    20,    21,    30,
867       31,    32,    33,    34,    35,    36,    37,    38,    42,    24,
868        4,    18,    19,     5,     6,     8,    11,    13,    15,    16,
869        4,    18,    38,     6,     8,    11,    13,    15,    16,     5,
870        6,     8,    10,    11,    12,    13,    15,    16,    18,    23,
871       25,    15,    15,     3,    18,    24,    23,    43,    18,    19,
872       18,    19,    19,    19,    19,    10,    18,    23,    44,    25,
873       43,    41,    19,    18,    44,    43
874 };
875
876 #define yyerrok         (yyerrstatus = 0)
877 #define yyclearin       (yychar = YYEMPTY)
878 #define YYEMPTY         (-2)
879 #define YYEOF           0
880
881 #define YYACCEPT        goto yyacceptlab
882 #define YYABORT         goto yyabortlab
883 #define YYERROR         goto yyerrorlab
884
885
886 /* Like YYERROR except do call yyerror.  This remains here temporarily
887    to ease the transition to the new meaning of YYERROR, for GCC.
888    Once GCC version 2 has supplanted version 1, this can go.  */
889
890 #define YYFAIL          goto yyerrlab
891
892 #define YYRECOVERING()  (!!yyerrstatus)
893
894 #define YYBACKUP(Token, Value)                                  \
895 do                                                              \
896   if (yychar == YYEMPTY && yylen == 1)                          \
897     {                                                           \
898       yychar = (Token);                                         \
899       yylval = (Value);                                         \
900       yytoken = YYTRANSLATE (yychar);                           \
901       YYPOPSTACK (1);                                           \
902       goto yybackup;                                            \
903     }                                                           \
904   else                                                          \
905     {                                                           \
906       yyerror (pc, YY_("syntax error: cannot back up")); \
907       YYERROR;                                                  \
908     }                                                           \
909 while (YYID (0))
910
911
912 #define YYTERROR        1
913 #define YYERRCODE       256
914
915
916 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
917    If N is 0, then set CURRENT to the empty location which ends
918    the previous symbol: RHS[0] (always defined).  */
919
920 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
921 #ifndef YYLLOC_DEFAULT
922 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
923     do                                                                  \
924       if (YYID (N))                                                    \
925         {                                                               \
926           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
927           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
928           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
929           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
930         }                                                               \
931       else                                                              \
932         {                                                               \
933           (Current).first_line   = (Current).last_line   =              \
934             YYRHSLOC (Rhs, 0).last_line;                                \
935           (Current).first_column = (Current).last_column =              \
936             YYRHSLOC (Rhs, 0).last_column;                              \
937         }                                                               \
938     while (YYID (0))
939 #endif
940
941
942 /* YY_LOCATION_PRINT -- Print the location on the stream.
943    This macro was not mandated originally: define only if we know
944    we won't break user code: when these are the locations we know.  */
945
946 #ifndef YY_LOCATION_PRINT
947 # if defined(YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL
948 #  define YY_LOCATION_PRINT(File, Loc)                  \
949      fprintf (File, "%d.%d-%d.%d",                      \
950               (Loc).first_line, (Loc).first_column,     \
951               (Loc).last_line,  (Loc).last_column)
952 # else
953 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
954 # endif
955 #endif
956
957
958 /* YYLEX -- calling `yylex' with the right arguments.  */
959
960 #ifdef YYLEX_PARAM
961 # define YYLEX yylex (&yylval, YYLEX_PARAM)
962 #else
963 # define YYLEX yylex (&yylval, pc)
964 #endif
965
966 /* Enable debugging if requested.  */
967 #if YYDEBUG
968
969 # ifndef YYFPRINTF
970 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
971 #  define YYFPRINTF fprintf
972 # endif
973
974 # define YYDPRINTF(Args)                        \
975 do {                                            \
976   if (yydebug)                                  \
977     YYFPRINTF Args;                             \
978 } while (YYID (0))
979
980 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
981 do {                                                                      \
982   if (yydebug)                                                            \
983     {                                                                     \
984       YYFPRINTF (stderr, "%s ", Title);                                   \
985       yy_symbol_print (stderr,                                            \
986                   Type, Value, pc); \
987       YYFPRINTF (stderr, "\n");                                           \
988     }                                                                     \
989 } while (YYID (0))
990
991
992 /*--------------------------------.
993 | Print this symbol on YYOUTPUT.  |
994 `--------------------------------*/
995
996 /*ARGSUSED*/
997 #if (defined __STDC__ || defined __C99__FUNC__ \
998      || defined __cplusplus || defined _MSC_VER)
999 static void
1000 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_control *pc)
1001 #else
1002 static void
1003 yy_symbol_value_print (yyoutput, yytype, yyvaluep, pc)
1004     FILE *yyoutput;
1005     int yytype;
1006     YYSTYPE const * const yyvaluep;
1007     parser_control *pc;
1008 #endif
1009 {
1010   if (!yyvaluep)
1011     return;
1012   YYUSE (pc);
1013 # ifdef YYPRINT
1014   if (yytype < YYNTOKENS)
1015     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1016 # else
1017   YYUSE (yyoutput);
1018 # endif
1019   switch (yytype)
1020     {
1021       default:
1022         break;
1023     }
1024 }
1025
1026
1027 /*--------------------------------.
1028 | Print this symbol on YYOUTPUT.  |
1029 `--------------------------------*/
1030
1031 #if (defined __STDC__ || defined __C99__FUNC__ \
1032      || defined __cplusplus || defined _MSC_VER)
1033 static void
1034 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, parser_control *pc)
1035 #else
1036 static void
1037 yy_symbol_print (yyoutput, yytype, yyvaluep, pc)
1038     FILE *yyoutput;
1039     int yytype;
1040     YYSTYPE const * const yyvaluep;
1041     parser_control *pc;
1042 #endif
1043 {
1044   if (yytype < YYNTOKENS)
1045     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1046   else
1047     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1048
1049   yy_symbol_value_print (yyoutput, yytype, yyvaluep, pc);
1050   YYFPRINTF (yyoutput, ")");
1051 }
1052
1053 /*------------------------------------------------------------------.
1054 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1055 | TOP (included).                                                   |
1056 `------------------------------------------------------------------*/
1057
1058 #if (defined __STDC__ || defined __C99__FUNC__ \
1059      || defined __cplusplus || defined _MSC_VER)
1060 static void
1061 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1062 #else
1063 static void
1064 yy_stack_print (bottom, top)
1065     yytype_int16 *bottom;
1066     yytype_int16 *top;
1067 #endif
1068 {
1069   YYFPRINTF (stderr, "Stack now");
1070   for (; bottom <= top; ++bottom)
1071     YYFPRINTF (stderr, " %d", *bottom);
1072   YYFPRINTF (stderr, "\n");
1073 }
1074
1075 # define YY_STACK_PRINT(Bottom, Top)                            \
1076 do {                                                            \
1077   if (yydebug)                                                  \
1078     yy_stack_print ((Bottom), (Top));                           \
1079 } while (YYID (0))
1080
1081
1082 /*------------------------------------------------.
1083 | Report that the YYRULE is going to be reduced.  |
1084 `------------------------------------------------*/
1085
1086 #if (defined __STDC__ || defined __C99__FUNC__ \
1087      || defined __cplusplus || defined _MSC_VER)
1088 static void
1089 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, parser_control *pc)
1090 #else
1091 static void
1092 yy_reduce_print (yyvsp, yyrule, pc)
1093     YYSTYPE *yyvsp;
1094     int yyrule;
1095     parser_control *pc;
1096 #endif
1097 {
1098   int yynrhs = yyr2[yyrule];
1099   int yyi;
1100   unsigned long int yylno = yyrline[yyrule];
1101   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1102              yyrule - 1, yylno);
1103   /* The symbols being reduced.  */
1104   for (yyi = 0; yyi < yynrhs; yyi++)
1105     {
1106       fprintf (stderr, "   $%d = ", yyi + 1);
1107       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1108                        &(yyvsp[(yyi + 1) - (yynrhs)])
1109                                        , pc);
1110       fprintf (stderr, "\n");
1111     }
1112 }
1113
1114 # define YY_REDUCE_PRINT(Rule)          \
1115 do {                                    \
1116   if (yydebug)                          \
1117     yy_reduce_print (yyvsp, Rule, pc); \
1118 } while (YYID (0))
1119
1120 /* Nonzero means print parse trace.  It is left uninitialized so that
1121    multiple parsers can coexist.  */
1122 int yydebug;
1123 #else /* !YYDEBUG */
1124 # define YYDPRINTF(Args)
1125 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1126 # define YY_STACK_PRINT(Bottom, Top)
1127 # define YY_REDUCE_PRINT(Rule)
1128 #endif /* !YYDEBUG */
1129
1130
1131 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1132 #ifndef YYINITDEPTH
1133 # define YYINITDEPTH 200
1134 #endif
1135
1136 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1137    if the built-in stack extension method is used).
1138
1139    Do not make this value too large; the results are undefined if
1140    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1141    evaluated with infinite-precision integer arithmetic.  */
1142
1143 #ifndef YYMAXDEPTH
1144 # define YYMAXDEPTH 10000
1145 #endif
1146
1147 \f
1148
1149 #if YYERROR_VERBOSE
1150
1151 # ifndef yystrlen
1152 #  if defined __GLIBC__ && defined _STRING_H
1153 #   define yystrlen strlen
1154 #  else
1155 /* Return the length of YYSTR.  */
1156 #if (defined __STDC__ || defined __C99__FUNC__ \
1157      || defined __cplusplus || defined _MSC_VER)
1158 static YYSIZE_T
1159 yystrlen (const char *yystr)
1160 #else
1161 static YYSIZE_T
1162 yystrlen (yystr)
1163     const char *yystr;
1164 #endif
1165 {
1166   YYSIZE_T yylen;
1167   for (yylen = 0; yystr[yylen]; yylen++)
1168     continue;
1169   return yylen;
1170 }
1171 #  endif
1172 # endif
1173
1174 # ifndef yystpcpy
1175 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1176 #   define yystpcpy stpcpy
1177 #  else
1178 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1179    YYDEST.  */
1180 #if (defined __STDC__ || defined __C99__FUNC__ \
1181      || defined __cplusplus || defined _MSC_VER)
1182 static char *
1183 yystpcpy (char *yydest, const char *yysrc)
1184 #else
1185 static char *
1186 yystpcpy (yydest, yysrc)
1187     char *yydest;
1188     const char *yysrc;
1189 #endif
1190 {
1191   char *yyd = yydest;
1192   const char *yys = yysrc;
1193
1194   while ((*yyd++ = *yys++) != '\0')
1195     continue;
1196
1197   return yyd - 1;
1198 }
1199 #  endif
1200 # endif
1201
1202 # ifndef yytnamerr
1203 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1204    quotes and backslashes, so that it's suitable for yyerror.  The
1205    heuristic is that double-quoting is unnecessary unless the string
1206    contains an apostrophe, a comma, or backslash (other than
1207    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1208    null, do not copy; instead, return the length of what the result
1209    would have been.  */
1210 static YYSIZE_T
1211 yytnamerr (char *yyres, const char *yystr)
1212 {
1213   if (*yystr == '"')
1214     {
1215       YYSIZE_T yyn = 0;
1216       char const *yyp = yystr;
1217
1218       for (;;)
1219         switch (*++yyp)
1220           {
1221           case '\'':
1222           case ',':
1223             goto do_not_strip_quotes;
1224
1225           case '\\':
1226             if (*++yyp != '\\')
1227               goto do_not_strip_quotes;
1228             /* Fall through.  */
1229           default:
1230             if (yyres)
1231               yyres[yyn] = *yyp;
1232             yyn++;
1233             break;
1234
1235           case '"':
1236             if (yyres)
1237               yyres[yyn] = '\0';
1238             return yyn;
1239           }
1240     do_not_strip_quotes: ;
1241     }
1242
1243   if (! yyres)
1244     return yystrlen (yystr);
1245
1246   return yystpcpy (yyres, yystr) - yyres;
1247 }
1248 # endif
1249
1250 /* Copy into YYRESULT an error message about the unexpected token
1251    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1252    including the terminating null byte.  If YYRESULT is null, do not
1253    copy anything; just return the number of bytes that would be
1254    copied.  As a special case, return 0 if an ordinary "syntax error"
1255    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1256    size calculation.  */
1257 static YYSIZE_T
1258 yysyntax_error (char *yyresult, int yystate, int yychar)
1259 {
1260   int yyn = yypact[yystate];
1261
1262   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1263     return 0;
1264   else
1265     {
1266       int yytype = YYTRANSLATE (yychar);
1267       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1268       YYSIZE_T yysize = yysize0;
1269       YYSIZE_T yysize1;
1270       int yysize_overflow = 0;
1271       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1272       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1273       int yyx;
1274
1275 # if 0
1276       /* This is so xgettext sees the translatable formats that are
1277          constructed on the fly.  */
1278       YY_("syntax error, unexpected %s");
1279       YY_("syntax error, unexpected %s, expecting %s");
1280       YY_("syntax error, unexpected %s, expecting %s or %s");
1281       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1282       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1283 # endif
1284       char *yyfmt;
1285       char const *yyf;
1286       static char const yyunexpected[] = "syntax error, unexpected %s";
1287       static char const yyexpecting[] = ", expecting %s";
1288       static char const yyor[] = " or %s";
1289       char yyformat[sizeof yyunexpected
1290                     + sizeof yyexpecting - 1
1291                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1292                        * (sizeof yyor - 1))];
1293       char const *yyprefix = yyexpecting;
1294
1295       /* Start YYX at -YYN if negative to avoid negative indexes in
1296          YYCHECK.  */
1297       int yyxbegin = yyn < 0 ? -yyn : 0;
1298
1299       /* Stay within bounds of both yycheck and yytname.  */
1300       int yychecklim = YYLAST - yyn + 1;
1301       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1302       int yycount = 1;
1303
1304       yyarg[0] = yytname[yytype];
1305       yyfmt = yystpcpy (yyformat, yyunexpected);
1306
1307       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1308         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1309           {
1310             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1311               {
1312                 yycount = 1;
1313                 yysize = yysize0;
1314                 yyformat[sizeof yyunexpected - 1] = '\0';
1315                 break;
1316               }
1317             yyarg[yycount++] = yytname[yyx];
1318             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1319             yysize_overflow |= (yysize1 < yysize);
1320             yysize = yysize1;
1321             yyfmt = yystpcpy (yyfmt, yyprefix);
1322             yyprefix = yyor;
1323           }
1324
1325       yyf = YY_(yyformat);
1326       yysize1 = yysize + yystrlen (yyf);
1327       yysize_overflow |= (yysize1 < yysize);
1328       yysize = yysize1;
1329
1330       if (yysize_overflow)
1331         return YYSIZE_MAXIMUM;
1332
1333       if (yyresult)
1334         {
1335           /* Avoid sprintf, as that infringes on the user's name space.
1336              Don't have undefined behavior even if the translation
1337              produced a string with the wrong number of "%s"s.  */
1338           char *yyp = yyresult;
1339           int yyi = 0;
1340           while ((*yyp = *yyf) != '\0')
1341             {
1342               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1343                 {
1344                   yyp += yytnamerr (yyp, yyarg[yyi++]);
1345                   yyf += 2;
1346                 }
1347               else
1348                 {
1349                   yyp++;
1350                   yyf++;
1351                 }
1352             }
1353         }
1354       return yysize;
1355     }
1356 }
1357 #endif /* YYERROR_VERBOSE */
1358 \f
1359
1360 /*-----------------------------------------------.
1361 | Release the memory associated to this symbol.  |
1362 `-----------------------------------------------*/
1363
1364 /*ARGSUSED*/
1365 #if (defined __STDC__ || defined __C99__FUNC__ \
1366      || defined __cplusplus || defined _MSC_VER)
1367 static void
1368 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, parser_control *pc)
1369 #else
1370 static void
1371 yydestruct (yymsg, yytype, yyvaluep, pc)
1372     const char *yymsg;
1373     int yytype;
1374     YYSTYPE *yyvaluep;
1375     parser_control *pc;
1376 #endif
1377 {
1378   YYUSE (yyvaluep);
1379   YYUSE (pc);
1380
1381   if (!yymsg)
1382     yymsg = "Deleting";
1383   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1384
1385   switch (yytype)
1386     {
1387
1388       default:
1389         break;
1390     }
1391 }
1392 \f
1393
1394 /* Prevent warnings from -Wmissing-prototypes.  */
1395
1396 #ifdef YYPARSE_PARAM
1397 #if defined __STDC__ || defined __cplusplus
1398 int yyparse (void *YYPARSE_PARAM);
1399 #else
1400 int yyparse ();
1401 #endif
1402 #else /* ! YYPARSE_PARAM */
1403 #if defined __STDC__ || defined __cplusplus
1404 int yyparse (parser_control *pc);
1405 #else
1406 int yyparse ();
1407 #endif
1408 #endif /* ! YYPARSE_PARAM */
1409
1410
1411
1412
1413
1414
1415 /*----------.
1416 | yyparse.  |
1417 `----------*/
1418
1419 #ifdef YYPARSE_PARAM
1420 #if (defined __STDC__ || defined __C99__FUNC__ \
1421      || defined __cplusplus || defined _MSC_VER)
1422 int
1423 yyparse (void *YYPARSE_PARAM)
1424 #else
1425 int
1426 yyparse (YYPARSE_PARAM)
1427     void *YYPARSE_PARAM;
1428 #endif
1429 #else /* ! YYPARSE_PARAM */
1430 #if (defined __STDC__ || defined __C99__FUNC__ \
1431      || defined __cplusplus || defined _MSC_VER)
1432 int
1433 yyparse (parser_control *pc)
1434 #else
1435 int
1436 yyparse (pc)
1437     parser_control *pc;
1438 #endif
1439 #endif
1440 {
1441   /* The look-ahead symbol.  */
1442 int yychar;
1443
1444 /* The semantic value of the look-ahead symbol.  */
1445 YYSTYPE yylval;
1446
1447 /* Number of syntax errors so far.  */
1448 int yynerrs;
1449
1450   int yystate;
1451   int yyn;
1452   int yyresult;
1453   /* Number of tokens to shift before error messages enabled.  */
1454   int yyerrstatus;
1455   /* Look-ahead token as an internal (translated) token number.  */
1456   int yytoken = 0;
1457 #if YYERROR_VERBOSE
1458   /* Buffer for error messages, and its allocated size.  */
1459   char yymsgbuf[128];
1460   char *yymsg = yymsgbuf;
1461   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1462 #endif
1463
1464   /* Three stacks and their tools:
1465      `yyss': related to states,
1466      `yyvs': related to semantic values,
1467      `yyls': related to locations.
1468
1469      Refer to the stacks thru separate pointers, to allow yyoverflow
1470      to reallocate them elsewhere.  */
1471
1472   /* The state stack.  */
1473   yytype_int16 yyssa[YYINITDEPTH];
1474   yytype_int16 *yyss = yyssa;
1475   yytype_int16 *yyssp;
1476
1477   /* The semantic value stack.  */
1478   YYSTYPE yyvsa[YYINITDEPTH];
1479   YYSTYPE *yyvs = yyvsa;
1480   YYSTYPE *yyvsp;
1481
1482
1483
1484 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1485
1486   YYSIZE_T yystacksize = YYINITDEPTH;
1487
1488   /* The variables used to return semantic value and location from the
1489      action routines.  */
1490   YYSTYPE yyval;
1491
1492
1493   /* The number of symbols on the RHS of the reduced rule.
1494      Keep to zero when no symbol should be popped.  */
1495   int yylen = 0;
1496
1497   YYDPRINTF ((stderr, "Starting parse\n"));
1498
1499   yystate = 0;
1500   yyerrstatus = 0;
1501   yynerrs = 0;
1502   yychar = YYEMPTY;             /* Cause a token to be read.  */
1503
1504   /* Initialize stack pointers.
1505      Waste one element of value and location stack
1506      so that they stay on the same level as the state stack.
1507      The wasted elements are never initialized.  */
1508
1509   yyssp = yyss;
1510   yyvsp = yyvs;
1511
1512   goto yysetstate;
1513
1514 /*------------------------------------------------------------.
1515 | yynewstate -- Push a new state, which is found in yystate.  |
1516 `------------------------------------------------------------*/
1517  yynewstate:
1518   /* In all cases, when you get here, the value and location stacks
1519      have just been pushed.  So pushing a state here evens the stacks.  */
1520   yyssp++;
1521
1522  yysetstate:
1523   *yyssp = yystate;
1524
1525   if (yyss + yystacksize - 1 <= yyssp)
1526     {
1527       /* Get the current used size of the three stacks, in elements.  */
1528       YYSIZE_T yysize = yyssp - yyss + 1;
1529
1530 #ifdef yyoverflow
1531       {
1532         /* Give user a chance to reallocate the stack.  Use copies of
1533            these so that the &'s don't force the real ones into
1534            memory.  */
1535         YYSTYPE *yyvs1 = yyvs;
1536         yytype_int16 *yyss1 = yyss;
1537
1538
1539         /* Each stack pointer address is followed by the size of the
1540            data in use in that stack, in bytes.  This used to be a
1541            conditional around just the two extra args, but that might
1542            be undefined if yyoverflow is a macro.  */
1543         yyoverflow (YY_("memory exhausted"),
1544                     &yyss1, yysize * sizeof (*yyssp),
1545                     &yyvs1, yysize * sizeof (*yyvsp),
1546
1547                     &yystacksize);
1548
1549         yyss = yyss1;
1550         yyvs = yyvs1;
1551       }
1552 #else /* no yyoverflow */
1553 # ifndef YYSTACK_RELOCATE
1554       goto yyexhaustedlab;
1555 # else
1556       /* Extend the stack our own way.  */
1557       if (YYMAXDEPTH <= yystacksize)
1558         goto yyexhaustedlab;
1559       yystacksize *= 2;
1560       if (YYMAXDEPTH < yystacksize)
1561         yystacksize = YYMAXDEPTH;
1562
1563       {
1564         yytype_int16 *yyss1 = yyss;
1565         union yyalloc *yyptr =
1566           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1567         if (! yyptr)
1568           goto yyexhaustedlab;
1569         YYSTACK_RELOCATE (yyss);
1570         YYSTACK_RELOCATE (yyvs);
1571
1572 #  undef YYSTACK_RELOCATE
1573         if (yyss1 != yyssa)
1574           YYSTACK_FREE (yyss1);
1575       }
1576 # endif
1577 #endif /* no yyoverflow */
1578
1579       yyssp = yyss + yysize - 1;
1580       yyvsp = yyvs + yysize - 1;
1581
1582
1583       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1584                   (unsigned long int) yystacksize));
1585
1586       if (yyss + yystacksize - 1 <= yyssp)
1587         YYABORT;
1588     }
1589
1590   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1591
1592   goto yybackup;
1593
1594 /*-----------.
1595 | yybackup.  |
1596 `-----------*/
1597 yybackup:
1598
1599   /* Do appropriate processing given the current state.  Read a
1600      look-ahead token if we need one and don't already have one.  */
1601
1602   /* First try to decide what to do without reference to look-ahead token.  */
1603   yyn = yypact[yystate];
1604   if (yyn == YYPACT_NINF)
1605     goto yydefault;
1606
1607   /* Not known => get a look-ahead token if don't already have one.  */
1608
1609   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1610   if (yychar == YYEMPTY)
1611     {
1612       YYDPRINTF ((stderr, "Reading a token: "));
1613       yychar = YYLEX;
1614     }
1615
1616   if (yychar <= YYEOF)
1617     {
1618       yychar = yytoken = YYEOF;
1619       YYDPRINTF ((stderr, "Now at end of input.\n"));
1620     }
1621   else
1622     {
1623       yytoken = YYTRANSLATE (yychar);
1624       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1625     }
1626
1627   /* If the proper action on seeing token YYTOKEN is to reduce or to
1628      detect an error, take that action.  */
1629   yyn += yytoken;
1630   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1631     goto yydefault;
1632   yyn = yytable[yyn];
1633   if (yyn <= 0)
1634     {
1635       if (yyn == 0 || yyn == YYTABLE_NINF)
1636         goto yyerrlab;
1637       yyn = -yyn;
1638       goto yyreduce;
1639     }
1640
1641   if (yyn == YYFINAL)
1642     YYACCEPT;
1643
1644   /* Count tokens shifted since error; after three, turn off error
1645      status.  */
1646   if (yyerrstatus)
1647     yyerrstatus--;
1648
1649   /* Shift the look-ahead token.  */
1650   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1651
1652   /* Discard the shifted token unless it is eof.  */
1653   if (yychar != YYEOF)
1654     yychar = YYEMPTY;
1655
1656   yystate = yyn;
1657   *++yyvsp = yylval;
1658
1659   goto yynewstate;
1660
1661
1662 /*-----------------------------------------------------------.
1663 | yydefault -- do the default action for the current state.  |
1664 `-----------------------------------------------------------*/
1665 yydefault:
1666   yyn = yydefact[yystate];
1667   if (yyn == 0)
1668     goto yyerrlab;
1669   goto yyreduce;
1670
1671
1672 /*-----------------------------.
1673 | yyreduce -- Do a reduction.  |
1674 `-----------------------------*/
1675 yyreduce:
1676   /* yyn is the number of a rule to reduce with.  */
1677   yylen = yyr2[yyn];
1678
1679   /* If YYLEN is nonzero, implement the default value of the action:
1680      `$$ = $1'.
1681
1682      Otherwise, the following line sets YYVAL to garbage.
1683      This behavior is undocumented and Bison
1684      users should not rely upon it.  Assigning to YYVAL
1685      unconditionally makes the parser a bit smaller, and it avoids a
1686      GCC warning that YYVAL may be used uninitialized.  */
1687   yyval = yyvsp[1-yylen];
1688
1689
1690   YY_REDUCE_PRINT (yyn);
1691   switch (yyn)
1692     {
1693         case 4:
1694 #line 287 "getdate.y"
1695     {
1696         pc->seconds = (yyvsp[(2) - (2)].timespec);
1697         pc->timespec_seen = true;
1698       ;}
1699     break;
1700
1701   case 7:
1702 #line 300 "getdate.y"
1703     { pc->times_seen++; ;}
1704     break;
1705
1706   case 8:
1707 #line 302 "getdate.y"
1708     { pc->local_zones_seen++; ;}
1709     break;
1710
1711   case 9:
1712 #line 304 "getdate.y"
1713     { pc->zones_seen++; ;}
1714     break;
1715
1716   case 10:
1717 #line 306 "getdate.y"
1718     { pc->dates_seen++; ;}
1719     break;
1720
1721   case 11:
1722 #line 308 "getdate.y"
1723     { pc->days_seen++; ;}
1724     break;
1725
1726   case 12:
1727 #line 310 "getdate.y"
1728     { pc->rels_seen = true; ;}
1729     break;
1730
1731   case 14:
1732 #line 316 "getdate.y"
1733     {
1734         pc->hour = (yyvsp[(1) - (2)].textintval).value;
1735         pc->minutes = 0;
1736         pc->seconds.tv_sec = 0;
1737         pc->seconds.tv_nsec = 0;
1738         pc->meridian = (yyvsp[(2) - (2)].intval);
1739       ;}
1740     break;
1741
1742   case 15:
1743 #line 324 "getdate.y"
1744     {
1745         pc->hour = (yyvsp[(1) - (4)].textintval).value;
1746         pc->minutes = (yyvsp[(3) - (4)].textintval).value;
1747         pc->seconds.tv_sec = 0;
1748         pc->seconds.tv_nsec = 0;
1749         pc->meridian = (yyvsp[(4) - (4)].intval);
1750       ;}
1751     break;
1752
1753   case 16:
1754 #line 332 "getdate.y"
1755     {
1756         pc->hour = (yyvsp[(1) - (5)].textintval).value;
1757         pc->minutes = (yyvsp[(3) - (5)].textintval).value;
1758         pc->seconds.tv_sec = 0;
1759         pc->seconds.tv_nsec = 0;
1760         pc->meridian = MER24;
1761         pc->zones_seen++;
1762         pc->time_zone = time_zone_hhmm ((yyvsp[(4) - (5)].textintval), (yyvsp[(5) - (5)].intval));
1763       ;}
1764     break;
1765
1766   case 17:
1767 #line 342 "getdate.y"
1768     {
1769         pc->hour = (yyvsp[(1) - (6)].textintval).value;
1770         pc->minutes = (yyvsp[(3) - (6)].textintval).value;
1771         pc->seconds = (yyvsp[(5) - (6)].timespec);
1772         pc->meridian = (yyvsp[(6) - (6)].intval);
1773       ;}
1774     break;
1775
1776   case 18:
1777 #line 349 "getdate.y"
1778     {
1779         pc->hour = (yyvsp[(1) - (7)].textintval).value;
1780         pc->minutes = (yyvsp[(3) - (7)].textintval).value;
1781         pc->seconds = (yyvsp[(5) - (7)].timespec);
1782         pc->meridian = MER24;
1783         pc->zones_seen++;
1784         pc->time_zone = time_zone_hhmm ((yyvsp[(6) - (7)].textintval), (yyvsp[(7) - (7)].intval));
1785       ;}
1786     break;
1787
1788   case 19:
1789 #line 361 "getdate.y"
1790     {
1791         pc->local_isdst = (yyvsp[(1) - (1)].intval);
1792         pc->dsts_seen += (0 < (yyvsp[(1) - (1)].intval));
1793       ;}
1794     break;
1795
1796   case 20:
1797 #line 366 "getdate.y"
1798     {
1799         pc->local_isdst = 1;
1800         pc->dsts_seen += (0 < (yyvsp[(1) - (2)].intval)) + 1;
1801       ;}
1802     break;
1803
1804   case 21:
1805 #line 374 "getdate.y"
1806     { pc->time_zone = (yyvsp[(1) - (1)].intval); ;}
1807     break;
1808
1809   case 22:
1810 #line 376 "getdate.y"
1811     { pc->time_zone = (yyvsp[(1) - (2)].intval); pc->rels_seen = true; ;}
1812     break;
1813
1814   case 23:
1815 #line 378 "getdate.y"
1816     { pc->time_zone = (yyvsp[(1) - (3)].intval) + time_zone_hhmm ((yyvsp[(2) - (3)].textintval), (yyvsp[(3) - (3)].intval)); ;}
1817     break;
1818
1819   case 24:
1820 #line 380 "getdate.y"
1821     { pc->time_zone = (yyvsp[(1) - (1)].intval) + 60; ;}
1822     break;
1823
1824   case 25:
1825 #line 382 "getdate.y"
1826     { pc->time_zone = (yyvsp[(1) - (2)].intval) + 60; ;}
1827     break;
1828
1829   case 26:
1830 #line 387 "getdate.y"
1831     {
1832         pc->day_ordinal = 1;
1833         pc->day_number = (yyvsp[(1) - (1)].intval);
1834       ;}
1835     break;
1836
1837   case 27:
1838 #line 392 "getdate.y"
1839     {
1840         pc->day_ordinal = 1;
1841         pc->day_number = (yyvsp[(1) - (2)].intval);
1842       ;}
1843     break;
1844
1845   case 28:
1846 #line 397 "getdate.y"
1847     {
1848         pc->day_ordinal = (yyvsp[(1) - (2)].intval);
1849         pc->day_number = (yyvsp[(2) - (2)].intval);
1850       ;}
1851     break;
1852
1853   case 29:
1854 #line 402 "getdate.y"
1855     {
1856         pc->day_ordinal = (yyvsp[(1) - (2)].textintval).value;
1857         pc->day_number = (yyvsp[(2) - (2)].intval);
1858       ;}
1859     break;
1860
1861   case 30:
1862 #line 410 "getdate.y"
1863     {
1864         pc->month = (yyvsp[(1) - (3)].textintval).value;
1865         pc->day = (yyvsp[(3) - (3)].textintval).value;
1866       ;}
1867     break;
1868
1869   case 31:
1870 #line 415 "getdate.y"
1871     {
1872         /* Interpret as YYYY/MM/DD if the first value has 4 or more digits,
1873            otherwise as MM/DD/YY.
1874            The goal in recognizing YYYY/MM/DD is solely to support legacy
1875            machine-generated dates like those in an RCS log listing.  If
1876            you want portability, use the ISO 8601 format.  */
1877         if (4 <= (yyvsp[(1) - (5)].textintval).digits)
1878           {
1879             pc->year = (yyvsp[(1) - (5)].textintval);
1880             pc->month = (yyvsp[(3) - (5)].textintval).value;
1881             pc->day = (yyvsp[(5) - (5)].textintval).value;
1882           }
1883         else
1884           {
1885             pc->month = (yyvsp[(1) - (5)].textintval).value;
1886             pc->day = (yyvsp[(3) - (5)].textintval).value;
1887             pc->year = (yyvsp[(5) - (5)].textintval);
1888           }
1889       ;}
1890     break;
1891
1892   case 32:
1893 #line 435 "getdate.y"
1894     {
1895         /* ISO 8601 format.  YYYY-MM-DD.  */
1896         pc->year = (yyvsp[(1) - (3)].textintval);
1897         pc->month = -(yyvsp[(2) - (3)].textintval).value;
1898         pc->day = -(yyvsp[(3) - (3)].textintval).value;
1899       ;}
1900     break;
1901
1902   case 33:
1903 #line 442 "getdate.y"
1904     {
1905         /* e.g. 17-JUN-1992.  */
1906         pc->day = (yyvsp[(1) - (3)].textintval).value;
1907         pc->month = (yyvsp[(2) - (3)].intval);
1908         pc->year.value = -(yyvsp[(3) - (3)].textintval).value;
1909         pc->year.digits = (yyvsp[(3) - (3)].textintval).digits;
1910       ;}
1911     break;
1912
1913   case 34:
1914 #line 450 "getdate.y"
1915     {
1916         /* e.g. JUN-17-1992.  */
1917         pc->month = (yyvsp[(1) - (3)].intval);
1918         pc->day = -(yyvsp[(2) - (3)].textintval).value;
1919         pc->year.value = -(yyvsp[(3) - (3)].textintval).value;
1920         pc->year.digits = (yyvsp[(3) - (3)].textintval).digits;
1921       ;}
1922     break;
1923
1924   case 35:
1925 #line 458 "getdate.y"
1926     {
1927         pc->month = (yyvsp[(1) - (2)].intval);
1928         pc->day = (yyvsp[(2) - (2)].textintval).value;
1929       ;}
1930     break;
1931
1932   case 36:
1933 #line 463 "getdate.y"
1934     {
1935         pc->month = (yyvsp[(1) - (4)].intval);
1936         pc->day = (yyvsp[(2) - (4)].textintval).value;
1937         pc->year = (yyvsp[(4) - (4)].textintval);
1938       ;}
1939     break;
1940
1941   case 37:
1942 #line 469 "getdate.y"
1943     {
1944         pc->day = (yyvsp[(1) - (2)].textintval).value;
1945         pc->month = (yyvsp[(2) - (2)].intval);
1946       ;}
1947     break;
1948
1949   case 38:
1950 #line 474 "getdate.y"
1951     {
1952         pc->day = (yyvsp[(1) - (3)].textintval).value;
1953         pc->month = (yyvsp[(2) - (3)].intval);
1954         pc->year = (yyvsp[(3) - (3)].textintval);
1955       ;}
1956     break;
1957
1958   case 39:
1959 #line 483 "getdate.y"
1960     {
1961         pc->rel_ns = -pc->rel_ns;
1962         pc->rel_seconds = -pc->rel_seconds;
1963         pc->rel_minutes = -pc->rel_minutes;
1964         pc->rel_hour = -pc->rel_hour;
1965         pc->rel_day = -pc->rel_day;
1966         pc->rel_month = -pc->rel_month;
1967         pc->rel_year = -pc->rel_year;
1968       ;}
1969     break;
1970
1971   case 41:
1972 #line 497 "getdate.y"
1973     { pc->rel_year += (yyvsp[(1) - (2)].intval) * (yyvsp[(2) - (2)].intval); ;}
1974     break;
1975
1976   case 42:
1977 #line 499 "getdate.y"
1978     { pc->rel_year += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
1979     break;
1980
1981   case 43:
1982 #line 501 "getdate.y"
1983     { pc->rel_year += (yyvsp[(1) - (1)].intval); ;}
1984     break;
1985
1986   case 44:
1987 #line 503 "getdate.y"
1988     { pc->rel_month += (yyvsp[(1) - (2)].intval) * (yyvsp[(2) - (2)].intval); ;}
1989     break;
1990
1991   case 45:
1992 #line 505 "getdate.y"
1993     { pc->rel_month += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
1994     break;
1995
1996   case 46:
1997 #line 507 "getdate.y"
1998     { pc->rel_month += (yyvsp[(1) - (1)].intval); ;}
1999     break;
2000
2001   case 47:
2002 #line 509 "getdate.y"
2003     { pc->rel_day += (yyvsp[(1) - (2)].intval) * (yyvsp[(2) - (2)].intval); ;}
2004     break;
2005
2006   case 48:
2007 #line 511 "getdate.y"
2008     { pc->rel_day += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2009     break;
2010
2011   case 49:
2012 #line 513 "getdate.y"
2013     { pc->rel_day += (yyvsp[(1) - (1)].intval); ;}
2014     break;
2015
2016   case 50:
2017 #line 515 "getdate.y"
2018     { pc->rel_hour += (yyvsp[(1) - (2)].intval) * (yyvsp[(2) - (2)].intval); ;}
2019     break;
2020
2021   case 51:
2022 #line 517 "getdate.y"
2023     { pc->rel_hour += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2024     break;
2025
2026   case 52:
2027 #line 519 "getdate.y"
2028     { pc->rel_hour += (yyvsp[(1) - (1)].intval); ;}
2029     break;
2030
2031   case 53:
2032 #line 521 "getdate.y"
2033     { pc->rel_minutes += (yyvsp[(1) - (2)].intval) * (yyvsp[(2) - (2)].intval); ;}
2034     break;
2035
2036   case 54:
2037 #line 523 "getdate.y"
2038     { pc->rel_minutes += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2039     break;
2040
2041   case 55:
2042 #line 525 "getdate.y"
2043     { pc->rel_minutes += (yyvsp[(1) - (1)].intval); ;}
2044     break;
2045
2046   case 56:
2047 #line 527 "getdate.y"
2048     { pc->rel_seconds += (yyvsp[(1) - (2)].intval) * (yyvsp[(2) - (2)].intval); ;}
2049     break;
2050
2051   case 57:
2052 #line 529 "getdate.y"
2053     { pc->rel_seconds += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2054     break;
2055
2056   case 58:
2057 #line 531 "getdate.y"
2058     { pc->rel_seconds += (yyvsp[(1) - (2)].timespec).tv_sec * (yyvsp[(2) - (2)].intval); pc->rel_ns += (yyvsp[(1) - (2)].timespec).tv_nsec * (yyvsp[(2) - (2)].intval); ;}
2059     break;
2060
2061   case 59:
2062 #line 533 "getdate.y"
2063     { pc->rel_seconds += (yyvsp[(1) - (2)].timespec).tv_sec * (yyvsp[(2) - (2)].intval); pc->rel_ns += (yyvsp[(1) - (2)].timespec).tv_nsec * (yyvsp[(2) - (2)].intval); ;}
2064     break;
2065
2066   case 60:
2067 #line 535 "getdate.y"
2068     { pc->rel_seconds += (yyvsp[(1) - (1)].intval); ;}
2069     break;
2070
2071   case 62:
2072 #line 541 "getdate.y"
2073     { pc->rel_year += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2074     break;
2075
2076   case 63:
2077 #line 543 "getdate.y"
2078     { pc->rel_month += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2079     break;
2080
2081   case 64:
2082 #line 545 "getdate.y"
2083     { pc->rel_day += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2084     break;
2085
2086   case 65:
2087 #line 547 "getdate.y"
2088     { pc->rel_hour += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2089     break;
2090
2091   case 66:
2092 #line 549 "getdate.y"
2093     { pc->rel_minutes += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2094     break;
2095
2096   case 67:
2097 #line 551 "getdate.y"
2098     { pc->rel_seconds += (yyvsp[(1) - (2)].textintval).value * (yyvsp[(2) - (2)].intval); ;}
2099     break;
2100
2101   case 71:
2102 #line 559 "getdate.y"
2103     { (yyval.timespec).tv_sec = (yyvsp[(1) - (1)].textintval).value; (yyval.timespec).tv_nsec = 0; ;}
2104     break;
2105
2106   case 73:
2107 #line 565 "getdate.y"
2108     { (yyval.timespec).tv_sec = (yyvsp[(1) - (1)].textintval).value; (yyval.timespec).tv_nsec = 0; ;}
2109     break;
2110
2111   case 74:
2112 #line 570 "getdate.y"
2113     {
2114         if (pc->dates_seen && ! pc->year.digits
2115             && ! pc->rels_seen && (pc->times_seen || 2 < (yyvsp[(1) - (1)].textintval).digits))
2116           pc->year = (yyvsp[(1) - (1)].textintval);
2117         else
2118           {
2119             if (4 < (yyvsp[(1) - (1)].textintval).digits)
2120               {
2121                 pc->dates_seen++;
2122                 pc->day = (yyvsp[(1) - (1)].textintval).value % 100;
2123                 pc->month = ((yyvsp[(1) - (1)].textintval).value / 100) % 100;
2124                 pc->year.value = (yyvsp[(1) - (1)].textintval).value / 10000;
2125                 pc->year.digits = (yyvsp[(1) - (1)].textintval).digits - 4;
2126               }
2127             else
2128               {
2129                 pc->times_seen++;
2130                 if ((yyvsp[(1) - (1)].textintval).digits <= 2)
2131                   {
2132                     pc->hour = (yyvsp[(1) - (1)].textintval).value;
2133                     pc->minutes = 0;
2134                   }
2135                 else
2136                   {
2137                     pc->hour = (yyvsp[(1) - (1)].textintval).value / 100;
2138                     pc->minutes = (yyvsp[(1) - (1)].textintval).value % 100;
2139                   }
2140                 pc->seconds.tv_sec = 0;
2141                 pc->seconds.tv_nsec = 0;
2142                 pc->meridian = MER24;
2143               }
2144           }
2145       ;}
2146     break;
2147
2148   case 75:
2149 #line 607 "getdate.y"
2150     { (yyval.intval) = -1; ;}
2151     break;
2152
2153   case 76:
2154 #line 609 "getdate.y"
2155     { (yyval.intval) = (yyvsp[(2) - (2)].textintval).value; ;}
2156     break;
2157
2158   case 77:
2159 #line 614 "getdate.y"
2160     { (yyval.intval) = MER24; ;}
2161     break;
2162
2163   case 78:
2164 #line 616 "getdate.y"
2165     { (yyval.intval) = (yyvsp[(1) - (1)].intval); ;}
2166     break;
2167
2168
2169 /* Line 1267 of yacc.c.  */
2170 #line 2171 "getdate.c"
2171       default: break;
2172     }
2173   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2174
2175   YYPOPSTACK (yylen);
2176   yylen = 0;
2177   YY_STACK_PRINT (yyss, yyssp);
2178
2179   *++yyvsp = yyval;
2180
2181
2182   /* Now `shift' the result of the reduction.  Determine what state
2183      that goes to, based on the state we popped back to and the rule
2184      number reduced by.  */
2185
2186   yyn = yyr1[yyn];
2187
2188   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2189   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2190     yystate = yytable[yystate];
2191   else
2192     yystate = yydefgoto[yyn - YYNTOKENS];
2193
2194   goto yynewstate;
2195
2196
2197 /*------------------------------------.
2198 | yyerrlab -- here on detecting error |
2199 `------------------------------------*/
2200 yyerrlab:
2201   /* If not already recovering from an error, report this error.  */
2202   if (!yyerrstatus)
2203     {
2204       ++yynerrs;
2205 #if ! YYERROR_VERBOSE
2206       yyerror (pc, YY_("syntax error"));
2207 #else
2208       {
2209         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2210         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2211           {
2212             YYSIZE_T yyalloc = 2 * yysize;
2213             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2214               yyalloc = YYSTACK_ALLOC_MAXIMUM;
2215             if (yymsg != yymsgbuf)
2216               YYSTACK_FREE (yymsg);
2217             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2218             if (yymsg)
2219               yymsg_alloc = yyalloc;
2220             else
2221               {
2222                 yymsg = yymsgbuf;
2223                 yymsg_alloc = sizeof yymsgbuf;
2224               }
2225           }
2226
2227         if (0 < yysize && yysize <= yymsg_alloc)
2228           {
2229             (void) yysyntax_error (yymsg, yystate, yychar);
2230             yyerror (pc, yymsg);
2231           }
2232         else
2233           {
2234             yyerror (pc, YY_("syntax error"));
2235             if (yysize != 0)
2236               goto yyexhaustedlab;
2237           }
2238       }
2239 #endif
2240     }
2241
2242
2243
2244   if (yyerrstatus == 3)
2245     {
2246       /* If just tried and failed to reuse look-ahead token after an
2247          error, discard it.  */
2248
2249       if (yychar <= YYEOF)
2250         {
2251           /* Return failure if at end of input.  */
2252           if (yychar == YYEOF)
2253             YYABORT;
2254         }
2255       else
2256         {
2257           yydestruct ("Error: discarding",
2258                       yytoken, &yylval, pc);
2259           yychar = YYEMPTY;
2260         }
2261     }
2262
2263   /* Else will try to reuse look-ahead token after shifting the error
2264      token.  */
2265   goto yyerrlab1;
2266
2267
2268 /*---------------------------------------------------.
2269 | yyerrorlab -- error raised explicitly by YYERROR.  |
2270 `---------------------------------------------------*/
2271 yyerrorlab:
2272
2273   /* Pacify compilers like GCC when the user code never invokes
2274      YYERROR and the label yyerrorlab therefore never appears in user
2275      code.  */
2276   if (/*CONSTCOND*/ 0)
2277      goto yyerrorlab;
2278
2279   /* Do not reclaim the symbols of the rule which action triggered
2280      this YYERROR.  */
2281   YYPOPSTACK (yylen);
2282   yylen = 0;
2283   YY_STACK_PRINT (yyss, yyssp);
2284   yystate = *yyssp;
2285   goto yyerrlab1;
2286
2287
2288 /*-------------------------------------------------------------.
2289 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
2290 `-------------------------------------------------------------*/
2291 yyerrlab1:
2292   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
2293
2294   for (;;)
2295     {
2296       yyn = yypact[yystate];
2297       if (yyn != YYPACT_NINF)
2298         {
2299           yyn += YYTERROR;
2300           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2301             {
2302               yyn = yytable[yyn];
2303               if (0 < yyn)
2304                 break;
2305             }
2306         }
2307
2308       /* Pop the current state because it cannot handle the error token.  */
2309       if (yyssp == yyss)
2310         YYABORT;
2311
2312
2313       yydestruct ("Error: popping",
2314                   yystos[yystate], yyvsp, pc);
2315       YYPOPSTACK (1);
2316       yystate = *yyssp;
2317       YY_STACK_PRINT (yyss, yyssp);
2318     }
2319
2320   if (yyn == YYFINAL)
2321     YYACCEPT;
2322
2323   *++yyvsp = yylval;
2324
2325
2326   /* Shift the error token.  */
2327   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2328
2329   yystate = yyn;
2330   goto yynewstate;
2331
2332
2333 /*-------------------------------------.
2334 | yyacceptlab -- YYACCEPT comes here.  |
2335 `-------------------------------------*/
2336 yyacceptlab:
2337   yyresult = 0;
2338   goto yyreturn;
2339
2340 /*-----------------------------------.
2341 | yyabortlab -- YYABORT comes here.  |
2342 `-----------------------------------*/
2343 yyabortlab:
2344   yyresult = 1;
2345   goto yyreturn;
2346
2347 #ifndef yyoverflow
2348 /*-------------------------------------------------.
2349 | yyexhaustedlab -- memory exhaustion comes here.  |
2350 `-------------------------------------------------*/
2351 yyexhaustedlab:
2352   yyerror (pc, YY_("memory exhausted"));
2353   yyresult = 2;
2354   /* Fall through.  */
2355 #endif
2356
2357 yyreturn:
2358   if (yychar != YYEOF && yychar != YYEMPTY)
2359      yydestruct ("Cleanup: discarding lookahead",
2360                  yytoken, &yylval, pc);
2361   /* Do not reclaim the symbols of the rule which action triggered
2362      this YYABORT or YYACCEPT.  */
2363   YYPOPSTACK (yylen);
2364   YY_STACK_PRINT (yyss, yyssp);
2365   while (yyssp != yyss)
2366     {
2367       yydestruct ("Cleanup: popping",
2368                   yystos[*yyssp], yyvsp, pc);
2369       YYPOPSTACK (1);
2370     }
2371 #ifndef yyoverflow
2372   if (yyss != yyssa)
2373     YYSTACK_FREE (yyss);
2374 #endif
2375 #if YYERROR_VERBOSE
2376   if (yymsg != yymsgbuf)
2377     YYSTACK_FREE (yymsg);
2378 #endif
2379   /* Make sure YYID is used.  */
2380   return YYID (yyresult);
2381 }
2382
2383
2384 #line 619 "getdate.y"
2385
2386
2387 static table const meridian_table[] =
2388 {
2389   { "AM",   tMERIDIAN, MERam },
2390   { "A.M.", tMERIDIAN, MERam },
2391   { "PM",   tMERIDIAN, MERpm },
2392   { "P.M.", tMERIDIAN, MERpm },
2393   { NULL, 0, 0 }
2394 };
2395
2396 static table const dst_table[] =
2397 {
2398   { "DST", tDST, 0 }
2399 };
2400
2401 static table const month_and_day_table[] =
2402 {
2403   { "JANUARY",  tMONTH,  1 },
2404   { "FEBRUARY", tMONTH,  2 },
2405   { "MARCH",    tMONTH,  3 },
2406   { "APRIL",    tMONTH,  4 },
2407   { "MAY",      tMONTH,  5 },
2408   { "JUNE",     tMONTH,  6 },
2409   { "JULY",     tMONTH,  7 },
2410   { "AUGUST",   tMONTH,  8 },
2411   { "SEPTEMBER",tMONTH,  9 },
2412   { "SEPT",     tMONTH,  9 },
2413   { "OCTOBER",  tMONTH, 10 },
2414   { "NOVEMBER", tMONTH, 11 },
2415   { "DECEMBER", tMONTH, 12 },
2416   { "SUNDAY",   tDAY,    0 },
2417   { "MONDAY",   tDAY,    1 },
2418   { "TUESDAY",  tDAY,    2 },
2419   { "TUES",     tDAY,    2 },
2420   { "WEDNESDAY",tDAY,    3 },
2421   { "WEDNES",   tDAY,    3 },
2422   { "THURSDAY", tDAY,    4 },
2423   { "THUR",     tDAY,    4 },
2424   { "THURS",    tDAY,    4 },
2425   { "FRIDAY",   tDAY,    5 },
2426   { "SATURDAY", tDAY,    6 },
2427   { NULL, 0, 0 }
2428 };
2429
2430 static table const time_units_table[] =
2431 {
2432   { "YEAR",     tYEAR_UNIT,      1 },
2433   { "MONTH",    tMONTH_UNIT,     1 },
2434   { "FORTNIGHT",tDAY_UNIT,      14 },
2435   { "WEEK",     tDAY_UNIT,       7 },
2436   { "DAY",      tDAY_UNIT,       1 },
2437   { "HOUR",     tHOUR_UNIT,      1 },
2438   { "MINUTE",   tMINUTE_UNIT,    1 },
2439   { "MIN",      tMINUTE_UNIT,    1 },
2440   { "SECOND",   tSEC_UNIT,       1 },
2441   { "SEC",      tSEC_UNIT,       1 },
2442   { NULL, 0, 0 }
2443 };
2444
2445 /* Assorted relative-time words. */
2446 static table const relative_time_table[] =
2447 {
2448   { "TOMORROW", tDAY_UNIT,       1 },
2449   { "YESTERDAY",tDAY_UNIT,      -1 },
2450   { "TODAY",    tDAY_UNIT,       0 },
2451   { "NOW",      tDAY_UNIT,       0 },
2452   { "LAST",     tORDINAL,       -1 },
2453   { "THIS",     tORDINAL,        0 },
2454   { "NEXT",     tORDINAL,        1 },
2455   { "FIRST",    tORDINAL,        1 },
2456 /*{ "SECOND",   tORDINAL,        2 }, */
2457   { "THIRD",    tORDINAL,        3 },
2458   { "FOURTH",   tORDINAL,        4 },
2459   { "FIFTH",    tORDINAL,        5 },
2460   { "SIXTH",    tORDINAL,        6 },
2461   { "SEVENTH",  tORDINAL,        7 },
2462   { "EIGHTH",   tORDINAL,        8 },
2463   { "NINTH",    tORDINAL,        9 },
2464   { "TENTH",    tORDINAL,       10 },
2465   { "ELEVENTH", tORDINAL,       11 },
2466   { "TWELFTH",  tORDINAL,       12 },
2467   { "AGO",      tAGO,            1 },
2468   { NULL, 0, 0 }
2469 };
2470
2471 /* The universal time zone table.  These labels can be used even for
2472    time stamps that would not otherwise be valid, e.g., GMT time
2473    stamps in London during summer.  */
2474 static table const universal_time_zone_table[] =
2475 {
2476   { "GMT",      tZONE,     HOUR ( 0) }, /* Greenwich Mean */
2477   { "UT",       tZONE,     HOUR ( 0) }, /* Universal (Coordinated) */
2478   { "UTC",      tZONE,     HOUR ( 0) },
2479   { NULL, 0, 0 }
2480 };
2481
2482 /* The time zone table.  This table is necessarily incomplete, as time
2483    zone abbreviations are ambiguous; e.g. Australians interpret "EST"
2484    as Eastern time in Australia, not as US Eastern Standard Time.
2485    You cannot rely on getdate to handle arbitrary time zone
2486    abbreviations; use numeric abbreviations like `-0500' instead.  */
2487 static table const time_zone_table[] =
2488 {
2489   { "WET",      tZONE,     HOUR ( 0) }, /* Western European */
2490   { "WEST",     tDAYZONE,  HOUR ( 0) }, /* Western European Summer */
2491   { "BST",      tDAYZONE,  HOUR ( 0) }, /* British Summer */
2492   { "ART",      tZONE,    -HOUR ( 3) }, /* Argentina */
2493   { "BRT",      tZONE,    -HOUR ( 3) }, /* Brazil */
2494   { "BRST",     tDAYZONE, -HOUR ( 3) }, /* Brazil Summer */
2495   { "NST",      tZONE,   -(HOUR ( 3) + 30) },   /* Newfoundland Standard */
2496   { "NDT",      tDAYZONE,-(HOUR ( 3) + 30) },   /* Newfoundland Daylight */
2497   { "AST",      tZONE,    -HOUR ( 4) }, /* Atlantic Standard */
2498   { "ADT",      tDAYZONE, -HOUR ( 4) }, /* Atlantic Daylight */
2499   { "CLT",      tZONE,    -HOUR ( 4) }, /* Chile */
2500   { "CLST",     tDAYZONE, -HOUR ( 4) }, /* Chile Summer */
2501   { "EST",      tZONE,    -HOUR ( 5) }, /* Eastern Standard */
2502   { "EDT",      tDAYZONE, -HOUR ( 5) }, /* Eastern Daylight */
2503   { "CST",      tZONE,    -HOUR ( 6) }, /* Central Standard */
2504   { "CDT",      tDAYZONE, -HOUR ( 6) }, /* Central Daylight */
2505   { "MST",      tZONE,    -HOUR ( 7) }, /* Mountain Standard */
2506   { "MDT",      tDAYZONE, -HOUR ( 7) }, /* Mountain Daylight */
2507   { "PST",      tZONE,    -HOUR ( 8) }, /* Pacific Standard */
2508   { "PDT",      tDAYZONE, -HOUR ( 8) }, /* Pacific Daylight */
2509   { "AKST",     tZONE,    -HOUR ( 9) }, /* Alaska Standard */
2510   { "AKDT",     tDAYZONE, -HOUR ( 9) }, /* Alaska Daylight */
2511   { "HST",      tZONE,    -HOUR (10) }, /* Hawaii Standard */
2512   { "HAST",     tZONE,    -HOUR (10) }, /* Hawaii-Aleutian Standard */
2513   { "HADT",     tDAYZONE, -HOUR (10) }, /* Hawaii-Aleutian Daylight */
2514   { "SST",      tZONE,    -HOUR (12) }, /* Samoa Standard */
2515   { "WAT",      tZONE,     HOUR ( 1) }, /* West Africa */
2516   { "CET",      tZONE,     HOUR ( 1) }, /* Central European */
2517   { "CEST",     tDAYZONE,  HOUR ( 1) }, /* Central European Summer */
2518   { "MET",      tZONE,     HOUR ( 1) }, /* Middle European */
2519   { "MEZ",      tZONE,     HOUR ( 1) }, /* Middle European */
2520   { "MEST",     tDAYZONE,  HOUR ( 1) }, /* Middle European Summer */
2521   { "MESZ",     tDAYZONE,  HOUR ( 1) }, /* Middle European Summer */
2522   { "EET",      tZONE,     HOUR ( 2) }, /* Eastern European */
2523   { "EEST",     tDAYZONE,  HOUR ( 2) }, /* Eastern European Summer */
2524   { "CAT",      tZONE,     HOUR ( 2) }, /* Central Africa */
2525   { "SAST",     tZONE,     HOUR ( 2) }, /* South Africa Standard */
2526   { "EAT",      tZONE,     HOUR ( 3) }, /* East Africa */
2527   { "MSK",      tZONE,     HOUR ( 3) }, /* Moscow */
2528   { "MSD",      tDAYZONE,  HOUR ( 3) }, /* Moscow Daylight */
2529   { "IST",      tZONE,    (HOUR ( 5) + 30) },   /* India Standard */
2530   { "SGT",      tZONE,     HOUR ( 8) }, /* Singapore */
2531   { "KST",      tZONE,     HOUR ( 9) }, /* Korea Standard */
2532   { "JST",      tZONE,     HOUR ( 9) }, /* Japan Standard */
2533   { "GST",      tZONE,     HOUR (10) }, /* Guam Standard */
2534   { "NZST",     tZONE,     HOUR (12) }, /* New Zealand Standard */
2535   { "NZDT",     tDAYZONE,  HOUR (12) }, /* New Zealand Daylight */
2536   { NULL, 0, 0 }
2537 };
2538
2539 /* Military time zone table. */
2540 static table const military_table[] =
2541 {
2542   { "A", tZONE, -HOUR ( 1) },
2543   { "B", tZONE, -HOUR ( 2) },
2544   { "C", tZONE, -HOUR ( 3) },
2545   { "D", tZONE, -HOUR ( 4) },
2546   { "E", tZONE, -HOUR ( 5) },
2547   { "F", tZONE, -HOUR ( 6) },
2548   { "G", tZONE, -HOUR ( 7) },
2549   { "H", tZONE, -HOUR ( 8) },
2550   { "I", tZONE, -HOUR ( 9) },
2551   { "K", tZONE, -HOUR (10) },
2552   { "L", tZONE, -HOUR (11) },
2553   { "M", tZONE, -HOUR (12) },
2554   { "N", tZONE,  HOUR ( 1) },
2555   { "O", tZONE,  HOUR ( 2) },
2556   { "P", tZONE,  HOUR ( 3) },
2557   { "Q", tZONE,  HOUR ( 4) },
2558   { "R", tZONE,  HOUR ( 5) },
2559   { "S", tZONE,  HOUR ( 6) },
2560   { "T", tZONE,  HOUR ( 7) },
2561   { "U", tZONE,  HOUR ( 8) },
2562   { "V", tZONE,  HOUR ( 9) },
2563   { "W", tZONE,  HOUR (10) },
2564   { "X", tZONE,  HOUR (11) },
2565   { "Y", tZONE,  HOUR (12) },
2566   { "Z", tZONE,  HOUR ( 0) },
2567   { NULL, 0, 0 }
2568 };
2569
2570 \f
2571
2572 /* Convert a time zone expressed as HH:MM into an integer count of
2573    minutes.  If MM is negative, then S is of the form HHMM and needs
2574    to be picked apart; otherwise, S is of the form HH.  */
2575
2576 static long int
2577 time_zone_hhmm (textint s, long int mm)
2578 {
2579   if (mm < 0)
2580     return (s.value / 100) * 60 + s.value % 100;
2581   else
2582     return s.value * 60 + (s.negative ? -mm : mm);
2583 }
2584
2585 static int
2586 to_hour (long int hours, int meridian)
2587 {
2588   switch (meridian)
2589     {
2590     default: /* Pacify GCC.  */
2591     case MER24:
2592       return 0 <= hours && hours < 24 ? hours : -1;
2593     case MERam:
2594       return 0 < hours && hours < 12 ? hours : hours == 12 ? 0 : -1;
2595     case MERpm:
2596       return 0 < hours && hours < 12 ? hours + 12 : hours == 12 ? 12 : -1;
2597     }
2598 }
2599
2600 static long int
2601 to_year (textint textyear)
2602 {
2603   long int year = textyear.value;
2604
2605   if (year < 0)
2606     year = -year;
2607
2608   /* XPG4 suggests that years 00-68 map to 2000-2068, and
2609      years 69-99 map to 1969-1999.  */
2610   else if (textyear.digits == 2)
2611     year += year < 69 ? 2000 : 1900;
2612
2613   return year;
2614 }
2615
2616 static table const *
2617 lookup_zone (parser_control const *pc, char const *name)
2618 {
2619   table const *tp;
2620
2621   for (tp = universal_time_zone_table; tp->name; tp++)
2622     if (strcmp (name, tp->name) == 0)
2623       return tp;
2624
2625   /* Try local zone abbreviations before those in time_zone_table, as
2626      the local ones are more likely to be right.  */
2627   for (tp = pc->local_time_zone_table; tp->name; tp++)
2628     if (strcmp (name, tp->name) == 0)
2629       return tp;
2630
2631   for (tp = time_zone_table; tp->name; tp++)
2632     if (strcmp (name, tp->name) == 0)
2633       return tp;
2634
2635   return NULL;
2636 }
2637
2638 #if ! HAVE_TM_GMTOFF
2639 /* Yield the difference between *A and *B,
2640    measured in seconds, ignoring leap seconds.
2641    The body of this function is taken directly from the GNU C Library;
2642    see src/strftime.c.  */
2643 static long int
2644 tm_diff (struct tm const *a, struct tm const *b)
2645 {
2646   /* Compute intervening leap days correctly even if year is negative.
2647      Take care to avoid int overflow in leap day calculations.  */
2648   int a4 = SHR (a->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (a->tm_year & 3);
2649   int b4 = SHR (b->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (b->tm_year & 3);
2650   int a100 = a4 / 25 - (a4 % 25 < 0);
2651   int b100 = b4 / 25 - (b4 % 25 < 0);
2652   int a400 = SHR (a100, 2);
2653   int b400 = SHR (b100, 2);
2654   int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
2655   long int ayear = a->tm_year;
2656   long int years = ayear - b->tm_year;
2657   long int days = (365 * years + intervening_leap_days
2658                    + (a->tm_yday - b->tm_yday));
2659   return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
2660                 + (a->tm_min - b->tm_min))
2661           + (a->tm_sec - b->tm_sec));
2662 }
2663 #endif /* ! HAVE_TM_GMTOFF */
2664
2665 static table const *
2666 lookup_word (parser_control const *pc, char *word)
2667 {
2668   char *p;
2669   char *q;
2670   size_t wordlen;
2671   table const *tp;
2672   bool period_found;
2673   bool abbrev;
2674
2675   /* Make it uppercase.  */
2676   for (p = word; *p; p++)
2677     {
2678       unsigned char ch = *p;
2679       if (ISLOWER (ch))
2680         *p = toupper (ch);
2681     }
2682
2683   for (tp = meridian_table; tp->name; tp++)
2684     if (strcmp (word, tp->name) == 0)
2685       return tp;
2686
2687   /* See if we have an abbreviation for a month. */
2688   wordlen = strlen (word);
2689   abbrev = wordlen == 3 || (wordlen == 4 && word[3] == '.');
2690
2691   for (tp = month_and_day_table; tp->name; tp++)
2692     if ((abbrev ? strncmp (word, tp->name, 3) : strcmp (word, tp->name)) == 0)
2693       return tp;
2694
2695   if ((tp = lookup_zone (pc, word)))
2696     return tp;
2697
2698   if (strcmp (word, dst_table[0].name) == 0)
2699     return dst_table;
2700
2701   for (tp = time_units_table; tp->name; tp++)
2702     if (strcmp (word, tp->name) == 0)
2703       return tp;
2704
2705   /* Strip off any plural and try the units table again. */
2706   if (word[wordlen - 1] == 'S')
2707     {
2708       word[wordlen - 1] = '\0';
2709       for (tp = time_units_table; tp->name; tp++)
2710         if (strcmp (word, tp->name) == 0)
2711           return tp;
2712       word[wordlen - 1] = 'S';  /* For "this" in relative_time_table.  */
2713     }
2714
2715   for (tp = relative_time_table; tp->name; tp++)
2716     if (strcmp (word, tp->name) == 0)
2717       return tp;
2718
2719   /* Military time zones. */
2720   if (wordlen == 1)
2721     for (tp = military_table; tp->name; tp++)
2722       if (word[0] == tp->name[0])
2723         return tp;
2724
2725   /* Drop out any periods and try the time zone table again. */
2726   for (period_found = false, p = q = word; (*p = *q); q++)
2727     if (*q == '.')
2728       period_found = true;
2729     else
2730       p++;
2731   if (period_found && (tp = lookup_zone (pc, word)))
2732     return tp;
2733
2734   return NULL;
2735 }
2736
2737 static int
2738 yylex (YYSTYPE *lvalp, parser_control *pc)
2739 {
2740   unsigned char c;
2741   size_t count;
2742
2743   for (;;)
2744     {
2745       while (c = *pc->input, ISSPACE (c))
2746         pc->input++;
2747
2748       if (ISDIGIT (c) || c == '-' || c == '+')
2749         {
2750           char const *p;
2751           int sign;
2752           unsigned long int value;
2753           if (c == '-' || c == '+')
2754             {
2755               sign = c == '-' ? -1 : 1;
2756               while (c = *++pc->input, ISSPACE (c))
2757                 continue;
2758               if (! ISDIGIT (c))
2759                 /* skip the '-' sign */
2760                 continue;
2761             }
2762           else
2763             sign = 0;
2764           p = pc->input;
2765           for (value = 0; ; value *= 10)
2766             {
2767               unsigned long int value1 = value + (c - '0');
2768               if (value1 < value)
2769                 return '?';
2770               value = value1;
2771               c = *++p;
2772               if (! ISDIGIT (c))
2773                 break;
2774               if (ULONG_MAX / 10 < value)
2775                 return '?';
2776             }
2777           if ((c == '.' || c == ',') && ISDIGIT (p[1]))
2778             {
2779               time_t s;
2780               int ns;
2781               int digits;
2782               unsigned long int value1;
2783
2784               /* Check for overflow when converting value to time_t.  */
2785               if (sign < 0)
2786                 {
2787                   s = - value;
2788                   if (0 < s)
2789                     return '?';
2790                   value1 = -s;
2791                 }
2792               else
2793                 {
2794                   s = value;
2795                   if (s < 0)
2796                     return '?';
2797                   value1 = s;
2798                 }
2799               if (value != value1)
2800                 return '?';
2801
2802               /* Accumulate fraction, to ns precision.  */
2803               p++;
2804               ns = *p++ - '0';
2805               for (digits = 2; digits <= LOG10_BILLION; digits++)
2806                 {
2807                   ns *= 10;
2808                   if (ISDIGIT (*p))
2809                     ns += *p++ - '0';
2810                 }
2811
2812               /* Skip excess digits, truncating toward -Infinity.  */
2813               if (sign < 0)
2814                 for (; ISDIGIT (*p); p++)
2815                   if (*p != '0')
2816                     {
2817                       ns++;
2818                       break;
2819                     }
2820               while (ISDIGIT (*p))
2821                 p++;
2822
2823               /* Adjust to the timespec convention, which is that
2824                  tv_nsec is always a positive offset even if tv_sec is
2825                  negative.  */
2826               if (sign < 0 && ns)
2827                 {
2828                   s--;
2829                   if (! (s < 0))
2830                     return '?';
2831                   ns = BILLION - ns;
2832                 }
2833
2834               lvalp->timespec.tv_sec = s;
2835               lvalp->timespec.tv_nsec = ns;
2836               pc->input = p;
2837               return sign ? tSDECIMAL_NUMBER : tUDECIMAL_NUMBER;
2838             }
2839           else
2840             {
2841               lvalp->textintval.negative = sign < 0;
2842               if (sign < 0)
2843                 {
2844                   lvalp->textintval.value = - value;
2845                   if (0 < lvalp->textintval.value)
2846                     return '?';
2847                 }
2848               else
2849                 {
2850                   lvalp->textintval.value = value;
2851                   if (lvalp->textintval.value < 0)
2852                     return '?';
2853                 }
2854               lvalp->textintval.digits = p - pc->input;
2855               pc->input = p;
2856               return sign ? tSNUMBER : tUNUMBER;
2857             }
2858         }
2859
2860       if (ISALPHA (c))
2861         {
2862           char buff[20];
2863           char *p = buff;
2864           table const *tp;
2865
2866           do
2867             {
2868               if (p < buff + sizeof buff - 1)
2869                 *p++ = c;
2870               c = *++pc->input;
2871             }
2872           while (ISALPHA (c) || c == '.');
2873
2874           *p = '\0';
2875           tp = lookup_word (pc, buff);
2876           if (! tp)
2877             return '?';
2878           lvalp->intval = tp->value;
2879           return tp->type;
2880         }
2881
2882       if (c != '(')
2883         return *pc->input++;
2884       count = 0;
2885       do
2886         {
2887           c = *pc->input++;
2888           if (c == '\0')
2889             return c;
2890           if (c == '(')
2891             count++;
2892           else if (c == ')')
2893             count--;
2894         }
2895       while (count != 0);
2896     }
2897 }
2898
2899 /* Do nothing if the parser reports an error.  */
2900 static int
2901 yyerror (parser_control *pc ATTRIBUTE_UNUSED, const char *s ATTRIBUTE_UNUSED)
2902 {
2903   return 0;
2904 }
2905
2906 /* If *TM0 is the old and *TM1 is the new value of a struct tm after
2907    passing it to mktime, return true if it's OK that mktime returned T.
2908    It's not OK if *TM0 has out-of-range members.  */
2909
2910 static bool
2911 mktime_ok (struct tm const *tm0, struct tm const *tm1, time_t t)
2912 {
2913   if (t == (time_t) -1)
2914     {
2915       /* Guard against falsely reporting an error when parsing a time
2916          stamp that happens to equal (time_t) -1, on a host that
2917          supports such a time stamp.  */
2918       tm1 = localtime (&t);
2919       if (!tm1)
2920         return false;
2921     }
2922
2923   return ! ((tm0->tm_sec ^ tm1->tm_sec)
2924             | (tm0->tm_min ^ tm1->tm_min)
2925             | (tm0->tm_hour ^ tm1->tm_hour)
2926             | (tm0->tm_mday ^ tm1->tm_mday)
2927             | (tm0->tm_mon ^ tm1->tm_mon)
2928             | (tm0->tm_year ^ tm1->tm_year));
2929 }
2930
2931 /* A reasonable upper bound for the size of ordinary TZ strings.
2932    Use heap allocation if TZ's length exceeds this.  */
2933 enum { TZBUFSIZE = 100 };
2934
2935 /* Return a copy of TZ, stored in TZBUF if it fits, and heap-allocated
2936    otherwise.  */
2937 static char *
2938 get_tz (char tzbuf[TZBUFSIZE])
2939 {
2940   char *tz = getenv ("TZ");
2941   if (tz)
2942     {
2943       size_t tzsize = strlen (tz) + 1;
2944       tz = (tzsize <= TZBUFSIZE
2945             ? memcpy (tzbuf, tz, tzsize)
2946             : xmemdup (tz, tzsize));
2947     }
2948   return tz;
2949 }
2950
2951 /* Parse a date/time string, storing the resulting time value into *RESULT.
2952    The string itself is pointed to by P.  Return true if successful.
2953    P can be an incomplete or relative time specification; if so, use
2954    *NOW as the basis for the returned time.  */
2955 bool
2956 get_date (struct timespec *result, char const *p, struct timespec const *now)
2957 {
2958   time_t Start;
2959   long int Start_ns;
2960   struct tm const *tmp;
2961   struct tm tm;
2962   struct tm tm0;
2963   parser_control pc;
2964   struct timespec gettime_buffer;
2965   unsigned char c;
2966   bool tz_was_altered = false;
2967   char *tz0 = NULL;
2968   char tz0buf[TZBUFSIZE];
2969   bool ok = true;
2970
2971   if (! now)
2972     {
2973       gettime (&gettime_buffer);
2974       now = &gettime_buffer;
2975     }
2976
2977   Start = now->tv_sec;
2978   Start_ns = now->tv_nsec;
2979
2980   tmp = localtime (&now->tv_sec);
2981   if (! tmp)
2982     return false;
2983
2984   while (c = *p, ISSPACE (c))
2985     p++;
2986
2987   if (strncmp (p, "TZ=\"", 4) == 0)
2988     {
2989       char const *tzbase = p + 4;
2990       size_t tzsize = 1;
2991       char const *s;
2992
2993       for (s = tzbase; *s; s++, tzsize++)
2994         if (*s == '\\')
2995           {
2996             s++;
2997             if (! (*s == '\\' || *s == '"'))
2998               break;
2999           }
3000         else if (*s == '"')
3001           {
3002             char *z;
3003             char *tz1;
3004             char tz1buf[TZBUFSIZE];
3005             bool large_tz = TZBUFSIZE < tzsize;
3006             bool setenv_ok;
3007             tz0 = get_tz (tz0buf);
3008             z = tz1 = large_tz ? xmalloc (tzsize) : tz1buf;
3009             for (s = tzbase; *s != '"'; s++)
3010               *z++ = *(s += *s == '\\');
3011             *z = '\0';
3012             setenv_ok = setenv ("TZ", tz1, 1) == 0;
3013             if (large_tz)
3014               free (tz1);
3015             if (!setenv_ok)
3016               goto fail;
3017             tz_was_altered = true;
3018             p = s + 1;
3019           }
3020     }
3021
3022   pc.input = p;
3023   pc.year.value = tmp->tm_year;
3024   pc.year.value += TM_YEAR_BASE;
3025   pc.year.digits = 0;
3026   pc.month = tmp->tm_mon + 1;
3027   pc.day = tmp->tm_mday;
3028   pc.hour = tmp->tm_hour;
3029   pc.minutes = tmp->tm_min;
3030   pc.seconds.tv_sec = tmp->tm_sec;
3031   pc.seconds.tv_nsec = Start_ns;
3032   tm.tm_isdst = tmp->tm_isdst;
3033
3034   pc.meridian = MER24;
3035   pc.rel_ns = 0;
3036   pc.rel_seconds = 0;
3037   pc.rel_minutes = 0;
3038   pc.rel_hour = 0;
3039   pc.rel_day = 0;
3040   pc.rel_month = 0;
3041   pc.rel_year = 0;
3042   pc.timespec_seen = false;
3043   pc.rels_seen = false;
3044   pc.dates_seen = 0;
3045   pc.days_seen = 0;
3046   pc.times_seen = 0;
3047   pc.local_zones_seen = 0;
3048   pc.dsts_seen = 0;
3049   pc.zones_seen = 0;
3050
3051 #if HAVE_STRUCT_TM_TM_ZONE
3052   pc.local_time_zone_table[0].name = tmp->tm_zone;
3053   pc.local_time_zone_table[0].type = tLOCAL_ZONE;
3054   pc.local_time_zone_table[0].value = tmp->tm_isdst;
3055   pc.local_time_zone_table[1].name = NULL;
3056
3057   /* Probe the names used in the next three calendar quarters, looking
3058      for a tm_isdst different from the one we already have.  */
3059   {
3060     int quarter;
3061     for (quarter = 1; quarter <= 3; quarter++)
3062       {
3063         time_t probe = Start + quarter * (90 * 24 * 60 * 60);
3064         struct tm const *probe_tm = localtime (&probe);
3065         if (probe_tm && probe_tm->tm_zone
3066             && probe_tm->tm_isdst != pc.local_time_zone_table[0].value)
3067           {
3068               {
3069                 pc.local_time_zone_table[1].name = probe_tm->tm_zone;
3070                 pc.local_time_zone_table[1].type = tLOCAL_ZONE;
3071                 pc.local_time_zone_table[1].value = probe_tm->tm_isdst;
3072                 pc.local_time_zone_table[2].name = NULL;
3073               }
3074             break;
3075           }
3076       }
3077   }
3078 #else
3079 #if HAVE_TZNAME
3080   {
3081 # ifndef tzname
3082     extern char *tzname[];
3083 # endif
3084     int i;
3085     for (i = 0; i < 2; i++)
3086       {
3087         pc.local_time_zone_table[i].name = tzname[i];
3088         pc.local_time_zone_table[i].type = tLOCAL_ZONE;
3089         pc.local_time_zone_table[i].value = i;
3090       }
3091     pc.local_time_zone_table[i].name = NULL;
3092   }
3093 #else
3094   pc.local_time_zone_table[0].name = NULL;
3095 #endif
3096 #endif
3097
3098   if (pc.local_time_zone_table[0].name && pc.local_time_zone_table[1].name
3099       && ! strcmp (pc.local_time_zone_table[0].name,
3100                    pc.local_time_zone_table[1].name))
3101     {
3102       /* This locale uses the same abbrevation for standard and
3103          daylight times.  So if we see that abbreviation, we don't
3104          know whether it's daylight time.  */
3105       pc.local_time_zone_table[0].value = -1;
3106       pc.local_time_zone_table[1].name = NULL;
3107     }
3108
3109   if (yyparse (&pc) != 0)
3110     goto fail;
3111
3112   if (pc.timespec_seen)
3113     *result = pc.seconds;
3114   else
3115     {
3116       if (1 < (pc.times_seen | pc.dates_seen | pc.days_seen | pc.dsts_seen
3117                | (pc.local_zones_seen + pc.zones_seen)))
3118         goto fail;
3119
3120       tm.tm_year = to_year (pc.year) - TM_YEAR_BASE;
3121       tm.tm_mon = pc.month - 1;
3122       tm.tm_mday = pc.day;
3123       if (pc.times_seen || (pc.rels_seen && ! pc.dates_seen && ! pc.days_seen))
3124         {
3125           tm.tm_hour = to_hour (pc.hour, pc.meridian);
3126           if (tm.tm_hour < 0)
3127             goto fail;
3128           tm.tm_min = pc.minutes;
3129           tm.tm_sec = pc.seconds.tv_sec;
3130         }
3131       else
3132         {
3133           tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
3134           pc.seconds.tv_nsec = 0;
3135         }
3136
3137       /* Let mktime deduce tm_isdst if we have an absolute time stamp.  */
3138       if (!pc.rels_seen)
3139         tm.tm_isdst = -1;
3140
3141       /* But if the input explicitly specifies local time with or without
3142          DST, give mktime that information.  */
3143       if (pc.local_zones_seen)
3144         tm.tm_isdst = pc.local_isdst;
3145
3146       tm0 = tm;
3147
3148       Start = mktime (&tm);
3149
3150       if (! mktime_ok (&tm0, &tm, Start))
3151         {
3152           if (! pc.zones_seen)
3153             goto fail;
3154           else
3155             {
3156               /* Guard against falsely reporting errors near the time_t
3157                  boundaries when parsing times in other time zones.  For
3158                  example, suppose the input string "1969-12-31 23:00:00 -0100",
3159                  the current time zone is 8 hours ahead of UTC, and the min
3160                  time_t value is 1970-01-01 00:00:00 UTC.  Then the min
3161                  localtime value is 1970-01-01 08:00:00, and mktime will
3162                  therefore fail on 1969-12-31 23:00:00.  To work around the
3163                  problem, set the time zone to 1 hour behind UTC temporarily
3164                  by setting TZ="XXX1:00" and try mktime again.  */
3165
3166               long int time_zone = pc.time_zone;
3167               long int abs_time_zone = time_zone < 0 ? - time_zone : time_zone;
3168               long int abs_time_zone_hour = abs_time_zone / 60;
3169               int abs_time_zone_min = abs_time_zone % 60;
3170               char tz1buf[sizeof "XXX+0:00"
3171                           + sizeof pc.time_zone * CHAR_BIT / 3];
3172               if (!tz_was_altered)
3173                 tz0 = get_tz (tz0buf);
3174               snprintf(tz1buf, sizeof(tz1buf),
3175                        "XXX%s%ld:%02d", "-" + (time_zone < 0),
3176                        abs_time_zone_hour, abs_time_zone_min);
3177               if (setenv ("TZ", tz1buf, 1) != 0)
3178                 goto fail;
3179               tz_was_altered = true;
3180               tm = tm0;
3181               Start = mktime (&tm);
3182               if (! mktime_ok (&tm0, &tm, Start))
3183                 goto fail;
3184             }
3185         }
3186
3187       if (pc.days_seen && ! pc.dates_seen)
3188         {
3189           tm.tm_mday += ((pc.day_number - tm.tm_wday + 7) % 7
3190                          + 7 * (pc.day_ordinal - (0 < pc.day_ordinal)));
3191           tm.tm_isdst = -1;
3192           Start = mktime (&tm);
3193           if (Start == (time_t) -1)
3194             goto fail;
3195         }
3196
3197       if (pc.zones_seen)
3198         {
3199           long int delta = pc.time_zone * 60;
3200           time_t t1;
3201 #ifdef HAVE_TM_GMTOFF
3202           delta -= tm.tm_gmtoff;
3203 #else
3204           time_t t = Start;
3205           struct tm const *gmt = gmtime (&t);
3206           if (! gmt)
3207             goto fail;
3208           delta -= tm_diff (&tm, gmt);
3209 #endif
3210           t1 = Start - delta;
3211           if ((Start < t1) != (delta < 0))
3212             goto fail;  /* time_t overflow */
3213           Start = t1;
3214         }
3215
3216       /* Add relative date.  */
3217       if (pc.rel_year | pc.rel_month | pc.rel_day)
3218         {
3219           int year = tm.tm_year + pc.rel_year;
3220           int month = tm.tm_mon + pc.rel_month;
3221           int day = tm.tm_mday + pc.rel_day;
3222           if (((year < tm.tm_year) ^ (pc.rel_year < 0))
3223               | ((month < tm.tm_mon) ^ (pc.rel_month < 0))
3224               | ((day < tm.tm_mday) ^ (pc.rel_day < 0)))
3225             goto fail;
3226           tm.tm_year = year;
3227           tm.tm_mon = month;
3228           tm.tm_mday = day;
3229           Start = mktime (&tm);
3230           if (Start == (time_t) -1)
3231             goto fail;
3232         }
3233
3234       /* Add relative hours, minutes, and seconds.  On hosts that support
3235          leap seconds, ignore the possibility of leap seconds; e.g.,
3236          "+ 10 minutes" adds 600 seconds, even if one of them is a
3237          leap second.  Typically this is not what the user wants, but it's
3238          too hard to do it the other way, because the time zone indicator
3239          must be applied before relative times, and if mktime is applied
3240          again the time zone will be lost.  */
3241       {
3242         long int sum_ns = pc.seconds.tv_nsec + pc.rel_ns;
3243         long int normalized_ns = (sum_ns % BILLION + BILLION) % BILLION;
3244         time_t t0 = Start;
3245         long int d1 = 60 * 60 * pc.rel_hour;
3246         time_t t1 = t0 + d1;
3247         long int d2 = 60 * pc.rel_minutes;
3248         time_t t2 = t1 + d2;
3249         long int d3 = pc.rel_seconds;
3250         time_t t3 = t2 + d3;
3251         long int d4 = (sum_ns - normalized_ns) / BILLION;
3252         time_t t4 = t3 + d4;
3253
3254         if ((d1 / (60 * 60) ^ pc.rel_hour)
3255             | (d2 / 60 ^ pc.rel_minutes)
3256             | ((t1 < t0) ^ (d1 < 0))
3257             | ((t2 < t1) ^ (d2 < 0))
3258             | ((t3 < t2) ^ (d3 < 0))
3259             | ((t4 < t3) ^ (d4 < 0)))
3260           goto fail;
3261
3262         result->tv_sec = t4;
3263         result->tv_nsec = normalized_ns;
3264       }
3265     }
3266
3267   goto done;
3268
3269  fail:
3270   ok = false;
3271  done:
3272   if (tz_was_altered)
3273     ok &= (tz0 ? setenv("TZ", tz0, 1) : (unsetenv("TZ"), 0)) == 0;
3274   if (tz0 != tz0buf)
3275     free (tz0);
3276   return ok;
3277 }
3278
3279 #if TEST
3280
3281 int
3282 main(int argc, char **argv)
3283 {
3284   char buff[BUFSIZ];
3285   int cmd = 0;
3286
3287   if (argc > 1) {
3288     int i = 1;
3289     buff[0] = '\0';
3290     while (i < argc) {
3291       if (i > 1)
3292         strlcat(buff, " ", BUFSIZ);
3293       strlcat(buff, argv[i++], BUFSIZ);
3294     }
3295     cmd++;
3296     goto once;
3297   }
3298
3299   printf("Enter date, or blank line to exit.\n> ");
3300   fflush (stdout);
3301
3302   buff[BUFSIZ - 1] = '\0';
3303   while (fgets(buff, BUFSIZ - 1, stdin) && buff[0] &&
3304          buff[0] != '\r' && buff[0] != '\n')
3305     {
3306       struct timespec d;
3307       struct tm const *tm;
3308  once:
3309       if (! get_date (&d, buff, NULL))
3310         printf ("Bad format - couldn't convert.\n");
3311       else if (! (tm = localtime (&d.tv_sec)))
3312         {
3313           printf ("localtime (%lld) failed\n", (long long)d.tv_sec);
3314         }
3315       else
3316         {
3317           int ns = d.tv_nsec;
3318           printf ("%13lld =\t%04ld-%02d-%02d %02d:%02d:%02d.%09d\n",
3319                   (long long)d.tv_sec, (long)tm->tm_year + 1900,
3320                   tm->tm_mon + 1, tm->tm_mday,
3321                   tm->tm_hour, tm->tm_min, tm->tm_sec, ns);
3322         }
3323       if (cmd)
3324         return 0;
3325       printf ("> ");
3326       fflush (stdout);
3327     }
3328   return 0;
3329 }
3330 #endif /* TEST */