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