external/gpl2/xcvs/dist/lib/getdate.c

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