Warning, file /frameworks/kholidays/src/parsers/plan2/holidayparserplan.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 
 /* A Bison parser, made by GNU Bison 2.4.1.  */
 
 /*  Skeleton implementation for Bison LALR(1) parsers in C++
 
     SPDX-FileCopyrightText: 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
 
     SPDX-License-Identifier: GPL-3.0-or-later WITH Bison-exception-2.2
 */
 
 // Take the name prefix into account.
 #define yylex KHolidayslex
 
 /* First part of user declarations.  */
 
 /* Line 311 of lalr1.cc  */
 #line 30 "holidayparserplan.ypp"
 /*** C/C++ Declarations ***/
 
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <QString>
 
 // clang-format off
 
 /* Line 311 of lalr1.cc  */
 #line 60 "holidayparserplan.cpp"
 
 #include "holidayparserplan.hpp"
 
 /* User implementation prologue.  */
 
 /* Line 317 of lalr1.cc  */
 #line 111 "holidayparserplan.ypp"
 
 #include "holidayparserdriverplan_p.h"
 #include "holidayscannerplan_p.h"
 
 /* this "connects" the bison parser in the driver to the flex scanner class
  * object. it defines the yylex() function call to pull the next token from the
  * current lexer object of the driver context. */
 #undef yylex
 #define yylex driver.m_scanner->lex
 
 /* Line 317 of lalr1.cc  */
 #line 83 "holidayparserplan.cpp"
 
 #ifndef YY_
 # if defined(YYENABLE_NLS) && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 #  endif
 # endif
 # ifndef YY_
 #  define YY_(msgid) msgid
 # endif
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
 #define YYUSE(e) ((void) (e))
 
 /* Enable debugging if requested.  */
 #if YYDEBUG
 
 /* A pseudo ostream that takes yydebug_ into account.  */
 # define YYCDEBUG if (yydebug_) (*yycdebug_)
 
 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)  \
     do {                            \
         if (yydebug_)                     \
         {                           \
             *yycdebug_ << Title << ' ';           \
             yy_symbol_print_ ((Type), (Value), (Location));   \
             *yycdebug_ << std::endl;              \
         }                           \
     } while (false)
 
 # define YY_REDUCE_PRINT(Rule)      \
     do {                    \
         if (yydebug_)             \
             yy_reduce_print_ (Rule);        \
     } while (false)
 
 # define YY_STACK_PRINT()       \
     do {                    \
         if (yydebug_)             \
             yystack_print_ ();          \
     } while (false)
 
 #else /* !YYDEBUG */
 
 # define YYCDEBUG if (false) std::cerr
 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 # define YY_REDUCE_PRINT(Rule)
 # define YY_STACK_PRINT()
 
 #endif /* !YYDEBUG */
 
 #define yyerrok     (yyerrstatus_ = 0)
 #define yyclearin   (yychar = yyempty_)
 
 #define YYACCEPT    goto yyacceptlab
 #define YYABORT     goto yyabortlab
 #define YYERROR     goto yyerrorlab
 #define YYRECOVERING()  (!!yyerrstatus_)
 
 /* Line 380 of lalr1.cc  */
 #line 1 "[Bison:b4_percent_define_default]"
 
 namespace KHolidays
 {
 
 /* Line 380 of lalr1.cc  */
 #line 152 "holidayparserplan.cpp"
 #if YYERROR_VERBOSE
 
 /* Return YYSTR after stripping away unnecessary quotes and
    backslashes, so that it's suitable for yyerror.  The heuristic is
    that double-quoting is unnecessary unless the string contains an
    apostrophe, a comma, or backslash (other than backslash-backslash).
    YYSTR is taken from yytname.  */
 std::string
 HolidayParserPlan::yytnamerr_(const char *yystr)
 {
     if (*yystr == '"') {
         std::string yyr = "";
         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:
                 yyr += *yyp;
                 break;
 
             case '"':
                 return yyr;
             }
     do_not_strip_quotes:;
     }
 
     return yystr;
 }
 
 #endif
 
 /// Build a parser object.
 HolidayParserPlan::HolidayParserPlan(class HolidayParserDriverPlan &driver_yyarg)
     :
 #if YYDEBUG
     yydebug_(false),
     yycdebug_(&std::cerr),
 #endif
     driver(driver_yyarg)
 {
 }
 
 HolidayParserPlan::~HolidayParserPlan()
 {
 }
 
 #if YYDEBUG
 /*--------------------------------.
 | Print this symbol on YYOUTPUT.  |
 `--------------------------------*/
 
 inline void
 HolidayParserPlan::yy_symbol_value_print_(int yytype,
         const semantic_type *yyvaluep, const location_type *yylocationp)
 {
     YYUSE(yylocationp);
     YYUSE(yyvaluep);
     switch (yytype) {
     default:
         break;
     }
 }
 
 void
 HolidayParserPlan::yy_symbol_print_(int yytype,
                                     const semantic_type *yyvaluep, const location_type *yylocationp)
 {
     *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
                << ' ' << yytname_[yytype] << " ("
                << *yylocationp << ": ";
     yy_symbol_value_print_(yytype, yyvaluep, yylocationp);
     *yycdebug_ << ')';
 }
 #endif
 
 void
 HolidayParserPlan::yydestruct_(const char *yymsg,
                                int yytype, semantic_type *yyvaluep, location_type *yylocationp)
 {
     YYUSE(yylocationp);
     YYUSE(yymsg);
     YYUSE(yyvaluep);
 
     YY_SYMBOL_PRINT(yymsg, yytype, yyvaluep, yylocationp);
 
     switch (yytype) {
     case 6: /* "STRING" */
 
         /* Line 480 of lalr1.cc  */
 #line 96 "holidayparserplan.ypp"
         {
             free((yyvaluep->sval));
         };
 
         /* Line 480 of lalr1.cc  */
 #line 259 "holidayparserplan.cpp"
         break;
 
     default:
         break;
     }
 }
 
 void
 HolidayParserPlan::yypop_(unsigned int n)
 {
     yystate_stack_.pop(n);
     yysemantic_stack_.pop(n);
     yylocation_stack_.pop(n);
 }
 
 #if YYDEBUG
 std::ostream &
 HolidayParserPlan::debug_stream() const
 {
     return *yycdebug_;
 }
 
 void
 HolidayParserPlan::set_debug_stream(std::ostream &o)
 {
     yycdebug_ = &o;
 }
 
 HolidayParserPlan::debug_level_type
 HolidayParserPlan::debug_level() const
 {
     return yydebug_;
 }
 
 void
 HolidayParserPlan::set_debug_level(debug_level_type l)
 {
     yydebug_ = l;
 }
 #endif
 
 int
 HolidayParserPlan::parse()
 {
     /// Lookahead and lookahead in internal form.
     int yychar = yyempty_;
     int yytoken = 0;
 
     /* State.  */
     int yyn;
     int yylen = 0;
     int yystate = 0;
 
     /* Error handling.  */
     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 
     /// Semantic value of the lookahead.
     semantic_type yylval;
     /// Location of the lookahead.
     location_type yylloc;
     /// The locations where the error started and ended.
     location_type yyerror_range[2];
 
     /// $$.
     semantic_type yyval;
     /// @$.
     location_type yyloc;
 
     int yyresult;
 
     YYCDEBUG << "Starting parse" << std::endl;
 
     /* User initialization code.  */
 
     /* Line 553 of lalr1.cc  */
 #line 70 "holidayparserplan.ypp"
     {
         // initialize the initial location object
         yylloc.begin.filename = driver.fileToParse();
         yylloc.end.filename = yylloc.begin.filename;
     }
 
     /* Line 553 of lalr1.cc  */
 #line 346 "holidayparserplan.cpp"
 
     /* Initialize the stacks.  The initial state will be pushed in
        yynewstate, since the latter expects the semantical and the
        location values to have been already stored, initialize these
        stacks with a primary value.  */
     yystate_stack_ = state_stack_type(0);
     yysemantic_stack_ = semantic_stack_type(0);
     yylocation_stack_ = location_stack_type(0);
     yysemantic_stack_.push(yylval);
     yylocation_stack_.push(yylloc);
 
     /* New state.  */
 yynewstate:
     yystate_stack_.push(yystate);
     YYCDEBUG << "Entering state " << yystate << std::endl;
 
     /* Accept?  */
     if (yystate == yyfinal_) {
         goto yyacceptlab;
     }
 
     goto yybackup;
 
     /* Backup.  */
 yybackup:
 
     /* Try to take a decision without lookahead.  */
     yyn = yypact_[yystate];
     if (yyn == yypact_ninf_) {
         goto yydefault;
     }
 
     /* Read a lookahead token.  */
     if (yychar == yyempty_) {
         YYCDEBUG << "Reading a token: ";
         yychar = yylex(&yylval, &yylloc);
     }
 
     /* Convert token to internal form.  */
     if (yychar <= yyeof_) {
         yychar = yytoken = yyeof_;
         YYCDEBUG << "Now at end of input." << std::endl;
     } else {
         yytoken = yytranslate_(yychar);
         YY_SYMBOL_PRINT("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;
     }
 
     /* Reduce or error.  */
     yyn = yytable_[yyn];
     if (yyn <= 0) {
         if (yyn == 0 || yyn == yytable_ninf_) {
             goto yyerrlab;
         }
         yyn = -yyn;
         goto yyreduce;
     }
 
     /* Shift the lookahead token.  */
     YY_SYMBOL_PRINT("Shifting", yytoken, &yylval, &yylloc);
 
     /* Discard the token being shifted.  */
     yychar = yyempty_;
 
     yysemantic_stack_.push(yylval);
     yylocation_stack_.push(yylloc);
 
     /* 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:
     yylen = yyr2_[yyn];
     /* If YYLEN is nonzero, implement the default value of the action:
        `$$ = $1'.  Otherwise, use the top of the stack.
 
        Otherwise, the following line sets YYVAL to garbage.
        This behavior is undocumented and Bison
        users should not rely upon it.  */
     if (yylen) {
         yyval = yysemantic_stack_[yylen - 1];
     } else {
         yyval = yysemantic_stack_[0];
     }
 
     {
         slice<location_type, location_stack_type> slice(yylocation_stack_, yylen);
         YYLLOC_DEFAULT(yyloc, slice, yylen);
     }
     YY_REDUCE_PRINT(yyn);
     switch (yyn) {
     case 4:
 
         /* Line 678 of lalr1.cc  */
 #line 132 "holidayparserplan.ypp"
         {
             driver.setFileCountryCode(QString());
         }
         break;
 
     case 5:
 
         /* Line 678 of lalr1.cc  */
 #line 133 "holidayparserplan.ypp"
         {
             char *s = (yysemantic_stack_[(2) - (2)].sval);
             driver.setFileCountryCode(QString::fromUtf8(s));
             free(s);
             (yysemantic_stack_[(2) - (2)].sval) = nullptr;
         }
         break;
 
     case 6:
 
         /* Line 678 of lalr1.cc  */
 #line 136 "holidayparserplan.ypp"
         {
             driver.setFileLanguageCode(QString());
         }
         break;
 
     case 7:
 
         /* Line 678 of lalr1.cc  */
 #line 137 "holidayparserplan.ypp"
         {
             char *s = (yysemantic_stack_[(2) - (2)].sval);
             driver.setFileLanguageCode(QString::fromUtf8(s));
             free(s);
             (yysemantic_stack_[(2) - (2)].sval) = nullptr;
         }
         break;
 
     case 8:
 
         /* Line 678 of lalr1.cc  */
 #line 140 "holidayparserplan.ypp"
         {
             driver.setFileName(QString());
         }
         break;
 
     case 9:
 
         /* Line 678 of lalr1.cc  */
 #line 141 "holidayparserplan.ypp"
         {
             char *s = (yysemantic_stack_[(2) - (2)].sval);
             driver.setFileName(QString::fromUtf8(s));
             free(s);
             (yysemantic_stack_[(2) - (2)].sval) = nullptr;
         }
         break;
 
     case 10:
 
         /* Line 678 of lalr1.cc  */
 #line 144 "holidayparserplan.ypp"
         {
             driver.setFileDescription(QString());
         }
         break;
 
     case 11:
 
         /* Line 678 of lalr1.cc  */
 #line 145 "holidayparserplan.ypp"
         {
             char *s = (yysemantic_stack_[(2) - (2)].sval);
             driver.setFileDescription(QString::fromUtf8(s));
             free(s);
             (yysemantic_stack_[(2) - (2)].sval) = nullptr;
         }
         break;
 
     case 14:
 
         /* Line 678 of lalr1.cc  */
 #line 152 "holidayparserplan.ypp"
         {
             char *s = (yysemantic_stack_[(1) - (1)].sval);
             driver.setEventName(QString::fromUtf8(s));
             free(s);
             (yysemantic_stack_[(1) - (1)].sval) = nullptr;
         }
         break;
 
     case 15:
 
         /* Line 678 of lalr1.cc  */
 #line 155 "holidayparserplan.ypp"
         {
             driver.setEventCategory((yysemantic_stack_[(1) - (1)].sval));
         }
         break;
 
     case 16:
 
         /* Line 678 of lalr1.cc  */
 #line 156 "holidayparserplan.ypp"
         {
             driver.setEventCategory((yysemantic_stack_[(2) - (2)].sval));
         }
         break;
 
     case 17:
 
         /* Line 678 of lalr1.cc  */
 #line 159 "holidayparserplan.ypp"
         {
             driver.setEventCalendarType(QStringLiteral("gregorian"));
         }
         break;
 
     case 18:
 
         /* Line 678 of lalr1.cc  */
 #line 160 "holidayparserplan.ypp"
         {
             driver.setEventCalendarType(QString::fromUtf8((yysemantic_stack_[(1) - (1)].sval)));
         }
         break;
 
     case 19:
 
         /* Line 678 of lalr1.cc  */
 #line 163 "holidayparserplan.ypp"
         {
             driver.setFromEaster((yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (3)].ival));
         }
         break;
 
     case 20:
 
         /* Line 678 of lalr1.cc  */
 #line 164 "holidayparserplan.ypp"
         {
             driver.setFromPascha((yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (3)].ival));
         }
         break;
 
     case 21:
 
         /* Line 678 of lalr1.cc  */
 #line 165 "holidayparserplan.ypp"
         {
             driver.setFromDate((yysemantic_stack_[(4) - (2)].ival), (yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (4)].ival));
         }
         break;
 
     case 22:
 
         /* Line 678 of lalr1.cc  */
 #line 166 "holidayparserplan.ypp"
         {
             driver.setFromWeekdayInMonth(1, (yysemantic_stack_[(3) - (1)].ival), 1, (yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (3)].ival));
         }
         break;
 
     case 23:
 
         /* Line 678 of lalr1.cc  */
 #line 167 "holidayparserplan.ypp"
         {
             driver.setFromWeekdayInMonth((yysemantic_stack_[(4) - (1)].ival), (yysemantic_stack_[(4) - (2)].ival), 1, (yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (4)].ival));
         }
         break;
 
     case 24:
 
         /* Line 678 of lalr1.cc  */
 #line 168 "holidayparserplan.ypp"
         {
             driver.setFromWeekdayInMonth((yysemantic_stack_[(6) - (1)].ival), (yysemantic_stack_[(6) - (2)].ival), (yysemantic_stack_[(6) - (4)].ival), (yysemantic_stack_[(6) - (5)].ival), (yysemantic_stack_[(6) - (6)].ival));
         }
         break;
 
     case 25:
 
         /* Line 678 of lalr1.cc  */
 #line 169 "holidayparserplan.ypp"
         {
             driver.setFromRelativeWeekday((yysemantic_stack_[(5) - (2)].ival), (yysemantic_stack_[(5) - (1)].ival), (yysemantic_stack_[(5) - (4)].ival), (yysemantic_stack_[(5) - (5)].ival));
         }
         break;
 
     case 26:
 
         /* Line 678 of lalr1.cc  */
 #line 172 "holidayparserplan.ypp"
         {
             (yyval.ival) =   0;
         }
         break;
 
     case 27:
 
         /* Line 678 of lalr1.cc  */
 #line 173 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(2) - (2)].ival);
         }
         break;
 
     case 28:
 
         /* Line 678 of lalr1.cc  */
 #line 174 "holidayparserplan.ypp"
         {
             (yyval.ival) = -(yysemantic_stack_[(2) - (2)].ival);
         }
         break;
 
     case 29:
 
         /* Line 678 of lalr1.cc  */
 #line 177 "holidayparserplan.ypp"
         {
             (yyval.ival) = 0;
         }
         break;
 
     case 30:
 
         /* Line 678 of lalr1.cc  */
 #line 178 "holidayparserplan.ypp"
         {
             (yyval.ival) = ((yysemantic_stack_[(4) - (2)].ival) << 8) | (yysemantic_stack_[(4) - (4)].ival);
         }
         break;
 
     case 31:
 
         /* Line 678 of lalr1.cc  */
 #line 181 "holidayparserplan.ypp"
         {
             (yyval.ival) = 0;
         }
         break;
 
     case 32:
 
         /* Line 678 of lalr1.cc  */
 #line 182 "holidayparserplan.ypp"
         {
             (yyval.ival) = (1 << (yysemantic_stack_[(1) - (1)].ival));
         }
         break;
 
     case 33:
 
         /* Line 678 of lalr1.cc  */
 #line 183 "holidayparserplan.ypp"
         {
             (yyval.ival) = (1 << (yysemantic_stack_[(3) - (1)].ival)) | (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 34:
 
         /* Line 678 of lalr1.cc  */
 #line 186 "holidayparserplan.ypp"
         {
             (yyval.ival) =  1;
         }
         break;
 
     case 35:
 
         /* Line 678 of lalr1.cc  */
 #line 187 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(2) - (2)].ival);
         }
         break;
 
     case 36:
 
         /* Line 678 of lalr1.cc  */
 #line 190 "holidayparserplan.ypp"
         {
             driver.setEventDate(-99999, (yysemantic_stack_[(3) - (3)].ival), (yysemantic_stack_[(3) - (1)].ival));
         }
         break;
 
     case 37:
 
         /* Line 678 of lalr1.cc  */
 #line 191 "holidayparserplan.ypp"
         {
             driver.setEventDate(-99999, (yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (1)].ival));
         }
         break;
 
     case 38:
 
         /* Line 678 of lalr1.cc  */
 #line 192 "holidayparserplan.ypp"
         {
             driver.setEventDate((yysemantic_stack_[(5) - (5)].ival), (yysemantic_stack_[(5) - (3)].ival), (yysemantic_stack_[(5) - (1)].ival));
         }
         break;
 
     case 39:
 
         /* Line 678 of lalr1.cc  */
 #line 193 "holidayparserplan.ypp"
         {
             driver.setEventDate(-99999, (yysemantic_stack_[(3) - (1)].ival), (yysemantic_stack_[(3) - (3)].ival));
         }
         break;
 
     case 40:
 
         /* Line 678 of lalr1.cc  */
 #line 194 "holidayparserplan.ypp"
         {
             driver.setEventDate((yysemantic_stack_[(5) - (5)].ival), (yysemantic_stack_[(5) - (1)].ival), (yysemantic_stack_[(5) - (3)].ival));
         }
         break;
 
     case 41:
 
         /* Line 678 of lalr1.cc  */
 #line 195 "holidayparserplan.ypp"
         {
             driver.setEventDate(-99999, (yysemantic_stack_[(2) - (1)].ival), (yysemantic_stack_[(2) - (2)].ival));
         }
         break;
 
     case 42:
 
         /* Line 678 of lalr1.cc  */
 #line 196 "holidayparserplan.ypp"
         {
             driver.setEventDate((yysemantic_stack_[(3) - (3)].ival), (yysemantic_stack_[(3) - (1)].ival), (yysemantic_stack_[(3) - (2)].ival));
         }
         break;
 
     case 43:
 
         /* Line 678 of lalr1.cc  */
 #line 197 "holidayparserplan.ypp"
         {
             driver.setEventDate(-99999, (yysemantic_stack_[(2) - (2)].ival), (yysemantic_stack_[(2) - (1)].ival));
         }
         break;
 
     case 44:
 
         /* Line 678 of lalr1.cc  */
 #line 198 "holidayparserplan.ypp"
         {
             driver.setEventDate((yysemantic_stack_[(3) - (3)].ival), (yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (1)].ival));
         }
         break;
 
     case 45:
 
         /* Line 678 of lalr1.cc  */
 #line 199 "holidayparserplan.ypp"
         {
             driver.setEventDate((yysemantic_stack_[(4) - (4)].ival), (yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (1)].ival));
         }
         break;
 
     case 46:
 
         /* Line 678 of lalr1.cc  */
 #line 200 "holidayparserplan.ypp"
         {
             driver.setEventDate((yysemantic_stack_[(1) - (1)].ival));
         }
         break;
 
     case 47:
 
         /* Line 678 of lalr1.cc  */
 #line 203 "holidayparserplan.ypp"
         {
             char *s = (yysemantic_stack_[(1) - (1)].sval);
             (yyval.ival) = driver.julianDayFromEventName(s);
             free(s);
             (yysemantic_stack_[(1) - (1)].sval) = nullptr;
         }
         break;
 
     case 48:
 
         /* Line 678 of lalr1.cc  */
 #line 204 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.julianDayFromEaster();
         }
         break;
 
     case 49:
 
         /* Line 678 of lalr1.cc  */
 #line 205 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.julianDayFromPascha();
         }
         break;
 
     case 50:
 
         /* Line 678 of lalr1.cc  */
 #line 206 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(3) - (3)].ival), (yysemantic_stack_[(3) - (1)].ival));
         }
         break;
 
     case 51:
 
         /* Line 678 of lalr1.cc  */
 #line 207 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (1)].ival));
         }
         break;
 
     case 52:
 
         /* Line 678 of lalr1.cc  */
 #line 208 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(3) - (1)].ival), (yysemantic_stack_[(3) - (3)].ival));
         }
         break;
 
     case 53:
 
         /* Line 678 of lalr1.cc  */
 #line 209 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(2) - (2)].ival), (yysemantic_stack_[(2) - (1)].ival));
         }
         break;
 
     case 54:
 
         /* Line 678 of lalr1.cc  */
 #line 210 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(2) - (1)].ival), (yysemantic_stack_[(2) - (2)].ival));
         }
         break;
 
     case 55:
 
         /* Line 678 of lalr1.cc  */
 #line 211 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.julianDayFromRelativeWeekday((yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (1)].ival), (yysemantic_stack_[(3) - (3)].ival));
         }
         break;
 
     case 56:
 
         /* Line 678 of lalr1.cc  */
 #line 212 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.julianDayFromWeekdayInMonth((yysemantic_stack_[(4) - (1)].ival), (yysemantic_stack_[(4) - (2)].ival), (yysemantic_stack_[(4) - (4)].ival));
         }
         break;
 
     case 58:
 
         /* Line 678 of lalr1.cc  */
 #line 216 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.adjustedMonthNumber((yysemantic_stack_[(1) - (1)].ival));
         }
         break;
 
     case 59:
 
         /* Line 678 of lalr1.cc  */
 #line 219 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.adjustedMonthNumber((yysemantic_stack_[(1) - (1)].ival));
         }
         break;
 
     case 60:
 
         /* Line 678 of lalr1.cc  */
 #line 222 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(1) - (1)].ival);
         }
         break;
 
     case 61:
 
         /* Line 678 of lalr1.cc  */
 #line 223 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) || (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 62:
 
         /* Line 678 of lalr1.cc  */
 #line 224 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) && (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 63:
 
         /* Line 678 of lalr1.cc  */
 #line 225 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) == (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 64:
 
         /* Line 678 of lalr1.cc  */
 #line 226 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) != (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 65:
 
         /* Line 678 of lalr1.cc  */
 #line 227 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) <= (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 66:
 
         /* Line 678 of lalr1.cc  */
 #line 228 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) >= (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 67:
 
         /* Line 678 of lalr1.cc  */
 #line 229 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) < (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 68:
 
         /* Line 678 of lalr1.cc  */
 #line 230 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) > (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 69:
 
         /* Line 678 of lalr1.cc  */
 #line 231 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) + (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 70:
 
         /* Line 678 of lalr1.cc  */
 #line 232 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) - (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 71:
 
         /* Line 678 of lalr1.cc  */
 #line 233 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) * (yysemantic_stack_[(3) - (3)].ival);
         }
         break;
 
     case 72:
 
         /* Line 678 of lalr1.cc  */
 #line 234 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (3)].ival) ? (yysemantic_stack_[(3) - (1)].ival) / (yysemantic_stack_[(3) - (3)].ival) : 0;
         }
         break;
 
     case 73:
 
         /* Line 678 of lalr1.cc  */
 #line 235 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (3)].ival) ? (yysemantic_stack_[(3) - (1)].ival) % (yysemantic_stack_[(3) - (3)].ival) : 0;
         }
         break;
 
     case 74:
 
         /* Line 678 of lalr1.cc  */
 #line 236 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(5) - (1)].ival) ? (yysemantic_stack_[(5) - (3)].ival) : (yysemantic_stack_[(5) - (5)].ival);
         }
         break;
 
     case 75:
 
         /* Line 678 of lalr1.cc  */
 #line 237 "holidayparserplan.ypp"
         {
             (yyval.ival) = !(yysemantic_stack_[(2) - (2)].ival);
         }
         break;
 
     case 76:
 
         /* Line 678 of lalr1.cc  */
 #line 238 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (2)].ival);
         }
         break;
 
     case 77:
 
         /* Line 678 of lalr1.cc  */
 #line 241 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(3) - (2)].ival);
         }
         break;
 
     case 78:
 
         /* Line 678 of lalr1.cc  */
 #line 242 "holidayparserplan.ypp"
         {
             (yyval.ival) = (yysemantic_stack_[(1) - (1)].ival);
         }
         break;
 
     case 80:
 
         /* Line 678 of lalr1.cc  */
 #line 246 "holidayparserplan.ypp"
         {
             (yyval.ival) = -(yysemantic_stack_[(2) - (2)].ival);
         }
         break;
 
     case 81:
 
         /* Line 678 of lalr1.cc  */
 #line 247 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.parseYear();
         }
         break;
 
     case 82:
 
         /* Line 678 of lalr1.cc  */
 #line 248 "holidayparserplan.ypp"
         {
             (yyval.ival) = driver.isLeapYear((yysemantic_stack_[(2) - (2)].ival));
         }
         break;
 
         /* Line 678 of lalr1.cc  */
 #line 990 "holidayparserplan.cpp"
     default:
         break;
     }
     YY_SYMBOL_PRINT("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
 
     yypop_(yylen);
     yylen = 0;
     YY_STACK_PRINT();
 
     yysemantic_stack_.push(yyval);
     yylocation_stack_.push(yyloc);
 
     /* Shift the result of the reduction.  */
     yyn = yyr1_[yyn];
     yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
     if (0 <= yystate && yystate <= yylast_
             && yycheck_[yystate] == yystate_stack_[0]) {
         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_;
         error(yylloc, yysyntax_error_(yylloc.begin.filename, yystate, yytoken));
     }
 
     yyerror_range[0] = yylloc;
     if (yyerrstatus_ == 3) {
         /* If just tried and failed to reuse lookahead token after an
          error, discard it.  */
 
         if (yychar <= yyeof_) {
             /* Return failure if at end of input.  */
             if (yychar == yyeof_) {
                 YYABORT;
             }
         } else {
             yydestruct_("Error: discarding", yytoken, &yylval, &yylloc);
             yychar = yyempty_;
         }
     }
 
     /* Else will try to reuse lookahead token after shifting the error
        token.  */
     goto yyerrlab1;
 
     /*---------------------------------------------------.
     | yyerrorlab -- error raised explicitly by YYERROR.  |
     `---------------------------------------------------*/
 yyerrorlab:
 
     /* Pacify compilers like GCC when the user code never invokes
        YYERROR and the label yyerrorlab therefore never appears in user
        code.  */
     if (false) {
         goto yyerrorlab;
     }
 
     yyerror_range[0] = yylocation_stack_[yylen - 1];
     /* Do not reclaim the symbols of the rule which action triggered
        this YYERROR.  */
     yypop_(yylen);
     yylen = 0;
     yystate = yystate_stack_[0];
     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 (yystate_stack_.height() == 1) {
             YYABORT;
         }
 
         yyerror_range[0] = yylocation_stack_[0];
         yydestruct_("Error: popping",
                     yystos_[yystate],
                     &yysemantic_stack_[0], &yylocation_stack_[0]);
         yypop_();
         yystate = yystate_stack_[0];
         YY_STACK_PRINT();
     }
 
     yyerror_range[1] = yylloc;
     // Using YYLLOC is tempting, but would change the location of
     // the lookahead.  YYLOC is available though.
     YYLLOC_DEFAULT(yyloc, (yyerror_range - 1), 2);
     yysemantic_stack_.push(yylval);
     yylocation_stack_.push(yyloc);
 
     /* Shift the error token.  */
     YY_SYMBOL_PRINT("Shifting", yystos_[yyn],
                     &yysemantic_stack_[0], &yylocation_stack_[0]);
 
     yystate = yyn;
     goto yynewstate;
 
     /* Accept.  */
 yyacceptlab:
     yyresult = 0;
     goto yyreturn;
 
     /* Abort.  */
 yyabortlab:
     yyresult = 1;
     goto yyreturn;
 
 yyreturn:
     if (yychar != yyempty_) {
         yydestruct_("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
     }
 
     /* Do not reclaim the symbols of the rule which action triggered
        this YYABORT or YYACCEPT.  */
     yypop_(yylen);
     while (yystate_stack_.height() != 1) {
         yydestruct_("Cleanup: popping",
                     yystos_[yystate_stack_[0]],
                     &yysemantic_stack_[0],
                     &yylocation_stack_[0]);
         yypop_();
     }
 
     return yyresult;
 }
 
 // Generate an error message.
 std::string
 HolidayParserPlan::yysyntax_error_(std::string *filename, int yystate, int tok)
 {
     std::string res;
     YYUSE(yystate);
 #if YYERROR_VERBOSE
     int yyn = yypact_[yystate];
     if (yypact_ninf_ < yyn && yyn <= yylast_) {
         /* 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 + 1;
         int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
         int count = 0;
         for (int x = yyxbegin; x < yyxend; ++x)
             if (yycheck_[x + yyn] == x && x != yyterror_) {
                 ++count;
             }
 
         // FIXME: This method of building the message is not compatible
         // with internationalization.  It should work like yacc.c does it.
         // That is, first build a string that looks like this:
         // "syntax error, unexpected %s or %s or %s"
         // Then, invoke YY_ on this string.
         // Finally, use the string as a format to output
         // yytname_[tok], etc.
         // Until this gets fixed, this message appears in English only.
         res = "syntax error, unexpected ";
         res += yytnamerr_(yytname_[tok]);
         if (count < 5) {
             count = 0;
             for (int x = yyxbegin; x < yyxend; ++x)
                 if (yycheck_[x + yyn] == x && x != yyterror_) {
                     res += (!count++) ? ", expecting " : " or ";
                     res += yytnamerr_(yytname_[x]);
                     res += ". Filepath : " + *filename;
                 }
         }
     } else
 #endif
         res = YY_("syntax error");
     return res;
 }
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
 const signed char HolidayParserPlan::yypact_ninf_ = -70;
 const short int
 HolidayParserPlan::yypact_[] = {
     -24,    -1,    25,   -70,     1,   -70,   -70,    39,    42,    38,
     -70,    65,   -70,    64,    51,   -70,     5,   -70,    75,   -70,
     -70,   -70,   114,   -70,   -70,   -70,   129,   -70,     6,    30,
     30,    84,   134,   -70,    30,    58,     6,    -2,   -70,   134,
     134,    77,    63,   -70,    77,    77,   -70,   134,    85,   160,
     -70,    81,     6,     6,    12,   131,     6,   209,   209,   134,
     -70,    30,    43,   -70,   -70,    62,     6,   -70,   -70,   -70,
     54,    67,     6,     3,   134,   134,   134,   134,   134,   134,
     134,   134,   134,   134,   134,   134,   134,   134,   -70,    98,
     77,    71,   -70,    63,    77,     6,    70,   -70,   -70,   -70,
     209,    77,     6,   -70,     6,   -70,   -70,   102,    63,   251,
     251,   251,   251,   251,   251,   230,   251,   116,   116,    62,
     62,    62,   187,    86,    99,   -70,     6,    30,   -70,   -70,
     134,   -70,   -70,   -70,    63,    80,   134,    98,    98,   -70,
     77,   209,   -70,   -70,   -70,   -70,   -70,   -70
 };
 
 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
    doesn't specify something else to do.  Zero means the default is an
    error.  */
 const unsigned char
 HolidayParserPlan::yydefact_[] = {
     4,     0,     0,    12,     6,     5,     1,     2,     0,     8,
     14,     0,     7,     0,    10,    15,    17,     9,     0,     3,
     16,    18,     0,    11,    79,    59,    26,    81,     0,    26,
     26,     0,     0,    13,    26,     0,    57,    46,    78,     0,
     0,    34,     0,    82,    34,    34,    80,     0,     0,     0,
     60,    29,     0,    41,    26,     0,    43,    27,    28,     0,
     22,    26,    46,    19,    20,    75,     0,    47,    48,    49,
     0,     0,    57,    58,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,    77,    31,
     34,    39,    42,     0,    34,    59,    36,    57,    58,    44,
     35,    34,     0,    76,     0,    54,    53,     0,     0,    63,
     64,    65,    66,    67,    68,    61,    62,    70,    69,    71,
     72,    73,     0,    32,     0,    21,     0,    26,    23,    45,
     37,    25,    55,    52,     0,    50,     0,    31,    31,    40,
     34,    38,    56,    51,    74,    33,    30,    24
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 const signed char
 HolidayParserPlan::yypgoto_[] = {
     -70,   -70,   -70,   -70,   -70,   -70,   -70,   -70,   -70,   -70,
     -70,   -70,   -19,   -70,   -69,   -16,    79,   -70,    -9,   111,
     -23,   -22,   -70
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 const signed char
 HolidayParserPlan::yydefgoto_[] = {
     -1,     2,     3,     4,     9,    14,    19,     7,    11,    16,
     22,    33,    41,    90,   124,    60,    34,    70,    35,    97,
     49,    50,    38
 };
 
 /* 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.  */
 const signed char HolidayParserPlan::yytable_ninf_ = -59;
 const short int
 HolidayParserPlan::yytable_[] = {
     37,     1,    25,    54,    42,     5,    43,   106,   107,    24,
     44,    45,    20,    21,    53,    51,    57,    58,    27,    28,
     62,    93,    39,    40,    65,     6,    73,     8,    63,    64,
     91,    92,   -58,    98,    99,    94,   100,    31,    55,    71,
     39,    40,   101,   108,   102,    10,    96,    25,    12,    32,
     105,   109,   110,   111,   112,   113,   114,   115,   116,   117,
     118,   119,   120,   121,   122,    13,    24,    25,   145,   146,
     17,    98,    15,   129,   125,    27,    28,   -58,   128,    18,
     132,    23,   133,    55,   127,   131,    98,    46,    24,    25,
     66,    67,    52,    59,    31,    89,   103,    27,    28,   135,
     87,   104,    68,   123,   139,   126,    32,   141,   140,    69,
     130,   134,    98,   144,   138,   137,    31,    24,    25,    26,
     143,    61,     0,     0,   147,   142,    27,    28,    32,     0,
     0,    29,    24,    36,    24,    95,     0,    24,    30,    39,
     40,    27,    28,    27,    28,    31,    27,    28,    56,    84,
     85,    86,     0,    36,    87,     0,     0,    32,     0,    72,
     31,     0,    31,     0,     0,    31,     0,     0,     0,     0,
     47,     0,    32,    56,    32,    48,     0,    32,    74,    75,
     76,    77,    78,    79,     0,     0,     0,     0,     0,    80,
     81,    82,    83,    84,    85,    86,     0,     0,    87,     0,
     0,     0,     0,     0,    88,    74,    75,    76,    77,    78,
     79,     0,     0,     0,     0,     0,    80,    81,    82,    83,
     84,    85,    86,     0,     0,    87,   136,    74,    75,    76,
     77,    78,    79,     0,     0,     0,     0,     0,    80,    81,
     82,    83,    84,    85,    86,     0,     0,    87,    74,    75,
     76,    77,    78,    79,     0,     0,     0,     0,     0,     0,
     81,    82,    83,    84,    85,    86,     0,     0,    87,    74,
     75,    76,    77,    78,    79,     0,     0,     0,     0,     0,
     0,     0,    82,    83,    84,    85,    86,     0,     0,    87
 };
 
 /* YYCHECK.  */
 const short int
 HolidayParserPlan::yycheck_[] = {
     22,    25,     4,     5,    26,     6,    28,     4,     5,     3,
     29,    30,     7,     8,    36,    34,    39,    40,    12,    13,
     42,     9,    10,    11,    47,     0,    48,    26,    44,    45,
     52,    53,    34,    55,    56,    54,    59,    31,    40,    48,
     10,    11,    61,    40,    66,     6,    55,     4,     6,    43,
     72,    74,    75,    76,    77,    78,    79,    80,    81,    82,
     83,    84,    85,    86,    87,    27,     3,     4,   137,   138,
     6,    93,     7,    95,    90,    12,    13,    34,    94,    28,
     102,     6,   104,    40,    93,   101,   108,     3,     3,     4,
     5,     6,    34,    16,    31,    14,    42,    12,    13,   108,
     38,    34,    17,     5,   126,    34,    43,   130,   127,    24,
     40,     9,   134,   136,    15,    29,    31,     3,     4,     5,
     40,    42,    -1,    -1,   140,   134,    12,    13,    43,    -1,
     -1,    17,     3,    22,     3,     4,    -1,     3,    24,    10,
     11,    12,    13,    12,    13,    31,    12,    13,    37,    33,
     34,    35,    -1,    42,    38,    -1,    -1,    43,    -1,    48,
     31,    -1,    31,    -1,    -1,    31,    -1,    -1,    -1,    -1,
     36,    -1,    43,    62,    43,    41,    -1,    43,    18,    19,
     20,    21,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
     30,    31,    32,    33,    34,    35,    -1,    -1,    38,    -1,
     -1,    -1,    -1,    -1,    44,    18,    19,    20,    21,    22,
     23,    -1,    -1,    -1,    -1,    -1,    29,    30,    31,    32,
     33,    34,    35,    -1,    -1,    38,    39,    18,    19,    20,
     21,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,    30,
     31,    32,    33,    34,    35,    -1,    -1,    38,    18,    19,
     20,    21,    22,    23,    -1,    -1,    -1,    -1,    -1,    -1,
     30,    31,    32,    33,    34,    35,    -1,    -1,    38,    18,
     19,    20,    21,    22,    23,    -1,    -1,    -1,    -1,    -1,
     -1,    -1,    31,    32,    33,    34,    35,    -1,    -1,    38
 };
 
 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
 const unsigned char
 HolidayParserPlan::yystos_[] = {
     0,    25,    46,    47,    48,     6,     0,    52,    26,    49,
     6,    53,     6,    27,    50,     7,    54,     6,    28,    51,
     7,     8,    55,     6,     3,     4,     5,    12,    13,    17,
     24,    31,    43,    56,    61,    63,    64,    66,    67,    10,
     11,    57,    66,    66,    57,    57,     3,    36,    41,    65,
     66,    57,    34,    66,     5,    40,    64,    65,    65,    16,
     60,    61,    66,    60,    60,    65,     5,     6,    17,    24,
     62,    63,    64,    66,    18,    19,    20,    21,    22,    23,
     29,    30,    31,    32,    33,    34,    35,    38,    44,    14,
     58,    66,    66,     9,    57,     4,    63,    64,    66,    66,
     65,    57,    66,    42,    34,    66,     4,     5,    40,    65,
     65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
     65,    65,    65,     5,    59,    60,    34,    63,    60,    66,
     40,    60,    66,    66,     9,    63,    39,    29,    15,    66,
     57,    65,    63,    40,    65,    59,    59,    60
 };
 
 #if YYDEBUG
 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
    to YYLEX-NUM.  */
 const unsigned short int
 HolidayParserPlan::yytoken_number_[] = {
     0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
     285,    45,    43,    42,    47,    37,    33,   286,    63,    58,
     46,    91,    93,    40,    41
 };
 #endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 const unsigned char
 HolidayParserPlan::yyr1_[] = {
     0,    45,    46,    47,    48,    48,    49,    49,    50,    50,
     51,    51,    52,    52,    53,    54,    54,    55,    55,    56,
     56,    56,    56,    56,    56,    56,    57,    57,    57,    58,
     58,    59,    59,    59,    60,    60,    61,    61,    61,    61,
     61,    61,    61,    61,    61,    61,    61,    62,    62,    62,
     62,    62,    62,    62,    62,    62,    62,    63,    63,    64,
     65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
     65,    65,    65,    65,    65,    65,    65,    66,    66,    67,
     67,    67,    67
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 const unsigned char
 HolidayParserPlan::yyr2_[] = {
     0,     2,     2,     4,     0,     2,     0,     2,     0,     2,
     0,     2,     0,     5,     1,     1,     2,     0,     1,     3,
     3,     4,     3,     4,     6,     5,     0,     2,     2,     0,
     4,     0,     1,     3,     0,     2,     3,     4,     5,     3,
     5,     2,     3,     2,     3,     4,     1,     1,     1,     1,
     3,     4,     3,     2,     2,     3,     4,     1,     1,     1,
     1,     3,     3,     3,     3,     3,     3,     3,     3,     3,
     3,     3,     3,     3,     5,     2,     3,     3,     1,     1,
     2,     1,     2
 };
 
 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
 const char *
 const HolidayParserPlan::yytname_[] = {
     "END", "error", "$undefined", "NUMBER", "MONTH", "WDAY", "STRING",
     "CATEGORY", "CALENDAR", "INOP", "PLUS", "MINUS", "YEAR", "LEAPYEAR",
     "SHIFT", "IF", "LENGTH", "EASTER", "EQ", "NE", "LE", "GE", "LT", "GT",
     "PASCHA", "COUNTRY", "LANGUAGE", "NAME", "DESCRIPTION", "OR", "AND",
     "'-'", "'+'", "'*'", "'/'", "'%'", "'!'", "UMINUS", "'?'", "':'", "'.'",
     "'['", "']'", "'('", "')'", "$accept", "planfile", "metadata",
     "countrycode", "languagecode", "name", "description", "list",
     "eventname", "categories", "calendar", "eventrule", "offset",
     "conditionaloffset", "wdaycondition", "length", "date", "reldate",
     "month", "monthnumber", "expr", "pexpr", "number", nullptr
 };
 #endif
 
 #if YYDEBUG
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 const HolidayParserPlan::rhs_number_type
 HolidayParserPlan::yyrhs_[] = {
     46,     0,    -1,    47,    52,    -1,    48,    49,    50,    51,
     -1,    -1,    25,     6,    -1,    -1,    26,     6,    -1,    -1,
     27,     6,    -1,    -1,    28,     6,    -1,    -1,    52,    53,
     54,    55,    56,    -1,     6,    -1,     7,    -1,    54,     7,
     -1,    -1,     8,    -1,    17,    57,    60,    -1,    24,    57,
     60,    -1,    61,    57,    58,    60,    -1,     5,    57,    60,
     -1,    66,     5,    57,    60,    -1,    66,     5,     9,    63,
     57,    60,    -1,     5,    66,    61,    57,    60,    -1,    -1,
     10,    65,    -1,    11,    65,    -1,    -1,    14,    59,    15,
     59,    -1,    -1,     5,    -1,     5,    29,    59,    -1,    -1,
     16,    65,    -1,    66,    40,    63,    -1,    66,    40,    63,
     40,    -1,    66,    40,    63,    40,    65,    -1,    63,    34,
     66,    -1,    63,    34,    66,    34,    66,    -1,    64,    66,
     -1,    64,    66,    66,    -1,    66,    64,    -1,    66,    64,
     66,    -1,    66,    40,     4,    66,    -1,    66,    -1,     6,
     -1,    17,    -1,    24,    -1,    66,    40,    63,    -1,    66,
     40,    63,    40,    -1,    63,    34,    66,    -1,    66,     4,
     -1,    64,    66,    -1,     5,    66,    66,    -1,    66,     5,
     9,    63,    -1,    64,    -1,    66,    -1,     4,    -1,    66,
     -1,    65,    29,    65,    -1,    65,    30,    65,    -1,    65,
     18,    65,    -1,    65,    19,    65,    -1,    65,    20,    65,
     -1,    65,    21,    65,    -1,    65,    22,    65,    -1,    65,
     23,    65,    -1,    65,    32,    65,    -1,    65,    31,    65,
     -1,    65,    33,    65,    -1,    65,    34,    65,    -1,    65,
     35,    65,    -1,    65,    38,    65,    39,    65,    -1,    36,
     65,    -1,    41,    62,    42,    -1,    43,    65,    44,    -1,
     67,    -1,     3,    -1,    31,     3,    -1,    12,    -1,    13,
     66,    -1
 };
 
 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */
 const unsigned short int
 HolidayParserPlan::yyprhs_[] = {
     0,     0,     3,     6,    11,    12,    15,    16,    19,    20,
     23,    24,    27,    28,    34,    36,    38,    41,    42,    44,
     48,    52,    57,    61,    66,    73,    79,    80,    83,    86,
     87,    92,    93,    95,    99,   100,   103,   107,   112,   118,
     122,   128,   131,   135,   138,   142,   147,   149,   151,   153,
     155,   159,   164,   168,   171,   174,   178,   183,   185,   187,
     189,   191,   195,   199,   203,   207,   211,   215,   219,   223,
     227,   231,   235,   239,   243,   249,   252,   256,   260,   262,
     264,   267,   269
 };
 
 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 const unsigned char
 HolidayParserPlan::yyrline_[] = {
     0,   126,   126,   129,   132,   133,   136,   137,   140,   141,
     144,   145,   148,   149,   152,   155,   156,   159,   160,   163,
     164,   165,   166,   167,   168,   169,   172,   173,   174,   177,
     178,   181,   182,   183,   186,   187,   190,   191,   192,   193,
     194,   195,   196,   197,   198,   199,   200,   203,   204,   205,
     206,   207,   208,   209,   210,   211,   212,   215,   216,   219,
     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
     232,   233,   234,   235,   236,   237,   238,   241,   242,   245,
     246,   247,   248
 };
 
 // Print the state stack on the debug stream.
 void
 HolidayParserPlan::yystack_print_()
 {
     *yycdebug_ << "Stack now";
     for (state_stack_type::const_iterator i = yystate_stack_.begin();
             i != yystate_stack_.end(); ++i) {
         *yycdebug_ << ' ' << *i;
     }
     *yycdebug_ << std::endl;
 }
 
 // Report on the debug stream that the rule \a yyrule is going to be reduced.
 void
 HolidayParserPlan::yy_reduce_print_(int yyrule)
 {
     unsigned int yylno = yyrline_[yyrule];
     int yynrhs = yyr2_[yyrule];
     /* Print the symbols being reduced, and their result.  */
     *yycdebug_ << "Reducing stack by rule " << yyrule - 1
                << " (line " << yylno << "):" << std::endl;
     /* The symbols being reduced.  */
     for (int yyi = 0; yyi < yynrhs; yyi++)
         YY_SYMBOL_PRINT("   $" << yyi + 1 << " =",
                         yyrhs_[yyprhs_[yyrule] + yyi],
                         &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
                         &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
 }
 #endif // YYDEBUG
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 HolidayParserPlan::token_number_type
 HolidayParserPlan::yytranslate_(int t)
 {
     static
     const token_number_type
     translate_table[] = {
         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,    36,     2,     2,     2,    35,     2,     2,
         43,    44,    33,    32,     2,    31,    40,    34,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,    39,     2,
         2,     2,     2,    38,     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,    41,     2,    42,     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,    12,    13,    14,
         15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
         25,    26,    27,    28,    29,    30,    37
     };
     if ((unsigned int) t <= yyuser_token_number_max_) {
         return translate_table[t];
     } else {
         return yyundef_token_;
     }
 }
 
 const int HolidayParserPlan::yyeof_ = 0;
 const int HolidayParserPlan::yylast_ = 289;
 const int HolidayParserPlan::yynnts_ = 23;
 const int HolidayParserPlan::yyempty_ = -2;
 const int HolidayParserPlan::yyfinal_ = 6;
 const int HolidayParserPlan::yyterror_ = 1;
 const int HolidayParserPlan::yyerrcode_ = 256;
 const int HolidayParserPlan::yyntokens_ = 45;
 
 const unsigned int HolidayParserPlan::yyuser_token_number_max_ = 286;
 const HolidayParserPlan::token_number_type HolidayParserPlan::yyundef_token_ = 2;
 
 /* Line 1054 of lalr1.cc  */
 #line 1 "[Bison:b4_percent_define_default]"
 
 } // KHolidays
 
 /* Line 1054 of lalr1.cc  */
 #line 1573 "holidayparserplan.cpp"
 
 /* Line 1056 of lalr1.cc  */
 #line 251 "holidayparserplan.ypp"
 
 /*** Private Yacc callbacks and helper functions ***/
 
 void KHolidays::HolidayParserPlan::error(const KHolidays::HolidayParserPlan::location_type &errorLocation, const std::string &errorMessage)
 {
     driver.error(errorLocation, errorMessage.c_str());
 }