File indexing completed on 2024-04-21 03:54:16
0001 0002 /* A Bison parser, made by GNU Bison 2.4.1. */ 0003 0004 /* Skeleton implementation for Bison LALR(1) parsers in C++ 0005 0006 SPDX-FileCopyrightText: 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. 0007 0008 SPDX-License-Identifier: GPL-3.0-or-later WITH Bison-exception-2.2 0009 */ 0010 0011 // Take the name prefix into account. 0012 #define yylex KHolidayslex 0013 0014 /* First part of user declarations. */ 0015 0016 /* Line 311 of lalr1.cc */ 0017 #line 30 "holidayparserplan.ypp" 0018 /*** C/C++ Declarations ***/ 0019 0020 #include <limits.h> 0021 #include <stdio.h> 0022 #include <stdlib.h> 0023 #include <string> 0024 #include <sys/stat.h> 0025 #include <sys/types.h> 0026 0027 #include <QString> 0028 0029 // clang-format off 0030 0031 /* Line 311 of lalr1.cc */ 0032 #line 60 "holidayparserplan.cpp" 0033 0034 #include "holidayparserplan.hpp" 0035 0036 /* User implementation prologue. */ 0037 0038 /* Line 317 of lalr1.cc */ 0039 #line 111 "holidayparserplan.ypp" 0040 0041 #include "holidayparserdriverplan_p.h" 0042 #include "holidayscannerplan_p.h" 0043 0044 /* this "connects" the bison parser in the driver to the flex scanner class 0045 * object. it defines the yylex() function call to pull the next token from the 0046 * current lexer object of the driver context. */ 0047 #undef yylex 0048 #define yylex driver.m_scanner->lex 0049 0050 /* Line 317 of lalr1.cc */ 0051 #line 83 "holidayparserplan.cpp" 0052 0053 #ifndef YY_ 0054 # if defined(YYENABLE_NLS) && YYENABLE_NLS 0055 # if ENABLE_NLS 0056 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */ 0057 # define YY_(msgid) dgettext ("bison-runtime", msgid) 0058 # endif 0059 # endif 0060 # ifndef YY_ 0061 # define YY_(msgid) msgid 0062 # endif 0063 #endif 0064 0065 /* Suppress unused-variable warnings by "using" E. */ 0066 #define YYUSE(e) ((void) (e)) 0067 0068 /* Enable debugging if requested. */ 0069 #if YYDEBUG 0070 0071 /* A pseudo ostream that takes yydebug_ into account. */ 0072 # define YYCDEBUG if (yydebug_) (*yycdebug_) 0073 0074 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 0075 do { \ 0076 if (yydebug_) \ 0077 { \ 0078 *yycdebug_ << Title << ' '; \ 0079 yy_symbol_print_ ((Type), (Value), (Location)); \ 0080 *yycdebug_ << std::endl; \ 0081 } \ 0082 } while (false) 0083 0084 # define YY_REDUCE_PRINT(Rule) \ 0085 do { \ 0086 if (yydebug_) \ 0087 yy_reduce_print_ (Rule); \ 0088 } while (false) 0089 0090 # define YY_STACK_PRINT() \ 0091 do { \ 0092 if (yydebug_) \ 0093 yystack_print_ (); \ 0094 } while (false) 0095 0096 #else /* !YYDEBUG */ 0097 0098 # define YYCDEBUG if (false) std::cerr 0099 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 0100 # define YY_REDUCE_PRINT(Rule) 0101 # define YY_STACK_PRINT() 0102 0103 #endif /* !YYDEBUG */ 0104 0105 #define yyerrok (yyerrstatus_ = 0) 0106 #define yyclearin (yychar = yyempty_) 0107 0108 #define YYACCEPT goto yyacceptlab 0109 #define YYABORT goto yyabortlab 0110 #define YYERROR goto yyerrorlab 0111 #define YYRECOVERING() (!!yyerrstatus_) 0112 0113 /* Line 380 of lalr1.cc */ 0114 #line 1 "[Bison:b4_percent_define_default]" 0115 0116 namespace KHolidays 0117 { 0118 0119 /* Line 380 of lalr1.cc */ 0120 #line 152 "holidayparserplan.cpp" 0121 #if YYERROR_VERBOSE 0122 0123 /* Return YYSTR after stripping away unnecessary quotes and 0124 backslashes, so that it's suitable for yyerror. The heuristic is 0125 that double-quoting is unnecessary unless the string contains an 0126 apostrophe, a comma, or backslash (other than backslash-backslash). 0127 YYSTR is taken from yytname. */ 0128 std::string 0129 HolidayParserPlan::yytnamerr_(const char *yystr) 0130 { 0131 if (*yystr == '"') { 0132 std::string yyr = ""; 0133 char const *yyp = yystr; 0134 0135 for (;;) 0136 switch (*++yyp) { 0137 case '\'': 0138 case ',': 0139 goto do_not_strip_quotes; 0140 0141 case '\\': 0142 if (*++yyp != '\\') { 0143 goto do_not_strip_quotes; 0144 } 0145 /* Fall through. */ 0146 default: 0147 yyr += *yyp; 0148 break; 0149 0150 case '"': 0151 return yyr; 0152 } 0153 do_not_strip_quotes:; 0154 } 0155 0156 return yystr; 0157 } 0158 0159 #endif 0160 0161 /// Build a parser object. 0162 HolidayParserPlan::HolidayParserPlan(class HolidayParserDriverPlan &driver_yyarg) 0163 : 0164 #if YYDEBUG 0165 yydebug_(false), 0166 yycdebug_(&std::cerr), 0167 #endif 0168 driver(driver_yyarg) 0169 { 0170 } 0171 0172 HolidayParserPlan::~HolidayParserPlan() 0173 { 0174 } 0175 0176 #if YYDEBUG 0177 /*--------------------------------. 0178 | Print this symbol on YYOUTPUT. | 0179 `--------------------------------*/ 0180 0181 inline void 0182 HolidayParserPlan::yy_symbol_value_print_(int yytype, 0183 const semantic_type *yyvaluep, const location_type *yylocationp) 0184 { 0185 YYUSE(yylocationp); 0186 YYUSE(yyvaluep); 0187 switch (yytype) { 0188 default: 0189 break; 0190 } 0191 } 0192 0193 void 0194 HolidayParserPlan::yy_symbol_print_(int yytype, 0195 const semantic_type *yyvaluep, const location_type *yylocationp) 0196 { 0197 *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm") 0198 << ' ' << yytname_[yytype] << " (" 0199 << *yylocationp << ": "; 0200 yy_symbol_value_print_(yytype, yyvaluep, yylocationp); 0201 *yycdebug_ << ')'; 0202 } 0203 #endif 0204 0205 void 0206 HolidayParserPlan::yydestruct_(const char *yymsg, 0207 int yytype, semantic_type *yyvaluep, location_type *yylocationp) 0208 { 0209 YYUSE(yylocationp); 0210 YYUSE(yymsg); 0211 YYUSE(yyvaluep); 0212 0213 YY_SYMBOL_PRINT(yymsg, yytype, yyvaluep, yylocationp); 0214 0215 switch (yytype) { 0216 case 6: /* "STRING" */ 0217 0218 /* Line 480 of lalr1.cc */ 0219 #line 96 "holidayparserplan.ypp" 0220 { 0221 free((yyvaluep->sval)); 0222 }; 0223 0224 /* Line 480 of lalr1.cc */ 0225 #line 259 "holidayparserplan.cpp" 0226 break; 0227 0228 default: 0229 break; 0230 } 0231 } 0232 0233 void 0234 HolidayParserPlan::yypop_(unsigned int n) 0235 { 0236 yystate_stack_.pop(n); 0237 yysemantic_stack_.pop(n); 0238 yylocation_stack_.pop(n); 0239 } 0240 0241 #if YYDEBUG 0242 std::ostream & 0243 HolidayParserPlan::debug_stream() const 0244 { 0245 return *yycdebug_; 0246 } 0247 0248 void 0249 HolidayParserPlan::set_debug_stream(std::ostream &o) 0250 { 0251 yycdebug_ = &o; 0252 } 0253 0254 HolidayParserPlan::debug_level_type 0255 HolidayParserPlan::debug_level() const 0256 { 0257 return yydebug_; 0258 } 0259 0260 void 0261 HolidayParserPlan::set_debug_level(debug_level_type l) 0262 { 0263 yydebug_ = l; 0264 } 0265 #endif 0266 0267 int 0268 HolidayParserPlan::parse() 0269 { 0270 /// Lookahead and lookahead in internal form. 0271 int yychar = yyempty_; 0272 int yytoken = 0; 0273 0274 /* State. */ 0275 int yyn; 0276 int yylen = 0; 0277 int yystate = 0; 0278 0279 /* Error handling. */ 0280 int yynerrs_ = 0; 0281 int yyerrstatus_ = 0; 0282 0283 /// Semantic value of the lookahead. 0284 semantic_type yylval; 0285 /// Location of the lookahead. 0286 location_type yylloc; 0287 /// The locations where the error started and ended. 0288 location_type yyerror_range[2]; 0289 0290 /// $$. 0291 semantic_type yyval; 0292 /// @$. 0293 location_type yyloc; 0294 0295 int yyresult; 0296 0297 YYCDEBUG << "Starting parse" << std::endl; 0298 0299 /* User initialization code. */ 0300 0301 /* Line 553 of lalr1.cc */ 0302 #line 70 "holidayparserplan.ypp" 0303 { 0304 // initialize the initial location object 0305 yylloc.begin.filename = driver.fileToParse(); 0306 yylloc.end.filename = yylloc.begin.filename; 0307 } 0308 0309 /* Line 553 of lalr1.cc */ 0310 #line 346 "holidayparserplan.cpp" 0311 0312 /* Initialize the stacks. The initial state will be pushed in 0313 yynewstate, since the latter expects the semantical and the 0314 location values to have been already stored, initialize these 0315 stacks with a primary value. */ 0316 yystate_stack_ = state_stack_type(0); 0317 yysemantic_stack_ = semantic_stack_type(0); 0318 yylocation_stack_ = location_stack_type(0); 0319 yysemantic_stack_.push(yylval); 0320 yylocation_stack_.push(yylloc); 0321 0322 /* New state. */ 0323 yynewstate: 0324 yystate_stack_.push(yystate); 0325 YYCDEBUG << "Entering state " << yystate << std::endl; 0326 0327 /* Accept? */ 0328 if (yystate == yyfinal_) { 0329 goto yyacceptlab; 0330 } 0331 0332 goto yybackup; 0333 0334 /* Backup. */ 0335 yybackup: 0336 0337 /* Try to take a decision without lookahead. */ 0338 yyn = yypact_[yystate]; 0339 if (yyn == yypact_ninf_) { 0340 goto yydefault; 0341 } 0342 0343 /* Read a lookahead token. */ 0344 if (yychar == yyempty_) { 0345 YYCDEBUG << "Reading a token: "; 0346 yychar = yylex(&yylval, &yylloc); 0347 } 0348 0349 /* Convert token to internal form. */ 0350 if (yychar <= yyeof_) { 0351 yychar = yytoken = yyeof_; 0352 YYCDEBUG << "Now at end of input." << std::endl; 0353 } else { 0354 yytoken = yytranslate_(yychar); 0355 YY_SYMBOL_PRINT("Next token is", yytoken, &yylval, &yylloc); 0356 } 0357 0358 /* If the proper action on seeing token YYTOKEN is to reduce or to 0359 detect an error, take that action. */ 0360 yyn += yytoken; 0361 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) { 0362 goto yydefault; 0363 } 0364 0365 /* Reduce or error. */ 0366 yyn = yytable_[yyn]; 0367 if (yyn <= 0) { 0368 if (yyn == 0 || yyn == yytable_ninf_) { 0369 goto yyerrlab; 0370 } 0371 yyn = -yyn; 0372 goto yyreduce; 0373 } 0374 0375 /* Shift the lookahead token. */ 0376 YY_SYMBOL_PRINT("Shifting", yytoken, &yylval, &yylloc); 0377 0378 /* Discard the token being shifted. */ 0379 yychar = yyempty_; 0380 0381 yysemantic_stack_.push(yylval); 0382 yylocation_stack_.push(yylloc); 0383 0384 /* Count tokens shifted since error; after three, turn off error 0385 status. */ 0386 if (yyerrstatus_) { 0387 --yyerrstatus_; 0388 } 0389 0390 yystate = yyn; 0391 goto yynewstate; 0392 0393 /*-----------------------------------------------------------. 0394 | yydefault -- do the default action for the current state. | 0395 `-----------------------------------------------------------*/ 0396 yydefault: 0397 yyn = yydefact_[yystate]; 0398 if (yyn == 0) { 0399 goto yyerrlab; 0400 } 0401 goto yyreduce; 0402 0403 /*-----------------------------. 0404 | yyreduce -- Do a reduction. | 0405 `-----------------------------*/ 0406 yyreduce: 0407 yylen = yyr2_[yyn]; 0408 /* If YYLEN is nonzero, implement the default value of the action: 0409 `$$ = $1'. Otherwise, use the top of the stack. 0410 0411 Otherwise, the following line sets YYVAL to garbage. 0412 This behavior is undocumented and Bison 0413 users should not rely upon it. */ 0414 if (yylen) { 0415 yyval = yysemantic_stack_[yylen - 1]; 0416 } else { 0417 yyval = yysemantic_stack_[0]; 0418 } 0419 0420 { 0421 slice<location_type, location_stack_type> slice(yylocation_stack_, yylen); 0422 YYLLOC_DEFAULT(yyloc, slice, yylen); 0423 } 0424 YY_REDUCE_PRINT(yyn); 0425 switch (yyn) { 0426 case 4: 0427 0428 /* Line 678 of lalr1.cc */ 0429 #line 132 "holidayparserplan.ypp" 0430 { 0431 driver.setFileCountryCode(QString()); 0432 } 0433 break; 0434 0435 case 5: 0436 0437 /* Line 678 of lalr1.cc */ 0438 #line 133 "holidayparserplan.ypp" 0439 { 0440 char *s = (yysemantic_stack_[(2) - (2)].sval); 0441 driver.setFileCountryCode(QString::fromUtf8(s)); 0442 free(s); 0443 (yysemantic_stack_[(2) - (2)].sval) = nullptr; 0444 } 0445 break; 0446 0447 case 6: 0448 0449 /* Line 678 of lalr1.cc */ 0450 #line 136 "holidayparserplan.ypp" 0451 { 0452 driver.setFileLanguageCode(QString()); 0453 } 0454 break; 0455 0456 case 7: 0457 0458 /* Line 678 of lalr1.cc */ 0459 #line 137 "holidayparserplan.ypp" 0460 { 0461 char *s = (yysemantic_stack_[(2) - (2)].sval); 0462 driver.setFileLanguageCode(QString::fromUtf8(s)); 0463 free(s); 0464 (yysemantic_stack_[(2) - (2)].sval) = nullptr; 0465 } 0466 break; 0467 0468 case 8: 0469 0470 /* Line 678 of lalr1.cc */ 0471 #line 140 "holidayparserplan.ypp" 0472 { 0473 driver.setFileName(QString()); 0474 } 0475 break; 0476 0477 case 9: 0478 0479 /* Line 678 of lalr1.cc */ 0480 #line 141 "holidayparserplan.ypp" 0481 { 0482 char *s = (yysemantic_stack_[(2) - (2)].sval); 0483 driver.setFileName(QString::fromUtf8(s)); 0484 free(s); 0485 (yysemantic_stack_[(2) - (2)].sval) = nullptr; 0486 } 0487 break; 0488 0489 case 10: 0490 0491 /* Line 678 of lalr1.cc */ 0492 #line 144 "holidayparserplan.ypp" 0493 { 0494 driver.setFileDescription(QString()); 0495 } 0496 break; 0497 0498 case 11: 0499 0500 /* Line 678 of lalr1.cc */ 0501 #line 145 "holidayparserplan.ypp" 0502 { 0503 char *s = (yysemantic_stack_[(2) - (2)].sval); 0504 driver.setFileDescription(QString::fromUtf8(s)); 0505 free(s); 0506 (yysemantic_stack_[(2) - (2)].sval) = nullptr; 0507 } 0508 break; 0509 0510 case 14: 0511 0512 /* Line 678 of lalr1.cc */ 0513 #line 152 "holidayparserplan.ypp" 0514 { 0515 char *s = (yysemantic_stack_[(1) - (1)].sval); 0516 driver.setEventName(QString::fromUtf8(s)); 0517 free(s); 0518 (yysemantic_stack_[(1) - (1)].sval) = nullptr; 0519 } 0520 break; 0521 0522 case 15: 0523 0524 /* Line 678 of lalr1.cc */ 0525 #line 155 "holidayparserplan.ypp" 0526 { 0527 driver.setEventCategory((yysemantic_stack_[(1) - (1)].sval)); 0528 } 0529 break; 0530 0531 case 16: 0532 0533 /* Line 678 of lalr1.cc */ 0534 #line 156 "holidayparserplan.ypp" 0535 { 0536 driver.setEventCategory((yysemantic_stack_[(2) - (2)].sval)); 0537 } 0538 break; 0539 0540 case 17: 0541 0542 /* Line 678 of lalr1.cc */ 0543 #line 159 "holidayparserplan.ypp" 0544 { 0545 driver.setEventCalendarType(QStringLiteral("gregorian")); 0546 } 0547 break; 0548 0549 case 18: 0550 0551 /* Line 678 of lalr1.cc */ 0552 #line 160 "holidayparserplan.ypp" 0553 { 0554 driver.setEventCalendarType(QString::fromUtf8((yysemantic_stack_[(1) - (1)].sval))); 0555 } 0556 break; 0557 0558 case 19: 0559 0560 /* Line 678 of lalr1.cc */ 0561 #line 163 "holidayparserplan.ypp" 0562 { 0563 driver.setFromEaster((yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (3)].ival)); 0564 } 0565 break; 0566 0567 case 20: 0568 0569 /* Line 678 of lalr1.cc */ 0570 #line 164 "holidayparserplan.ypp" 0571 { 0572 driver.setFromPascha((yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (3)].ival)); 0573 } 0574 break; 0575 0576 case 21: 0577 0578 /* Line 678 of lalr1.cc */ 0579 #line 165 "holidayparserplan.ypp" 0580 { 0581 driver.setFromDate((yysemantic_stack_[(4) - (2)].ival), (yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (4)].ival)); 0582 } 0583 break; 0584 0585 case 22: 0586 0587 /* Line 678 of lalr1.cc */ 0588 #line 166 "holidayparserplan.ypp" 0589 { 0590 driver.setFromWeekdayInMonth(1, (yysemantic_stack_[(3) - (1)].ival), 1, (yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (3)].ival)); 0591 } 0592 break; 0593 0594 case 23: 0595 0596 /* Line 678 of lalr1.cc */ 0597 #line 167 "holidayparserplan.ypp" 0598 { 0599 driver.setFromWeekdayInMonth((yysemantic_stack_[(4) - (1)].ival), (yysemantic_stack_[(4) - (2)].ival), 1, (yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (4)].ival)); 0600 } 0601 break; 0602 0603 case 24: 0604 0605 /* Line 678 of lalr1.cc */ 0606 #line 168 "holidayparserplan.ypp" 0607 { 0608 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)); 0609 } 0610 break; 0611 0612 case 25: 0613 0614 /* Line 678 of lalr1.cc */ 0615 #line 169 "holidayparserplan.ypp" 0616 { 0617 driver.setFromRelativeWeekday((yysemantic_stack_[(5) - (2)].ival), (yysemantic_stack_[(5) - (1)].ival), (yysemantic_stack_[(5) - (4)].ival), (yysemantic_stack_[(5) - (5)].ival)); 0618 } 0619 break; 0620 0621 case 26: 0622 0623 /* Line 678 of lalr1.cc */ 0624 #line 172 "holidayparserplan.ypp" 0625 { 0626 (yyval.ival) = 0; 0627 } 0628 break; 0629 0630 case 27: 0631 0632 /* Line 678 of lalr1.cc */ 0633 #line 173 "holidayparserplan.ypp" 0634 { 0635 (yyval.ival) = (yysemantic_stack_[(2) - (2)].ival); 0636 } 0637 break; 0638 0639 case 28: 0640 0641 /* Line 678 of lalr1.cc */ 0642 #line 174 "holidayparserplan.ypp" 0643 { 0644 (yyval.ival) = -(yysemantic_stack_[(2) - (2)].ival); 0645 } 0646 break; 0647 0648 case 29: 0649 0650 /* Line 678 of lalr1.cc */ 0651 #line 177 "holidayparserplan.ypp" 0652 { 0653 (yyval.ival) = 0; 0654 } 0655 break; 0656 0657 case 30: 0658 0659 /* Line 678 of lalr1.cc */ 0660 #line 178 "holidayparserplan.ypp" 0661 { 0662 (yyval.ival) = ((yysemantic_stack_[(4) - (2)].ival) << 8) | (yysemantic_stack_[(4) - (4)].ival); 0663 } 0664 break; 0665 0666 case 31: 0667 0668 /* Line 678 of lalr1.cc */ 0669 #line 181 "holidayparserplan.ypp" 0670 { 0671 (yyval.ival) = 0; 0672 } 0673 break; 0674 0675 case 32: 0676 0677 /* Line 678 of lalr1.cc */ 0678 #line 182 "holidayparserplan.ypp" 0679 { 0680 (yyval.ival) = (1 << (yysemantic_stack_[(1) - (1)].ival)); 0681 } 0682 break; 0683 0684 case 33: 0685 0686 /* Line 678 of lalr1.cc */ 0687 #line 183 "holidayparserplan.ypp" 0688 { 0689 (yyval.ival) = (1 << (yysemantic_stack_[(3) - (1)].ival)) | (yysemantic_stack_[(3) - (3)].ival); 0690 } 0691 break; 0692 0693 case 34: 0694 0695 /* Line 678 of lalr1.cc */ 0696 #line 186 "holidayparserplan.ypp" 0697 { 0698 (yyval.ival) = 1; 0699 } 0700 break; 0701 0702 case 35: 0703 0704 /* Line 678 of lalr1.cc */ 0705 #line 187 "holidayparserplan.ypp" 0706 { 0707 (yyval.ival) = (yysemantic_stack_[(2) - (2)].ival); 0708 } 0709 break; 0710 0711 case 36: 0712 0713 /* Line 678 of lalr1.cc */ 0714 #line 190 "holidayparserplan.ypp" 0715 { 0716 driver.setEventDate(-99999, (yysemantic_stack_[(3) - (3)].ival), (yysemantic_stack_[(3) - (1)].ival)); 0717 } 0718 break; 0719 0720 case 37: 0721 0722 /* Line 678 of lalr1.cc */ 0723 #line 191 "holidayparserplan.ypp" 0724 { 0725 driver.setEventDate(-99999, (yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (1)].ival)); 0726 } 0727 break; 0728 0729 case 38: 0730 0731 /* Line 678 of lalr1.cc */ 0732 #line 192 "holidayparserplan.ypp" 0733 { 0734 driver.setEventDate((yysemantic_stack_[(5) - (5)].ival), (yysemantic_stack_[(5) - (3)].ival), (yysemantic_stack_[(5) - (1)].ival)); 0735 } 0736 break; 0737 0738 case 39: 0739 0740 /* Line 678 of lalr1.cc */ 0741 #line 193 "holidayparserplan.ypp" 0742 { 0743 driver.setEventDate(-99999, (yysemantic_stack_[(3) - (1)].ival), (yysemantic_stack_[(3) - (3)].ival)); 0744 } 0745 break; 0746 0747 case 40: 0748 0749 /* Line 678 of lalr1.cc */ 0750 #line 194 "holidayparserplan.ypp" 0751 { 0752 driver.setEventDate((yysemantic_stack_[(5) - (5)].ival), (yysemantic_stack_[(5) - (1)].ival), (yysemantic_stack_[(5) - (3)].ival)); 0753 } 0754 break; 0755 0756 case 41: 0757 0758 /* Line 678 of lalr1.cc */ 0759 #line 195 "holidayparserplan.ypp" 0760 { 0761 driver.setEventDate(-99999, (yysemantic_stack_[(2) - (1)].ival), (yysemantic_stack_[(2) - (2)].ival)); 0762 } 0763 break; 0764 0765 case 42: 0766 0767 /* Line 678 of lalr1.cc */ 0768 #line 196 "holidayparserplan.ypp" 0769 { 0770 driver.setEventDate((yysemantic_stack_[(3) - (3)].ival), (yysemantic_stack_[(3) - (1)].ival), (yysemantic_stack_[(3) - (2)].ival)); 0771 } 0772 break; 0773 0774 case 43: 0775 0776 /* Line 678 of lalr1.cc */ 0777 #line 197 "holidayparserplan.ypp" 0778 { 0779 driver.setEventDate(-99999, (yysemantic_stack_[(2) - (2)].ival), (yysemantic_stack_[(2) - (1)].ival)); 0780 } 0781 break; 0782 0783 case 44: 0784 0785 /* Line 678 of lalr1.cc */ 0786 #line 198 "holidayparserplan.ypp" 0787 { 0788 driver.setEventDate((yysemantic_stack_[(3) - (3)].ival), (yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (1)].ival)); 0789 } 0790 break; 0791 0792 case 45: 0793 0794 /* Line 678 of lalr1.cc */ 0795 #line 199 "holidayparserplan.ypp" 0796 { 0797 driver.setEventDate((yysemantic_stack_[(4) - (4)].ival), (yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (1)].ival)); 0798 } 0799 break; 0800 0801 case 46: 0802 0803 /* Line 678 of lalr1.cc */ 0804 #line 200 "holidayparserplan.ypp" 0805 { 0806 driver.setEventDate((yysemantic_stack_[(1) - (1)].ival)); 0807 } 0808 break; 0809 0810 case 47: 0811 0812 /* Line 678 of lalr1.cc */ 0813 #line 203 "holidayparserplan.ypp" 0814 { 0815 char *s = (yysemantic_stack_[(1) - (1)].sval); 0816 (yyval.ival) = driver.julianDayFromEventName(s); 0817 free(s); 0818 (yysemantic_stack_[(1) - (1)].sval) = nullptr; 0819 } 0820 break; 0821 0822 case 48: 0823 0824 /* Line 678 of lalr1.cc */ 0825 #line 204 "holidayparserplan.ypp" 0826 { 0827 (yyval.ival) = driver.julianDayFromEaster(); 0828 } 0829 break; 0830 0831 case 49: 0832 0833 /* Line 678 of lalr1.cc */ 0834 #line 205 "holidayparserplan.ypp" 0835 { 0836 (yyval.ival) = driver.julianDayFromPascha(); 0837 } 0838 break; 0839 0840 case 50: 0841 0842 /* Line 678 of lalr1.cc */ 0843 #line 206 "holidayparserplan.ypp" 0844 { 0845 (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(3) - (3)].ival), (yysemantic_stack_[(3) - (1)].ival)); 0846 } 0847 break; 0848 0849 case 51: 0850 0851 /* Line 678 of lalr1.cc */ 0852 #line 207 "holidayparserplan.ypp" 0853 { 0854 (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(4) - (3)].ival), (yysemantic_stack_[(4) - (1)].ival)); 0855 } 0856 break; 0857 0858 case 52: 0859 0860 /* Line 678 of lalr1.cc */ 0861 #line 208 "holidayparserplan.ypp" 0862 { 0863 (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(3) - (1)].ival), (yysemantic_stack_[(3) - (3)].ival)); 0864 } 0865 break; 0866 0867 case 53: 0868 0869 /* Line 678 of lalr1.cc */ 0870 #line 209 "holidayparserplan.ypp" 0871 { 0872 (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(2) - (2)].ival), (yysemantic_stack_[(2) - (1)].ival)); 0873 } 0874 break; 0875 0876 case 54: 0877 0878 /* Line 678 of lalr1.cc */ 0879 #line 210 "holidayparserplan.ypp" 0880 { 0881 (yyval.ival) = driver.julianDayFromMonthDay((yysemantic_stack_[(2) - (1)].ival), (yysemantic_stack_[(2) - (2)].ival)); 0882 } 0883 break; 0884 0885 case 55: 0886 0887 /* Line 678 of lalr1.cc */ 0888 #line 211 "holidayparserplan.ypp" 0889 { 0890 (yyval.ival) = driver.julianDayFromRelativeWeekday((yysemantic_stack_[(3) - (2)].ival), (yysemantic_stack_[(3) - (1)].ival), (yysemantic_stack_[(3) - (3)].ival)); 0891 } 0892 break; 0893 0894 case 56: 0895 0896 /* Line 678 of lalr1.cc */ 0897 #line 212 "holidayparserplan.ypp" 0898 { 0899 (yyval.ival) = driver.julianDayFromWeekdayInMonth((yysemantic_stack_[(4) - (1)].ival), (yysemantic_stack_[(4) - (2)].ival), (yysemantic_stack_[(4) - (4)].ival)); 0900 } 0901 break; 0902 0903 case 58: 0904 0905 /* Line 678 of lalr1.cc */ 0906 #line 216 "holidayparserplan.ypp" 0907 { 0908 (yyval.ival) = driver.adjustedMonthNumber((yysemantic_stack_[(1) - (1)].ival)); 0909 } 0910 break; 0911 0912 case 59: 0913 0914 /* Line 678 of lalr1.cc */ 0915 #line 219 "holidayparserplan.ypp" 0916 { 0917 (yyval.ival) = driver.adjustedMonthNumber((yysemantic_stack_[(1) - (1)].ival)); 0918 } 0919 break; 0920 0921 case 60: 0922 0923 /* Line 678 of lalr1.cc */ 0924 #line 222 "holidayparserplan.ypp" 0925 { 0926 (yyval.ival) = (yysemantic_stack_[(1) - (1)].ival); 0927 } 0928 break; 0929 0930 case 61: 0931 0932 /* Line 678 of lalr1.cc */ 0933 #line 223 "holidayparserplan.ypp" 0934 { 0935 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) || (yysemantic_stack_[(3) - (3)].ival); 0936 } 0937 break; 0938 0939 case 62: 0940 0941 /* Line 678 of lalr1.cc */ 0942 #line 224 "holidayparserplan.ypp" 0943 { 0944 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) && (yysemantic_stack_[(3) - (3)].ival); 0945 } 0946 break; 0947 0948 case 63: 0949 0950 /* Line 678 of lalr1.cc */ 0951 #line 225 "holidayparserplan.ypp" 0952 { 0953 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) == (yysemantic_stack_[(3) - (3)].ival); 0954 } 0955 break; 0956 0957 case 64: 0958 0959 /* Line 678 of lalr1.cc */ 0960 #line 226 "holidayparserplan.ypp" 0961 { 0962 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) != (yysemantic_stack_[(3) - (3)].ival); 0963 } 0964 break; 0965 0966 case 65: 0967 0968 /* Line 678 of lalr1.cc */ 0969 #line 227 "holidayparserplan.ypp" 0970 { 0971 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) <= (yysemantic_stack_[(3) - (3)].ival); 0972 } 0973 break; 0974 0975 case 66: 0976 0977 /* Line 678 of lalr1.cc */ 0978 #line 228 "holidayparserplan.ypp" 0979 { 0980 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) >= (yysemantic_stack_[(3) - (3)].ival); 0981 } 0982 break; 0983 0984 case 67: 0985 0986 /* Line 678 of lalr1.cc */ 0987 #line 229 "holidayparserplan.ypp" 0988 { 0989 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) < (yysemantic_stack_[(3) - (3)].ival); 0990 } 0991 break; 0992 0993 case 68: 0994 0995 /* Line 678 of lalr1.cc */ 0996 #line 230 "holidayparserplan.ypp" 0997 { 0998 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) > (yysemantic_stack_[(3) - (3)].ival); 0999 } 1000 break; 1001 1002 case 69: 1003 1004 /* Line 678 of lalr1.cc */ 1005 #line 231 "holidayparserplan.ypp" 1006 { 1007 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) + (yysemantic_stack_[(3) - (3)].ival); 1008 } 1009 break; 1010 1011 case 70: 1012 1013 /* Line 678 of lalr1.cc */ 1014 #line 232 "holidayparserplan.ypp" 1015 { 1016 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) - (yysemantic_stack_[(3) - (3)].ival); 1017 } 1018 break; 1019 1020 case 71: 1021 1022 /* Line 678 of lalr1.cc */ 1023 #line 233 "holidayparserplan.ypp" 1024 { 1025 (yyval.ival) = (yysemantic_stack_[(3) - (1)].ival) * (yysemantic_stack_[(3) - (3)].ival); 1026 } 1027 break; 1028 1029 case 72: 1030 1031 /* Line 678 of lalr1.cc */ 1032 #line 234 "holidayparserplan.ypp" 1033 { 1034 (yyval.ival) = (yysemantic_stack_[(3) - (3)].ival) ? (yysemantic_stack_[(3) - (1)].ival) / (yysemantic_stack_[(3) - (3)].ival) : 0; 1035 } 1036 break; 1037 1038 case 73: 1039 1040 /* Line 678 of lalr1.cc */ 1041 #line 235 "holidayparserplan.ypp" 1042 { 1043 (yyval.ival) = (yysemantic_stack_[(3) - (3)].ival) ? (yysemantic_stack_[(3) - (1)].ival) % (yysemantic_stack_[(3) - (3)].ival) : 0; 1044 } 1045 break; 1046 1047 case 74: 1048 1049 /* Line 678 of lalr1.cc */ 1050 #line 236 "holidayparserplan.ypp" 1051 { 1052 (yyval.ival) = (yysemantic_stack_[(5) - (1)].ival) ? (yysemantic_stack_[(5) - (3)].ival) : (yysemantic_stack_[(5) - (5)].ival); 1053 } 1054 break; 1055 1056 case 75: 1057 1058 /* Line 678 of lalr1.cc */ 1059 #line 237 "holidayparserplan.ypp" 1060 { 1061 (yyval.ival) = !(yysemantic_stack_[(2) - (2)].ival); 1062 } 1063 break; 1064 1065 case 76: 1066 1067 /* Line 678 of lalr1.cc */ 1068 #line 238 "holidayparserplan.ypp" 1069 { 1070 (yyval.ival) = (yysemantic_stack_[(3) - (2)].ival); 1071 } 1072 break; 1073 1074 case 77: 1075 1076 /* Line 678 of lalr1.cc */ 1077 #line 241 "holidayparserplan.ypp" 1078 { 1079 (yyval.ival) = (yysemantic_stack_[(3) - (2)].ival); 1080 } 1081 break; 1082 1083 case 78: 1084 1085 /* Line 678 of lalr1.cc */ 1086 #line 242 "holidayparserplan.ypp" 1087 { 1088 (yyval.ival) = (yysemantic_stack_[(1) - (1)].ival); 1089 } 1090 break; 1091 1092 case 80: 1093 1094 /* Line 678 of lalr1.cc */ 1095 #line 246 "holidayparserplan.ypp" 1096 { 1097 (yyval.ival) = -(yysemantic_stack_[(2) - (2)].ival); 1098 } 1099 break; 1100 1101 case 81: 1102 1103 /* Line 678 of lalr1.cc */ 1104 #line 247 "holidayparserplan.ypp" 1105 { 1106 (yyval.ival) = driver.parseYear(); 1107 } 1108 break; 1109 1110 case 82: 1111 1112 /* Line 678 of lalr1.cc */ 1113 #line 248 "holidayparserplan.ypp" 1114 { 1115 (yyval.ival) = driver.isLeapYear((yysemantic_stack_[(2) - (2)].ival)); 1116 } 1117 break; 1118 1119 /* Line 678 of lalr1.cc */ 1120 #line 990 "holidayparserplan.cpp" 1121 default: 1122 break; 1123 } 1124 YY_SYMBOL_PRINT("-> $$ =", yyr1_[yyn], &yyval, &yyloc); 1125 1126 yypop_(yylen); 1127 yylen = 0; 1128 YY_STACK_PRINT(); 1129 1130 yysemantic_stack_.push(yyval); 1131 yylocation_stack_.push(yyloc); 1132 1133 /* Shift the result of the reduction. */ 1134 yyn = yyr1_[yyn]; 1135 yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0]; 1136 if (0 <= yystate && yystate <= yylast_ 1137 && yycheck_[yystate] == yystate_stack_[0]) { 1138 yystate = yytable_[yystate]; 1139 } else { 1140 yystate = yydefgoto_[yyn - yyntokens_]; 1141 } 1142 goto yynewstate; 1143 1144 /*------------------------------------. 1145 | yyerrlab -- here on detecting error | 1146 `------------------------------------*/ 1147 yyerrlab: 1148 /* If not already recovering from an error, report this error. */ 1149 if (!yyerrstatus_) { 1150 ++yynerrs_; 1151 error(yylloc, yysyntax_error_(yylloc.begin.filename, yystate, yytoken)); 1152 } 1153 1154 yyerror_range[0] = yylloc; 1155 if (yyerrstatus_ == 3) { 1156 /* If just tried and failed to reuse lookahead token after an 1157 error, discard it. */ 1158 1159 if (yychar <= yyeof_) { 1160 /* Return failure if at end of input. */ 1161 if (yychar == yyeof_) { 1162 YYABORT; 1163 } 1164 } else { 1165 yydestruct_("Error: discarding", yytoken, &yylval, &yylloc); 1166 yychar = yyempty_; 1167 } 1168 } 1169 1170 /* Else will try to reuse lookahead token after shifting the error 1171 token. */ 1172 goto yyerrlab1; 1173 1174 /*---------------------------------------------------. 1175 | yyerrorlab -- error raised explicitly by YYERROR. | 1176 `---------------------------------------------------*/ 1177 yyerrorlab: 1178 1179 /* Pacify compilers like GCC when the user code never invokes 1180 YYERROR and the label yyerrorlab therefore never appears in user 1181 code. */ 1182 if (false) { 1183 goto yyerrorlab; 1184 } 1185 1186 yyerror_range[0] = yylocation_stack_[yylen - 1]; 1187 /* Do not reclaim the symbols of the rule which action triggered 1188 this YYERROR. */ 1189 yypop_(yylen); 1190 yylen = 0; 1191 yystate = yystate_stack_[0]; 1192 goto yyerrlab1; 1193 1194 /*-------------------------------------------------------------. 1195 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1196 `-------------------------------------------------------------*/ 1197 yyerrlab1: 1198 yyerrstatus_ = 3; /* Each real token shifted decrements this. */ 1199 1200 for (;;) { 1201 yyn = yypact_[yystate]; 1202 if (yyn != yypact_ninf_) { 1203 yyn += yyterror_; 1204 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) { 1205 yyn = yytable_[yyn]; 1206 if (0 < yyn) { 1207 break; 1208 } 1209 } 1210 } 1211 1212 /* Pop the current state because it cannot handle the error token. */ 1213 if (yystate_stack_.height() == 1) { 1214 YYABORT; 1215 } 1216 1217 yyerror_range[0] = yylocation_stack_[0]; 1218 yydestruct_("Error: popping", 1219 yystos_[yystate], 1220 &yysemantic_stack_[0], &yylocation_stack_[0]); 1221 yypop_(); 1222 yystate = yystate_stack_[0]; 1223 YY_STACK_PRINT(); 1224 } 1225 1226 yyerror_range[1] = yylloc; 1227 // Using YYLLOC is tempting, but would change the location of 1228 // the lookahead. YYLOC is available though. 1229 YYLLOC_DEFAULT(yyloc, (yyerror_range - 1), 2); 1230 yysemantic_stack_.push(yylval); 1231 yylocation_stack_.push(yyloc); 1232 1233 /* Shift the error token. */ 1234 YY_SYMBOL_PRINT("Shifting", yystos_[yyn], 1235 &yysemantic_stack_[0], &yylocation_stack_[0]); 1236 1237 yystate = yyn; 1238 goto yynewstate; 1239 1240 /* Accept. */ 1241 yyacceptlab: 1242 yyresult = 0; 1243 goto yyreturn; 1244 1245 /* Abort. */ 1246 yyabortlab: 1247 yyresult = 1; 1248 goto yyreturn; 1249 1250 yyreturn: 1251 if (yychar != yyempty_) { 1252 yydestruct_("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc); 1253 } 1254 1255 /* Do not reclaim the symbols of the rule which action triggered 1256 this YYABORT or YYACCEPT. */ 1257 yypop_(yylen); 1258 while (yystate_stack_.height() != 1) { 1259 yydestruct_("Cleanup: popping", 1260 yystos_[yystate_stack_[0]], 1261 &yysemantic_stack_[0], 1262 &yylocation_stack_[0]); 1263 yypop_(); 1264 } 1265 1266 return yyresult; 1267 } 1268 1269 // Generate an error message. 1270 std::string 1271 HolidayParserPlan::yysyntax_error_(std::string *filename, int yystate, int tok) 1272 { 1273 std::string res; 1274 YYUSE(yystate); 1275 #if YYERROR_VERBOSE 1276 int yyn = yypact_[yystate]; 1277 if (yypact_ninf_ < yyn && yyn <= yylast_) { 1278 /* Start YYX at -YYN if negative to avoid negative indexes in 1279 YYCHECK. */ 1280 int yyxbegin = yyn < 0 ? -yyn : 0; 1281 1282 /* Stay within bounds of both yycheck and yytname. */ 1283 int yychecklim = yylast_ - yyn + 1; 1284 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; 1285 int count = 0; 1286 for (int x = yyxbegin; x < yyxend; ++x) 1287 if (yycheck_[x + yyn] == x && x != yyterror_) { 1288 ++count; 1289 } 1290 1291 // FIXME: This method of building the message is not compatible 1292 // with internationalization. It should work like yacc.c does it. 1293 // That is, first build a string that looks like this: 1294 // "syntax error, unexpected %s or %s or %s" 1295 // Then, invoke YY_ on this string. 1296 // Finally, use the string as a format to output 1297 // yytname_[tok], etc. 1298 // Until this gets fixed, this message appears in English only. 1299 res = "syntax error, unexpected "; 1300 res += yytnamerr_(yytname_[tok]); 1301 if (count < 5) { 1302 count = 0; 1303 for (int x = yyxbegin; x < yyxend; ++x) 1304 if (yycheck_[x + yyn] == x && x != yyterror_) { 1305 res += (!count++) ? ", expecting " : " or "; 1306 res += yytnamerr_(yytname_[x]); 1307 res += ". Filepath : " + *filename; 1308 } 1309 } 1310 } else 1311 #endif 1312 res = YY_("syntax error"); 1313 return res; 1314 } 1315 1316 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1317 STATE-NUM. */ 1318 const signed char HolidayParserPlan::yypact_ninf_ = -70; 1319 const short int 1320 HolidayParserPlan::yypact_[] = { 1321 -24, -1, 25, -70, 1, -70, -70, 39, 42, 38, 1322 -70, 65, -70, 64, 51, -70, 5, -70, 75, -70, 1323 -70, -70, 114, -70, -70, -70, 129, -70, 6, 30, 1324 30, 84, 134, -70, 30, 58, 6, -2, -70, 134, 1325 134, 77, 63, -70, 77, 77, -70, 134, 85, 160, 1326 -70, 81, 6, 6, 12, 131, 6, 209, 209, 134, 1327 -70, 30, 43, -70, -70, 62, 6, -70, -70, -70, 1328 54, 67, 6, 3, 134, 134, 134, 134, 134, 134, 1329 134, 134, 134, 134, 134, 134, 134, 134, -70, 98, 1330 77, 71, -70, 63, 77, 6, 70, -70, -70, -70, 1331 209, 77, 6, -70, 6, -70, -70, 102, 63, 251, 1332 251, 251, 251, 251, 251, 230, 251, 116, 116, 62, 1333 62, 62, 187, 86, 99, -70, 6, 30, -70, -70, 1334 134, -70, -70, -70, 63, 80, 134, 98, 98, -70, 1335 77, 209, -70, -70, -70, -70, -70, -70 1336 }; 1337 1338 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE 1339 doesn't specify something else to do. Zero means the default is an 1340 error. */ 1341 const unsigned char 1342 HolidayParserPlan::yydefact_[] = { 1343 4, 0, 0, 12, 6, 5, 1, 2, 0, 8, 1344 14, 0, 7, 0, 10, 15, 17, 9, 0, 3, 1345 16, 18, 0, 11, 79, 59, 26, 81, 0, 26, 1346 26, 0, 0, 13, 26, 0, 57, 46, 78, 0, 1347 0, 34, 0, 82, 34, 34, 80, 0, 0, 0, 1348 60, 29, 0, 41, 26, 0, 43, 27, 28, 0, 1349 22, 26, 46, 19, 20, 75, 0, 47, 48, 49, 1350 0, 0, 57, 58, 0, 0, 0, 0, 0, 0, 1351 0, 0, 0, 0, 0, 0, 0, 0, 77, 31, 1352 34, 39, 42, 0, 34, 59, 36, 57, 58, 44, 1353 35, 34, 0, 76, 0, 54, 53, 0, 0, 63, 1354 64, 65, 66, 67, 68, 61, 62, 70, 69, 71, 1355 72, 73, 0, 32, 0, 21, 0, 26, 23, 45, 1356 37, 25, 55, 52, 0, 50, 0, 31, 31, 40, 1357 34, 38, 56, 51, 74, 33, 30, 24 1358 }; 1359 1360 /* YYPGOTO[NTERM-NUM]. */ 1361 const signed char 1362 HolidayParserPlan::yypgoto_[] = { 1363 -70, -70, -70, -70, -70, -70, -70, -70, -70, -70, 1364 -70, -70, -19, -70, -69, -16, 79, -70, -9, 111, 1365 -23, -22, -70 1366 }; 1367 1368 /* YYDEFGOTO[NTERM-NUM]. */ 1369 const signed char 1370 HolidayParserPlan::yydefgoto_[] = { 1371 -1, 2, 3, 4, 9, 14, 19, 7, 11, 16, 1372 22, 33, 41, 90, 124, 60, 34, 70, 35, 97, 1373 49, 50, 38 1374 }; 1375 1376 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 1377 positive, shift that token. If negative, reduce the rule which 1378 number is the opposite. If zero, do what YYDEFACT says. */ 1379 const signed char HolidayParserPlan::yytable_ninf_ = -59; 1380 const short int 1381 HolidayParserPlan::yytable_[] = { 1382 37, 1, 25, 54, 42, 5, 43, 106, 107, 24, 1383 44, 45, 20, 21, 53, 51, 57, 58, 27, 28, 1384 62, 93, 39, 40, 65, 6, 73, 8, 63, 64, 1385 91, 92, -58, 98, 99, 94, 100, 31, 55, 71, 1386 39, 40, 101, 108, 102, 10, 96, 25, 12, 32, 1387 105, 109, 110, 111, 112, 113, 114, 115, 116, 117, 1388 118, 119, 120, 121, 122, 13, 24, 25, 145, 146, 1389 17, 98, 15, 129, 125, 27, 28, -58, 128, 18, 1390 132, 23, 133, 55, 127, 131, 98, 46, 24, 25, 1391 66, 67, 52, 59, 31, 89, 103, 27, 28, 135, 1392 87, 104, 68, 123, 139, 126, 32, 141, 140, 69, 1393 130, 134, 98, 144, 138, 137, 31, 24, 25, 26, 1394 143, 61, 0, 0, 147, 142, 27, 28, 32, 0, 1395 0, 29, 24, 36, 24, 95, 0, 24, 30, 39, 1396 40, 27, 28, 27, 28, 31, 27, 28, 56, 84, 1397 85, 86, 0, 36, 87, 0, 0, 32, 0, 72, 1398 31, 0, 31, 0, 0, 31, 0, 0, 0, 0, 1399 47, 0, 32, 56, 32, 48, 0, 32, 74, 75, 1400 76, 77, 78, 79, 0, 0, 0, 0, 0, 80, 1401 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 1402 0, 0, 0, 0, 88, 74, 75, 76, 77, 78, 1403 79, 0, 0, 0, 0, 0, 80, 81, 82, 83, 1404 84, 85, 86, 0, 0, 87, 136, 74, 75, 76, 1405 77, 78, 79, 0, 0, 0, 0, 0, 80, 81, 1406 82, 83, 84, 85, 86, 0, 0, 87, 74, 75, 1407 76, 77, 78, 79, 0, 0, 0, 0, 0, 0, 1408 81, 82, 83, 84, 85, 86, 0, 0, 87, 74, 1409 75, 76, 77, 78, 79, 0, 0, 0, 0, 0, 1410 0, 0, 82, 83, 84, 85, 86, 0, 0, 87 1411 }; 1412 1413 /* YYCHECK. */ 1414 const short int 1415 HolidayParserPlan::yycheck_[] = { 1416 22, 25, 4, 5, 26, 6, 28, 4, 5, 3, 1417 29, 30, 7, 8, 36, 34, 39, 40, 12, 13, 1418 42, 9, 10, 11, 47, 0, 48, 26, 44, 45, 1419 52, 53, 34, 55, 56, 54, 59, 31, 40, 48, 1420 10, 11, 61, 40, 66, 6, 55, 4, 6, 43, 1421 72, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1422 83, 84, 85, 86, 87, 27, 3, 4, 137, 138, 1423 6, 93, 7, 95, 90, 12, 13, 34, 94, 28, 1424 102, 6, 104, 40, 93, 101, 108, 3, 3, 4, 1425 5, 6, 34, 16, 31, 14, 42, 12, 13, 108, 1426 38, 34, 17, 5, 126, 34, 43, 130, 127, 24, 1427 40, 9, 134, 136, 15, 29, 31, 3, 4, 5, 1428 40, 42, -1, -1, 140, 134, 12, 13, 43, -1, 1429 -1, 17, 3, 22, 3, 4, -1, 3, 24, 10, 1430 11, 12, 13, 12, 13, 31, 12, 13, 37, 33, 1431 34, 35, -1, 42, 38, -1, -1, 43, -1, 48, 1432 31, -1, 31, -1, -1, 31, -1, -1, -1, -1, 1433 36, -1, 43, 62, 43, 41, -1, 43, 18, 19, 1434 20, 21, 22, 23, -1, -1, -1, -1, -1, 29, 1435 30, 31, 32, 33, 34, 35, -1, -1, 38, -1, 1436 -1, -1, -1, -1, 44, 18, 19, 20, 21, 22, 1437 23, -1, -1, -1, -1, -1, 29, 30, 31, 32, 1438 33, 34, 35, -1, -1, 38, 39, 18, 19, 20, 1439 21, 22, 23, -1, -1, -1, -1, -1, 29, 30, 1440 31, 32, 33, 34, 35, -1, -1, 38, 18, 19, 1441 20, 21, 22, 23, -1, -1, -1, -1, -1, -1, 1442 30, 31, 32, 33, 34, 35, -1, -1, 38, 18, 1443 19, 20, 21, 22, 23, -1, -1, -1, -1, -1, 1444 -1, -1, 31, 32, 33, 34, 35, -1, -1, 38 1445 }; 1446 1447 /* STOS_[STATE-NUM] -- The (internal number of the) accessing 1448 symbol of state STATE-NUM. */ 1449 const unsigned char 1450 HolidayParserPlan::yystos_[] = { 1451 0, 25, 46, 47, 48, 6, 0, 52, 26, 49, 1452 6, 53, 6, 27, 50, 7, 54, 6, 28, 51, 1453 7, 8, 55, 6, 3, 4, 5, 12, 13, 17, 1454 24, 31, 43, 56, 61, 63, 64, 66, 67, 10, 1455 11, 57, 66, 66, 57, 57, 3, 36, 41, 65, 1456 66, 57, 34, 66, 5, 40, 64, 65, 65, 16, 1457 60, 61, 66, 60, 60, 65, 5, 6, 17, 24, 1458 62, 63, 64, 66, 18, 19, 20, 21, 22, 23, 1459 29, 30, 31, 32, 33, 34, 35, 38, 44, 14, 1460 58, 66, 66, 9, 57, 4, 63, 64, 66, 66, 1461 65, 57, 66, 42, 34, 66, 4, 5, 40, 65, 1462 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 1463 65, 65, 65, 5, 59, 60, 34, 63, 60, 66, 1464 40, 60, 66, 66, 9, 63, 39, 29, 15, 66, 1465 57, 65, 63, 40, 65, 59, 59, 60 1466 }; 1467 1468 #if YYDEBUG 1469 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding 1470 to YYLEX-NUM. */ 1471 const unsigned short int 1472 HolidayParserPlan::yytoken_number_[] = { 1473 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 1474 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 1475 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1476 285, 45, 43, 42, 47, 37, 33, 286, 63, 58, 1477 46, 91, 93, 40, 41 1478 }; 1479 #endif 1480 1481 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 1482 const unsigned char 1483 HolidayParserPlan::yyr1_[] = { 1484 0, 45, 46, 47, 48, 48, 49, 49, 50, 50, 1485 51, 51, 52, 52, 53, 54, 54, 55, 55, 56, 1486 56, 56, 56, 56, 56, 56, 57, 57, 57, 58, 1487 58, 59, 59, 59, 60, 60, 61, 61, 61, 61, 1488 61, 61, 61, 61, 61, 61, 61, 62, 62, 62, 1489 62, 62, 62, 62, 62, 62, 62, 63, 63, 64, 1490 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 1491 65, 65, 65, 65, 65, 65, 65, 66, 66, 67, 1492 67, 67, 67 1493 }; 1494 1495 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 1496 const unsigned char 1497 HolidayParserPlan::yyr2_[] = { 1498 0, 2, 2, 4, 0, 2, 0, 2, 0, 2, 1499 0, 2, 0, 5, 1, 1, 2, 0, 1, 3, 1500 3, 4, 3, 4, 6, 5, 0, 2, 2, 0, 1501 4, 0, 1, 3, 0, 2, 3, 4, 5, 3, 1502 5, 2, 3, 2, 3, 4, 1, 1, 1, 1, 1503 3, 4, 3, 2, 2, 3, 4, 1, 1, 1, 1504 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1505 3, 3, 3, 3, 5, 2, 3, 3, 1, 1, 1506 2, 1, 2 1507 }; 1508 1509 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 1510 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 1511 First, the terminals, then, starting at \a yyntokens_, nonterminals. */ 1512 const char * 1513 const HolidayParserPlan::yytname_[] = { 1514 "END", "error", "$undefined", "NUMBER", "MONTH", "WDAY", "STRING", 1515 "CATEGORY", "CALENDAR", "INOP", "PLUS", "MINUS", "YEAR", "LEAPYEAR", 1516 "SHIFT", "IF", "LENGTH", "EASTER", "EQ", "NE", "LE", "GE", "LT", "GT", 1517 "PASCHA", "COUNTRY", "LANGUAGE", "NAME", "DESCRIPTION", "OR", "AND", 1518 "'-'", "'+'", "'*'", "'/'", "'%'", "'!'", "UMINUS", "'?'", "':'", "'.'", 1519 "'['", "']'", "'('", "')'", "$accept", "planfile", "metadata", 1520 "countrycode", "languagecode", "name", "description", "list", 1521 "eventname", "categories", "calendar", "eventrule", "offset", 1522 "conditionaloffset", "wdaycondition", "length", "date", "reldate", 1523 "month", "monthnumber", "expr", "pexpr", "number", nullptr 1524 }; 1525 #endif 1526 1527 #if YYDEBUG 1528 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 1529 const HolidayParserPlan::rhs_number_type 1530 HolidayParserPlan::yyrhs_[] = { 1531 46, 0, -1, 47, 52, -1, 48, 49, 50, 51, 1532 -1, -1, 25, 6, -1, -1, 26, 6, -1, -1, 1533 27, 6, -1, -1, 28, 6, -1, -1, 52, 53, 1534 54, 55, 56, -1, 6, -1, 7, -1, 54, 7, 1535 -1, -1, 8, -1, 17, 57, 60, -1, 24, 57, 1536 60, -1, 61, 57, 58, 60, -1, 5, 57, 60, 1537 -1, 66, 5, 57, 60, -1, 66, 5, 9, 63, 1538 57, 60, -1, 5, 66, 61, 57, 60, -1, -1, 1539 10, 65, -1, 11, 65, -1, -1, 14, 59, 15, 1540 59, -1, -1, 5, -1, 5, 29, 59, -1, -1, 1541 16, 65, -1, 66, 40, 63, -1, 66, 40, 63, 1542 40, -1, 66, 40, 63, 40, 65, -1, 63, 34, 1543 66, -1, 63, 34, 66, 34, 66, -1, 64, 66, 1544 -1, 64, 66, 66, -1, 66, 64, -1, 66, 64, 1545 66, -1, 66, 40, 4, 66, -1, 66, -1, 6, 1546 -1, 17, -1, 24, -1, 66, 40, 63, -1, 66, 1547 40, 63, 40, -1, 63, 34, 66, -1, 66, 4, 1548 -1, 64, 66, -1, 5, 66, 66, -1, 66, 5, 1549 9, 63, -1, 64, -1, 66, -1, 4, -1, 66, 1550 -1, 65, 29, 65, -1, 65, 30, 65, -1, 65, 1551 18, 65, -1, 65, 19, 65, -1, 65, 20, 65, 1552 -1, 65, 21, 65, -1, 65, 22, 65, -1, 65, 1553 23, 65, -1, 65, 32, 65, -1, 65, 31, 65, 1554 -1, 65, 33, 65, -1, 65, 34, 65, -1, 65, 1555 35, 65, -1, 65, 38, 65, 39, 65, -1, 36, 1556 65, -1, 41, 62, 42, -1, 43, 65, 44, -1, 1557 67, -1, 3, -1, 31, 3, -1, 12, -1, 13, 1558 66, -1 1559 }; 1560 1561 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 1562 YYRHS. */ 1563 const unsigned short int 1564 HolidayParserPlan::yyprhs_[] = { 1565 0, 0, 3, 6, 11, 12, 15, 16, 19, 20, 1566 23, 24, 27, 28, 34, 36, 38, 41, 42, 44, 1567 48, 52, 57, 61, 66, 73, 79, 80, 83, 86, 1568 87, 92, 93, 95, 99, 100, 103, 107, 112, 118, 1569 122, 128, 131, 135, 138, 142, 147, 149, 151, 153, 1570 155, 159, 164, 168, 171, 174, 178, 183, 185, 187, 1571 189, 191, 195, 199, 203, 207, 211, 215, 219, 223, 1572 227, 231, 235, 239, 243, 249, 252, 256, 260, 262, 1573 264, 267, 269 1574 }; 1575 1576 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 1577 const unsigned char 1578 HolidayParserPlan::yyrline_[] = { 1579 0, 126, 126, 129, 132, 133, 136, 137, 140, 141, 1580 144, 145, 148, 149, 152, 155, 156, 159, 160, 163, 1581 164, 165, 166, 167, 168, 169, 172, 173, 174, 177, 1582 178, 181, 182, 183, 186, 187, 190, 191, 192, 193, 1583 194, 195, 196, 197, 198, 199, 200, 203, 204, 205, 1584 206, 207, 208, 209, 210, 211, 212, 215, 216, 219, 1585 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 1586 232, 233, 234, 235, 236, 237, 238, 241, 242, 245, 1587 246, 247, 248 1588 }; 1589 1590 // Print the state stack on the debug stream. 1591 void 1592 HolidayParserPlan::yystack_print_() 1593 { 1594 *yycdebug_ << "Stack now"; 1595 for (state_stack_type::const_iterator i = yystate_stack_.begin(); 1596 i != yystate_stack_.end(); ++i) { 1597 *yycdebug_ << ' ' << *i; 1598 } 1599 *yycdebug_ << std::endl; 1600 } 1601 1602 // Report on the debug stream that the rule \a yyrule is going to be reduced. 1603 void 1604 HolidayParserPlan::yy_reduce_print_(int yyrule) 1605 { 1606 unsigned int yylno = yyrline_[yyrule]; 1607 int yynrhs = yyr2_[yyrule]; 1608 /* Print the symbols being reduced, and their result. */ 1609 *yycdebug_ << "Reducing stack by rule " << yyrule - 1 1610 << " (line " << yylno << "):" << std::endl; 1611 /* The symbols being reduced. */ 1612 for (int yyi = 0; yyi < yynrhs; yyi++) 1613 YY_SYMBOL_PRINT(" $" << yyi + 1 << " =", 1614 yyrhs_[yyprhs_[yyrule] + yyi], 1615 &(yysemantic_stack_[(yynrhs) - (yyi + 1)]), 1616 &(yylocation_stack_[(yynrhs) - (yyi + 1)])); 1617 } 1618 #endif // YYDEBUG 1619 1620 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 1621 HolidayParserPlan::token_number_type 1622 HolidayParserPlan::yytranslate_(int t) 1623 { 1624 static 1625 const token_number_type 1626 translate_table[] = { 1627 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1628 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1629 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1630 2, 2, 2, 36, 2, 2, 2, 35, 2, 2, 1631 43, 44, 33, 32, 2, 31, 40, 34, 2, 2, 1632 2, 2, 2, 2, 2, 2, 2, 2, 39, 2, 1633 2, 2, 2, 38, 2, 2, 2, 2, 2, 2, 1634 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1635 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1636 2, 41, 2, 42, 2, 2, 2, 2, 2, 2, 1637 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1638 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1639 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1640 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1641 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1642 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1643 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1644 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1645 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1646 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1647 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1648 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1649 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1650 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1651 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1652 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 1653 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1654 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 1655 25, 26, 27, 28, 29, 30, 37 1656 }; 1657 if ((unsigned int) t <= yyuser_token_number_max_) { 1658 return translate_table[t]; 1659 } else { 1660 return yyundef_token_; 1661 } 1662 } 1663 1664 const int HolidayParserPlan::yyeof_ = 0; 1665 const int HolidayParserPlan::yylast_ = 289; 1666 const int HolidayParserPlan::yynnts_ = 23; 1667 const int HolidayParserPlan::yyempty_ = -2; 1668 const int HolidayParserPlan::yyfinal_ = 6; 1669 const int HolidayParserPlan::yyterror_ = 1; 1670 const int HolidayParserPlan::yyerrcode_ = 256; 1671 const int HolidayParserPlan::yyntokens_ = 45; 1672 1673 const unsigned int HolidayParserPlan::yyuser_token_number_max_ = 286; 1674 const HolidayParserPlan::token_number_type HolidayParserPlan::yyundef_token_ = 2; 1675 1676 /* Line 1054 of lalr1.cc */ 1677 #line 1 "[Bison:b4_percent_define_default]" 1678 1679 } // KHolidays 1680 1681 /* Line 1054 of lalr1.cc */ 1682 #line 1573 "holidayparserplan.cpp" 1683 1684 /* Line 1056 of lalr1.cc */ 1685 #line 251 "holidayparserplan.ypp" 1686 1687 /*** Private Yacc callbacks and helper functions ***/ 1688 1689 void KHolidays::HolidayParserPlan::error(const KHolidays::HolidayParserPlan::location_type &errorLocation, const std::string &errorMessage) 1690 { 1691 driver.error(errorLocation, errorMessage.c_str()); 1692 } 1693