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(75); \r
  84     _errHandler->sync(this);\r
  85     _la = _input->LA(1);\r
  86     do {\r
  87       setState(74);\r
  88       decl();\r
  89       setState(77); \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__3)\r
  95       | (1ULL << TocParser::T__9))) != 0));\r
  96     setState(79);\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(84);\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(81);\r
 162         varDecl();\r
 163         break;\r
 164       }\r
 165 \r
 166       case TocParser::T__3: {\r
 167         enterOuterAlt(_localctx, 2);\r
 168         setState(82);\r
 169         funcDecl();\r
 170         break;\r
 171       }\r
 172 \r
 173       case TocParser::T__9: {\r
 174         enterOuterAlt(_localctx, 3);\r
 175         setState(83);\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(86);\r
 235     match(TocParser::T__0);\r
 236     setState(87);\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(89);\r
 299     varName();\r
 300 \r
 301     setState(90);\r
 302     match(TocParser::T__1);\r
 303     setState(91);\r
 304     type();\r
 305     setState(95);\r
 306     _errHandler->sync(this);\r
 307 \r
 308     _la = _input->LA(1);\r
 309     if (_la == TocParser::T__2) {\r
 310       setState(93);\r
 311       match(TocParser::T__2);\r
 312       setState(94);\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 //----------------- TypeContext ------------------------------------------------------------------\r
 327 \r
 328 TocParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState)\r
 329   : ParserRuleContext(parent, invokingState) {\r
 330 }\r
 331 \r
 332 TocParser::TypeNameContext* TocParser::TypeContext::typeName() {\r
 333   return getRuleContext<TocParser::TypeNameContext>(0);\r
 334 }\r
 335 \r
 336 \r
 337 size_t TocParser::TypeContext::getRuleIndex() const {\r
 338   return TocParser::RuleType;\r
 339 }\r
 340 \r
 341 void TocParser::TypeContext::enterRule(tree::ParseTreeListener *listener) {\r
 342   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 343   if (parserListener != nullptr)\r
 344     parserListener->enterType(this);\r
 345 }\r
 346 \r
 347 void TocParser::TypeContext::exitRule(tree::ParseTreeListener *listener) {\r
 348   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 349   if (parserListener != nullptr)\r
 350     parserListener->exitType(this);\r
 351 }\r
 352 \r
 353 TocParser::TypeContext* TocParser::type() {\r
 354   TypeContext *_localctx = _tracker.createInstance<TypeContext>(_ctx, getState());\r
 355   enterRule(_localctx, 8, TocParser::RuleType);\r
 356 \r
 357 #if __cplusplus > 201703L\r
 358   auto onExit = finally([=, this] {\r
 359 #else\r
 360   auto onExit = finally([=] {\r
 361 #endif\r
 362     exitRule();\r
 363   });\r
 364   try {\r
 365     enterOuterAlt(_localctx, 1);\r
 366     setState(97);\r
 367     typeName();\r
 368    \r
 369   }\r
 370   catch (RecognitionException &e) {\r
 371     _errHandler->reportError(this, e);\r
 372     _localctx->exception = std::current_exception();\r
 373     _errHandler->recover(this, _localctx->exception);\r
 374   }\r
 375 \r
 376   return _localctx;\r
 377 }\r
 378 \r
 379 //----------------- FuncDeclContext ------------------------------------------------------------------\r
 380 \r
 381 TocParser::FuncDeclContext::FuncDeclContext(ParserRuleContext *parent, size_t invokingState)\r
 382   : ParserRuleContext(parent, invokingState) {\r
 383 }\r
 384 \r
 385 TocParser::FuncContext* TocParser::FuncDeclContext::func() {\r
 386   return getRuleContext<TocParser::FuncContext>(0);\r
 387 }\r
 388 \r
 389 \r
 390 size_t TocParser::FuncDeclContext::getRuleIndex() const {\r
 391   return TocParser::RuleFuncDecl;\r
 392 }\r
 393 \r
 394 void TocParser::FuncDeclContext::enterRule(tree::ParseTreeListener *listener) {\r
 395   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 396   if (parserListener != nullptr)\r
 397     parserListener->enterFuncDecl(this);\r
 398 }\r
 399 \r
 400 void TocParser::FuncDeclContext::exitRule(tree::ParseTreeListener *listener) {\r
 401   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 402   if (parserListener != nullptr)\r
 403     parserListener->exitFuncDecl(this);\r
 404 }\r
 405 \r
 406 TocParser::FuncDeclContext* TocParser::funcDecl() {\r
 407   FuncDeclContext *_localctx = _tracker.createInstance<FuncDeclContext>(_ctx, getState());\r
 408   enterRule(_localctx, 10, TocParser::RuleFuncDecl);\r
 409 \r
 410 #if __cplusplus > 201703L\r
 411   auto onExit = finally([=, this] {\r
 412 #else\r
 413   auto onExit = finally([=] {\r
 414 #endif\r
 415     exitRule();\r
 416   });\r
 417   try {\r
 418     enterOuterAlt(_localctx, 1);\r
 419     setState(99);\r
 420     match(TocParser::T__3);\r
 421     setState(100);\r
 422     func();\r
 423    \r
 424   }\r
 425   catch (RecognitionException &e) {\r
 426     _errHandler->reportError(this, e);\r
 427     _localctx->exception = std::current_exception();\r
 428     _errHandler->recover(this, _localctx->exception);\r
 429   }\r
 430 \r
 431   return _localctx;\r
 432 }\r
 433 \r
 434 //----------------- FuncContext ------------------------------------------------------------------\r
 435 \r
 436 TocParser::FuncContext::FuncContext(ParserRuleContext *parent, size_t invokingState)\r
 437   : ParserRuleContext(parent, invokingState) {\r
 438 }\r
 439 \r
 440 TocParser::FuncNameContext* TocParser::FuncContext::funcName() {\r
 441   return getRuleContext<TocParser::FuncNameContext>(0);\r
 442 }\r
 443 \r
 444 TocParser::ParameterContext* TocParser::FuncContext::parameter() {\r
 445   return getRuleContext<TocParser::ParameterContext>(0);\r
 446 }\r
 447 \r
 448 TocParser::BodyContext* TocParser::FuncContext::body() {\r
 449   return getRuleContext<TocParser::BodyContext>(0);\r
 450 }\r
 451 \r
 452 TocParser::TypeContext* TocParser::FuncContext::type() {\r
 453   return getRuleContext<TocParser::TypeContext>(0);\r
 454 }\r
 455 \r
 456 \r
 457 size_t TocParser::FuncContext::getRuleIndex() const {\r
 458   return TocParser::RuleFunc;\r
 459 }\r
 460 \r
 461 void TocParser::FuncContext::enterRule(tree::ParseTreeListener *listener) {\r
 462   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 463   if (parserListener != nullptr)\r
 464     parserListener->enterFunc(this);\r
 465 }\r
 466 \r
 467 void TocParser::FuncContext::exitRule(tree::ParseTreeListener *listener) {\r
 468   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 469   if (parserListener != nullptr)\r
 470     parserListener->exitFunc(this);\r
 471 }\r
 472 \r
 473 TocParser::FuncContext* TocParser::func() {\r
 474   FuncContext *_localctx = _tracker.createInstance<FuncContext>(_ctx, getState());\r
 475   enterRule(_localctx, 12, TocParser::RuleFunc);\r
 476 \r
 477 #if __cplusplus > 201703L\r
 478   auto onExit = finally([=, this] {\r
 479 #else\r
 480   auto onExit = finally([=] {\r
 481 #endif\r
 482     exitRule();\r
 483   });\r
 484   try {\r
 485     enterOuterAlt(_localctx, 1);\r
 486     setState(102);\r
 487     funcName();\r
 488     setState(103);\r
 489     match(TocParser::T__4);\r
 490     setState(104);\r
 491     parameter();\r
 492     setState(105);\r
 493     match(TocParser::T__5);\r
 494 \r
 495     setState(106);\r
 496     match(TocParser::T__1);\r
 497     setState(107);\r
 498     type();\r
 499     setState(109);\r
 500     body();\r
 501    \r
 502   }\r
 503   catch (RecognitionException &e) {\r
 504     _errHandler->reportError(this, e);\r
 505     _localctx->exception = std::current_exception();\r
 506     _errHandler->recover(this, _localctx->exception);\r
 507   }\r
 508 \r
 509   return _localctx;\r
 510 }\r
 511 \r
 512 //----------------- ParameterContext ------------------------------------------------------------------\r
 513 \r
 514 TocParser::ParameterContext::ParameterContext(ParserRuleContext *parent, size_t invokingState)\r
 515   : ParserRuleContext(parent, invokingState) {\r
 516 }\r
 517 \r
 518 TocParser::FirstParameterContext* TocParser::ParameterContext::firstParameter() {\r
 519   return getRuleContext<TocParser::FirstParameterContext>(0);\r
 520 }\r
 521 \r
 522 std::vector<TocParser::AdditionalParameterContext *> TocParser::ParameterContext::additionalParameter() {\r
 523   return getRuleContexts<TocParser::AdditionalParameterContext>();\r
 524 }\r
 525 \r
 526 TocParser::AdditionalParameterContext* TocParser::ParameterContext::additionalParameter(size_t i) {\r
 527   return getRuleContext<TocParser::AdditionalParameterContext>(i);\r
 528 }\r
 529 \r
 530 \r
 531 size_t TocParser::ParameterContext::getRuleIndex() const {\r
 532   return TocParser::RuleParameter;\r
 533 }\r
 534 \r
 535 void TocParser::ParameterContext::enterRule(tree::ParseTreeListener *listener) {\r
 536   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 537   if (parserListener != nullptr)\r
 538     parserListener->enterParameter(this);\r
 539 }\r
 540 \r
 541 void TocParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) {\r
 542   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 543   if (parserListener != nullptr)\r
 544     parserListener->exitParameter(this);\r
 545 }\r
 546 \r
 547 TocParser::ParameterContext* TocParser::parameter() {\r
 548   ParameterContext *_localctx = _tracker.createInstance<ParameterContext>(_ctx, getState());\r
 549   enterRule(_localctx, 14, TocParser::RuleParameter);\r
 550   size_t _la = 0;\r
 551 \r
 552 #if __cplusplus > 201703L\r
 553   auto onExit = finally([=, this] {\r
 554 #else\r
 555   auto onExit = finally([=] {\r
 556 #endif\r
 557     exitRule();\r
 558   });\r
 559   try {\r
 560     enterOuterAlt(_localctx, 1);\r
 561     setState(118);\r
 562     _errHandler->sync(this);\r
 563 \r
 564     _la = _input->LA(1);\r
 565     if (_la == TocParser::NAME) {\r
 566       setState(111);\r
 567       firstParameter();\r
 568       setState(115);\r
 569       _errHandler->sync(this);\r
 570       _la = _input->LA(1);\r
 571       while (_la == TocParser::T__6) {\r
 572         setState(112);\r
 573         additionalParameter();\r
 574         setState(117);\r
 575         _errHandler->sync(this);\r
 576         _la = _input->LA(1);\r
 577       }\r
 578     }\r
 579    \r
 580   }\r
 581   catch (RecognitionException &e) {\r
 582     _errHandler->reportError(this, e);\r
 583     _localctx->exception = std::current_exception();\r
 584     _errHandler->recover(this, _localctx->exception);\r
 585   }\r
 586 \r
 587   return _localctx;\r
 588 }\r
 589 \r
 590 //----------------- FirstParameterContext ------------------------------------------------------------------\r
 591 \r
 592 TocParser::FirstParameterContext::FirstParameterContext(ParserRuleContext *parent, size_t invokingState)\r
 593   : ParserRuleContext(parent, invokingState) {\r
 594 }\r
 595 \r
 596 TocParser::VarContext* TocParser::FirstParameterContext::var() {\r
 597   return getRuleContext<TocParser::VarContext>(0);\r
 598 }\r
 599 \r
 600 \r
 601 size_t TocParser::FirstParameterContext::getRuleIndex() const {\r
 602   return TocParser::RuleFirstParameter;\r
 603 }\r
 604 \r
 605 void TocParser::FirstParameterContext::enterRule(tree::ParseTreeListener *listener) {\r
 606   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 607   if (parserListener != nullptr)\r
 608     parserListener->enterFirstParameter(this);\r
 609 }\r
 610 \r
 611 void TocParser::FirstParameterContext::exitRule(tree::ParseTreeListener *listener) {\r
 612   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 613   if (parserListener != nullptr)\r
 614     parserListener->exitFirstParameter(this);\r
 615 }\r
 616 \r
 617 TocParser::FirstParameterContext* TocParser::firstParameter() {\r
 618   FirstParameterContext *_localctx = _tracker.createInstance<FirstParameterContext>(_ctx, getState());\r
 619   enterRule(_localctx, 16, TocParser::RuleFirstParameter);\r
 620 \r
 621 #if __cplusplus > 201703L\r
 622   auto onExit = finally([=, this] {\r
 623 #else\r
 624   auto onExit = finally([=] {\r
 625 #endif\r
 626     exitRule();\r
 627   });\r
 628   try {\r
 629     enterOuterAlt(_localctx, 1);\r
 630     setState(120);\r
 631     var();\r
 632    \r
 633   }\r
 634   catch (RecognitionException &e) {\r
 635     _errHandler->reportError(this, e);\r
 636     _localctx->exception = std::current_exception();\r
 637     _errHandler->recover(this, _localctx->exception);\r
 638   }\r
 639 \r
 640   return _localctx;\r
 641 }\r
 642 \r
 643 //----------------- AdditionalParameterContext ------------------------------------------------------------------\r
 644 \r
 645 TocParser::AdditionalParameterContext::AdditionalParameterContext(ParserRuleContext *parent, size_t invokingState)\r
 646   : ParserRuleContext(parent, invokingState) {\r
 647 }\r
 648 \r
 649 TocParser::VarContext* TocParser::AdditionalParameterContext::var() {\r
 650   return getRuleContext<TocParser::VarContext>(0);\r
 651 }\r
 652 \r
 653 \r
 654 size_t TocParser::AdditionalParameterContext::getRuleIndex() const {\r
 655   return TocParser::RuleAdditionalParameter;\r
 656 }\r
 657 \r
 658 void TocParser::AdditionalParameterContext::enterRule(tree::ParseTreeListener *listener) {\r
 659   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 660   if (parserListener != nullptr)\r
 661     parserListener->enterAdditionalParameter(this);\r
 662 }\r
 663 \r
 664 void TocParser::AdditionalParameterContext::exitRule(tree::ParseTreeListener *listener) {\r
 665   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 666   if (parserListener != nullptr)\r
 667     parserListener->exitAdditionalParameter(this);\r
 668 }\r
 669 \r
 670 TocParser::AdditionalParameterContext* TocParser::additionalParameter() {\r
 671   AdditionalParameterContext *_localctx = _tracker.createInstance<AdditionalParameterContext>(_ctx, getState());\r
 672   enterRule(_localctx, 18, TocParser::RuleAdditionalParameter);\r
 673 \r
 674 #if __cplusplus > 201703L\r
 675   auto onExit = finally([=, this] {\r
 676 #else\r
 677   auto onExit = finally([=] {\r
 678 #endif\r
 679     exitRule();\r
 680   });\r
 681   try {\r
 682     enterOuterAlt(_localctx, 1);\r
 683     setState(122);\r
 684     match(TocParser::T__6);\r
 685     setState(123);\r
 686     var();\r
 687    \r
 688   }\r
 689   catch (RecognitionException &e) {\r
 690     _errHandler->reportError(this, e);\r
 691     _localctx->exception = std::current_exception();\r
 692     _errHandler->recover(this, _localctx->exception);\r
 693   }\r
 694 \r
 695   return _localctx;\r
 696 }\r
 697 \r
 698 //----------------- BodyContext ------------------------------------------------------------------\r
 699 \r
 700 TocParser::BodyContext::BodyContext(ParserRuleContext *parent, size_t invokingState)\r
 701   : ParserRuleContext(parent, invokingState) {\r
 702 }\r
 703 \r
 704 std::vector<TocParser::StmtContext *> TocParser::BodyContext::stmt() {\r
 705   return getRuleContexts<TocParser::StmtContext>();\r
 706 }\r
 707 \r
 708 TocParser::StmtContext* TocParser::BodyContext::stmt(size_t i) {\r
 709   return getRuleContext<TocParser::StmtContext>(i);\r
 710 }\r
 711 \r
 712 \r
 713 size_t TocParser::BodyContext::getRuleIndex() const {\r
 714   return TocParser::RuleBody;\r
 715 }\r
 716 \r
 717 void TocParser::BodyContext::enterRule(tree::ParseTreeListener *listener) {\r
 718   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 719   if (parserListener != nullptr)\r
 720     parserListener->enterBody(this);\r
 721 }\r
 722 \r
 723 void TocParser::BodyContext::exitRule(tree::ParseTreeListener *listener) {\r
 724   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 725   if (parserListener != nullptr)\r
 726     parserListener->exitBody(this);\r
 727 }\r
 728 \r
 729 TocParser::BodyContext* TocParser::body() {\r
 730   BodyContext *_localctx = _tracker.createInstance<BodyContext>(_ctx, getState());\r
 731   enterRule(_localctx, 20, TocParser::RuleBody);\r
 732   size_t _la = 0;\r
 733 \r
 734 #if __cplusplus > 201703L\r
 735   auto onExit = finally([=, this] {\r
 736 #else\r
 737   auto onExit = finally([=] {\r
 738 #endif\r
 739     exitRule();\r
 740   });\r
 741   try {\r
 742     enterOuterAlt(_localctx, 1);\r
 743     setState(125);\r
 744     match(TocParser::T__7);\r
 745     setState(129);\r
 746     _errHandler->sync(this);\r
 747     _la = _input->LA(1);\r
 748     while ((((_la & ~ 0x3fULL) == 0) &&\r
 749       ((1ULL << _la) & ((1ULL << TocParser::T__0)\r
 750       | (1ULL << TocParser::T__4)\r
 751       | (1ULL << TocParser::T__10)\r
 752       | (1ULL << TocParser::T__11)\r
 753       | (1ULL << TocParser::T__12)\r
 754       | (1ULL << TocParser::INTLIT)\r
 755       | (1ULL << TocParser::NAME))) != 0)) {\r
 756       setState(126);\r
 757       stmt();\r
 758       setState(131);\r
 759       _errHandler->sync(this);\r
 760       _la = _input->LA(1);\r
 761     }\r
 762     setState(132);\r
 763     match(TocParser::T__8);\r
 764    \r
 765   }\r
 766   catch (RecognitionException &e) {\r
 767     _errHandler->reportError(this, e);\r
 768     _localctx->exception = std::current_exception();\r
 769     _errHandler->recover(this, _localctx->exception);\r
 770   }\r
 771 \r
 772   return _localctx;\r
 773 }\r
 774 \r
 775 //----------------- StructDeclContext ------------------------------------------------------------------\r
 776 \r
 777 TocParser::StructDeclContext::StructDeclContext(ParserRuleContext *parent, size_t invokingState)\r
 778   : ParserRuleContext(parent, invokingState) {\r
 779 }\r
 780 \r
 781 TocParser::StructNameContext* TocParser::StructDeclContext::structName() {\r
 782   return getRuleContext<TocParser::StructNameContext>(0);\r
 783 }\r
 784 \r
 785 std::vector<TocParser::StructMemberContext *> TocParser::StructDeclContext::structMember() {\r
 786   return getRuleContexts<TocParser::StructMemberContext>();\r
 787 }\r
 788 \r
 789 TocParser::StructMemberContext* TocParser::StructDeclContext::structMember(size_t i) {\r
 790   return getRuleContext<TocParser::StructMemberContext>(i);\r
 791 }\r
 792 \r
 793 \r
 794 size_t TocParser::StructDeclContext::getRuleIndex() const {\r
 795   return TocParser::RuleStructDecl;\r
 796 }\r
 797 \r
 798 void TocParser::StructDeclContext::enterRule(tree::ParseTreeListener *listener) {\r
 799   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 800   if (parserListener != nullptr)\r
 801     parserListener->enterStructDecl(this);\r
 802 }\r
 803 \r
 804 void TocParser::StructDeclContext::exitRule(tree::ParseTreeListener *listener) {\r
 805   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 806   if (parserListener != nullptr)\r
 807     parserListener->exitStructDecl(this);\r
 808 }\r
 809 \r
 810 TocParser::StructDeclContext* TocParser::structDecl() {\r
 811   StructDeclContext *_localctx = _tracker.createInstance<StructDeclContext>(_ctx, getState());\r
 812   enterRule(_localctx, 22, TocParser::RuleStructDecl);\r
 813   size_t _la = 0;\r
 814 \r
 815 #if __cplusplus > 201703L\r
 816   auto onExit = finally([=, this] {\r
 817 #else\r
 818   auto onExit = finally([=] {\r
 819 #endif\r
 820     exitRule();\r
 821   });\r
 822   try {\r
 823     enterOuterAlt(_localctx, 1);\r
 824     setState(134);\r
 825     match(TocParser::T__9);\r
 826     setState(135);\r
 827     structName();\r
 828     setState(136);\r
 829     match(TocParser::T__7);\r
 830     setState(140);\r
 831     _errHandler->sync(this);\r
 832     _la = _input->LA(1);\r
 833     while (_la == TocParser::NAME) {\r
 834       setState(137);\r
 835       structMember();\r
 836       setState(142);\r
 837       _errHandler->sync(this);\r
 838       _la = _input->LA(1);\r
 839     }\r
 840     setState(143);\r
 841     match(TocParser::T__8);\r
 842    \r
 843   }\r
 844   catch (RecognitionException &e) {\r
 845     _errHandler->reportError(this, e);\r
 846     _localctx->exception = std::current_exception();\r
 847     _errHandler->recover(this, _localctx->exception);\r
 848   }\r
 849 \r
 850   return _localctx;\r
 851 }\r
 852 \r
 853 //----------------- StructMemberContext ------------------------------------------------------------------\r
 854 \r
 855 TocParser::StructMemberContext::StructMemberContext(ParserRuleContext *parent, size_t invokingState)\r
 856   : ParserRuleContext(parent, invokingState) {\r
 857 }\r
 858 \r
 859 TocParser::StructVarContext* TocParser::StructMemberContext::structVar() {\r
 860   return getRuleContext<TocParser::StructVarContext>(0);\r
 861 }\r
 862 \r
 863 TocParser::StructMethodContext* TocParser::StructMemberContext::structMethod() {\r
 864   return getRuleContext<TocParser::StructMethodContext>(0);\r
 865 }\r
 866 \r
 867 \r
 868 size_t TocParser::StructMemberContext::getRuleIndex() const {\r
 869   return TocParser::RuleStructMember;\r
 870 }\r
 871 \r
 872 void TocParser::StructMemberContext::enterRule(tree::ParseTreeListener *listener) {\r
 873   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 874   if (parserListener != nullptr)\r
 875     parserListener->enterStructMember(this);\r
 876 }\r
 877 \r
 878 void TocParser::StructMemberContext::exitRule(tree::ParseTreeListener *listener) {\r
 879   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 880   if (parserListener != nullptr)\r
 881     parserListener->exitStructMember(this);\r
 882 }\r
 883 \r
 884 TocParser::StructMemberContext* TocParser::structMember() {\r
 885   StructMemberContext *_localctx = _tracker.createInstance<StructMemberContext>(_ctx, getState());\r
 886   enterRule(_localctx, 24, TocParser::RuleStructMember);\r
 887 \r
 888 #if __cplusplus > 201703L\r
 889   auto onExit = finally([=, this] {\r
 890 #else\r
 891   auto onExit = finally([=] {\r
 892 #endif\r
 893     exitRule();\r
 894   });\r
 895   try {\r
 896     setState(147);\r
 897     _errHandler->sync(this);\r
 898     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {\r
 899     case 1: {\r
 900       enterOuterAlt(_localctx, 1);\r
 901       setState(145);\r
 902       structVar();\r
 903       break;\r
 904     }\r
 905 \r
 906     case 2: {\r
 907       enterOuterAlt(_localctx, 2);\r
 908       setState(146);\r
 909       structMethod();\r
 910       break;\r
 911     }\r
 912 \r
 913     default:\r
 914       break;\r
 915     }\r
 916    \r
 917   }\r
 918   catch (RecognitionException &e) {\r
 919     _errHandler->reportError(this, e);\r
 920     _localctx->exception = std::current_exception();\r
 921     _errHandler->recover(this, _localctx->exception);\r
 922   }\r
 923 \r
 924   return _localctx;\r
 925 }\r
 926 \r
 927 //----------------- StructVarContext ------------------------------------------------------------------\r
 928 \r
 929 TocParser::StructVarContext::StructVarContext(ParserRuleContext *parent, size_t invokingState)\r
 930   : ParserRuleContext(parent, invokingState) {\r
 931 }\r
 932 \r
 933 TocParser::VarContext* TocParser::StructVarContext::var() {\r
 934   return getRuleContext<TocParser::VarContext>(0);\r
 935 }\r
 936 \r
 937 \r
 938 size_t TocParser::StructVarContext::getRuleIndex() const {\r
 939   return TocParser::RuleStructVar;\r
 940 }\r
 941 \r
 942 void TocParser::StructVarContext::enterRule(tree::ParseTreeListener *listener) {\r
 943   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 944   if (parserListener != nullptr)\r
 945     parserListener->enterStructVar(this);\r
 946 }\r
 947 \r
 948 void TocParser::StructVarContext::exitRule(tree::ParseTreeListener *listener) {\r
 949   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 950   if (parserListener != nullptr)\r
 951     parserListener->exitStructVar(this);\r
 952 }\r
 953 \r
 954 TocParser::StructVarContext* TocParser::structVar() {\r
 955   StructVarContext *_localctx = _tracker.createInstance<StructVarContext>(_ctx, getState());\r
 956   enterRule(_localctx, 26, TocParser::RuleStructVar);\r
 957 \r
 958 #if __cplusplus > 201703L\r
 959   auto onExit = finally([=, this] {\r
 960 #else\r
 961   auto onExit = finally([=] {\r
 962 #endif\r
 963     exitRule();\r
 964   });\r
 965   try {\r
 966     enterOuterAlt(_localctx, 1);\r
 967     setState(149);\r
 968     var();\r
 969    \r
 970   }\r
 971   catch (RecognitionException &e) {\r
 972     _errHandler->reportError(this, e);\r
 973     _localctx->exception = std::current_exception();\r
 974     _errHandler->recover(this, _localctx->exception);\r
 975   }\r
 976 \r
 977   return _localctx;\r
 978 }\r
 979 \r
 980 //----------------- StructMethodContext ------------------------------------------------------------------\r
 981 \r
 982 TocParser::StructMethodContext::StructMethodContext(ParserRuleContext *parent, size_t invokingState)\r
 983   : ParserRuleContext(parent, invokingState) {\r
 984 }\r
 985 \r
 986 TocParser::FuncContext* TocParser::StructMethodContext::func() {\r
 987   return getRuleContext<TocParser::FuncContext>(0);\r
 988 }\r
 989 \r
 990 \r
 991 size_t TocParser::StructMethodContext::getRuleIndex() const {\r
 992   return TocParser::RuleStructMethod;\r
 993 }\r
 994 \r
 995 void TocParser::StructMethodContext::enterRule(tree::ParseTreeListener *listener) {\r
 996   auto parserListener = dynamic_cast<TocListener *>(listener);\r
 997   if (parserListener != nullptr)\r
 998     parserListener->enterStructMethod(this);\r
 999 }\r
1000 \r
1001 void TocParser::StructMethodContext::exitRule(tree::ParseTreeListener *listener) {\r
1002   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1003   if (parserListener != nullptr)\r
1004     parserListener->exitStructMethod(this);\r
1005 }\r
1006 \r
1007 TocParser::StructMethodContext* TocParser::structMethod() {\r
1008   StructMethodContext *_localctx = _tracker.createInstance<StructMethodContext>(_ctx, getState());\r
1009   enterRule(_localctx, 28, TocParser::RuleStructMethod);\r
1010 \r
1011 #if __cplusplus > 201703L\r
1012   auto onExit = finally([=, this] {\r
1013 #else\r
1014   auto onExit = finally([=] {\r
1015 #endif\r
1016     exitRule();\r
1017   });\r
1018   try {\r
1019     enterOuterAlt(_localctx, 1);\r
1020     setState(151);\r
1021     func();\r
1022    \r
1023   }\r
1024   catch (RecognitionException &e) {\r
1025     _errHandler->reportError(this, e);\r
1026     _localctx->exception = std::current_exception();\r
1027     _errHandler->recover(this, _localctx->exception);\r
1028   }\r
1029 \r
1030   return _localctx;\r
1031 }\r
1032 \r
1033 //----------------- StmtContext ------------------------------------------------------------------\r
1034 \r
1035 TocParser::StmtContext::StmtContext(ParserRuleContext *parent, size_t invokingState)\r
1036   : ParserRuleContext(parent, invokingState) {\r
1037 }\r
1038 \r
1039 TocParser::VarDeclContext* TocParser::StmtContext::varDecl() {\r
1040   return getRuleContext<TocParser::VarDeclContext>(0);\r
1041 }\r
1042 \r
1043 TocParser::ConditionalContext* TocParser::StmtContext::conditional() {\r
1044   return getRuleContext<TocParser::ConditionalContext>(0);\r
1045 }\r
1046 \r
1047 TocParser::LoopContext* TocParser::StmtContext::loop() {\r
1048   return getRuleContext<TocParser::LoopContext>(0);\r
1049 }\r
1050 \r
1051 TocParser::AssignmentContext* TocParser::StmtContext::assignment() {\r
1052   return getRuleContext<TocParser::AssignmentContext>(0);\r
1053 }\r
1054 \r
1055 TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() {\r
1056   return getRuleContext<TocParser::ReturnStmtContext>(0);\r
1057 }\r
1058 \r
1059 TocParser::ExprContext* TocParser::StmtContext::expr() {\r
1060   return getRuleContext<TocParser::ExprContext>(0);\r
1061 }\r
1062 \r
1063 \r
1064 size_t TocParser::StmtContext::getRuleIndex() const {\r
1065   return TocParser::RuleStmt;\r
1066 }\r
1067 \r
1068 void TocParser::StmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1069   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1070   if (parserListener != nullptr)\r
1071     parserListener->enterStmt(this);\r
1072 }\r
1073 \r
1074 void TocParser::StmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1075   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1076   if (parserListener != nullptr)\r
1077     parserListener->exitStmt(this);\r
1078 }\r
1079 \r
1080 TocParser::StmtContext* TocParser::stmt() {\r
1081   StmtContext *_localctx = _tracker.createInstance<StmtContext>(_ctx, getState());\r
1082   enterRule(_localctx, 30, TocParser::RuleStmt);\r
1083 \r
1084 #if __cplusplus > 201703L\r
1085   auto onExit = finally([=, this] {\r
1086 #else\r
1087   auto onExit = finally([=] {\r
1088 #endif\r
1089     exitRule();\r
1090   });\r
1091   try {\r
1092     enterOuterAlt(_localctx, 1);\r
1093     setState(159);\r
1094     _errHandler->sync(this);\r
1095     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx)) {\r
1096     case 1: {\r
1097       setState(153);\r
1098       varDecl();\r
1099       break;\r
1100     }\r
1101 \r
1102     case 2: {\r
1103       setState(154);\r
1104       conditional();\r
1105       break;\r
1106     }\r
1107 \r
1108     case 3: {\r
1109       setState(155);\r
1110       loop();\r
1111       break;\r
1112     }\r
1113 \r
1114     case 4: {\r
1115       setState(156);\r
1116       assignment();\r
1117       break;\r
1118     }\r
1119 \r
1120     case 5: {\r
1121       setState(157);\r
1122       returnStmt();\r
1123       break;\r
1124     }\r
1125 \r
1126     case 6: {\r
1127       setState(158);\r
1128       expr();\r
1129       break;\r
1130     }\r
1131 \r
1132     default:\r
1133       break;\r
1134     }\r
1135    \r
1136   }\r
1137   catch (RecognitionException &e) {\r
1138     _errHandler->reportError(this, e);\r
1139     _localctx->exception = std::current_exception();\r
1140     _errHandler->recover(this, _localctx->exception);\r
1141   }\r
1142 \r
1143   return _localctx;\r
1144 }\r
1145 \r
1146 //----------------- ConditionalContext ------------------------------------------------------------------\r
1147 \r
1148 TocParser::ConditionalContext::ConditionalContext(ParserRuleContext *parent, size_t invokingState)\r
1149   : ParserRuleContext(parent, invokingState) {\r
1150 }\r
1151 \r
1152 TocParser::IfCondContext* TocParser::ConditionalContext::ifCond() {\r
1153   return getRuleContext<TocParser::IfCondContext>(0);\r
1154 }\r
1155 \r
1156 \r
1157 size_t TocParser::ConditionalContext::getRuleIndex() const {\r
1158   return TocParser::RuleConditional;\r
1159 }\r
1160 \r
1161 void TocParser::ConditionalContext::enterRule(tree::ParseTreeListener *listener) {\r
1162   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1163   if (parserListener != nullptr)\r
1164     parserListener->enterConditional(this);\r
1165 }\r
1166 \r
1167 void TocParser::ConditionalContext::exitRule(tree::ParseTreeListener *listener) {\r
1168   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1169   if (parserListener != nullptr)\r
1170     parserListener->exitConditional(this);\r
1171 }\r
1172 \r
1173 TocParser::ConditionalContext* TocParser::conditional() {\r
1174   ConditionalContext *_localctx = _tracker.createInstance<ConditionalContext>(_ctx, getState());\r
1175   enterRule(_localctx, 32, TocParser::RuleConditional);\r
1176 \r
1177 #if __cplusplus > 201703L\r
1178   auto onExit = finally([=, this] {\r
1179 #else\r
1180   auto onExit = finally([=] {\r
1181 #endif\r
1182     exitRule();\r
1183   });\r
1184   try {\r
1185     enterOuterAlt(_localctx, 1);\r
1186     setState(161);\r
1187     ifCond();\r
1188    \r
1189   }\r
1190   catch (RecognitionException &e) {\r
1191     _errHandler->reportError(this, e);\r
1192     _localctx->exception = std::current_exception();\r
1193     _errHandler->recover(this, _localctx->exception);\r
1194   }\r
1195 \r
1196   return _localctx;\r
1197 }\r
1198 \r
1199 //----------------- IfCondContext ------------------------------------------------------------------\r
1200 \r
1201 TocParser::IfCondContext::IfCondContext(ParserRuleContext *parent, size_t invokingState)\r
1202   : ParserRuleContext(parent, invokingState) {\r
1203 }\r
1204 \r
1205 TocParser::ExprContext* TocParser::IfCondContext::expr() {\r
1206   return getRuleContext<TocParser::ExprContext>(0);\r
1207 }\r
1208 \r
1209 TocParser::BodyContext* TocParser::IfCondContext::body() {\r
1210   return getRuleContext<TocParser::BodyContext>(0);\r
1211 }\r
1212 \r
1213 \r
1214 size_t TocParser::IfCondContext::getRuleIndex() const {\r
1215   return TocParser::RuleIfCond;\r
1216 }\r
1217 \r
1218 void TocParser::IfCondContext::enterRule(tree::ParseTreeListener *listener) {\r
1219   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1220   if (parserListener != nullptr)\r
1221     parserListener->enterIfCond(this);\r
1222 }\r
1223 \r
1224 void TocParser::IfCondContext::exitRule(tree::ParseTreeListener *listener) {\r
1225   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1226   if (parserListener != nullptr)\r
1227     parserListener->exitIfCond(this);\r
1228 }\r
1229 \r
1230 TocParser::IfCondContext* TocParser::ifCond() {\r
1231   IfCondContext *_localctx = _tracker.createInstance<IfCondContext>(_ctx, getState());\r
1232   enterRule(_localctx, 34, TocParser::RuleIfCond);\r
1233 \r
1234 #if __cplusplus > 201703L\r
1235   auto onExit = finally([=, this] {\r
1236 #else\r
1237   auto onExit = finally([=] {\r
1238 #endif\r
1239     exitRule();\r
1240   });\r
1241   try {\r
1242     enterOuterAlt(_localctx, 1);\r
1243     setState(163);\r
1244     match(TocParser::T__10);\r
1245     setState(164);\r
1246     expr();\r
1247     setState(165);\r
1248     body();\r
1249    \r
1250   }\r
1251   catch (RecognitionException &e) {\r
1252     _errHandler->reportError(this, e);\r
1253     _localctx->exception = std::current_exception();\r
1254     _errHandler->recover(this, _localctx->exception);\r
1255   }\r
1256 \r
1257   return _localctx;\r
1258 }\r
1259 \r
1260 //----------------- LoopContext ------------------------------------------------------------------\r
1261 \r
1262 TocParser::LoopContext::LoopContext(ParserRuleContext *parent, size_t invokingState)\r
1263   : ParserRuleContext(parent, invokingState) {\r
1264 }\r
1265 \r
1266 TocParser::WhileLoopContext* TocParser::LoopContext::whileLoop() {\r
1267   return getRuleContext<TocParser::WhileLoopContext>(0);\r
1268 }\r
1269 \r
1270 \r
1271 size_t TocParser::LoopContext::getRuleIndex() const {\r
1272   return TocParser::RuleLoop;\r
1273 }\r
1274 \r
1275 void TocParser::LoopContext::enterRule(tree::ParseTreeListener *listener) {\r
1276   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1277   if (parserListener != nullptr)\r
1278     parserListener->enterLoop(this);\r
1279 }\r
1280 \r
1281 void TocParser::LoopContext::exitRule(tree::ParseTreeListener *listener) {\r
1282   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1283   if (parserListener != nullptr)\r
1284     parserListener->exitLoop(this);\r
1285 }\r
1286 \r
1287 TocParser::LoopContext* TocParser::loop() {\r
1288   LoopContext *_localctx = _tracker.createInstance<LoopContext>(_ctx, getState());\r
1289   enterRule(_localctx, 36, TocParser::RuleLoop);\r
1290 \r
1291 #if __cplusplus > 201703L\r
1292   auto onExit = finally([=, this] {\r
1293 #else\r
1294   auto onExit = finally([=] {\r
1295 #endif\r
1296     exitRule();\r
1297   });\r
1298   try {\r
1299     enterOuterAlt(_localctx, 1);\r
1300     setState(167);\r
1301     whileLoop();\r
1302    \r
1303   }\r
1304   catch (RecognitionException &e) {\r
1305     _errHandler->reportError(this, e);\r
1306     _localctx->exception = std::current_exception();\r
1307     _errHandler->recover(this, _localctx->exception);\r
1308   }\r
1309 \r
1310   return _localctx;\r
1311 }\r
1312 \r
1313 //----------------- WhileLoopContext ------------------------------------------------------------------\r
1314 \r
1315 TocParser::WhileLoopContext::WhileLoopContext(ParserRuleContext *parent, size_t invokingState)\r
1316   : ParserRuleContext(parent, invokingState) {\r
1317 }\r
1318 \r
1319 TocParser::ExprContext* TocParser::WhileLoopContext::expr() {\r
1320   return getRuleContext<TocParser::ExprContext>(0);\r
1321 }\r
1322 \r
1323 TocParser::BodyContext* TocParser::WhileLoopContext::body() {\r
1324   return getRuleContext<TocParser::BodyContext>(0);\r
1325 }\r
1326 \r
1327 \r
1328 size_t TocParser::WhileLoopContext::getRuleIndex() const {\r
1329   return TocParser::RuleWhileLoop;\r
1330 }\r
1331 \r
1332 void TocParser::WhileLoopContext::enterRule(tree::ParseTreeListener *listener) {\r
1333   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1334   if (parserListener != nullptr)\r
1335     parserListener->enterWhileLoop(this);\r
1336 }\r
1337 \r
1338 void TocParser::WhileLoopContext::exitRule(tree::ParseTreeListener *listener) {\r
1339   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1340   if (parserListener != nullptr)\r
1341     parserListener->exitWhileLoop(this);\r
1342 }\r
1343 \r
1344 TocParser::WhileLoopContext* TocParser::whileLoop() {\r
1345   WhileLoopContext *_localctx = _tracker.createInstance<WhileLoopContext>(_ctx, getState());\r
1346   enterRule(_localctx, 38, TocParser::RuleWhileLoop);\r
1347 \r
1348 #if __cplusplus > 201703L\r
1349   auto onExit = finally([=, this] {\r
1350 #else\r
1351   auto onExit = finally([=] {\r
1352 #endif\r
1353     exitRule();\r
1354   });\r
1355   try {\r
1356     enterOuterAlt(_localctx, 1);\r
1357     setState(169);\r
1358     match(TocParser::T__11);\r
1359     setState(170);\r
1360     expr();\r
1361     setState(171);\r
1362     body();\r
1363    \r
1364   }\r
1365   catch (RecognitionException &e) {\r
1366     _errHandler->reportError(this, e);\r
1367     _localctx->exception = std::current_exception();\r
1368     _errHandler->recover(this, _localctx->exception);\r
1369   }\r
1370 \r
1371   return _localctx;\r
1372 }\r
1373 \r
1374 //----------------- AssignmentContext ------------------------------------------------------------------\r
1375 \r
1376 TocParser::AssignmentContext::AssignmentContext(ParserRuleContext *parent, size_t invokingState)\r
1377   : ParserRuleContext(parent, invokingState) {\r
1378 }\r
1379 \r
1380 TocParser::IdentifierContext* TocParser::AssignmentContext::identifier() {\r
1381   return getRuleContext<TocParser::IdentifierContext>(0);\r
1382 }\r
1383 \r
1384 TocParser::ExprContext* TocParser::AssignmentContext::expr() {\r
1385   return getRuleContext<TocParser::ExprContext>(0);\r
1386 }\r
1387 \r
1388 \r
1389 size_t TocParser::AssignmentContext::getRuleIndex() const {\r
1390   return TocParser::RuleAssignment;\r
1391 }\r
1392 \r
1393 void TocParser::AssignmentContext::enterRule(tree::ParseTreeListener *listener) {\r
1394   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1395   if (parserListener != nullptr)\r
1396     parserListener->enterAssignment(this);\r
1397 }\r
1398 \r
1399 void TocParser::AssignmentContext::exitRule(tree::ParseTreeListener *listener) {\r
1400   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1401   if (parserListener != nullptr)\r
1402     parserListener->exitAssignment(this);\r
1403 }\r
1404 \r
1405 TocParser::AssignmentContext* TocParser::assignment() {\r
1406   AssignmentContext *_localctx = _tracker.createInstance<AssignmentContext>(_ctx, getState());\r
1407   enterRule(_localctx, 40, TocParser::RuleAssignment);\r
1408 \r
1409 #if __cplusplus > 201703L\r
1410   auto onExit = finally([=, this] {\r
1411 #else\r
1412   auto onExit = finally([=] {\r
1413 #endif\r
1414     exitRule();\r
1415   });\r
1416   try {\r
1417     enterOuterAlt(_localctx, 1);\r
1418     setState(173);\r
1419     identifier();\r
1420     setState(174);\r
1421     match(TocParser::T__2);\r
1422     setState(175);\r
1423     expr();\r
1424    \r
1425   }\r
1426   catch (RecognitionException &e) {\r
1427     _errHandler->reportError(this, e);\r
1428     _localctx->exception = std::current_exception();\r
1429     _errHandler->recover(this, _localctx->exception);\r
1430   }\r
1431 \r
1432   return _localctx;\r
1433 }\r
1434 \r
1435 //----------------- ReturnStmtContext ------------------------------------------------------------------\r
1436 \r
1437 TocParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1438   : ParserRuleContext(parent, invokingState) {\r
1439 }\r
1440 \r
1441 TocParser::ExprContext* TocParser::ReturnStmtContext::expr() {\r
1442   return getRuleContext<TocParser::ExprContext>(0);\r
1443 }\r
1444 \r
1445 \r
1446 size_t TocParser::ReturnStmtContext::getRuleIndex() const {\r
1447   return TocParser::RuleReturnStmt;\r
1448 }\r
1449 \r
1450 void TocParser::ReturnStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
1451   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1452   if (parserListener != nullptr)\r
1453     parserListener->enterReturnStmt(this);\r
1454 }\r
1455 \r
1456 void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
1457   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1458   if (parserListener != nullptr)\r
1459     parserListener->exitReturnStmt(this);\r
1460 }\r
1461 \r
1462 TocParser::ReturnStmtContext* TocParser::returnStmt() {\r
1463   ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());\r
1464   enterRule(_localctx, 42, TocParser::RuleReturnStmt);\r
1465 \r
1466 #if __cplusplus > 201703L\r
1467   auto onExit = finally([=, this] {\r
1468 #else\r
1469   auto onExit = finally([=] {\r
1470 #endif\r
1471     exitRule();\r
1472   });\r
1473   try {\r
1474     enterOuterAlt(_localctx, 1);\r
1475     setState(177);\r
1476     match(TocParser::T__12);\r
1477     setState(178);\r
1478     expr();\r
1479    \r
1480   }\r
1481   catch (RecognitionException &e) {\r
1482     _errHandler->reportError(this, e);\r
1483     _localctx->exception = std::current_exception();\r
1484     _errHandler->recover(this, _localctx->exception);\r
1485   }\r
1486 \r
1487   return _localctx;\r
1488 }\r
1489 \r
1490 //----------------- ExprContext ------------------------------------------------------------------\r
1491 \r
1492 TocParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState)\r
1493   : ParserRuleContext(parent, invokingState) {\r
1494 }\r
1495 \r
1496 TocParser::FuncCallContext* TocParser::ExprContext::funcCall() {\r
1497   return getRuleContext<TocParser::FuncCallContext>(0);\r
1498 }\r
1499 \r
1500 TocParser::LiteralContext* TocParser::ExprContext::literal() {\r
1501   return getRuleContext<TocParser::LiteralContext>(0);\r
1502 }\r
1503 \r
1504 TocParser::IdentifierContext* TocParser::ExprContext::identifier() {\r
1505   return getRuleContext<TocParser::IdentifierContext>(0);\r
1506 }\r
1507 \r
1508 TocParser::SubscriptContext* TocParser::ExprContext::subscript() {\r
1509   return getRuleContext<TocParser::SubscriptContext>(0);\r
1510 }\r
1511 \r
1512 TocParser::MemberAccessContext* TocParser::ExprContext::memberAccess() {\r
1513   return getRuleContext<TocParser::MemberAccessContext>(0);\r
1514 }\r
1515 \r
1516 TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() {\r
1517   return getRuleContext<TocParser::ParenExprContext>(0);\r
1518 }\r
1519 \r
1520 TocParser::OperatorExprContext* TocParser::ExprContext::operatorExpr() {\r
1521   return getRuleContext<TocParser::OperatorExprContext>(0);\r
1522 }\r
1523 \r
1524 \r
1525 size_t TocParser::ExprContext::getRuleIndex() const {\r
1526   return TocParser::RuleExpr;\r
1527 }\r
1528 \r
1529 void TocParser::ExprContext::enterRule(tree::ParseTreeListener *listener) {\r
1530   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1531   if (parserListener != nullptr)\r
1532     parserListener->enterExpr(this);\r
1533 }\r
1534 \r
1535 void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) {\r
1536   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1537   if (parserListener != nullptr)\r
1538     parserListener->exitExpr(this);\r
1539 }\r
1540 \r
1541 TocParser::ExprContext* TocParser::expr() {\r
1542   ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());\r
1543   enterRule(_localctx, 44, TocParser::RuleExpr);\r
1544 \r
1545 #if __cplusplus > 201703L\r
1546   auto onExit = finally([=, this] {\r
1547 #else\r
1548   auto onExit = finally([=] {\r
1549 #endif\r
1550     exitRule();\r
1551   });\r
1552   try {\r
1553     setState(187);\r
1554     _errHandler->sync(this);\r
1555     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {\r
1556     case 1: {\r
1557       enterOuterAlt(_localctx, 1);\r
1558       setState(180);\r
1559       funcCall();\r
1560       break;\r
1561     }\r
1562 \r
1563     case 2: {\r
1564       enterOuterAlt(_localctx, 2);\r
1565       setState(181);\r
1566       literal();\r
1567       break;\r
1568     }\r
1569 \r
1570     case 3: {\r
1571       enterOuterAlt(_localctx, 3);\r
1572       setState(182);\r
1573       identifier();\r
1574       break;\r
1575     }\r
1576 \r
1577     case 4: {\r
1578       enterOuterAlt(_localctx, 4);\r
1579       setState(183);\r
1580       subscript();\r
1581       break;\r
1582     }\r
1583 \r
1584     case 5: {\r
1585       enterOuterAlt(_localctx, 5);\r
1586       setState(184);\r
1587       memberAccess();\r
1588       break;\r
1589     }\r
1590 \r
1591     case 6: {\r
1592       enterOuterAlt(_localctx, 6);\r
1593       setState(185);\r
1594       parenExpr();\r
1595       break;\r
1596     }\r
1597 \r
1598     case 7: {\r
1599       enterOuterAlt(_localctx, 7);\r
1600       setState(186);\r
1601       operatorExpr();\r
1602       break;\r
1603     }\r
1604 \r
1605     default:\r
1606       break;\r
1607     }\r
1608    \r
1609   }\r
1610   catch (RecognitionException &e) {\r
1611     _errHandler->reportError(this, e);\r
1612     _localctx->exception = std::current_exception();\r
1613     _errHandler->recover(this, _localctx->exception);\r
1614   }\r
1615 \r
1616   return _localctx;\r
1617 }\r
1618 \r
1619 //----------------- NonOpExprContext ------------------------------------------------------------------\r
1620 \r
1621 TocParser::NonOpExprContext::NonOpExprContext(ParserRuleContext *parent, size_t invokingState)\r
1622   : ParserRuleContext(parent, invokingState) {\r
1623 }\r
1624 \r
1625 TocParser::FuncCallContext* TocParser::NonOpExprContext::funcCall() {\r
1626   return getRuleContext<TocParser::FuncCallContext>(0);\r
1627 }\r
1628 \r
1629 TocParser::LiteralContext* TocParser::NonOpExprContext::literal() {\r
1630   return getRuleContext<TocParser::LiteralContext>(0);\r
1631 }\r
1632 \r
1633 TocParser::IdentifierContext* TocParser::NonOpExprContext::identifier() {\r
1634   return getRuleContext<TocParser::IdentifierContext>(0);\r
1635 }\r
1636 \r
1637 TocParser::SubscriptContext* TocParser::NonOpExprContext::subscript() {\r
1638   return getRuleContext<TocParser::SubscriptContext>(0);\r
1639 }\r
1640 \r
1641 TocParser::MemberAccessContext* TocParser::NonOpExprContext::memberAccess() {\r
1642   return getRuleContext<TocParser::MemberAccessContext>(0);\r
1643 }\r
1644 \r
1645 TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() {\r
1646   return getRuleContext<TocParser::ParenExprContext>(0);\r
1647 }\r
1648 \r
1649 \r
1650 size_t TocParser::NonOpExprContext::getRuleIndex() const {\r
1651   return TocParser::RuleNonOpExpr;\r
1652 }\r
1653 \r
1654 void TocParser::NonOpExprContext::enterRule(tree::ParseTreeListener *listener) {\r
1655   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1656   if (parserListener != nullptr)\r
1657     parserListener->enterNonOpExpr(this);\r
1658 }\r
1659 \r
1660 void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) {\r
1661   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1662   if (parserListener != nullptr)\r
1663     parserListener->exitNonOpExpr(this);\r
1664 }\r
1665 \r
1666 TocParser::NonOpExprContext* TocParser::nonOpExpr() {\r
1667   NonOpExprContext *_localctx = _tracker.createInstance<NonOpExprContext>(_ctx, getState());\r
1668   enterRule(_localctx, 46, TocParser::RuleNonOpExpr);\r
1669 \r
1670 #if __cplusplus > 201703L\r
1671   auto onExit = finally([=, this] {\r
1672 #else\r
1673   auto onExit = finally([=] {\r
1674 #endif\r
1675     exitRule();\r
1676   });\r
1677   try {\r
1678     setState(195);\r
1679     _errHandler->sync(this);\r
1680     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {\r
1681     case 1: {\r
1682       enterOuterAlt(_localctx, 1);\r
1683       setState(189);\r
1684       funcCall();\r
1685       break;\r
1686     }\r
1687 \r
1688     case 2: {\r
1689       enterOuterAlt(_localctx, 2);\r
1690       setState(190);\r
1691       literal();\r
1692       break;\r
1693     }\r
1694 \r
1695     case 3: {\r
1696       enterOuterAlt(_localctx, 3);\r
1697       setState(191);\r
1698       identifier();\r
1699       break;\r
1700     }\r
1701 \r
1702     case 4: {\r
1703       enterOuterAlt(_localctx, 4);\r
1704       setState(192);\r
1705       subscript();\r
1706       break;\r
1707     }\r
1708 \r
1709     case 5: {\r
1710       enterOuterAlt(_localctx, 5);\r
1711       setState(193);\r
1712       memberAccess();\r
1713       break;\r
1714     }\r
1715 \r
1716     case 6: {\r
1717       enterOuterAlt(_localctx, 6);\r
1718       setState(194);\r
1719       parenExpr();\r
1720       break;\r
1721     }\r
1722 \r
1723     default:\r
1724       break;\r
1725     }\r
1726    \r
1727   }\r
1728   catch (RecognitionException &e) {\r
1729     _errHandler->reportError(this, e);\r
1730     _localctx->exception = std::current_exception();\r
1731     _errHandler->recover(this, _localctx->exception);\r
1732   }\r
1733 \r
1734   return _localctx;\r
1735 }\r
1736 \r
1737 //----------------- NonSubscriptExprContext ------------------------------------------------------------------\r
1738 \r
1739 TocParser::NonSubscriptExprContext::NonSubscriptExprContext(ParserRuleContext *parent, size_t invokingState)\r
1740   : ParserRuleContext(parent, invokingState) {\r
1741 }\r
1742 \r
1743 TocParser::FuncCallContext* TocParser::NonSubscriptExprContext::funcCall() {\r
1744   return getRuleContext<TocParser::FuncCallContext>(0);\r
1745 }\r
1746 \r
1747 TocParser::IdentifierContext* TocParser::NonSubscriptExprContext::identifier() {\r
1748   return getRuleContext<TocParser::IdentifierContext>(0);\r
1749 }\r
1750 \r
1751 TocParser::MemberAccessContext* TocParser::NonSubscriptExprContext::memberAccess() {\r
1752   return getRuleContext<TocParser::MemberAccessContext>(0);\r
1753 }\r
1754 \r
1755 TocParser::ParenExprContext* TocParser::NonSubscriptExprContext::parenExpr() {\r
1756   return getRuleContext<TocParser::ParenExprContext>(0);\r
1757 }\r
1758 \r
1759 \r
1760 size_t TocParser::NonSubscriptExprContext::getRuleIndex() const {\r
1761   return TocParser::RuleNonSubscriptExpr;\r
1762 }\r
1763 \r
1764 void TocParser::NonSubscriptExprContext::enterRule(tree::ParseTreeListener *listener) {\r
1765   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1766   if (parserListener != nullptr)\r
1767     parserListener->enterNonSubscriptExpr(this);\r
1768 }\r
1769 \r
1770 void TocParser::NonSubscriptExprContext::exitRule(tree::ParseTreeListener *listener) {\r
1771   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1772   if (parserListener != nullptr)\r
1773     parserListener->exitNonSubscriptExpr(this);\r
1774 }\r
1775 \r
1776 TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() {\r
1777   NonSubscriptExprContext *_localctx = _tracker.createInstance<NonSubscriptExprContext>(_ctx, getState());\r
1778   enterRule(_localctx, 48, TocParser::RuleNonSubscriptExpr);\r
1779 \r
1780 #if __cplusplus > 201703L\r
1781   auto onExit = finally([=, this] {\r
1782 #else\r
1783   auto onExit = finally([=] {\r
1784 #endif\r
1785     exitRule();\r
1786   });\r
1787   try {\r
1788     setState(201);\r
1789     _errHandler->sync(this);\r
1790     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx)) {\r
1791     case 1: {\r
1792       enterOuterAlt(_localctx, 1);\r
1793       setState(197);\r
1794       funcCall();\r
1795       break;\r
1796     }\r
1797 \r
1798     case 2: {\r
1799       enterOuterAlt(_localctx, 2);\r
1800       setState(198);\r
1801       identifier();\r
1802       break;\r
1803     }\r
1804 \r
1805     case 3: {\r
1806       enterOuterAlt(_localctx, 3);\r
1807       setState(199);\r
1808       memberAccess();\r
1809       break;\r
1810     }\r
1811 \r
1812     case 4: {\r
1813       enterOuterAlt(_localctx, 4);\r
1814       setState(200);\r
1815       parenExpr();\r
1816       break;\r
1817     }\r
1818 \r
1819     default:\r
1820       break;\r
1821     }\r
1822    \r
1823   }\r
1824   catch (RecognitionException &e) {\r
1825     _errHandler->reportError(this, e);\r
1826     _localctx->exception = std::current_exception();\r
1827     _errHandler->recover(this, _localctx->exception);\r
1828   }\r
1829 \r
1830   return _localctx;\r
1831 }\r
1832 \r
1833 //----------------- FuncCallContext ------------------------------------------------------------------\r
1834 \r
1835 TocParser::FuncCallContext::FuncCallContext(ParserRuleContext *parent, size_t invokingState)\r
1836   : ParserRuleContext(parent, invokingState) {\r
1837 }\r
1838 \r
1839 TocParser::FuncNameContext* TocParser::FuncCallContext::funcName() {\r
1840   return getRuleContext<TocParser::FuncNameContext>(0);\r
1841 }\r
1842 \r
1843 std::vector<TocParser::ExprContext *> TocParser::FuncCallContext::expr() {\r
1844   return getRuleContexts<TocParser::ExprContext>();\r
1845 }\r
1846 \r
1847 TocParser::ExprContext* TocParser::FuncCallContext::expr(size_t i) {\r
1848   return getRuleContext<TocParser::ExprContext>(i);\r
1849 }\r
1850 \r
1851 \r
1852 size_t TocParser::FuncCallContext::getRuleIndex() const {\r
1853   return TocParser::RuleFuncCall;\r
1854 }\r
1855 \r
1856 void TocParser::FuncCallContext::enterRule(tree::ParseTreeListener *listener) {\r
1857   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1858   if (parserListener != nullptr)\r
1859     parserListener->enterFuncCall(this);\r
1860 }\r
1861 \r
1862 void TocParser::FuncCallContext::exitRule(tree::ParseTreeListener *listener) {\r
1863   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1864   if (parserListener != nullptr)\r
1865     parserListener->exitFuncCall(this);\r
1866 }\r
1867 \r
1868 TocParser::FuncCallContext* TocParser::funcCall() {\r
1869   FuncCallContext *_localctx = _tracker.createInstance<FuncCallContext>(_ctx, getState());\r
1870   enterRule(_localctx, 50, TocParser::RuleFuncCall);\r
1871   size_t _la = 0;\r
1872 \r
1873 #if __cplusplus > 201703L\r
1874   auto onExit = finally([=, this] {\r
1875 #else\r
1876   auto onExit = finally([=] {\r
1877 #endif\r
1878     exitRule();\r
1879   });\r
1880   try {\r
1881     enterOuterAlt(_localctx, 1);\r
1882     setState(203);\r
1883     funcName();\r
1884     setState(204);\r
1885     match(TocParser::T__4);\r
1886     setState(213);\r
1887     _errHandler->sync(this);\r
1888 \r
1889     _la = _input->LA(1);\r
1890     if ((((_la & ~ 0x3fULL) == 0) &&\r
1891       ((1ULL << _la) & ((1ULL << TocParser::T__4)\r
1892       | (1ULL << TocParser::INTLIT)\r
1893       | (1ULL << TocParser::NAME))) != 0)) {\r
1894       setState(205);\r
1895       expr();\r
1896       setState(210);\r
1897       _errHandler->sync(this);\r
1898       _la = _input->LA(1);\r
1899       while (_la == TocParser::T__6) {\r
1900         setState(206);\r
1901         match(TocParser::T__6);\r
1902         setState(207);\r
1903         expr();\r
1904         setState(212);\r
1905         _errHandler->sync(this);\r
1906         _la = _input->LA(1);\r
1907       }\r
1908     }\r
1909     setState(215);\r
1910     match(TocParser::T__5);\r
1911    \r
1912   }\r
1913   catch (RecognitionException &e) {\r
1914     _errHandler->reportError(this, e);\r
1915     _localctx->exception = std::current_exception();\r
1916     _errHandler->recover(this, _localctx->exception);\r
1917   }\r
1918 \r
1919   return _localctx;\r
1920 }\r
1921 \r
1922 //----------------- OperatorExprContext ------------------------------------------------------------------\r
1923 \r
1924 TocParser::OperatorExprContext::OperatorExprContext(ParserRuleContext *parent, size_t invokingState)\r
1925   : ParserRuleContext(parent, invokingState) {\r
1926 }\r
1927 \r
1928 TocParser::BinaryOperatorContext* TocParser::OperatorExprContext::binaryOperator() {\r
1929   return getRuleContext<TocParser::BinaryOperatorContext>(0);\r
1930 }\r
1931 \r
1932 \r
1933 size_t TocParser::OperatorExprContext::getRuleIndex() const {\r
1934   return TocParser::RuleOperatorExpr;\r
1935 }\r
1936 \r
1937 void TocParser::OperatorExprContext::enterRule(tree::ParseTreeListener *listener) {\r
1938   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1939   if (parserListener != nullptr)\r
1940     parserListener->enterOperatorExpr(this);\r
1941 }\r
1942 \r
1943 void TocParser::OperatorExprContext::exitRule(tree::ParseTreeListener *listener) {\r
1944   auto parserListener = dynamic_cast<TocListener *>(listener);\r
1945   if (parserListener != nullptr)\r
1946     parserListener->exitOperatorExpr(this);\r
1947 }\r
1948 \r
1949 TocParser::OperatorExprContext* TocParser::operatorExpr() {\r
1950   OperatorExprContext *_localctx = _tracker.createInstance<OperatorExprContext>(_ctx, getState());\r
1951   enterRule(_localctx, 52, TocParser::RuleOperatorExpr);\r
1952 \r
1953 #if __cplusplus > 201703L\r
1954   auto onExit = finally([=, this] {\r
1955 #else\r
1956   auto onExit = finally([=] {\r
1957 #endif\r
1958     exitRule();\r
1959   });\r
1960   try {\r
1961     enterOuterAlt(_localctx, 1);\r
1962     setState(217);\r
1963     binaryOperator();\r
1964    \r
1965   }\r
1966   catch (RecognitionException &e) {\r
1967     _errHandler->reportError(this, e);\r
1968     _localctx->exception = std::current_exception();\r
1969     _errHandler->recover(this, _localctx->exception);\r
1970   }\r
1971 \r
1972   return _localctx;\r
1973 }\r
1974 \r
1975 //----------------- BinaryOperatorContext ------------------------------------------------------------------\r
1976 \r
1977 TocParser::BinaryOperatorContext::BinaryOperatorContext(ParserRuleContext *parent, size_t invokingState)\r
1978   : ParserRuleContext(parent, invokingState) {\r
1979 }\r
1980 \r
1981 std::vector<TocParser::NonOpExprContext *> TocParser::BinaryOperatorContext::nonOpExpr() {\r
1982   return getRuleContexts<TocParser::NonOpExprContext>();\r
1983 }\r
1984 \r
1985 TocParser::NonOpExprContext* TocParser::BinaryOperatorContext::nonOpExpr(size_t i) {\r
1986   return getRuleContext<TocParser::NonOpExprContext>(i);\r
1987 }\r
1988 \r
1989 std::vector<tree::TerminalNode *> TocParser::BinaryOperatorContext::BINARY_OPERATOR() {\r
1990   return getTokens(TocParser::BINARY_OPERATOR);\r
1991 }\r
1992 \r
1993 tree::TerminalNode* TocParser::BinaryOperatorContext::BINARY_OPERATOR(size_t i) {\r
1994   return getToken(TocParser::BINARY_OPERATOR, i);\r
1995 }\r
1996 \r
1997 \r
1998 size_t TocParser::BinaryOperatorContext::getRuleIndex() const {\r
1999   return TocParser::RuleBinaryOperator;\r
2000 }\r
2001 \r
2002 void TocParser::BinaryOperatorContext::enterRule(tree::ParseTreeListener *listener) {\r
2003   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2004   if (parserListener != nullptr)\r
2005     parserListener->enterBinaryOperator(this);\r
2006 }\r
2007 \r
2008 void TocParser::BinaryOperatorContext::exitRule(tree::ParseTreeListener *listener) {\r
2009   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2010   if (parserListener != nullptr)\r
2011     parserListener->exitBinaryOperator(this);\r
2012 }\r
2013 \r
2014 TocParser::BinaryOperatorContext* TocParser::binaryOperator() {\r
2015   BinaryOperatorContext *_localctx = _tracker.createInstance<BinaryOperatorContext>(_ctx, getState());\r
2016   enterRule(_localctx, 54, TocParser::RuleBinaryOperator);\r
2017   size_t _la = 0;\r
2018 \r
2019 #if __cplusplus > 201703L\r
2020   auto onExit = finally([=, this] {\r
2021 #else\r
2022   auto onExit = finally([=] {\r
2023 #endif\r
2024     exitRule();\r
2025   });\r
2026   try {\r
2027     enterOuterAlt(_localctx, 1);\r
2028     setState(219);\r
2029     nonOpExpr();\r
2030     setState(220);\r
2031     match(TocParser::BINARY_OPERATOR);\r
2032     setState(221);\r
2033     nonOpExpr();\r
2034     setState(226);\r
2035     _errHandler->sync(this);\r
2036     _la = _input->LA(1);\r
2037     while (_la == TocParser::BINARY_OPERATOR) {\r
2038       setState(222);\r
2039       match(TocParser::BINARY_OPERATOR);\r
2040       setState(223);\r
2041       nonOpExpr();\r
2042       setState(228);\r
2043       _errHandler->sync(this);\r
2044       _la = _input->LA(1);\r
2045     }\r
2046    \r
2047   }\r
2048   catch (RecognitionException &e) {\r
2049     _errHandler->reportError(this, e);\r
2050     _localctx->exception = std::current_exception();\r
2051     _errHandler->recover(this, _localctx->exception);\r
2052   }\r
2053 \r
2054   return _localctx;\r
2055 }\r
2056 \r
2057 //----------------- IdentifierContext ------------------------------------------------------------------\r
2058 \r
2059 TocParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)\r
2060   : ParserRuleContext(parent, invokingState) {\r
2061 }\r
2062 \r
2063 TocParser::VarNameContext* TocParser::IdentifierContext::varName() {\r
2064   return getRuleContext<TocParser::VarNameContext>(0);\r
2065 }\r
2066 \r
2067 \r
2068 size_t TocParser::IdentifierContext::getRuleIndex() const {\r
2069   return TocParser::RuleIdentifier;\r
2070 }\r
2071 \r
2072 void TocParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) {\r
2073   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2074   if (parserListener != nullptr)\r
2075     parserListener->enterIdentifier(this);\r
2076 }\r
2077 \r
2078 void TocParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) {\r
2079   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2080   if (parserListener != nullptr)\r
2081     parserListener->exitIdentifier(this);\r
2082 }\r
2083 \r
2084 TocParser::IdentifierContext* TocParser::identifier() {\r
2085   IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());\r
2086   enterRule(_localctx, 56, TocParser::RuleIdentifier);\r
2087 \r
2088 #if __cplusplus > 201703L\r
2089   auto onExit = finally([=, this] {\r
2090 #else\r
2091   auto onExit = finally([=] {\r
2092 #endif\r
2093     exitRule();\r
2094   });\r
2095   try {\r
2096     enterOuterAlt(_localctx, 1);\r
2097     setState(229);\r
2098     varName();\r
2099    \r
2100   }\r
2101   catch (RecognitionException &e) {\r
2102     _errHandler->reportError(this, e);\r
2103     _localctx->exception = std::current_exception();\r
2104     _errHandler->recover(this, _localctx->exception);\r
2105   }\r
2106 \r
2107   return _localctx;\r
2108 }\r
2109 \r
2110 //----------------- LiteralContext ------------------------------------------------------------------\r
2111 \r
2112 TocParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)\r
2113   : ParserRuleContext(parent, invokingState) {\r
2114 }\r
2115 \r
2116 tree::TerminalNode* TocParser::LiteralContext::INTLIT() {\r
2117   return getToken(TocParser::INTLIT, 0);\r
2118 }\r
2119 \r
2120 \r
2121 size_t TocParser::LiteralContext::getRuleIndex() const {\r
2122   return TocParser::RuleLiteral;\r
2123 }\r
2124 \r
2125 void TocParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) {\r
2126   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2127   if (parserListener != nullptr)\r
2128     parserListener->enterLiteral(this);\r
2129 }\r
2130 \r
2131 void TocParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) {\r
2132   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2133   if (parserListener != nullptr)\r
2134     parserListener->exitLiteral(this);\r
2135 }\r
2136 \r
2137 TocParser::LiteralContext* TocParser::literal() {\r
2138   LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());\r
2139   enterRule(_localctx, 58, TocParser::RuleLiteral);\r
2140 \r
2141 #if __cplusplus > 201703L\r
2142   auto onExit = finally([=, this] {\r
2143 #else\r
2144   auto onExit = finally([=] {\r
2145 #endif\r
2146     exitRule();\r
2147   });\r
2148   try {\r
2149     enterOuterAlt(_localctx, 1);\r
2150     setState(231);\r
2151     match(TocParser::INTLIT);\r
2152    \r
2153   }\r
2154   catch (RecognitionException &e) {\r
2155     _errHandler->reportError(this, e);\r
2156     _localctx->exception = std::current_exception();\r
2157     _errHandler->recover(this, _localctx->exception);\r
2158   }\r
2159 \r
2160   return _localctx;\r
2161 }\r
2162 \r
2163 //----------------- SubscriptContext ------------------------------------------------------------------\r
2164 \r
2165 TocParser::SubscriptContext::SubscriptContext(ParserRuleContext *parent, size_t invokingState)\r
2166   : ParserRuleContext(parent, invokingState) {\r
2167 }\r
2168 \r
2169 TocParser::NonSubscriptExprContext* TocParser::SubscriptContext::nonSubscriptExpr() {\r
2170   return getRuleContext<TocParser::NonSubscriptExprContext>(0);\r
2171 }\r
2172 \r
2173 TocParser::ExprContext* TocParser::SubscriptContext::expr() {\r
2174   return getRuleContext<TocParser::ExprContext>(0);\r
2175 }\r
2176 \r
2177 \r
2178 size_t TocParser::SubscriptContext::getRuleIndex() const {\r
2179   return TocParser::RuleSubscript;\r
2180 }\r
2181 \r
2182 void TocParser::SubscriptContext::enterRule(tree::ParseTreeListener *listener) {\r
2183   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2184   if (parserListener != nullptr)\r
2185     parserListener->enterSubscript(this);\r
2186 }\r
2187 \r
2188 void TocParser::SubscriptContext::exitRule(tree::ParseTreeListener *listener) {\r
2189   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2190   if (parserListener != nullptr)\r
2191     parserListener->exitSubscript(this);\r
2192 }\r
2193 \r
2194 TocParser::SubscriptContext* TocParser::subscript() {\r
2195   SubscriptContext *_localctx = _tracker.createInstance<SubscriptContext>(_ctx, getState());\r
2196   enterRule(_localctx, 60, TocParser::RuleSubscript);\r
2197 \r
2198 #if __cplusplus > 201703L\r
2199   auto onExit = finally([=, this] {\r
2200 #else\r
2201   auto onExit = finally([=] {\r
2202 #endif\r
2203     exitRule();\r
2204   });\r
2205   try {\r
2206     enterOuterAlt(_localctx, 1);\r
2207     setState(233);\r
2208     nonSubscriptExpr();\r
2209     setState(234);\r
2210     match(TocParser::T__13);\r
2211     setState(235);\r
2212     expr();\r
2213     setState(236);\r
2214     match(TocParser::T__14);\r
2215    \r
2216   }\r
2217   catch (RecognitionException &e) {\r
2218     _errHandler->reportError(this, e);\r
2219     _localctx->exception = std::current_exception();\r
2220     _errHandler->recover(this, _localctx->exception);\r
2221   }\r
2222 \r
2223   return _localctx;\r
2224 }\r
2225 \r
2226 //----------------- MemberAccessContext ------------------------------------------------------------------\r
2227 \r
2228 TocParser::MemberAccessContext::MemberAccessContext(ParserRuleContext *parent, size_t invokingState)\r
2229   : ParserRuleContext(parent, invokingState) {\r
2230 }\r
2231 \r
2232 std::vector<TocParser::IdentifierContext *> TocParser::MemberAccessContext::identifier() {\r
2233   return getRuleContexts<TocParser::IdentifierContext>();\r
2234 }\r
2235 \r
2236 TocParser::IdentifierContext* TocParser::MemberAccessContext::identifier(size_t i) {\r
2237   return getRuleContext<TocParser::IdentifierContext>(i);\r
2238 }\r
2239 \r
2240 \r
2241 size_t TocParser::MemberAccessContext::getRuleIndex() const {\r
2242   return TocParser::RuleMemberAccess;\r
2243 }\r
2244 \r
2245 void TocParser::MemberAccessContext::enterRule(tree::ParseTreeListener *listener) {\r
2246   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2247   if (parserListener != nullptr)\r
2248     parserListener->enterMemberAccess(this);\r
2249 }\r
2250 \r
2251 void TocParser::MemberAccessContext::exitRule(tree::ParseTreeListener *listener) {\r
2252   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2253   if (parserListener != nullptr)\r
2254     parserListener->exitMemberAccess(this);\r
2255 }\r
2256 \r
2257 TocParser::MemberAccessContext* TocParser::memberAccess() {\r
2258   MemberAccessContext *_localctx = _tracker.createInstance<MemberAccessContext>(_ctx, getState());\r
2259   enterRule(_localctx, 62, TocParser::RuleMemberAccess);\r
2260 \r
2261 #if __cplusplus > 201703L\r
2262   auto onExit = finally([=, this] {\r
2263 #else\r
2264   auto onExit = finally([=] {\r
2265 #endif\r
2266     exitRule();\r
2267   });\r
2268   try {\r
2269     enterOuterAlt(_localctx, 1);\r
2270     setState(238);\r
2271     identifier();\r
2272     setState(239);\r
2273     match(TocParser::T__15);\r
2274     setState(240);\r
2275     identifier();\r
2276    \r
2277   }\r
2278   catch (RecognitionException &e) {\r
2279     _errHandler->reportError(this, e);\r
2280     _localctx->exception = std::current_exception();\r
2281     _errHandler->recover(this, _localctx->exception);\r
2282   }\r
2283 \r
2284   return _localctx;\r
2285 }\r
2286 \r
2287 //----------------- ParenExprContext ------------------------------------------------------------------\r
2288 \r
2289 TocParser::ParenExprContext::ParenExprContext(ParserRuleContext *parent, size_t invokingState)\r
2290   : ParserRuleContext(parent, invokingState) {\r
2291 }\r
2292 \r
2293 TocParser::ExprContext* TocParser::ParenExprContext::expr() {\r
2294   return getRuleContext<TocParser::ExprContext>(0);\r
2295 }\r
2296 \r
2297 \r
2298 size_t TocParser::ParenExprContext::getRuleIndex() const {\r
2299   return TocParser::RuleParenExpr;\r
2300 }\r
2301 \r
2302 void TocParser::ParenExprContext::enterRule(tree::ParseTreeListener *listener) {\r
2303   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2304   if (parserListener != nullptr)\r
2305     parserListener->enterParenExpr(this);\r
2306 }\r
2307 \r
2308 void TocParser::ParenExprContext::exitRule(tree::ParseTreeListener *listener) {\r
2309   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2310   if (parserListener != nullptr)\r
2311     parserListener->exitParenExpr(this);\r
2312 }\r
2313 \r
2314 TocParser::ParenExprContext* TocParser::parenExpr() {\r
2315   ParenExprContext *_localctx = _tracker.createInstance<ParenExprContext>(_ctx, getState());\r
2316   enterRule(_localctx, 64, TocParser::RuleParenExpr);\r
2317 \r
2318 #if __cplusplus > 201703L\r
2319   auto onExit = finally([=, this] {\r
2320 #else\r
2321   auto onExit = finally([=] {\r
2322 #endif\r
2323     exitRule();\r
2324   });\r
2325   try {\r
2326     enterOuterAlt(_localctx, 1);\r
2327     setState(242);\r
2328     match(TocParser::T__4);\r
2329     setState(243);\r
2330     expr();\r
2331     setState(244);\r
2332     match(TocParser::T__5);\r
2333    \r
2334   }\r
2335   catch (RecognitionException &e) {\r
2336     _errHandler->reportError(this, e);\r
2337     _localctx->exception = std::current_exception();\r
2338     _errHandler->recover(this, _localctx->exception);\r
2339   }\r
2340 \r
2341   return _localctx;\r
2342 }\r
2343 \r
2344 //----------------- FuncNameContext ------------------------------------------------------------------\r
2345 \r
2346 TocParser::FuncNameContext::FuncNameContext(ParserRuleContext *parent, size_t invokingState)\r
2347   : ParserRuleContext(parent, invokingState) {\r
2348 }\r
2349 \r
2350 tree::TerminalNode* TocParser::FuncNameContext::NAME() {\r
2351   return getToken(TocParser::NAME, 0);\r
2352 }\r
2353 \r
2354 \r
2355 size_t TocParser::FuncNameContext::getRuleIndex() const {\r
2356   return TocParser::RuleFuncName;\r
2357 }\r
2358 \r
2359 void TocParser::FuncNameContext::enterRule(tree::ParseTreeListener *listener) {\r
2360   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2361   if (parserListener != nullptr)\r
2362     parserListener->enterFuncName(this);\r
2363 }\r
2364 \r
2365 void TocParser::FuncNameContext::exitRule(tree::ParseTreeListener *listener) {\r
2366   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2367   if (parserListener != nullptr)\r
2368     parserListener->exitFuncName(this);\r
2369 }\r
2370 \r
2371 TocParser::FuncNameContext* TocParser::funcName() {\r
2372   FuncNameContext *_localctx = _tracker.createInstance<FuncNameContext>(_ctx, getState());\r
2373   enterRule(_localctx, 66, TocParser::RuleFuncName);\r
2374 \r
2375 #if __cplusplus > 201703L\r
2376   auto onExit = finally([=, this] {\r
2377 #else\r
2378   auto onExit = finally([=] {\r
2379 #endif\r
2380     exitRule();\r
2381   });\r
2382   try {\r
2383     enterOuterAlt(_localctx, 1);\r
2384     setState(246);\r
2385     match(TocParser::NAME);\r
2386    \r
2387   }\r
2388   catch (RecognitionException &e) {\r
2389     _errHandler->reportError(this, e);\r
2390     _localctx->exception = std::current_exception();\r
2391     _errHandler->recover(this, _localctx->exception);\r
2392   }\r
2393 \r
2394   return _localctx;\r
2395 }\r
2396 \r
2397 //----------------- VarNameContext ------------------------------------------------------------------\r
2398 \r
2399 TocParser::VarNameContext::VarNameContext(ParserRuleContext *parent, size_t invokingState)\r
2400   : ParserRuleContext(parent, invokingState) {\r
2401 }\r
2402 \r
2403 tree::TerminalNode* TocParser::VarNameContext::NAME() {\r
2404   return getToken(TocParser::NAME, 0);\r
2405 }\r
2406 \r
2407 \r
2408 size_t TocParser::VarNameContext::getRuleIndex() const {\r
2409   return TocParser::RuleVarName;\r
2410 }\r
2411 \r
2412 void TocParser::VarNameContext::enterRule(tree::ParseTreeListener *listener) {\r
2413   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2414   if (parserListener != nullptr)\r
2415     parserListener->enterVarName(this);\r
2416 }\r
2417 \r
2418 void TocParser::VarNameContext::exitRule(tree::ParseTreeListener *listener) {\r
2419   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2420   if (parserListener != nullptr)\r
2421     parserListener->exitVarName(this);\r
2422 }\r
2423 \r
2424 TocParser::VarNameContext* TocParser::varName() {\r
2425   VarNameContext *_localctx = _tracker.createInstance<VarNameContext>(_ctx, getState());\r
2426   enterRule(_localctx, 68, TocParser::RuleVarName);\r
2427 \r
2428 #if __cplusplus > 201703L\r
2429   auto onExit = finally([=, this] {\r
2430 #else\r
2431   auto onExit = finally([=] {\r
2432 #endif\r
2433     exitRule();\r
2434   });\r
2435   try {\r
2436     enterOuterAlt(_localctx, 1);\r
2437     setState(248);\r
2438     match(TocParser::NAME);\r
2439    \r
2440   }\r
2441   catch (RecognitionException &e) {\r
2442     _errHandler->reportError(this, e);\r
2443     _localctx->exception = std::current_exception();\r
2444     _errHandler->recover(this, _localctx->exception);\r
2445   }\r
2446 \r
2447   return _localctx;\r
2448 }\r
2449 \r
2450 //----------------- TypeNameContext ------------------------------------------------------------------\r
2451 \r
2452 TocParser::TypeNameContext::TypeNameContext(ParserRuleContext *parent, size_t invokingState)\r
2453   : ParserRuleContext(parent, invokingState) {\r
2454 }\r
2455 \r
2456 tree::TerminalNode* TocParser::TypeNameContext::NAME() {\r
2457   return getToken(TocParser::NAME, 0);\r
2458 }\r
2459 \r
2460 \r
2461 size_t TocParser::TypeNameContext::getRuleIndex() const {\r
2462   return TocParser::RuleTypeName;\r
2463 }\r
2464 \r
2465 void TocParser::TypeNameContext::enterRule(tree::ParseTreeListener *listener) {\r
2466   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2467   if (parserListener != nullptr)\r
2468     parserListener->enterTypeName(this);\r
2469 }\r
2470 \r
2471 void TocParser::TypeNameContext::exitRule(tree::ParseTreeListener *listener) {\r
2472   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2473   if (parserListener != nullptr)\r
2474     parserListener->exitTypeName(this);\r
2475 }\r
2476 \r
2477 TocParser::TypeNameContext* TocParser::typeName() {\r
2478   TypeNameContext *_localctx = _tracker.createInstance<TypeNameContext>(_ctx, getState());\r
2479   enterRule(_localctx, 70, TocParser::RuleTypeName);\r
2480 \r
2481 #if __cplusplus > 201703L\r
2482   auto onExit = finally([=, this] {\r
2483 #else\r
2484   auto onExit = finally([=] {\r
2485 #endif\r
2486     exitRule();\r
2487   });\r
2488   try {\r
2489     enterOuterAlt(_localctx, 1);\r
2490     setState(250);\r
2491     match(TocParser::NAME);\r
2492    \r
2493   }\r
2494   catch (RecognitionException &e) {\r
2495     _errHandler->reportError(this, e);\r
2496     _localctx->exception = std::current_exception();\r
2497     _errHandler->recover(this, _localctx->exception);\r
2498   }\r
2499 \r
2500   return _localctx;\r
2501 }\r
2502 \r
2503 //----------------- StructNameContext ------------------------------------------------------------------\r
2504 \r
2505 TocParser::StructNameContext::StructNameContext(ParserRuleContext *parent, size_t invokingState)\r
2506   : ParserRuleContext(parent, invokingState) {\r
2507 }\r
2508 \r
2509 tree::TerminalNode* TocParser::StructNameContext::NAME() {\r
2510   return getToken(TocParser::NAME, 0);\r
2511 }\r
2512 \r
2513 \r
2514 size_t TocParser::StructNameContext::getRuleIndex() const {\r
2515   return TocParser::RuleStructName;\r
2516 }\r
2517 \r
2518 void TocParser::StructNameContext::enterRule(tree::ParseTreeListener *listener) {\r
2519   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2520   if (parserListener != nullptr)\r
2521     parserListener->enterStructName(this);\r
2522 }\r
2523 \r
2524 void TocParser::StructNameContext::exitRule(tree::ParseTreeListener *listener) {\r
2525   auto parserListener = dynamic_cast<TocListener *>(listener);\r
2526   if (parserListener != nullptr)\r
2527     parserListener->exitStructName(this);\r
2528 }\r
2529 \r
2530 TocParser::StructNameContext* TocParser::structName() {\r
2531   StructNameContext *_localctx = _tracker.createInstance<StructNameContext>(_ctx, getState());\r
2532   enterRule(_localctx, 72, TocParser::RuleStructName);\r
2533 \r
2534 #if __cplusplus > 201703L\r
2535   auto onExit = finally([=, this] {\r
2536 #else\r
2537   auto onExit = finally([=] {\r
2538 #endif\r
2539     exitRule();\r
2540   });\r
2541   try {\r
2542     enterOuterAlt(_localctx, 1);\r
2543     setState(252);\r
2544     match(TocParser::NAME);\r
2545    \r
2546   }\r
2547   catch (RecognitionException &e) {\r
2548     _errHandler->reportError(this, e);\r
2549     _localctx->exception = std::current_exception();\r
2550     _errHandler->recover(this, _localctx->exception);\r
2551   }\r
2552 \r
2553   return _localctx;\r
2554 }\r
2555 \r
2556 // Static vars and initialization.\r
2557 std::vector<dfa::DFA> TocParser::_decisionToDFA;\r
2558 atn::PredictionContextCache TocParser::_sharedContextCache;\r
2559 \r
2560 // We own the ATN which in turn owns the ATN states.\r
2561 atn::ATN TocParser::_atn;\r
2562 std::vector<uint16_t> TocParser::_serializedATN;\r
2563 \r
2564 std::vector<std::string> TocParser::_ruleNames = {\r
2565   "prog", "decl", "varDecl", "var", "type", "funcDecl", "func", "parameter", \r
2566   "firstParameter", "additionalParameter", "body", "structDecl", "structMember", \r
2567   "structVar", "structMethod", "stmt", "conditional", "ifCond", "loop", \r
2568   "whileLoop", "assignment", "returnStmt", "expr", "nonOpExpr", "nonSubscriptExpr", \r
2569   "funcCall", "operatorExpr", "binaryOperator", "identifier", "literal", \r
2570   "subscript", "memberAccess", "parenExpr", "funcName", "varName", "typeName", \r
2571   "structName"\r
2572 };\r
2573 \r
2574 std::vector<std::string> TocParser::_literalNames = {\r
2575   "", "'var'", "':'", "'='", "'func'", "'('", "')'", "','", "'{'", "'}'", \r
2576   "'struct'", "'if'", "'while'", "'return'", "'['", "']'", "'.'"\r
2577 };\r
2578 \r
2579 std::vector<std::string> TocParser::_symbolicNames = {\r
2580   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "BINARY_OPERATOR", \r
2581   "INTLIT", "NAME", "WS", "NEWLINE"\r
2582 };\r
2583 \r
2584 dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames);\r
2585 \r
2586 std::vector<std::string> TocParser::_tokenNames;\r
2587 \r
2588 TocParser::Initializer::Initializer() {\r
2589         for (size_t i = 0; i < _symbolicNames.size(); ++i) {\r
2590                 std::string name = _vocabulary.getLiteralName(i);\r
2591                 if (name.empty()) {\r
2592                         name = _vocabulary.getSymbolicName(i);\r
2593                 }\r
2594 \r
2595                 if (name.empty()) {\r
2596                         _tokenNames.push_back("<INVALID>");\r
2597                 } else {\r
2598       _tokenNames.push_back(name);\r
2599     }\r
2600         }\r
2601 \r
2602   static const uint16_t serializedATNSegment0[] = {\r
2603     0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, \r
2604        0x3, 0x17, 0x101, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, \r
2605        0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, \r
2606        0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, \r
2607        0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, \r
2608        0xe, 0x9, 0xe, 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, \r
2609        0x9, 0x11, 0x4, 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, \r
2610        0x9, 0x14, 0x4, 0x15, 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, \r
2611        0x9, 0x17, 0x4, 0x18, 0x9, 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, \r
2612        0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, \r
2613        0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, \r
2614        0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, \r
2615        0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, \r
2616        0x9, 0x26, 0x3, 0x2, 0x6, 0x2, 0x4e, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, \r
2617        0x4f, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, \r
2618        0x57, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, \r
2619        0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x62, 0xa, 0x5, \r
2620        0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, \r
2621        0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, \r
2622        0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x74, 0xa, 0x9, 0xc, 0x9, \r
2623        0xe, 0x9, 0x77, 0xb, 0x9, 0x5, 0x9, 0x79, 0xa, 0x9, 0x3, 0xa, 0x3, \r
2624        0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, \r
2625        0x82, 0xa, 0xc, 0xc, 0xc, 0xe, 0xc, 0x85, 0xb, 0xc, 0x3, 0xc, 0x3, \r
2626        0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0x8d, 0xa, \r
2627        0xd, 0xc, 0xd, 0xe, 0xd, 0x90, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, \r
2628        0xe, 0x3, 0xe, 0x5, 0xe, 0x96, 0xa, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, \r
2629        0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, \r
2630        0x11, 0x3, 0x11, 0x5, 0x11, 0xa2, 0xa, 0x11, 0x3, 0x12, 0x3, 0x12, \r
2631        0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, \r
2632        0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, \r
2633        0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, \r
2634        0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, \r
2635        0x5, 0x18, 0xbe, 0xa, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, \r
2636        0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0xc6, 0xa, 0x19, 0x3, 0x1a, \r
2637        0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0xcc, 0xa, 0x1a, 0x3, \r
2638        0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x7, 0x1b, 0xd3, \r
2639        0xa, 0x1b, 0xc, 0x1b, 0xe, 0x1b, 0xd6, 0xb, 0x1b, 0x5, 0x1b, 0xd8, \r
2640        0xa, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, \r
2641        0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x7, 0x1d, 0xe3, 0xa, \r
2642        0x1d, 0xc, 0x1d, 0xe, 0x1d, 0xe6, 0xb, 0x1d, 0x3, 0x1e, 0x3, 0x1e, \r
2643        0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, \r
2644        0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, \r
2645        0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, \r
2646        0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, \r
2647        0x2, 0x2, 0x27, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, \r
2648        0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, \r
2649        0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, \r
2650        0x42, 0x44, 0x46, 0x48, 0x4a, 0x2, 0x2, 0x2, 0xfa, 0x2, 0x4d, 0x3, \r
2651        0x2, 0x2, 0x2, 0x4, 0x56, 0x3, 0x2, 0x2, 0x2, 0x6, 0x58, 0x3, 0x2, \r
2652        0x2, 0x2, 0x8, 0x5b, 0x3, 0x2, 0x2, 0x2, 0xa, 0x63, 0x3, 0x2, 0x2, \r
2653        0x2, 0xc, 0x65, 0x3, 0x2, 0x2, 0x2, 0xe, 0x68, 0x3, 0x2, 0x2, 0x2, \r
2654        0x10, 0x78, 0x3, 0x2, 0x2, 0x2, 0x12, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x14, \r
2655        0x7c, 0x3, 0x2, 0x2, 0x2, 0x16, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x18, 0x88, \r
2656        0x3, 0x2, 0x2, 0x2, 0x1a, 0x95, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x97, 0x3, \r
2657        0x2, 0x2, 0x2, 0x1e, 0x99, 0x3, 0x2, 0x2, 0x2, 0x20, 0xa1, 0x3, 0x2, \r
2658        0x2, 0x2, 0x22, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x24, 0xa5, 0x3, 0x2, 0x2, \r
2659        0x2, 0x26, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x28, 0xab, 0x3, 0x2, 0x2, 0x2, \r
2660        0x2a, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xb3, 0x3, 0x2, 0x2, 0x2, 0x2e, \r
2661        0xbd, 0x3, 0x2, 0x2, 0x2, 0x30, 0xc5, 0x3, 0x2, 0x2, 0x2, 0x32, 0xcb, \r
2662        0x3, 0x2, 0x2, 0x2, 0x34, 0xcd, 0x3, 0x2, 0x2, 0x2, 0x36, 0xdb, 0x3, \r
2663        0x2, 0x2, 0x2, 0x38, 0xdd, 0x3, 0x2, 0x2, 0x2, 0x3a, 0xe7, 0x3, 0x2, \r
2664        0x2, 0x2, 0x3c, 0xe9, 0x3, 0x2, 0x2, 0x2, 0x3e, 0xeb, 0x3, 0x2, 0x2, \r
2665        0x2, 0x40, 0xf0, 0x3, 0x2, 0x2, 0x2, 0x42, 0xf4, 0x3, 0x2, 0x2, 0x2, \r
2666        0x44, 0xf8, 0x3, 0x2, 0x2, 0x2, 0x46, 0xfa, 0x3, 0x2, 0x2, 0x2, 0x48, \r
2667        0xfc, 0x3, 0x2, 0x2, 0x2, 0x4a, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x4e, \r
2668        0x5, 0x4, 0x3, 0x2, 0x4d, 0x4c, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x4f, 0x3, \r
2669        0x2, 0x2, 0x2, 0x4f, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0x3, 0x2, \r
2670        0x2, 0x2, 0x50, 0x51, 0x3, 0x2, 0x2, 0x2, 0x51, 0x52, 0x7, 0x2, 0x2, \r
2671        0x3, 0x52, 0x3, 0x3, 0x2, 0x2, 0x2, 0x53, 0x57, 0x5, 0x6, 0x4, 0x2, \r
2672        0x54, 0x57, 0x5, 0xc, 0x7, 0x2, 0x55, 0x57, 0x5, 0x18, 0xd, 0x2, \r
2673        0x56, 0x53, 0x3, 0x2, 0x2, 0x2, 0x56, 0x54, 0x3, 0x2, 0x2, 0x2, 0x56, \r
2674        0x55, 0x3, 0x2, 0x2, 0x2, 0x57, 0x5, 0x3, 0x2, 0x2, 0x2, 0x58, 0x59, \r
2675        0x7, 0x3, 0x2, 0x2, 0x59, 0x5a, 0x5, 0x8, 0x5, 0x2, 0x5a, 0x7, 0x3, \r
2676        0x2, 0x2, 0x2, 0x5b, 0x5c, 0x5, 0x46, 0x24, 0x2, 0x5c, 0x5d, 0x7, \r
2677        0x4, 0x2, 0x2, 0x5d, 0x5e, 0x5, 0xa, 0x6, 0x2, 0x5e, 0x61, 0x3, 0x2, \r
2678        0x2, 0x2, 0x5f, 0x60, 0x7, 0x5, 0x2, 0x2, 0x60, 0x62, 0x5, 0x2e, \r
2679        0x18, 0x2, 0x61, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x3, 0x2, \r
2680        0x2, 0x2, 0x62, 0x9, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, 0x5, 0x48, 0x25, \r
2681        0x2, 0x64, 0xb, 0x3, 0x2, 0x2, 0x2, 0x65, 0x66, 0x7, 0x6, 0x2, 0x2, \r
2682        0x66, 0x67, 0x5, 0xe, 0x8, 0x2, 0x67, 0xd, 0x3, 0x2, 0x2, 0x2, 0x68, \r
2683        0x69, 0x5, 0x44, 0x23, 0x2, 0x69, 0x6a, 0x7, 0x7, 0x2, 0x2, 0x6a, \r
2684        0x6b, 0x5, 0x10, 0x9, 0x2, 0x6b, 0x6c, 0x7, 0x8, 0x2, 0x2, 0x6c, \r
2685        0x6d, 0x7, 0x4, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0xa, 0x6, 0x2, 0x6e, 0x6f, \r
2686        0x3, 0x2, 0x2, 0x2, 0x6f, 0x70, 0x5, 0x16, 0xc, 0x2, 0x70, 0xf, 0x3, \r
2687        0x2, 0x2, 0x2, 0x71, 0x75, 0x5, 0x12, 0xa, 0x2, 0x72, 0x74, 0x5, \r
2688        0x14, 0xb, 0x2, 0x73, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, 0x77, 0x3, \r
2689        0x2, 0x2, 0x2, 0x75, 0x73, 0x3, 0x2, 0x2, 0x2, 0x75, 0x76, 0x3, 0x2, \r
2690        0x2, 0x2, 0x76, 0x79, 0x3, 0x2, 0x2, 0x2, 0x77, 0x75, 0x3, 0x2, 0x2, \r
2691        0x2, 0x78, 0x71, 0x3, 0x2, 0x2, 0x2, 0x78, 0x79, 0x3, 0x2, 0x2, 0x2, \r
2692        0x79, 0x11, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x7b, 0x5, 0x8, 0x5, 0x2, 0x7b, \r
2693        0x13, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x7d, 0x7, 0x9, 0x2, 0x2, 0x7d, 0x7e, \r
2694        0x5, 0x8, 0x5, 0x2, 0x7e, 0x15, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x83, 0x7, \r
2695        0xa, 0x2, 0x2, 0x80, 0x82, 0x5, 0x20, 0x11, 0x2, 0x81, 0x80, 0x3, \r
2696        0x2, 0x2, 0x2, 0x82, 0x85, 0x3, 0x2, 0x2, 0x2, 0x83, 0x81, 0x3, 0x2, \r
2697        0x2, 0x2, 0x83, 0x84, 0x3, 0x2, 0x2, 0x2, 0x84, 0x86, 0x3, 0x2, 0x2, \r
2698        0x2, 0x85, 0x83, 0x3, 0x2, 0x2, 0x2, 0x86, 0x87, 0x7, 0xb, 0x2, 0x2, \r
2699        0x87, 0x17, 0x3, 0x2, 0x2, 0x2, 0x88, 0x89, 0x7, 0xc, 0x2, 0x2, 0x89, \r
2700        0x8a, 0x5, 0x4a, 0x26, 0x2, 0x8a, 0x8e, 0x7, 0xa, 0x2, 0x2, 0x8b, \r
2701        0x8d, 0x5, 0x1a, 0xe, 0x2, 0x8c, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8d, \r
2702        0x90, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8c, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8f, \r
2703        0x3, 0x2, 0x2, 0x2, 0x8f, 0x91, 0x3, 0x2, 0x2, 0x2, 0x90, 0x8e, 0x3, \r
2704        0x2, 0x2, 0x2, 0x91, 0x92, 0x7, 0xb, 0x2, 0x2, 0x92, 0x19, 0x3, 0x2, \r
2705        0x2, 0x2, 0x93, 0x96, 0x5, 0x1c, 0xf, 0x2, 0x94, 0x96, 0x5, 0x1e, \r
2706        0x10, 0x2, 0x95, 0x93, 0x3, 0x2, 0x2, 0x2, 0x95, 0x94, 0x3, 0x2, \r
2707        0x2, 0x2, 0x96, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x97, 0x98, 0x5, 0x8, 0x5, \r
2708        0x2, 0x98, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x99, 0x9a, 0x5, 0xe, 0x8, 0x2, \r
2709        0x9a, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x9b, 0xa2, 0x5, 0x6, 0x4, 0x2, 0x9c, \r
2710        0xa2, 0x5, 0x22, 0x12, 0x2, 0x9d, 0xa2, 0x5, 0x26, 0x14, 0x2, 0x9e, \r
2711        0xa2, 0x5, 0x2a, 0x16, 0x2, 0x9f, 0xa2, 0x5, 0x2c, 0x17, 0x2, 0xa0, \r
2712        0xa2, 0x5, 0x2e, 0x18, 0x2, 0xa1, 0x9b, 0x3, 0x2, 0x2, 0x2, 0xa1, \r
2713        0x9c, 0x3, 0x2, 0x2, 0x2, 0xa1, 0x9d, 0x3, 0x2, 0x2, 0x2, 0xa1, 0x9e, \r
2714        0x3, 0x2, 0x2, 0x2, 0xa1, 0x9f, 0x3, 0x2, 0x2, 0x2, 0xa1, 0xa0, 0x3, \r
2715        0x2, 0x2, 0x2, 0xa2, 0x21, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x5, 0x24, \r
2716        0x13, 0x2, 0xa4, 0x23, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x7, 0xd, \r
2717        0x2, 0x2, 0xa6, 0xa7, 0x5, 0x2e, 0x18, 0x2, 0xa7, 0xa8, 0x5, 0x16, \r
2718        0xc, 0x2, 0xa8, 0x25, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x5, 0x28, \r
2719        0x15, 0x2, 0xaa, 0x27, 0x3, 0x2, 0x2, 0x2, 0xab, 0xac, 0x7, 0xe, \r
2720        0x2, 0x2, 0xac, 0xad, 0x5, 0x2e, 0x18, 0x2, 0xad, 0xae, 0x5, 0x16, \r
2721        0xc, 0x2, 0xae, 0x29, 0x3, 0x2, 0x2, 0x2, 0xaf, 0xb0, 0x5, 0x3a, \r
2722        0x1e, 0x2, 0xb0, 0xb1, 0x7, 0x5, 0x2, 0x2, 0xb1, 0xb2, 0x5, 0x2e, \r
2723        0x18, 0x2, 0xb2, 0x2b, 0x3, 0x2, 0x2, 0x2, 0xb3, 0xb4, 0x7, 0xf, \r
2724        0x2, 0x2, 0xb4, 0xb5, 0x5, 0x2e, 0x18, 0x2, 0xb5, 0x2d, 0x3, 0x2, \r
2725        0x2, 0x2, 0xb6, 0xbe, 0x5, 0x34, 0x1b, 0x2, 0xb7, 0xbe, 0x5, 0x3c, \r
2726        0x1f, 0x2, 0xb8, 0xbe, 0x5, 0x3a, 0x1e, 0x2, 0xb9, 0xbe, 0x5, 0x3e, \r
2727        0x20, 0x2, 0xba, 0xbe, 0x5, 0x40, 0x21, 0x2, 0xbb, 0xbe, 0x5, 0x42, \r
2728        0x22, 0x2, 0xbc, 0xbe, 0x5, 0x36, 0x1c, 0x2, 0xbd, 0xb6, 0x3, 0x2, \r
2729        0x2, 0x2, 0xbd, 0xb7, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xb8, 0x3, 0x2, 0x2, \r
2730        0x2, 0xbd, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xba, 0x3, 0x2, 0x2, 0x2, \r
2731        0xbd, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbe, \r
2732        0x2f, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xc6, 0x5, 0x34, 0x1b, 0x2, 0xc0, \r
2733        0xc6, 0x5, 0x3c, 0x1f, 0x2, 0xc1, 0xc6, 0x5, 0x3a, 0x1e, 0x2, 0xc2, \r
2734        0xc6, 0x5, 0x3e, 0x20, 0x2, 0xc3, 0xc6, 0x5, 0x40, 0x21, 0x2, 0xc4, \r
2735        0xc6, 0x5, 0x42, 0x22, 0x2, 0xc5, 0xbf, 0x3, 0x2, 0x2, 0x2, 0xc5, \r
2736        0xc0, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc1, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc2, \r
2737        0x3, 0x2, 0x2, 0x2, 0xc5, 0xc3, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc4, 0x3, \r
2738        0x2, 0x2, 0x2, 0xc6, 0x31, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xcc, 0x5, 0x34, \r
2739        0x1b, 0x2, 0xc8, 0xcc, 0x5, 0x3a, 0x1e, 0x2, 0xc9, 0xcc, 0x5, 0x40, \r
2740        0x21, 0x2, 0xca, 0xcc, 0x5, 0x42, 0x22, 0x2, 0xcb, 0xc7, 0x3, 0x2, \r
2741        0x2, 0x2, 0xcb, 0xc8, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xc9, 0x3, 0x2, 0x2, \r
2742        0x2, 0xcb, 0xca, 0x3, 0x2, 0x2, 0x2, 0xcc, 0x33, 0x3, 0x2, 0x2, 0x2, \r
2743        0xcd, 0xce, 0x5, 0x44, 0x23, 0x2, 0xce, 0xd7, 0x7, 0x7, 0x2, 0x2, \r
2744        0xcf, 0xd4, 0x5, 0x2e, 0x18, 0x2, 0xd0, 0xd1, 0x7, 0x9, 0x2, 0x2, \r
2745        0xd1, 0xd3, 0x5, 0x2e, 0x18, 0x2, 0xd2, 0xd0, 0x3, 0x2, 0x2, 0x2, \r
2746        0xd3, 0xd6, 0x3, 0x2, 0x2, 0x2, 0xd4, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xd4, \r
2747        0xd5, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd6, 0xd4, \r
2748        0x3, 0x2, 0x2, 0x2, 0xd7, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, 0x3, \r
2749        0x2, 0x2, 0x2, 0xd8, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xda, 0x7, 0x8, \r
2750        0x2, 0x2, 0xda, 0x35, 0x3, 0x2, 0x2, 0x2, 0xdb, 0xdc, 0x5, 0x38, \r
2751        0x1d, 0x2, 0xdc, 0x37, 0x3, 0x2, 0x2, 0x2, 0xdd, 0xde, 0x5, 0x30, \r
2752        0x19, 0x2, 0xde, 0xdf, 0x7, 0x13, 0x2, 0x2, 0xdf, 0xe4, 0x5, 0x30, \r
2753        0x19, 0x2, 0xe0, 0xe1, 0x7, 0x13, 0x2, 0x2, 0xe1, 0xe3, 0x5, 0x30, \r
2754        0x19, 0x2, 0xe2, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xe3, 0xe6, 0x3, 0x2, \r
2755        0x2, 0x2, 0xe4, 0xe2, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x3, 0x2, 0x2, \r
2756        0x2, 0xe5, 0x39, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe4, 0x3, 0x2, 0x2, 0x2, \r
2757        0xe7, 0xe8, 0x5, 0x46, 0x24, 0x2, 0xe8, 0x3b, 0x3, 0x2, 0x2, 0x2, \r
2758        0xe9, 0xea, 0x7, 0x14, 0x2, 0x2, 0xea, 0x3d, 0x3, 0x2, 0x2, 0x2, \r
2759        0xeb, 0xec, 0x5, 0x32, 0x1a, 0x2, 0xec, 0xed, 0x7, 0x10, 0x2, 0x2, \r
2760        0xed, 0xee, 0x5, 0x2e, 0x18, 0x2, 0xee, 0xef, 0x7, 0x11, 0x2, 0x2, \r
2761        0xef, 0x3f, 0x3, 0x2, 0x2, 0x2, 0xf0, 0xf1, 0x5, 0x3a, 0x1e, 0x2, \r
2762        0xf1, 0xf2, 0x7, 0x12, 0x2, 0x2, 0xf2, 0xf3, 0x5, 0x3a, 0x1e, 0x2, \r
2763        0xf3, 0x41, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf5, 0x7, 0x7, 0x2, 0x2, 0xf5, \r
2764        0xf6, 0x5, 0x2e, 0x18, 0x2, 0xf6, 0xf7, 0x7, 0x8, 0x2, 0x2, 0xf7, \r
2765        0x43, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xf9, 0x7, 0x15, 0x2, 0x2, 0xf9, \r
2766        0x45, 0x3, 0x2, 0x2, 0x2, 0xfa, 0xfb, 0x7, 0x15, 0x2, 0x2, 0xfb, \r
2767        0x47, 0x3, 0x2, 0x2, 0x2, 0xfc, 0xfd, 0x7, 0x15, 0x2, 0x2, 0xfd, \r
2768        0x49, 0x3, 0x2, 0x2, 0x2, 0xfe, 0xff, 0x7, 0x15, 0x2, 0x2, 0xff, \r
2769        0x4b, 0x3, 0x2, 0x2, 0x2, 0x11, 0x4f, 0x56, 0x61, 0x75, 0x78, 0x83, \r
2770        0x8e, 0x95, 0xa1, 0xbd, 0xc5, 0xcb, 0xd4, 0xd7, 0xe4, \r
2771   };\r
2772 \r
2773   _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,\r
2774     serializedATNSegment0 + sizeof(serializedATNSegment0) / sizeof(serializedATNSegment0[0]));\r
2775 \r
2776 \r
2777   atn::ATNDeserializer deserializer;\r
2778   _atn = deserializer.deserialize(_serializedATN);\r
2779 \r
2780   size_t count = _atn.getNumberOfDecisions();\r
2781   _decisionToDFA.reserve(count);\r
2782   for (size_t i = 0; i < count; i++) { \r
2783     _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);\r
2784   }\r
2785 }\r
2786 \r
2787 TocParser::Initializer TocParser::_init;\r