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