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