--/* A Bison parser, made by GNU Bison 2.5. */
++/* A Bison parser, made by GNU Bison 3.0.2. */
/* Bison implementation for Yacc-like parsers in C
--
-- Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
--
++
++ Copyright (C) 1984, 1989-1990, 2000-2013 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 3 of the License, 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, see <http://www.gnu.org/licenses/>. */
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
--
++
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
#define YYBISON 1
/* Bison version. */
--#define YYBISON_VERSION "2.5"
++#define YYBISON_VERSION "3.0.2"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
/* Pull parsers. */
#define YYPULL 1
--/* Using locations. */
--#define YYLSP_NEEDED 0
/* Copy the first part of user declarations. */
--
--/* Line 268 of yacc.c */
--#line 1 "parsedate.y"
++#line 1 "parsedate.y" /* yacc.c:339 */
/* $Revision$
**
static void date_error(char *);
++#line 179 "y.tab.c" /* yacc.c:339 */
--/* Line 268 of yacc.c */
--#line 185 "y.tab.c"
--
--/* Enabling traces. */
--#ifndef YYDEBUG
--# define YYDEBUG 0
--#endif
++# ifndef YY_NULLPTR
++# if defined __cplusplus && 201103L <= __cplusplus
++# define YY_NULLPTR nullptr
++# else
++# define YY_NULLPTR 0
++# endif
++# endif
/* Enabling verbose error messages. */
#ifdef YYERROR_VERBOSE
# define YYERROR_VERBOSE 0
#endif
--/* Enabling the token table. */
--#ifndef YYTOKEN_TABLE
--# define YYTOKEN_TABLE 0
--#endif
++/* Debug traces. */
++#ifndef YYDEBUG
++# define YYDEBUG 0
++#endif
++#if YYDEBUG
++extern int yydebug;
++#endif
--/* Tokens. */
++/* Token type. */
#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
-- };
++ enum yytokentype
++ {
++ tDAY = 258,
++ tDAYZONE = 259,
++ tMERIDIAN = 260,
++ tMONTH = 261,
++ tMONTH_UNIT = 262,
++ tSEC_UNIT = 263,
++ tSNUMBER = 264,
++ tUNUMBER = 265,
++ tZONE = 266
++ };
#endif
/* Tokens. */
#define tDAY 258
#define tUNUMBER 265
#define tZONE 266
--
--
--
++/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
--typedef union YYSTYPE
++typedef union YYSTYPE YYSTYPE;
++union YYSTYPE
{
--
--/* Line 293 of yacc.c */
--#line 114 "parsedate.y"
++#line 114 "parsedate.y" /* yacc.c:355 */
time_t Number;
enum _MERIDIAN Meridian;
--
--
--/* Line 293 of yacc.c */
--#line 250 "y.tab.c"
--} YYSTYPE;
++#line 243 "y.tab.c" /* yacc.c:355 */
++};
# define YYSTYPE_IS_TRIVIAL 1
--# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
#endif
--/* Copy the second part of user declarations. */
++extern YYSTYPE yylval;
++
++int yyparse (void);
--/* Line 343 of yacc.c */
--#line 262 "y.tab.c"
++
++/* Copy the second part of user declarations. */
++
++#line 258 "y.tab.c" /* yacc.c:358 */
#ifdef short
# undef short
#ifdef YYTYPE_INT8
typedef YYTYPE_INT8 yytype_int8;
--#elif (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
--typedef signed char yytype_int8;
#else
--typedef short int yytype_int8;
++typedef signed char yytype_int8;
#endif
#ifdef YYTYPE_UINT16
# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
--# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
++# elif ! defined YYSIZE_T
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# else
# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
--# define YY_(msgid) dgettext ("bison-runtime", msgid)
++# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
# endif
# endif
# ifndef YY_
--# define YY_(msgid) msgid
++# define YY_(Msgid) Msgid
++# endif
++#endif
++
++#ifndef YY_ATTRIBUTE
++# if (defined __GNUC__ \
++ && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
++ || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
++# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
++# else
++# define YY_ATTRIBUTE(Spec) /* empty */
++# endif
++#endif
++
++#ifndef YY_ATTRIBUTE_PURE
++# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
++#endif
++
++#ifndef YY_ATTRIBUTE_UNUSED
++# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
++#endif
++
++#if !defined _Noreturn \
++ && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
++# if defined _MSC_VER && 1200 <= _MSC_VER
++# define _Noreturn __declspec (noreturn)
++# else
++# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
# endif
#endif
/* Suppress unused-variable warnings by "using" E. */
#if ! defined lint || defined __GNUC__
--# define YYUSE(e) ((void) (e))
++# define YYUSE(E) ((void) (E))
#else
--# define YYUSE(e) /* empty */
++# define YYUSE(E) /* empty */
#endif
--/* Identity function, used to suppress warnings about constant conditions. */
--#ifndef lint
--# define YYID(n) (n)
--#else
--#if (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
--static int
--YYID (int yyi)
++#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
++/* Suppress an incorrect diagnostic about yylval being uninitialized. */
++# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
++ _Pragma ("GCC diagnostic push") \
++ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
++ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
++# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
++ _Pragma ("GCC diagnostic pop")
#else
--static int
--YYID (yyi)
-- int yyi;
++# define YY_INITIAL_VALUE(Value) Value
#endif
--{
-- return yyi;
--}
++#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
++# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
++# define YY_IGNORE_MAYBE_UNINITIALIZED_END
++#endif
++#ifndef YY_INITIAL_VALUE
++# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
++
#if ! defined yyoverflow || YYERROR_VERBOSE
/* The parser invokes alloca or malloc; define the necessary symbols. */
# define alloca _alloca
# else
# define YYSTACK_ALLOC alloca
--# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
++# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
++ /* Use EXIT_SUCCESS as a witness for stdlib.h. */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# ifdef YYSTACK_ALLOC
-- /* Pacify GCC's `empty if-body' warning. */
--# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
++ /* Pacify GCC's 'empty if-body' warning. */
++# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes. So we cannot safely
# endif
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
&& ! ((defined YYMALLOC || defined malloc) \
-- && (defined YYFREE || defined free)))
++ && (defined YYFREE || defined free)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
--# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
++# if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE free
--# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
++# if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
#if (! defined yyoverflow \
&& (! defined __cplusplus \
-- || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
++ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
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_alloc, Stack) \
-- do \
-- { \
-- YYSIZE_T yynewbytes; \
-- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
-- Stack = &yyptr->Stack_alloc; \
-- yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
-- yyptr += yynewbytes / sizeof (*yyptr); \
-- } \
-- while (YYID (0))
++# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
++ do \
++ { \
++ YYSIZE_T yynewbytes; \
++ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
++ Stack = &yyptr->Stack_alloc; \
++ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
++ yyptr += yynewbytes / sizeof (*yyptr); \
++ } \
++ while (0)
#endif
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
--/* Copy COUNT objects from FROM to TO. The source and destination do
++/* Copy COUNT objects from SRC to DST. 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)))
++# define YYCOPY(Dst, Src, Count) \
++ __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
# else
--# define YYCOPY(To, From, Count) \
-- do \
-- { \
-- YYSIZE_T yyi; \
-- for (yyi = 0; yyi < (Count); yyi++) \
-- (To)[yyi] = (From)[yyi]; \
-- } \
-- while (YYID (0))
++# define YYCOPY(Dst, Src, Count) \
++ do \
++ { \
++ YYSIZE_T yyi; \
++ for (yyi = 0; yyi < (Count); yyi++) \
++ (Dst)[yyi] = (Src)[yyi]; \
++ } \
++ while (0)
# endif
# endif
#endif /* !YYCOPY_NEEDED */
#define YYNNTS 9
/* YYNRULES -- Number of rules. */
#define YYNRULES 30
--/* YYNRULES -- Number of states. */
++/* YYNSTATES -- Number of states. */
#define YYNSTATES 44
--/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
++/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
++ by yylex, with out-of-bounds checking. */
#define YYUNDEFTOK 2
#define YYMAXUTOK 266
--#define YYTRANSLATE(YYX) \
++#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
--/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
++/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
++ as returned by yylex, without out-of-bounds checking. */
static const yytype_uint8 yytranslate[] =
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
};
#if YYDEBUG
--/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-- YYRHS. */
--static const yytype_uint8 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 yytype_int8 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. */
++ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
0, 128, 128, 129, 132, 141, 145, 148, 153, 165,
};
#endif
--#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
++#if YYDEBUG || YYERROR_VERBOSE || 0
/* YYTNAME[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
++ "numzone", "date", "rel", "o_merid", YY_NULLPTR
};
#endif
# ifdef YYPRINT
--/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-- token YYLEX-NUM. */
++/* YYTOKNUM[NUM] -- (External) token number corresponding to the
++ (internal) symbol number NUM (which must be that of a token). */
static const yytype_uint16 yytoknum[] =
{
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
};
# endif
--/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
--static const yytype_uint8 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
--};
++#define YYPACT_NINF -29
--/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
--static const yytype_uint8 yyr2[] =
++#define yypact_value_is_default(Yystate) \
++ (!!((Yystate) == (-29)))
++
++#define YYTABLE_NINF -1
++
++#define yytable_value_is_error(Yytable_value) \
++ 0
++
++ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
++ STATE-NUM. */
++static const yytype_int8 yypact[] =
{
-- 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
++ -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
};
--/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
-- Performed when YYTABLE doesn't specify something else to do. Zero
-- means the default is an error. */
++ /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
++ Performed when YYTABLE does not specify something else to do. Zero
++ means the default is an error. */
static const yytype_uint8 yydefact[] =
{
2, 0, 1, 0, 0, 0, 29, 3, 4, 6,
29, 19, 12, 11
};
--/* YYDEFGOTO[NTERM-NUM]. */
--static const yytype_int8 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 yytype_int8 yypact[] =
++ /* YYPGOTO[NTERM-NUM]. */
++static const yytype_int8 yypgoto[] =
{
-- -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
++ -29, -29, -29, -29, -29, -24, -29, -29, -28
};
--/* YYPGOTO[NTERM-NUM]. */
--static const yytype_int8 yypgoto[] =
++ /* YYDEFGOTO[NTERM-NUM]. */
++static const yytype_int8 yydefgoto[] =
{
-- -29, -29, -29, -29, -29, -24, -29, -29, -28
++ -1, 1, 7, 8, 25, 26, 9, 10, 21
};
--/* 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 YYTABLE_NINF, syntax error. */
--#define YYTABLE_NINF -1
++ /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
++ positive, shift that token. If negative, reduce the rule whose
++ number is the opposite. If YYTABLE_NINF, syntax error. */
static const yytype_uint8 yytable[] =
{
32, 2, 37, 11, 3, 15, 36, 4, 22, 23,
41
};
--#define yypact_value_is_default(yystate) \
-- ((yystate) == (-29))
--
--#define yytable_value_is_error(yytable_value) \
-- YYID (0)
--
static const yytype_int8 yycheck[] =
{
24, 0, 30, 14, 3, 5, 30, 6, 4, 9,
10
};
--/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-- symbol of state STATE-NUM. */
++ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
++ symbol of state STATE-NUM. */
static const yytype_uint8 yystos[] =
{
0, 16, 0, 3, 6, 9, 10, 17, 18, 21,
10, 10, 20, 23
};
--#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. However,
-- YYFAIL appears to be in use. Nevertheless, it is formally deprecated
-- in Bison 2.4.2's NEWS entry, where a plan to phase it out is
-- discussed. */
--
--#define YYFAIL goto yyerrlab
--#if defined YYFAIL
-- /* This is here to suppress warnings from the GCC cpp's
-- -Wunused-macros. Normally we don't worry about that warning, but
-- some users do, and we want to make it easy for users to remove
-- YYFAIL uses, which will produce warnings from Bison 2.5. */
--#endif
++ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
++static const yytype_uint8 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
++};
--#define YYRECOVERING() (!!yyerrstatus)
++ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
++static const yytype_uint8 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
++};
--#define YYBACKUP(Token, Value) \
--do \
-- if (yychar == YYEMPTY && yylen == 1) \
-- { \
-- yychar = (Token); \
-- yylval = (Value); \
-- YYPOPSTACK (1); \
-- goto yybackup; \
-- } \
-- else \
-- { \
-- yyerror (YY_("syntax error: cannot back up")); \
-- YYERROR; \
-- } \
--while (YYID (0))
--
--
--#define YYTERROR 1
--#define YYERRCODE 256
--
--
--/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
-- If N is 0, then set CURRENT to the empty location which ends
-- the previous symbol: RHS[0] (always defined). */
--
--#define YYRHSLOC(Rhs, K) ((Rhs)[K])
--#ifndef YYLLOC_DEFAULT
--# define YYLLOC_DEFAULT(Current, Rhs, N) \
-- do \
-- if (YYID (N)) \
-- { \
-- (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
-- (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
-- (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
-- (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
-- } \
-- else \
-- { \
-- (Current).first_line = (Current).last_line = \
-- YYRHSLOC (Rhs, 0).last_line; \
-- (Current).first_column = (Current).last_column = \
-- YYRHSLOC (Rhs, 0).last_column; \
-- } \
-- while (YYID (0))
--#endif
++#define yyerrok (yyerrstatus = 0)
++#define yyclearin (yychar = YYEMPTY)
++#define YYEMPTY (-2)
++#define YYEOF 0
--/* This macro is provided for backward compatibility. */
++#define YYACCEPT goto yyacceptlab
++#define YYABORT goto yyabortlab
++#define YYERROR goto yyerrorlab
--#ifndef YY_LOCATION_PRINT
--# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
--#endif
++#define YYRECOVERING() (!!yyerrstatus)
++
++#define YYBACKUP(Token, Value) \
++do \
++ if (yychar == YYEMPTY) \
++ { \
++ yychar = (Token); \
++ yylval = (Value); \
++ YYPOPSTACK (yylen); \
++ yystate = *yyssp; \
++ goto yybackup; \
++ } \
++ else \
++ { \
++ yyerror (YY_("syntax error: cannot back up")); \
++ YYERROR; \
++ } \
++while (0)
++
++/* Error token number */
++#define YYTERROR 1
++#define YYERRCODE 256
--/* 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
# define YYFPRINTF fprintf
# endif
--# define YYDPRINTF(Args) \
--do { \
-- if (yydebug) \
-- YYFPRINTF Args; \
--} while (YYID (0))
++# define YYDPRINTF(Args) \
++do { \
++ if (yydebug) \
++ YYFPRINTF Args; \
++} while (0)
--# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
--do { \
-- if (yydebug) \
-- { \
-- YYFPRINTF (stderr, "%s ", Title); \
-- yy_symbol_print (stderr, \
-- Type, Value); \
-- YYFPRINTF (stderr, "\n"); \
-- } \
--} while (YYID (0))
++/* This macro is provided for backward compatibility. */
++#ifndef YY_LOCATION_PRINT
++# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
++#endif
--/*--------------------------------.
--| Print this symbol on YYOUTPUT. |
--`--------------------------------*/
++# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
++do { \
++ if (yydebug) \
++ { \
++ YYFPRINTF (stderr, "%s ", Title); \
++ yy_symbol_print (stderr, \
++ Type, Value); \
++ YYFPRINTF (stderr, "\n"); \
++ } \
++} while (0)
++
++
++/*----------------------------------------.
++| Print this symbol's value on YYOUTPUT. |
++`----------------------------------------*/
--/*ARGSUSED*/
--#if (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
--#else
--static void
--yy_symbol_value_print (yyoutput, yytype, yyvaluep)
-- FILE *yyoutput;
-- int yytype;
-- YYSTYPE const * const yyvaluep;
--#endif
{
++ FILE *yyo = yyoutput;
++ YYUSE (yyo);
if (!yyvaluep)
return;
# ifdef YYPRINT
if (yytype < YYNTOKENS)
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
--# else
-- YYUSE (yyoutput);
# endif
-- switch (yytype)
-- {
-- default:
-- break;
-- }
++ YYUSE (yytype);
}
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
--#if (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
--#else
--static void
--yy_symbol_print (yyoutput, yytype, yyvaluep)
-- FILE *yyoutput;
-- int yytype;
-- YYSTYPE const * const yyvaluep;
--#endif
{
-- if (yytype < YYNTOKENS)
-- YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
-- else
-- YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
++ YYFPRINTF (yyoutput, "%s %s (",
++ yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
yy_symbol_value_print (yyoutput, yytype, yyvaluep);
YYFPRINTF (yyoutput, ")");
| TOP (included). |
`------------------------------------------------------------------*/
--#if (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
--#else
--static void
--yy_stack_print (yybottom, yytop)
-- yytype_int16 *yybottom;
-- yytype_int16 *yytop;
--#endif
{
YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)
YYFPRINTF (stderr, "\n");
}
--# define YY_STACK_PRINT(Bottom, Top) \
--do { \
-- if (yydebug) \
-- yy_stack_print ((Bottom), (Top)); \
--} while (YYID (0))
++# 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 __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
static void
--yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
--#else
--static void
--yy_reduce_print (yyvsp, yyrule)
-- YYSTYPE *yyvsp;
-- int yyrule;
--#endif
++yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
{
++ unsigned long int yylno = yyrline[yyrule];
int yynrhs = yyr2[yyrule];
int yyi;
-- unsigned long int yylno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
-- yyrule - 1, yylno);
++ yyrule - 1, yylno);
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
-- yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
-- &(yyvsp[(yyi + 1) - (yynrhs)])
-- );
++ yy_symbol_print (stderr,
++ yystos[yyssp[yyi + 1 - yynrhs]],
++ &(yyvsp[(yyi + 1) - (yynrhs)])
++ );
YYFPRINTF (stderr, "\n");
}
}
--# define YY_REDUCE_PRINT(Rule) \
--do { \
-- if (yydebug) \
-- yy_reduce_print (yyvsp, Rule); \
--} while (YYID (0))
++# define YY_REDUCE_PRINT(Rule) \
++do { \
++ if (yydebug) \
++ yy_reduce_print (yyssp, yyvsp, Rule); \
++} while (0)
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
/* YYINITDEPTH -- initial size of the parser's stacks. */
--#ifndef YYINITDEPTH
++#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif
# define yystrlen strlen
# else
/* Return the length of YYSTR. */
--#if (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
static YYSIZE_T
yystrlen (const char *yystr)
--#else
--static YYSIZE_T
--yystrlen (yystr)
-- const char *yystr;
--#endif
{
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */
--#if (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
static char *
yystpcpy (char *yydest, const char *yysrc)
--#else
--static char *
--yystpcpy (yydest, yysrc)
-- char *yydest;
-- const char *yysrc;
--#endif
{
char *yyd = yydest;
const char *yys = yysrc;
char const *yyp = yystr;
for (;;)
-- switch (*++yyp)
-- {
-- case '\'':
-- case ',':
-- goto do_not_strip_quotes;
--
-- case '\\':
-- if (*++yyp != '\\')
-- goto do_not_strip_quotes;
-- /* Fall through. */
-- default:
-- if (yyres)
-- yyres[yyn] = *yyp;
-- yyn++;
-- break;
--
-- case '"':
-- if (yyres)
-- yyres[yyn] = '\0';
-- return yyn;
-- }
++ switch (*++yyp)
++ {
++ case '\'':
++ case ',':
++ goto do_not_strip_quotes;
++
++ case '\\':
++ if (*++yyp != '\\')
++ goto do_not_strip_quotes;
++ /* Fall through. */
++ default:
++ if (yyres)
++ yyres[yyn] = *yyp;
++ yyn++;
++ break;
++
++ case '"':
++ if (yyres)
++ yyres[yyn] = '\0';
++ return yyn;
++ }
do_not_strip_quotes: ;
}
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
yytype_int16 *yyssp, int yytoken)
{
-- YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
++ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
YYSIZE_T yysize = yysize0;
-- YYSIZE_T yysize1;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */
-- const char *yyformat = 0;
++ const char *yyformat = YY_NULLPTR;
/* Arguments of yyformat. */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Number of reported tokens (one for the "unexpected", one per
int yycount = 0;
/* There are many possibilities here to consider:
-- - Assume YYFAIL is not used. It's too flawed to consider. See
-- <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
-- for details. YYERROR is fine as it does not invoke this
-- function.
- If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected
break;
}
yyarg[yycount++] = yytname[yyx];
-- yysize1 = yysize + yytnamerr (0, yytname[yyx]);
-- if (! (yysize <= yysize1
-- && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-- return 2;
-- yysize = yysize1;
++ {
++ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
++ if (! (yysize <= yysize1
++ && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
++ return 2;
++ yysize = yysize1;
++ }
}
}
}
# undef YYCASE_
}
-- yysize1 = yysize + yystrlen (yyformat);
-- if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-- return 2;
-- yysize = yysize1;
++ {
++ YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
++ if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
++ return 2;
++ yysize = yysize1;
++ }
if (*yymsg_alloc < yysize)
{
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
--/*ARGSUSED*/
--#if (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
--#else
--static void
--yydestruct (yymsg, yytype, yyvaluep)
-- const char *yymsg;
-- int yytype;
-- YYSTYPE *yyvaluep;
--#endif
{
YYUSE (yyvaluep);
--
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
-- switch (yytype)
-- {
--
-- default:
-- break;
-- }
++ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
++ YYUSE (yytype);
++ YY_IGNORE_MAYBE_UNINITIALIZED_END
}
--/* 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. */
/* 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 __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
--int
--yyparse (void *YYPARSE_PARAM)
--#else
--int
--yyparse (YYPARSE_PARAM)
-- void *YYPARSE_PARAM;
--#endif
--#else /* ! YYPARSE_PARAM */
--#if (defined __STDC__ || defined __C99__FUNC__ \
-- || defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
--#else
--int
--yyparse ()
--
--#endif
--#endif
{
int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* The stacks and their tools:
-- `yyss': related to states.
-- `yyvs': related to semantic values.
++ 'yyss': related to states.
++ 'yyvs': related to semantic values.
-- Refer to the stacks thru separate pointers, to allow yyoverflow
++ Refer to the stacks through separate pointers, to allow yyoverflow
to reallocate them elsewhere. */
/* The state stack. */
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
-- int yytoken;
++ int yytoken = 0;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
Keep to zero when no symbol should be popped. */
int yylen = 0;
-- yytoken = 0;
-- yyss = yyssa;
-- yyvs = yyvsa;
++ yyssp = yyss = yyssa;
++ yyvsp = yyvs = yyvsa;
yystacksize = YYINITDEPTH;
YYDPRINTF ((stderr, "Starting parse\n"));
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;
/*------------------------------------------------------------.
#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;
-- yytype_int16 *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 (YY_("memory exhausted"),
-- &yyss1, yysize * sizeof (*yyssp),
-- &yyvs1, yysize * sizeof (*yyvsp),
-- &yystacksize);
--
-- yyss = yyss1;
-- yyvs = yyvs1;
++ /* 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;
++ yytype_int16 *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 (YY_("memory exhausted"),
++ &yyss1, yysize * sizeof (*yyssp),
++ &yyvs1, yysize * sizeof (*yyvsp),
++ &yystacksize);
++
++ yyss = yyss1;
++ yyvs = yyvs1;
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
-- goto yyexhaustedlab;
++ goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
-- yystacksize = YYMAXDEPTH;
++ yystacksize = YYMAXDEPTH;
{
-- yytype_int16 *yyss1 = yyss;
-- union yyalloc *yyptr =
-- (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
-- if (! yyptr)
-- goto yyexhaustedlab;
-- YYSTACK_RELOCATE (yyss_alloc, yyss);
-- YYSTACK_RELOCATE (yyvs_alloc, yyvs);
++ yytype_int16 *yyss1 = yyss;
++ union yyalloc *yyptr =
++ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
++ if (! yyptr)
++ goto yyexhaustedlab;
++ YYSTACK_RELOCATE (yyss_alloc, yyss);
++ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
-- if (yyss1 != yyssa)
-- YYSTACK_FREE (yyss1);
++ if (yyss1 != yyssa)
++ YYSTACK_FREE (yyss1);
}
# endif
#endif /* no yyoverflow */
yyvsp = yyvs + yysize - 1;
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-- (unsigned long int) yystacksize));
++ (unsigned long int) yystacksize));
if (yyss + yystacksize - 1 <= yyssp)
-- YYABORT;
++ YYABORT;
}
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
-- yychar = YYLEX;
++ yychar = yylex ();
}
if (yychar <= YYEOF)
yychar = YYEMPTY;
yystate = yyn;
++ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
++ YY_IGNORE_MAYBE_UNINITIALIZED_END
goto yynewstate;
yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
-- `$$ = $1'.
++ '$$ = $1'.
Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison
switch (yyn)
{
case 4:
--
--/* Line 1806 of yacc.c */
--#line 132 "parsedate.y"
++#line 132 "parsedate.y" /* yacc.c:1646 */
{
yyHaveTime++;
#ifdef lint
}
#endif /* lint */
}
++#line 1364 "y.tab.c" /* yacc.c:1646 */
break;
case 5:
--
--/* Line 1806 of yacc.c */
--#line 141 "parsedate.y"
++#line 141 "parsedate.y" /* yacc.c:1646 */
{
yyHaveTime++;
-- yyTimezone = (yyvsp[(2) - (2)].Number);
++ yyTimezone = (yyvsp[0].Number);
}
++#line 1373 "y.tab.c" /* yacc.c:1646 */
break;
case 6:
--
--/* Line 1806 of yacc.c */
--#line 145 "parsedate.y"
++#line 145 "parsedate.y" /* yacc.c:1646 */
{
yyHaveDate++;
}
++#line 1381 "y.tab.c" /* yacc.c:1646 */
break;
case 7:
--
--/* Line 1806 of yacc.c */
--#line 148 "parsedate.y"
++#line 148 "parsedate.y" /* yacc.c:1646 */
{
yyHaveRel = 1;
}
++#line 1389 "y.tab.c" /* yacc.c:1646 */
break;
case 8:
--
--/* Line 1806 of yacc.c */
--#line 153 "parsedate.y"
++#line 153 "parsedate.y" /* yacc.c:1646 */
{
-- if ((yyvsp[(1) - (2)].Number) < 100) {
-- yyHour = (yyvsp[(1) - (2)].Number);
++ if ((yyvsp[-1].Number) < 100) {
++ yyHour = (yyvsp[-1].Number);
yyMinutes = 0;
}
else {
-- yyHour = (yyvsp[(1) - (2)].Number) / 100;
-- yyMinutes = (yyvsp[(1) - (2)].Number) % 100;
++ yyHour = (yyvsp[-1].Number) / 100;
++ yyMinutes = (yyvsp[-1].Number) % 100;
}
yySeconds = 0;
-- yyMeridian = (yyvsp[(2) - (2)].Meridian);
++ yyMeridian = (yyvsp[0].Meridian);
}
++#line 1406 "y.tab.c" /* yacc.c:1646 */
break;
case 9:
--
--/* Line 1806 of yacc.c */
--#line 165 "parsedate.y"
++#line 165 "parsedate.y" /* yacc.c:1646 */
{
-- yyHour = (yyvsp[(1) - (4)].Number);
-- yyMinutes = (yyvsp[(3) - (4)].Number);
++ yyHour = (yyvsp[-3].Number);
++ yyMinutes = (yyvsp[-1].Number);
yySeconds = 0;
-- yyMeridian = (yyvsp[(4) - (4)].Meridian);
++ yyMeridian = (yyvsp[0].Meridian);
}
++#line 1417 "y.tab.c" /* yacc.c:1646 */
break;
case 10:
--
--/* Line 1806 of yacc.c */
--#line 171 "parsedate.y"
++#line 171 "parsedate.y" /* yacc.c:1646 */
{
-- yyHour = (yyvsp[(1) - (4)].Number);
-- yyMinutes = (yyvsp[(3) - (4)].Number);
-- yyTimezone = (yyvsp[(4) - (4)].Number);
++ yyHour = (yyvsp[-3].Number);
++ yyMinutes = (yyvsp[-1].Number);
++ yyTimezone = (yyvsp[0].Number);
yyMeridian = MER24;
yyDSTmode = DSToff;
}
++#line 1429 "y.tab.c" /* yacc.c:1646 */
break;
case 11:
--
--/* Line 1806 of yacc.c */
--#line 178 "parsedate.y"
++#line 178 "parsedate.y" /* yacc.c:1646 */
{
-- yyHour = (yyvsp[(1) - (6)].Number);
-- yyMinutes = (yyvsp[(3) - (6)].Number);
-- yySeconds = (yyvsp[(5) - (6)].Number);
-- yyMeridian = (yyvsp[(6) - (6)].Meridian);
++ yyHour = (yyvsp[-5].Number);
++ yyMinutes = (yyvsp[-3].Number);
++ yySeconds = (yyvsp[-1].Number);
++ yyMeridian = (yyvsp[0].Meridian);
}
++#line 1440 "y.tab.c" /* yacc.c:1646 */
break;
case 12:
--
--/* Line 1806 of yacc.c */
--#line 184 "parsedate.y"
++#line 184 "parsedate.y" /* yacc.c:1646 */
{
-- yyHour = (yyvsp[(1) - (6)].Number);
-- yyMinutes = (yyvsp[(3) - (6)].Number);
-- yySeconds = (yyvsp[(5) - (6)].Number);
-- yyTimezone = (yyvsp[(6) - (6)].Number);
++ yyHour = (yyvsp[-5].Number);
++ yyMinutes = (yyvsp[-3].Number);
++ yySeconds = (yyvsp[-1].Number);
++ yyTimezone = (yyvsp[0].Number);
yyMeridian = MER24;
yyDSTmode = DSToff;
}
++#line 1453 "y.tab.c" /* yacc.c:1646 */
break;
case 13:
--
--/* Line 1806 of yacc.c */
--#line 194 "parsedate.y"
++#line 194 "parsedate.y" /* yacc.c:1646 */
{
-- (yyval.Number) = (yyvsp[(1) - (1)].Number);
++ (yyval.Number) = (yyvsp[0].Number);
yyDSTmode = DSToff;
}
++#line 1462 "y.tab.c" /* yacc.c:1646 */
break;
case 14:
--
--/* Line 1806 of yacc.c */
--#line 198 "parsedate.y"
++#line 198 "parsedate.y" /* yacc.c:1646 */
{
-- (yyval.Number) = (yyvsp[(1) - (1)].Number);
++ (yyval.Number) = (yyvsp[0].Number);
yyDSTmode = DSTon;
}
++#line 1471 "y.tab.c" /* yacc.c:1646 */
break;
case 15:
--
--/* Line 1806 of yacc.c */
--#line 202 "parsedate.y"
++#line 202 "parsedate.y" /* yacc.c:1646 */
{
/* Only allow "GMT+300" and "GMT-0800" */
-- if ((yyvsp[(1) - (2)].Number) != 0) {
++ if ((yyvsp[-1].Number) != 0) {
YYABORT;
}
-- (yyval.Number) = (yyvsp[(2) - (2)].Number);
++ (yyval.Number) = (yyvsp[0].Number);
yyDSTmode = DSToff;
}
++#line 1484 "y.tab.c" /* yacc.c:1646 */
break;
case 16:
--
--/* Line 1806 of yacc.c */
--#line 210 "parsedate.y"
++#line 210 "parsedate.y" /* yacc.c:1646 */
{
-- (yyval.Number) = (yyvsp[(1) - (1)].Number);
++ (yyval.Number) = (yyvsp[0].Number);
yyDSTmode = DSToff;
}
++#line 1493 "y.tab.c" /* yacc.c:1646 */
break;
case 17:
--
--/* Line 1806 of yacc.c */
--#line 216 "parsedate.y"
++#line 216 "parsedate.y" /* yacc.c:1646 */
{
int i;
/* Unix and GMT and numeric timezones -- a little confusing. */
-- if ((yyvsp[(1) - (1)].Number) < 0) {
++ if ((yyvsp[0].Number) < 0) {
/* Don't work with negative modulus. */
-- (yyvsp[(1) - (1)].Number) = -(yyvsp[(1) - (1)].Number);
-- if ((yyvsp[(1) - (1)].Number) > 9999 || (i = (yyvsp[(1) - (1)].Number) % 100) >= 60) {
++ (yyvsp[0].Number) = -(yyvsp[0].Number);
++ if ((yyvsp[0].Number) > 9999 || (i = (yyvsp[0].Number) % 100) >= 60) {
YYABORT;
}
-- (yyval.Number) = ((yyvsp[(1) - (1)].Number) / 100) * 60 + i;
++ (yyval.Number) = ((yyvsp[0].Number) / 100) * 60 + i;
}
else {
-- if ((yyvsp[(1) - (1)].Number) > 9999 || (i = (yyvsp[(1) - (1)].Number) % 100) >= 60) {
++ if ((yyvsp[0].Number) > 9999 || (i = (yyvsp[0].Number) % 100) >= 60) {
YYABORT;
}
-- (yyval.Number) = -(((yyvsp[(1) - (1)].Number) / 100) * 60 + i);
++ (yyval.Number) = -(((yyvsp[0].Number) / 100) * 60 + i);
}
}
++#line 1517 "y.tab.c" /* yacc.c:1646 */
break;
case 18:
--
--/* Line 1806 of yacc.c */
--#line 237 "parsedate.y"
++#line 237 "parsedate.y" /* yacc.c:1646 */
{
-- yyMonth = (yyvsp[(1) - (3)].Number);
-- yyDay = (yyvsp[(3) - (3)].Number);
++ yyMonth = (yyvsp[-2].Number);
++ yyDay = (yyvsp[0].Number);
}
++#line 1526 "y.tab.c" /* yacc.c:1646 */
break;
case 19:
--
--/* Line 1806 of yacc.c */
--#line 241 "parsedate.y"
++#line 241 "parsedate.y" /* yacc.c:1646 */
{
-- if ((yyvsp[(1) - (5)].Number) > 100) {
-- yyYear = (yyvsp[(1) - (5)].Number);
-- yyMonth = (yyvsp[(3) - (5)].Number);
-- yyDay = (yyvsp[(5) - (5)].Number);
++ if ((yyvsp[-4].Number) > 100) {
++ yyYear = (yyvsp[-4].Number);
++ yyMonth = (yyvsp[-2].Number);
++ yyDay = (yyvsp[0].Number);
}
else {
-- yyMonth = (yyvsp[(1) - (5)].Number);
-- yyDay = (yyvsp[(3) - (5)].Number);
-- yyYear = (yyvsp[(5) - (5)].Number);
++ yyMonth = (yyvsp[-4].Number);
++ yyDay = (yyvsp[-2].Number);
++ yyYear = (yyvsp[0].Number);
}
}
++#line 1543 "y.tab.c" /* yacc.c:1646 */
break;
case 20:
--
--/* Line 1806 of yacc.c */
--#line 253 "parsedate.y"
++#line 253 "parsedate.y" /* yacc.c:1646 */
{
-- yyMonth = (yyvsp[(1) - (2)].Number);
-- yyDay = (yyvsp[(2) - (2)].Number);
++ yyMonth = (yyvsp[-1].Number);
++ yyDay = (yyvsp[0].Number);
}
++#line 1552 "y.tab.c" /* yacc.c:1646 */
break;
case 21:
--
--/* Line 1806 of yacc.c */
--#line 257 "parsedate.y"
++#line 257 "parsedate.y" /* yacc.c:1646 */
{
-- yyMonth = (yyvsp[(1) - (4)].Number);
-- yyDay = (yyvsp[(2) - (4)].Number);
-- yyYear = (yyvsp[(4) - (4)].Number);
++ yyMonth = (yyvsp[-3].Number);
++ yyDay = (yyvsp[-2].Number);
++ yyYear = (yyvsp[0].Number);
}
++#line 1562 "y.tab.c" /* yacc.c:1646 */
break;
case 22:
--
--/* Line 1806 of yacc.c */
--#line 262 "parsedate.y"
++#line 262 "parsedate.y" /* yacc.c:1646 */
{
-- yyDay = (yyvsp[(1) - (2)].Number);
-- yyMonth = (yyvsp[(2) - (2)].Number);
++ yyDay = (yyvsp[-1].Number);
++ yyMonth = (yyvsp[0].Number);
}
++#line 1571 "y.tab.c" /* yacc.c:1646 */
break;
case 23:
--
--/* Line 1806 of yacc.c */
--#line 266 "parsedate.y"
++#line 266 "parsedate.y" /* yacc.c:1646 */
{
-- yyDay = (yyvsp[(1) - (3)].Number);
-- yyMonth = (yyvsp[(2) - (3)].Number);
-- yyYear = (yyvsp[(3) - (3)].Number);
++ yyDay = (yyvsp[-2].Number);
++ yyMonth = (yyvsp[-1].Number);
++ yyYear = (yyvsp[0].Number);
}
++#line 1581 "y.tab.c" /* yacc.c:1646 */
break;
case 24:
--
--/* Line 1806 of yacc.c */
--#line 271 "parsedate.y"
++#line 271 "parsedate.y" /* yacc.c:1646 */
{
-- yyDay = (yyvsp[(3) - (5)].Number);
-- yyMonth = (yyvsp[(4) - (5)].Number);
-- yyYear = (yyvsp[(5) - (5)].Number);
++ yyDay = (yyvsp[-2].Number);
++ yyMonth = (yyvsp[-1].Number);
++ yyYear = (yyvsp[0].Number);
}
++#line 1591 "y.tab.c" /* yacc.c:1646 */
break;
case 25:
--
--/* Line 1806 of yacc.c */
--#line 278 "parsedate.y"
++#line 278 "parsedate.y" /* yacc.c:1646 */
{
-- yyRelSeconds += (yyvsp[(1) - (2)].Number) * (yyvsp[(2) - (2)].Number);
++ yyRelSeconds += (yyvsp[-1].Number) * (yyvsp[0].Number);
}
++#line 1599 "y.tab.c" /* yacc.c:1646 */
break;
case 26:
--
--/* Line 1806 of yacc.c */
--#line 281 "parsedate.y"
++#line 281 "parsedate.y" /* yacc.c:1646 */
{
-- yyRelSeconds += (yyvsp[(1) - (2)].Number) * (yyvsp[(2) - (2)].Number);
++ yyRelSeconds += (yyvsp[-1].Number) * (yyvsp[0].Number);
}
++#line 1607 "y.tab.c" /* yacc.c:1646 */
break;
case 27:
--
--/* Line 1806 of yacc.c */
--#line 284 "parsedate.y"
++#line 284 "parsedate.y" /* yacc.c:1646 */
{
-- yyRelMonth += (yyvsp[(1) - (2)].Number) * (yyvsp[(2) - (2)].Number);
++ yyRelMonth += (yyvsp[-1].Number) * (yyvsp[0].Number);
}
++#line 1615 "y.tab.c" /* yacc.c:1646 */
break;
case 28:
--
--/* Line 1806 of yacc.c */
--#line 287 "parsedate.y"
++#line 287 "parsedate.y" /* yacc.c:1646 */
{
-- yyRelMonth += (yyvsp[(1) - (2)].Number) * (yyvsp[(2) - (2)].Number);
++ yyRelMonth += (yyvsp[-1].Number) * (yyvsp[0].Number);
}
++#line 1623 "y.tab.c" /* yacc.c:1646 */
break;
case 29:
--
--/* Line 1806 of yacc.c */
--#line 292 "parsedate.y"
++#line 292 "parsedate.y" /* yacc.c:1646 */
{
(yyval.Meridian) = MER24;
}
++#line 1631 "y.tab.c" /* yacc.c:1646 */
break;
case 30:
--
--/* Line 1806 of yacc.c */
--#line 295 "parsedate.y"
++#line 295 "parsedate.y" /* yacc.c:1646 */
{
-- (yyval.Meridian) = (yyvsp[(1) - (1)].Meridian);
++ (yyval.Meridian) = (yyvsp[0].Meridian);
}
++#line 1639 "y.tab.c" /* yacc.c:1646 */
break;
--
--/* Line 1806 of yacc.c */
--#line 1832 "y.tab.c"
++#line 1643 "y.tab.c" /* yacc.c:1646 */
default: break;
}
/* User semantic actions sometimes alter yychar, and that requires
*++yyvsp = yyval;
-- /* Now `shift' the result of the reduction. Determine what state
++ /* 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. */
goto yynewstate;
--/*------------------------------------.
--| yyerrlab -- here on detecting error |
--`------------------------------------*/
++/*--------------------------------------.
++| yyerrlab -- here on detecting error. |
++`--------------------------------------*/
yyerrlab:
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
if (yyerrstatus == 3)
{
/* If just tried and failed to reuse lookahead token after an
-- error, discard it. */
++ error, discard it. */
if (yychar <= YYEOF)
-- {
-- /* Return failure if at end of input. */
-- if (yychar == YYEOF)
-- YYABORT;
-- }
++ {
++ /* Return failure if at end of input. */
++ if (yychar == YYEOF)
++ YYABORT;
++ }
else
-- {
-- yydestruct ("Error: discarding",
-- yytoken, &yylval);
-- yychar = YYEMPTY;
-- }
++ {
++ yydestruct ("Error: discarding",
++ yytoken, &yylval);
++ yychar = YYEMPTY;
++ }
}
/* Else will try to reuse lookahead token after shifting the error
if (/*CONSTCOND*/ 0)
goto yyerrorlab;
-- /* Do not reclaim the symbols of the rule which action triggered
++ /* Do not reclaim the symbols of the rule whose action triggered
this YYERROR. */
YYPOPSTACK (yylen);
yylen = 0;
| yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/
yyerrlab1:
-- yyerrstatus = 3; /* Each real token shifted decrements this. */
++ yyerrstatus = 3; /* Each real token shifted decrements this. */
for (;;)
{
yyn = yypact[yystate];
if (!yypact_value_is_default (yyn))
-- {
-- yyn += YYTERROR;
-- if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
-- {
-- yyn = yytable[yyn];
-- if (0 < yyn)
-- break;
-- }
-- }
++ {
++ 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;
++ YYABORT;
yydestruct ("Error: popping",
-- yystos[yystate], yyvsp);
++ yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
++ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
++ YY_IGNORE_MAYBE_UNINITIALIZED_END
/* Shift the error token. */
yyresult = 1;
goto yyreturn;
--#if !defined(yyoverflow) || YYERROR_VERBOSE
++#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval);
}
-- /* Do not reclaim the symbols of the rule which action triggered
++ /* Do not reclaim the symbols of the rule whose action triggered
this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
-- yystos[*yyssp], yyvsp);
++ yystos[*yyssp], yyvsp);
YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
-- /* Make sure YYID is used. */
-- return YYID (yyresult);
++ return yyresult;
}
--
--
--
--/* Line 2067 of yacc.c */
--#line 300 "parsedate.y"
++#line 300 "parsedate.y" /* yacc.c:1906 */
/* Month and day table. */
/* NOTREACHED */
}
#endif /* TEST */
--
projects / citadel.git / commitdiff