|
|
/* A Bison parser, made by GNU Bison 1.875d. */
|
|
|
|
|
|
/* Skeleton parser for Yacc-like parsing with Bison,
|
|
|
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
|
any later version.
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
along with this program; if not, write to the Free Software
|
|
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
|
|
/* As a special exception, when this file is copied by Bison into a
|
|
|
Bison output file, you may use that output file without restriction.
|
|
|
This special exception was added by the Free Software Foundation
|
|
|
in version 1.24 of Bison. */
|
|
|
|
|
|
/* Written by Richard Stallman by simplifying the original so called
|
|
|
``semantic'' parser. */
|
|
|
|
|
|
/* All symbols defined below should begin with yy or YY, to avoid
|
|
|
infringing on user name space. This should be done even for local
|
|
|
variables, as they might otherwise be expanded by user macros.
|
|
|
There are some unavoidable exceptions within include files to
|
|
|
define necessary library symbols; they are noted "INFRINGES ON
|
|
|
USER NAME SPACE" below. */
|
|
|
|
|
|
/* Identify Bison output. */
|
|
|
#define YYBISON 1
|
|
|
|
|
|
/* Skeleton name. */
|
|
|
#define YYSKELETON_NAME "yacc.c"
|
|
|
|
|
|
/* Pure parsers. */
|
|
|
#define YYPURE 0
|
|
|
|
|
|
/* Using locations. */
|
|
|
#define YYLSP_NEEDED 0
|
|
|
|
|
|
|
|
|
|
|
|
/* Tokens. */
|
|
|
#ifndef YYTOKENTYPE
|
|
|
# define YYTOKENTYPE
|
|
|
/* Put the tokens into the symbol table, so that GDB and other debuggers
|
|
|
know about them. */
|
|
|
enum yytokentype {
|
|
|
tDAY = 258,
|
|
|
tDAYZONE = 259,
|
|
|
tMERIDIAN = 260,
|
|
|
tMONTH = 261,
|
|
|
tMONTH_UNIT = 262,
|
|
|
tSEC_UNIT = 263,
|
|
|
tSNUMBER = 264,
|
|
|
tUNUMBER = 265,
|
|
|
tZONE = 266
|
|
|
};
|
|
|
#endif
|
|
|
#define tDAY 258
|
|
|
#define tDAYZONE 259
|
|
|
#define tMERIDIAN 260
|
|
|
#define tMONTH 261
|
|
|
#define tMONTH_UNIT 262
|
|
|
#define tSEC_UNIT 263
|
|
|
#define tSNUMBER 264
|
|
|
#define tUNUMBER 265
|
|
|
#define tZONE 266
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Copy the first part of user declarations. */
|
|
|
#line 1 "parsedate.y"
|
|
|
|
|
|
/* $Revision: 1.16 $
|
|
|
**
|
|
|
** Originally written by Steven M. Bellovin <smb@research.att.com> while
|
|
|
** at the University of North Carolina at Chapel Hill. Later tweaked by
|
|
|
** a couple of people on Usenet. Completely overhauled by Rich $alz
|
|
|
** <rsalz@osf.org> and Jim Berets <jberets@bbn.com> in August, 1990.
|
|
|
** Further revised (removed obsolete constructs and cleaned up timezone
|
|
|
** names) in August, 1991, by Rich. Paul Eggert <eggert@twinsun.com>
|
|
|
** helped in September, 1992.
|
|
|
**
|
|
|
** This grammar has six shift/reduce conflicts.
|
|
|
**
|
|
|
** This code is in the public domain and has no copyright.
|
|
|
*/
|
|
|
/* SUPPRESS 530 *//* Empty body for statement */
|
|
|
/* SUPPRESS 593 on yyerrlab *//* Label was not used */
|
|
|
/* SUPPRESS 593 on yynewstate *//* Label was not used */
|
|
|
/* SUPPRESS 595 on yypvt *//* Automatic variable may be used before set */
|
|
|
#include <stdio.h>
|
|
|
#include <stdlib.h>
|
|
|
#include <sys/types.h>
|
|
|
#include <ctype.h>
|
|
|
#include <time.h>
|
|
|
#include <string.h>
|
|
|
|
|
|
int date_lex();
|
|
|
|
|
|
#define yyparse date_parse
|
|
|
#define yylex date_lex
|
|
|
#define yyerror date_error
|
|
|
|
|
|
|
|
|
/* See the LeapYears table in Convert. */
|
|
|
#define EPOCH 1970
|
|
|
#define END_OF_TIME 2038
|
|
|
/* Constants for general time calculations. */
|
|
|
#define DST_OFFSET 1
|
|
|
#define SECSPERDAY (24L * 60L * 60L)
|
|
|
/* Readability for TABLE stuff. */
|
|
|
#define HOUR(x) (x * 60)
|
|
|
|
|
|
#define LPAREN '('
|
|
|
#define RPAREN ')'
|
|
|
#define IS7BIT(x) ((unsigned int)(x) < 0200)
|
|
|
|
|
|
#define SIZEOF(array) ((int)(sizeof array / sizeof array[0]))
|
|
|
#define ENDOF(array) (&array[SIZEOF(array)])
|
|
|
|
|
|
|
|
|
/*
|
|
|
** An entry in the lexical lookup table.
|
|
|
*/
|
|
|
typedef struct _TABLE {
|
|
|
char *name;
|
|
|
int type;
|
|
|
time_t value;
|
|
|
} TABLE;
|
|
|
|
|
|
/*
|
|
|
** Daylight-savings mode: on, off, or not yet known.
|
|
|
*/
|
|
|
typedef enum _DSTMODE {
|
|
|
DSTon, DSToff, DSTmaybe
|
|
|
} DSTMODE;
|
|
|
|
|
|
/*
|
|
|
** Meridian: am, pm, or 24-hour style.
|
|
|
*/
|
|
|
typedef enum _MERIDIAN {
|
|
|
MERam, MERpm, MER24
|
|
|
} MERIDIAN;
|
|
|
|
|
|
|
|
|
/*
|
|
|
** Global variables. We could get rid of most of them by using a yacc
|
|
|
** union, but this is more efficient. (This routine predates the
|
|
|
** yacc %union construct.)
|
|
|
*/
|
|
|
static char *yyInput;
|
|
|
static DSTMODE yyDSTmode;
|
|
|
static int yyHaveDate;
|
|
|
static int yyHaveRel;
|
|
|
static int yyHaveTime;
|
|
|
static time_t yyTimezone;
|
|
|
static time_t yyDay;
|
|
|
static time_t yyHour;
|
|
|
static time_t yyMinutes;
|
|
|
static time_t yyMonth;
|
|
|
static time_t yySeconds;
|
|
|
static time_t yyYear;
|
|
|
static MERIDIAN yyMeridian;
|
|
|
static time_t yyRelMonth;
|
|
|
static time_t yyRelSeconds;
|
|
|
|
|
|
|
|
|
extern struct tm *localtime();
|
|
|
static void date_error();
|
|
|
|
|
|
|
|
|
/* Enabling traces. */
|
|
|
#ifndef YYDEBUG
|
|
|
# define YYDEBUG 0
|
|
|
#endif
|
|
|
|
|
|
/* Enabling verbose error messages. */
|
|
|
#ifdef YYERROR_VERBOSE
|
|
|
# undef YYERROR_VERBOSE
|
|
|
# define YYERROR_VERBOSE 1
|
|
|
#else
|
|
|
# define YYERROR_VERBOSE 0
|
|
|
#endif
|
|
|
|
|
|
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
|
|
|
#line 101 "parsedate.y"
|
|
|
typedef union YYSTYPE {
|
|
|
time_t Number;
|
|
|
enum _MERIDIAN Meridian;
|
|
|
} YYSTYPE;
|
|
|
/* Line 191 of yacc.c. */
|
|
|
#line 203 "parsedate.c"
|
|
|
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
|
|
|
# define YYSTYPE_IS_DECLARED 1
|
|
|
# define YYSTYPE_IS_TRIVIAL 1
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/* Copy the second part of user declarations. */
|
|
|
|
|
|
|
|
|
/* Line 214 of yacc.c. */
|
|
|
#line 215 "parsedate.c"
|
|
|
|
|
|
#if ! defined (yyoverflow) || YYERROR_VERBOSE
|
|
|
|
|
|
# ifndef YYFREE
|
|
|
# define YYFREE free
|
|
|
# endif
|
|
|
# ifndef YYMALLOC
|
|
|
# define YYMALLOC malloc
|
|
|
# endif
|
|
|
|
|
|
/* The parser invokes alloca or malloc; define the necessary symbols. */
|
|
|
|
|
|
# ifdef YYSTACK_USE_ALLOCA
|
|
|
# if YYSTACK_USE_ALLOCA
|
|
|
# define YYSTACK_ALLOC alloca
|
|
|
# endif
|
|
|
# else
|
|
|
# if defined (alloca) || defined (_ALLOCA_H)
|
|
|
# define YYSTACK_ALLOC alloca
|
|
|
# else
|
|
|
# ifdef __GNUC__
|
|
|
# define YYSTACK_ALLOC __builtin_alloca
|
|
|
# endif
|
|
|
# endif
|
|
|
# endif
|
|
|
|
|
|
# ifdef YYSTACK_ALLOC
|
|
|
/* Pacify GCC's `empty if-body' warning. */
|
|
|
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
|
|
|
# else
|
|
|
# if defined (__STDC__) || defined (__cplusplus)
|
|
|
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
|
|
|
# define YYSIZE_T size_t
|
|
|
# endif
|
|
|
# define YYSTACK_ALLOC YYMALLOC
|
|
|
# define YYSTACK_FREE YYFREE
|
|
|
# endif
|
|
|
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
|
|
|
|
|
|
|
|
|
#if (! defined (yyoverflow) \
|
|
|
&& (! defined (__cplusplus) \
|
|
|
|| (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
|
|
|
|
|
|
/* A type that is properly aligned for any stack member. */
|
|
|
union yyalloc
|
|
|
{
|
|
|
short int yyss;
|
|
|
YYSTYPE yyvs;
|
|
|
};
|
|
|
|
|
|
/* The size of the maximum gap between one aligned stack and the next. */
|
|
|
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
|
|
|
|
|
|
/* The size of an array large to enough to hold all stacks, each with
|
|
|
N elements. */
|
|
|
# define YYSTACK_BYTES(N) \
|
|
|
((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
|
|
|
+ YYSTACK_GAP_MAXIMUM)
|
|
|
|
|
|
/* Copy COUNT objects from FROM to TO. The source and destination do
|
|
|
not overlap. */
|
|
|
# ifndef YYCOPY
|
|
|
# if defined (__GNUC__) && 1 < __GNUC__
|
|
|
# define YYCOPY(To, From, Count) \
|
|
|
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
|
|
|
# else
|
|
|
# define YYCOPY(To, From, Count) \
|
|
|
do \
|
|
|
{ \
|
|
|
register YYSIZE_T yyi; \
|
|
|
for (yyi = 0; yyi < (Count); yyi++) \
|
|
|
(To)[yyi] = (From)[yyi]; \
|
|
|
} \
|
|
|
while (0)
|
|
|
# endif
|
|
|
# endif
|
|
|
|
|
|
/* Relocate STACK from its old location to the new one. The
|
|
|
local variables YYSIZE and YYSTACKSIZE give the old and new number of
|
|
|
elements in the stack, and YYPTR gives the new location of the
|
|
|
stack. Advance YYPTR to a properly aligned location for the next
|
|
|
stack. */
|
|
|
# define YYSTACK_RELOCATE(Stack) \
|
|
|
do \
|
|
|
{ \
|
|
|
YYSIZE_T yynewbytes; \
|
|
|
YYCOPY (&yyptr->Stack, Stack, yysize); \
|
|
|
Stack = &yyptr->Stack; \
|
|
|
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
|
|
|
yyptr += yynewbytes / sizeof (*yyptr); \
|
|
|
} \
|
|
|
while (0)
|
|
|
|
|
|
#endif
|
|
|
|
|
|
#if defined (__STDC__) || defined (__cplusplus)
|
|
|
typedef signed char yysigned_char;
|
|
|
#else
|
|
|
typedef short int yysigned_char;
|
|
|
#endif
|
|
|
|
|
|
/* YYFINAL -- State number of the termination state. */
|
|
|
#define YYFINAL 2
|
|
|
/* YYLAST -- Last index in YYTABLE. */
|
|
|
#define YYLAST 40
|
|
|
|
|
|
/* YYNTOKENS -- Number of terminals. */
|
|
|
#define YYNTOKENS 15
|
|
|
/* YYNNTS -- Number of nonterminals. */
|
|
|
#define YYNNTS 9
|
|
|
/* YYNRULES -- Number of rules. */
|
|
|
#define YYNRULES 30
|
|
|
/* YYNRULES -- Number of states. */
|
|
|
#define YYNSTATES 44
|
|
|
|
|
|
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
|
|
|
#define YYUNDEFTOK 2
|
|
|
#define YYMAXUTOK 266
|
|
|
|
|
|
#define YYTRANSLATE(YYX) \
|
|
|
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
|
|
|
|
|
|
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
|
|
|
static const unsigned char yytranslate[] =
|
|
|
{
|
|
|
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 14, 2, 2, 13, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 12, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
|
|
|
5, 6, 7, 8, 9, 10, 11
|
|
|
};
|
|
|
|
|
|
#if YYDEBUG
|
|
|
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
|
|
|
YYRHS. */
|
|
|
static const unsigned char yyprhs[] =
|
|
|
{
|
|
|
0, 0, 3, 4, 7, 9, 12, 14, 16, 19,
|
|
|
24, 29, 36, 43, 45, 47, 50, 52, 54, 58,
|
|
|
64, 67, 72, 75, 79, 85, 88, 91, 94, 97,
|
|
|
98
|
|
|
};
|
|
|
|
|
|
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
|
|
|
static const yysigned_char yyrhs[] =
|
|
|
{
|
|
|
16, 0, -1, -1, 16, 17, -1, 18, -1, 18,
|
|
|
19, -1, 21, -1, 22, -1, 10, 23, -1, 10,
|
|
|
12, 10, 23, -1, 10, 12, 10, 20, -1, 10,
|
|
|
12, 10, 12, 10, 23, -1, 10, 12, 10, 12,
|
|
|
10, 20, -1, 11, -1, 4, -1, 11, 20, -1,
|
|
|
20, -1, 9, -1, 10, 13, 10, -1, 10, 13,
|
|
|
10, 13, 10, -1, 6, 10, -1, 6, 10, 14,
|
|
|
10, -1, 10, 6, -1, 10, 6, 10, -1, 3,
|
|
|
14, 10, 6, 10, -1, 9, 8, -1, 10, 8,
|
|
|
-1, 9, 7, -1, 10, 7, -1, -1, 5, -1
|
|
|
};
|
|
|
|
|
|
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
|
|
|
static const unsigned short int yyrline[] =
|
|
|
{
|
|
|
0, 115, 115, 116, 119, 128, 132, 135, 140, 152,
|
|
|
158, 165, 171, 181, 185, 189, 197, 203, 224, 228,
|
|
|
240, 244, 249, 253, 258, 265, 268, 271, 274, 279,
|
|
|
282
|
|
|
};
|
|
|
#endif
|
|
|
|
|
|
#if YYDEBUG || YYERROR_VERBOSE
|
|
|
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
|
|
|
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
|
|
|
static const char *const yytname[] =
|
|
|
{
|
|
|
"$end", "error", "$undefined", "tDAY", "tDAYZONE", "tMERIDIAN",
|
|
|
"tMONTH", "tMONTH_UNIT", "tSEC_UNIT", "tSNUMBER", "tUNUMBER", "tZONE",
|
|
|
"':'", "'/'", "','", "$accept", "spec", "item", "time", "zone",
|
|
|
"numzone", "date", "rel", "o_merid", 0
|
|
|
};
|
|
|
#endif
|
|
|
|
|
|
# ifdef YYPRINT
|
|
|
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
|
|
|
token YYLEX-NUM. */
|
|
|
static const unsigned short int yytoknum[] =
|
|
|
{
|
|
|
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
|
|
|
265, 266, 58, 47, 44
|
|
|
};
|
|
|
# endif
|
|
|
|
|
|
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
|
|
|
static const unsigned char yyr1[] =
|
|
|
{
|
|
|
0, 15, 16, 16, 17, 17, 17, 17, 18, 18,
|
|
|
18, 18, 18, 19, 19, 19, 19, 20, 21, 21,
|
|
|
21, 21, 21, 21, 21, 22, 22, 22, 22, 23,
|
|
|
23
|
|
|
};
|
|
|
|
|
|
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
|
|
|
static const unsigned char yyr2[] =
|
|
|
{
|
|
|
0, 2, 0, 2, 1, 2, 1, 1, 2, 4,
|
|
|
4, 6, 6, 1, 1, 2, 1, 1, 3, 5,
|
|
|
2, 4, 2, 3, 5, 2, 2, 2, 2, 0,
|
|
|
1
|
|
|
};
|
|
|
|
|
|
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
|
|
|
STATE-NUM when YYTABLE doesn't specify something else to do. Zero
|
|
|
means the default is an error. */
|
|
|
static const unsigned char yydefact[] =
|
|
|
{
|
|
|
2, 0, 1, 0, 0, 0, 29, 3, 4, 6,
|
|
|
7, 0, 20, 27, 25, 30, 22, 28, 26, 0,
|
|
|
0, 8, 14, 17, 13, 5, 16, 0, 0, 23,
|
|
|
29, 18, 15, 0, 21, 0, 10, 9, 0, 24,
|
|
|
29, 19, 12, 11
|
|
|
};
|
|
|
|
|
|
/* YYDEFGOTO[NTERM-NUM]. */
|
|
|
static const yysigned_char yydefgoto[] =
|
|
|
{
|
|
|
-1, 1, 7, 8, 25, 26, 9, 10, 21
|
|
|
};
|
|
|
|
|
|
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
|
|
|
STATE-NUM. */
|
|
|
#define YYPACT_NINF -29
|
|
|
static const yysigned_char yypact[] =
|
|
|
{
|
|
|
-29, 1, -29, -11, 11, 20, 12, -29, 4, -29,
|
|
|
-29, 13, 16, -29, -29, -29, 21, -29, -29, 22,
|
|
|
23, -29, -29, -29, 5, -29, -29, 28, 25, -29,
|
|
|
17, 24, -29, 26, -29, 29, -29, -29, 30, -29,
|
|
|
0, -29, -29, -29
|
|
|
};
|
|
|
|
|
|
/* YYPGOTO[NTERM-NUM]. */
|
|
|
static const yysigned_char yypgoto[] =
|
|
|
{
|
|
|
-29, -29, -29, -29, -29, -24, -29, -29, -28
|
|
|
};
|
|
|
|
|
|
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
|
|
|
positive, shift that token. If negative, reduce the rule which
|
|
|
number is the opposite. If zero, do what YYDEFACT says.
|
|
|
If YYTABLE_NINF, syntax error. */
|
|
|
#define YYTABLE_NINF -1
|
|
|
static const unsigned char yytable[] =
|
|
|
{
|
|
|
32, 2, 37, 11, 3, 15, 36, 4, 22, 23,
|
|
|
5, 6, 43, 23, 23, 24, 42, 15, 16, 17,
|
|
|
18, 12, 15, 27, 19, 20, 23, 13, 14, 35,
|
|
|
28, 29, 30, 31, 33, 34, 39, 38, 0, 40,
|
|
|
41
|
|
|
};
|
|
|
|
|
|
static const yysigned_char yycheck[] =
|
|
|
{
|
|
|
24, 0, 30, 14, 3, 5, 30, 6, 4, 9,
|
|
|
9, 10, 40, 9, 9, 11, 40, 5, 6, 7,
|
|
|
8, 10, 5, 10, 12, 13, 9, 7, 8, 12,
|
|
|
14, 10, 10, 10, 6, 10, 10, 13, -1, 10,
|
|
|
10
|
|
|
};
|
|
|
|
|
|
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
|
|
|
symbol of state STATE-NUM. */
|
|
|
static const unsigned char yystos[] =
|
|
|
{
|
|
|
0, 16, 0, 3, 6, 9, 10, 17, 18, 21,
|
|
|
22, 14, 10, 7, 8, 5, 6, 7, 8, 12,
|
|
|
13, 23, 4, 9, 11, 19, 20, 10, 14, 10,
|
|
|
10, 10, 20, 6, 10, 12, 20, 23, 13, 10,
|
|
|
10, 10, 20, 23
|
|
|
};
|
|
|
|
|
|
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
|
|
|
# define YYSIZE_T __SIZE_TYPE__
|
|
|
#endif
|
|
|
#if ! defined (YYSIZE_T) && defined (size_t)
|
|
|
# define YYSIZE_T size_t
|
|
|
#endif
|
|
|
#if ! defined (YYSIZE_T)
|
|
|
# if defined (__STDC__) || defined (__cplusplus)
|
|
|
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
|
|
|
# define YYSIZE_T size_t
|
|
|
# endif
|
|
|
#endif
|
|
|
#if ! defined (YYSIZE_T)
|
|
|
# define YYSIZE_T unsigned int
|
|
|
#endif
|
|
|
|
|
|
#define yyerrok (yyerrstatus = 0)
|
|
|
#define yyclearin (yychar = YYEMPTY)
|
|
|
#define YYEMPTY (-2)
|
|
|
#define YYEOF 0
|
|
|
|
|
|
#define YYACCEPT goto yyacceptlab
|
|
|
#define YYABORT goto yyabortlab
|
|
|
#define YYERROR goto yyerrorlab
|
|
|
|
|
|
|
|
|
/* Like YYERROR except do call yyerror. This remains here temporarily
|
|
|
to ease the transition to the new meaning of YYERROR, for GCC.
|
|
|
Once GCC version 2 has supplanted version 1, this can go. */
|
|
|
|
|
|
#define YYFAIL goto yyerrlab
|
|
|
|
|
|
#define YYRECOVERING() (!!yyerrstatus)
|
|
|
|
|
|
#define YYBACKUP(Token, Value) \
|
|
|
do \
|
|
|
if (yychar == YYEMPTY && yylen == 1) \
|
|
|
{ \
|
|
|
yychar = (Token); \
|
|
|
yylval = (Value); \
|
|
|
yytoken = YYTRANSLATE (yychar); \
|
|
|
YYPOPSTACK; \
|
|
|
goto yybackup; \
|
|
|
} \
|
|
|
else \
|
|
|
{ \
|
|
|
yyerror ("syntax error: cannot back up");\
|
|
|
YYERROR; \
|
|
|
} \
|
|
|
while (0)
|
|
|
|
|
|
#define YYTERROR 1
|
|
|
#define YYERRCODE 256
|
|
|
|
|
|
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
|
|
|
are run). */
|
|
|
|
|
|
#ifndef YYLLOC_DEFAULT
|
|
|
# define YYLLOC_DEFAULT(Current, Rhs, N) \
|
|
|
((Current).first_line = (Rhs)[1].first_line, \
|
|
|
(Current).first_column = (Rhs)[1].first_column, \
|
|
|
(Current).last_line = (Rhs)[N].last_line, \
|
|
|
(Current).last_column = (Rhs)[N].last_column)
|
|
|
#endif
|
|
|
|
|
|
/* YYLEX -- calling `yylex' with the right arguments. */
|
|
|
|
|
|
#ifdef YYLEX_PARAM
|
|
|
# define YYLEX yylex (YYLEX_PARAM)
|
|
|
#else
|
|
|
# define YYLEX yylex ()
|
|
|
#endif
|
|
|
|
|
|
/* Enable debugging if requested. */
|
|
|
#if YYDEBUG
|
|
|
|
|
|
# ifndef YYFPRINTF
|
|
|
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
|
|
|
# define YYFPRINTF fprintf
|
|
|
# endif
|
|
|
|
|
|
# define YYDPRINTF(Args) \
|
|
|
do { \
|
|
|
if (yydebug) \
|
|
|
YYFPRINTF Args; \
|
|
|
} while (0)
|
|
|
|
|
|
# define YYDSYMPRINT(Args) \
|
|
|
do { \
|
|
|
if (yydebug) \
|
|
|
yysymprint Args; \
|
|
|
} while (0)
|
|
|
|
|
|
# define YYDSYMPRINTF(Title, Token, Value, Location) \
|
|
|
do { \
|
|
|
if (yydebug) \
|
|
|
{ \
|
|
|
YYFPRINTF (stderr, "%s ", Title); \
|
|
|
yysymprint (stderr, \
|
|
|
Token, Value); \
|
|
|
YYFPRINTF (stderr, "\n"); \
|
|
|
} \
|
|
|
} while (0)
|
|
|
|
|
|
/*------------------------------------------------------------------.
|
|
|
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
|
|
|
| TOP (included). |
|
|
|
`------------------------------------------------------------------*/
|
|
|
|
|
|
#if defined (__STDC__) || defined (__cplusplus)
|
|
|
static void
|
|
|
yy_stack_print (short int *bottom, short int *top)
|
|
|
#else
|
|
|
static void
|
|
|
yy_stack_print (bottom, top)
|
|
|
short int *bottom;
|
|
|
short int *top;
|
|
|
#endif
|
|
|
{
|
|
|
YYFPRINTF (stderr, "Stack now");
|
|
|
for (/* Nothing. */; bottom <= top; ++bottom)
|
|
|
YYFPRINTF (stderr, " %d", *bottom);
|
|
|
YYFPRINTF (stderr, "\n");
|
|
|
}
|
|
|
|
|
|
# define YY_STACK_PRINT(Bottom, Top) \
|
|
|
do { \
|
|
|
if (yydebug) \
|
|
|
yy_stack_print ((Bottom), (Top)); \
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
/*------------------------------------------------.
|
|
|
| Report that the YYRULE is going to be reduced. |
|
|
|
`------------------------------------------------*/
|
|
|
|
|
|
#if defined (__STDC__) || defined (__cplusplus)
|
|
|
static void
|
|
|
yy_reduce_print (int yyrule)
|
|
|
#else
|
|
|
static void
|
|
|
yy_reduce_print (yyrule)
|
|
|
int yyrule;
|
|
|
#endif
|
|
|
{
|
|
|
int yyi;
|
|
|
unsigned int yylno = yyrline[yyrule];
|
|
|
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
|
|
|
yyrule - 1, yylno);
|
|
|
/* Print the symbols being reduced, and their result. */
|
|
|
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
|
|
|
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
|
|
|
YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
|
|
|
}
|
|
|
|
|
|
# define YY_REDUCE_PRINT(Rule) \
|
|
|
do { \
|
|
|
if (yydebug) \
|
|
|
yy_reduce_print (Rule); \
|
|
|
} while (0)
|
|
|
|
|
|
/* Nonzero means print parse trace. It is left uninitialized so that
|
|
|
multiple parsers can coexist. */
|
|
|
int yydebug;
|
|
|
#else /* !YYDEBUG */
|
|
|
# define YYDPRINTF(Args)
|
|
|
# define YYDSYMPRINT(Args)
|
|
|
# define YYDSYMPRINTF(Title, Token, Value, Location)
|
|
|
# define YY_STACK_PRINT(Bottom, Top)
|
|
|
# define YY_REDUCE_PRINT(Rule)
|
|
|
#endif /* !YYDEBUG */
|
|
|
|
|
|
|
|
|
/* YYINITDEPTH -- initial size of the parser's stacks. */
|
|
|
#ifndef YYINITDEPTH
|
|
|
# define YYINITDEPTH 200
|
|
|
#endif
|
|
|
|
|
|
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
|
|
|
if the built-in stack extension method is used).
|
|
|
|
|
|
Do not make this value too large; the results are undefined if
|
|
|
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
|
|
|
evaluated with infinite-precision integer arithmetic. */
|
|
|
|
|
|
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
|
|
|
# undef YYMAXDEPTH
|
|
|
#endif
|
|
|
|
|
|
#ifndef YYMAXDEPTH
|
|
|
# define YYMAXDEPTH 10000
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if YYERROR_VERBOSE
|
|
|
|
|
|
# ifndef yystrlen
|
|
|
# if defined (__GLIBC__) && defined (_STRING_H)
|
|
|
# define yystrlen strlen
|
|
|
# else
|
|
|
/* Return the length of YYSTR. */
|
|
|
static YYSIZE_T
|
|
|
# if defined (__STDC__) || defined (__cplusplus)
|
|
|
yystrlen (const char *yystr)
|
|
|
# else
|
|
|
yystrlen (yystr)
|
|
|
const char *yystr;
|
|
|
# endif
|
|
|
{
|
|
|
register const char *yys = yystr;
|
|
|
|
|
|
while (*yys++ != '\0')
|
|
|
continue;
|
|
|
|
|
|
return yys - yystr - 1;
|
|
|
}
|
|
|
# endif
|
|
|
# endif
|
|
|
|
|
|
# ifndef yystpcpy
|
|
|
# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
|
|
|
# define yystpcpy stpcpy
|
|
|
# else
|
|
|
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
|
|
|
YYDEST. */
|
|
|
static char *
|
|
|
# if defined (__STDC__) || defined (__cplusplus)
|
|
|
yystpcpy (char *yydest, const char *yysrc)
|
|
|
# else
|
|
|
yystpcpy (yydest, yysrc)
|
|
|
char *yydest;
|
|
|
const char *yysrc;
|
|
|
# endif
|
|
|
{
|
|
|
register char *yyd = yydest;
|
|
|
register const char *yys = yysrc;
|
|
|
|
|
|
while ((*yyd++ = *yys++) != '\0')
|
|
|
continue;
|
|
|
|
|
|
return yyd - 1;
|
|
|
}
|
|
|
# endif
|
|
|
# endif
|
|
|
|
|
|
#endif /* !YYERROR_VERBOSE */
|
|
|
|
|
|
|
|
|
|
|
|
#if YYDEBUG
|
|
|
/*--------------------------------.
|
|
|
| Print this symbol on YYOUTPUT. |
|
|
|
`--------------------------------*/
|
|
|
|
|
|
#if defined (__STDC__) || defined (__cplusplus)
|
|
|
static void
|
|
|
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
|
|
|
#else
|
|
|
static void
|
|
|
yysymprint (yyoutput, yytype, yyvaluep)
|
|
|
FILE *yyoutput;
|
|
|
int yytype;
|
|
|
YYSTYPE *yyvaluep;
|
|
|
#endif
|
|
|
{
|
|
|
/* Pacify ``unused variable'' warnings. */
|
|
|
(void) yyvaluep;
|
|
|
|
|
|
if (yytype < YYNTOKENS)
|
|
|
{
|
|
|
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
|
|
|
# ifdef YYPRINT
|
|
|
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
|
|
|
# endif
|
|
|
}
|
|
|
else
|
|
|
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
|
|
|
|
|
|
switch (yytype)
|
|
|
{
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
YYFPRINTF (yyoutput, ")");
|
|
|
}
|
|
|
|
|
|
#endif /* ! YYDEBUG */
|
|
|
/*-----------------------------------------------.
|
|
|
| Release the memory associated to this symbol. |
|
|
|
`-----------------------------------------------*/
|
|
|
|
|
|
#if defined (__STDC__) || defined (__cplusplus)
|
|
|
static void
|
|
|
yydestruct (int yytype, YYSTYPE *yyvaluep)
|
|
|
#else
|
|
|
static void
|
|
|
yydestruct (yytype, yyvaluep)
|
|
|
int yytype;
|
|
|
YYSTYPE *yyvaluep;
|
|
|
#endif
|
|
|
{
|
|
|
/* Pacify ``unused variable'' warnings. */
|
|
|
(void) yyvaluep;
|
|
|
|
|
|
switch (yytype)
|
|
|
{
|
|
|
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/* Prevent warnings from -Wmissing-prototypes. */
|
|
|
|
|
|
#ifdef YYPARSE_PARAM
|
|
|
# if defined (__STDC__) || defined (__cplusplus)
|
|
|
int yyparse (void *YYPARSE_PARAM);
|
|
|
# else
|
|
|
int yyparse ();
|
|
|
# endif
|
|
|
#else /* ! YYPARSE_PARAM */
|
|
|
#if defined (__STDC__) || defined (__cplusplus)
|
|
|
int yyparse (void);
|
|
|
#else
|
|
|
int yyparse ();
|
|
|
#endif
|
|
|
#endif /* ! YYPARSE_PARAM */
|
|
|
|
|
|
|
|
|
|
|
|
/* The lookahead symbol. */
|
|
|
int yychar;
|
|
|
|
|
|
/* The semantic value of the lookahead symbol. */
|
|
|
YYSTYPE yylval;
|
|
|
|
|
|
/* Number of syntax errors so far. */
|
|
|
int yynerrs;
|
|
|
|
|
|
|
|
|
|
|
|
/*----------.
|
|
|
| yyparse. |
|
|
|
`----------*/
|
|
|
|
|
|
#ifdef YYPARSE_PARAM
|
|
|
# if defined (__STDC__) || defined (__cplusplus)
|
|
|
int yyparse (void *YYPARSE_PARAM)
|
|
|
# else
|
|
|
int yyparse (YYPARSE_PARAM)
|
|
|
void *YYPARSE_PARAM;
|
|
|
# endif
|
|
|
#else /* ! YYPARSE_PARAM */
|
|
|
#if defined (__STDC__) || defined (__cplusplus)
|
|
|
int
|
|
|
yyparse (void)
|
|
|
#else
|
|
|
int
|
|
|
yyparse ()
|
|
|
|
|
|
#endif
|
|
|
#endif
|
|
|
{
|
|
|
|
|
|
register int yystate;
|
|
|
register int yyn;
|
|
|
int yyresult;
|
|
|
/* Number of tokens to shift before error messages enabled. */
|
|
|
int yyerrstatus;
|
|
|
/* Lookahead token as an internal (translated) token number. */
|
|
|
int yytoken = 0;
|
|
|
|
|
|
/* Three stacks and their tools:
|
|
|
`yyss': related to states,
|
|
|
`yyvs': related to semantic values,
|
|
|
`yyls': related to locations.
|
|
|
|
|
|
Refer to the stacks thru separate pointers, to allow yyoverflow
|
|
|
to reallocate them elsewhere. */
|
|
|
|
|
|
/* The state stack. */
|
|
|
short int yyssa[YYINITDEPTH];
|
|
|
short int *yyss = yyssa;
|
|
|
register short int *yyssp;
|
|
|
|
|
|
/* The semantic value stack. */
|
|
|
YYSTYPE yyvsa[YYINITDEPTH];
|
|
|
YYSTYPE *yyvs = yyvsa;
|
|
|
register YYSTYPE *yyvsp;
|
|
|
|
|
|
|
|
|
|
|
|
#define YYPOPSTACK (yyvsp--, yyssp--)
|
|
|
|
|
|
YYSIZE_T yystacksize = YYINITDEPTH;
|
|
|
|
|
|
/* The variables used to return semantic value and location from the
|
|
|
action routines. */
|
|
|
YYSTYPE yyval;
|
|
|
|
|
|
|
|
|
/* When reducing, the number of symbols on the RHS of the reduced
|
|
|
rule. */
|
|
|
int yylen;
|
|
|
|
|
|
YYDPRINTF ((stderr, "Starting parse\n"));
|
|
|
|
|
|
yystate = 0;
|
|
|
yyerrstatus = 0;
|
|
|
yynerrs = 0;
|
|
|
yychar = YYEMPTY; /* Cause a token to be read. */
|
|
|
|
|
|
/* Initialize stack pointers.
|
|
|
Waste one element of value and location stack
|
|
|
so that they stay on the same level as the state stack.
|
|
|
The wasted elements are never initialized. */
|
|
|
|
|
|
yyssp = yyss;
|
|
|
yyvsp = yyvs;
|
|
|
|
|
|
|
|
|
goto yysetstate;
|
|
|
|
|
|
/*------------------------------------------------------------.
|
|
|
| yynewstate -- Push a new state, which is found in yystate. |
|
|
|
`------------------------------------------------------------*/
|
|
|
yynewstate:
|
|
|
/* In all cases, when you get here, the value and location stacks
|
|
|
have just been pushed. so pushing a state here evens the stacks.
|
|
|
*/
|
|
|
yyssp++;
|
|
|
|
|
|
yysetstate:
|
|
|
*yyssp = yystate;
|
|
|
|
|
|
if (yyss + yystacksize - 1 <= yyssp)
|
|
|
{
|
|
|
/* Get the current used size of the three stacks, in elements. */
|
|
|
YYSIZE_T yysize = yyssp - yyss + 1;
|
|
|
|
|
|
#ifdef yyoverflow
|
|
|
{
|
|
|
/* Give user a chance to reallocate the stack. Use copies of
|
|
|
these so that the &'s don't force the real ones into
|
|
|
memory. */
|
|
|
YYSTYPE *yyvs1 = yyvs;
|
|
|
short int *yyss1 = yyss;
|
|
|
|
|
|
|
|
|
/* Each stack pointer address is followed by the size of the
|
|
|
data in use in that stack, in bytes. This used to be a
|
|
|
conditional around just the two extra args, but that might
|
|
|
be undefined if yyoverflow is a macro. */
|
|
|
yyoverflow ("parser stack overflow",
|
|
|
&yyss1, yysize * sizeof (*yyssp),
|
|
|
&yyvs1, yysize * sizeof (*yyvsp),
|
|
|
|
|
|
&yystacksize);
|
|
|
|
|
|
yyss = yyss1;
|
|
|
yyvs = yyvs1;
|
|
|
}
|
|
|
#else /* no yyoverflow */
|
|
|
# ifndef YYSTACK_RELOCATE
|
|
|
goto yyoverflowlab;
|
|
|
# else
|
|
|
/* Extend the stack our own way. */
|
|
|
if (YYMAXDEPTH <= yystacksize)
|
|
|
goto yyoverflowlab;
|
|
|
yystacksize *= 2;
|
|
|
if (YYMAXDEPTH < yystacksize)
|
|
|
yystacksize = YYMAXDEPTH;
|
|
|
|
|
|
{
|
|
|
short int *yyss1 = yyss;
|
|
|
union yyalloc *yyptr =
|
|
|
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
|
|
|
if (! yyptr)
|
|
|
goto yyoverflowlab;
|
|
|
YYSTACK_RELOCATE (yyss);
|
|
|
YYSTACK_RELOCATE (yyvs);
|
|
|
|
|
|
# undef YYSTACK_RELOCATE
|
|
|
if (yyss1 != yyssa)
|
|
|
YYSTACK_FREE (yyss1);
|
|
|
}
|
|
|
# endif
|
|
|
#endif /* no yyoverflow */
|
|
|
|
|
|
yyssp = yyss + yysize - 1;
|
|
|
yyvsp = yyvs + yysize - 1;
|
|
|
|
|
|
|
|
|
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
|
|
|
(unsigned long int) yystacksize));
|
|
|
|
|
|
if (yyss + yystacksize - 1 <= yyssp)
|
|
|
YYABORT;
|
|
|
}
|
|
|
|
|
|
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
|
|
|
|
|
|
goto yybackup;
|
|
|
|
|
|
/*-----------.
|
|
|
| yybackup. |
|
|
|
`-----------*/
|
|
|
yybackup:
|
|
|
|
|
|
/* Do appropriate processing given the current state. */
|
|
|
/* Read a lookahead token if we need one and don't already have one. */
|
|
|
/* yyresume: */
|
|
|
|
|
|
/* First try to decide what to do without reference to lookahead token. */
|
|
|
|
|
|
yyn = yypact[yystate];
|
|
|
if (yyn == YYPACT_NINF)
|
|
|
goto yydefault;
|
|
|
|
|
|
/* Not known => get a lookahead token if don't already have one. */
|
|
|
|
|
|
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
|
|
|
if (yychar == YYEMPTY)
|
|
|
{
|
|
|
YYDPRINTF ((stderr, "Reading a token: "));
|
|
|
yychar = YYLEX;
|
|
|
}
|
|
|
|
|
|
if (yychar <= YYEOF)
|
|
|
{
|
|
|
yychar = yytoken = YYEOF;
|
|
|
YYDPRINTF ((stderr, "Now at end of input.\n"));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
yytoken = YYTRANSLATE (yychar);
|
|
|
YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
|
|
|
}
|
|
|
|
|
|
/* If the proper action on seeing token YYTOKEN is to reduce or to
|
|
|
detect an error, take that action. */
|
|
|
yyn += yytoken;
|
|
|
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
|
|
|
goto yydefault;
|
|
|
yyn = yytable[yyn];
|
|
|
if (yyn <= 0)
|
|
|
{
|
|
|
if (yyn == 0 || yyn == YYTABLE_NINF)
|
|
|
goto yyerrlab;
|
|
|
yyn = -yyn;
|
|
|
goto yyreduce;
|
|
|
}
|
|
|
|
|
|
if (yyn == YYFINAL)
|
|
|
YYACCEPT;
|
|
|
|
|
|
/* Shift the lookahead token. */
|
|
|
YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
|
|
|
|
|
|
/* Discard the token being shifted unless it is eof. */
|
|
|
if (yychar != YYEOF)
|
|
|
yychar = YYEMPTY;
|
|
|
|
|
|
*++yyvsp = yylval;
|
|
|
|
|
|
|
|
|
/* Count tokens shifted since error; after three, turn off error
|
|
|
status. */
|
|
|
if (yyerrstatus)
|
|
|
yyerrstatus--;
|
|
|
|
|
|
yystate = yyn;
|
|
|
goto yynewstate;
|
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------.
|
|
|
| yydefault -- do the default action for the current state. |
|
|
|
`-----------------------------------------------------------*/
|
|
|
yydefault:
|
|
|
yyn = yydefact[yystate];
|
|
|
if (yyn == 0)
|
|
|
goto yyerrlab;
|
|
|
goto yyreduce;
|
|
|
|
|
|
|
|
|
/*-----------------------------.
|
|
|
| yyreduce -- Do a reduction. |
|
|
|
`-----------------------------*/
|
|
|
yyreduce:
|
|
|
/* yyn is the number of a rule to reduce with. */
|
|
|
yylen = yyr2[yyn];
|
|
|
|
|
|
/* If YYLEN is nonzero, implement the default value of the action:
|
|
|
`$$ = $1'.
|
|
|
|
|
|
Otherwise, the following line sets YYVAL to garbage.
|
|
|
This behavior is undocumented and Bison
|
|
|
users should not rely upon it. Assigning to YYVAL
|
|
|
unconditionally makes the parser a bit smaller, and it avoids a
|
|
|
GCC warning that YYVAL may be used uninitialized. */
|
|
|
yyval = yyvsp[1-yylen];
|
|
|
|
|
|
|
|
|
YY_REDUCE_PRINT (yyn);
|
|
|
switch (yyn)
|
|
|
{
|
|
|
case 4:
|
|
|
#line 119 "parsedate.y"
|
|
|
{
|
|
|
yyHaveTime++;
|
|
|
#ifdef lint
|
|
|
/* I am compulsive about lint natterings... */
|
|
|
if (yyHaveTime == -1) {
|
|
|
YYERROR;
|
|
|
}
|
|
|
#endif /* lint */
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 5:
|
|
|
#line 128 "parsedate.y"
|
|
|
{
|
|
|
yyHaveTime++;
|
|
|
yyTimezone = yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 6:
|
|
|
#line 132 "parsedate.y"
|
|
|
{
|
|
|
yyHaveDate++;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 7:
|
|
|
#line 135 "parsedate.y"
|
|
|
{
|
|
|
yyHaveRel = 1;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 8:
|
|
|
#line 140 "parsedate.y"
|
|
|
{
|
|
|
if (yyvsp[-1].Number < 100) {
|
|
|
yyHour = yyvsp[-1].Number;
|
|
|
yyMinutes = 0;
|
|
|
}
|
|
|
else {
|
|
|
yyHour = yyvsp[-1].Number / 100;
|
|
|
yyMinutes = yyvsp[-1].Number % 100;
|
|
|
}
|
|
|
yySeconds = 0;
|
|
|
yyMeridian = yyvsp[0].Meridian;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 9:
|
|
|
#line 152 "parsedate.y"
|
|
|
{
|
|
|
yyHour = yyvsp[-3].Number;
|
|
|
yyMinutes = yyvsp[-1].Number;
|
|
|
yySeconds = 0;
|
|
|
yyMeridian = yyvsp[0].Meridian;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 10:
|
|
|
#line 158 "parsedate.y"
|
|
|
{
|
|
|
yyHour = yyvsp[-3].Number;
|
|
|
yyMinutes = yyvsp[-1].Number;
|
|
|
yyTimezone = yyvsp[0].Number;
|
|
|
yyMeridian = MER24;
|
|
|
yyDSTmode = DSToff;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 11:
|
|
|
#line 165 "parsedate.y"
|
|
|
{
|
|
|
yyHour = yyvsp[-5].Number;
|
|
|
yyMinutes = yyvsp[-3].Number;
|
|
|
yySeconds = yyvsp[-1].Number;
|
|
|
yyMeridian = yyvsp[0].Meridian;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 12:
|
|
|
#line 171 "parsedate.y"
|
|
|
{
|
|
|
yyHour = yyvsp[-5].Number;
|
|
|
yyMinutes = yyvsp[-3].Number;
|
|
|
yySeconds = yyvsp[-1].Number;
|
|
|
yyTimezone = yyvsp[0].Number;
|
|
|
yyMeridian = MER24;
|
|
|
yyDSTmode = DSToff;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 13:
|
|
|
#line 181 "parsedate.y"
|
|
|
{
|
|
|
yyval.Number = yyvsp[0].Number;
|
|
|
yyDSTmode = DSToff;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 14:
|
|
|
#line 185 "parsedate.y"
|
|
|
{
|
|
|
yyval.Number = yyvsp[0].Number;
|
|
|
yyDSTmode = DSTon;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 15:
|
|
|
#line 189 "parsedate.y"
|
|
|
{
|
|
|
/* Only allow "GMT+300" and "GMT-0800" */
|
|
|
if (yyvsp[-1].Number != 0) {
|
|
|
YYABORT;
|
|
|
}
|
|
|
yyval.Number = yyvsp[0].Number;
|
|
|
yyDSTmode = DSToff;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 16:
|
|
|
#line 197 "parsedate.y"
|
|
|
{
|
|
|
yyval.Number = yyvsp[0].Number;
|
|
|
yyDSTmode = DSToff;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 17:
|
|
|
#line 203 "parsedate.y"
|
|
|
{
|
|
|
int i;
|
|
|
|
|
|
/* Unix and GMT and numeric timezones -- a little confusing. */
|
|
|
if (yyvsp[0].Number < 0) {
|
|
|
/* Don't work with negative modulus. */
|
|
|
yyvsp[0].Number = -yyvsp[0].Number;
|
|
|
if (yyvsp[0].Number > 9999 || (i = yyvsp[0].Number % 100) >= 60) {
|
|
|
YYABORT;
|
|
|
}
|
|
|
yyval.Number = (yyvsp[0].Number / 100) * 60 + i;
|
|
|
}
|
|
|
else {
|
|
|
if (yyvsp[0].Number > 9999 || (i = yyvsp[0].Number % 100) >= 60) {
|
|
|
YYABORT;
|
|
|
}
|
|
|
yyval.Number = -((yyvsp[0].Number / 100) * 60 + i);
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 18:
|
|
|
#line 224 "parsedate.y"
|
|
|
{
|
|
|
yyMonth = yyvsp[-2].Number;
|
|
|
yyDay = yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 19:
|
|
|
#line 228 "parsedate.y"
|
|
|
{
|
|
|
if (yyvsp[-4].Number > 100) {
|
|
|
yyYear = yyvsp[-4].Number;
|
|
|
yyMonth = yyvsp[-2].Number;
|
|
|
yyDay = yyvsp[0].Number;
|
|
|
}
|
|
|
else {
|
|
|
yyMonth = yyvsp[-4].Number;
|
|
|
yyDay = yyvsp[-2].Number;
|
|
|
yyYear = yyvsp[0].Number;
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 20:
|
|
|
#line 240 "parsedate.y"
|
|
|
{
|
|
|
yyMonth = yyvsp[-1].Number;
|
|
|
yyDay = yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 21:
|
|
|
#line 244 "parsedate.y"
|
|
|
{
|
|
|
yyMonth = yyvsp[-3].Number;
|
|
|
yyDay = yyvsp[-2].Number;
|
|
|
yyYear = yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 22:
|
|
|
#line 249 "parsedate.y"
|
|
|
{
|
|
|
yyDay = yyvsp[-1].Number;
|
|
|
yyMonth = yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 23:
|
|
|
#line 253 "parsedate.y"
|
|
|
{
|
|
|
yyDay = yyvsp[-2].Number;
|
|
|
yyMonth = yyvsp[-1].Number;
|
|
|
yyYear = yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 24:
|
|
|
#line 258 "parsedate.y"
|
|
|
{
|
|
|
yyDay = yyvsp[-2].Number;
|
|
|
yyMonth = yyvsp[-1].Number;
|
|
|
yyYear = yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 25:
|
|
|
#line 265 "parsedate.y"
|
|
|
{
|
|
|
yyRelSeconds += yyvsp[-1].Number * yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 26:
|
|
|
#line 268 "parsedate.y"
|
|
|
{
|
|
|
yyRelSeconds += yyvsp[-1].Number * yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 27:
|
|
|
#line 271 "parsedate.y"
|
|
|
{
|
|
|
yyRelMonth += yyvsp[-1].Number * yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 28:
|
|
|
#line 274 "parsedate.y"
|
|
|
{
|
|
|
yyRelMonth += yyvsp[-1].Number * yyvsp[0].Number;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 29:
|
|
|
#line 279 "parsedate.y"
|
|
|
{
|
|
|
yyval.Meridian = MER24;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case 30:
|
|
|
#line 282 "parsedate.y"
|
|
|
{
|
|
|
yyval.Meridian = yyvsp[0].Meridian;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
/* Line 1010 of yacc.c. */
|
|
|
#line 1391 "parsedate.c"
|
|
|
|
|
|
yyvsp -= yylen;
|
|
|
yyssp -= yylen;
|
|
|
|
|
|
|
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
|
|
|
|
*++yyvsp = yyval;
|
|
|
|
|
|
|
|
|
/* Now `shift' the result of the reduction. Determine what state
|
|
|
that goes to, based on the state we popped back to and the rule
|
|
|
number reduced by. */
|
|
|
|
|
|
yyn = yyr1[yyn];
|
|
|
|
|
|
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
|
|
|
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
|
|
|
yystate = yytable[yystate];
|
|
|
else
|
|
|
yystate = yydefgoto[yyn - YYNTOKENS];
|
|
|
|
|
|
goto yynewstate;
|
|
|
|
|
|
|
|
|
/*------------------------------------.
|
|
|
| yyerrlab -- here on detecting error |
|
|
|
`------------------------------------*/
|
|
|
yyerrlab:
|
|
|
/* If not already recovering from an error, report this error. */
|
|
|
if (!yyerrstatus)
|
|
|
{
|
|
|
++yynerrs;
|
|
|
#if YYERROR_VERBOSE
|
|
|
yyn = yypact[yystate];
|
|
|
|
|
|
if (YYPACT_NINF < yyn && yyn < YYLAST)
|
|
|
{
|
|
|
YYSIZE_T yysize = 0;
|
|
|
int yytype = YYTRANSLATE (yychar);
|
|
|
const char* yyprefix;
|
|
|
char *yymsg;
|
|
|
int yyx;
|
|
|
|
|
|
/* Start YYX at -YYN if negative to avoid negative indexes in
|
|
|
YYCHECK. */
|
|
|
int yyxbegin = yyn < 0 ? -yyn : 0;
|
|
|
|
|
|
/* Stay within bounds of both yycheck and yytname. */
|
|
|
int yychecklim = YYLAST - yyn;
|
|
|
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
|
|
|
int yycount = 0;
|
|
|
|
|
|
yyprefix = ", expecting ";
|
|
|
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
|
|
|
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
|
|
|
{
|
|
|
yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
|
|
|
yycount += 1;
|
|
|
if (yycount == 5)
|
|
|
{
|
|
|
yysize = 0;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
yysize += (sizeof ("syntax error, unexpected ")
|
|
|
+ yystrlen (yytname[yytype]));
|
|
|
yymsg = (char *) YYSTACK_ALLOC (yysize);
|
|
|
if (yymsg != 0)
|
|
|
{
|
|
|
char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
|
|
|
yyp = yystpcpy (yyp, yytname[yytype]);
|
|
|
|
|
|
if (yycount < 5)
|
|
|
{
|
|
|
yyprefix = ", expecting ";
|
|
|
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
|
|
|
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
|
|
|
{
|
|
|
yyp = yystpcpy (yyp, yyprefix);
|
|
|
yyp = yystpcpy (yyp, yytname[yyx]);
|
|
|
yyprefix = " or ";
|
|
|
}
|
|
|
}
|
|
|
yyerror (yymsg);
|
|
|
YYSTACK_FREE (yymsg);
|
|
|
}
|
|
|
else
|
|
|
yyerror ("syntax error; also virtual memory exhausted");
|
|
|
}
|
|
|
else
|
|
|
#endif /* YYERROR_VERBOSE */
|
|
|
yyerror ("syntax error");
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (yyerrstatus == 3)
|
|
|
{
|
|
|
/* If just tried and failed to reuse lookahead token after an
|
|
|
error, discard it. */
|
|
|
|
|
|
if (yychar <= YYEOF)
|
|
|
{
|
|
|
/* If at end of input, pop the error token,
|
|
|
then the rest of the stack, then return failure. */
|
|
|
if (yychar == YYEOF)
|
|
|
for (;;)
|
|
|
{
|
|
|
YYPOPSTACK;
|
|
|
if (yyssp == yyss)
|
|
|
YYABORT;
|
|
|
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
|
|
|
yydestruct (yystos[*yyssp], yyvsp);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
|
|
|
yydestruct (yytoken, &yylval);
|
|
|
yychar = YYEMPTY;
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Else will try to reuse lookahead token after shifting the error
|
|
|
token. */
|
|
|
goto yyerrlab1;
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------.
|
|
|
| yyerrorlab -- error raised explicitly by YYERROR. |
|
|
|
`---------------------------------------------------*/
|
|
|
yyerrorlab:
|
|
|
|
|
|
#ifdef __GNUC__
|
|
|
/* Pacify GCC when the user code never invokes YYERROR and the label
|
|
|
yyerrorlab therefore never appears in user code. */
|
|
|
if (0)
|
|
|
goto yyerrorlab;
|
|
|
#endif
|
|
|
|
|
|
yyvsp -= yylen;
|
|
|
yyssp -= yylen;
|
|
|
yystate = *yyssp;
|
|
|
goto yyerrlab1;
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------.
|
|
|
| yyerrlab1 -- common code for both syntax error and YYERROR. |
|
|
|
`-------------------------------------------------------------*/
|
|
|
yyerrlab1:
|
|
|
yyerrstatus = 3; /* Each real token shifted decrements this. */
|
|
|
|
|
|
for (;;)
|
|
|
{
|
|
|
yyn = yypact[yystate];
|
|
|
if (yyn != YYPACT_NINF)
|
|
|
{
|
|
|
yyn += YYTERROR;
|
|
|
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
|
|
|
{
|
|
|
yyn = yytable[yyn];
|
|
|
if (0 < yyn)
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Pop the current state because it cannot handle the error token. */
|
|
|
if (yyssp == yyss)
|
|
|
YYABORT;
|
|
|
|
|
|
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
|
|
|
yydestruct (yystos[yystate], yyvsp);
|
|
|
YYPOPSTACK;
|
|
|
yystate = *yyssp;
|
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
|
}
|
|
|
|
|
|
if (yyn == YYFINAL)
|
|
|
YYACCEPT;
|
|
|
|
|
|
YYDPRINTF ((stderr, "Shifting error token, "));
|
|
|
|
|
|
*++yyvsp = yylval;
|
|
|
|
|
|
|
|
|
yystate = yyn;
|
|
|
goto yynewstate;
|
|
|
|
|
|
|
|
|
/*-------------------------------------.
|
|
|
| yyacceptlab -- YYACCEPT comes here. |
|
|
|
`-------------------------------------*/
|
|
|
yyacceptlab:
|
|
|
yyresult = 0;
|
|
|
goto yyreturn;
|
|
|
|
|
|
/*-----------------------------------.
|
|
|
| yyabortlab -- YYABORT comes here. |
|
|
|
`-----------------------------------*/
|
|
|
yyabortlab:
|
|
|
yyresult = 1;
|
|
|
goto yyreturn;
|
|
|
|
|
|
#ifndef yyoverflow
|
|
|
/*----------------------------------------------.
|
|
|
| yyoverflowlab -- parser overflow comes here. |
|
|
|
`----------------------------------------------*/
|
|
|
yyoverflowlab:
|
|
|
yyerror ("parser stack overflow");
|
|
|
yyresult = 2;
|
|
|
/* Fall through. */
|
|
|
#endif
|
|
|
|
|
|
yyreturn:
|
|
|
#ifndef yyoverflow
|
|
|
if (yyss != yyssa)
|
|
|
YYSTACK_FREE (yyss);
|
|
|
#endif
|
|
|
return yyresult;
|
|
|
}
|
|
|
|
|
|
|
|
|
#line 287 "parsedate.y"
|
|
|
|
|
|
|
|
|
/* Month and day table. */
|
|
|
static TABLE MonthDayTable[] = {
|
|
|
{ "january", tMONTH, 1 },
|
|
|
{ "february", tMONTH, 2 },
|
|
|
{ "march", tMONTH, 3 },
|
|
|
{ "april", tMONTH, 4 },
|
|
|
{ "may", tMONTH, 5 },
|
|
|
{ "june", tMONTH, 6 },
|
|
|
{ "july", tMONTH, 7 },
|
|
|
{ "august", tMONTH, 8 },
|
|
|
{ "september", tMONTH, 9 },
|
|
|
{ "october", tMONTH, 10 },
|
|
|
{ "november", tMONTH, 11 },
|
|
|
{ "december", tMONTH, 12 },
|
|
|
/* The value of the day isn't used... */
|
|
|
{ "sunday", tDAY, 0 },
|
|
|
{ "monday", tDAY, 0 },
|
|
|
{ "tuesday", tDAY, 0 },
|
|
|
{ "wednesday", tDAY, 0 },
|
|
|
{ "thursday", tDAY, 0 },
|
|
|
{ "friday", tDAY, 0 },
|
|
|
{ "saturday", tDAY, 0 },
|
|
|
};
|
|
|
|
|
|
/* Time units table. */
|
|
|
static TABLE UnitsTable[] = {
|
|
|
{ "year", tMONTH_UNIT, 12 },
|
|
|
{ "month", tMONTH_UNIT, 1 },
|
|
|
{ "week", tSEC_UNIT, 7L * 24 * 60 * 60 },
|
|
|
{ "day", tSEC_UNIT, 1L * 24 * 60 * 60 },
|
|
|
{ "hour", tSEC_UNIT, 60 * 60 },
|
|
|
{ "minute", tSEC_UNIT, 60 },
|
|
|
{ "min", tSEC_UNIT, 60 },
|
|
|
{ "second", tSEC_UNIT, 1 },
|
|
|
{ "sec", tSEC_UNIT, 1 },
|
|
|
};
|
|
|
|
|
|
/* Timezone table. */
|
|
|
static TABLE TimezoneTable[] = {
|
|
|
{ "gmt", tZONE, HOUR( 0) }, /* Greenwich Mean */
|
|
|
{ "ut", tZONE, HOUR( 0) }, /* Universal */
|
|
|
{ "utc", tZONE, HOUR( 0) }, /* Universal Coordinated */
|
|
|
{ "cut", tZONE, HOUR( 0) }, /* Coordinated Universal */
|
|
|
{ "z", tZONE, HOUR( 0) }, /* Greenwich Mean */
|
|
|
{ "wet", tZONE, HOUR( 0) }, /* Western European */
|
|
|
{ "bst", tDAYZONE, HOUR( 0) }, /* British Summer */
|
|
|
{ "nst", tZONE, HOUR(3)+30 }, /* Newfoundland Standard */
|
|
|
{ "ndt", tDAYZONE, HOUR(3)+30 }, /* Newfoundland Daylight */
|
|
|
{ "ast", tZONE, HOUR( 4) }, /* Atlantic Standard */
|
|
|
{ "adt", tDAYZONE, HOUR( 4) }, /* Atlantic Daylight */
|
|
|
{ "est", tZONE, HOUR( 5) }, /* Eastern Standard */
|
|
|
{ "edt", tDAYZONE, HOUR( 5) }, /* Eastern Daylight */
|
|
|
{ "cst", tZONE, HOUR( 6) }, /* Central Standard */
|
|
|
{ "cdt", tDAYZONE, HOUR( 6) }, /* Central Daylight */
|
|
|
{ "mst", tZONE, HOUR( 7) }, /* Mountain Standard */
|
|
|
{ "mdt", tDAYZONE, HOUR( 7) }, /* Mountain Daylight */
|
|
|
{ "pst", tZONE, HOUR( 8) }, /* Pacific Standard */
|
|
|
{ "pdt", tDAYZONE, HOUR( 8) }, /* Pacific Daylight */
|
|
|
{ "yst", tZONE, HOUR( 9) }, /* Yukon Standard */
|
|
|
{ "ydt", tDAYZONE, HOUR( 9) }, /* Yukon Daylight */
|
|
|
{ "akst", tZONE, HOUR( 9) }, /* Alaska Standard */
|
|
|
{ "akdt", tDAYZONE, HOUR( 9) }, /* Alaska Daylight */
|
|
|
{ "hst", tZONE, HOUR(10) }, /* Hawaii Standard */
|
|
|
{ "hast", tZONE, HOUR(10) }, /* Hawaii-Aleutian Standard */
|
|
|
{ "hadt", tDAYZONE, HOUR(10) }, /* Hawaii-Aleutian Daylight */
|
|
|
{ "ces", tDAYZONE, -HOUR(1) }, /* Central European Summer */
|
|
|
{ "cest", tDAYZONE, -HOUR(1) }, /* Central European Summer */
|
|
|
{ "mez", tZONE, -HOUR(1) }, /* Middle European */
|
|
|
{ "mezt", tDAYZONE, -HOUR(1) }, /* Middle European Summer */
|
|
|
{ "cet", tZONE, -HOUR(1) }, /* Central European */
|
|
|
{ "met", tZONE, -HOUR(1) }, /* Middle European */
|
|
|
{ "eet", tZONE, -HOUR(2) }, /* Eastern Europe */
|
|
|
{ "msk", tZONE, -HOUR(3) }, /* Moscow Winter */
|
|
|
{ "msd", tDAYZONE, -HOUR(3) }, /* Moscow Summer */
|
|
|
{ "wast", tZONE, -HOUR(8) }, /* West Australian Standard */
|
|
|
{ "wadt", tDAYZONE, -HOUR(8) }, /* West Australian Daylight */
|
|
|
{ "hkt", tZONE, -HOUR(8) }, /* Hong Kong */
|
|
|
{ "cct", tZONE, -HOUR(8) }, /* China Coast */
|
|
|
{ "jst", tZONE, -HOUR(9) }, /* Japan Standard */
|
|
|
{ "kst", tZONE, -HOUR(9) }, /* Korean Standard */
|
|
|
{ "kdt", tZONE, -HOUR(9) }, /* Korean Daylight */
|
|
|
{ "cast", tZONE, -(HOUR(9)+30) }, /* Central Australian Standard */
|
|
|
{ "cadt", tDAYZONE, -(HOUR(9)+30) }, /* Central Australian Daylight */
|
|
|
{ "east", tZONE, -HOUR(10) }, /* Eastern Australian Standard */
|
|
|
{ "eadt", tDAYZONE, -HOUR(10) }, /* Eastern Australian Daylight */
|
|
|
{ "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */
|
|
|
{ "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */
|
|
|
|
|
|
/* For completeness we include the following entries. */
|
|
|
#if 0
|
|
|
|
|
|
/* Duplicate names. Either they conflict with a zone listed above
|
|
|
* (which is either more likely to be seen or just been in circulation
|
|
|
* longer), or they conflict with another zone in this section and
|
|
|
* we could not reasonably choose one over the other. */
|
|
|
{ "fst", tZONE, HOUR( 2) }, /* Fernando De Noronha Standard */
|
|
|
{ "fdt", tDAYZONE, HOUR( 2) }, /* Fernando De Noronha Daylight */
|
|
|
{ "bst", tZONE, HOUR( 3) }, /* Brazil Standard */
|
|
|
{ "est", tZONE, HOUR( 3) }, /* Eastern Standard (Brazil) */
|
|
|
{ "edt", tDAYZONE, HOUR( 3) }, /* Eastern Daylight (Brazil) */
|
|
|
{ "wst", tZONE, HOUR( 4) }, /* Western Standard (Brazil) */
|
|
|
{ "wdt", tDAYZONE, HOUR( 4) }, /* Western Daylight (Brazil) */
|
|
|
{ "cst", tZONE, HOUR( 5) }, /* Chile Standard */
|
|
|
{ "cdt", tDAYZONE, HOUR( 5) }, /* Chile Daylight */
|
|
|
{ "ast", tZONE, HOUR( 5) }, /* Acre Standard */
|
|
|
{ "adt", tDAYZONE, HOUR( 5) }, /* Acre Daylight */
|
|
|
{ "cst", tZONE, HOUR( 5) }, /* Cuba Standard */
|
|
|
{ "cdt", tDAYZONE, HOUR( 5) }, /* Cuba Daylight */
|
|
|
{ "est", tZONE, HOUR( 6) }, /* Easter Island Standard */
|
|
|
{ "edt", tDAYZONE, HOUR( 6) }, /* Easter Island Daylight */
|
|
|
{ "sst", tZONE, HOUR(11) }, /* Samoa Standard */
|
|
|
{ "ist", tZONE, -HOUR(2) }, /* Israel Standard */
|
|
|
{ "idt", tDAYZONE, -HOUR(2) }, /* Israel Daylight */
|
|
|
{ "idt", tDAYZONE, -(HOUR(3)+30) }, /* Iran Daylight */
|
|
|
{ "ist", tZONE, -(HOUR(3)+30) }, /* Iran Standard */
|
|
|
{ "cst", tZONE, -HOUR(8) }, /* China Standard */
|
|
|
{ "cdt", tDAYZONE, -HOUR(8) }, /* China Daylight */
|
|
|
{ "sst", tZONE, -HOUR(8) }, /* Singapore Standard */
|
|
|
|
|
|
/* Dubious (e.g., not in Olson's TIMEZONE package) or obsolete. */
|
|
|
{ "gst", tZONE, HOUR( 3) }, /* Greenland Standard */
|
|
|
{ "wat", tZONE, -HOUR(1) }, /* West Africa */
|
|
|
{ "at", tZONE, HOUR( 2) }, /* Azores */
|
|
|
{ "gst", tZONE, -HOUR(10) }, /* Guam Standard */
|
|
|
{ "nft", tZONE, HOUR(3)+30 }, /* Newfoundland */
|
|
|
{ "idlw", tZONE, HOUR(12) }, /* International Date Line West */
|
|
|
{ "mewt", tZONE, -HOUR(1) }, /* Middle European Winter */
|
|
|
{ "mest", tDAYZONE, -HOUR(1) }, /* Middle European Summer */
|
|
|
{ "swt", tZONE, -HOUR(1) }, /* Swedish Winter */
|
|
|
{ "sst", tDAYZONE, -HOUR(1) }, /* Swedish Summer */
|
|
|
{ "fwt", tZONE, -HOUR(1) }, /* French Winter */
|
|
|
{ "fst", tDAYZONE, -HOUR(1) }, /* French Summer */
|
|
|
{ "bt", tZONE, -HOUR(3) }, /* Baghdad */
|
|
|
{ "it", tZONE, -(HOUR(3)+30) }, /* Iran */
|
|
|
{ "zp4", tZONE, -HOUR(4) }, /* USSR Zone 3 */
|
|
|
{ "zp5", tZONE, -HOUR(5) }, /* USSR Zone 4 */
|
|
|
{ "ist", tZONE, -(HOUR(5)+30) }, /* Indian Standard */
|
|
|
{ "zp6", tZONE, -HOUR(6) }, /* USSR Zone 5 */
|
|
|
{ "nst", tZONE, -HOUR(7) }, /* North Sumatra */
|
|
|
{ "sst", tZONE, -HOUR(7) }, /* South Sumatra */
|
|
|
{ "jt", tZONE, -(HOUR(7)+30) }, /* Java (3pm in Cronusland!) */
|
|
|
{ "nzt", tZONE, -HOUR(12) }, /* New Zealand */
|
|
|
{ "idle", tZONE, -HOUR(12) }, /* International Date Line East */
|
|
|
{ "cat", tZONE, HOUR(10) }, /* -- expired 1967 */
|
|
|
{ "nt", tZONE, HOUR(11) }, /* -- expired 1967 */
|
|
|
{ "ahst", tZONE, HOUR(10) }, /* -- expired 1983 */
|
|
|
{ "hdt", tDAYZONE, HOUR(10) }, /* -- expired 1986 */
|
|
|
#endif /* 0 */
|
|
|
};
|
|
|
|
|
|
|
|
|
/* ARGSUSED */
|
|
|
static void
|
|
|
date_error(s)
|
|
|
char *s;
|
|
|
{
|
|
|
/* NOTREACHED */
|
|
|
}
|
|
|
|
|
|
|
|
|
static time_t
|
|
|
ToSeconds(Hours, Minutes, Seconds, Meridian)
|
|
|
time_t Hours;
|
|
|
time_t Minutes;
|
|
|
time_t Seconds;
|
|
|
MERIDIAN Meridian;
|
|
|
{
|
|
|
if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 61)
|
|
|
return -1;
|
|
|
if (Meridian == MER24) {
|
|
|
if (Hours < 0 || Hours > 23)
|
|
|
return -1;
|
|
|
}
|
|
|
else {
|
|
|
if (Hours < 1 || Hours > 12)
|
|
|
return -1;
|
|
|
if (Hours == 12)
|
|
|
Hours = 0;
|
|
|
if (Meridian == MERpm)
|
|
|
Hours += 12;
|
|
|
}
|
|
|
return (Hours * 60L + Minutes) * 60L + Seconds;
|
|
|
}
|
|
|
|
|
|
|
|
|
static time_t
|
|
|
Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, dst)
|
|
|
time_t Month;
|
|
|
time_t Day;
|
|
|
time_t Year;
|
|
|
time_t Hours;
|
|
|
time_t Minutes;
|
|
|
time_t Seconds;
|
|
|
MERIDIAN Meridian;
|
|
|
DSTMODE dst;
|
|
|
{
|
|
|
static int DaysNormal[13] = {
|
|
|
0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
|
|
|
};
|
|
|
static int DaysLeap[13] = {
|
|
|
0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
|
|
|
};
|
|
|
static int LeapYears[] = {
|
|
|
1972, 1976, 1980, 1984, 1988, 1992, 1996,
|
|
|
2000, 2004, 2008, 2012, 2016, 2020, 2024, 2028, 2032, 2036
|
|
|
};
|
|
|
register int *yp;
|
|
|
register int *mp;
|
|
|
register time_t Julian;
|
|
|
register int i;
|
|
|
time_t tod;
|
|
|
|
|
|
if (Year < 0)
|
|
|
Year = -Year;
|
|
|
if (Year < 100)
|
|
|
Year += 1900;
|
|
|
if (Year < EPOCH)
|
|
|
Year += 100;
|
|
|
for (mp = DaysNormal, yp = LeapYears; yp < ENDOF(LeapYears); yp++)
|
|
|
if (Year == *yp) {
|
|
|
mp = DaysLeap;
|
|
|
break;
|
|
|
}
|
|
|
if (Year < EPOCH || Year > END_OF_TIME
|
|
|
|| Month < 1 || Month > 12
|
|
|
/* NOSTRICT *//* conversion from long may lose accuracy */
|
|
|
|| Day < 1 || Day > mp[(int)Month])
|
|
|
return -1;
|
|
|
|
|
|
Julian = Day - 1 + (Year - EPOCH) * 365;
|
|
|
for (yp = LeapYears; yp < ENDOF(LeapYears); yp++, Julian++)
|
|
|
if (Year <= *yp)
|
|
|
break;
|
|
|
for (i = 1; i < Month; i++)
|
|
|
Julian += *++mp;
|
|
|
Julian *= SECSPERDAY;
|
|
|
Julian += yyTimezone * 60L;
|
|
|
if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0)
|
|
|
return -1;
|
|
|
Julian += tod;
|
|
|
tod = Julian;
|
|
|
if (dst == DSTon || (dst == DSTmaybe && localtime(&tod)->tm_isdst))
|
|
|
Julian -= DST_OFFSET * 60L * 60L;
|
|
|
return Julian;
|
|
|
}
|
|
|
|
|
|
|
|
|
static time_t
|
|
|
DSTcorrect(Start, Future)
|
|
|
time_t Start;
|
|
|
time_t Future;
|
|
|
{
|
|
|
time_t StartDay;
|
|
|
time_t FutureDay;
|
|
|
|
|
|
StartDay = (localtime(&Start)->tm_hour + 1) % 24;
|
|
|
FutureDay = (localtime(&Future)->tm_hour + 1) % 24;
|
|
|
return (Future - Start) + (StartDay - FutureDay) * DST_OFFSET * 60L * 60L;
|
|
|
}
|
|
|
|
|
|
|
|
|
static time_t
|
|
|
RelativeMonth(Start, RelMonth)
|
|
|
time_t Start;
|
|
|
time_t RelMonth;
|
|
|
{
|
|
|
struct tm *tm;
|
|
|
time_t Month;
|
|
|
time_t Year;
|
|
|
|
|
|
tm = localtime(&Start);
|
|
|
Month = 12 * tm->tm_year + tm->tm_mon + RelMonth;
|
|
|
Year = Month / 12;
|
|
|
Month = Month % 12 + 1;
|
|
|
return DSTcorrect(Start,
|
|
|
Convert(Month, (time_t)tm->tm_mday, Year,
|
|
|
(time_t)tm->tm_hour, (time_t)tm->tm_min, (time_t)tm->tm_sec,
|
|
|
MER24, DSTmaybe));
|
|
|
}
|
|
|
|
|
|
|
|
|
static int
|
|
|
LookupWord(buff, length)
|
|
|
char *buff;
|
|
|
register int length;
|
|
|
{
|
|
|
register char *p;
|
|
|
register char *q;
|
|
|
register TABLE *tp;
|
|
|
register int c;
|
|
|
|
|
|
p = buff;
|
|
|
c = p[0];
|
|
|
|
|
|
/* See if we have an abbreviation for a month. */
|
|
|
if (length == 3 || (length == 4 && p[3] == '.'))
|
|
|
for (tp = MonthDayTable; tp < ENDOF(MonthDayTable); tp++) {
|
|
|
q = tp->name;
|
|
|
if (c == q[0] && p[1] == q[1] && p[2] == q[2]) {
|
|
|
yylval.Number = tp->value;
|
|
|
return tp->type;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
for (tp = MonthDayTable; tp < ENDOF(MonthDayTable); tp++)
|
|
|
if (c == tp->name[0] && strcmp(p, tp->name) == 0) {
|
|
|
yylval.Number = tp->value;
|
|
|
return tp->type;
|
|
|
}
|
|
|
|
|
|
/* Try for a timezone. */
|
|
|
for (tp = TimezoneTable; tp < ENDOF(TimezoneTable); tp++)
|
|
|
if (c == tp->name[0] && p[1] == tp->name[1]
|
|
|
&& strcmp(p, tp->name) == 0) {
|
|
|
yylval.Number = tp->value;
|
|
|
return tp->type;
|
|
|
}
|
|
|
|
|
|
/* Try the units table. */
|
|
|
for (tp = UnitsTable; tp < ENDOF(UnitsTable); tp++)
|
|
|
if (c == tp->name[0] && strcmp(p, tp->name) == 0) {
|
|
|
yylval.Number = tp->value;
|
|
|
return tp->type;
|
|
|
}
|
|
|
|
|
|
/* Strip off any plural and try the units table again. */
|
|
|
if (--length > 0 && p[length] == 's') {
|
|
|
p[length] = '\0';
|
|
|
for (tp = UnitsTable; tp < ENDOF(UnitsTable); tp++)
|
|
|
if (c == tp->name[0] && strcmp(p, tp->name) == 0) {
|
|
|
p[length] = 's';
|
|
|
yylval.Number = tp->value;
|
|
|
return tp->type;
|
|
|
}
|
|
|
p[length] = 's';
|
|
|
}
|
|
|
length++;
|
|
|
|
|
|
/* Drop out any periods. */
|
|
|
for (p = buff, q = (char*)buff; *q; q++)
|
|
|
if (*q != '.')
|
|
|
*p++ = *q;
|
|
|
*p = '\0';
|
|
|
|
|
|
/* Try the meridians. */
|
|
|
if (buff[1] == 'm' && buff[2] == '\0') {
|
|
|
if (buff[0] == 'a') {
|
|
|
yylval.Meridian = MERam;
|
|
|
return tMERIDIAN;
|
|
|
}
|
|
|
if (buff[0] == 'p') {
|
|
|
yylval.Meridian = MERpm;
|
|
|
return tMERIDIAN;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* If we saw any periods, try the timezones again. */
|
|
|
if (p - buff != length) {
|
|
|
c = buff[0];
|
|
|
for (p = buff, tp = TimezoneTable; tp < ENDOF(TimezoneTable); tp++)
|
|
|
if (c == tp->name[0] && p[1] == tp->name[1]
|
|
|
&& strcmp(p, tp->name) == 0) {
|
|
|
yylval.Number = tp->value;
|
|
|
return tp->type;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Unknown word -- assume GMT timezone. */
|
|
|
yylval.Number = 0;
|
|
|
return tZONE;
|
|
|
}
|
|
|
|
|
|
|
|
|
int
|
|
|
date_lex()
|
|
|
{
|
|
|
register char c;
|
|
|
register char *p;
|
|
|
char buff[20];
|
|
|
register int sign;
|
|
|
register int i;
|
|
|
register int nesting;
|
|
|
|
|
|
for ( ; ; ) {
|
|
|
/* Get first character after the whitespace. */
|
|
|
for ( ; ; ) {
|
|
|
while (isspace(*yyInput))
|
|
|
yyInput++;
|
|
|
c = *yyInput;
|
|
|
|
|
|
/* Ignore RFC 822 comments, typically time zone names. */
|
|
|
if (c != LPAREN)
|
|
|
break;
|
|
|
for (nesting = 1; (c = *++yyInput) != RPAREN || --nesting; )
|
|
|
if (c == LPAREN)
|
|
|
nesting++;
|
|
|
else if (!IS7BIT(c) || c == '\0' || c == '\r'
|
|
|
|| (c == '\\' && ((c = *++yyInput) == '\0' || !IS7BIT(c))))
|
|
|
/* Lexical error: bad comment. */
|
|
|
return '?';
|
|
|
yyInput++;
|
|
|
}
|
|
|
|
|
|
/* A number? */
|
|
|
if (isdigit(c) || c == '-' || c == '+') {
|
|
|
if (c == '-' || c == '+') {
|
|
|
sign = c == '-' ? -1 : 1;
|
|
|
yyInput++;
|
|
|
if (!isdigit(*yyInput))
|
|
|
/* Skip the plus or minus sign. */
|
|
|
continue;
|
|
|
}
|
|
|
else
|
|
|
sign = 0;
|
|
|
for (i = 0; (c = *yyInput++) != '\0' && isdigit(c); )
|
|
|
i = 10 * i + c - '0';
|
|
|
yyInput--;
|
|
|
yylval.Number = sign < 0 ? -i : i;
|
|
|
return sign ? tSNUMBER : tUNUMBER;
|
|
|
}
|
|
|
|
|
|
/* A word? */
|
|
|
if (isalpha(c)) {
|
|
|
for (p = buff; (c = *yyInput++) == '.' || isalpha(c); )
|
|
|
if (p < &buff[sizeof buff - 1])
|
|
|
*p++ = isupper(c) ? tolower(c) : c;
|
|
|
*p = '\0';
|
|
|
yyInput--;
|
|
|
return LookupWord(buff, p - buff);
|
|
|
}
|
|
|
|
|
|
return *yyInput++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
time_t
|
|
|
parsedate(p)
|
|
|
char *p;
|
|
|
{
|
|
|
extern int date_parse();
|
|
|
time_t Start;
|
|
|
|
|
|
yyInput = p;
|
|
|
|
|
|
yyYear = 0;
|
|
|
yyMonth = 0;
|
|
|
yyDay = 0;
|
|
|
yyTimezone = 0;
|
|
|
yyDSTmode = DSTmaybe;
|
|
|
yyHour = 0;
|
|
|
yyMinutes = 0;
|
|
|
yySeconds = 0;
|
|
|
yyMeridian = MER24;
|
|
|
yyRelSeconds = 0;
|
|
|
yyRelMonth = 0;
|
|
|
yyHaveDate = 0;
|
|
|
yyHaveRel = 0;
|
|
|
yyHaveTime = 0;
|
|
|
|
|
|
if (date_parse() || yyHaveTime > 1 || yyHaveDate > 1)
|
|
|
return -1;
|
|
|
|
|
|
if (yyHaveDate || yyHaveTime) {
|
|
|
Start = Convert(yyMonth, yyDay, yyYear, yyHour, yyMinutes, yySeconds,
|
|
|
yyMeridian, yyDSTmode);
|
|
|
if (Start < 0)
|
|
|
return -1;
|
|
|
}
|
|
|
else
|
|
|
return -1;
|
|
|
|
|
|
Start += yyRelSeconds;
|
|
|
if (yyRelMonth)
|
|
|
Start += RelativeMonth(Start, yyRelMonth);
|
|
|
|
|
|
/* Have to do *something* with a legitimate -1 so it's distinguishable
|
|
|
* from the error return value. (Alternately could set errno on error.) */
|
|
|
return Start == -1 ? 0 : Start;
|
|
|
}
|
|
|
|
|
|
|
|
|
#ifdef TEST
|
|
|
|
|
|
#if YYDEBUG
|
|
|
extern int yydebug;
|
|
|
#endif /* YYDEBUG */
|
|
|
|
|
|
/* ARGSUSED */
|
|
|
int
|
|
|
main(ac, av)
|
|
|
int ac;
|
|
|
char *av[];
|
|
|
{
|
|
|
char buff[128];
|
|
|
time_t d;
|
|
|
|
|
|
#if YYDEBUG
|
|
|
yydebug = 1;
|
|
|
#endif /* YYDEBUG */
|
|
|
|
|
|
(void)printf("Enter date, or blank line to exit.\n\t> ");
|
|
|
for ( ; ; ) {
|
|
|
(void)printf("\t> ");
|
|
|
(void)fflush(stdout);
|
|
|
if (gets(buff) == NULL || buff[0] == '\n')
|
|
|
break;
|
|
|
#if YYDEBUG
|
|
|
if (strcmp(buff, "yydebug") == 0) {
|
|
|
yydebug = !yydebug;
|
|
|
printf("yydebug = %s\n", yydebug ? "on" : "off");
|
|
|
continue;
|
|
|
}
|
|
|
#endif /* YYDEBUG */
|
|
|
d = parsedate(buff, (TIMEINFO *)NULL);
|
|
|
if (d == -1)
|
|
|
(void)printf("Bad format - couldn't convert.\n");
|
|
|
else
|
|
|
(void)printf("%s", ctime(&d));
|
|
|
}
|
|
|
|
|
|
exit(0);
|
|
|
/* NOTREACHED */
|
|
|
}
|
|
|
#endif /* TEST */
|
|
|
|
|
|
|