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

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