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