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