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