gitweb.ps.run Git - toc/blob - gen/TocParser.cpp

   1 \r
   2 // Generated from Toc.g4 by ANTLR 4.9.2\r
   3 \r
   4 \r
   5 #include "TocListener.h"\r
   6 \r
   7 #include "TocParser.h"\r
   8 \r
   9 \r
  10 using namespace antlrcpp;\r
  11 using namespace antlr4;\r
  12 \r
  13 TocParser::TocParser(TokenStream *input) : Parser(input) {\r
  14   _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);\r
  15 }\r
  16 \r
  17 TocParser::~TocParser() {\r
  18   delete _interpreter;\r
  19 }\r
  20 \r
  21 std::string TocParser::getGrammarFileName() const {\r
  22   return "Toc.g4";\r
  23 }\r
  24 \r
  25 const std::vector<std::string>& TocParser::getRuleNames() const {\r
  26   return _ruleNames;\r
  27 }\r
  28 \r
  29 dfa::Vocabulary& TocParser::getVocabulary() const {\r
  30   return _vocabulary;\r
  31 }\r
  32 \r
  33 \r
  34 //----------------- ProgContext ------------------------------------------------------------------\r
  35 \r
  36 TocParser::ProgContext::ProgContext(ParserRuleContext *parent, size_t invokingState)\r
  37   : ParserRuleContext(parent, invokingState) {\r
  38 }\r
  39 \r
  40 tree::TerminalNode* TocParser::ProgContext::EOF() {\r
  41   return getToken(TocParser::EOF, 0);\r
  42 }\r
  43 \r
  44 std::vector<TocParser::DeclContext *> TocParser::ProgContext::decl() {\r
  45   return getRuleContexts<TocParser::DeclContext>();\r
  46 }\r
  47 \r
  48 TocParser::DeclContext* TocParser::ProgContext::decl(size_t i) {\r
  49   return getRuleContext<TocParser::DeclContext>(i);\r
  50 }\r
  51 \r
  52 \r
  53 size_t TocParser::ProgContext::getRuleIndex() const {\r
  54   return TocParser::RuleProg;\r
  55 }\r
  56 \r
  57 void TocParser::ProgContext::enterRule(tree::ParseTreeListener *listener) {\r
  58   auto parserListener = dynamic_cast<TocListener *>(listener);\r
  59   if (parserListener != nullptr)\r
  60     parserListener->enterProg(this);\r
  61 }\r
  62 \r
  63 void TocParser::ProgContext::exitRule(tree::ParseTreeListener *listener) {\r
  64   auto parserListener = dynamic_cast<TocListener *>(listener);\r
  65   if (parserListener != nullptr)\r
  66     parserListener->exitProg(this);\r
  67 }\r
  68 \r
  69 TocParser::ProgContext* TocParser::prog() {\r
  70   ProgContext *_localctx = _tracker.createInstance<ProgContext>(_ctx, getState());\r
  71   enterRule(_localctx, 0, TocParser::RuleProg);\r
  72   size_t _la = 0;\r
  73 \r
  74 #if __cplusplus > 201703L\r
  75   auto onExit = finally([=, this] {\r
  76 #else\r
  77   auto onExit = finally([=] {\r
  78 #endif\r
  79     exitRule();\r
  80   });\r
  81   try {\r
  82     enterOuterAlt(_localctx, 1);\r
  83     setState(99); \r
  84     _errHandler->sync(this);\r
  85     _la = _input->LA(1);\r
  86     do {\r
  87       setState(98);\r
  88       decl();\r
  89       setState(101); \r
  90       _errHandler->sync(this);\r
  91       _la = _input->LA(1);\r
  92     } while ((((_la & ~ 0x3fULL) == 0) &&\r
  93       ((1ULL << _la) & ((1ULL << TocParser::T__0)\r
  94       | (1ULL << TocParser::T__6)\r
  95       | (1ULL << TocParser::T__12))) != 0));\r
  96     setState(103);\r
  97     match(TocParser::EOF);\r
  98    \r
  99   }\r
 100   catch (RecognitionException &e) {\r
 101     _errHandler->reportError(this, e);\r
 102     _localctx->exception = std::current_exception();\r
 103     _errHandler->recover(this, _localctx->exception);\r
 104   }\r
 105 \r
 106   return _localctx;\r
 107 }\r
 108 \r
 109 //----------------- DeclContext ------------------------------------------------------------------\r
 110 \r
 111 TocParser::DeclContext::DeclContext(ParserRuleContext *parent, size_t invokingState)\r
 112   : ParserRuleContext(parent, invokingState) {\r
 113 }\r
 114 \r
 115 TocParser::VarDeclContext* TocParser::DeclContext::varDecl() {\r
 116   return getRuleContext<TocParser::VarDeclContext>(0);\r
 117 }\r
 118 \r
 119 TocParser::FuncDeclContext* TocParser::DeclContext::funcDecl() {\r
 120   return getRuleContext<TocParser::FuncDeclContext>(0);\r
 121 }\r
 122 \r
 123 TocParser::StructDeclContext* TocParser::DeclContext::structDecl() {\r
 124   return getRuleContext<TocParser::StructDeclContext>(0);\r
 125 }\r
 126 \r
 127 \r
 128 size_t TocParser::DeclContext::getRuleIndex() const {\r
 129   return TocParser::RuleDecl;\r
 130 }\r
 131 \r
 132 void TocParser::DeclContext::enterRule(tree::ParseTreeListener *listener) {\r
 133   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 134   if (parserListener != nullptr)\r
 135     parserListener->enterDecl(this);\r
 136 }\r
 137 \r
 138 void TocParser::DeclContext::exitRule(tree::ParseTreeListener *listener) {\r
 139   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 140   if (parserListener != nullptr)\r
 141     parserListener->exitDecl(this);\r
 142 }\r
 143 \r
 144 TocParser::DeclContext* TocParser::decl() {\r
 145   DeclContext *_localctx = _tracker.createInstance<DeclContext>(_ctx, getState());\r
 146   enterRule(_localctx, 2, TocParser::RuleDecl);\r
 147 \r
 148 #if __cplusplus > 201703L\r
 149   auto onExit = finally([=, this] {\r
 150 #else\r
 151   auto onExit = finally([=] {\r
 152 #endif\r
 153     exitRule();\r
 154   });\r
 155   try {\r
 156     setState(108);\r
 157     _errHandler->sync(this);\r
 158     switch (_input->LA(1)) {\r
 159       case TocParser::T__0: {\r
 160         enterOuterAlt(_localctx, 1);\r
 161         setState(105);\r
 162         varDecl();\r
 163         break;\r
 164       }\r
 165 \r
 166       case TocParser::T__6: {\r
 167         enterOuterAlt(_localctx, 2);\r
 168         setState(106);\r
 169         funcDecl();\r
 170         break;\r
 171       }\r
 172 \r
 173       case TocParser::T__12: {\r
 174         enterOuterAlt(_localctx, 3);\r
 175         setState(107);\r
 176         structDecl();\r
 177         break;\r
 178       }\r
 179 \r
 180     default:\r
 181       throw NoViableAltException(this);\r
 182     }\r
 183    \r
 184   }\r
 185   catch (RecognitionException &e) {\r
 186     _errHandler->reportError(this, e);\r
 187     _localctx->exception = std::current_exception();\r
 188     _errHandler->recover(this, _localctx->exception);\r
 189   }\r
 190 \r
 191   return _localctx;\r
 192 }\r
 193 \r
 194 //----------------- VarDeclContext ------------------------------------------------------------------\r
 195 \r
 196 TocParser::VarDeclContext::VarDeclContext(ParserRuleContext *parent, size_t invokingState)\r
 197   : ParserRuleContext(parent, invokingState) {\r
 198 }\r
 199 \r
 200 TocParser::VarContext* TocParser::VarDeclContext::var() {\r
 201   return getRuleContext<TocParser::VarContext>(0);\r
 202 }\r
 203 \r
 204 \r
 205 size_t TocParser::VarDeclContext::getRuleIndex() const {\r
 206   return TocParser::RuleVarDecl;\r
 207 }\r
 208 \r
 209 void TocParser::VarDeclContext::enterRule(tree::ParseTreeListener *listener) {\r
 210   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 211   if (parserListener != nullptr)\r
 212     parserListener->enterVarDecl(this);\r
 213 }\r
 214 \r
 215 void TocParser::VarDeclContext::exitRule(tree::ParseTreeListener *listener) {\r
 216   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 217   if (parserListener != nullptr)\r
 218     parserListener->exitVarDecl(this);\r
 219 }\r
 220 \r
 221 TocParser::VarDeclContext* TocParser::varDecl() {\r
 222   VarDeclContext *_localctx = _tracker.createInstance<VarDeclContext>(_ctx, getState());\r
 223   enterRule(_localctx, 4, TocParser::RuleVarDecl);\r
 224 \r
 225 #if __cplusplus > 201703L\r
 226   auto onExit = finally([=, this] {\r
 227 #else\r
 228   auto onExit = finally([=] {\r
 229 #endif\r
 230     exitRule();\r
 231   });\r
 232   try {\r
 233     enterOuterAlt(_localctx, 1);\r
 234     setState(110);\r
 235     match(TocParser::T__0);\r
 236     setState(111);\r
 237     var();\r
 238    \r
 239   }\r
 240   catch (RecognitionException &e) {\r
 241     _errHandler->reportError(this, e);\r
 242     _localctx->exception = std::current_exception();\r
 243     _errHandler->recover(this, _localctx->exception);\r
 244   }\r
 245 \r
 246   return _localctx;\r
 247 }\r
 248 \r
 249 //----------------- VarContext ------------------------------------------------------------------\r
 250 \r
 251 TocParser::VarContext::VarContext(ParserRuleContext *parent, size_t invokingState)\r
 252   : ParserRuleContext(parent, invokingState) {\r
 253 }\r
 254 \r
 255 TocParser::VarNameContext* TocParser::VarContext::varName() {\r
 256   return getRuleContext<TocParser::VarNameContext>(0);\r
 257 }\r
 258 \r
 259 TocParser::TypeContext* TocParser::VarContext::type() {\r
 260   return getRuleContext<TocParser::TypeContext>(0);\r
 261 }\r
 262 \r
 263 TocParser::ExprContext* TocParser::VarContext::expr() {\r
 264   return getRuleContext<TocParser::ExprContext>(0);\r
 265 }\r
 266 \r
 267 \r
 268 size_t TocParser::VarContext::getRuleIndex() const {\r
 269   return TocParser::RuleVar;\r
 270 }\r
 271 \r
 272 void TocParser::VarContext::enterRule(tree::ParseTreeListener *listener) {\r
 273   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 274   if (parserListener != nullptr)\r
 275     parserListener->enterVar(this);\r
 276 }\r
 277 \r
 278 void TocParser::VarContext::exitRule(tree::ParseTreeListener *listener) {\r
 279   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 280   if (parserListener != nullptr)\r
 281     parserListener->exitVar(this);\r
 282 }\r
 283 \r
 284 TocParser::VarContext* TocParser::var() {\r
 285   VarContext *_localctx = _tracker.createInstance<VarContext>(_ctx, getState());\r
 286   enterRule(_localctx, 6, TocParser::RuleVar);\r
 287   size_t _la = 0;\r
 288 \r
 289 #if __cplusplus > 201703L\r
 290   auto onExit = finally([=, this] {\r
 291 #else\r
 292   auto onExit = finally([=] {\r
 293 #endif\r
 294     exitRule();\r
 295   });\r
 296   try {\r
 297     enterOuterAlt(_localctx, 1);\r
 298     setState(113);\r
 299     varName();\r
 300 \r
 301     setState(114);\r
 302     match(TocParser::T__1);\r
 303     setState(115);\r
 304     type();\r
 305     setState(119);\r
 306     _errHandler->sync(this);\r
 307 \r
 308     _la = _input->LA(1);\r
 309     if (_la == TocParser::T__2) {\r
 310       setState(117);\r
 311       match(TocParser::T__2);\r
 312       setState(118);\r
 313       expr();\r
 314     }\r
 315    \r
 316   }\r
 317   catch (RecognitionException &e) {\r
 318     _errHandler->reportError(this, e);\r
 319     _localctx->exception = std::current_exception();\r
 320     _errHandler->recover(this, _localctx->exception);\r
 321   }\r
 322 \r
 323   return _localctx;\r
 324 }\r
 325 \r
 326 //----------------- VarInitContext ------------------------------------------------------------------\r
 327 \r
 328 TocParser::VarInitContext::VarInitContext(ParserRuleContext *parent, size_t invokingState)\r
 329   : ParserRuleContext(parent, invokingState) {\r
 330 }\r
 331 \r
 332 TocParser::VarNameContext* TocParser::VarInitContext::varName() {\r
 333   return getRuleContext<TocParser::VarNameContext>(0);\r
 334 }\r
 335 \r
 336 TocParser::TypeContext* TocParser::VarInitContext::type() {\r
 337   return getRuleContext<TocParser::TypeContext>(0);\r
 338 }\r
 339 \r
 340 TocParser::ExprContext* TocParser::VarInitContext::expr() {\r
 341   return getRuleContext<TocParser::ExprContext>(0);\r
 342 }\r
 343 \r
 344 \r
 345 size_t TocParser::VarInitContext::getRuleIndex() const {\r
 346   return TocParser::RuleVarInit;\r
 347 }\r
 348 \r
 349 void TocParser::VarInitContext::enterRule(tree::ParseTreeListener *listener) {\r
 350   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 351   if (parserListener != nullptr)\r
 352     parserListener->enterVarInit(this);\r
 353 }\r
 354 \r
 355 void TocParser::VarInitContext::exitRule(tree::ParseTreeListener *listener) {\r
 356   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 357   if (parserListener != nullptr)\r
 358     parserListener->exitVarInit(this);\r
 359 }\r
 360 \r
 361 TocParser::VarInitContext* TocParser::varInit() {\r
 362   VarInitContext *_localctx = _tracker.createInstance<VarInitContext>(_ctx, getState());\r
 363   enterRule(_localctx, 8, TocParser::RuleVarInit);\r
 364 \r
 365 #if __cplusplus > 201703L\r
 366   auto onExit = finally([=, this] {\r
 367 #else\r
 368   auto onExit = finally([=] {\r
 369 #endif\r
 370     exitRule();\r
 371   });\r
 372   try {\r
 373     enterOuterAlt(_localctx, 1);\r
 374     setState(121);\r
 375     varName();\r
 376 \r
 377     setState(122);\r
 378     match(TocParser::T__1);\r
 379     setState(123);\r
 380     type();\r
 381 \r
 382     setState(125);\r
 383     match(TocParser::T__2);\r
 384     setState(126);\r
 385     expr();\r
 386    \r
 387   }\r
 388   catch (RecognitionException &e) {\r
 389     _errHandler->reportError(this, e);\r
 390     _localctx->exception = std::current_exception();\r
 391     _errHandler->recover(this, _localctx->exception);\r
 392   }\r
 393 \r
 394   return _localctx;\r
 395 }\r
 396 \r
 397 //----------------- TypeContext ------------------------------------------------------------------\r
 398 \r
 399 TocParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState)\r
 400   : ParserRuleContext(parent, invokingState) {\r
 401 }\r
 402 \r
 403 TocParser::TypeNameContext* TocParser::TypeContext::typeName() {\r
 404   return getRuleContext<TocParser::TypeNameContext>(0);\r
 405 }\r
 406 \r
 407 std::vector<TocParser::TypeModifierContext *> TocParser::TypeContext::typeModifier() {\r
 408   return getRuleContexts<TocParser::TypeModifierContext>();\r
 409 }\r
 410 \r
 411 TocParser::TypeModifierContext* TocParser::TypeContext::typeModifier(size_t i) {\r
 412   return getRuleContext<TocParser::TypeModifierContext>(i);\r
 413 }\r
 414 \r
 415 \r
 416 size_t TocParser::TypeContext::getRuleIndex() const {\r
 417   return TocParser::RuleType;\r
 418 }\r
 419 \r
 420 void TocParser::TypeContext::enterRule(tree::ParseTreeListener *listener) {\r
 421   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 422   if (parserListener != nullptr)\r
 423     parserListener->enterType(this);\r
 424 }\r
 425 \r
 426 void TocParser::TypeContext::exitRule(tree::ParseTreeListener *listener) {\r
 427   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 428   if (parserListener != nullptr)\r
 429     parserListener->exitType(this);\r
 430 }\r
 431 \r
 432 TocParser::TypeContext* TocParser::type() {\r
 433   TypeContext *_localctx = _tracker.createInstance<TypeContext>(_ctx, getState());\r
 434   enterRule(_localctx, 10, TocParser::RuleType);\r
 435 \r
 436 #if __cplusplus > 201703L\r
 437   auto onExit = finally([=, this] {\r
 438 #else\r
 439   auto onExit = finally([=] {\r
 440 #endif\r
 441     exitRule();\r
 442   });\r
 443   try {\r
 444     size_t alt;\r
 445     enterOuterAlt(_localctx, 1);\r
 446     setState(128);\r
 447     typeName();\r
 448     setState(132);\r
 449     _errHandler->sync(this);\r
 450     alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx);\r
 451     while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {\r
 452       if (alt == 1) {\r
 453         setState(129);\r
 454         typeModifier(); \r
 455       }\r
 456       setState(134);\r
 457       _errHandler->sync(this);\r
 458       alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx);\r
 459     }\r
 460    \r
 461   }\r
 462   catch (RecognitionException &e) {\r
 463     _errHandler->reportError(this, e);\r
 464     _localctx->exception = std::current_exception();\r
 465     _errHandler->recover(this, _localctx->exception);\r
 466   }\r
 467 \r
 468   return _localctx;\r
 469 }\r
 470 \r
 471 //----------------- TypeModifierContext ------------------------------------------------------------------\r
 472 \r
 473 TocParser::TypeModifierContext::TypeModifierContext(ParserRuleContext *parent, size_t invokingState)\r
 474   : ParserRuleContext(parent, invokingState) {\r
 475 }\r
 476 \r
 477 tree::TerminalNode* TocParser::TypeModifierContext::NUMBER() {\r
 478   return getToken(TocParser::NUMBER, 0);\r
 479 }\r
 480 \r
 481 \r
 482 size_t TocParser::TypeModifierContext::getRuleIndex() const {\r
 483   return TocParser::RuleTypeModifier;\r
 484 }\r
 485 \r
 486 void TocParser::TypeModifierContext::enterRule(tree::ParseTreeListener *listener) {\r
 487   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 488   if (parserListener != nullptr)\r
 489     parserListener->enterTypeModifier(this);\r
 490 }\r
 491 \r
 492 void TocParser::TypeModifierContext::exitRule(tree::ParseTreeListener *listener) {\r
 493   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 494   if (parserListener != nullptr)\r
 495     parserListener->exitTypeModifier(this);\r
 496 }\r
 497 \r
 498 TocParser::TypeModifierContext* TocParser::typeModifier() {\r
 499   TypeModifierContext *_localctx = _tracker.createInstance<TypeModifierContext>(_ctx, getState());\r
 500   enterRule(_localctx, 12, TocParser::RuleTypeModifier);\r
 501   size_t _la = 0;\r
 502 \r
 503 #if __cplusplus > 201703L\r
 504   auto onExit = finally([=, this] {\r
 505 #else\r
 506   auto onExit = finally([=] {\r
 507 #endif\r
 508     exitRule();\r
 509   });\r
 510   try {\r
 511     setState(141);\r
 512     _errHandler->sync(this);\r
 513     switch (_input->LA(1)) {\r
 514       case TocParser::T__3: {\r
 515         enterOuterAlt(_localctx, 1);\r
 516         setState(135);\r
 517         match(TocParser::T__3);\r
 518         break;\r
 519       }\r
 520 \r
 521       case TocParser::T__4: {\r
 522         enterOuterAlt(_localctx, 2);\r
 523         setState(136);\r
 524         match(TocParser::T__4);\r
 525         setState(138);\r
 526         _errHandler->sync(this);\r
 527 \r
 528         _la = _input->LA(1);\r
 529         if (_la == TocParser::NUMBER) {\r
 530           setState(137);\r
 531           match(TocParser::NUMBER);\r
 532         }\r
 533         setState(140);\r
 534         match(TocParser::T__5);\r
 535         break;\r
 536       }\r
 537 \r
 538     default:\r
 539       throw NoViableAltException(this);\r
 540     }\r
 541    \r
 542   }\r
 543   catch (RecognitionException &e) {\r
 544     _errHandler->reportError(this, e);\r
 545     _localctx->exception = std::current_exception();\r
 546     _errHandler->recover(this, _localctx->exception);\r
 547   }\r
 548 \r
 549   return _localctx;\r
 550 }\r
 551 \r
 552 //----------------- FuncDeclContext ------------------------------------------------------------------\r
 553 \r
 554 TocParser::FuncDeclContext::FuncDeclContext(ParserRuleContext *parent, size_t invokingState)\r
 555   : ParserRuleContext(parent, invokingState) {\r
 556 }\r
 557 \r
 558 TocParser::FuncContext* TocParser::FuncDeclContext::func() {\r
 559   return getRuleContext<TocParser::FuncContext>(0);\r
 560 }\r
 561 \r
 562 \r
 563 size_t TocParser::FuncDeclContext::getRuleIndex() const {\r
 564   return TocParser::RuleFuncDecl;\r
 565 }\r
 566 \r
 567 void TocParser::FuncDeclContext::enterRule(tree::ParseTreeListener *listener) {\r
 568   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 569   if (parserListener != nullptr)\r
 570     parserListener->enterFuncDecl(this);\r
 571 }\r
 572 \r
 573 void TocParser::FuncDeclContext::exitRule(tree::ParseTreeListener *listener) {\r
 574   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 575   if (parserListener != nullptr)\r
 576     parserListener->exitFuncDecl(this);\r
 577 }\r
 578 \r
 579 TocParser::FuncDeclContext* TocParser::funcDecl() {\r
 580   FuncDeclContext *_localctx = _tracker.createInstance<FuncDeclContext>(_ctx, getState());\r
 581   enterRule(_localctx, 14, TocParser::RuleFuncDecl);\r
 582 \r
 583 #if __cplusplus > 201703L\r
 584   auto onExit = finally([=, this] {\r
 585 #else\r
 586   auto onExit = finally([=] {\r
 587 #endif\r
 588     exitRule();\r
 589   });\r
 590   try {\r
 591     enterOuterAlt(_localctx, 1);\r
 592     setState(143);\r
 593     match(TocParser::T__6);\r
 594     setState(144);\r
 595     func();\r
 596    \r
 597   }\r
 598   catch (RecognitionException &e) {\r
 599     _errHandler->reportError(this, e);\r
 600     _localctx->exception = std::current_exception();\r
 601     _errHandler->recover(this, _localctx->exception);\r
 602   }\r
 603 \r
 604   return _localctx;\r
 605 }\r
 606 \r
 607 //----------------- FuncContext ------------------------------------------------------------------\r
 608 \r
 609 TocParser::FuncContext::FuncContext(ParserRuleContext *parent, size_t invokingState)\r
 610   : ParserRuleContext(parent, invokingState) {\r
 611 }\r
 612 \r
 613 TocParser::FuncNameContext* TocParser::FuncContext::funcName() {\r
 614   return getRuleContext<TocParser::FuncNameContext>(0);\r
 615 }\r
 616 \r
 617 TocParser::ParameterContext* TocParser::FuncContext::parameter() {\r
 618   return getRuleContext<TocParser::ParameterContext>(0);\r
 619 }\r
 620 \r
 621 TocParser::BodyContext* TocParser::FuncContext::body() {\r
 622   return getRuleContext<TocParser::BodyContext>(0);\r
 623 }\r
 624 \r
 625 TocParser::TypeContext* TocParser::FuncContext::type() {\r
 626   return getRuleContext<TocParser::TypeContext>(0);\r
 627 }\r
 628 \r
 629 \r
 630 size_t TocParser::FuncContext::getRuleIndex() const {\r
 631   return TocParser::RuleFunc;\r
 632 }\r
 633 \r
 634 void TocParser::FuncContext::enterRule(tree::ParseTreeListener *listener) {\r
 635   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 636   if (parserListener != nullptr)\r
 637     parserListener->enterFunc(this);\r
 638 }\r
 639 \r
 640 void TocParser::FuncContext::exitRule(tree::ParseTreeListener *listener) {\r
 641   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 642   if (parserListener != nullptr)\r
 643     parserListener->exitFunc(this);\r
 644 }\r
 645 \r
 646 TocParser::FuncContext* TocParser::func() {\r
 647   FuncContext *_localctx = _tracker.createInstance<FuncContext>(_ctx, getState());\r
 648   enterRule(_localctx, 16, TocParser::RuleFunc);\r
 649 \r
 650 #if __cplusplus > 201703L\r
 651   auto onExit = finally([=, this] {\r
 652 #else\r
 653   auto onExit = finally([=] {\r
 654 #endif\r
 655     exitRule();\r
 656   });\r
 657   try {\r
 658     enterOuterAlt(_localctx, 1);\r
 659     setState(146);\r
 660     funcName();\r
 661     setState(147);\r
 662     match(TocParser::T__7);\r
 663     setState(148);\r
 664     parameter();\r
 665     setState(149);\r
 666     match(TocParser::T__8);\r
 667 \r
 668     setState(150);\r
 669     match(TocParser::T__1);\r
 670     setState(151);\r
 671     type();\r
 672     setState(153);\r
 673     body();\r
 674    \r
 675   }\r
 676   catch (RecognitionException &e) {\r
 677     _errHandler->reportError(this, e);\r
 678     _localctx->exception = std::current_exception();\r
 679     _errHandler->recover(this, _localctx->exception);\r
 680   }\r
 681 \r
 682   return _localctx;\r
 683 }\r
 684 \r
 685 //----------------- ParameterContext ------------------------------------------------------------------\r
 686 \r
 687 TocParser::ParameterContext::ParameterContext(ParserRuleContext *parent, size_t invokingState)\r
 688   : ParserRuleContext(parent, invokingState) {\r
 689 }\r
 690 \r
 691 std::vector<TocParser::VarContext *> TocParser::ParameterContext::var() {\r
 692   return getRuleContexts<TocParser::VarContext>();\r
 693 }\r
 694 \r
 695 TocParser::VarContext* TocParser::ParameterContext::var(size_t i) {\r
 696   return getRuleContext<TocParser::VarContext>(i);\r
 697 }\r
 698 \r
 699 \r
 700 size_t TocParser::ParameterContext::getRuleIndex() const {\r
 701   return TocParser::RuleParameter;\r
 702 }\r
 703 \r
 704 void TocParser::ParameterContext::enterRule(tree::ParseTreeListener *listener) {\r
 705   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 706   if (parserListener != nullptr)\r
 707     parserListener->enterParameter(this);\r
 708 }\r
 709 \r
 710 void TocParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) {\r
 711   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 712   if (parserListener != nullptr)\r
 713     parserListener->exitParameter(this);\r
 714 }\r
 715 \r
 716 TocParser::ParameterContext* TocParser::parameter() {\r
 717   ParameterContext *_localctx = _tracker.createInstance<ParameterContext>(_ctx, getState());\r
 718   enterRule(_localctx, 18, TocParser::RuleParameter);\r
 719   size_t _la = 0;\r
 720 \r
 721 #if __cplusplus > 201703L\r
 722   auto onExit = finally([=, this] {\r
 723 #else\r
 724   auto onExit = finally([=] {\r
 725 #endif\r
 726     exitRule();\r
 727   });\r
 728   try {\r
 729     enterOuterAlt(_localctx, 1);\r
 730     setState(163);\r
 731     _errHandler->sync(this);\r
 732 \r
 733     _la = _input->LA(1);\r
 734     if (_la == TocParser::NAME) {\r
 735       setState(155);\r
 736       var();\r
 737       setState(160);\r
 738       _errHandler->sync(this);\r
 739       _la = _input->LA(1);\r
 740       while (_la == TocParser::T__9) {\r
 741         setState(156);\r
 742         match(TocParser::T__9);\r
 743         setState(157);\r
 744         var();\r
 745         setState(162);\r
 746         _errHandler->sync(this);\r
 747         _la = _input->LA(1);\r
 748       }\r
 749     }\r
 750    \r
 751   }\r
 752   catch (RecognitionException &e) {\r
 753     _errHandler->reportError(this, e);\r
 754     _localctx->exception = std::current_exception();\r
 755     _errHandler->recover(this, _localctx->exception);\r
 756   }\r
 757 \r
 758   return _localctx;\r
 759 }\r
 760 \r
 761 //----------------- BodyContext ------------------------------------------------------------------\r
 762 \r
 763 TocParser::BodyContext::BodyContext(ParserRuleContext *parent, size_t invokingState)\r
 764   : ParserRuleContext(parent, invokingState) {\r
 765 }\r
 766 \r
 767 std::vector<TocParser::StmtContext *> TocParser::BodyContext::stmt() {\r
 768   return getRuleContexts<TocParser::StmtContext>();\r
 769 }\r
 770 \r
 771 TocParser::StmtContext* TocParser::BodyContext::stmt(size_t i) {\r
 772   return getRuleContext<TocParser::StmtContext>(i);\r
 773 }\r
 774 \r
 775 \r
 776 size_t TocParser::BodyContext::getRuleIndex() const {\r
 777   return TocParser::RuleBody;\r
 778 }\r
 779 \r
 780 void TocParser::BodyContext::enterRule(tree::ParseTreeListener *listener) {\r
 781   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 782   if (parserListener != nullptr)\r
 783     parserListener->enterBody(this);\r
 784 }\r
 785 \r
 786 void TocParser::BodyContext::exitRule(tree::ParseTreeListener *listener) {\r
 787   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 788   if (parserListener != nullptr)\r
 789     parserListener->exitBody(this);\r
 790 }\r
 791 \r
 792 TocParser::BodyContext* TocParser::body() {\r
 793   BodyContext *_localctx = _tracker.createInstance<BodyContext>(_ctx, getState());\r
 794   enterRule(_localctx, 20, TocParser::RuleBody);\r
 795   size_t _la = 0;\r
 796 \r
 797 #if __cplusplus > 201703L\r
 798   auto onExit = finally([=, this] {\r
 799 #else\r
 800   auto onExit = finally([=] {\r
 801 #endif\r
 802     exitRule();\r
 803   });\r
 804   try {\r
 805     enterOuterAlt(_localctx, 1);\r
 806     setState(165);\r
 807     match(TocParser::T__10);\r
 808     setState(169);\r
 809     _errHandler->sync(this);\r
 810     _la = _input->LA(1);\r
 811     while ((((_la & ~ 0x3fULL) == 0) &&\r
 812       ((1ULL << _la) & ((1ULL << TocParser::T__0)\r
 813       | (1ULL << TocParser::T__3)\r
 814       | (1ULL << TocParser::T__7)\r
 815       | (1ULL << TocParser::T__13)\r
 816       | (1ULL << TocParser::T__15)\r
 817       | (1ULL << TocParser::T__17)\r
 818       | (1ULL << TocParser::T__18)\r
 819       | (1ULL << TocParser::T__19)\r
 820       | (1ULL << TocParser::T__23)\r
 821       | (1ULL << TocParser::T__24)\r
 822       | (1ULL << TocParser::T__25)\r
 823       | (1ULL << TocParser::T__26)\r
 824       | (1ULL << TocParser::T__27)\r
 825       | (1ULL << TocParser::T__28)\r
 826       | (1ULL << TocParser::T__29)\r
 827       | (1ULL << TocParser::INT_LIT)\r
 828       | (1ULL << TocParser::DECIMAL_LIT)\r
 829       | (1ULL << TocParser::STRING_LIT)\r
 830       | (1ULL << TocParser::BOOL_LIT)\r
 831       | (1ULL << TocParser::NAME))) != 0)) {\r
 832       setState(166);\r
 833       stmt();\r
 834       setState(171);\r
 835       _errHandler->sync(this);\r
 836       _la = _input->LA(1);\r
 837     }\r
 838     setState(172);\r
 839     match(TocParser::T__11);\r
 840    \r
 841   }\r
 842   catch (RecognitionException &e) {\r
 843     _errHandler->reportError(this, e);\r
 844     _localctx->exception = std::current_exception();\r
 845     _errHandler->recover(this, _localctx->exception);\r
 846   }\r
 847 \r
 848   return _localctx;\r
 849 }\r
 850 \r
 851 //----------------- StructDeclContext ------------------------------------------------------------------\r
 852 \r
 853 TocParser::StructDeclContext::StructDeclContext(ParserRuleContext *parent, size_t invokingState)\r
 854   : ParserRuleContext(parent, invokingState) {\r
 855 }\r
 856 \r
 857 TocParser::StructNameContext* TocParser::StructDeclContext::structName() {\r
 858   return getRuleContext<TocParser::StructNameContext>(0);\r
 859 }\r
 860 \r
 861 std::vector<TocParser::StructMemberContext *> TocParser::StructDeclContext::structMember() {\r
 862   return getRuleContexts<TocParser::StructMemberContext>();\r
 863 }\r
 864 \r
 865 TocParser::StructMemberContext* TocParser::StructDeclContext::structMember(size_t i) {\r
 866   return getRuleContext<TocParser::StructMemberContext>(i);\r
 867 }\r
 868 \r
 869 \r
 870 size_t TocParser::StructDeclContext::getRuleIndex() const {\r
 871   return TocParser::RuleStructDecl;\r
 872 }\r
 873 \r
 874 void TocParser::StructDeclContext::enterRule(tree::ParseTreeListener *listener) {\r
 875   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 876   if (parserListener != nullptr)\r
 877     parserListener->enterStructDecl(this);\r
 878 }\r
 879 \r
 880 void TocParser::StructDeclContext::exitRule(tree::ParseTreeListener *listener) {\r
 881   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 882   if (parserListener != nullptr)\r
 883     parserListener->exitStructDecl(this);\r
 884 }\r
 885 \r
 886 TocParser::StructDeclContext* TocParser::structDecl() {\r
 887   StructDeclContext *_localctx = _tracker.createInstance<StructDeclContext>(_ctx, getState());\r
 888   enterRule(_localctx, 22, TocParser::RuleStructDecl);\r
 889   size_t _la = 0;\r
 890 \r
 891 #if __cplusplus > 201703L\r
 892   auto onExit = finally([=, this] {\r
 893 #else\r
 894   auto onExit = finally([=] {\r
 895 #endif\r
 896     exitRule();\r
 897   });\r
 898   try {\r
 899     enterOuterAlt(_localctx, 1);\r
 900     setState(174);\r
 901     match(TocParser::T__12);\r
 902     setState(175);\r
 903     structName();\r
 904     setState(176);\r
 905     match(TocParser::T__10);\r
 906     setState(180);\r
 907     _errHandler->sync(this);\r
 908     _la = _input->LA(1);\r
 909     while (_la == TocParser::NAME) {\r
 910       setState(177);\r
 911       structMember();\r
 912       setState(182);\r
 913       _errHandler->sync(this);\r
 914       _la = _input->LA(1);\r
 915     }\r
 916     setState(183);\r
 917     match(TocParser::T__11);\r
 918    \r
 919   }\r
 920   catch (RecognitionException &e) {\r
 921     _errHandler->reportError(this, e);\r
 922     _localctx->exception = std::current_exception();\r
 923     _errHandler->recover(this, _localctx->exception);\r
 924   }\r
 925 \r
 926   return _localctx;\r
 927 }\r
 928 \r
 929 //----------------- StructMemberContext ------------------------------------------------------------------\r
 930 \r
 931 TocParser::StructMemberContext::StructMemberContext(ParserRuleContext *parent, size_t invokingState)\r
 932   : ParserRuleContext(parent, invokingState) {\r
 933 }\r
 934 \r
 935 TocParser::StructVarContext* TocParser::StructMemberContext::structVar() {\r
 936   return getRuleContext<TocParser::StructVarContext>(0);\r
 937 }\r
 938 \r
 939 TocParser::StructMethodContext* TocParser::StructMemberContext::structMethod() {\r
 940   return getRuleContext<TocParser::StructMethodContext>(0);\r
 941 }\r
 942 \r
 943 \r
 944 size_t TocParser::StructMemberContext::getRuleIndex() const {\r
 945   return TocParser::RuleStructMember;\r
 946 }\r
 947 \r
 948 void TocParser::StructMemberContext::enterRule(tree::ParseTreeListener *listener) {\r
 949   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 950   if (parserListener != nullptr)\r
 951     parserListener->enterStructMember(this);\r
 952 }\r
 953 \r
 954 void TocParser::StructMemberContext::exitRule(tree::ParseTreeListener *listener) {\r
 955   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 956   if (parserListener != nullptr)\r
 957     parserListener->exitStructMember(this);\r
 958 }\r
 959 \r
 960 TocParser::StructMemberContext* TocParser::structMember() {\r
 961   StructMemberContext *_localctx = _tracker.createInstance<StructMemberContext>(_ctx, getState());\r
 962   enterRule(_localctx, 24, TocParser::RuleStructMember);\r
 963 \r
 964 #if __cplusplus > 201703L\r
 965   auto onExit = finally([=, this] {\r
 966 #else\r
 967   auto onExit = finally([=] {\r
 968 #endif\r
 969     exitRule();\r
 970   });\r
 971   try {\r
 972     setState(187);\r
 973     _errHandler->sync(this);\r
 974     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {\r
 975     case 1: {\r
 976       enterOuterAlt(_localctx, 1);\r
 977       setState(185);\r
 978       structVar();\r
 979       break;\r
 980     }\r
 981 \r
 982     case 2: {\r
 983       enterOuterAlt(_localctx, 2);\r
 984       setState(186);\r
 985       structMethod();\r
 986       break;\r
 987     }\r
 988 \r
 989     default:\r
 990       break;\r
 991     }\r
 992    \r
 993   }\r
 994   catch (RecognitionException &e) {\r
 995     _errHandler->reportError(this, e);\r
 996     _localctx->exception = std::current_exception();\r
 997     _errHandler->recover(this, _localctx->exception);\r
 998   }\r
 999 \r
1000   return _localctx;\r
1001 }\r
1002 \r
1003 //----------------- StructVarContext ------------------------------------------------------------------\r
1004 \r
1005 TocParser::StructVarContext::StructVarContext(ParserRuleContext *parent, size_t invokingState)\r
1006   : ParserRuleContext(parent, invokingState) {\r
1007 }\r
1008 \r
1009 TocParser::VarContext* TocParser::StructVarContext::var() {\r
1010   return getRuleContext<TocParser::VarContext>(0);\r
1011 }\r
1012 \r
1013 \r
1014 size_t TocParser::StructVarContext::getRuleIndex() const {\r
1015   return TocParser::RuleStructVar;\r
1016 }\r
1017 \r
1018 void TocParser::StructVarContext::enterRule(tree::ParseTreeListener *listener) {\r
1019   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1020   if (parserListener != nullptr)\r
1021     parserListener->enterStructVar(this);\r
1022 }\r
1023 \r
1024 void TocParser::StructVarContext::exitRule(tree::ParseTreeListener *listener) {\r
1025   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1026   if (parserListener != nullptr)\r
1027     parserListener->exitStructVar(this);\r
1028 }\r
1029 \r
1030 TocParser::StructVarContext* TocParser::structVar() {\r
1031   StructVarContext *_localctx = _tracker.createInstance<StructVarContext>(_ctx, getState());\r
1032   enterRule(_localctx, 26, TocParser::RuleStructVar);\r
1033 \r
1034 #if __cplusplus > 201703L\r
1035   auto onExit = finally([=, this] {\r
1036 #else\r
1037   auto onExit = finally([=] {\r
1038 #endif\r
1039     exitRule();\r
1040   });\r
1041   try {\r
1042     enterOuterAlt(_localctx, 1);\r
1043     setState(189);\r
1044     var();\r
1045    \r
1046   }\r
1047   catch (RecognitionException &e) {\r
1048     _errHandler->reportError(this, e);\r
1049     _localctx->exception = std::current_exception();\r
1050     _errHandler->recover(this, _localctx->exception);\r
1051   }\r
1052 \r
1053   return _localctx;\r
1054 }\r
1055 \r
1056 //----------------- StructMethodContext ------------------------------------------------------------------\r
1057 \r
1058 TocParser::StructMethodContext::StructMethodContext(ParserRuleContext *parent, size_t invokingState)\r
1059   : ParserRuleContext(parent, invokingState) {\r
1060 }\r
1061 \r
1062 TocParser::FuncContext* TocParser::StructMethodContext::func() {\r
1063   return getRuleContext<TocParser::FuncContext>(0);\r
1064 }\r
1065 \r
1066 \r
1067 size_t TocParser::StructMethodContext::getRuleIndex() const {\r
1068   return TocParser::RuleStructMethod;\r
1069 }\r
1070 \r
1071 void TocParser::StructMethodContext::enterRule(tree::ParseTreeListener *listener) {\r
1072   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1073   if (parserListener != nullptr)\r
1074     parserListener->enterStructMethod(this);\r
1075 }\r
1076 \r
1077 void TocParser::StructMethodContext::exitRule(tree::ParseTreeListener *listener) {\r
1078   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1079   if (parserListener != nullptr)\r
1080     parserListener->exitStructMethod(this);\r
1081 }\r
1082 \r
1083 TocParser::StructMethodContext* TocParser::structMethod() {\r
1084   StructMethodContext *_localctx = _tracker.createInstance<StructMethodContext>(_ctx, getState());\r
1085   enterRule(_localctx, 28, TocParser::RuleStructMethod);\r
1086 \r
1087 #if __cplusplus > 201703L\r
1088   auto onExit = finally([=, this] {\r
1089 #else\r
1090   auto onExit = finally([=] {\r
1091 #endif\r
1092     exitRule();\r
1093   });\r
1094   try {\r
1095     enterOuterAlt(_localctx, 1);\r
1096     setState(191);\r
1097     func();\r
1098    \r
1099   }\r
1100   catch (RecognitionException &e) {\r
1101     _errHandler->reportError(this, e);\r
1102     _localctx->exception = std::current_exception();\r
1103     _errHandler->recover(this, _localctx->exception);\r
1104   }\r
1105 \r
1106   return _localctx;\r
1107 }\r
1108 \r
1109 //----------------- StmtContext ------------------------------------------------------------------\r
1110 \r
1111 TocParser::StmtContext::StmtContext(ParserRuleContext *parent, size_t invokingState)\r
1112   : ParserRuleContext(parent, invokingState) {\r
1113 }\r
1114 \r
1115 TocParser::VarDeclContext* TocParser::StmtContext::varDecl() {\r
1116   return getRuleContext<TocParser::VarDeclContext>(0);\r
1117 }\r
1118 \r
1119 TocParser::IfStmtContext* TocParser::StmtContext::ifStmt() {\r
1120   return getRuleContext<TocParser::IfStmtContext>(0);\r
1121 }\r
1122 \r
1123 TocParser::SwitchStmtContext* TocParser::StmtContext::switchStmt() {\r
1124   return getRuleContext<TocParser::SwitchStmtContext>(0);\r
1125 }\r
1126 \r
1127 TocParser::ForStmtContext* TocParser::StmtContext::forStmt() {\r
1128   return getRuleContext<TocParser::ForStmtContext>(0);\r
1129 }\r
1130 \r
1131 TocParser::WhileStmtContext* TocParser::StmtContext::whileStmt() {\r
1132   return getRuleContext<TocParser::WhileStmtContext>(0);\r
1133 }\r
1134 \r
1135 TocParser::AssignStmtContext* TocParser::StmtContext::assignStmt() {\r
1136   return getRuleContext<TocParser::AssignStmtContext>(0);\r
1137 }\r
1138 \r
1139 TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() {\r
1140   return getRuleContext<TocParser::ReturnStmtContext>(0);\r
1141 }\r
1142 \r
1143 TocParser::ExprContext* TocParser::StmtContext::expr() {\r
1144   return getRuleContext<TocParser::ExprContext>(0);\r
1145 }\r
1146 \r
1147 \r
1148 size_t TocParser::StmtContext::getRuleIndex() const {\r
1149   return TocParser::RuleStmt;\r
1150 }\r
1151 \r
1152 void TocParser::StmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1153   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1154   if (parserListener != nullptr)\r
1155     parserListener->enterStmt(this);\r
1156 }\r
1157 \r
1158 void TocParser::StmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1159   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1160   if (parserListener != nullptr)\r
1161     parserListener->exitStmt(this);\r
1162 }\r
1163 \r
1164 TocParser::StmtContext* TocParser::stmt() {\r
1165   StmtContext *_localctx = _tracker.createInstance<StmtContext>(_ctx, getState());\r
1166   enterRule(_localctx, 30, TocParser::RuleStmt);\r
1167 \r
1168 #if __cplusplus > 201703L\r
1169   auto onExit = finally([=, this] {\r
1170 #else\r
1171   auto onExit = finally([=] {\r
1172 #endif\r
1173     exitRule();\r
1174   });\r
1175   try {\r
1176     setState(201);\r
1177     _errHandler->sync(this);\r
1178     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx)) {\r
1179     case 1: {\r
1180       enterOuterAlt(_localctx, 1);\r
1181       setState(193);\r
1182       varDecl();\r
1183       break;\r
1184     }\r
1185 \r
1186     case 2: {\r
1187       enterOuterAlt(_localctx, 2);\r
1188       setState(194);\r
1189       ifStmt();\r
1190       break;\r
1191     }\r
1192 \r
1193     case 3: {\r
1194       enterOuterAlt(_localctx, 3);\r
1195       setState(195);\r
1196       switchStmt();\r
1197       break;\r
1198     }\r
1199 \r
1200     case 4: {\r
1201       enterOuterAlt(_localctx, 4);\r
1202       setState(196);\r
1203       forStmt();\r
1204       break;\r
1205     }\r
1206 \r
1207     case 5: {\r
1208       enterOuterAlt(_localctx, 5);\r
1209       setState(197);\r
1210       whileStmt();\r
1211       break;\r
1212     }\r
1213 \r
1214     case 6: {\r
1215       enterOuterAlt(_localctx, 6);\r
1216       setState(198);\r
1217       assignStmt();\r
1218       break;\r
1219     }\r
1220 \r
1221     case 7: {\r
1222       enterOuterAlt(_localctx, 7);\r
1223       setState(199);\r
1224       returnStmt();\r
1225       break;\r
1226     }\r
1227 \r
1228     case 8: {\r
1229       enterOuterAlt(_localctx, 8);\r
1230       setState(200);\r
1231       expr();\r
1232       break;\r
1233     }\r
1234 \r
1235     default:\r
1236       break;\r
1237     }\r
1238    \r
1239   }\r
1240   catch (RecognitionException &e) {\r
1241     _errHandler->reportError(this, e);\r
1242     _localctx->exception = std::current_exception();\r
1243     _errHandler->recover(this, _localctx->exception);\r
1244   }\r
1245 \r
1246   return _localctx;\r
1247 }\r
1248 \r
1249 //----------------- IfStmtContext ------------------------------------------------------------------\r
1250 \r
1251 TocParser::IfStmtContext::IfStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1252   : ParserRuleContext(parent, invokingState) {\r
1253 }\r
1254 \r
1255 TocParser::ExprContext* TocParser::IfStmtContext::expr() {\r
1256   return getRuleContext<TocParser::ExprContext>(0);\r
1257 }\r
1258 \r
1259 TocParser::BodyContext* TocParser::IfStmtContext::body() {\r
1260   return getRuleContext<TocParser::BodyContext>(0);\r
1261 }\r
1262 \r
1263 std::vector<TocParser::ElseIfStmtContext *> TocParser::IfStmtContext::elseIfStmt() {\r
1264   return getRuleContexts<TocParser::ElseIfStmtContext>();\r
1265 }\r
1266 \r
1267 TocParser::ElseIfStmtContext* TocParser::IfStmtContext::elseIfStmt(size_t i) {\r
1268   return getRuleContext<TocParser::ElseIfStmtContext>(i);\r
1269 }\r
1270 \r
1271 TocParser::ElseStmtContext* TocParser::IfStmtContext::elseStmt() {\r
1272   return getRuleContext<TocParser::ElseStmtContext>(0);\r
1273 }\r
1274 \r
1275 \r
1276 size_t TocParser::IfStmtContext::getRuleIndex() const {\r
1277   return TocParser::RuleIfStmt;\r
1278 }\r
1279 \r
1280 void TocParser::IfStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1281   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1282   if (parserListener != nullptr)\r
1283     parserListener->enterIfStmt(this);\r
1284 }\r
1285 \r
1286 void TocParser::IfStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1287   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1288   if (parserListener != nullptr)\r
1289     parserListener->exitIfStmt(this);\r
1290 }\r
1291 \r
1292 TocParser::IfStmtContext* TocParser::ifStmt() {\r
1293   IfStmtContext *_localctx = _tracker.createInstance<IfStmtContext>(_ctx, getState());\r
1294   enterRule(_localctx, 32, TocParser::RuleIfStmt);\r
1295   size_t _la = 0;\r
1296 \r
1297 #if __cplusplus > 201703L\r
1298   auto onExit = finally([=, this] {\r
1299 #else\r
1300   auto onExit = finally([=] {\r
1301 #endif\r
1302     exitRule();\r
1303   });\r
1304   try {\r
1305     size_t alt;\r
1306     enterOuterAlt(_localctx, 1);\r
1307     setState(203);\r
1308     match(TocParser::T__13);\r
1309     setState(204);\r
1310     expr();\r
1311     setState(205);\r
1312     body();\r
1313     setState(209);\r
1314     _errHandler->sync(this);\r
1315     alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx);\r
1316     while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {\r
1317       if (alt == 1) {\r
1318         setState(206);\r
1319         elseIfStmt(); \r
1320       }\r
1321       setState(211);\r
1322       _errHandler->sync(this);\r
1323       alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx);\r
1324     }\r
1325     setState(213);\r
1326     _errHandler->sync(this);\r
1327 \r
1328     _la = _input->LA(1);\r
1329     if (_la == TocParser::T__14) {\r
1330       setState(212);\r
1331       elseStmt();\r
1332     }\r
1333    \r
1334   }\r
1335   catch (RecognitionException &e) {\r
1336     _errHandler->reportError(this, e);\r
1337     _localctx->exception = std::current_exception();\r
1338     _errHandler->recover(this, _localctx->exception);\r
1339   }\r
1340 \r
1341   return _localctx;\r
1342 }\r
1343 \r
1344 //----------------- ElseIfStmtContext ------------------------------------------------------------------\r
1345 \r
1346 TocParser::ElseIfStmtContext::ElseIfStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1347   : ParserRuleContext(parent, invokingState) {\r
1348 }\r
1349 \r
1350 TocParser::ExprContext* TocParser::ElseIfStmtContext::expr() {\r
1351   return getRuleContext<TocParser::ExprContext>(0);\r
1352 }\r
1353 \r
1354 TocParser::BodyContext* TocParser::ElseIfStmtContext::body() {\r
1355   return getRuleContext<TocParser::BodyContext>(0);\r
1356 }\r
1357 \r
1358 \r
1359 size_t TocParser::ElseIfStmtContext::getRuleIndex() const {\r
1360   return TocParser::RuleElseIfStmt;\r
1361 }\r
1362 \r
1363 void TocParser::ElseIfStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1364   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1365   if (parserListener != nullptr)\r
1366     parserListener->enterElseIfStmt(this);\r
1367 }\r
1368 \r
1369 void TocParser::ElseIfStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1370   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1371   if (parserListener != nullptr)\r
1372     parserListener->exitElseIfStmt(this);\r
1373 }\r
1374 \r
1375 TocParser::ElseIfStmtContext* TocParser::elseIfStmt() {\r
1376   ElseIfStmtContext *_localctx = _tracker.createInstance<ElseIfStmtContext>(_ctx, getState());\r
1377   enterRule(_localctx, 34, TocParser::RuleElseIfStmt);\r
1378 \r
1379 #if __cplusplus > 201703L\r
1380   auto onExit = finally([=, this] {\r
1381 #else\r
1382   auto onExit = finally([=] {\r
1383 #endif\r
1384     exitRule();\r
1385   });\r
1386   try {\r
1387     enterOuterAlt(_localctx, 1);\r
1388     setState(215);\r
1389     match(TocParser::T__14);\r
1390     setState(216);\r
1391     match(TocParser::T__13);\r
1392     setState(217);\r
1393     expr();\r
1394     setState(218);\r
1395     body();\r
1396    \r
1397   }\r
1398   catch (RecognitionException &e) {\r
1399     _errHandler->reportError(this, e);\r
1400     _localctx->exception = std::current_exception();\r
1401     _errHandler->recover(this, _localctx->exception);\r
1402   }\r
1403 \r
1404   return _localctx;\r
1405 }\r
1406 \r
1407 //----------------- ElseStmtContext ------------------------------------------------------------------\r
1408 \r
1409 TocParser::ElseStmtContext::ElseStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1410   : ParserRuleContext(parent, invokingState) {\r
1411 }\r
1412 \r
1413 TocParser::BodyContext* TocParser::ElseStmtContext::body() {\r
1414   return getRuleContext<TocParser::BodyContext>(0);\r
1415 }\r
1416 \r
1417 \r
1418 size_t TocParser::ElseStmtContext::getRuleIndex() const {\r
1419   return TocParser::RuleElseStmt;\r
1420 }\r
1421 \r
1422 void TocParser::ElseStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1423   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1424   if (parserListener != nullptr)\r
1425     parserListener->enterElseStmt(this);\r
1426 }\r
1427 \r
1428 void TocParser::ElseStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1429   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1430   if (parserListener != nullptr)\r
1431     parserListener->exitElseStmt(this);\r
1432 }\r
1433 \r
1434 TocParser::ElseStmtContext* TocParser::elseStmt() {\r
1435   ElseStmtContext *_localctx = _tracker.createInstance<ElseStmtContext>(_ctx, getState());\r
1436   enterRule(_localctx, 36, TocParser::RuleElseStmt);\r
1437 \r
1438 #if __cplusplus > 201703L\r
1439   auto onExit = finally([=, this] {\r
1440 #else\r
1441   auto onExit = finally([=] {\r
1442 #endif\r
1443     exitRule();\r
1444   });\r
1445   try {\r
1446     enterOuterAlt(_localctx, 1);\r
1447     setState(220);\r
1448     match(TocParser::T__14);\r
1449     setState(221);\r
1450     body();\r
1451    \r
1452   }\r
1453   catch (RecognitionException &e) {\r
1454     _errHandler->reportError(this, e);\r
1455     _localctx->exception = std::current_exception();\r
1456     _errHandler->recover(this, _localctx->exception);\r
1457   }\r
1458 \r
1459   return _localctx;\r
1460 }\r
1461 \r
1462 //----------------- SwitchStmtContext ------------------------------------------------------------------\r
1463 \r
1464 TocParser::SwitchStmtContext::SwitchStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1465   : ParserRuleContext(parent, invokingState) {\r
1466 }\r
1467 \r
1468 TocParser::IdentifierExprContext* TocParser::SwitchStmtContext::identifierExpr() {\r
1469   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
1470 }\r
1471 \r
1472 TocParser::SwitchBodyContext* TocParser::SwitchStmtContext::switchBody() {\r
1473   return getRuleContext<TocParser::SwitchBodyContext>(0);\r
1474 }\r
1475 \r
1476 \r
1477 size_t TocParser::SwitchStmtContext::getRuleIndex() const {\r
1478   return TocParser::RuleSwitchStmt;\r
1479 }\r
1480 \r
1481 void TocParser::SwitchStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1482   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1483   if (parserListener != nullptr)\r
1484     parserListener->enterSwitchStmt(this);\r
1485 }\r
1486 \r
1487 void TocParser::SwitchStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1488   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1489   if (parserListener != nullptr)\r
1490     parserListener->exitSwitchStmt(this);\r
1491 }\r
1492 \r
1493 TocParser::SwitchStmtContext* TocParser::switchStmt() {\r
1494   SwitchStmtContext *_localctx = _tracker.createInstance<SwitchStmtContext>(_ctx, getState());\r
1495   enterRule(_localctx, 38, TocParser::RuleSwitchStmt);\r
1496 \r
1497 #if __cplusplus > 201703L\r
1498   auto onExit = finally([=, this] {\r
1499 #else\r
1500   auto onExit = finally([=] {\r
1501 #endif\r
1502     exitRule();\r
1503   });\r
1504   try {\r
1505     enterOuterAlt(_localctx, 1);\r
1506     setState(223);\r
1507     match(TocParser::T__15);\r
1508     setState(224);\r
1509     identifierExpr();\r
1510     setState(225);\r
1511     switchBody();\r
1512    \r
1513   }\r
1514   catch (RecognitionException &e) {\r
1515     _errHandler->reportError(this, e);\r
1516     _localctx->exception = std::current_exception();\r
1517     _errHandler->recover(this, _localctx->exception);\r
1518   }\r
1519 \r
1520   return _localctx;\r
1521 }\r
1522 \r
1523 //----------------- SwitchBodyContext ------------------------------------------------------------------\r
1524 \r
1525 TocParser::SwitchBodyContext::SwitchBodyContext(ParserRuleContext *parent, size_t invokingState)\r
1526   : ParserRuleContext(parent, invokingState) {\r
1527 }\r
1528 \r
1529 std::vector<TocParser::SwitchCaseContext *> TocParser::SwitchBodyContext::switchCase() {\r
1530   return getRuleContexts<TocParser::SwitchCaseContext>();\r
1531 }\r
1532 \r
1533 TocParser::SwitchCaseContext* TocParser::SwitchBodyContext::switchCase(size_t i) {\r
1534   return getRuleContext<TocParser::SwitchCaseContext>(i);\r
1535 }\r
1536 \r
1537 \r
1538 size_t TocParser::SwitchBodyContext::getRuleIndex() const {\r
1539   return TocParser::RuleSwitchBody;\r
1540 }\r
1541 \r
1542 void TocParser::SwitchBodyContext::enterRule(tree::ParseTreeListener *listener) {\r
1543   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1544   if (parserListener != nullptr)\r
1545     parserListener->enterSwitchBody(this);\r
1546 }\r
1547 \r
1548 void TocParser::SwitchBodyContext::exitRule(tree::ParseTreeListener *listener) {\r
1549   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1550   if (parserListener != nullptr)\r
1551     parserListener->exitSwitchBody(this);\r
1552 }\r
1553 \r
1554 TocParser::SwitchBodyContext* TocParser::switchBody() {\r
1555   SwitchBodyContext *_localctx = _tracker.createInstance<SwitchBodyContext>(_ctx, getState());\r
1556   enterRule(_localctx, 40, TocParser::RuleSwitchBody);\r
1557   size_t _la = 0;\r
1558 \r
1559 #if __cplusplus > 201703L\r
1560   auto onExit = finally([=, this] {\r
1561 #else\r
1562   auto onExit = finally([=] {\r
1563 #endif\r
1564     exitRule();\r
1565   });\r
1566   try {\r
1567     enterOuterAlt(_localctx, 1);\r
1568     setState(227);\r
1569     match(TocParser::T__10);\r
1570     setState(231);\r
1571     _errHandler->sync(this);\r
1572     _la = _input->LA(1);\r
1573     while (_la == TocParser::T__16) {\r
1574       setState(228);\r
1575       switchCase();\r
1576       setState(233);\r
1577       _errHandler->sync(this);\r
1578       _la = _input->LA(1);\r
1579     }\r
1580     setState(234);\r
1581     match(TocParser::T__11);\r
1582    \r
1583   }\r
1584   catch (RecognitionException &e) {\r
1585     _errHandler->reportError(this, e);\r
1586     _localctx->exception = std::current_exception();\r
1587     _errHandler->recover(this, _localctx->exception);\r
1588   }\r
1589 \r
1590   return _localctx;\r
1591 }\r
1592 \r
1593 //----------------- SwitchCaseContext ------------------------------------------------------------------\r
1594 \r
1595 TocParser::SwitchCaseContext::SwitchCaseContext(ParserRuleContext *parent, size_t invokingState)\r
1596   : ParserRuleContext(parent, invokingState) {\r
1597 }\r
1598 \r
1599 TocParser::ExprContext* TocParser::SwitchCaseContext::expr() {\r
1600   return getRuleContext<TocParser::ExprContext>(0);\r
1601 }\r
1602 \r
1603 TocParser::BodyContext* TocParser::SwitchCaseContext::body() {\r
1604   return getRuleContext<TocParser::BodyContext>(0);\r
1605 }\r
1606 \r
1607 \r
1608 size_t TocParser::SwitchCaseContext::getRuleIndex() const {\r
1609   return TocParser::RuleSwitchCase;\r
1610 }\r
1611 \r
1612 void TocParser::SwitchCaseContext::enterRule(tree::ParseTreeListener *listener) {\r
1613   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1614   if (parserListener != nullptr)\r
1615     parserListener->enterSwitchCase(this);\r
1616 }\r
1617 \r
1618 void TocParser::SwitchCaseContext::exitRule(tree::ParseTreeListener *listener) {\r
1619   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1620   if (parserListener != nullptr)\r
1621     parserListener->exitSwitchCase(this);\r
1622 }\r
1623 \r
1624 TocParser::SwitchCaseContext* TocParser::switchCase() {\r
1625   SwitchCaseContext *_localctx = _tracker.createInstance<SwitchCaseContext>(_ctx, getState());\r
1626   enterRule(_localctx, 42, TocParser::RuleSwitchCase);\r
1627 \r
1628 #if __cplusplus > 201703L\r
1629   auto onExit = finally([=, this] {\r
1630 #else\r
1631   auto onExit = finally([=] {\r
1632 #endif\r
1633     exitRule();\r
1634   });\r
1635   try {\r
1636     enterOuterAlt(_localctx, 1);\r
1637     setState(236);\r
1638     match(TocParser::T__16);\r
1639     setState(237);\r
1640     expr();\r
1641     setState(238);\r
1642     body();\r
1643    \r
1644   }\r
1645   catch (RecognitionException &e) {\r
1646     _errHandler->reportError(this, e);\r
1647     _localctx->exception = std::current_exception();\r
1648     _errHandler->recover(this, _localctx->exception);\r
1649   }\r
1650 \r
1651   return _localctx;\r
1652 }\r
1653 \r
1654 //----------------- ForStmtContext ------------------------------------------------------------------\r
1655 \r
1656 TocParser::ForStmtContext::ForStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1657   : ParserRuleContext(parent, invokingState) {\r
1658 }\r
1659 \r
1660 std::vector<TocParser::ExprContext *> TocParser::ForStmtContext::expr() {\r
1661   return getRuleContexts<TocParser::ExprContext>();\r
1662 }\r
1663 \r
1664 TocParser::ExprContext* TocParser::ForStmtContext::expr(size_t i) {\r
1665   return getRuleContext<TocParser::ExprContext>(i);\r
1666 }\r
1667 \r
1668 TocParser::BodyContext* TocParser::ForStmtContext::body() {\r
1669   return getRuleContext<TocParser::BodyContext>(0);\r
1670 }\r
1671 \r
1672 TocParser::VarInitContext* TocParser::ForStmtContext::varInit() {\r
1673   return getRuleContext<TocParser::VarInitContext>(0);\r
1674 }\r
1675 \r
1676 TocParser::AssignStmtContext* TocParser::ForStmtContext::assignStmt() {\r
1677   return getRuleContext<TocParser::AssignStmtContext>(0);\r
1678 }\r
1679 \r
1680 \r
1681 size_t TocParser::ForStmtContext::getRuleIndex() const {\r
1682   return TocParser::RuleForStmt;\r
1683 }\r
1684 \r
1685 void TocParser::ForStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1686   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1687   if (parserListener != nullptr)\r
1688     parserListener->enterForStmt(this);\r
1689 }\r
1690 \r
1691 void TocParser::ForStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1692   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1693   if (parserListener != nullptr)\r
1694     parserListener->exitForStmt(this);\r
1695 }\r
1696 \r
1697 TocParser::ForStmtContext* TocParser::forStmt() {\r
1698   ForStmtContext *_localctx = _tracker.createInstance<ForStmtContext>(_ctx, getState());\r
1699   enterRule(_localctx, 44, TocParser::RuleForStmt);\r
1700 \r
1701 #if __cplusplus > 201703L\r
1702   auto onExit = finally([=, this] {\r
1703 #else\r
1704   auto onExit = finally([=] {\r
1705 #endif\r
1706     exitRule();\r
1707   });\r
1708   try {\r
1709     enterOuterAlt(_localctx, 1);\r
1710     setState(240);\r
1711     match(TocParser::T__17);\r
1712     setState(243);\r
1713     _errHandler->sync(this);\r
1714     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx)) {\r
1715     case 1: {\r
1716       setState(241);\r
1717       varInit();\r
1718       break;\r
1719     }\r
1720 \r
1721     case 2: {\r
1722       setState(242);\r
1723       assignStmt();\r
1724       break;\r
1725     }\r
1726 \r
1727     default:\r
1728       break;\r
1729     }\r
1730     setState(245);\r
1731     match(TocParser::T__9);\r
1732     setState(246);\r
1733     expr();\r
1734     setState(247);\r
1735     match(TocParser::T__9);\r
1736     setState(248);\r
1737     expr();\r
1738     setState(249);\r
1739     body();\r
1740    \r
1741   }\r
1742   catch (RecognitionException &e) {\r
1743     _errHandler->reportError(this, e);\r
1744     _localctx->exception = std::current_exception();\r
1745     _errHandler->recover(this, _localctx->exception);\r
1746   }\r
1747 \r
1748   return _localctx;\r
1749 }\r
1750 \r
1751 //----------------- WhileStmtContext ------------------------------------------------------------------\r
1752 \r
1753 TocParser::WhileStmtContext::WhileStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1754   : ParserRuleContext(parent, invokingState) {\r
1755 }\r
1756 \r
1757 TocParser::ExprContext* TocParser::WhileStmtContext::expr() {\r
1758   return getRuleContext<TocParser::ExprContext>(0);\r
1759 }\r
1760 \r
1761 TocParser::BodyContext* TocParser::WhileStmtContext::body() {\r
1762   return getRuleContext<TocParser::BodyContext>(0);\r
1763 }\r
1764 \r
1765 \r
1766 size_t TocParser::WhileStmtContext::getRuleIndex() const {\r
1767   return TocParser::RuleWhileStmt;\r
1768 }\r
1769 \r
1770 void TocParser::WhileStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1771   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1772   if (parserListener != nullptr)\r
1773     parserListener->enterWhileStmt(this);\r
1774 }\r
1775 \r
1776 void TocParser::WhileStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1777   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1778   if (parserListener != nullptr)\r
1779     parserListener->exitWhileStmt(this);\r
1780 }\r
1781 \r
1782 TocParser::WhileStmtContext* TocParser::whileStmt() {\r
1783   WhileStmtContext *_localctx = _tracker.createInstance<WhileStmtContext>(_ctx, getState());\r
1784   enterRule(_localctx, 46, TocParser::RuleWhileStmt);\r
1785 \r
1786 #if __cplusplus > 201703L\r
1787   auto onExit = finally([=, this] {\r
1788 #else\r
1789   auto onExit = finally([=] {\r
1790 #endif\r
1791     exitRule();\r
1792   });\r
1793   try {\r
1794     enterOuterAlt(_localctx, 1);\r
1795     setState(251);\r
1796     match(TocParser::T__18);\r
1797     setState(252);\r
1798     expr();\r
1799     setState(253);\r
1800     body();\r
1801    \r
1802   }\r
1803   catch (RecognitionException &e) {\r
1804     _errHandler->reportError(this, e);\r
1805     _localctx->exception = std::current_exception();\r
1806     _errHandler->recover(this, _localctx->exception);\r
1807   }\r
1808 \r
1809   return _localctx;\r
1810 }\r
1811 \r
1812 //----------------- AssignStmtContext ------------------------------------------------------------------\r
1813 \r
1814 TocParser::AssignStmtContext::AssignStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1815   : ParserRuleContext(parent, invokingState) {\r
1816 }\r
1817 \r
1818 TocParser::IdentifierExprContext* TocParser::AssignStmtContext::identifierExpr() {\r
1819   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
1820 }\r
1821 \r
1822 TocParser::ExprContext* TocParser::AssignStmtContext::expr() {\r
1823   return getRuleContext<TocParser::ExprContext>(0);\r
1824 }\r
1825 \r
1826 \r
1827 size_t TocParser::AssignStmtContext::getRuleIndex() const {\r
1828   return TocParser::RuleAssignStmt;\r
1829 }\r
1830 \r
1831 void TocParser::AssignStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1832   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1833   if (parserListener != nullptr)\r
1834     parserListener->enterAssignStmt(this);\r
1835 }\r
1836 \r
1837 void TocParser::AssignStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1838   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1839   if (parserListener != nullptr)\r
1840     parserListener->exitAssignStmt(this);\r
1841 }\r
1842 \r
1843 TocParser::AssignStmtContext* TocParser::assignStmt() {\r
1844   AssignStmtContext *_localctx = _tracker.createInstance<AssignStmtContext>(_ctx, getState());\r
1845   enterRule(_localctx, 48, TocParser::RuleAssignStmt);\r
1846 \r
1847 #if __cplusplus > 201703L\r
1848   auto onExit = finally([=, this] {\r
1849 #else\r
1850   auto onExit = finally([=] {\r
1851 #endif\r
1852     exitRule();\r
1853   });\r
1854   try {\r
1855     enterOuterAlt(_localctx, 1);\r
1856     setState(255);\r
1857     identifierExpr();\r
1858     setState(256);\r
1859     match(TocParser::T__2);\r
1860     setState(257);\r
1861     expr();\r
1862    \r
1863   }\r
1864   catch (RecognitionException &e) {\r
1865     _errHandler->reportError(this, e);\r
1866     _localctx->exception = std::current_exception();\r
1867     _errHandler->recover(this, _localctx->exception);\r
1868   }\r
1869 \r
1870   return _localctx;\r
1871 }\r
1872 \r
1873 //----------------- ReturnStmtContext ------------------------------------------------------------------\r
1874 \r
1875 TocParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1876   : ParserRuleContext(parent, invokingState) {\r
1877 }\r
1878 \r
1879 TocParser::ExprContext* TocParser::ReturnStmtContext::expr() {\r
1880   return getRuleContext<TocParser::ExprContext>(0);\r
1881 }\r
1882 \r
1883 \r
1884 size_t TocParser::ReturnStmtContext::getRuleIndex() const {\r
1885   return TocParser::RuleReturnStmt;\r
1886 }\r
1887 \r
1888 void TocParser::ReturnStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1889   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1890   if (parserListener != nullptr)\r
1891     parserListener->enterReturnStmt(this);\r
1892 }\r
1893 \r
1894 void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1895   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1896   if (parserListener != nullptr)\r
1897     parserListener->exitReturnStmt(this);\r
1898 }\r
1899 \r
1900 TocParser::ReturnStmtContext* TocParser::returnStmt() {\r
1901   ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());\r
1902   enterRule(_localctx, 50, TocParser::RuleReturnStmt);\r
1903 \r
1904 #if __cplusplus > 201703L\r
1905   auto onExit = finally([=, this] {\r
1906 #else\r
1907   auto onExit = finally([=] {\r
1908 #endif\r
1909     exitRule();\r
1910   });\r
1911   try {\r
1912     enterOuterAlt(_localctx, 1);\r
1913     setState(259);\r
1914     match(TocParser::T__19);\r
1915     setState(260);\r
1916     expr();\r
1917    \r
1918   }\r
1919   catch (RecognitionException &e) {\r
1920     _errHandler->reportError(this, e);\r
1921     _localctx->exception = std::current_exception();\r
1922     _errHandler->recover(this, _localctx->exception);\r
1923   }\r
1924 \r
1925   return _localctx;\r
1926 }\r
1927 \r
1928 //----------------- ExprContext ------------------------------------------------------------------\r
1929 \r
1930 TocParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState)\r
1931   : ParserRuleContext(parent, invokingState) {\r
1932 }\r
1933 \r
1934 TocParser::FuncExprContext* TocParser::ExprContext::funcExpr() {\r
1935   return getRuleContext<TocParser::FuncExprContext>(0);\r
1936 }\r
1937 \r
1938 TocParser::LitExprContext* TocParser::ExprContext::litExpr() {\r
1939   return getRuleContext<TocParser::LitExprContext>(0);\r
1940 }\r
1941 \r
1942 TocParser::IdentifierExprContext* TocParser::ExprContext::identifierExpr() {\r
1943   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
1944 }\r
1945 \r
1946 TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() {\r
1947   return getRuleContext<TocParser::ParenExprContext>(0);\r
1948 }\r
1949 \r
1950 TocParser::AccessExprContext* TocParser::ExprContext::accessExpr() {\r
1951   return getRuleContext<TocParser::AccessExprContext>(0);\r
1952 }\r
1953 \r
1954 TocParser::OpExprContext* TocParser::ExprContext::opExpr() {\r
1955   return getRuleContext<TocParser::OpExprContext>(0);\r
1956 }\r
1957 \r
1958 \r
1959 size_t TocParser::ExprContext::getRuleIndex() const {\r
1960   return TocParser::RuleExpr;\r
1961 }\r
1962 \r
1963 void TocParser::ExprContext::enterRule(tree::ParseTreeListener *listener) {\r
1964   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1965   if (parserListener != nullptr)\r
1966     parserListener->enterExpr(this);\r
1967 }\r
1968 \r
1969 void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) {\r
1970   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1971   if (parserListener != nullptr)\r
1972     parserListener->exitExpr(this);\r
1973 }\r
1974 \r
1975 TocParser::ExprContext* TocParser::expr() {\r
1976   ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());\r
1977   enterRule(_localctx, 52, TocParser::RuleExpr);\r
1978 \r
1979 #if __cplusplus > 201703L\r
1980   auto onExit = finally([=, this] {\r
1981 #else\r
1982   auto onExit = finally([=] {\r
1983 #endif\r
1984     exitRule();\r
1985   });\r
1986   try {\r
1987     setState(268);\r
1988     _errHandler->sync(this);\r
1989     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 16, _ctx)) {\r
1990     case 1: {\r
1991       enterOuterAlt(_localctx, 1);\r
1992       setState(262);\r
1993       funcExpr();\r
1994       break;\r
1995     }\r
1996 \r
1997     case 2: {\r
1998       enterOuterAlt(_localctx, 2);\r
1999       setState(263);\r
2000       litExpr();\r
2001       break;\r
2002     }\r
2003 \r
2004     case 3: {\r
2005       enterOuterAlt(_localctx, 3);\r
2006       setState(264);\r
2007       identifierExpr();\r
2008       break;\r
2009     }\r
2010 \r
2011     case 4: {\r
2012       enterOuterAlt(_localctx, 4);\r
2013       setState(265);\r
2014       parenExpr();\r
2015       break;\r
2016     }\r
2017 \r
2018     case 5: {\r
2019       enterOuterAlt(_localctx, 5);\r
2020       setState(266);\r
2021       accessExpr();\r
2022       break;\r
2023     }\r
2024 \r
2025     case 6: {\r
2026       enterOuterAlt(_localctx, 6);\r
2027       setState(267);\r
2028       opExpr();\r
2029       break;\r
2030     }\r
2031 \r
2032     default:\r
2033       break;\r
2034     }\r
2035    \r
2036   }\r
2037   catch (RecognitionException &e) {\r
2038     _errHandler->reportError(this, e);\r
2039     _localctx->exception = std::current_exception();\r
2040     _errHandler->recover(this, _localctx->exception);\r
2041   }\r
2042 \r
2043   return _localctx;\r
2044 }\r
2045 \r
2046 //----------------- NonOpExprContext ------------------------------------------------------------------\r
2047 \r
2048 TocParser::NonOpExprContext::NonOpExprContext(ParserRuleContext *parent, size_t invokingState)\r
2049   : ParserRuleContext(parent, invokingState) {\r
2050 }\r
2051 \r
2052 TocParser::FuncExprContext* TocParser::NonOpExprContext::funcExpr() {\r
2053   return getRuleContext<TocParser::FuncExprContext>(0);\r
2054 }\r
2055 \r
2056 TocParser::LitExprContext* TocParser::NonOpExprContext::litExpr() {\r
2057   return getRuleContext<TocParser::LitExprContext>(0);\r
2058 }\r
2059 \r
2060 TocParser::IdentifierExprContext* TocParser::NonOpExprContext::identifierExpr() {\r
2061   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
2062 }\r
2063 \r
2064 TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() {\r
2065   return getRuleContext<TocParser::ParenExprContext>(0);\r
2066 }\r
2067 \r
2068 TocParser::AccessExprContext* TocParser::NonOpExprContext::accessExpr() {\r
2069   return getRuleContext<TocParser::AccessExprContext>(0);\r
2070 }\r
2071 \r
2072 \r
2073 size_t TocParser::NonOpExprContext::getRuleIndex() const {\r
2074   return TocParser::RuleNonOpExpr;\r
2075 }\r
2076 \r
2077 void TocParser::NonOpExprContext::enterRule(tree::ParseTreeListener *listener) {\r
2078   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2079   if (parserListener != nullptr)\r
2080     parserListener->enterNonOpExpr(this);\r
2081 }\r
2082 \r
2083 void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) {\r
2084   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2085   if (parserListener != nullptr)\r
2086     parserListener->exitNonOpExpr(this);\r
2087 }\r
2088 \r
2089 TocParser::NonOpExprContext* TocParser::nonOpExpr() {\r
2090   NonOpExprContext *_localctx = _tracker.createInstance<NonOpExprContext>(_ctx, getState());\r
2091   enterRule(_localctx, 54, TocParser::RuleNonOpExpr);\r
2092 \r
2093 #if __cplusplus > 201703L\r
2094   auto onExit = finally([=, this] {\r
2095 #else\r
2096   auto onExit = finally([=] {\r
2097 #endif\r
2098     exitRule();\r
2099   });\r
2100   try {\r
2101     setState(275);\r
2102     _errHandler->sync(this);\r
2103     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx)) {\r
2104     case 1: {\r
2105       enterOuterAlt(_localctx, 1);\r
2106       setState(270);\r
2107       funcExpr();\r
2108       break;\r
2109     }\r
2110 \r
2111     case 2: {\r
2112       enterOuterAlt(_localctx, 2);\r
2113       setState(271);\r
2114       litExpr();\r
2115       break;\r
2116     }\r
2117 \r
2118     case 3: {\r
2119       enterOuterAlt(_localctx, 3);\r
2120       setState(272);\r
2121       identifierExpr();\r
2122       break;\r
2123     }\r
2124 \r
2125     case 4: {\r
2126       enterOuterAlt(_localctx, 4);\r
2127       setState(273);\r
2128       parenExpr();\r
2129       break;\r
2130     }\r
2131 \r
2132     case 5: {\r
2133       enterOuterAlt(_localctx, 5);\r
2134       setState(274);\r
2135       accessExpr();\r
2136       break;\r
2137     }\r
2138 \r
2139     default:\r
2140       break;\r
2141     }\r
2142    \r
2143   }\r
2144   catch (RecognitionException &e) {\r
2145     _errHandler->reportError(this, e);\r
2146     _localctx->exception = std::current_exception();\r
2147     _errHandler->recover(this, _localctx->exception);\r
2148   }\r
2149 \r
2150   return _localctx;\r
2151 }\r
2152 \r
2153 //----------------- NonAccessExprContext ------------------------------------------------------------------\r
2154 \r
2155 TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState)\r
2156   : ParserRuleContext(parent, invokingState) {\r
2157 }\r
2158 \r
2159 TocParser::FuncExprContext* TocParser::NonAccessExprContext::funcExpr() {\r
2160   return getRuleContext<TocParser::FuncExprContext>(0);\r
2161 }\r
2162 \r
2163 TocParser::IdentifierExprContext* TocParser::NonAccessExprContext::identifierExpr() {\r
2164   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
2165 }\r
2166 \r
2167 TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() {\r
2168   return getRuleContext<TocParser::ParenExprContext>(0);\r
2169 }\r
2170 \r
2171 \r
2172 size_t TocParser::NonAccessExprContext::getRuleIndex() const {\r
2173   return TocParser::RuleNonAccessExpr;\r
2174 }\r
2175 \r
2176 void TocParser::NonAccessExprContext::enterRule(tree::ParseTreeListener *listener) {\r
2177   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2178   if (parserListener != nullptr)\r
2179     parserListener->enterNonAccessExpr(this);\r
2180 }\r
2181 \r
2182 void TocParser::NonAccessExprContext::exitRule(tree::ParseTreeListener *listener) {\r
2183   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2184   if (parserListener != nullptr)\r
2185     parserListener->exitNonAccessExpr(this);\r
2186 }\r
2187 \r
2188 TocParser::NonAccessExprContext* TocParser::nonAccessExpr() {\r
2189   NonAccessExprContext *_localctx = _tracker.createInstance<NonAccessExprContext>(_ctx, getState());\r
2190   enterRule(_localctx, 56, TocParser::RuleNonAccessExpr);\r
2191 \r
2192 #if __cplusplus > 201703L\r
2193   auto onExit = finally([=, this] {\r
2194 #else\r
2195   auto onExit = finally([=] {\r
2196 #endif\r
2197     exitRule();\r
2198   });\r
2199   try {\r
2200     setState(280);\r
2201     _errHandler->sync(this);\r
2202     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {\r
2203     case 1: {\r
2204       enterOuterAlt(_localctx, 1);\r
2205       setState(277);\r
2206       funcExpr();\r
2207       break;\r
2208     }\r
2209 \r
2210     case 2: {\r
2211       enterOuterAlt(_localctx, 2);\r
2212       setState(278);\r
2213       identifierExpr();\r
2214       break;\r
2215     }\r
2216 \r
2217     case 3: {\r
2218       enterOuterAlt(_localctx, 3);\r
2219       setState(279);\r
2220       parenExpr();\r
2221       break;\r
2222     }\r
2223 \r
2224     default:\r
2225       break;\r
2226     }\r
2227    \r
2228   }\r
2229   catch (RecognitionException &e) {\r
2230     _errHandler->reportError(this, e);\r
2231     _localctx->exception = std::current_exception();\r
2232     _errHandler->recover(this, _localctx->exception);\r
2233   }\r
2234 \r
2235   return _localctx;\r
2236 }\r
2237 \r
2238 //----------------- FuncExprContext ------------------------------------------------------------------\r
2239 \r
2240 TocParser::FuncExprContext::FuncExprContext(ParserRuleContext *parent, size_t invokingState)\r
2241   : ParserRuleContext(parent, invokingState) {\r
2242 }\r
2243 \r
2244 TocParser::FuncNameContext* TocParser::FuncExprContext::funcName() {\r
2245   return getRuleContext<TocParser::FuncNameContext>(0);\r
2246 }\r
2247 \r
2248 std::vector<TocParser::ExprContext *> TocParser::FuncExprContext::expr() {\r
2249   return getRuleContexts<TocParser::ExprContext>();\r
2250 }\r
2251 \r
2252 TocParser::ExprContext* TocParser::FuncExprContext::expr(size_t i) {\r
2253   return getRuleContext<TocParser::ExprContext>(i);\r
2254 }\r
2255 \r
2256 \r
2257 size_t TocParser::FuncExprContext::getRuleIndex() const {\r
2258   return TocParser::RuleFuncExpr;\r
2259 }\r
2260 \r
2261 void TocParser::FuncExprContext::enterRule(tree::ParseTreeListener *listener) {\r
2262   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2263   if (parserListener != nullptr)\r
2264     parserListener->enterFuncExpr(this);\r
2265 }\r
2266 \r
2267 void TocParser::FuncExprContext::exitRule(tree::ParseTreeListener *listener) {\r
2268   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2269   if (parserListener != nullptr)\r
2270     parserListener->exitFuncExpr(this);\r
2271 }\r
2272 \r
2273 TocParser::FuncExprContext* TocParser::funcExpr() {\r
2274   FuncExprContext *_localctx = _tracker.createInstance<FuncExprContext>(_ctx, getState());\r
2275   enterRule(_localctx, 58, TocParser::RuleFuncExpr);\r
2276   size_t _la = 0;\r
2277 \r
2278 #if __cplusplus > 201703L\r
2279   auto onExit = finally([=, this] {\r
2280 #else\r
2281   auto onExit = finally([=] {\r
2282 #endif\r
2283     exitRule();\r
2284   });\r
2285   try {\r
2286     enterOuterAlt(_localctx, 1);\r
2287     setState(282);\r
2288     funcName();\r
2289     setState(283);\r
2290     match(TocParser::T__7);\r
2291     setState(292);\r
2292     _errHandler->sync(this);\r
2293 \r
2294     _la = _input->LA(1);\r
2295     if ((((_la & ~ 0x3fULL) == 0) &&\r
2296       ((1ULL << _la) & ((1ULL << TocParser::T__3)\r
2297       | (1ULL << TocParser::T__7)\r
2298       | (1ULL << TocParser::T__23)\r
2299       | (1ULL << TocParser::T__24)\r
2300       | (1ULL << TocParser::T__25)\r
2301       | (1ULL << TocParser::T__26)\r
2302       | (1ULL << TocParser::T__27)\r
2303       | (1ULL << TocParser::T__28)\r
2304       | (1ULL << TocParser::T__29)\r
2305       | (1ULL << TocParser::INT_LIT)\r
2306       | (1ULL << TocParser::DECIMAL_LIT)\r
2307       | (1ULL << TocParser::STRING_LIT)\r
2308       | (1ULL << TocParser::BOOL_LIT)\r
2309       | (1ULL << TocParser::NAME))) != 0)) {\r
2310       setState(284);\r
2311       expr();\r
2312       setState(289);\r
2313       _errHandler->sync(this);\r
2314       _la = _input->LA(1);\r
2315       while (_la == TocParser::T__9) {\r
2316         setState(285);\r
2317         match(TocParser::T__9);\r
2318         setState(286);\r
2319         expr();\r
2320         setState(291);\r
2321         _errHandler->sync(this);\r
2322         _la = _input->LA(1);\r
2323       }\r
2324     }\r
2325     setState(294);\r
2326     match(TocParser::T__8);\r
2327    \r
2328   }\r
2329   catch (RecognitionException &e) {\r
2330     _errHandler->reportError(this, e);\r
2331     _localctx->exception = std::current_exception();\r
2332     _errHandler->recover(this, _localctx->exception);\r
2333   }\r
2334 \r
2335   return _localctx;\r
2336 }\r
2337 \r
2338 //----------------- OpExprContext ------------------------------------------------------------------\r
2339 \r
2340 TocParser::OpExprContext::OpExprContext(ParserRuleContext *parent, size_t invokingState)\r
2341   : ParserRuleContext(parent, invokingState) {\r
2342 }\r
2343 \r
2344 TocParser::BinaryOpContext* TocParser::OpExprContext::binaryOp() {\r
2345   return getRuleContext<TocParser::BinaryOpContext>(0);\r
2346 }\r
2347 \r
2348 TocParser::PrefixOpContext* TocParser::OpExprContext::prefixOp() {\r
2349   return getRuleContext<TocParser::PrefixOpContext>(0);\r
2350 }\r
2351 \r
2352 TocParser::PostfixOpContext* TocParser::OpExprContext::postfixOp() {\r
2353   return getRuleContext<TocParser::PostfixOpContext>(0);\r
2354 }\r
2355 \r
2356 TocParser::TernaryOpContext* TocParser::OpExprContext::ternaryOp() {\r
2357   return getRuleContext<TocParser::TernaryOpContext>(0);\r
2358 }\r
2359 \r
2360 \r
2361 size_t TocParser::OpExprContext::getRuleIndex() const {\r
2362   return TocParser::RuleOpExpr;\r
2363 }\r
2364 \r
2365 void TocParser::OpExprContext::enterRule(tree::ParseTreeListener *listener) {\r
2366   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2367   if (parserListener != nullptr)\r
2368     parserListener->enterOpExpr(this);\r
2369 }\r
2370 \r
2371 void TocParser::OpExprContext::exitRule(tree::ParseTreeListener *listener) {\r
2372   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2373   if (parserListener != nullptr)\r
2374     parserListener->exitOpExpr(this);\r
2375 }\r
2376 \r
2377 TocParser::OpExprContext* TocParser::opExpr() {\r
2378   OpExprContext *_localctx = _tracker.createInstance<OpExprContext>(_ctx, getState());\r
2379   enterRule(_localctx, 60, TocParser::RuleOpExpr);\r
2380 \r
2381 #if __cplusplus > 201703L\r
2382   auto onExit = finally([=, this] {\r
2383 #else\r
2384   auto onExit = finally([=] {\r
2385 #endif\r
2386     exitRule();\r
2387   });\r
2388   try {\r
2389     setState(300);\r
2390     _errHandler->sync(this);\r
2391     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx)) {\r
2392     case 1: {\r
2393       enterOuterAlt(_localctx, 1);\r
2394       setState(296);\r
2395       binaryOp();\r
2396       break;\r
2397     }\r
2398 \r
2399     case 2: {\r
2400       enterOuterAlt(_localctx, 2);\r
2401       setState(297);\r
2402       prefixOp();\r
2403       break;\r
2404     }\r
2405 \r
2406     case 3: {\r
2407       enterOuterAlt(_localctx, 3);\r
2408       setState(298);\r
2409       postfixOp();\r
2410       break;\r
2411     }\r
2412 \r
2413     case 4: {\r
2414       enterOuterAlt(_localctx, 4);\r
2415       setState(299);\r
2416       ternaryOp();\r
2417       break;\r
2418     }\r
2419 \r
2420     default:\r
2421       break;\r
2422     }\r
2423    \r
2424   }\r
2425   catch (RecognitionException &e) {\r
2426     _errHandler->reportError(this, e);\r
2427     _localctx->exception = std::current_exception();\r
2428     _errHandler->recover(this, _localctx->exception);\r
2429   }\r
2430 \r
2431   return _localctx;\r
2432 }\r
2433 \r
2434 //----------------- BinaryOpContext ------------------------------------------------------------------\r
2435 \r
2436 TocParser::BinaryOpContext::BinaryOpContext(ParserRuleContext *parent, size_t invokingState)\r
2437   : ParserRuleContext(parent, invokingState) {\r
2438 }\r
2439 \r
2440 std::vector<TocParser::NonOpExprContext *> TocParser::BinaryOpContext::nonOpExpr() {\r
2441   return getRuleContexts<TocParser::NonOpExprContext>();\r
2442 }\r
2443 \r
2444 TocParser::NonOpExprContext* TocParser::BinaryOpContext::nonOpExpr(size_t i) {\r
2445   return getRuleContext<TocParser::NonOpExprContext>(i);\r
2446 }\r
2447 \r
2448 std::vector<TocParser::Binary_opContext *> TocParser::BinaryOpContext::binary_op() {\r
2449   return getRuleContexts<TocParser::Binary_opContext>();\r
2450 }\r
2451 \r
2452 TocParser::Binary_opContext* TocParser::BinaryOpContext::binary_op(size_t i) {\r
2453   return getRuleContext<TocParser::Binary_opContext>(i);\r
2454 }\r
2455 \r
2456 \r
2457 size_t TocParser::BinaryOpContext::getRuleIndex() const {\r
2458   return TocParser::RuleBinaryOp;\r
2459 }\r
2460 \r
2461 void TocParser::BinaryOpContext::enterRule(tree::ParseTreeListener *listener) {\r
2462   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2463   if (parserListener != nullptr)\r
2464     parserListener->enterBinaryOp(this);\r
2465 }\r
2466 \r
2467 void TocParser::BinaryOpContext::exitRule(tree::ParseTreeListener *listener) {\r
2468   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2469   if (parserListener != nullptr)\r
2470     parserListener->exitBinaryOp(this);\r
2471 }\r
2472 \r
2473 TocParser::BinaryOpContext* TocParser::binaryOp() {\r
2474   BinaryOpContext *_localctx = _tracker.createInstance<BinaryOpContext>(_ctx, getState());\r
2475   enterRule(_localctx, 62, TocParser::RuleBinaryOp);\r
2476 \r
2477 #if __cplusplus > 201703L\r
2478   auto onExit = finally([=, this] {\r
2479 #else\r
2480   auto onExit = finally([=] {\r
2481 #endif\r
2482     exitRule();\r
2483   });\r
2484   try {\r
2485     size_t alt;\r
2486     enterOuterAlt(_localctx, 1);\r
2487     setState(302);\r
2488     nonOpExpr();\r
2489     setState(303);\r
2490     binary_op();\r
2491     setState(304);\r
2492     nonOpExpr();\r
2493     setState(310);\r
2494     _errHandler->sync(this);\r
2495     alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx);\r
2496     while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {\r
2497       if (alt == 1) {\r
2498         setState(305);\r
2499         binary_op();\r
2500         setState(306);\r
2501         nonOpExpr(); \r
2502       }\r
2503       setState(312);\r
2504       _errHandler->sync(this);\r
2505       alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx);\r
2506     }\r
2507    \r
2508   }\r
2509   catch (RecognitionException &e) {\r
2510     _errHandler->reportError(this, e);\r
2511     _localctx->exception = std::current_exception();\r
2512     _errHandler->recover(this, _localctx->exception);\r
2513   }\r
2514 \r
2515   return _localctx;\r
2516 }\r
2517 \r
2518 //----------------- PrefixOpContext ------------------------------------------------------------------\r
2519 \r
2520 TocParser::PrefixOpContext::PrefixOpContext(ParserRuleContext *parent, size_t invokingState)\r
2521   : ParserRuleContext(parent, invokingState) {\r
2522 }\r
2523 \r
2524 TocParser::Prefix_opContext* TocParser::PrefixOpContext::prefix_op() {\r
2525   return getRuleContext<TocParser::Prefix_opContext>(0);\r
2526 }\r
2527 \r
2528 TocParser::NonOpExprContext* TocParser::PrefixOpContext::nonOpExpr() {\r
2529   return getRuleContext<TocParser::NonOpExprContext>(0);\r
2530 }\r
2531 \r
2532 \r
2533 size_t TocParser::PrefixOpContext::getRuleIndex() const {\r
2534   return TocParser::RulePrefixOp;\r
2535 }\r
2536 \r
2537 void TocParser::PrefixOpContext::enterRule(tree::ParseTreeListener *listener) {\r
2538   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2539   if (parserListener != nullptr)\r
2540     parserListener->enterPrefixOp(this);\r
2541 }\r
2542 \r
2543 void TocParser::PrefixOpContext::exitRule(tree::ParseTreeListener *listener) {\r
2544   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2545   if (parserListener != nullptr)\r
2546     parserListener->exitPrefixOp(this);\r
2547 }\r
2548 \r
2549 TocParser::PrefixOpContext* TocParser::prefixOp() {\r
2550   PrefixOpContext *_localctx = _tracker.createInstance<PrefixOpContext>(_ctx, getState());\r
2551   enterRule(_localctx, 64, TocParser::RulePrefixOp);\r
2552 \r
2553 #if __cplusplus > 201703L\r
2554   auto onExit = finally([=, this] {\r
2555 #else\r
2556   auto onExit = finally([=] {\r
2557 #endif\r
2558     exitRule();\r
2559   });\r
2560   try {\r
2561     enterOuterAlt(_localctx, 1);\r
2562     setState(313);\r
2563     prefix_op();\r
2564     setState(314);\r
2565     nonOpExpr();\r
2566    \r
2567   }\r
2568   catch (RecognitionException &e) {\r
2569     _errHandler->reportError(this, e);\r
2570     _localctx->exception = std::current_exception();\r
2571     _errHandler->recover(this, _localctx->exception);\r
2572   }\r
2573 \r
2574   return _localctx;\r
2575 }\r
2576 \r
2577 //----------------- PostfixOpContext ------------------------------------------------------------------\r
2578 \r
2579 TocParser::PostfixOpContext::PostfixOpContext(ParserRuleContext *parent, size_t invokingState)\r
2580   : ParserRuleContext(parent, invokingState) {\r
2581 }\r
2582 \r
2583 TocParser::NonOpExprContext* TocParser::PostfixOpContext::nonOpExpr() {\r
2584   return getRuleContext<TocParser::NonOpExprContext>(0);\r
2585 }\r
2586 \r
2587 TocParser::Postfix_opContext* TocParser::PostfixOpContext::postfix_op() {\r
2588   return getRuleContext<TocParser::Postfix_opContext>(0);\r
2589 }\r
2590 \r
2591 \r
2592 size_t TocParser::PostfixOpContext::getRuleIndex() const {\r
2593   return TocParser::RulePostfixOp;\r
2594 }\r
2595 \r
2596 void TocParser::PostfixOpContext::enterRule(tree::ParseTreeListener *listener) {\r
2597   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2598   if (parserListener != nullptr)\r
2599     parserListener->enterPostfixOp(this);\r
2600 }\r
2601 \r
2602 void TocParser::PostfixOpContext::exitRule(tree::ParseTreeListener *listener) {\r
2603   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2604   if (parserListener != nullptr)\r
2605     parserListener->exitPostfixOp(this);\r
2606 }\r
2607 \r
2608 TocParser::PostfixOpContext* TocParser::postfixOp() {\r
2609   PostfixOpContext *_localctx = _tracker.createInstance<PostfixOpContext>(_ctx, getState());\r
2610   enterRule(_localctx, 66, TocParser::RulePostfixOp);\r
2611 \r
2612 #if __cplusplus > 201703L\r
2613   auto onExit = finally([=, this] {\r
2614 #else\r
2615   auto onExit = finally([=] {\r
2616 #endif\r
2617     exitRule();\r
2618   });\r
2619   try {\r
2620     enterOuterAlt(_localctx, 1);\r
2621     setState(316);\r
2622     nonOpExpr();\r
2623     setState(317);\r
2624     postfix_op();\r
2625    \r
2626   }\r
2627   catch (RecognitionException &e) {\r
2628     _errHandler->reportError(this, e);\r
2629     _localctx->exception = std::current_exception();\r
2630     _errHandler->recover(this, _localctx->exception);\r
2631   }\r
2632 \r
2633   return _localctx;\r
2634 }\r
2635 \r
2636 //----------------- TernaryOpContext ------------------------------------------------------------------\r
2637 \r
2638 TocParser::TernaryOpContext::TernaryOpContext(ParserRuleContext *parent, size_t invokingState)\r
2639   : ParserRuleContext(parent, invokingState) {\r
2640 }\r
2641 \r
2642 TocParser::NonOpExprContext* TocParser::TernaryOpContext::nonOpExpr() {\r
2643   return getRuleContext<TocParser::NonOpExprContext>(0);\r
2644 }\r
2645 \r
2646 std::vector<TocParser::ExprContext *> TocParser::TernaryOpContext::expr() {\r
2647   return getRuleContexts<TocParser::ExprContext>();\r
2648 }\r
2649 \r
2650 TocParser::ExprContext* TocParser::TernaryOpContext::expr(size_t i) {\r
2651   return getRuleContext<TocParser::ExprContext>(i);\r
2652 }\r
2653 \r
2654 \r
2655 size_t TocParser::TernaryOpContext::getRuleIndex() const {\r
2656   return TocParser::RuleTernaryOp;\r
2657 }\r
2658 \r
2659 void TocParser::TernaryOpContext::enterRule(tree::ParseTreeListener *listener) {\r
2660   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2661   if (parserListener != nullptr)\r
2662     parserListener->enterTernaryOp(this);\r
2663 }\r
2664 \r
2665 void TocParser::TernaryOpContext::exitRule(tree::ParseTreeListener *listener) {\r
2666   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2667   if (parserListener != nullptr)\r
2668     parserListener->exitTernaryOp(this);\r
2669 }\r
2670 \r
2671 TocParser::TernaryOpContext* TocParser::ternaryOp() {\r
2672   TernaryOpContext *_localctx = _tracker.createInstance<TernaryOpContext>(_ctx, getState());\r
2673   enterRule(_localctx, 68, TocParser::RuleTernaryOp);\r
2674 \r
2675 #if __cplusplus > 201703L\r
2676   auto onExit = finally([=, this] {\r
2677 #else\r
2678   auto onExit = finally([=] {\r
2679 #endif\r
2680     exitRule();\r
2681   });\r
2682   try {\r
2683     enterOuterAlt(_localctx, 1);\r
2684     setState(319);\r
2685     nonOpExpr();\r
2686     setState(320);\r
2687     match(TocParser::T__20);\r
2688     setState(321);\r
2689     expr();\r
2690     setState(322);\r
2691     match(TocParser::T__1);\r
2692     setState(323);\r
2693     expr();\r
2694    \r
2695   }\r
2696   catch (RecognitionException &e) {\r
2697     _errHandler->reportError(this, e);\r
2698     _localctx->exception = std::current_exception();\r
2699     _errHandler->recover(this, _localctx->exception);\r
2700   }\r
2701 \r
2702   return _localctx;\r
2703 }\r
2704 \r
2705 //----------------- IdentifierExprContext ------------------------------------------------------------------\r
2706 \r
2707 TocParser::IdentifierExprContext::IdentifierExprContext(ParserRuleContext *parent, size_t invokingState)\r
2708   : ParserRuleContext(parent, invokingState) {\r
2709 }\r
2710 \r
2711 TocParser::VarNameContext* TocParser::IdentifierExprContext::varName() {\r
2712   return getRuleContext<TocParser::VarNameContext>(0);\r
2713 }\r
2714 \r
2715 \r
2716 size_t TocParser::IdentifierExprContext::getRuleIndex() const {\r
2717   return TocParser::RuleIdentifierExpr;\r
2718 }\r
2719 \r
2720 void TocParser::IdentifierExprContext::enterRule(tree::ParseTreeListener *listener) {\r
2721   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2722   if (parserListener != nullptr)\r
2723     parserListener->enterIdentifierExpr(this);\r
2724 }\r
2725 \r
2726 void TocParser::IdentifierExprContext::exitRule(tree::ParseTreeListener *listener) {\r
2727   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2728   if (parserListener != nullptr)\r
2729     parserListener->exitIdentifierExpr(this);\r
2730 }\r
2731 \r
2732 TocParser::IdentifierExprContext* TocParser::identifierExpr() {\r
2733   IdentifierExprContext *_localctx = _tracker.createInstance<IdentifierExprContext>(_ctx, getState());\r
2734   enterRule(_localctx, 70, TocParser::RuleIdentifierExpr);\r
2735 \r
2736 #if __cplusplus > 201703L\r
2737   auto onExit = finally([=, this] {\r
2738 #else\r
2739   auto onExit = finally([=] {\r
2740 #endif\r
2741     exitRule();\r
2742   });\r
2743   try {\r
2744     enterOuterAlt(_localctx, 1);\r
2745     setState(325);\r
2746     varName();\r
2747    \r
2748   }\r
2749   catch (RecognitionException &e) {\r
2750     _errHandler->reportError(this, e);\r
2751     _localctx->exception = std::current_exception();\r
2752     _errHandler->recover(this, _localctx->exception);\r
2753   }\r
2754 \r
2755   return _localctx;\r
2756 }\r
2757 \r
2758 //----------------- LitExprContext ------------------------------------------------------------------\r
2759 \r
2760 TocParser::LitExprContext::LitExprContext(ParserRuleContext *parent, size_t invokingState)\r
2761   : ParserRuleContext(parent, invokingState) {\r
2762 }\r
2763 \r
2764 tree::TerminalNode* TocParser::LitExprContext::INT_LIT() {\r
2765   return getToken(TocParser::INT_LIT, 0);\r
2766 }\r
2767 \r
2768 tree::TerminalNode* TocParser::LitExprContext::DECIMAL_LIT() {\r
2769   return getToken(TocParser::DECIMAL_LIT, 0);\r
2770 }\r
2771 \r
2772 tree::TerminalNode* TocParser::LitExprContext::STRING_LIT() {\r
2773   return getToken(TocParser::STRING_LIT, 0);\r
2774 }\r
2775 \r
2776 tree::TerminalNode* TocParser::LitExprContext::BOOL_LIT() {\r
2777   return getToken(TocParser::BOOL_LIT, 0);\r
2778 }\r
2779 \r
2780 \r
2781 size_t TocParser::LitExprContext::getRuleIndex() const {\r
2782   return TocParser::RuleLitExpr;\r
2783 }\r
2784 \r
2785 void TocParser::LitExprContext::enterRule(tree::ParseTreeListener *listener) {\r
2786   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2787   if (parserListener != nullptr)\r
2788     parserListener->enterLitExpr(this);\r
2789 }\r
2790 \r
2791 void TocParser::LitExprContext::exitRule(tree::ParseTreeListener *listener) {\r
2792   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2793   if (parserListener != nullptr)\r
2794     parserListener->exitLitExpr(this);\r
2795 }\r
2796 \r
2797 TocParser::LitExprContext* TocParser::litExpr() {\r
2798   LitExprContext *_localctx = _tracker.createInstance<LitExprContext>(_ctx, getState());\r
2799   enterRule(_localctx, 72, TocParser::RuleLitExpr);\r
2800   size_t _la = 0;\r
2801 \r
2802 #if __cplusplus > 201703L\r
2803   auto onExit = finally([=, this] {\r
2804 #else\r
2805   auto onExit = finally([=] {\r
2806 #endif\r
2807     exitRule();\r
2808   });\r
2809   try {\r
2810     enterOuterAlt(_localctx, 1);\r
2811     setState(327);\r
2812     _la = _input->LA(1);\r
2813     if (!((((_la & ~ 0x3fULL) == 0) &&\r
2814       ((1ULL << _la) & ((1ULL << TocParser::INT_LIT)\r
2815       | (1ULL << TocParser::DECIMAL_LIT)\r
2816       | (1ULL << TocParser::STRING_LIT)\r
2817       | (1ULL << TocParser::BOOL_LIT))) != 0))) {\r
2818     _errHandler->recoverInline(this);\r
2819     }\r
2820     else {\r
2821       _errHandler->reportMatch(this);\r
2822       consume();\r
2823     }\r
2824    \r
2825   }\r
2826   catch (RecognitionException &e) {\r
2827     _errHandler->reportError(this, e);\r
2828     _localctx->exception = std::current_exception();\r
2829     _errHandler->recover(this, _localctx->exception);\r
2830   }\r
2831 \r
2832   return _localctx;\r
2833 }\r
2834 \r
2835 //----------------- AccessExprContext ------------------------------------------------------------------\r
2836 \r
2837 TocParser::AccessExprContext::AccessExprContext(ParserRuleContext *parent, size_t invokingState)\r
2838   : ParserRuleContext(parent, invokingState) {\r
2839 }\r
2840 \r
2841 TocParser::NonAccessExprContext* TocParser::AccessExprContext::nonAccessExpr() {\r
2842   return getRuleContext<TocParser::NonAccessExprContext>(0);\r
2843 }\r
2844 \r
2845 std::vector<TocParser::AccessSubExprContext *> TocParser::AccessExprContext::accessSubExpr() {\r
2846   return getRuleContexts<TocParser::AccessSubExprContext>();\r
2847 }\r
2848 \r
2849 TocParser::AccessSubExprContext* TocParser::AccessExprContext::accessSubExpr(size_t i) {\r
2850   return getRuleContext<TocParser::AccessSubExprContext>(i);\r
2851 }\r
2852 \r
2853 \r
2854 size_t TocParser::AccessExprContext::getRuleIndex() const {\r
2855   return TocParser::RuleAccessExpr;\r
2856 }\r
2857 \r
2858 void TocParser::AccessExprContext::enterRule(tree::ParseTreeListener *listener) {\r
2859   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2860   if (parserListener != nullptr)\r
2861     parserListener->enterAccessExpr(this);\r
2862 }\r
2863 \r
2864 void TocParser::AccessExprContext::exitRule(tree::ParseTreeListener *listener) {\r
2865   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2866   if (parserListener != nullptr)\r
2867     parserListener->exitAccessExpr(this);\r
2868 }\r
2869 \r
2870 TocParser::AccessExprContext* TocParser::accessExpr() {\r
2871   AccessExprContext *_localctx = _tracker.createInstance<AccessExprContext>(_ctx, getState());\r
2872   enterRule(_localctx, 74, TocParser::RuleAccessExpr);\r
2873   size_t _la = 0;\r
2874 \r
2875 #if __cplusplus > 201703L\r
2876   auto onExit = finally([=, this] {\r
2877 #else\r
2878   auto onExit = finally([=] {\r
2879 #endif\r
2880     exitRule();\r
2881   });\r
2882   try {\r
2883     enterOuterAlt(_localctx, 1);\r
2884     setState(329);\r
2885     nonAccessExpr();\r
2886     setState(331); \r
2887     _errHandler->sync(this);\r
2888     _la = _input->LA(1);\r
2889     do {\r
2890       setState(330);\r
2891       accessSubExpr();\r
2892       setState(333); \r
2893       _errHandler->sync(this);\r
2894       _la = _input->LA(1);\r
2895     } while ((((_la & ~ 0x3fULL) == 0) &&\r
2896       ((1ULL << _la) & ((1ULL << TocParser::T__4)\r
2897       | (1ULL << TocParser::T__21)\r
2898       | (1ULL << TocParser::T__22))) != 0));\r
2899    \r
2900   }\r
2901   catch (RecognitionException &e) {\r
2902     _errHandler->reportError(this, e);\r
2903     _localctx->exception = std::current_exception();\r
2904     _errHandler->recover(this, _localctx->exception);\r
2905   }\r
2906 \r
2907   return _localctx;\r
2908 }\r
2909 \r
2910 //----------------- AccessSubExprContext ------------------------------------------------------------------\r
2911 \r
2912 TocParser::AccessSubExprContext::AccessSubExprContext(ParserRuleContext *parent, size_t invokingState)\r
2913   : ParserRuleContext(parent, invokingState) {\r
2914 }\r
2915 \r
2916 TocParser::AccessMemberContext* TocParser::AccessSubExprContext::accessMember() {\r
2917   return getRuleContext<TocParser::AccessMemberContext>(0);\r
2918 }\r
2919 \r
2920 TocParser::AccessBracketsContext* TocParser::AccessSubExprContext::accessBrackets() {\r
2921   return getRuleContext<TocParser::AccessBracketsContext>(0);\r
2922 }\r
2923 \r
2924 \r
2925 size_t TocParser::AccessSubExprContext::getRuleIndex() const {\r
2926   return TocParser::RuleAccessSubExpr;\r
2927 }\r
2928 \r
2929 void TocParser::AccessSubExprContext::enterRule(tree::ParseTreeListener *listener) {\r
2930   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2931   if (parserListener != nullptr)\r
2932     parserListener->enterAccessSubExpr(this);\r
2933 }\r
2934 \r
2935 void TocParser::AccessSubExprContext::exitRule(tree::ParseTreeListener *listener) {\r
2936   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2937   if (parserListener != nullptr)\r
2938     parserListener->exitAccessSubExpr(this);\r
2939 }\r
2940 \r
2941 TocParser::AccessSubExprContext* TocParser::accessSubExpr() {\r
2942   AccessSubExprContext *_localctx = _tracker.createInstance<AccessSubExprContext>(_ctx, getState());\r
2943   enterRule(_localctx, 76, TocParser::RuleAccessSubExpr);\r
2944 \r
2945 #if __cplusplus > 201703L\r
2946   auto onExit = finally([=, this] {\r
2947 #else\r
2948   auto onExit = finally([=] {\r
2949 #endif\r
2950     exitRule();\r
2951   });\r
2952   try {\r
2953     setState(337);\r
2954     _errHandler->sync(this);\r
2955     switch (_input->LA(1)) {\r
2956       case TocParser::T__21:\r
2957       case TocParser::T__22: {\r
2958         enterOuterAlt(_localctx, 1);\r
2959         setState(335);\r
2960         accessMember();\r
2961         break;\r
2962       }\r
2963 \r
2964       case TocParser::T__4: {\r
2965         enterOuterAlt(_localctx, 2);\r
2966         setState(336);\r
2967         accessBrackets();\r
2968         break;\r
2969       }\r
2970 \r
2971     default:\r
2972       throw NoViableAltException(this);\r
2973     }\r
2974    \r
2975   }\r
2976   catch (RecognitionException &e) {\r
2977     _errHandler->reportError(this, e);\r
2978     _localctx->exception = std::current_exception();\r
2979     _errHandler->recover(this, _localctx->exception);\r
2980   }\r
2981 \r
2982   return _localctx;\r
2983 }\r
2984 \r
2985 //----------------- AccessMemberContext ------------------------------------------------------------------\r
2986 \r
2987 TocParser::AccessMemberContext::AccessMemberContext(ParserRuleContext *parent, size_t invokingState)\r
2988   : ParserRuleContext(parent, invokingState) {\r
2989 }\r
2990 \r
2991 TocParser::IdentifierExprContext* TocParser::AccessMemberContext::identifierExpr() {\r
2992   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
2993 }\r
2994 \r
2995 \r
2996 size_t TocParser::AccessMemberContext::getRuleIndex() const {\r
2997   return TocParser::RuleAccessMember;\r
2998 }\r
2999 \r
3000 void TocParser::AccessMemberContext::enterRule(tree::ParseTreeListener *listener) {\r
3001   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3002   if (parserListener != nullptr)\r
3003     parserListener->enterAccessMember(this);\r
3004 }\r
3005 \r
3006 void TocParser::AccessMemberContext::exitRule(tree::ParseTreeListener *listener) {\r
3007   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3008   if (parserListener != nullptr)\r
3009     parserListener->exitAccessMember(this);\r
3010 }\r
3011 \r
3012 TocParser::AccessMemberContext* TocParser::accessMember() {\r
3013   AccessMemberContext *_localctx = _tracker.createInstance<AccessMemberContext>(_ctx, getState());\r
3014   enterRule(_localctx, 78, TocParser::RuleAccessMember);\r
3015   size_t _la = 0;\r
3016 \r
3017 #if __cplusplus > 201703L\r
3018   auto onExit = finally([=, this] {\r
3019 #else\r
3020   auto onExit = finally([=] {\r
3021 #endif\r
3022     exitRule();\r
3023   });\r
3024   try {\r
3025     enterOuterAlt(_localctx, 1);\r
3026     setState(339);\r
3027     _la = _input->LA(1);\r
3028     if (!(_la == TocParser::T__21\r
3029 \r
3030     || _la == TocParser::T__22)) {\r
3031     _errHandler->recoverInline(this);\r
3032     }\r
3033     else {\r
3034       _errHandler->reportMatch(this);\r
3035       consume();\r
3036     }\r
3037     setState(340);\r
3038     identifierExpr();\r
3039    \r
3040   }\r
3041   catch (RecognitionException &e) {\r
3042     _errHandler->reportError(this, e);\r
3043     _localctx->exception = std::current_exception();\r
3044     _errHandler->recover(this, _localctx->exception);\r
3045   }\r
3046 \r
3047   return _localctx;\r
3048 }\r
3049 \r
3050 //----------------- AccessBracketsContext ------------------------------------------------------------------\r
3051 \r
3052 TocParser::AccessBracketsContext::AccessBracketsContext(ParserRuleContext *parent, size_t invokingState)\r
3053   : ParserRuleContext(parent, invokingState) {\r
3054 }\r
3055 \r
3056 TocParser::ExprContext* TocParser::AccessBracketsContext::expr() {\r
3057   return getRuleContext<TocParser::ExprContext>(0);\r
3058 }\r
3059 \r
3060 \r
3061 size_t TocParser::AccessBracketsContext::getRuleIndex() const {\r
3062   return TocParser::RuleAccessBrackets;\r
3063 }\r
3064 \r
3065 void TocParser::AccessBracketsContext::enterRule(tree::ParseTreeListener *listener) {\r
3066   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3067   if (parserListener != nullptr)\r
3068     parserListener->enterAccessBrackets(this);\r
3069 }\r
3070 \r
3071 void TocParser::AccessBracketsContext::exitRule(tree::ParseTreeListener *listener) {\r
3072   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3073   if (parserListener != nullptr)\r
3074     parserListener->exitAccessBrackets(this);\r
3075 }\r
3076 \r
3077 TocParser::AccessBracketsContext* TocParser::accessBrackets() {\r
3078   AccessBracketsContext *_localctx = _tracker.createInstance<AccessBracketsContext>(_ctx, getState());\r
3079   enterRule(_localctx, 80, TocParser::RuleAccessBrackets);\r
3080 \r
3081 #if __cplusplus > 201703L\r
3082   auto onExit = finally([=, this] {\r
3083 #else\r
3084   auto onExit = finally([=] {\r
3085 #endif\r
3086     exitRule();\r
3087   });\r
3088   try {\r
3089     enterOuterAlt(_localctx, 1);\r
3090     setState(342);\r
3091     match(TocParser::T__4);\r
3092     setState(343);\r
3093     expr();\r
3094     setState(344);\r
3095     match(TocParser::T__5);\r
3096    \r
3097   }\r
3098   catch (RecognitionException &e) {\r
3099     _errHandler->reportError(this, e);\r
3100     _localctx->exception = std::current_exception();\r
3101     _errHandler->recover(this, _localctx->exception);\r
3102   }\r
3103 \r
3104   return _localctx;\r
3105 }\r
3106 \r
3107 //----------------- ParenExprContext ------------------------------------------------------------------\r
3108 \r
3109 TocParser::ParenExprContext::ParenExprContext(ParserRuleContext *parent, size_t invokingState)\r
3110   : ParserRuleContext(parent, invokingState) {\r
3111 }\r
3112 \r
3113 TocParser::ExprContext* TocParser::ParenExprContext::expr() {\r
3114   return getRuleContext<TocParser::ExprContext>(0);\r
3115 }\r
3116 \r
3117 \r
3118 size_t TocParser::ParenExprContext::getRuleIndex() const {\r
3119   return TocParser::RuleParenExpr;\r
3120 }\r
3121 \r
3122 void TocParser::ParenExprContext::enterRule(tree::ParseTreeListener *listener) {\r
3123   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3124   if (parserListener != nullptr)\r
3125     parserListener->enterParenExpr(this);\r
3126 }\r
3127 \r
3128 void TocParser::ParenExprContext::exitRule(tree::ParseTreeListener *listener) {\r
3129   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3130   if (parserListener != nullptr)\r
3131     parserListener->exitParenExpr(this);\r
3132 }\r
3133 \r
3134 TocParser::ParenExprContext* TocParser::parenExpr() {\r
3135   ParenExprContext *_localctx = _tracker.createInstance<ParenExprContext>(_ctx, getState());\r
3136   enterRule(_localctx, 82, TocParser::RuleParenExpr);\r
3137 \r
3138 #if __cplusplus > 201703L\r
3139   auto onExit = finally([=, this] {\r
3140 #else\r
3141   auto onExit = finally([=] {\r
3142 #endif\r
3143     exitRule();\r
3144   });\r
3145   try {\r
3146     enterOuterAlt(_localctx, 1);\r
3147     setState(346);\r
3148     match(TocParser::T__7);\r
3149     setState(347);\r
3150     expr();\r
3151     setState(348);\r
3152     match(TocParser::T__8);\r
3153    \r
3154   }\r
3155   catch (RecognitionException &e) {\r
3156     _errHandler->reportError(this, e);\r
3157     _localctx->exception = std::current_exception();\r
3158     _errHandler->recover(this, _localctx->exception);\r
3159   }\r
3160 \r
3161   return _localctx;\r
3162 }\r
3163 \r
3164 //----------------- FuncNameContext ------------------------------------------------------------------\r
3165 \r
3166 TocParser::FuncNameContext::FuncNameContext(ParserRuleContext *parent, size_t invokingState)\r
3167   : ParserRuleContext(parent, invokingState) {\r
3168 }\r
3169 \r
3170 tree::TerminalNode* TocParser::FuncNameContext::NAME() {\r
3171   return getToken(TocParser::NAME, 0);\r
3172 }\r
3173 \r
3174 \r
3175 size_t TocParser::FuncNameContext::getRuleIndex() const {\r
3176   return TocParser::RuleFuncName;\r
3177 }\r
3178 \r
3179 void TocParser::FuncNameContext::enterRule(tree::ParseTreeListener *listener) {\r
3180   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3181   if (parserListener != nullptr)\r
3182     parserListener->enterFuncName(this);\r
3183 }\r
3184 \r
3185 void TocParser::FuncNameContext::exitRule(tree::ParseTreeListener *listener) {\r
3186   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3187   if (parserListener != nullptr)\r
3188     parserListener->exitFuncName(this);\r
3189 }\r
3190 \r
3191 TocParser::FuncNameContext* TocParser::funcName() {\r
3192   FuncNameContext *_localctx = _tracker.createInstance<FuncNameContext>(_ctx, getState());\r
3193   enterRule(_localctx, 84, TocParser::RuleFuncName);\r
3194 \r
3195 #if __cplusplus > 201703L\r
3196   auto onExit = finally([=, this] {\r
3197 #else\r
3198   auto onExit = finally([=] {\r
3199 #endif\r
3200     exitRule();\r
3201   });\r
3202   try {\r
3203     enterOuterAlt(_localctx, 1);\r
3204     setState(350);\r
3205     match(TocParser::NAME);\r
3206    \r
3207   }\r
3208   catch (RecognitionException &e) {\r
3209     _errHandler->reportError(this, e);\r
3210     _localctx->exception = std::current_exception();\r
3211     _errHandler->recover(this, _localctx->exception);\r
3212   }\r
3213 \r
3214   return _localctx;\r
3215 }\r
3216 \r
3217 //----------------- VarNameContext ------------------------------------------------------------------\r
3218 \r
3219 TocParser::VarNameContext::VarNameContext(ParserRuleContext *parent, size_t invokingState)\r
3220   : ParserRuleContext(parent, invokingState) {\r
3221 }\r
3222 \r
3223 tree::TerminalNode* TocParser::VarNameContext::NAME() {\r
3224   return getToken(TocParser::NAME, 0);\r
3225 }\r
3226 \r
3227 \r
3228 size_t TocParser::VarNameContext::getRuleIndex() const {\r
3229   return TocParser::RuleVarName;\r
3230 }\r
3231 \r
3232 void TocParser::VarNameContext::enterRule(tree::ParseTreeListener *listener) {\r
3233   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3234   if (parserListener != nullptr)\r
3235     parserListener->enterVarName(this);\r
3236 }\r
3237 \r
3238 void TocParser::VarNameContext::exitRule(tree::ParseTreeListener *listener) {\r
3239   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3240   if (parserListener != nullptr)\r
3241     parserListener->exitVarName(this);\r
3242 }\r
3243 \r
3244 TocParser::VarNameContext* TocParser::varName() {\r
3245   VarNameContext *_localctx = _tracker.createInstance<VarNameContext>(_ctx, getState());\r
3246   enterRule(_localctx, 86, TocParser::RuleVarName);\r
3247 \r
3248 #if __cplusplus > 201703L\r
3249   auto onExit = finally([=, this] {\r
3250 #else\r
3251   auto onExit = finally([=] {\r
3252 #endif\r
3253     exitRule();\r
3254   });\r
3255   try {\r
3256     enterOuterAlt(_localctx, 1);\r
3257     setState(352);\r
3258     match(TocParser::NAME);\r
3259    \r
3260   }\r
3261   catch (RecognitionException &e) {\r
3262     _errHandler->reportError(this, e);\r
3263     _localctx->exception = std::current_exception();\r
3264     _errHandler->recover(this, _localctx->exception);\r
3265   }\r
3266 \r
3267   return _localctx;\r
3268 }\r
3269 \r
3270 //----------------- TypeNameContext ------------------------------------------------------------------\r
3271 \r
3272 TocParser::TypeNameContext::TypeNameContext(ParserRuleContext *parent, size_t invokingState)\r
3273   : ParserRuleContext(parent, invokingState) {\r
3274 }\r
3275 \r
3276 tree::TerminalNode* TocParser::TypeNameContext::NAME() {\r
3277   return getToken(TocParser::NAME, 0);\r
3278 }\r
3279 \r
3280 \r
3281 size_t TocParser::TypeNameContext::getRuleIndex() const {\r
3282   return TocParser::RuleTypeName;\r
3283 }\r
3284 \r
3285 void TocParser::TypeNameContext::enterRule(tree::ParseTreeListener *listener) {\r
3286   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3287   if (parserListener != nullptr)\r
3288     parserListener->enterTypeName(this);\r
3289 }\r
3290 \r
3291 void TocParser::TypeNameContext::exitRule(tree::ParseTreeListener *listener) {\r
3292   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3293   if (parserListener != nullptr)\r
3294     parserListener->exitTypeName(this);\r
3295 }\r
3296 \r
3297 TocParser::TypeNameContext* TocParser::typeName() {\r
3298   TypeNameContext *_localctx = _tracker.createInstance<TypeNameContext>(_ctx, getState());\r
3299   enterRule(_localctx, 88, TocParser::RuleTypeName);\r
3300 \r
3301 #if __cplusplus > 201703L\r
3302   auto onExit = finally([=, this] {\r
3303 #else\r
3304   auto onExit = finally([=] {\r
3305 #endif\r
3306     exitRule();\r
3307   });\r
3308   try {\r
3309     enterOuterAlt(_localctx, 1);\r
3310     setState(354);\r
3311     match(TocParser::NAME);\r
3312    \r
3313   }\r
3314   catch (RecognitionException &e) {\r
3315     _errHandler->reportError(this, e);\r
3316     _localctx->exception = std::current_exception();\r
3317     _errHandler->recover(this, _localctx->exception);\r
3318   }\r
3319 \r
3320   return _localctx;\r
3321 }\r
3322 \r
3323 //----------------- StructNameContext ------------------------------------------------------------------\r
3324 \r
3325 TocParser::StructNameContext::StructNameContext(ParserRuleContext *parent, size_t invokingState)\r
3326   : ParserRuleContext(parent, invokingState) {\r
3327 }\r
3328 \r
3329 tree::TerminalNode* TocParser::StructNameContext::NAME() {\r
3330   return getToken(TocParser::NAME, 0);\r
3331 }\r
3332 \r
3333 \r
3334 size_t TocParser::StructNameContext::getRuleIndex() const {\r
3335   return TocParser::RuleStructName;\r
3336 }\r
3337 \r
3338 void TocParser::StructNameContext::enterRule(tree::ParseTreeListener *listener) {\r
3339   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3340   if (parserListener != nullptr)\r
3341     parserListener->enterStructName(this);\r
3342 }\r
3343 \r
3344 void TocParser::StructNameContext::exitRule(tree::ParseTreeListener *listener) {\r
3345   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3346   if (parserListener != nullptr)\r
3347     parserListener->exitStructName(this);\r
3348 }\r
3349 \r
3350 TocParser::StructNameContext* TocParser::structName() {\r
3351   StructNameContext *_localctx = _tracker.createInstance<StructNameContext>(_ctx, getState());\r
3352   enterRule(_localctx, 90, TocParser::RuleStructName);\r
3353 \r
3354 #if __cplusplus > 201703L\r
3355   auto onExit = finally([=, this] {\r
3356 #else\r
3357   auto onExit = finally([=] {\r
3358 #endif\r
3359     exitRule();\r
3360   });\r
3361   try {\r
3362     enterOuterAlt(_localctx, 1);\r
3363     setState(356);\r
3364     match(TocParser::NAME);\r
3365    \r
3366   }\r
3367   catch (RecognitionException &e) {\r
3368     _errHandler->reportError(this, e);\r
3369     _localctx->exception = std::current_exception();\r
3370     _errHandler->recover(this, _localctx->exception);\r
3371   }\r
3372 \r
3373   return _localctx;\r
3374 }\r
3375 \r
3376 //----------------- Postfix_opContext ------------------------------------------------------------------\r
3377 \r
3378 TocParser::Postfix_opContext::Postfix_opContext(ParserRuleContext *parent, size_t invokingState)\r
3379   : ParserRuleContext(parent, invokingState) {\r
3380 }\r
3381 \r
3382 \r
3383 size_t TocParser::Postfix_opContext::getRuleIndex() const {\r
3384   return TocParser::RulePostfix_op;\r
3385 }\r
3386 \r
3387 void TocParser::Postfix_opContext::enterRule(tree::ParseTreeListener *listener) {\r
3388   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3389   if (parserListener != nullptr)\r
3390     parserListener->enterPostfix_op(this);\r
3391 }\r
3392 \r
3393 void TocParser::Postfix_opContext::exitRule(tree::ParseTreeListener *listener) {\r
3394   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3395   if (parserListener != nullptr)\r
3396     parserListener->exitPostfix_op(this);\r
3397 }\r
3398 \r
3399 TocParser::Postfix_opContext* TocParser::postfix_op() {\r
3400   Postfix_opContext *_localctx = _tracker.createInstance<Postfix_opContext>(_ctx, getState());\r
3401   enterRule(_localctx, 92, TocParser::RulePostfix_op);\r
3402   size_t _la = 0;\r
3403 \r
3404 #if __cplusplus > 201703L\r
3405   auto onExit = finally([=, this] {\r
3406 #else\r
3407   auto onExit = finally([=] {\r
3408 #endif\r
3409     exitRule();\r
3410   });\r
3411   try {\r
3412     enterOuterAlt(_localctx, 1);\r
3413     setState(358);\r
3414     _la = _input->LA(1);\r
3415     if (!(_la == TocParser::T__23\r
3416 \r
3417     || _la == TocParser::T__24)) {\r
3418     _errHandler->recoverInline(this);\r
3419     }\r
3420     else {\r
3421       _errHandler->reportMatch(this);\r
3422       consume();\r
3423     }\r
3424    \r
3425   }\r
3426   catch (RecognitionException &e) {\r
3427     _errHandler->reportError(this, e);\r
3428     _localctx->exception = std::current_exception();\r
3429     _errHandler->recover(this, _localctx->exception);\r
3430   }\r
3431 \r
3432   return _localctx;\r
3433 }\r
3434 \r
3435 //----------------- Prefix_opContext ------------------------------------------------------------------\r
3436 \r
3437 TocParser::Prefix_opContext::Prefix_opContext(ParserRuleContext *parent, size_t invokingState)\r
3438   : ParserRuleContext(parent, invokingState) {\r
3439 }\r
3440 \r
3441 TocParser::Postfix_opContext* TocParser::Prefix_opContext::postfix_op() {\r
3442   return getRuleContext<TocParser::Postfix_opContext>(0);\r
3443 }\r
3444 \r
3445 \r
3446 size_t TocParser::Prefix_opContext::getRuleIndex() const {\r
3447   return TocParser::RulePrefix_op;\r
3448 }\r
3449 \r
3450 void TocParser::Prefix_opContext::enterRule(tree::ParseTreeListener *listener) {\r
3451   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3452   if (parserListener != nullptr)\r
3453     parserListener->enterPrefix_op(this);\r
3454 }\r
3455 \r
3456 void TocParser::Prefix_opContext::exitRule(tree::ParseTreeListener *listener) {\r
3457   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3458   if (parserListener != nullptr)\r
3459     parserListener->exitPrefix_op(this);\r
3460 }\r
3461 \r
3462 TocParser::Prefix_opContext* TocParser::prefix_op() {\r
3463   Prefix_opContext *_localctx = _tracker.createInstance<Prefix_opContext>(_ctx, getState());\r
3464   enterRule(_localctx, 94, TocParser::RulePrefix_op);\r
3465 \r
3466 #if __cplusplus > 201703L\r
3467   auto onExit = finally([=, this] {\r
3468 #else\r
3469   auto onExit = finally([=] {\r
3470 #endif\r
3471     exitRule();\r
3472   });\r
3473   try {\r
3474     setState(367);\r
3475     _errHandler->sync(this);\r
3476     switch (_input->LA(1)) {\r
3477       case TocParser::T__25: {\r
3478         enterOuterAlt(_localctx, 1);\r
3479         setState(360);\r
3480         match(TocParser::T__25);\r
3481         break;\r
3482       }\r
3483 \r
3484       case TocParser::T__26: {\r
3485         enterOuterAlt(_localctx, 2);\r
3486         setState(361);\r
3487         match(TocParser::T__26);\r
3488         break;\r
3489       }\r
3490 \r
3491       case TocParser::T__27: {\r
3492         enterOuterAlt(_localctx, 3);\r
3493         setState(362);\r
3494         match(TocParser::T__27);\r
3495         break;\r
3496       }\r
3497 \r
3498       case TocParser::T__28: {\r
3499         enterOuterAlt(_localctx, 4);\r
3500         setState(363);\r
3501         match(TocParser::T__28);\r
3502         break;\r
3503       }\r
3504 \r
3505       case TocParser::T__29: {\r
3506         enterOuterAlt(_localctx, 5);\r
3507         setState(364);\r
3508         match(TocParser::T__29);\r
3509         break;\r
3510       }\r
3511 \r
3512       case TocParser::T__3: {\r
3513         enterOuterAlt(_localctx, 6);\r
3514         setState(365);\r
3515         match(TocParser::T__3);\r
3516         break;\r
3517       }\r
3518 \r
3519       case TocParser::T__23:\r
3520       case TocParser::T__24: {\r
3521         enterOuterAlt(_localctx, 7);\r
3522         setState(366);\r
3523         postfix_op();\r
3524         break;\r
3525       }\r
3526 \r
3527     default:\r
3528       throw NoViableAltException(this);\r
3529     }\r
3530    \r
3531   }\r
3532   catch (RecognitionException &e) {\r
3533     _errHandler->reportError(this, e);\r
3534     _localctx->exception = std::current_exception();\r
3535     _errHandler->recover(this, _localctx->exception);\r
3536   }\r
3537 \r
3538   return _localctx;\r
3539 }\r
3540 \r
3541 //----------------- Binary_opContext ------------------------------------------------------------------\r
3542 \r
3543 TocParser::Binary_opContext::Binary_opContext(ParserRuleContext *parent, size_t invokingState)\r
3544   : ParserRuleContext(parent, invokingState) {\r
3545 }\r
3546 \r
3547 \r
3548 size_t TocParser::Binary_opContext::getRuleIndex() const {\r
3549   return TocParser::RuleBinary_op;\r
3550 }\r
3551 \r
3552 void TocParser::Binary_opContext::enterRule(tree::ParseTreeListener *listener) {\r
3553   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3554   if (parserListener != nullptr)\r
3555     parserListener->enterBinary_op(this);\r
3556 }\r
3557 \r
3558 void TocParser::Binary_opContext::exitRule(tree::ParseTreeListener *listener) {\r
3559   auto parserListener = dynamic_cast<TocListener *>(listener);\r
3560   if (parserListener != nullptr)\r
3561     parserListener->exitBinary_op(this);\r
3562 }\r
3563 \r
3564 TocParser::Binary_opContext* TocParser::binary_op() {\r
3565   Binary_opContext *_localctx = _tracker.createInstance<Binary_opContext>(_ctx, getState());\r
3566   enterRule(_localctx, 96, TocParser::RuleBinary_op);\r
3567   size_t _la = 0;\r
3568 \r
3569 #if __cplusplus > 201703L\r
3570   auto onExit = finally([=, this] {\r
3571 #else\r
3572   auto onExit = finally([=] {\r
3573 #endif\r
3574     exitRule();\r
3575   });\r
3576   try {\r
3577     enterOuterAlt(_localctx, 1);\r
3578     setState(369);\r
3579     _la = _input->LA(1);\r
3580     if (!((((_la & ~ 0x3fULL) == 0) &&\r
3581       ((1ULL << _la) & ((1ULL << TocParser::T__3)\r
3582       | (1ULL << TocParser::T__25)\r
3583       | (1ULL << TocParser::T__26)\r
3584       | (1ULL << TocParser::T__29)\r
3585       | (1ULL << TocParser::T__30)\r
3586       | (1ULL << TocParser::T__31)\r
3587       | (1ULL << TocParser::T__32)\r
3588       | (1ULL << TocParser::T__33)\r
3589       | (1ULL << TocParser::T__34)\r
3590       | (1ULL << TocParser::T__35)\r
3591       | (1ULL << TocParser::T__36)\r
3592       | (1ULL << TocParser::T__37)\r
3593       | (1ULL << TocParser::T__38)\r
3594       | (1ULL << TocParser::T__39)\r
3595       | (1ULL << TocParser::T__40)\r
3596       | (1ULL << TocParser::T__41)\r
3597       | (1ULL << TocParser::T__42)\r
3598       | (1ULL << TocParser::T__43)\r
3599       | (1ULL << TocParser::T__44)\r
3600       | (1ULL << TocParser::T__45)\r
3601       | (1ULL << TocParser::T__46)\r
3602       | (1ULL << TocParser::T__47)\r
3603       | (1ULL << TocParser::T__48)\r
3604       | (1ULL << TocParser::T__49)\r
3605       | (1ULL << TocParser::T__50)\r
3606       | (1ULL << TocParser::T__51)\r
3607       | (1ULL << TocParser::T__52)\r
3608       | (1ULL << TocParser::T__53))) != 0))) {\r
3609     _errHandler->recoverInline(this);\r
3610     }\r
3611     else {\r
3612       _errHandler->reportMatch(this);\r
3613       consume();\r
3614     }\r
3615    \r
3616   }\r
3617   catch (RecognitionException &e) {\r
3618     _errHandler->reportError(this, e);\r
3619     _localctx->exception = std::current_exception();\r
3620     _errHandler->recover(this, _localctx->exception);\r
3621   }\r
3622 \r
3623   return _localctx;\r
3624 }\r
3625 \r
3626 // Static vars and initialization.\r
3627 std::vector<dfa::DFA> TocParser::_decisionToDFA;\r
3628 atn::PredictionContextCache TocParser::_sharedContextCache;\r
3629 \r
3630 // We own the ATN which in turn owns the ATN states.\r
3631 atn::ATN TocParser::_atn;\r
3632 std::vector<uint16_t> TocParser::_serializedATN;\r
3633 \r
3634 std::vector<std::string> TocParser::_ruleNames = {\r
3635   "prog", "decl", "varDecl", "var", "varInit", "type", "typeModifier", "funcDecl", \r
3636   "func", "parameter", "body", "structDecl", "structMember", "structVar", \r
3637   "structMethod", "stmt", "ifStmt", "elseIfStmt", "elseStmt", "switchStmt", \r
3638   "switchBody", "switchCase", "forStmt", "whileStmt", "assignStmt", "returnStmt", \r
3639   "expr", "nonOpExpr", "nonAccessExpr", "funcExpr", "opExpr", "binaryOp", \r
3640   "prefixOp", "postfixOp", "ternaryOp", "identifierExpr", "litExpr", "accessExpr", \r
3641   "accessSubExpr", "accessMember", "accessBrackets", "parenExpr", "funcName", \r
3642   "varName", "typeName", "structName", "postfix_op", "prefix_op", "binary_op"\r
3643 };\r
3644 \r
3645 std::vector<std::string> TocParser::_literalNames = {\r
3646   "", "'var'", "':'", "'='", "'*'", "'['", "']'", "'func'", "'('", "')'", \r
3647   "','", "'{'", "'}'", "'struct'", "'if'", "'else'", "'switch'", "'case'", \r
3648   "'for'", "'while'", "'return'", "'\u003F'", "'.'", "'->'", "'++'", "'--'", \r
3649   "'+'", "'-'", "'!'", "'~'", "'&'", "'/'", "'%'", "'<'", "'|'", "'^'", \r
3650   "'>'", "'=='", "'!='", "'<='", "'>='", "'<<'", "'>>'", "'||'", "'&&'", \r
3651   "'&='", "'|='", "'^='", "'<<='", "'>>='", "'+='", "'-='", "'*='", "'/='", \r
3652   "'%='"\r
3653 };\r
3654 \r
3655 std::vector<std::string> TocParser::_symbolicNames = {\r
3656   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", \r
3657   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", \r
3658   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", \r
3659   "", "INT_LIT", "DECIMAL_LIT", "STRING_LIT", "BOOL_LIT", "NAME", "WS", \r
3660   "NEWLINE", "NUMBER"\r
3661 };\r
3662 \r
3663 dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames);\r
3664 \r
3665 std::vector<std::string> TocParser::_tokenNames;\r
3666 \r
3667 TocParser::Initializer::Initializer() {\r
3668         for (size_t i = 0; i < _symbolicNames.size(); ++i) {\r
3669                 std::string name = _vocabulary.getLiteralName(i);\r
3670                 if (name.empty()) {\r
3671                         name = _vocabulary.getSymbolicName(i);\r
3672                 }\r
3673 \r
3674                 if (name.empty()) {\r
3675                         _tokenNames.push_back("<INVALID>");\r
3676                 } else {\r
3677       _tokenNames.push_back(name);\r
3678     }\r
3679         }\r
3680 \r
3681   static const uint16_t serializedATNSegment0[] = {\r
3682     0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, \r
3683        0x3, 0x40, 0x176, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, \r
3684        0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, \r
3685        0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, \r
3686        0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, \r
3687        0xe, 0x9, 0xe, 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, \r
3688        0x9, 0x11, 0x4, 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, \r
3689        0x9, 0x14, 0x4, 0x15, 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, \r
3690        0x9, 0x17, 0x4, 0x18, 0x9, 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, \r
3691        0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, \r
3692        0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, \r
3693        0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, \r
3694        0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, \r
3695        0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 0x4, 0x29, \r
3696        0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4, 0x2c, \r
3697        0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, \r
3698        0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, \r
3699        0x9, 0x32, 0x3, 0x2, 0x6, 0x2, 0x66, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, \r
3700        0x67, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, \r
3701        0x6f, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, \r
3702        0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x7a, 0xa, 0x5, \r
3703        0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, \r
3704        0x6, 0x3, 0x7, 0x3, 0x7, 0x7, 0x7, 0x85, 0xa, 0x7, 0xc, 0x7, 0xe, \r
3705        0x7, 0x88, 0xb, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x5, 0x8, 0x8d, \r
3706        0xa, 0x8, 0x3, 0x8, 0x5, 0x8, 0x90, 0xa, 0x8, 0x3, 0x9, 0x3, 0x9, \r
3707        0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, \r
3708        0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, \r
3709        0x7, 0xb, 0xa1, 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0xa4, 0xb, 0xb, 0x5, \r
3710        0xb, 0xa6, 0xa, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 0xaa, 0xa, 0xc, \r
3711        0xc, 0xc, 0xe, 0xc, 0xad, 0xb, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd, \r
3712        0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0xb5, 0xa, 0xd, 0xc, 0xd, \r
3713        0xe, 0xd, 0xb8, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, \r
3714        0x5, 0xe, 0xbe, 0xa, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, \r
3715        0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, \r
3716        0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0xcc, 0xa, 0x11, 0x3, 0x12, 0x3, \r
3717        0x12, 0x3, 0x12, 0x3, 0x12, 0x7, 0x12, 0xd2, 0xa, 0x12, 0xc, 0x12, \r
3718        0xe, 0x12, 0xd5, 0xb, 0x12, 0x3, 0x12, 0x5, 0x12, 0xd8, 0xa, 0x12, \r
3719        0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, \r
3720        0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, \r
3721        0x3, 0x16, 0x3, 0x16, 0x7, 0x16, 0xe8, 0xa, 0x16, 0xc, 0x16, 0xe, \r
3722        0x16, 0xeb, 0xb, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, \r
3723        0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, \r
3724        0xf6, 0xa, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, \r
3725        0x18, 0x3, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, \r
3726        0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, \r
3727        0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, \r
3728        0x1c, 0x5, 0x1c, 0x10f, 0xa, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, \r
3729        0x3, 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x116, 0xa, 0x1d, 0x3, 0x1e, 0x3, \r
3730        0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x11b, 0xa, 0x1e, 0x3, 0x1f, 0x3, 0x1f, \r
3731        0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x7, 0x1f, 0x122, 0xa, 0x1f, 0xc, \r
3732        0x1f, 0xe, 0x1f, 0x125, 0xb, 0x1f, 0x5, 0x1f, 0x127, 0xa, 0x1f, 0x3, \r
3733        0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x5, \r
3734        0x20, 0x12f, 0xa, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, \r
3735        0x3, 0x21, 0x3, 0x21, 0x7, 0x21, 0x137, 0xa, 0x21, 0xc, 0x21, 0xe, \r
3736        0x21, 0x13a, 0xb, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, \r
3737        0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, \r
3738        0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, \r
3739        0x3, 0x27, 0x3, 0x27, 0x6, 0x27, 0x14e, 0xa, 0x27, 0xd, 0x27, 0xe, \r
3740        0x27, 0x14f, 0x3, 0x28, 0x3, 0x28, 0x5, 0x28, 0x154, 0xa, 0x28, 0x3, \r
3741        0x29, 0x3, 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, \r
3742        0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c, 0x3, \r
3743        0x2c, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3, \r
3744        0x2f, 0x3, 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, \r
3745        0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x5, 0x31, 0x172, 0xa, 0x31, \r
3746        0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x2, 0x2, 0x33, 0x2, 0x4, 0x6, 0x8, \r
3747        0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, \r
3748        0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, \r
3749        0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, \r
3750        0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x62, \r
3751        0x2, 0x6, 0x3, 0x2, 0x39, 0x3c, 0x3, 0x2, 0x18, 0x19, 0x3, 0x2, 0x1a, \r
3752        0x1b, 0x5, 0x2, 0x6, 0x6, 0x1c, 0x1d, 0x20, 0x38, 0x2, 0x174, 0x2, \r
3753        0x65, 0x3, 0x2, 0x2, 0x2, 0x4, 0x6e, 0x3, 0x2, 0x2, 0x2, 0x6, 0x70, \r
3754        0x3, 0x2, 0x2, 0x2, 0x8, 0x73, 0x3, 0x2, 0x2, 0x2, 0xa, 0x7b, 0x3, \r
3755        0x2, 0x2, 0x2, 0xc, 0x82, 0x3, 0x2, 0x2, 0x2, 0xe, 0x8f, 0x3, 0x2, \r
3756        0x2, 0x2, 0x10, 0x91, 0x3, 0x2, 0x2, 0x2, 0x12, 0x94, 0x3, 0x2, 0x2, \r
3757        0x2, 0x14, 0xa5, 0x3, 0x2, 0x2, 0x2, 0x16, 0xa7, 0x3, 0x2, 0x2, 0x2, \r
3758        0x18, 0xb0, 0x3, 0x2, 0x2, 0x2, 0x1a, 0xbd, 0x3, 0x2, 0x2, 0x2, 0x1c, \r
3759        0xbf, 0x3, 0x2, 0x2, 0x2, 0x1e, 0xc1, 0x3, 0x2, 0x2, 0x2, 0x20, 0xcb, \r
3760        0x3, 0x2, 0x2, 0x2, 0x22, 0xcd, 0x3, 0x2, 0x2, 0x2, 0x24, 0xd9, 0x3, \r
3761        0x2, 0x2, 0x2, 0x26, 0xde, 0x3, 0x2, 0x2, 0x2, 0x28, 0xe1, 0x3, 0x2, \r
3762        0x2, 0x2, 0x2a, 0xe5, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xee, 0x3, 0x2, 0x2, \r
3763        0x2, 0x2e, 0xf2, 0x3, 0x2, 0x2, 0x2, 0x30, 0xfd, 0x3, 0x2, 0x2, 0x2, \r
3764        0x32, 0x101, 0x3, 0x2, 0x2, 0x2, 0x34, 0x105, 0x3, 0x2, 0x2, 0x2, \r
3765        0x36, 0x10e, 0x3, 0x2, 0x2, 0x2, 0x38, 0x115, 0x3, 0x2, 0x2, 0x2, \r
3766        0x3a, 0x11a, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x11c, 0x3, 0x2, 0x2, 0x2, \r
3767        0x3e, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x40, 0x130, 0x3, 0x2, 0x2, 0x2, \r
3768        0x42, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x44, 0x13e, 0x3, 0x2, 0x2, 0x2, \r
3769        0x46, 0x141, 0x3, 0x2, 0x2, 0x2, 0x48, 0x147, 0x3, 0x2, 0x2, 0x2, \r
3770        0x4a, 0x149, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x14b, 0x3, 0x2, 0x2, 0x2, \r
3771        0x4e, 0x153, 0x3, 0x2, 0x2, 0x2, 0x50, 0x155, 0x3, 0x2, 0x2, 0x2, \r
3772        0x52, 0x158, 0x3, 0x2, 0x2, 0x2, 0x54, 0x15c, 0x3, 0x2, 0x2, 0x2, \r
3773        0x56, 0x160, 0x3, 0x2, 0x2, 0x2, 0x58, 0x162, 0x3, 0x2, 0x2, 0x2, \r
3774        0x5a, 0x164, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x166, 0x3, 0x2, 0x2, 0x2, \r
3775        0x5e, 0x168, 0x3, 0x2, 0x2, 0x2, 0x60, 0x171, 0x3, 0x2, 0x2, 0x2, \r
3776        0x62, 0x173, 0x3, 0x2, 0x2, 0x2, 0x64, 0x66, 0x5, 0x4, 0x3, 0x2, \r
3777        0x65, 0x64, 0x3, 0x2, 0x2, 0x2, 0x66, 0x67, 0x3, 0x2, 0x2, 0x2, 0x67, \r
3778        0x65, 0x3, 0x2, 0x2, 0x2, 0x67, 0x68, 0x3, 0x2, 0x2, 0x2, 0x68, 0x69, \r
3779        0x3, 0x2, 0x2, 0x2, 0x69, 0x6a, 0x7, 0x2, 0x2, 0x3, 0x6a, 0x3, 0x3, \r
3780        0x2, 0x2, 0x2, 0x6b, 0x6f, 0x5, 0x6, 0x4, 0x2, 0x6c, 0x6f, 0x5, 0x10, \r
3781        0x9, 0x2, 0x6d, 0x6f, 0x5, 0x18, 0xd, 0x2, 0x6e, 0x6b, 0x3, 0x2, \r
3782        0x2, 0x2, 0x6e, 0x6c, 0x3, 0x2, 0x2, 0x2, 0x6e, 0x6d, 0x3, 0x2, 0x2, \r
3783        0x2, 0x6f, 0x5, 0x3, 0x2, 0x2, 0x2, 0x70, 0x71, 0x7, 0x3, 0x2, 0x2, \r
3784        0x71, 0x72, 0x5, 0x8, 0x5, 0x2, 0x72, 0x7, 0x3, 0x2, 0x2, 0x2, 0x73, \r
3785        0x74, 0x5, 0x58, 0x2d, 0x2, 0x74, 0x75, 0x7, 0x4, 0x2, 0x2, 0x75, \r
3786        0x76, 0x5, 0xc, 0x7, 0x2, 0x76, 0x79, 0x3, 0x2, 0x2, 0x2, 0x77, 0x78, \r
3787        0x7, 0x5, 0x2, 0x2, 0x78, 0x7a, 0x5, 0x36, 0x1c, 0x2, 0x79, 0x77, \r
3788        0x3, 0x2, 0x2, 0x2, 0x79, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x9, 0x3, \r
3789        0x2, 0x2, 0x2, 0x7b, 0x7c, 0x5, 0x58, 0x2d, 0x2, 0x7c, 0x7d, 0x7, \r
3790        0x4, 0x2, 0x2, 0x7d, 0x7e, 0x5, 0xc, 0x7, 0x2, 0x7e, 0x7f, 0x3, 0x2, \r
3791        0x2, 0x2, 0x7f, 0x80, 0x7, 0x5, 0x2, 0x2, 0x80, 0x81, 0x5, 0x36, \r
3792        0x1c, 0x2, 0x81, 0xb, 0x3, 0x2, 0x2, 0x2, 0x82, 0x86, 0x5, 0x5a, \r
3793        0x2e, 0x2, 0x83, 0x85, 0x5, 0xe, 0x8, 0x2, 0x84, 0x83, 0x3, 0x2, \r
3794        0x2, 0x2, 0x85, 0x88, 0x3, 0x2, 0x2, 0x2, 0x86, 0x84, 0x3, 0x2, 0x2, \r
3795        0x2, 0x86, 0x87, 0x3, 0x2, 0x2, 0x2, 0x87, 0xd, 0x3, 0x2, 0x2, 0x2, \r
3796        0x88, 0x86, 0x3, 0x2, 0x2, 0x2, 0x89, 0x90, 0x7, 0x6, 0x2, 0x2, 0x8a, \r
3797        0x8c, 0x7, 0x7, 0x2, 0x2, 0x8b, 0x8d, 0x7, 0x40, 0x2, 0x2, 0x8c, \r
3798        0x8b, 0x3, 0x2, 0x2, 0x2, 0x8c, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x8d, 0x8e, \r
3799        0x3, 0x2, 0x2, 0x2, 0x8e, 0x90, 0x7, 0x8, 0x2, 0x2, 0x8f, 0x89, 0x3, \r
3800        0x2, 0x2, 0x2, 0x8f, 0x8a, 0x3, 0x2, 0x2, 0x2, 0x90, 0xf, 0x3, 0x2, \r
3801        0x2, 0x2, 0x91, 0x92, 0x7, 0x9, 0x2, 0x2, 0x92, 0x93, 0x5, 0x12, \r
3802        0xa, 0x2, 0x93, 0x11, 0x3, 0x2, 0x2, 0x2, 0x94, 0x95, 0x5, 0x56, \r
3803        0x2c, 0x2, 0x95, 0x96, 0x7, 0xa, 0x2, 0x2, 0x96, 0x97, 0x5, 0x14, \r
3804        0xb, 0x2, 0x97, 0x98, 0x7, 0xb, 0x2, 0x2, 0x98, 0x99, 0x7, 0x4, 0x2, \r
3805        0x2, 0x99, 0x9a, 0x5, 0xc, 0x7, 0x2, 0x9a, 0x9b, 0x3, 0x2, 0x2, 0x2, \r
3806        0x9b, 0x9c, 0x5, 0x16, 0xc, 0x2, 0x9c, 0x13, 0x3, 0x2, 0x2, 0x2, \r
3807        0x9d, 0xa2, 0x5, 0x8, 0x5, 0x2, 0x9e, 0x9f, 0x7, 0xc, 0x2, 0x2, 0x9f, \r
3808        0xa1, 0x5, 0x8, 0x5, 0x2, 0xa0, 0x9e, 0x3, 0x2, 0x2, 0x2, 0xa1, 0xa4, \r
3809        0x3, 0x2, 0x2, 0x2, 0xa2, 0xa0, 0x3, 0x2, 0x2, 0x2, 0xa2, 0xa3, 0x3, \r
3810        0x2, 0x2, 0x2, 0xa3, 0xa6, 0x3, 0x2, 0x2, 0x2, 0xa4, 0xa2, 0x3, 0x2, \r
3811        0x2, 0x2, 0xa5, 0x9d, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x3, 0x2, 0x2, \r
3812        0x2, 0xa6, 0x15, 0x3, 0x2, 0x2, 0x2, 0xa7, 0xab, 0x7, 0xd, 0x2, 0x2, \r
3813        0xa8, 0xaa, 0x5, 0x20, 0x11, 0x2, 0xa9, 0xa8, 0x3, 0x2, 0x2, 0x2, \r
3814        0xaa, 0xad, 0x3, 0x2, 0x2, 0x2, 0xab, 0xa9, 0x3, 0x2, 0x2, 0x2, 0xab, \r
3815        0xac, 0x3, 0x2, 0x2, 0x2, 0xac, 0xae, 0x3, 0x2, 0x2, 0x2, 0xad, 0xab, \r
3816        0x3, 0x2, 0x2, 0x2, 0xae, 0xaf, 0x7, 0xe, 0x2, 0x2, 0xaf, 0x17, 0x3, \r
3817        0x2, 0x2, 0x2, 0xb0, 0xb1, 0x7, 0xf, 0x2, 0x2, 0xb1, 0xb2, 0x5, 0x5c, \r
3818        0x2f, 0x2, 0xb2, 0xb6, 0x7, 0xd, 0x2, 0x2, 0xb3, 0xb5, 0x5, 0x1a, \r
3819        0xe, 0x2, 0xb4, 0xb3, 0x3, 0x2, 0x2, 0x2, 0xb5, 0xb8, 0x3, 0x2, 0x2, \r
3820        0x2, 0xb6, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb6, 0xb7, 0x3, 0x2, 0x2, 0x2, \r
3821        0xb7, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xb8, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb9, \r
3822        0xba, 0x7, 0xe, 0x2, 0x2, 0xba, 0x19, 0x3, 0x2, 0x2, 0x2, 0xbb, 0xbe, \r
3823        0x5, 0x1c, 0xf, 0x2, 0xbc, 0xbe, 0x5, 0x1e, 0x10, 0x2, 0xbd, 0xbb, \r
3824        0x3, 0x2, 0x2, 0x2, 0xbd, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbe, 0x1b, 0x3, \r
3825        0x2, 0x2, 0x2, 0xbf, 0xc0, 0x5, 0x8, 0x5, 0x2, 0xc0, 0x1d, 0x3, 0x2, \r
3826        0x2, 0x2, 0xc1, 0xc2, 0x5, 0x12, 0xa, 0x2, 0xc2, 0x1f, 0x3, 0x2, \r
3827        0x2, 0x2, 0xc3, 0xcc, 0x5, 0x6, 0x4, 0x2, 0xc4, 0xcc, 0x5, 0x22, \r
3828        0x12, 0x2, 0xc5, 0xcc, 0x5, 0x28, 0x15, 0x2, 0xc6, 0xcc, 0x5, 0x2e, \r
3829        0x18, 0x2, 0xc7, 0xcc, 0x5, 0x30, 0x19, 0x2, 0xc8, 0xcc, 0x5, 0x32, \r
3830        0x1a, 0x2, 0xc9, 0xcc, 0x5, 0x34, 0x1b, 0x2, 0xca, 0xcc, 0x5, 0x36, \r
3831        0x1c, 0x2, 0xcb, 0xc3, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xc4, 0x3, 0x2, \r
3832        0x2, 0x2, 0xcb, 0xc5, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xc6, 0x3, 0x2, 0x2, \r
3833        0x2, 0xcb, 0xc7, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xc8, 0x3, 0x2, 0x2, 0x2, \r
3834        0xcb, 0xc9, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xca, 0x3, 0x2, 0x2, 0x2, 0xcc, \r
3835        0x21, 0x3, 0x2, 0x2, 0x2, 0xcd, 0xce, 0x7, 0x10, 0x2, 0x2, 0xce, \r
3836        0xcf, 0x5, 0x36, 0x1c, 0x2, 0xcf, 0xd3, 0x5, 0x16, 0xc, 0x2, 0xd0, \r
3837        0xd2, 0x5, 0x24, 0x13, 0x2, 0xd1, 0xd0, 0x3, 0x2, 0x2, 0x2, 0xd2, \r
3838        0xd5, 0x3, 0x2, 0x2, 0x2, 0xd3, 0xd1, 0x3, 0x2, 0x2, 0x2, 0xd3, 0xd4, \r
3839        0x3, 0x2, 0x2, 0x2, 0xd4, 0xd7, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd3, 0x3, \r
3840        0x2, 0x2, 0x2, 0xd6, 0xd8, 0x5, 0x26, 0x14, 0x2, 0xd7, 0xd6, 0x3, \r
3841        0x2, 0x2, 0x2, 0xd7, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd8, 0x23, 0x3, 0x2, \r
3842        0x2, 0x2, 0xd9, 0xda, 0x7, 0x11, 0x2, 0x2, 0xda, 0xdb, 0x7, 0x10, \r
3843        0x2, 0x2, 0xdb, 0xdc, 0x5, 0x36, 0x1c, 0x2, 0xdc, 0xdd, 0x5, 0x16, \r
3844        0xc, 0x2, 0xdd, 0x25, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdf, 0x7, 0x11, \r
3845        0x2, 0x2, 0xdf, 0xe0, 0x5, 0x16, 0xc, 0x2, 0xe0, 0x27, 0x3, 0x2, \r
3846        0x2, 0x2, 0xe1, 0xe2, 0x7, 0x12, 0x2, 0x2, 0xe2, 0xe3, 0x5, 0x48, \r
3847        0x25, 0x2, 0xe3, 0xe4, 0x5, 0x2a, 0x16, 0x2, 0xe4, 0x29, 0x3, 0x2, \r
3848        0x2, 0x2, 0xe5, 0xe9, 0x7, 0xd, 0x2, 0x2, 0xe6, 0xe8, 0x5, 0x2c, \r
3849        0x17, 0x2, 0xe7, 0xe6, 0x3, 0x2, 0x2, 0x2, 0xe8, 0xeb, 0x3, 0x2, \r
3850        0x2, 0x2, 0xe9, 0xe7, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xea, 0x3, 0x2, 0x2, \r
3851        0x2, 0xea, 0xec, 0x3, 0x2, 0x2, 0x2, 0xeb, 0xe9, 0x3, 0x2, 0x2, 0x2, \r
3852        0xec, 0xed, 0x7, 0xe, 0x2, 0x2, 0xed, 0x2b, 0x3, 0x2, 0x2, 0x2, 0xee, \r
3853        0xef, 0x7, 0x13, 0x2, 0x2, 0xef, 0xf0, 0x5, 0x36, 0x1c, 0x2, 0xf0, \r
3854        0xf1, 0x5, 0x16, 0xc, 0x2, 0xf1, 0x2d, 0x3, 0x2, 0x2, 0x2, 0xf2, \r
3855        0xf5, 0x7, 0x14, 0x2, 0x2, 0xf3, 0xf6, 0x5, 0xa, 0x6, 0x2, 0xf4, \r
3856        0xf6, 0x5, 0x32, 0x1a, 0x2, 0xf5, 0xf3, 0x3, 0x2, 0x2, 0x2, 0xf5, \r
3857        0xf4, 0x3, 0x2, 0x2, 0x2, 0xf6, 0xf7, 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf8, \r
3858        0x7, 0xc, 0x2, 0x2, 0xf8, 0xf9, 0x5, 0x36, 0x1c, 0x2, 0xf9, 0xfa, \r
3859        0x7, 0xc, 0x2, 0x2, 0xfa, 0xfb, 0x5, 0x36, 0x1c, 0x2, 0xfb, 0xfc, \r
3860        0x5, 0x16, 0xc, 0x2, 0xfc, 0x2f, 0x3, 0x2, 0x2, 0x2, 0xfd, 0xfe, \r
3861        0x7, 0x15, 0x2, 0x2, 0xfe, 0xff, 0x5, 0x36, 0x1c, 0x2, 0xff, 0x100, \r
3862        0x5, 0x16, 0xc, 0x2, 0x100, 0x31, 0x3, 0x2, 0x2, 0x2, 0x101, 0x102, \r
3863        0x5, 0x48, 0x25, 0x2, 0x102, 0x103, 0x7, 0x5, 0x2, 0x2, 0x103, 0x104, \r
3864        0x5, 0x36, 0x1c, 0x2, 0x104, 0x33, 0x3, 0x2, 0x2, 0x2, 0x105, 0x106, \r
3865        0x7, 0x16, 0x2, 0x2, 0x106, 0x107, 0x5, 0x36, 0x1c, 0x2, 0x107, 0x35, \r
3866        0x3, 0x2, 0x2, 0x2, 0x108, 0x10f, 0x5, 0x3c, 0x1f, 0x2, 0x109, 0x10f, \r
3867        0x5, 0x4a, 0x26, 0x2, 0x10a, 0x10f, 0x5, 0x48, 0x25, 0x2, 0x10b, \r
3868        0x10f, 0x5, 0x54, 0x2b, 0x2, 0x10c, 0x10f, 0x5, 0x4c, 0x27, 0x2, \r
3869        0x10d, 0x10f, 0x5, 0x3e, 0x20, 0x2, 0x10e, 0x108, 0x3, 0x2, 0x2, \r
3870        0x2, 0x10e, 0x109, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x10a, 0x3, 0x2, 0x2, \r
3871        0x2, 0x10e, 0x10b, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x10c, 0x3, 0x2, 0x2, \r
3872        0x2, 0x10e, 0x10d, 0x3, 0x2, 0x2, 0x2, 0x10f, 0x37, 0x3, 0x2, 0x2, \r
3873        0x2, 0x110, 0x116, 0x5, 0x3c, 0x1f, 0x2, 0x111, 0x116, 0x5, 0x4a, \r
3874        0x26, 0x2, 0x112, 0x116, 0x5, 0x48, 0x25, 0x2, 0x113, 0x116, 0x5, \r
3875        0x54, 0x2b, 0x2, 0x114, 0x116, 0x5, 0x4c, 0x27, 0x2, 0x115, 0x110, \r
3876        0x3, 0x2, 0x2, 0x2, 0x115, 0x111, 0x3, 0x2, 0x2, 0x2, 0x115, 0x112, \r
3877        0x3, 0x2, 0x2, 0x2, 0x115, 0x113, 0x3, 0x2, 0x2, 0x2, 0x115, 0x114, \r
3878        0x3, 0x2, 0x2, 0x2, 0x116, 0x39, 0x3, 0x2, 0x2, 0x2, 0x117, 0x11b, \r
3879        0x5, 0x3c, 0x1f, 0x2, 0x118, 0x11b, 0x5, 0x48, 0x25, 0x2, 0x119, \r
3880        0x11b, 0x5, 0x54, 0x2b, 0x2, 0x11a, 0x117, 0x3, 0x2, 0x2, 0x2, 0x11a, \r
3881        0x118, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x119, 0x3, 0x2, 0x2, 0x2, 0x11b, \r
3882        0x3b, 0x3, 0x2, 0x2, 0x2, 0x11c, 0x11d, 0x5, 0x56, 0x2c, 0x2, 0x11d, \r
3883        0x126, 0x7, 0xa, 0x2, 0x2, 0x11e, 0x123, 0x5, 0x36, 0x1c, 0x2, 0x11f, \r
3884        0x120, 0x7, 0xc, 0x2, 0x2, 0x120, 0x122, 0x5, 0x36, 0x1c, 0x2, 0x121, \r
3885        0x11f, 0x3, 0x2, 0x2, 0x2, 0x122, 0x125, 0x3, 0x2, 0x2, 0x2, 0x123, \r
3886        0x121, 0x3, 0x2, 0x2, 0x2, 0x123, 0x124, 0x3, 0x2, 0x2, 0x2, 0x124, \r
3887        0x127, 0x3, 0x2, 0x2, 0x2, 0x125, 0x123, 0x3, 0x2, 0x2, 0x2, 0x126, \r
3888        0x11e, 0x3, 0x2, 0x2, 0x2, 0x126, 0x127, 0x3, 0x2, 0x2, 0x2, 0x127, \r
3889        0x128, 0x3, 0x2, 0x2, 0x2, 0x128, 0x129, 0x7, 0xb, 0x2, 0x2, 0x129, \r
3890        0x3d, 0x3, 0x2, 0x2, 0x2, 0x12a, 0x12f, 0x5, 0x40, 0x21, 0x2, 0x12b, \r
3891        0x12f, 0x5, 0x42, 0x22, 0x2, 0x12c, 0x12f, 0x5, 0x44, 0x23, 0x2, \r
3892        0x12d, 0x12f, 0x5, 0x46, 0x24, 0x2, 0x12e, 0x12a, 0x3, 0x2, 0x2, \r
3893        0x2, 0x12e, 0x12b, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x12c, 0x3, 0x2, 0x2, \r
3894        0x2, 0x12e, 0x12d, 0x3, 0x2, 0x2, 0x2, 0x12f, 0x3f, 0x3, 0x2, 0x2, \r
3895        0x2, 0x130, 0x131, 0x5, 0x38, 0x1d, 0x2, 0x131, 0x132, 0x5, 0x62, \r
3896        0x32, 0x2, 0x132, 0x138, 0x5, 0x38, 0x1d, 0x2, 0x133, 0x134, 0x5, \r
3897        0x62, 0x32, 0x2, 0x134, 0x135, 0x5, 0x38, 0x1d, 0x2, 0x135, 0x137, \r
3898        0x3, 0x2, 0x2, 0x2, 0x136, 0x133, 0x3, 0x2, 0x2, 0x2, 0x137, 0x13a, \r
3899        0x3, 0x2, 0x2, 0x2, 0x138, 0x136, 0x3, 0x2, 0x2, 0x2, 0x138, 0x139, \r
3900        0x3, 0x2, 0x2, 0x2, 0x139, 0x41, 0x3, 0x2, 0x2, 0x2, 0x13a, 0x138, \r
3901        0x3, 0x2, 0x2, 0x2, 0x13b, 0x13c, 0x5, 0x60, 0x31, 0x2, 0x13c, 0x13d, \r
3902        0x5, 0x38, 0x1d, 0x2, 0x13d, 0x43, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x13f, \r
3903        0x5, 0x38, 0x1d, 0x2, 0x13f, 0x140, 0x5, 0x5e, 0x30, 0x2, 0x140, \r
3904        0x45, 0x3, 0x2, 0x2, 0x2, 0x141, 0x142, 0x5, 0x38, 0x1d, 0x2, 0x142, \r
3905        0x143, 0x7, 0x17, 0x2, 0x2, 0x143, 0x144, 0x5, 0x36, 0x1c, 0x2, 0x144, \r
3906        0x145, 0x7, 0x4, 0x2, 0x2, 0x145, 0x146, 0x5, 0x36, 0x1c, 0x2, 0x146, \r
3907        0x47, 0x3, 0x2, 0x2, 0x2, 0x147, 0x148, 0x5, 0x58, 0x2d, 0x2, 0x148, \r
3908        0x49, 0x3, 0x2, 0x2, 0x2, 0x149, 0x14a, 0x9, 0x2, 0x2, 0x2, 0x14a, \r
3909        0x4b, 0x3, 0x2, 0x2, 0x2, 0x14b, 0x14d, 0x5, 0x3a, 0x1e, 0x2, 0x14c, \r
3910        0x14e, 0x5, 0x4e, 0x28, 0x2, 0x14d, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x14e, \r
3911        0x14f, 0x3, 0x2, 0x2, 0x2, 0x14f, 0x14d, 0x3, 0x2, 0x2, 0x2, 0x14f, \r
3912        0x150, 0x3, 0x2, 0x2, 0x2, 0x150, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x151, \r
3913        0x154, 0x5, 0x50, 0x29, 0x2, 0x152, 0x154, 0x5, 0x52, 0x2a, 0x2, \r
3914        0x153, 0x151, 0x3, 0x2, 0x2, 0x2, 0x153, 0x152, 0x3, 0x2, 0x2, 0x2, \r
3915        0x154, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x155, 0x156, 0x9, 0x3, 0x2, 0x2, \r
3916        0x156, 0x157, 0x5, 0x48, 0x25, 0x2, 0x157, 0x51, 0x3, 0x2, 0x2, 0x2, \r
3917        0x158, 0x159, 0x7, 0x7, 0x2, 0x2, 0x159, 0x15a, 0x5, 0x36, 0x1c, \r
3918        0x2, 0x15a, 0x15b, 0x7, 0x8, 0x2, 0x2, 0x15b, 0x53, 0x3, 0x2, 0x2, \r
3919        0x2, 0x15c, 0x15d, 0x7, 0xa, 0x2, 0x2, 0x15d, 0x15e, 0x5, 0x36, 0x1c, \r
3920        0x2, 0x15e, 0x15f, 0x7, 0xb, 0x2, 0x2, 0x15f, 0x55, 0x3, 0x2, 0x2, \r
3921        0x2, 0x160, 0x161, 0x7, 0x3d, 0x2, 0x2, 0x161, 0x57, 0x3, 0x2, 0x2, \r
3922        0x2, 0x162, 0x163, 0x7, 0x3d, 0x2, 0x2, 0x163, 0x59, 0x3, 0x2, 0x2, \r
3923        0x2, 0x164, 0x165, 0x7, 0x3d, 0x2, 0x2, 0x165, 0x5b, 0x3, 0x2, 0x2, \r
3924        0x2, 0x166, 0x167, 0x7, 0x3d, 0x2, 0x2, 0x167, 0x5d, 0x3, 0x2, 0x2, \r
3925        0x2, 0x168, 0x169, 0x9, 0x4, 0x2, 0x2, 0x169, 0x5f, 0x3, 0x2, 0x2, \r
3926        0x2, 0x16a, 0x172, 0x7, 0x1c, 0x2, 0x2, 0x16b, 0x172, 0x7, 0x1d, \r
3927        0x2, 0x2, 0x16c, 0x172, 0x7, 0x1e, 0x2, 0x2, 0x16d, 0x172, 0x7, 0x1f, \r
3928        0x2, 0x2, 0x16e, 0x172, 0x7, 0x20, 0x2, 0x2, 0x16f, 0x172, 0x7, 0x6, \r
3929        0x2, 0x2, 0x170, 0x172, 0x5, 0x5e, 0x30, 0x2, 0x171, 0x16a, 0x3, \r
3930        0x2, 0x2, 0x2, 0x171, 0x16b, 0x3, 0x2, 0x2, 0x2, 0x171, 0x16c, 0x3, \r
3931        0x2, 0x2, 0x2, 0x171, 0x16d, 0x3, 0x2, 0x2, 0x2, 0x171, 0x16e, 0x3, \r
3932        0x2, 0x2, 0x2, 0x171, 0x16f, 0x3, 0x2, 0x2, 0x2, 0x171, 0x170, 0x3, \r
3933        0x2, 0x2, 0x2, 0x172, 0x61, 0x3, 0x2, 0x2, 0x2, 0x173, 0x174, 0x9, \r
3934        0x5, 0x2, 0x2, 0x174, 0x63, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x67, 0x6e, \r
3935        0x79, 0x86, 0x8c, 0x8f, 0xa2, 0xa5, 0xab, 0xb6, 0xbd, 0xcb, 0xd3, \r
3936        0xd7, 0xe9, 0xf5, 0x10e, 0x115, 0x11a, 0x123, 0x126, 0x12e, 0x138, \r
3937        0x14f, 0x153, 0x171, \r
3938   };\r
3939 \r
3940   _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,\r
3941     serializedATNSegment0 + sizeof(serializedATNSegment0) / sizeof(serializedATNSegment0[0]));\r
3942 \r
3943 \r
3944   atn::ATNDeserializer deserializer;\r
3945   _atn = deserializer.deserialize(_serializedATN);\r
3946 \r
3947   size_t count = _atn.getNumberOfDecisions();\r
3948   _decisionToDFA.reserve(count);\r
3949   for (size_t i = 0; i < count; i++) { \r
3950     _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);\r
3951   }\r
3952 }\r
3953 \r
3954 TocParser::Initializer TocParser::_init;\r