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

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