X-Git-Url: https://gitweb.ps.run/toc/blobdiff_plain/45409c781a9e35df68c43b1e2f028d30bf90c0a0..8aeae09e74b46ca52866f22b48f55fecdf27b849:/gen/TocParser.cpp diff --git a/gen/TocParser.cpp b/gen/TocParser.cpp index 8c58634..5c5f85b 100644 --- a/gen/TocParser.cpp +++ b/gen/TocParser.cpp @@ -80,20 +80,20 @@ TocParser::ProgContext* TocParser::prog() { }); try { enterOuterAlt(_localctx, 1); - setState(75); + setState(99); _errHandler->sync(this); _la = _input->LA(1); do { - setState(74); + setState(98); decl(); - setState(77); + setState(101); _errHandler->sync(this); _la = _input->LA(1); } while ((((_la & ~ 0x3fULL) == 0) && - ((1ULL << _la) & ((1ULL << TocParser::T__0) - | (1ULL << TocParser::T__3) - | (1ULL << TocParser::T__9))) != 0)); - setState(79); + ((1ULL << _la) & ((1ULL << TocParser::T__1) + | (1ULL << TocParser::T__7) + | (1ULL << TocParser::T__13))) != 0)); + setState(103); match(TocParser::EOF); } @@ -153,26 +153,28 @@ TocParser::DeclContext* TocParser::decl() { exitRule(); }); try { - setState(84); + setState(110); _errHandler->sync(this); switch (_input->LA(1)) { - case TocParser::T__0: { + case TocParser::T__1: { enterOuterAlt(_localctx, 1); - setState(81); + setState(105); varDecl(); + setState(106); + match(TocParser::T__0); break; } - case TocParser::T__3: { + case TocParser::T__7: { enterOuterAlt(_localctx, 2); - setState(82); + setState(108); funcDecl(); break; } - case TocParser::T__9: { + case TocParser::T__13: { enterOuterAlt(_localctx, 3); - setState(83); + setState(109); structDecl(); break; } @@ -231,9 +233,9 @@ TocParser::VarDeclContext* TocParser::varDecl() { }); try { enterOuterAlt(_localctx, 1); - setState(86); - match(TocParser::T__0); - setState(87); + setState(112); + match(TocParser::T__1); + setState(113); var(); } @@ -295,21 +297,21 @@ TocParser::VarContext* TocParser::var() { }); try { enterOuterAlt(_localctx, 1); - setState(89); + setState(115); varName(); - setState(90); - match(TocParser::T__1); - setState(91); + setState(116); + match(TocParser::T__2); + setState(117); type(); - setState(95); + setState(121); _errHandler->sync(this); _la = _input->LA(1); - if (_la == TocParser::T__2) { - setState(93); - match(TocParser::T__2); - setState(94); + if (_la == TocParser::T__3) { + setState(119); + match(TocParser::T__3); + setState(120); expr(); } @@ -323,6 +325,77 @@ TocParser::VarContext* TocParser::var() { return _localctx; } +//----------------- VarInitContext ------------------------------------------------------------------ + +TocParser::VarInitContext::VarInitContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::VarNameContext* TocParser::VarInitContext::varName() { + return getRuleContext(0); +} + +TocParser::TypeContext* TocParser::VarInitContext::type() { + return getRuleContext(0); +} + +TocParser::ExprContext* TocParser::VarInitContext::expr() { + return getRuleContext(0); +} + + +size_t TocParser::VarInitContext::getRuleIndex() const { + return TocParser::RuleVarInit; +} + +void TocParser::VarInitContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterVarInit(this); +} + +void TocParser::VarInitContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitVarInit(this); +} + +TocParser::VarInitContext* TocParser::varInit() { + VarInitContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 8, TocParser::RuleVarInit); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(123); + varName(); + + setState(124); + match(TocParser::T__2); + setState(125); + type(); + + setState(127); + match(TocParser::T__3); + setState(128); + expr(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + //----------------- TypeContext ------------------------------------------------------------------ TocParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState) @@ -333,6 +406,14 @@ TocParser::TypeNameContext* TocParser::TypeContext::typeName() { return getRuleContext(0); } +std::vector TocParser::TypeContext::typeModifier() { + return getRuleContexts(); +} + +TocParser::TypeModifierContext* TocParser::TypeContext::typeModifier(size_t i) { + return getRuleContext(i); +} + size_t TocParser::TypeContext::getRuleIndex() const { return TocParser::RuleType; @@ -352,7 +433,8 @@ void TocParser::TypeContext::exitRule(tree::ParseTreeListener *listener) { TocParser::TypeContext* TocParser::type() { TypeContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 8, TocParser::RuleType); + enterRule(_localctx, 10, TocParser::RuleType); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -363,8 +445,101 @@ TocParser::TypeContext* TocParser::type() { }); try { enterOuterAlt(_localctx, 1); - setState(97); + setState(130); typeName(); + setState(134); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TocParser::T__4 + + || _la == TocParser::T__5) { + setState(131); + typeModifier(); + setState(136); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TypeModifierContext ------------------------------------------------------------------ + +TocParser::TypeModifierContext::TypeModifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TocParser::TypeModifierContext::INT_LIT() { + return getToken(TocParser::INT_LIT, 0); +} + + +size_t TocParser::TypeModifierContext::getRuleIndex() const { + return TocParser::RuleTypeModifier; +} + +void TocParser::TypeModifierContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterTypeModifier(this); +} + +void TocParser::TypeModifierContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitTypeModifier(this); +} + +TocParser::TypeModifierContext* TocParser::typeModifier() { + TypeModifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 12, TocParser::RuleTypeModifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(143); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TocParser::T__4: { + enterOuterAlt(_localctx, 1); + setState(137); + match(TocParser::T__4); + break; + } + + case TocParser::T__5: { + enterOuterAlt(_localctx, 2); + setState(138); + match(TocParser::T__5); + setState(140); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == TocParser::INT_LIT) { + setState(139); + match(TocParser::INT_LIT); + } + setState(142); + match(TocParser::T__6); + break; + } + + default: + throw NoViableAltException(this); + } } catch (RecognitionException &e) { @@ -405,7 +580,7 @@ void TocParser::FuncDeclContext::exitRule(tree::ParseTreeListener *listener) { TocParser::FuncDeclContext* TocParser::funcDecl() { FuncDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 10, TocParser::RuleFuncDecl); + enterRule(_localctx, 14, TocParser::RuleFuncDecl); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -416,9 +591,9 @@ TocParser::FuncDeclContext* TocParser::funcDecl() { }); try { enterOuterAlt(_localctx, 1); - setState(99); - match(TocParser::T__3); - setState(100); + setState(145); + match(TocParser::T__7); + setState(146); func(); } @@ -472,7 +647,7 @@ void TocParser::FuncContext::exitRule(tree::ParseTreeListener *listener) { TocParser::FuncContext* TocParser::func() { FuncContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 12, TocParser::RuleFunc); + enterRule(_localctx, 16, TocParser::RuleFunc); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -483,20 +658,20 @@ TocParser::FuncContext* TocParser::func() { }); try { enterOuterAlt(_localctx, 1); - setState(102); + setState(148); funcName(); - setState(103); - match(TocParser::T__4); - setState(104); + setState(149); + match(TocParser::T__8); + setState(150); parameter(); - setState(105); - match(TocParser::T__5); + setState(151); + match(TocParser::T__9); - setState(106); - match(TocParser::T__1); - setState(107); + setState(152); + match(TocParser::T__2); + setState(153); type(); - setState(109); + setState(155); body(); } @@ -515,16 +690,12 @@ TocParser::ParameterContext::ParameterContext(ParserRuleContext *parent, size_t : ParserRuleContext(parent, invokingState) { } -TocParser::FirstParameterContext* TocParser::ParameterContext::firstParameter() { - return getRuleContext(0); -} - -std::vector TocParser::ParameterContext::additionalParameter() { - return getRuleContexts(); +std::vector TocParser::ParameterContext::var() { + return getRuleContexts(); } -TocParser::AdditionalParameterContext* TocParser::ParameterContext::additionalParameter(size_t i) { - return getRuleContext(i); +TocParser::VarContext* TocParser::ParameterContext::var(size_t i) { + return getRuleContext(i); } @@ -546,7 +717,7 @@ void TocParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) { TocParser::ParameterContext* TocParser::parameter() { ParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 14, TocParser::RuleParameter); + enterRule(_localctx, 18, TocParser::RuleParameter); size_t _la = 0; #if __cplusplus > 201703L @@ -558,20 +729,22 @@ TocParser::ParameterContext* TocParser::parameter() { }); try { enterOuterAlt(_localctx, 1); - setState(118); + setState(165); _errHandler->sync(this); _la = _input->LA(1); if (_la == TocParser::NAME) { - setState(111); - firstParameter(); - setState(115); + setState(157); + var(); + setState(162); _errHandler->sync(this); _la = _input->LA(1); - while (_la == TocParser::T__6) { - setState(112); - additionalParameter(); - setState(117); + while (_la == TocParser::T__10) { + setState(158); + match(TocParser::T__10); + setState(159); + var(); + setState(164); _errHandler->sync(this); _la = _input->LA(1); } @@ -587,114 +760,6 @@ TocParser::ParameterContext* TocParser::parameter() { return _localctx; } -//----------------- FirstParameterContext ------------------------------------------------------------------ - -TocParser::FirstParameterContext::FirstParameterContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -TocParser::VarContext* TocParser::FirstParameterContext::var() { - return getRuleContext(0); -} - - -size_t TocParser::FirstParameterContext::getRuleIndex() const { - return TocParser::RuleFirstParameter; -} - -void TocParser::FirstParameterContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterFirstParameter(this); -} - -void TocParser::FirstParameterContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitFirstParameter(this); -} - -TocParser::FirstParameterContext* TocParser::firstParameter() { - FirstParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 16, TocParser::RuleFirstParameter); - -#if __cplusplus > 201703L - auto onExit = finally([=, this] { -#else - auto onExit = finally([=] { -#endif - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(120); - var(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- AdditionalParameterContext ------------------------------------------------------------------ - -TocParser::AdditionalParameterContext::AdditionalParameterContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -TocParser::VarContext* TocParser::AdditionalParameterContext::var() { - return getRuleContext(0); -} - - -size_t TocParser::AdditionalParameterContext::getRuleIndex() const { - return TocParser::RuleAdditionalParameter; -} - -void TocParser::AdditionalParameterContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterAdditionalParameter(this); -} - -void TocParser::AdditionalParameterContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitAdditionalParameter(this); -} - -TocParser::AdditionalParameterContext* TocParser::additionalParameter() { - AdditionalParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 18, TocParser::RuleAdditionalParameter); - -#if __cplusplus > 201703L - auto onExit = finally([=, this] { -#else - auto onExit = finally([=] { -#endif - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(122); - match(TocParser::T__6); - setState(123); - var(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - //----------------- BodyContext ------------------------------------------------------------------ TocParser::BodyContext::BodyContext(ParserRuleContext *parent, size_t invokingState) @@ -740,27 +805,40 @@ TocParser::BodyContext* TocParser::body() { }); try { enterOuterAlt(_localctx, 1); - setState(125); - match(TocParser::T__7); - setState(129); + setState(167); + match(TocParser::T__11); + setState(171); _errHandler->sync(this); _la = _input->LA(1); while ((((_la & ~ 0x3fULL) == 0) && - ((1ULL << _la) & ((1ULL << TocParser::T__0) + ((1ULL << _la) & ((1ULL << TocParser::T__1) | (1ULL << TocParser::T__4) - | (1ULL << TocParser::T__10) - | (1ULL << TocParser::T__11) - | (1ULL << TocParser::T__12) - | (1ULL << TocParser::INTLIT) + | (1ULL << TocParser::T__8) + | (1ULL << TocParser::T__14) + | (1ULL << TocParser::T__16) + | (1ULL << TocParser::T__18) + | (1ULL << TocParser::T__19) + | (1ULL << TocParser::T__20) + | (1ULL << TocParser::T__24) + | (1ULL << TocParser::T__25) + | (1ULL << TocParser::T__26) + | (1ULL << TocParser::T__27) + | (1ULL << TocParser::T__28) + | (1ULL << TocParser::T__29) + | (1ULL << TocParser::T__30) + | (1ULL << TocParser::INT_LIT) + | (1ULL << TocParser::DECIMAL_LIT) + | (1ULL << TocParser::STRING_LIT) + | (1ULL << TocParser::BOOL_LIT) | (1ULL << TocParser::NAME))) != 0)) { - setState(126); + setState(168); stmt(); - setState(131); + setState(173); _errHandler->sync(this); _la = _input->LA(1); } - setState(132); - match(TocParser::T__8); + setState(174); + match(TocParser::T__12); } catch (RecognitionException &e) { @@ -821,24 +899,24 @@ TocParser::StructDeclContext* TocParser::structDecl() { }); try { enterOuterAlt(_localctx, 1); - setState(134); - match(TocParser::T__9); - setState(135); + setState(176); + match(TocParser::T__13); + setState(177); structName(); - setState(136); - match(TocParser::T__7); - setState(140); + setState(178); + match(TocParser::T__11); + setState(182); _errHandler->sync(this); _la = _input->LA(1); while (_la == TocParser::NAME) { - setState(137); + setState(179); structMember(); - setState(142); + setState(184); _errHandler->sync(this); _la = _input->LA(1); } - setState(143); - match(TocParser::T__8); + setState(185); + match(TocParser::T__12); } catch (RecognitionException &e) { @@ -893,19 +971,19 @@ TocParser::StructMemberContext* TocParser::structMember() { exitRule(); }); try { - setState(147); + setState(189); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 7, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 10, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(145); + setState(187); structVar(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(146); + setState(188); structMethod(); break; } @@ -964,8 +1042,10 @@ TocParser::StructVarContext* TocParser::structVar() { }); try { enterOuterAlt(_localctx, 1); - setState(149); + setState(191); var(); + setState(192); + match(TocParser::T__0); } catch (RecognitionException &e) { @@ -1017,7 +1097,7 @@ TocParser::StructMethodContext* TocParser::structMethod() { }); try { enterOuterAlt(_localctx, 1); - setState(151); + setState(194); func(); } @@ -1040,16 +1120,24 @@ TocParser::VarDeclContext* TocParser::StmtContext::varDecl() { return getRuleContext(0); } -TocParser::ConditionalContext* TocParser::StmtContext::conditional() { - return getRuleContext(0); +TocParser::IfStmtContext* TocParser::StmtContext::ifStmt() { + return getRuleContext(0); } -TocParser::LoopContext* TocParser::StmtContext::loop() { - return getRuleContext(0); +TocParser::SwitchStmtContext* TocParser::StmtContext::switchStmt() { + return getRuleContext(0); } -TocParser::AssignmentContext* TocParser::StmtContext::assignment() { - return getRuleContext(0); +TocParser::ForStmtContext* TocParser::StmtContext::forStmt() { + return getRuleContext(0); +} + +TocParser::WhileStmtContext* TocParser::StmtContext::whileStmt() { + return getRuleContext(0); +} + +TocParser::AssignStmtContext* TocParser::StmtContext::assignStmt() { + return getRuleContext(0); } TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() { @@ -1089,43 +1177,70 @@ TocParser::StmtContext* TocParser::stmt() { exitRule(); }); try { - enterOuterAlt(_localctx, 1); - setState(159); + setState(212); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 8, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { case 1: { - setState(153); + enterOuterAlt(_localctx, 1); + setState(196); varDecl(); + setState(197); + match(TocParser::T__0); break; } case 2: { - setState(154); - conditional(); + enterOuterAlt(_localctx, 2); + setState(199); + ifStmt(); break; } case 3: { - setState(155); - loop(); + enterOuterAlt(_localctx, 3); + setState(200); + switchStmt(); break; } case 4: { - setState(156); - assignment(); + enterOuterAlt(_localctx, 4); + setState(201); + forStmt(); break; } case 5: { - setState(157); - returnStmt(); + enterOuterAlt(_localctx, 5); + setState(202); + whileStmt(); break; } case 6: { - setState(158); + enterOuterAlt(_localctx, 6); + setState(203); + assignStmt(); + setState(204); + match(TocParser::T__0); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(206); + returnStmt(); + setState(207); + match(TocParser::T__0); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(209); expr(); + setState(210); + match(TocParser::T__0); break; } @@ -1143,36 +1258,53 @@ TocParser::StmtContext* TocParser::stmt() { return _localctx; } -//----------------- ConditionalContext ------------------------------------------------------------------ +//----------------- IfStmtContext ------------------------------------------------------------------ -TocParser::ConditionalContext::ConditionalContext(ParserRuleContext *parent, size_t invokingState) +TocParser::IfStmtContext::IfStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::IfCondContext* TocParser::ConditionalContext::ifCond() { - return getRuleContext(0); +TocParser::ExprContext* TocParser::IfStmtContext::expr() { + return getRuleContext(0); +} + +TocParser::BodyContext* TocParser::IfStmtContext::body() { + return getRuleContext(0); +} + +std::vector TocParser::IfStmtContext::elseIfStmt() { + return getRuleContexts(); +} + +TocParser::ElseIfStmtContext* TocParser::IfStmtContext::elseIfStmt(size_t i) { + return getRuleContext(i); +} + +TocParser::ElseStmtContext* TocParser::IfStmtContext::elseStmt() { + return getRuleContext(0); } -size_t TocParser::ConditionalContext::getRuleIndex() const { - return TocParser::RuleConditional; +size_t TocParser::IfStmtContext::getRuleIndex() const { + return TocParser::RuleIfStmt; } -void TocParser::ConditionalContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::IfStmtContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterConditional(this); + parserListener->enterIfStmt(this); } -void TocParser::ConditionalContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::IfStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitConditional(this); + parserListener->exitIfStmt(this); } -TocParser::ConditionalContext* TocParser::conditional() { - ConditionalContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 32, TocParser::RuleConditional); +TocParser::IfStmtContext* TocParser::ifStmt() { + IfStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 32, TocParser::RuleIfStmt); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1182,9 +1314,34 @@ TocParser::ConditionalContext* TocParser::conditional() { exitRule(); }); try { + size_t alt; enterOuterAlt(_localctx, 1); - setState(161); - ifCond(); + setState(214); + match(TocParser::T__14); + setState(215); + expr(); + setState(216); + body(); + setState(220); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 12, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(217); + elseIfStmt(); + } + setState(222); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 12, _ctx); + } + setState(224); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == TocParser::T__15) { + setState(223); + elseStmt(); + } } catch (RecognitionException &e) { @@ -1196,40 +1353,40 @@ TocParser::ConditionalContext* TocParser::conditional() { return _localctx; } -//----------------- IfCondContext ------------------------------------------------------------------ +//----------------- ElseIfStmtContext ------------------------------------------------------------------ -TocParser::IfCondContext::IfCondContext(ParserRuleContext *parent, size_t invokingState) +TocParser::ElseIfStmtContext::ElseIfStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::ExprContext* TocParser::IfCondContext::expr() { +TocParser::ExprContext* TocParser::ElseIfStmtContext::expr() { return getRuleContext(0); } -TocParser::BodyContext* TocParser::IfCondContext::body() { +TocParser::BodyContext* TocParser::ElseIfStmtContext::body() { return getRuleContext(0); } -size_t TocParser::IfCondContext::getRuleIndex() const { - return TocParser::RuleIfCond; +size_t TocParser::ElseIfStmtContext::getRuleIndex() const { + return TocParser::RuleElseIfStmt; } -void TocParser::IfCondContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::ElseIfStmtContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterIfCond(this); + parserListener->enterElseIfStmt(this); } -void TocParser::IfCondContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::ElseIfStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitIfCond(this); + parserListener->exitElseIfStmt(this); } -TocParser::IfCondContext* TocParser::ifCond() { - IfCondContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 34, TocParser::RuleIfCond); +TocParser::ElseIfStmtContext* TocParser::elseIfStmt() { + ElseIfStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 34, TocParser::RuleElseIfStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1240,11 +1397,13 @@ TocParser::IfCondContext* TocParser::ifCond() { }); try { enterOuterAlt(_localctx, 1); - setState(163); - match(TocParser::T__10); - setState(164); + setState(226); + match(TocParser::T__15); + setState(227); + match(TocParser::T__14); + setState(228); expr(); - setState(165); + setState(229); body(); } @@ -1257,36 +1416,36 @@ TocParser::IfCondContext* TocParser::ifCond() { return _localctx; } -//----------------- LoopContext ------------------------------------------------------------------ +//----------------- ElseStmtContext ------------------------------------------------------------------ -TocParser::LoopContext::LoopContext(ParserRuleContext *parent, size_t invokingState) +TocParser::ElseStmtContext::ElseStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::WhileLoopContext* TocParser::LoopContext::whileLoop() { - return getRuleContext(0); +TocParser::BodyContext* TocParser::ElseStmtContext::body() { + return getRuleContext(0); } -size_t TocParser::LoopContext::getRuleIndex() const { - return TocParser::RuleLoop; +size_t TocParser::ElseStmtContext::getRuleIndex() const { + return TocParser::RuleElseStmt; } -void TocParser::LoopContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::ElseStmtContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterLoop(this); + parserListener->enterElseStmt(this); } -void TocParser::LoopContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::ElseStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitLoop(this); + parserListener->exitElseStmt(this); } -TocParser::LoopContext* TocParser::loop() { - LoopContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 36, TocParser::RuleLoop); +TocParser::ElseStmtContext* TocParser::elseStmt() { + ElseStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 36, TocParser::RuleElseStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1297,8 +1456,10 @@ TocParser::LoopContext* TocParser::loop() { }); try { enterOuterAlt(_localctx, 1); - setState(167); - whileLoop(); + setState(231); + match(TocParser::T__15); + setState(232); + body(); } catch (RecognitionException &e) { @@ -1310,40 +1471,40 @@ TocParser::LoopContext* TocParser::loop() { return _localctx; } -//----------------- WhileLoopContext ------------------------------------------------------------------ +//----------------- SwitchStmtContext ------------------------------------------------------------------ -TocParser::WhileLoopContext::WhileLoopContext(ParserRuleContext *parent, size_t invokingState) +TocParser::SwitchStmtContext::SwitchStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::ExprContext* TocParser::WhileLoopContext::expr() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::SwitchStmtContext::identifierExpr() { + return getRuleContext(0); } -TocParser::BodyContext* TocParser::WhileLoopContext::body() { - return getRuleContext(0); +TocParser::SwitchBodyContext* TocParser::SwitchStmtContext::switchBody() { + return getRuleContext(0); } -size_t TocParser::WhileLoopContext::getRuleIndex() const { - return TocParser::RuleWhileLoop; +size_t TocParser::SwitchStmtContext::getRuleIndex() const { + return TocParser::RuleSwitchStmt; } -void TocParser::WhileLoopContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchStmtContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterWhileLoop(this); + parserListener->enterSwitchStmt(this); } -void TocParser::WhileLoopContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitWhileLoop(this); + parserListener->exitSwitchStmt(this); } -TocParser::WhileLoopContext* TocParser::whileLoop() { - WhileLoopContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 38, TocParser::RuleWhileLoop); +TocParser::SwitchStmtContext* TocParser::switchStmt() { + SwitchStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 38, TocParser::RuleSwitchStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1354,12 +1515,12 @@ TocParser::WhileLoopContext* TocParser::whileLoop() { }); try { enterOuterAlt(_localctx, 1); - setState(169); - match(TocParser::T__11); - setState(170); - expr(); - setState(171); - body(); + setState(234); + match(TocParser::T__16); + setState(235); + identifierExpr(); + setState(236); + switchBody(); } catch (RecognitionException &e) { @@ -1371,40 +1532,41 @@ TocParser::WhileLoopContext* TocParser::whileLoop() { return _localctx; } -//----------------- AssignmentContext ------------------------------------------------------------------ +//----------------- SwitchBodyContext ------------------------------------------------------------------ -TocParser::AssignmentContext::AssignmentContext(ParserRuleContext *parent, size_t invokingState) +TocParser::SwitchBodyContext::SwitchBodyContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::IdentifierContext* TocParser::AssignmentContext::identifier() { - return getRuleContext(0); +std::vector TocParser::SwitchBodyContext::switchCase() { + return getRuleContexts(); } -TocParser::ExprContext* TocParser::AssignmentContext::expr() { - return getRuleContext(0); +TocParser::SwitchCaseContext* TocParser::SwitchBodyContext::switchCase(size_t i) { + return getRuleContext(i); } -size_t TocParser::AssignmentContext::getRuleIndex() const { - return TocParser::RuleAssignment; +size_t TocParser::SwitchBodyContext::getRuleIndex() const { + return TocParser::RuleSwitchBody; } -void TocParser::AssignmentContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchBodyContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterAssignment(this); + parserListener->enterSwitchBody(this); } -void TocParser::AssignmentContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchBodyContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitAssignment(this); + parserListener->exitSwitchBody(this); } -TocParser::AssignmentContext* TocParser::assignment() { - AssignmentContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 40, TocParser::RuleAssignment); +TocParser::SwitchBodyContext* TocParser::switchBody() { + SwitchBodyContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 40, TocParser::RuleSwitchBody); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1415,12 +1577,20 @@ TocParser::AssignmentContext* TocParser::assignment() { }); try { enterOuterAlt(_localctx, 1); - setState(173); - identifier(); - setState(174); - match(TocParser::T__2); - setState(175); - expr(); + setState(238); + match(TocParser::T__11); + setState(242); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TocParser::T__17) { + setState(239); + switchCase(); + setState(244); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(245); + match(TocParser::T__12); } catch (RecognitionException &e) { @@ -1432,36 +1602,40 @@ TocParser::AssignmentContext* TocParser::assignment() { return _localctx; } -//----------------- ReturnStmtContext ------------------------------------------------------------------ +//----------------- SwitchCaseContext ------------------------------------------------------------------ -TocParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState) +TocParser::SwitchCaseContext::SwitchCaseContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::ExprContext* TocParser::ReturnStmtContext::expr() { +TocParser::ExprContext* TocParser::SwitchCaseContext::expr() { return getRuleContext(0); } +TocParser::BodyContext* TocParser::SwitchCaseContext::body() { + return getRuleContext(0); +} + -size_t TocParser::ReturnStmtContext::getRuleIndex() const { - return TocParser::RuleReturnStmt; +size_t TocParser::SwitchCaseContext::getRuleIndex() const { + return TocParser::RuleSwitchCase; } -void TocParser::ReturnStmtContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchCaseContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterReturnStmt(this); + parserListener->enterSwitchCase(this); } -void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchCaseContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitReturnStmt(this); + parserListener->exitSwitchCase(this); } -TocParser::ReturnStmtContext* TocParser::returnStmt() { - ReturnStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 42, TocParser::RuleReturnStmt); +TocParser::SwitchCaseContext* TocParser::switchCase() { + SwitchCaseContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 42, TocParser::RuleSwitchCase); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1472,10 +1646,12 @@ TocParser::ReturnStmtContext* TocParser::returnStmt() { }); try { enterOuterAlt(_localctx, 1); - setState(177); - match(TocParser::T__12); - setState(178); + setState(247); + match(TocParser::T__17); + setState(248); expr(); + setState(249); + body(); } catch (RecognitionException &e) { @@ -1487,60 +1663,52 @@ TocParser::ReturnStmtContext* TocParser::returnStmt() { return _localctx; } -//----------------- ExprContext ------------------------------------------------------------------ +//----------------- ForStmtContext ------------------------------------------------------------------ -TocParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::ForStmtContext::ForStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncCallContext* TocParser::ExprContext::funcCall() { - return getRuleContext(0); -} - -TocParser::LiteralContext* TocParser::ExprContext::literal() { - return getRuleContext(0); -} - -TocParser::IdentifierContext* TocParser::ExprContext::identifier() { - return getRuleContext(0); +std::vector TocParser::ForStmtContext::expr() { + return getRuleContexts(); } -TocParser::SubscriptContext* TocParser::ExprContext::subscript() { - return getRuleContext(0); +TocParser::ExprContext* TocParser::ForStmtContext::expr(size_t i) { + return getRuleContext(i); } -TocParser::MemberAccessContext* TocParser::ExprContext::memberAccess() { - return getRuleContext(0); +TocParser::BodyContext* TocParser::ForStmtContext::body() { + return getRuleContext(0); } -TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() { - return getRuleContext(0); +TocParser::VarInitContext* TocParser::ForStmtContext::varInit() { + return getRuleContext(0); } -TocParser::OperatorExprContext* TocParser::ExprContext::operatorExpr() { - return getRuleContext(0); +TocParser::AssignStmtContext* TocParser::ForStmtContext::assignStmt() { + return getRuleContext(0); } -size_t TocParser::ExprContext::getRuleIndex() const { - return TocParser::RuleExpr; +size_t TocParser::ForStmtContext::getRuleIndex() const { + return TocParser::RuleForStmt; } -void TocParser::ExprContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::ForStmtContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterExpr(this); + parserListener->enterForStmt(this); } -void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::ForStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitExpr(this); + parserListener->exitForStmt(this); } -TocParser::ExprContext* TocParser::expr() { - ExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 44, TocParser::RuleExpr); +TocParser::ForStmtContext* TocParser::forStmt() { + ForStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 44, TocParser::RuleForStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1550,61 +1718,37 @@ TocParser::ExprContext* TocParser::expr() { exitRule(); }); try { - setState(187); + enterOuterAlt(_localctx, 1); + setState(251); + match(TocParser::T__18); + setState(254); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 9, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 15, _ctx)) { case 1: { - enterOuterAlt(_localctx, 1); - setState(180); - funcCall(); + setState(252); + varInit(); break; } case 2: { - enterOuterAlt(_localctx, 2); - setState(181); - literal(); - break; - } - - case 3: { - enterOuterAlt(_localctx, 3); - setState(182); - identifier(); - break; - } - - case 4: { - enterOuterAlt(_localctx, 4); - setState(183); - subscript(); - break; - } - - case 5: { - enterOuterAlt(_localctx, 5); - setState(184); - memberAccess(); - break; - } - - case 6: { - enterOuterAlt(_localctx, 6); - setState(185); - parenExpr(); - break; - } - - case 7: { - enterOuterAlt(_localctx, 7); - setState(186); - operatorExpr(); + setState(253); + assignStmt(); break; } default: break; } + setState(256); + match(TocParser::T__10); + setState(257); + expr(); + setState(258); + match(TocParser::T__10); + setState(259); + expr(); + setState(260); + body(); } catch (RecognitionException &e) { @@ -1616,56 +1760,40 @@ TocParser::ExprContext* TocParser::expr() { return _localctx; } -//----------------- NonOpExprContext ------------------------------------------------------------------ +//----------------- WhileStmtContext ------------------------------------------------------------------ -TocParser::NonOpExprContext::NonOpExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::WhileStmtContext::WhileStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncCallContext* TocParser::NonOpExprContext::funcCall() { - return getRuleContext(0); -} - -TocParser::LiteralContext* TocParser::NonOpExprContext::literal() { - return getRuleContext(0); -} - -TocParser::IdentifierContext* TocParser::NonOpExprContext::identifier() { - return getRuleContext(0); -} - -TocParser::SubscriptContext* TocParser::NonOpExprContext::subscript() { - return getRuleContext(0); -} - -TocParser::MemberAccessContext* TocParser::NonOpExprContext::memberAccess() { - return getRuleContext(0); +TocParser::ExprContext* TocParser::WhileStmtContext::expr() { + return getRuleContext(0); } -TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() { - return getRuleContext(0); +TocParser::BodyContext* TocParser::WhileStmtContext::body() { + return getRuleContext(0); } -size_t TocParser::NonOpExprContext::getRuleIndex() const { - return TocParser::RuleNonOpExpr; +size_t TocParser::WhileStmtContext::getRuleIndex() const { + return TocParser::RuleWhileStmt; } -void TocParser::NonOpExprContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::WhileStmtContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterNonOpExpr(this); + parserListener->enterWhileStmt(this); } -void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::WhileStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitNonOpExpr(this); + parserListener->exitWhileStmt(this); } -TocParser::NonOpExprContext* TocParser::nonOpExpr() { - NonOpExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 46, TocParser::RuleNonOpExpr); +TocParser::WhileStmtContext* TocParser::whileStmt() { + WhileStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 46, TocParser::RuleWhileStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1675,54 +1803,13 @@ TocParser::NonOpExprContext* TocParser::nonOpExpr() { exitRule(); }); try { - setState(195); - _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 10, _ctx)) { - case 1: { - enterOuterAlt(_localctx, 1); - setState(189); - funcCall(); - break; - } - - case 2: { - enterOuterAlt(_localctx, 2); - setState(190); - literal(); - break; - } - - case 3: { - enterOuterAlt(_localctx, 3); - setState(191); - identifier(); - break; - } - - case 4: { - enterOuterAlt(_localctx, 4); - setState(192); - subscript(); - break; - } - - case 5: { - enterOuterAlt(_localctx, 5); - setState(193); - memberAccess(); - break; - } - - case 6: { - enterOuterAlt(_localctx, 6); - setState(194); - parenExpr(); - break; - } - - default: - break; - } + enterOuterAlt(_localctx, 1); + setState(262); + match(TocParser::T__19); + setState(263); + expr(); + setState(264); + body(); } catch (RecognitionException &e) { @@ -1734,48 +1821,40 @@ TocParser::NonOpExprContext* TocParser::nonOpExpr() { return _localctx; } -//----------------- NonSubscriptExprContext ------------------------------------------------------------------ +//----------------- AssignStmtContext ------------------------------------------------------------------ -TocParser::NonSubscriptExprContext::NonSubscriptExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AssignStmtContext::AssignStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncCallContext* TocParser::NonSubscriptExprContext::funcCall() { - return getRuleContext(0); -} - -TocParser::IdentifierContext* TocParser::NonSubscriptExprContext::identifier() { - return getRuleContext(0); -} - -TocParser::MemberAccessContext* TocParser::NonSubscriptExprContext::memberAccess() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::AssignStmtContext::identifierExpr() { + return getRuleContext(0); } -TocParser::ParenExprContext* TocParser::NonSubscriptExprContext::parenExpr() { - return getRuleContext(0); +TocParser::ExprContext* TocParser::AssignStmtContext::expr() { + return getRuleContext(0); } -size_t TocParser::NonSubscriptExprContext::getRuleIndex() const { - return TocParser::RuleNonSubscriptExpr; +size_t TocParser::AssignStmtContext::getRuleIndex() const { + return TocParser::RuleAssignStmt; } -void TocParser::NonSubscriptExprContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::AssignStmtContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterNonSubscriptExpr(this); + parserListener->enterAssignStmt(this); } -void TocParser::NonSubscriptExprContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::AssignStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitNonSubscriptExpr(this); + parserListener->exitAssignStmt(this); } -TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { - NonSubscriptExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 48, TocParser::RuleNonSubscriptExpr); +TocParser::AssignStmtContext* TocParser::assignStmt() { + AssignStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 48, TocParser::RuleAssignStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1785,38 +1864,572 @@ TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { exitRule(); }); try { - setState(201); - _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { - case 1: { - enterOuterAlt(_localctx, 1); - setState(197); - funcCall(); - break; - } - - case 2: { - enterOuterAlt(_localctx, 2); - setState(198); - identifier(); - break; - } + enterOuterAlt(_localctx, 1); + setState(266); + identifierExpr(); + setState(267); + match(TocParser::T__3); + setState(268); + expr(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } - case 3: { - enterOuterAlt(_localctx, 3); - setState(199); - memberAccess(); - break; - } + return _localctx; +} - case 4: { - enterOuterAlt(_localctx, 4); - setState(200); - parenExpr(); - break; - } +//----------------- ReturnStmtContext ------------------------------------------------------------------ - default: +TocParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::ExprContext* TocParser::ReturnStmtContext::expr() { + return getRuleContext(0); +} + + +size_t TocParser::ReturnStmtContext::getRuleIndex() const { + return TocParser::RuleReturnStmt; +} + +void TocParser::ReturnStmtContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterReturnStmt(this); +} + +void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitReturnStmt(this); +} + +TocParser::ReturnStmtContext* TocParser::returnStmt() { + ReturnStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 50, TocParser::RuleReturnStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(270); + match(TocParser::T__20); + setState(271); + expr(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExprContext ------------------------------------------------------------------ + +TocParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::FuncExprContext* TocParser::ExprContext::funcExpr() { + return getRuleContext(0); +} + +TocParser::LitExprContext* TocParser::ExprContext::litExpr() { + return getRuleContext(0); +} + +TocParser::IdentifierExprContext* TocParser::ExprContext::identifierExpr() { + return getRuleContext(0); +} + +TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() { + return getRuleContext(0); +} + +TocParser::AccessExprContext* TocParser::ExprContext::accessExpr() { + return getRuleContext(0); +} + +TocParser::OpExprContext* TocParser::ExprContext::opExpr() { + return getRuleContext(0); +} + + +size_t TocParser::ExprContext::getRuleIndex() const { + return TocParser::RuleExpr; +} + +void TocParser::ExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterExpr(this); +} + +void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitExpr(this); +} + +TocParser::ExprContext* TocParser::expr() { + ExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 52, TocParser::RuleExpr); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(279); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 16, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(273); + funcExpr(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(274); + litExpr(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(275); + identifierExpr(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(276); + parenExpr(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(277); + accessExpr(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(278); + opExpr(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NonOpExprContext ------------------------------------------------------------------ + +TocParser::NonOpExprContext::NonOpExprContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::FuncExprContext* TocParser::NonOpExprContext::funcExpr() { + return getRuleContext(0); +} + +TocParser::LitExprContext* TocParser::NonOpExprContext::litExpr() { + return getRuleContext(0); +} + +TocParser::IdentifierExprContext* TocParser::NonOpExprContext::identifierExpr() { + return getRuleContext(0); +} + +TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() { + return getRuleContext(0); +} + +TocParser::AccessExprContext* TocParser::NonOpExprContext::accessExpr() { + return getRuleContext(0); +} + + +size_t TocParser::NonOpExprContext::getRuleIndex() const { + return TocParser::RuleNonOpExpr; +} + +void TocParser::NonOpExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterNonOpExpr(this); +} + +void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitNonOpExpr(this); +} + +TocParser::NonOpExprContext* TocParser::nonOpExpr() { + NonOpExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 54, TocParser::RuleNonOpExpr); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(286); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 17, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(281); + funcExpr(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(282); + litExpr(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(283); + identifierExpr(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(284); + parenExpr(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(285); + accessExpr(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NonAccessExprContext ------------------------------------------------------------------ + +TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::FuncExprContext* TocParser::NonAccessExprContext::funcExpr() { + return getRuleContext(0); +} + +TocParser::IdentifierExprContext* TocParser::NonAccessExprContext::identifierExpr() { + return getRuleContext(0); +} + +TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() { + return getRuleContext(0); +} + + +size_t TocParser::NonAccessExprContext::getRuleIndex() const { + return TocParser::RuleNonAccessExpr; +} + +void TocParser::NonAccessExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterNonAccessExpr(this); +} + +void TocParser::NonAccessExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitNonAccessExpr(this); +} + +TocParser::NonAccessExprContext* TocParser::nonAccessExpr() { + NonAccessExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 56, TocParser::RuleNonAccessExpr); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(291); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 18, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(288); + funcExpr(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(289); + identifierExpr(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(290); + parenExpr(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FuncExprContext ------------------------------------------------------------------ + +TocParser::FuncExprContext::FuncExprContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::FuncNameContext* TocParser::FuncExprContext::funcName() { + return getRuleContext(0); +} + +std::vector TocParser::FuncExprContext::expr() { + return getRuleContexts(); +} + +TocParser::ExprContext* TocParser::FuncExprContext::expr(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::FuncExprContext::getRuleIndex() const { + return TocParser::RuleFuncExpr; +} + +void TocParser::FuncExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterFuncExpr(this); +} + +void TocParser::FuncExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitFuncExpr(this); +} + +TocParser::FuncExprContext* TocParser::funcExpr() { + FuncExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 58, TocParser::RuleFuncExpr); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(293); + funcName(); + setState(294); + match(TocParser::T__8); + setState(303); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__4) + | (1ULL << TocParser::T__8) + | (1ULL << TocParser::T__24) + | (1ULL << TocParser::T__25) + | (1ULL << TocParser::T__26) + | (1ULL << TocParser::T__27) + | (1ULL << TocParser::T__28) + | (1ULL << TocParser::T__29) + | (1ULL << TocParser::T__30) + | (1ULL << TocParser::INT_LIT) + | (1ULL << TocParser::DECIMAL_LIT) + | (1ULL << TocParser::STRING_LIT) + | (1ULL << TocParser::BOOL_LIT) + | (1ULL << TocParser::NAME))) != 0)) { + setState(295); + expr(); + setState(300); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TocParser::T__10) { + setState(296); + match(TocParser::T__10); + setState(297); + expr(); + setState(302); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(305); + match(TocParser::T__9); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- OpExprContext ------------------------------------------------------------------ + +TocParser::OpExprContext::OpExprContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::BinaryOpContext* TocParser::OpExprContext::binaryOp() { + return getRuleContext(0); +} + +TocParser::PrefixOpContext* TocParser::OpExprContext::prefixOp() { + return getRuleContext(0); +} + +TocParser::PostfixOpContext* TocParser::OpExprContext::postfixOp() { + return getRuleContext(0); +} + +TocParser::TernaryOpContext* TocParser::OpExprContext::ternaryOp() { + return getRuleContext(0); +} + + +size_t TocParser::OpExprContext::getRuleIndex() const { + return TocParser::RuleOpExpr; +} + +void TocParser::OpExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterOpExpr(this); +} + +void TocParser::OpExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitOpExpr(this); +} + +TocParser::OpExprContext* TocParser::opExpr() { + OpExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 60, TocParser::RuleOpExpr); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(311); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 21, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(307); + binaryOp(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(308); + prefixOp(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(309); + postfixOp(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(310); + ternaryOp(); + break; + } + + default: break; } @@ -1830,45 +2443,272 @@ TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { return _localctx; } -//----------------- FuncCallContext ------------------------------------------------------------------ +//----------------- BinaryOpContext ------------------------------------------------------------------ + +TocParser::BinaryOpContext::BinaryOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector TocParser::BinaryOpContext::nonOpExpr() { + return getRuleContexts(); +} + +TocParser::NonOpExprContext* TocParser::BinaryOpContext::nonOpExpr(size_t i) { + return getRuleContext(i); +} + +std::vector TocParser::BinaryOpContext::binary_op() { + return getRuleContexts(); +} + +TocParser::Binary_opContext* TocParser::BinaryOpContext::binary_op(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::BinaryOpContext::getRuleIndex() const { + return TocParser::RuleBinaryOp; +} + +void TocParser::BinaryOpContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterBinaryOp(this); +} + +void TocParser::BinaryOpContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitBinaryOp(this); +} + +TocParser::BinaryOpContext* TocParser::binaryOp() { + BinaryOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 62, TocParser::RuleBinaryOp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(313); + nonOpExpr(); + setState(314); + binary_op(); + setState(315); + nonOpExpr(); + setState(321); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__4) + | (1ULL << TocParser::T__26) + | (1ULL << TocParser::T__27) + | (1ULL << TocParser::T__30) + | (1ULL << TocParser::T__31) + | (1ULL << TocParser::T__32) + | (1ULL << TocParser::T__33) + | (1ULL << TocParser::T__34) + | (1ULL << TocParser::T__35) + | (1ULL << TocParser::T__36) + | (1ULL << TocParser::T__37) + | (1ULL << TocParser::T__38) + | (1ULL << TocParser::T__39) + | (1ULL << TocParser::T__40) + | (1ULL << TocParser::T__41) + | (1ULL << TocParser::T__42) + | (1ULL << TocParser::T__43) + | (1ULL << TocParser::T__44) + | (1ULL << TocParser::T__45) + | (1ULL << TocParser::T__46) + | (1ULL << TocParser::T__47) + | (1ULL << TocParser::T__48) + | (1ULL << TocParser::T__49) + | (1ULL << TocParser::T__50) + | (1ULL << TocParser::T__51) + | (1ULL << TocParser::T__52) + | (1ULL << TocParser::T__53) + | (1ULL << TocParser::T__54))) != 0)) { + setState(316); + binary_op(); + setState(317); + nonOpExpr(); + setState(323); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PrefixOpContext ------------------------------------------------------------------ + +TocParser::PrefixOpContext::PrefixOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::Prefix_opContext* TocParser::PrefixOpContext::prefix_op() { + return getRuleContext(0); +} + +TocParser::NonOpExprContext* TocParser::PrefixOpContext::nonOpExpr() { + return getRuleContext(0); +} + + +size_t TocParser::PrefixOpContext::getRuleIndex() const { + return TocParser::RulePrefixOp; +} + +void TocParser::PrefixOpContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterPrefixOp(this); +} + +void TocParser::PrefixOpContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitPrefixOp(this); +} + +TocParser::PrefixOpContext* TocParser::prefixOp() { + PrefixOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 64, TocParser::RulePrefixOp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(324); + prefix_op(); + setState(325); + nonOpExpr(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PostfixOpContext ------------------------------------------------------------------ + +TocParser::PostfixOpContext::PostfixOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::NonOpExprContext* TocParser::PostfixOpContext::nonOpExpr() { + return getRuleContext(0); +} + +TocParser::Postfix_opContext* TocParser::PostfixOpContext::postfix_op() { + return getRuleContext(0); +} + + +size_t TocParser::PostfixOpContext::getRuleIndex() const { + return TocParser::RulePostfixOp; +} + +void TocParser::PostfixOpContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterPostfixOp(this); +} + +void TocParser::PostfixOpContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitPostfixOp(this); +} + +TocParser::PostfixOpContext* TocParser::postfixOp() { + PostfixOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 66, TocParser::RulePostfixOp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(327); + nonOpExpr(); + setState(328); + postfix_op(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TernaryOpContext ------------------------------------------------------------------ -TocParser::FuncCallContext::FuncCallContext(ParserRuleContext *parent, size_t invokingState) +TocParser::TernaryOpContext::TernaryOpContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncNameContext* TocParser::FuncCallContext::funcName() { - return getRuleContext(0); +TocParser::NonOpExprContext* TocParser::TernaryOpContext::nonOpExpr() { + return getRuleContext(0); } -std::vector TocParser::FuncCallContext::expr() { +std::vector TocParser::TernaryOpContext::expr() { return getRuleContexts(); } -TocParser::ExprContext* TocParser::FuncCallContext::expr(size_t i) { +TocParser::ExprContext* TocParser::TernaryOpContext::expr(size_t i) { return getRuleContext(i); } -size_t TocParser::FuncCallContext::getRuleIndex() const { - return TocParser::RuleFuncCall; +size_t TocParser::TernaryOpContext::getRuleIndex() const { + return TocParser::RuleTernaryOp; } -void TocParser::FuncCallContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::TernaryOpContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterFuncCall(this); + parserListener->enterTernaryOp(this); } -void TocParser::FuncCallContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::TernaryOpContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitFuncCall(this); + parserListener->exitTernaryOp(this); } -TocParser::FuncCallContext* TocParser::funcCall() { - FuncCallContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 50, TocParser::RuleFuncCall); - size_t _la = 0; +TocParser::TernaryOpContext* TocParser::ternaryOp() { + TernaryOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 68, TocParser::RuleTernaryOp); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1879,35 +2719,16 @@ TocParser::FuncCallContext* TocParser::funcCall() { }); try { enterOuterAlt(_localctx, 1); - setState(203); - funcName(); - setState(204); - match(TocParser::T__4); - setState(213); - _errHandler->sync(this); - - _la = _input->LA(1); - if ((((_la & ~ 0x3fULL) == 0) && - ((1ULL << _la) & ((1ULL << TocParser::T__4) - | (1ULL << TocParser::INTLIT) - | (1ULL << TocParser::NAME))) != 0)) { - setState(205); - expr(); - setState(210); - _errHandler->sync(this); - _la = _input->LA(1); - while (_la == TocParser::T__6) { - setState(206); - match(TocParser::T__6); - setState(207); - expr(); - setState(212); - _errHandler->sync(this); - _la = _input->LA(1); - } - } - setState(215); - match(TocParser::T__5); + setState(330); + nonOpExpr(); + setState(331); + match(TocParser::T__21); + setState(332); + expr(); + setState(333); + match(TocParser::T__2); + setState(334); + expr(); } catch (RecognitionException &e) { @@ -1919,36 +2740,36 @@ TocParser::FuncCallContext* TocParser::funcCall() { return _localctx; } -//----------------- OperatorExprContext ------------------------------------------------------------------ +//----------------- IdentifierExprContext ------------------------------------------------------------------ -TocParser::OperatorExprContext::OperatorExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::IdentifierExprContext::IdentifierExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::BinaryOperatorContext* TocParser::OperatorExprContext::binaryOperator() { - return getRuleContext(0); +TocParser::VarNameContext* TocParser::IdentifierExprContext::varName() { + return getRuleContext(0); } -size_t TocParser::OperatorExprContext::getRuleIndex() const { - return TocParser::RuleOperatorExpr; +size_t TocParser::IdentifierExprContext::getRuleIndex() const { + return TocParser::RuleIdentifierExpr; } -void TocParser::OperatorExprContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::IdentifierExprContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterOperatorExpr(this); + parserListener->enterIdentifierExpr(this); } -void TocParser::OperatorExprContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::IdentifierExprContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitOperatorExpr(this); + parserListener->exitIdentifierExpr(this); } -TocParser::OperatorExprContext* TocParser::operatorExpr() { - OperatorExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 52, TocParser::RuleOperatorExpr); +TocParser::IdentifierExprContext* TocParser::identifierExpr() { + IdentifierExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 70, TocParser::RuleIdentifierExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1959,8 +2780,8 @@ TocParser::OperatorExprContext* TocParser::operatorExpr() { }); try { enterOuterAlt(_localctx, 1); - setState(217); - binaryOperator(); + setState(336); + varName(); } catch (RecognitionException &e) { @@ -1972,48 +2793,48 @@ TocParser::OperatorExprContext* TocParser::operatorExpr() { return _localctx; } -//----------------- BinaryOperatorContext ------------------------------------------------------------------ +//----------------- LitExprContext ------------------------------------------------------------------ -TocParser::BinaryOperatorContext::BinaryOperatorContext(ParserRuleContext *parent, size_t invokingState) +TocParser::LitExprContext::LitExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -std::vector TocParser::BinaryOperatorContext::nonOpExpr() { - return getRuleContexts(); +tree::TerminalNode* TocParser::LitExprContext::INT_LIT() { + return getToken(TocParser::INT_LIT, 0); } -TocParser::NonOpExprContext* TocParser::BinaryOperatorContext::nonOpExpr(size_t i) { - return getRuleContext(i); +tree::TerminalNode* TocParser::LitExprContext::DECIMAL_LIT() { + return getToken(TocParser::DECIMAL_LIT, 0); } -std::vector TocParser::BinaryOperatorContext::BINARY_OPERATOR() { - return getTokens(TocParser::BINARY_OPERATOR); +tree::TerminalNode* TocParser::LitExprContext::STRING_LIT() { + return getToken(TocParser::STRING_LIT, 0); } -tree::TerminalNode* TocParser::BinaryOperatorContext::BINARY_OPERATOR(size_t i) { - return getToken(TocParser::BINARY_OPERATOR, i); +tree::TerminalNode* TocParser::LitExprContext::BOOL_LIT() { + return getToken(TocParser::BOOL_LIT, 0); } -size_t TocParser::BinaryOperatorContext::getRuleIndex() const { - return TocParser::RuleBinaryOperator; +size_t TocParser::LitExprContext::getRuleIndex() const { + return TocParser::RuleLitExpr; } -void TocParser::BinaryOperatorContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::LitExprContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterBinaryOperator(this); + parserListener->enterLitExpr(this); } -void TocParser::BinaryOperatorContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::LitExprContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitBinaryOperator(this); + parserListener->exitLitExpr(this); } -TocParser::BinaryOperatorContext* TocParser::binaryOperator() { - BinaryOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 54, TocParser::RuleBinaryOperator); +TocParser::LitExprContext* TocParser::litExpr() { + LitExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 72, TocParser::RuleLitExpr); size_t _la = 0; #if __cplusplus > 201703L @@ -2025,23 +2846,18 @@ TocParser::BinaryOperatorContext* TocParser::binaryOperator() { }); try { enterOuterAlt(_localctx, 1); - setState(219); - nonOpExpr(); - setState(220); - match(TocParser::BINARY_OPERATOR); - setState(221); - nonOpExpr(); - setState(226); - _errHandler->sync(this); + setState(338); _la = _input->LA(1); - while (_la == TocParser::BINARY_OPERATOR) { - setState(222); - match(TocParser::BINARY_OPERATOR); - setState(223); - nonOpExpr(); - setState(228); - _errHandler->sync(this); - _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::INT_LIT) + | (1ULL << TocParser::DECIMAL_LIT) + | (1ULL << TocParser::STRING_LIT) + | (1ULL << TocParser::BOOL_LIT))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); } } @@ -2054,36 +2870,45 @@ TocParser::BinaryOperatorContext* TocParser::binaryOperator() { return _localctx; } -//----------------- IdentifierContext ------------------------------------------------------------------ +//----------------- AccessExprContext ------------------------------------------------------------------ -TocParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AccessExprContext::AccessExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::VarNameContext* TocParser::IdentifierContext::varName() { - return getRuleContext(0); +TocParser::NonAccessExprContext* TocParser::AccessExprContext::nonAccessExpr() { + return getRuleContext(0); +} + +std::vector TocParser::AccessExprContext::accessSubExpr() { + return getRuleContexts(); +} + +TocParser::AccessSubExprContext* TocParser::AccessExprContext::accessSubExpr(size_t i) { + return getRuleContext(i); } -size_t TocParser::IdentifierContext::getRuleIndex() const { - return TocParser::RuleIdentifier; +size_t TocParser::AccessExprContext::getRuleIndex() const { + return TocParser::RuleAccessExpr; } -void TocParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::AccessExprContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterIdentifier(this); + parserListener->enterAccessExpr(this); } -void TocParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::AccessExprContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitIdentifier(this); + parserListener->exitAccessExpr(this); } -TocParser::IdentifierContext* TocParser::identifier() { - IdentifierContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 56, TocParser::RuleIdentifier); +TocParser::AccessExprContext* TocParser::accessExpr() { + AccessExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 74, TocParser::RuleAccessExpr); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2094,8 +2919,21 @@ TocParser::IdentifierContext* TocParser::identifier() { }); try { enterOuterAlt(_localctx, 1); - setState(229); - varName(); + setState(340); + nonAccessExpr(); + setState(342); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(341); + accessSubExpr(); + setState(344); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__5) + | (1ULL << TocParser::T__22) + | (1ULL << TocParser::T__23))) != 0)); } catch (RecognitionException &e) { @@ -2107,36 +2945,40 @@ TocParser::IdentifierContext* TocParser::identifier() { return _localctx; } -//----------------- LiteralContext ------------------------------------------------------------------ +//----------------- AccessSubExprContext ------------------------------------------------------------------ -TocParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AccessSubExprContext::AccessSubExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -tree::TerminalNode* TocParser::LiteralContext::INTLIT() { - return getToken(TocParser::INTLIT, 0); +TocParser::AccessMemberContext* TocParser::AccessSubExprContext::accessMember() { + return getRuleContext(0); +} + +TocParser::AccessBracketsContext* TocParser::AccessSubExprContext::accessBrackets() { + return getRuleContext(0); } -size_t TocParser::LiteralContext::getRuleIndex() const { - return TocParser::RuleLiteral; +size_t TocParser::AccessSubExprContext::getRuleIndex() const { + return TocParser::RuleAccessSubExpr; } -void TocParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::AccessSubExprContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterLiteral(this); + parserListener->enterAccessSubExpr(this); } -void TocParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::AccessSubExprContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitLiteral(this); + parserListener->exitAccessSubExpr(this); } -TocParser::LiteralContext* TocParser::literal() { - LiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 58, TocParser::RuleLiteral); +TocParser::AccessSubExprContext* TocParser::accessSubExpr() { + AccessSubExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 76, TocParser::RuleAccessSubExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2146,9 +2988,27 @@ TocParser::LiteralContext* TocParser::literal() { exitRule(); }); try { - enterOuterAlt(_localctx, 1); - setState(231); - match(TocParser::INTLIT); + setState(348); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TocParser::T__22: + case TocParser::T__23: { + enterOuterAlt(_localctx, 1); + setState(346); + accessMember(); + break; + } + + case TocParser::T__5: { + enterOuterAlt(_localctx, 2); + setState(347); + accessBrackets(); + break; + } + + default: + throw NoViableAltException(this); + } } catch (RecognitionException &e) { @@ -2160,40 +3020,37 @@ TocParser::LiteralContext* TocParser::literal() { return _localctx; } -//----------------- SubscriptContext ------------------------------------------------------------------ +//----------------- AccessMemberContext ------------------------------------------------------------------ -TocParser::SubscriptContext::SubscriptContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AccessMemberContext::AccessMemberContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::NonSubscriptExprContext* TocParser::SubscriptContext::nonSubscriptExpr() { - return getRuleContext(0); -} - -TocParser::ExprContext* TocParser::SubscriptContext::expr() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::AccessMemberContext::identifierExpr() { + return getRuleContext(0); } -size_t TocParser::SubscriptContext::getRuleIndex() const { - return TocParser::RuleSubscript; +size_t TocParser::AccessMemberContext::getRuleIndex() const { + return TocParser::RuleAccessMember; } -void TocParser::SubscriptContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::AccessMemberContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterSubscript(this); + parserListener->enterAccessMember(this); } -void TocParser::SubscriptContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::AccessMemberContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitSubscript(this); + parserListener->exitAccessMember(this); } -TocParser::SubscriptContext* TocParser::subscript() { - SubscriptContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 60, TocParser::RuleSubscript); +TocParser::AccessMemberContext* TocParser::accessMember() { + AccessMemberContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 78, TocParser::RuleAccessMember); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2204,14 +3061,19 @@ TocParser::SubscriptContext* TocParser::subscript() { }); try { enterOuterAlt(_localctx, 1); - setState(233); - nonSubscriptExpr(); - setState(234); - match(TocParser::T__13); - setState(235); - expr(); - setState(236); - match(TocParser::T__14); + setState(350); + _la = _input->LA(1); + if (!(_la == TocParser::T__22 + + || _la == TocParser::T__23)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(351); + identifierExpr(); } catch (RecognitionException &e) { @@ -2223,40 +3085,36 @@ TocParser::SubscriptContext* TocParser::subscript() { return _localctx; } -//----------------- MemberAccessContext ------------------------------------------------------------------ +//----------------- AccessBracketsContext ------------------------------------------------------------------ -TocParser::MemberAccessContext::MemberAccessContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AccessBracketsContext::AccessBracketsContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -std::vector TocParser::MemberAccessContext::identifier() { - return getRuleContexts(); -} - -TocParser::IdentifierContext* TocParser::MemberAccessContext::identifier(size_t i) { - return getRuleContext(i); +TocParser::ExprContext* TocParser::AccessBracketsContext::expr() { + return getRuleContext(0); } -size_t TocParser::MemberAccessContext::getRuleIndex() const { - return TocParser::RuleMemberAccess; +size_t TocParser::AccessBracketsContext::getRuleIndex() const { + return TocParser::RuleAccessBrackets; } -void TocParser::MemberAccessContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::AccessBracketsContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterMemberAccess(this); + parserListener->enterAccessBrackets(this); } -void TocParser::MemberAccessContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::AccessBracketsContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitMemberAccess(this); + parserListener->exitAccessBrackets(this); } -TocParser::MemberAccessContext* TocParser::memberAccess() { - MemberAccessContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 62, TocParser::RuleMemberAccess); +TocParser::AccessBracketsContext* TocParser::accessBrackets() { + AccessBracketsContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 80, TocParser::RuleAccessBrackets); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2267,12 +3125,12 @@ TocParser::MemberAccessContext* TocParser::memberAccess() { }); try { enterOuterAlt(_localctx, 1); - setState(238); - identifier(); - setState(239); - match(TocParser::T__15); - setState(240); - identifier(); + setState(353); + match(TocParser::T__5); + setState(354); + expr(); + setState(355); + match(TocParser::T__6); } catch (RecognitionException &e) { @@ -2313,7 +3171,7 @@ void TocParser::ParenExprContext::exitRule(tree::ParseTreeListener *listener) { TocParser::ParenExprContext* TocParser::parenExpr() { ParenExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 64, TocParser::RuleParenExpr); + enterRule(_localctx, 82, TocParser::RuleParenExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2324,12 +3182,12 @@ TocParser::ParenExprContext* TocParser::parenExpr() { }); try { enterOuterAlt(_localctx, 1); - setState(242); - match(TocParser::T__4); - setState(243); + setState(357); + match(TocParser::T__8); + setState(358); expr(); - setState(244); - match(TocParser::T__5); + setState(359); + match(TocParser::T__9); } catch (RecognitionException &e) { @@ -2370,7 +3228,7 @@ void TocParser::FuncNameContext::exitRule(tree::ParseTreeListener *listener) { TocParser::FuncNameContext* TocParser::funcName() { FuncNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 66, TocParser::RuleFuncName); + enterRule(_localctx, 84, TocParser::RuleFuncName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2381,7 +3239,7 @@ TocParser::FuncNameContext* TocParser::funcName() { }); try { enterOuterAlt(_localctx, 1); - setState(246); + setState(361); match(TocParser::NAME); } @@ -2423,7 +3281,7 @@ void TocParser::VarNameContext::exitRule(tree::ParseTreeListener *listener) { TocParser::VarNameContext* TocParser::varName() { VarNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 68, TocParser::RuleVarName); + enterRule(_localctx, 86, TocParser::RuleVarName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2434,7 +3292,7 @@ TocParser::VarNameContext* TocParser::varName() { }); try { enterOuterAlt(_localctx, 1); - setState(248); + setState(363); match(TocParser::NAME); } @@ -2476,7 +3334,7 @@ void TocParser::TypeNameContext::exitRule(tree::ParseTreeListener *listener) { TocParser::TypeNameContext* TocParser::typeName() { TypeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 70, TocParser::RuleTypeName); + enterRule(_localctx, 88, TocParser::RuleTypeName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2487,7 +3345,7 @@ TocParser::TypeNameContext* TocParser::typeName() { }); try { enterOuterAlt(_localctx, 1); - setState(250); + setState(365); match(TocParser::NAME); } @@ -2529,7 +3387,7 @@ void TocParser::StructNameContext::exitRule(tree::ParseTreeListener *listener) { TocParser::StructNameContext* TocParser::structName() { StructNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 72, TocParser::RuleStructName); + enterRule(_localctx, 90, TocParser::RuleStructName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2540,7 +3398,7 @@ TocParser::StructNameContext* TocParser::structName() { }); try { enterOuterAlt(_localctx, 1); - setState(252); + setState(367); match(TocParser::NAME); } @@ -2553,6 +3411,256 @@ TocParser::StructNameContext* TocParser::structName() { return _localctx; } +//----------------- Postfix_opContext ------------------------------------------------------------------ + +TocParser::Postfix_opContext::Postfix_opContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + + +size_t TocParser::Postfix_opContext::getRuleIndex() const { + return TocParser::RulePostfix_op; +} + +void TocParser::Postfix_opContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterPostfix_op(this); +} + +void TocParser::Postfix_opContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitPostfix_op(this); +} + +TocParser::Postfix_opContext* TocParser::postfix_op() { + Postfix_opContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 92, TocParser::RulePostfix_op); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(369); + _la = _input->LA(1); + if (!(_la == TocParser::T__24 + + || _la == TocParser::T__25)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- Prefix_opContext ------------------------------------------------------------------ + +TocParser::Prefix_opContext::Prefix_opContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::Postfix_opContext* TocParser::Prefix_opContext::postfix_op() { + return getRuleContext(0); +} + + +size_t TocParser::Prefix_opContext::getRuleIndex() const { + return TocParser::RulePrefix_op; +} + +void TocParser::Prefix_opContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterPrefix_op(this); +} + +void TocParser::Prefix_opContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitPrefix_op(this); +} + +TocParser::Prefix_opContext* TocParser::prefix_op() { + Prefix_opContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 94, TocParser::RulePrefix_op); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(378); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TocParser::T__26: { + enterOuterAlt(_localctx, 1); + setState(371); + match(TocParser::T__26); + break; + } + + case TocParser::T__27: { + enterOuterAlt(_localctx, 2); + setState(372); + match(TocParser::T__27); + break; + } + + case TocParser::T__28: { + enterOuterAlt(_localctx, 3); + setState(373); + match(TocParser::T__28); + break; + } + + case TocParser::T__29: { + enterOuterAlt(_localctx, 4); + setState(374); + match(TocParser::T__29); + break; + } + + case TocParser::T__30: { + enterOuterAlt(_localctx, 5); + setState(375); + match(TocParser::T__30); + break; + } + + case TocParser::T__4: { + enterOuterAlt(_localctx, 6); + setState(376); + match(TocParser::T__4); + break; + } + + case TocParser::T__24: + case TocParser::T__25: { + enterOuterAlt(_localctx, 7); + setState(377); + postfix_op(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- Binary_opContext ------------------------------------------------------------------ + +TocParser::Binary_opContext::Binary_opContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + + +size_t TocParser::Binary_opContext::getRuleIndex() const { + return TocParser::RuleBinary_op; +} + +void TocParser::Binary_opContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterBinary_op(this); +} + +void TocParser::Binary_opContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitBinary_op(this); +} + +TocParser::Binary_opContext* TocParser::binary_op() { + Binary_opContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 96, TocParser::RuleBinary_op); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(380); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__4) + | (1ULL << TocParser::T__26) + | (1ULL << TocParser::T__27) + | (1ULL << TocParser::T__30) + | (1ULL << TocParser::T__31) + | (1ULL << TocParser::T__32) + | (1ULL << TocParser::T__33) + | (1ULL << TocParser::T__34) + | (1ULL << TocParser::T__35) + | (1ULL << TocParser::T__36) + | (1ULL << TocParser::T__37) + | (1ULL << TocParser::T__38) + | (1ULL << TocParser::T__39) + | (1ULL << TocParser::T__40) + | (1ULL << TocParser::T__41) + | (1ULL << TocParser::T__42) + | (1ULL << TocParser::T__43) + | (1ULL << TocParser::T__44) + | (1ULL << TocParser::T__45) + | (1ULL << TocParser::T__46) + | (1ULL << TocParser::T__47) + | (1ULL << TocParser::T__48) + | (1ULL << TocParser::T__49) + | (1ULL << TocParser::T__50) + | (1ULL << TocParser::T__51) + | (1ULL << TocParser::T__52) + | (1ULL << TocParser::T__53) + | (1ULL << TocParser::T__54))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + // Static vars and initialization. std::vector TocParser::_decisionToDFA; atn::PredictionContextCache TocParser::_sharedContextCache; @@ -2562,23 +3670,32 @@ atn::ATN TocParser::_atn; std::vector TocParser::_serializedATN; std::vector TocParser::_ruleNames = { - "prog", "decl", "varDecl", "var", "type", "funcDecl", "func", "parameter", - "firstParameter", "additionalParameter", "body", "structDecl", "structMember", - "structVar", "structMethod", "stmt", "conditional", "ifCond", "loop", - "whileLoop", "assignment", "returnStmt", "expr", "nonOpExpr", "nonSubscriptExpr", - "funcCall", "operatorExpr", "binaryOperator", "identifier", "literal", - "subscript", "memberAccess", "parenExpr", "funcName", "varName", "typeName", - "structName" + "prog", "decl", "varDecl", "var", "varInit", "type", "typeModifier", "funcDecl", + "func", "parameter", "body", "structDecl", "structMember", "structVar", + "structMethod", "stmt", "ifStmt", "elseIfStmt", "elseStmt", "switchStmt", + "switchBody", "switchCase", "forStmt", "whileStmt", "assignStmt", "returnStmt", + "expr", "nonOpExpr", "nonAccessExpr", "funcExpr", "opExpr", "binaryOp", + "prefixOp", "postfixOp", "ternaryOp", "identifierExpr", "litExpr", "accessExpr", + "accessSubExpr", "accessMember", "accessBrackets", "parenExpr", "funcName", + "varName", "typeName", "structName", "postfix_op", "prefix_op", "binary_op" }; std::vector TocParser::_literalNames = { - "", "'var'", "':'", "'='", "'func'", "'('", "')'", "','", "'{'", "'}'", - "'struct'", "'if'", "'while'", "'return'", "'['", "']'", "'.'" + "", "';'", "'var'", "':'", "'='", "'*'", "'['", "']'", "'func'", "'('", + "')'", "','", "'{'", "'}'", "'struct'", "'if'", "'else'", "'switch'", + "'case'", "'for'", "'while'", "'return'", "'\u003F'", "'.'", "'->'", "'++'", + "'--'", "'+'", "'-'", "'!'", "'~'", "'&'", "'/'", "'%'", "'<'", "'|'", + "'^'", "'>'", "'=='", "'!='", "'<='", "'>='", "'<<'", "'>>'", "'||'", + "'&&'", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'+='", "'-='", "'*='", + "'/='", "'%='" }; std::vector TocParser::_symbolicNames = { - "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "BINARY_OPERATOR", - "INTLIT", "NAME", "WS", "NEWLINE" + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "INT_LIT", "DECIMAL_LIT", "STRING_LIT", "BOOL_LIT", "NAME", "WS", + "NEWLINE" }; dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames); @@ -2601,7 +3718,7 @@ TocParser::Initializer::Initializer() { static const uint16_t serializedATNSegment0[] = { 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, - 0x3, 0x17, 0x101, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, + 0x3, 0x40, 0x181, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, @@ -2613,161 +3730,256 @@ TocParser::Initializer::Initializer() { 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, - 0x9, 0x26, 0x3, 0x2, 0x6, 0x2, 0x4e, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, - 0x4f, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, - 0x57, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, - 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x62, 0xa, 0x5, - 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, - 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, - 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x74, 0xa, 0x9, 0xc, 0x9, - 0xe, 0x9, 0x77, 0xb, 0x9, 0x5, 0x9, 0x79, 0xa, 0x9, 0x3, 0xa, 0x3, - 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, - 0x82, 0xa, 0xc, 0xc, 0xc, 0xe, 0xc, 0x85, 0xb, 0xc, 0x3, 0xc, 0x3, - 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0x8d, 0xa, - 0xd, 0xc, 0xd, 0xe, 0xd, 0x90, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, - 0xe, 0x3, 0xe, 0x5, 0xe, 0x96, 0xa, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, - 0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, - 0x11, 0x3, 0x11, 0x5, 0x11, 0xa2, 0xa, 0x11, 0x3, 0x12, 0x3, 0x12, + 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 0x4, 0x29, + 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4, 0x2c, + 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, + 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, + 0x9, 0x32, 0x3, 0x2, 0x6, 0x2, 0x66, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, + 0x67, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, + 0x3, 0x3, 0x5, 0x3, 0x71, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, + 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, + 0x5, 0x7c, 0xa, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, + 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x7, 0x7, 0x87, 0xa, + 0x7, 0xc, 0x7, 0xe, 0x7, 0x8a, 0xb, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, + 0x8, 0x5, 0x8, 0x8f, 0xa, 0x8, 0x3, 0x8, 0x5, 0x8, 0x92, 0xa, 0x8, + 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, + 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, + 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0xa3, 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, + 0xa6, 0xb, 0xb, 0x5, 0xb, 0xa8, 0xa, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, + 0xc, 0xac, 0xa, 0xc, 0xc, 0xc, 0xe, 0xc, 0xaf, 0xb, 0xc, 0x3, 0xc, + 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0xb7, + 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0xba, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, + 0x3, 0xe, 0x3, 0xe, 0x5, 0xe, 0xc0, 0xa, 0xe, 0x3, 0xf, 0x3, 0xf, + 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, + 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, + 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, + 0x3, 0x11, 0x5, 0x11, 0xd7, 0xa, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, + 0x12, 0x3, 0x12, 0x7, 0x12, 0xdd, 0xa, 0x12, 0xc, 0x12, 0xe, 0x12, + 0xe0, 0xb, 0x12, 0x3, 0x12, 0x5, 0x12, 0xe3, 0xa, 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, - 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, - 0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, - 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, - 0x5, 0x18, 0xbe, 0xa, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, - 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0xc6, 0xa, 0x19, 0x3, 0x1a, - 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0xcc, 0xa, 0x1a, 0x3, - 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x7, 0x1b, 0xd3, - 0xa, 0x1b, 0xc, 0x1b, 0xe, 0x1b, 0xd6, 0xb, 0x1b, 0x5, 0x1b, 0xd8, - 0xa, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, - 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x7, 0x1d, 0xe3, 0xa, - 0x1d, 0xc, 0x1d, 0xe, 0x1d, 0xe6, 0xb, 0x1d, 0x3, 0x1e, 0x3, 0x1e, - 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, - 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, - 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, - 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, - 0x2, 0x2, 0x27, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, - 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, - 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, - 0x42, 0x44, 0x46, 0x48, 0x4a, 0x2, 0x2, 0x2, 0xfa, 0x2, 0x4d, 0x3, - 0x2, 0x2, 0x2, 0x4, 0x56, 0x3, 0x2, 0x2, 0x2, 0x6, 0x58, 0x3, 0x2, - 0x2, 0x2, 0x8, 0x5b, 0x3, 0x2, 0x2, 0x2, 0xa, 0x63, 0x3, 0x2, 0x2, - 0x2, 0xc, 0x65, 0x3, 0x2, 0x2, 0x2, 0xe, 0x68, 0x3, 0x2, 0x2, 0x2, - 0x10, 0x78, 0x3, 0x2, 0x2, 0x2, 0x12, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x14, - 0x7c, 0x3, 0x2, 0x2, 0x2, 0x16, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x18, 0x88, - 0x3, 0x2, 0x2, 0x2, 0x1a, 0x95, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x97, 0x3, - 0x2, 0x2, 0x2, 0x1e, 0x99, 0x3, 0x2, 0x2, 0x2, 0x20, 0xa1, 0x3, 0x2, - 0x2, 0x2, 0x22, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x24, 0xa5, 0x3, 0x2, 0x2, - 0x2, 0x26, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x28, 0xab, 0x3, 0x2, 0x2, 0x2, - 0x2a, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xb3, 0x3, 0x2, 0x2, 0x2, 0x2e, - 0xbd, 0x3, 0x2, 0x2, 0x2, 0x30, 0xc5, 0x3, 0x2, 0x2, 0x2, 0x32, 0xcb, - 0x3, 0x2, 0x2, 0x2, 0x34, 0xcd, 0x3, 0x2, 0x2, 0x2, 0x36, 0xdb, 0x3, - 0x2, 0x2, 0x2, 0x38, 0xdd, 0x3, 0x2, 0x2, 0x2, 0x3a, 0xe7, 0x3, 0x2, - 0x2, 0x2, 0x3c, 0xe9, 0x3, 0x2, 0x2, 0x2, 0x3e, 0xeb, 0x3, 0x2, 0x2, - 0x2, 0x40, 0xf0, 0x3, 0x2, 0x2, 0x2, 0x42, 0xf4, 0x3, 0x2, 0x2, 0x2, - 0x44, 0xf8, 0x3, 0x2, 0x2, 0x2, 0x46, 0xfa, 0x3, 0x2, 0x2, 0x2, 0x48, - 0xfc, 0x3, 0x2, 0x2, 0x2, 0x4a, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x4e, - 0x5, 0x4, 0x3, 0x2, 0x4d, 0x4c, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x4f, 0x3, - 0x2, 0x2, 0x2, 0x4f, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0x3, 0x2, - 0x2, 0x2, 0x50, 0x51, 0x3, 0x2, 0x2, 0x2, 0x51, 0x52, 0x7, 0x2, 0x2, - 0x3, 0x52, 0x3, 0x3, 0x2, 0x2, 0x2, 0x53, 0x57, 0x5, 0x6, 0x4, 0x2, - 0x54, 0x57, 0x5, 0xc, 0x7, 0x2, 0x55, 0x57, 0x5, 0x18, 0xd, 0x2, - 0x56, 0x53, 0x3, 0x2, 0x2, 0x2, 0x56, 0x54, 0x3, 0x2, 0x2, 0x2, 0x56, - 0x55, 0x3, 0x2, 0x2, 0x2, 0x57, 0x5, 0x3, 0x2, 0x2, 0x2, 0x58, 0x59, - 0x7, 0x3, 0x2, 0x2, 0x59, 0x5a, 0x5, 0x8, 0x5, 0x2, 0x5a, 0x7, 0x3, - 0x2, 0x2, 0x2, 0x5b, 0x5c, 0x5, 0x46, 0x24, 0x2, 0x5c, 0x5d, 0x7, - 0x4, 0x2, 0x2, 0x5d, 0x5e, 0x5, 0xa, 0x6, 0x2, 0x5e, 0x61, 0x3, 0x2, - 0x2, 0x2, 0x5f, 0x60, 0x7, 0x5, 0x2, 0x2, 0x60, 0x62, 0x5, 0x2e, - 0x18, 0x2, 0x61, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x3, 0x2, - 0x2, 0x2, 0x62, 0x9, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, 0x5, 0x48, 0x25, - 0x2, 0x64, 0xb, 0x3, 0x2, 0x2, 0x2, 0x65, 0x66, 0x7, 0x6, 0x2, 0x2, - 0x66, 0x67, 0x5, 0xe, 0x8, 0x2, 0x67, 0xd, 0x3, 0x2, 0x2, 0x2, 0x68, - 0x69, 0x5, 0x44, 0x23, 0x2, 0x69, 0x6a, 0x7, 0x7, 0x2, 0x2, 0x6a, - 0x6b, 0x5, 0x10, 0x9, 0x2, 0x6b, 0x6c, 0x7, 0x8, 0x2, 0x2, 0x6c, - 0x6d, 0x7, 0x4, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0xa, 0x6, 0x2, 0x6e, 0x6f, - 0x3, 0x2, 0x2, 0x2, 0x6f, 0x70, 0x5, 0x16, 0xc, 0x2, 0x70, 0xf, 0x3, - 0x2, 0x2, 0x2, 0x71, 0x75, 0x5, 0x12, 0xa, 0x2, 0x72, 0x74, 0x5, - 0x14, 0xb, 0x2, 0x73, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, 0x77, 0x3, - 0x2, 0x2, 0x2, 0x75, 0x73, 0x3, 0x2, 0x2, 0x2, 0x75, 0x76, 0x3, 0x2, - 0x2, 0x2, 0x76, 0x79, 0x3, 0x2, 0x2, 0x2, 0x77, 0x75, 0x3, 0x2, 0x2, - 0x2, 0x78, 0x71, 0x3, 0x2, 0x2, 0x2, 0x78, 0x79, 0x3, 0x2, 0x2, 0x2, - 0x79, 0x11, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x7b, 0x5, 0x8, 0x5, 0x2, 0x7b, - 0x13, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x7d, 0x7, 0x9, 0x2, 0x2, 0x7d, 0x7e, - 0x5, 0x8, 0x5, 0x2, 0x7e, 0x15, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x83, 0x7, - 0xa, 0x2, 0x2, 0x80, 0x82, 0x5, 0x20, 0x11, 0x2, 0x81, 0x80, 0x3, - 0x2, 0x2, 0x2, 0x82, 0x85, 0x3, 0x2, 0x2, 0x2, 0x83, 0x81, 0x3, 0x2, - 0x2, 0x2, 0x83, 0x84, 0x3, 0x2, 0x2, 0x2, 0x84, 0x86, 0x3, 0x2, 0x2, - 0x2, 0x85, 0x83, 0x3, 0x2, 0x2, 0x2, 0x86, 0x87, 0x7, 0xb, 0x2, 0x2, - 0x87, 0x17, 0x3, 0x2, 0x2, 0x2, 0x88, 0x89, 0x7, 0xc, 0x2, 0x2, 0x89, - 0x8a, 0x5, 0x4a, 0x26, 0x2, 0x8a, 0x8e, 0x7, 0xa, 0x2, 0x2, 0x8b, - 0x8d, 0x5, 0x1a, 0xe, 0x2, 0x8c, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8d, - 0x90, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8c, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8f, - 0x3, 0x2, 0x2, 0x2, 0x8f, 0x91, 0x3, 0x2, 0x2, 0x2, 0x90, 0x8e, 0x3, - 0x2, 0x2, 0x2, 0x91, 0x92, 0x7, 0xb, 0x2, 0x2, 0x92, 0x19, 0x3, 0x2, - 0x2, 0x2, 0x93, 0x96, 0x5, 0x1c, 0xf, 0x2, 0x94, 0x96, 0x5, 0x1e, - 0x10, 0x2, 0x95, 0x93, 0x3, 0x2, 0x2, 0x2, 0x95, 0x94, 0x3, 0x2, - 0x2, 0x2, 0x96, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x97, 0x98, 0x5, 0x8, 0x5, - 0x2, 0x98, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x99, 0x9a, 0x5, 0xe, 0x8, 0x2, - 0x9a, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x9b, 0xa2, 0x5, 0x6, 0x4, 0x2, 0x9c, - 0xa2, 0x5, 0x22, 0x12, 0x2, 0x9d, 0xa2, 0x5, 0x26, 0x14, 0x2, 0x9e, - 0xa2, 0x5, 0x2a, 0x16, 0x2, 0x9f, 0xa2, 0x5, 0x2c, 0x17, 0x2, 0xa0, - 0xa2, 0x5, 0x2e, 0x18, 0x2, 0xa1, 0x9b, 0x3, 0x2, 0x2, 0x2, 0xa1, - 0x9c, 0x3, 0x2, 0x2, 0x2, 0xa1, 0x9d, 0x3, 0x2, 0x2, 0x2, 0xa1, 0x9e, - 0x3, 0x2, 0x2, 0x2, 0xa1, 0x9f, 0x3, 0x2, 0x2, 0x2, 0xa1, 0xa0, 0x3, - 0x2, 0x2, 0x2, 0xa2, 0x21, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x5, 0x24, - 0x13, 0x2, 0xa4, 0x23, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x7, 0xd, - 0x2, 0x2, 0xa6, 0xa7, 0x5, 0x2e, 0x18, 0x2, 0xa7, 0xa8, 0x5, 0x16, - 0xc, 0x2, 0xa8, 0x25, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x5, 0x28, - 0x15, 0x2, 0xaa, 0x27, 0x3, 0x2, 0x2, 0x2, 0xab, 0xac, 0x7, 0xe, - 0x2, 0x2, 0xac, 0xad, 0x5, 0x2e, 0x18, 0x2, 0xad, 0xae, 0x5, 0x16, - 0xc, 0x2, 0xae, 0x29, 0x3, 0x2, 0x2, 0x2, 0xaf, 0xb0, 0x5, 0x3a, - 0x1e, 0x2, 0xb0, 0xb1, 0x7, 0x5, 0x2, 0x2, 0xb1, 0xb2, 0x5, 0x2e, - 0x18, 0x2, 0xb2, 0x2b, 0x3, 0x2, 0x2, 0x2, 0xb3, 0xb4, 0x7, 0xf, - 0x2, 0x2, 0xb4, 0xb5, 0x5, 0x2e, 0x18, 0x2, 0xb5, 0x2d, 0x3, 0x2, - 0x2, 0x2, 0xb6, 0xbe, 0x5, 0x34, 0x1b, 0x2, 0xb7, 0xbe, 0x5, 0x3c, - 0x1f, 0x2, 0xb8, 0xbe, 0x5, 0x3a, 0x1e, 0x2, 0xb9, 0xbe, 0x5, 0x3e, - 0x20, 0x2, 0xba, 0xbe, 0x5, 0x40, 0x21, 0x2, 0xbb, 0xbe, 0x5, 0x42, - 0x22, 0x2, 0xbc, 0xbe, 0x5, 0x36, 0x1c, 0x2, 0xbd, 0xb6, 0x3, 0x2, - 0x2, 0x2, 0xbd, 0xb7, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xb8, 0x3, 0x2, 0x2, - 0x2, 0xbd, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xba, 0x3, 0x2, 0x2, 0x2, - 0xbd, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbe, - 0x2f, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xc6, 0x5, 0x34, 0x1b, 0x2, 0xc0, - 0xc6, 0x5, 0x3c, 0x1f, 0x2, 0xc1, 0xc6, 0x5, 0x3a, 0x1e, 0x2, 0xc2, - 0xc6, 0x5, 0x3e, 0x20, 0x2, 0xc3, 0xc6, 0x5, 0x40, 0x21, 0x2, 0xc4, - 0xc6, 0x5, 0x42, 0x22, 0x2, 0xc5, 0xbf, 0x3, 0x2, 0x2, 0x2, 0xc5, - 0xc0, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc1, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc2, - 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc3, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc4, 0x3, - 0x2, 0x2, 0x2, 0xc6, 0x31, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xcc, 0x5, 0x34, - 0x1b, 0x2, 0xc8, 0xcc, 0x5, 0x3a, 0x1e, 0x2, 0xc9, 0xcc, 0x5, 0x40, - 0x21, 0x2, 0xca, 0xcc, 0x5, 0x42, 0x22, 0x2, 0xcb, 0xc7, 0x3, 0x2, - 0x2, 0x2, 0xcb, 0xc8, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xc9, 0x3, 0x2, 0x2, - 0x2, 0xcb, 0xca, 0x3, 0x2, 0x2, 0x2, 0xcc, 0x33, 0x3, 0x2, 0x2, 0x2, - 0xcd, 0xce, 0x5, 0x44, 0x23, 0x2, 0xce, 0xd7, 0x7, 0x7, 0x2, 0x2, - 0xcf, 0xd4, 0x5, 0x2e, 0x18, 0x2, 0xd0, 0xd1, 0x7, 0x9, 0x2, 0x2, - 0xd1, 0xd3, 0x5, 0x2e, 0x18, 0x2, 0xd2, 0xd0, 0x3, 0x2, 0x2, 0x2, - 0xd3, 0xd6, 0x3, 0x2, 0x2, 0x2, 0xd4, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xd4, - 0xd5, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd6, 0xd4, - 0x3, 0x2, 0x2, 0x2, 0xd7, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, 0x3, - 0x2, 0x2, 0x2, 0xd8, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xda, 0x7, 0x8, - 0x2, 0x2, 0xda, 0x35, 0x3, 0x2, 0x2, 0x2, 0xdb, 0xdc, 0x5, 0x38, - 0x1d, 0x2, 0xdc, 0x37, 0x3, 0x2, 0x2, 0x2, 0xdd, 0xde, 0x5, 0x30, - 0x19, 0x2, 0xde, 0xdf, 0x7, 0x13, 0x2, 0x2, 0xdf, 0xe4, 0x5, 0x30, - 0x19, 0x2, 0xe0, 0xe1, 0x7, 0x13, 0x2, 0x2, 0xe1, 0xe3, 0x5, 0x30, - 0x19, 0x2, 0xe2, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xe3, 0xe6, 0x3, 0x2, - 0x2, 0x2, 0xe4, 0xe2, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x3, 0x2, 0x2, - 0x2, 0xe5, 0x39, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe4, 0x3, 0x2, 0x2, 0x2, - 0xe7, 0xe8, 0x5, 0x46, 0x24, 0x2, 0xe8, 0x3b, 0x3, 0x2, 0x2, 0x2, - 0xe9, 0xea, 0x7, 0x14, 0x2, 0x2, 0xea, 0x3d, 0x3, 0x2, 0x2, 0x2, - 0xeb, 0xec, 0x5, 0x32, 0x1a, 0x2, 0xec, 0xed, 0x7, 0x10, 0x2, 0x2, - 0xed, 0xee, 0x5, 0x2e, 0x18, 0x2, 0xee, 0xef, 0x7, 0x11, 0x2, 0x2, - 0xef, 0x3f, 0x3, 0x2, 0x2, 0x2, 0xf0, 0xf1, 0x5, 0x3a, 0x1e, 0x2, - 0xf1, 0xf2, 0x7, 0x12, 0x2, 0x2, 0xf2, 0xf3, 0x5, 0x3a, 0x1e, 0x2, - 0xf3, 0x41, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf5, 0x7, 0x7, 0x2, 0x2, 0xf5, - 0xf6, 0x5, 0x2e, 0x18, 0x2, 0xf6, 0xf7, 0x7, 0x8, 0x2, 0x2, 0xf7, - 0x43, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xf9, 0x7, 0x15, 0x2, 0x2, 0xf9, - 0x45, 0x3, 0x2, 0x2, 0x2, 0xfa, 0xfb, 0x7, 0x15, 0x2, 0x2, 0xfb, - 0x47, 0x3, 0x2, 0x2, 0x2, 0xfc, 0xfd, 0x7, 0x15, 0x2, 0x2, 0xfd, - 0x49, 0x3, 0x2, 0x2, 0x2, 0xfe, 0xff, 0x7, 0x15, 0x2, 0x2, 0xff, - 0x4b, 0x3, 0x2, 0x2, 0x2, 0x11, 0x4f, 0x56, 0x61, 0x75, 0x78, 0x83, - 0x8e, 0x95, 0xa1, 0xbd, 0xc5, 0xcb, 0xd4, 0xd7, 0xe4, + 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, + 0x3, 0x16, 0x7, 0x16, 0xf3, 0xa, 0x16, 0xc, 0x16, 0xe, 0x16, 0xf6, + 0xb, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, + 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0x101, 0xa, + 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, + 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, 0x3, + 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, + 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x5, + 0x1c, 0x11a, 0xa, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, + 0x3, 0x1d, 0x5, 0x1d, 0x121, 0xa, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, + 0x1e, 0x5, 0x1e, 0x126, 0xa, 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, + 0x3, 0x1f, 0x3, 0x1f, 0x7, 0x1f, 0x12d, 0xa, 0x1f, 0xc, 0x1f, 0xe, + 0x1f, 0x130, 0xb, 0x1f, 0x5, 0x1f, 0x132, 0xa, 0x1f, 0x3, 0x1f, 0x3, + 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x5, 0x20, 0x13a, + 0xa, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, + 0x3, 0x21, 0x7, 0x21, 0x142, 0xa, 0x21, 0xc, 0x21, 0xe, 0x21, 0x145, + 0xb, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, + 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, + 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x27, + 0x3, 0x27, 0x6, 0x27, 0x159, 0xa, 0x27, 0xd, 0x27, 0xe, 0x27, 0x15a, + 0x3, 0x28, 0x3, 0x28, 0x5, 0x28, 0x15f, 0xa, 0x28, 0x3, 0x29, 0x3, + 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, + 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, + 0x2d, 0x3, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, + 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, + 0x31, 0x3, 0x31, 0x3, 0x31, 0x5, 0x31, 0x17d, 0xa, 0x31, 0x3, 0x32, + 0x3, 0x32, 0x3, 0x32, 0x2, 0x2, 0x33, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, + 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, + 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, + 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, + 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x62, 0x2, + 0x6, 0x3, 0x2, 0x3a, 0x3d, 0x3, 0x2, 0x19, 0x1a, 0x3, 0x2, 0x1b, + 0x1c, 0x5, 0x2, 0x7, 0x7, 0x1d, 0x1e, 0x21, 0x39, 0x2, 0x17f, 0x2, + 0x65, 0x3, 0x2, 0x2, 0x2, 0x4, 0x70, 0x3, 0x2, 0x2, 0x2, 0x6, 0x72, + 0x3, 0x2, 0x2, 0x2, 0x8, 0x75, 0x3, 0x2, 0x2, 0x2, 0xa, 0x7d, 0x3, + 0x2, 0x2, 0x2, 0xc, 0x84, 0x3, 0x2, 0x2, 0x2, 0xe, 0x91, 0x3, 0x2, + 0x2, 0x2, 0x10, 0x93, 0x3, 0x2, 0x2, 0x2, 0x12, 0x96, 0x3, 0x2, 0x2, + 0x2, 0x14, 0xa7, 0x3, 0x2, 0x2, 0x2, 0x16, 0xa9, 0x3, 0x2, 0x2, 0x2, + 0x18, 0xb2, 0x3, 0x2, 0x2, 0x2, 0x1a, 0xbf, 0x3, 0x2, 0x2, 0x2, 0x1c, + 0xc1, 0x3, 0x2, 0x2, 0x2, 0x1e, 0xc4, 0x3, 0x2, 0x2, 0x2, 0x20, 0xd6, + 0x3, 0x2, 0x2, 0x2, 0x22, 0xd8, 0x3, 0x2, 0x2, 0x2, 0x24, 0xe4, 0x3, + 0x2, 0x2, 0x2, 0x26, 0xe9, 0x3, 0x2, 0x2, 0x2, 0x28, 0xec, 0x3, 0x2, + 0x2, 0x2, 0x2a, 0xf0, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xf9, 0x3, 0x2, 0x2, + 0x2, 0x2e, 0xfd, 0x3, 0x2, 0x2, 0x2, 0x30, 0x108, 0x3, 0x2, 0x2, + 0x2, 0x32, 0x10c, 0x3, 0x2, 0x2, 0x2, 0x34, 0x110, 0x3, 0x2, 0x2, + 0x2, 0x36, 0x119, 0x3, 0x2, 0x2, 0x2, 0x38, 0x120, 0x3, 0x2, 0x2, + 0x2, 0x3a, 0x125, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x127, 0x3, 0x2, 0x2, + 0x2, 0x3e, 0x139, 0x3, 0x2, 0x2, 0x2, 0x40, 0x13b, 0x3, 0x2, 0x2, + 0x2, 0x42, 0x146, 0x3, 0x2, 0x2, 0x2, 0x44, 0x149, 0x3, 0x2, 0x2, + 0x2, 0x46, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x48, 0x152, 0x3, 0x2, 0x2, + 0x2, 0x4a, 0x154, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x156, 0x3, 0x2, 0x2, + 0x2, 0x4e, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x50, 0x160, 0x3, 0x2, 0x2, + 0x2, 0x52, 0x163, 0x3, 0x2, 0x2, 0x2, 0x54, 0x167, 0x3, 0x2, 0x2, + 0x2, 0x56, 0x16b, 0x3, 0x2, 0x2, 0x2, 0x58, 0x16d, 0x3, 0x2, 0x2, + 0x2, 0x5a, 0x16f, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x171, 0x3, 0x2, 0x2, + 0x2, 0x5e, 0x173, 0x3, 0x2, 0x2, 0x2, 0x60, 0x17c, 0x3, 0x2, 0x2, + 0x2, 0x62, 0x17e, 0x3, 0x2, 0x2, 0x2, 0x64, 0x66, 0x5, 0x4, 0x3, + 0x2, 0x65, 0x64, 0x3, 0x2, 0x2, 0x2, 0x66, 0x67, 0x3, 0x2, 0x2, 0x2, + 0x67, 0x65, 0x3, 0x2, 0x2, 0x2, 0x67, 0x68, 0x3, 0x2, 0x2, 0x2, 0x68, + 0x69, 0x3, 0x2, 0x2, 0x2, 0x69, 0x6a, 0x7, 0x2, 0x2, 0x3, 0x6a, 0x3, + 0x3, 0x2, 0x2, 0x2, 0x6b, 0x6c, 0x5, 0x6, 0x4, 0x2, 0x6c, 0x6d, 0x7, + 0x3, 0x2, 0x2, 0x6d, 0x71, 0x3, 0x2, 0x2, 0x2, 0x6e, 0x71, 0x5, 0x10, + 0x9, 0x2, 0x6f, 0x71, 0x5, 0x18, 0xd, 0x2, 0x70, 0x6b, 0x3, 0x2, + 0x2, 0x2, 0x70, 0x6e, 0x3, 0x2, 0x2, 0x2, 0x70, 0x6f, 0x3, 0x2, 0x2, + 0x2, 0x71, 0x5, 0x3, 0x2, 0x2, 0x2, 0x72, 0x73, 0x7, 0x4, 0x2, 0x2, + 0x73, 0x74, 0x5, 0x8, 0x5, 0x2, 0x74, 0x7, 0x3, 0x2, 0x2, 0x2, 0x75, + 0x76, 0x5, 0x58, 0x2d, 0x2, 0x76, 0x77, 0x7, 0x5, 0x2, 0x2, 0x77, + 0x78, 0x5, 0xc, 0x7, 0x2, 0x78, 0x7b, 0x3, 0x2, 0x2, 0x2, 0x79, 0x7a, + 0x7, 0x6, 0x2, 0x2, 0x7a, 0x7c, 0x5, 0x36, 0x1c, 0x2, 0x7b, 0x79, + 0x3, 0x2, 0x2, 0x2, 0x7b, 0x7c, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x9, 0x3, + 0x2, 0x2, 0x2, 0x7d, 0x7e, 0x5, 0x58, 0x2d, 0x2, 0x7e, 0x7f, 0x7, + 0x5, 0x2, 0x2, 0x7f, 0x80, 0x5, 0xc, 0x7, 0x2, 0x80, 0x81, 0x3, 0x2, + 0x2, 0x2, 0x81, 0x82, 0x7, 0x6, 0x2, 0x2, 0x82, 0x83, 0x5, 0x36, + 0x1c, 0x2, 0x83, 0xb, 0x3, 0x2, 0x2, 0x2, 0x84, 0x88, 0x5, 0x5a, + 0x2e, 0x2, 0x85, 0x87, 0x5, 0xe, 0x8, 0x2, 0x86, 0x85, 0x3, 0x2, + 0x2, 0x2, 0x87, 0x8a, 0x3, 0x2, 0x2, 0x2, 0x88, 0x86, 0x3, 0x2, 0x2, + 0x2, 0x88, 0x89, 0x3, 0x2, 0x2, 0x2, 0x89, 0xd, 0x3, 0x2, 0x2, 0x2, + 0x8a, 0x88, 0x3, 0x2, 0x2, 0x2, 0x8b, 0x92, 0x7, 0x7, 0x2, 0x2, 0x8c, + 0x8e, 0x7, 0x8, 0x2, 0x2, 0x8d, 0x8f, 0x7, 0x3a, 0x2, 0x2, 0x8e, + 0x8d, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8f, 0x3, 0x2, 0x2, 0x2, 0x8f, 0x90, + 0x3, 0x2, 0x2, 0x2, 0x90, 0x92, 0x7, 0x9, 0x2, 0x2, 0x91, 0x8b, 0x3, + 0x2, 0x2, 0x2, 0x91, 0x8c, 0x3, 0x2, 0x2, 0x2, 0x92, 0xf, 0x3, 0x2, + 0x2, 0x2, 0x93, 0x94, 0x7, 0xa, 0x2, 0x2, 0x94, 0x95, 0x5, 0x12, + 0xa, 0x2, 0x95, 0x11, 0x3, 0x2, 0x2, 0x2, 0x96, 0x97, 0x5, 0x56, + 0x2c, 0x2, 0x97, 0x98, 0x7, 0xb, 0x2, 0x2, 0x98, 0x99, 0x5, 0x14, + 0xb, 0x2, 0x99, 0x9a, 0x7, 0xc, 0x2, 0x2, 0x9a, 0x9b, 0x7, 0x5, 0x2, + 0x2, 0x9b, 0x9c, 0x5, 0xc, 0x7, 0x2, 0x9c, 0x9d, 0x3, 0x2, 0x2, 0x2, + 0x9d, 0x9e, 0x5, 0x16, 0xc, 0x2, 0x9e, 0x13, 0x3, 0x2, 0x2, 0x2, + 0x9f, 0xa4, 0x5, 0x8, 0x5, 0x2, 0xa0, 0xa1, 0x7, 0xd, 0x2, 0x2, 0xa1, + 0xa3, 0x5, 0x8, 0x5, 0x2, 0xa2, 0xa0, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa6, + 0x3, 0x2, 0x2, 0x2, 0xa4, 0xa2, 0x3, 0x2, 0x2, 0x2, 0xa4, 0xa5, 0x3, + 0x2, 0x2, 0x2, 0xa5, 0xa8, 0x3, 0x2, 0x2, 0x2, 0xa6, 0xa4, 0x3, 0x2, + 0x2, 0x2, 0xa7, 0x9f, 0x3, 0x2, 0x2, 0x2, 0xa7, 0xa8, 0x3, 0x2, 0x2, + 0x2, 0xa8, 0x15, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xad, 0x7, 0xe, 0x2, 0x2, + 0xaa, 0xac, 0x5, 0x20, 0x11, 0x2, 0xab, 0xaa, 0x3, 0x2, 0x2, 0x2, + 0xac, 0xaf, 0x3, 0x2, 0x2, 0x2, 0xad, 0xab, 0x3, 0x2, 0x2, 0x2, 0xad, + 0xae, 0x3, 0x2, 0x2, 0x2, 0xae, 0xb0, 0x3, 0x2, 0x2, 0x2, 0xaf, 0xad, + 0x3, 0x2, 0x2, 0x2, 0xb0, 0xb1, 0x7, 0xf, 0x2, 0x2, 0xb1, 0x17, 0x3, + 0x2, 0x2, 0x2, 0xb2, 0xb3, 0x7, 0x10, 0x2, 0x2, 0xb3, 0xb4, 0x5, + 0x5c, 0x2f, 0x2, 0xb4, 0xb8, 0x7, 0xe, 0x2, 0x2, 0xb5, 0xb7, 0x5, + 0x1a, 0xe, 0x2, 0xb6, 0xb5, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xba, 0x3, + 0x2, 0x2, 0x2, 0xb8, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb8, 0xb9, 0x3, 0x2, + 0x2, 0x2, 0xb9, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xba, 0xb8, 0x3, 0x2, 0x2, + 0x2, 0xbb, 0xbc, 0x7, 0xf, 0x2, 0x2, 0xbc, 0x19, 0x3, 0x2, 0x2, 0x2, + 0xbd, 0xc0, 0x5, 0x1c, 0xf, 0x2, 0xbe, 0xc0, 0x5, 0x1e, 0x10, 0x2, + 0xbf, 0xbd, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xbe, 0x3, 0x2, 0x2, 0x2, 0xc0, + 0x1b, 0x3, 0x2, 0x2, 0x2, 0xc1, 0xc2, 0x5, 0x8, 0x5, 0x2, 0xc2, 0xc3, + 0x7, 0x3, 0x2, 0x2, 0xc3, 0x1d, 0x3, 0x2, 0x2, 0x2, 0xc4, 0xc5, 0x5, + 0x12, 0xa, 0x2, 0xc5, 0x1f, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc7, 0x5, + 0x6, 0x4, 0x2, 0xc7, 0xc8, 0x7, 0x3, 0x2, 0x2, 0xc8, 0xd7, 0x3, 0x2, + 0x2, 0x2, 0xc9, 0xd7, 0x5, 0x22, 0x12, 0x2, 0xca, 0xd7, 0x5, 0x28, + 0x15, 0x2, 0xcb, 0xd7, 0x5, 0x2e, 0x18, 0x2, 0xcc, 0xd7, 0x5, 0x30, + 0x19, 0x2, 0xcd, 0xce, 0x5, 0x32, 0x1a, 0x2, 0xce, 0xcf, 0x7, 0x3, + 0x2, 0x2, 0xcf, 0xd7, 0x3, 0x2, 0x2, 0x2, 0xd0, 0xd1, 0x5, 0x34, + 0x1b, 0x2, 0xd1, 0xd2, 0x7, 0x3, 0x2, 0x2, 0xd2, 0xd7, 0x3, 0x2, + 0x2, 0x2, 0xd3, 0xd4, 0x5, 0x36, 0x1c, 0x2, 0xd4, 0xd5, 0x7, 0x3, + 0x2, 0x2, 0xd5, 0xd7, 0x3, 0x2, 0x2, 0x2, 0xd6, 0xc6, 0x3, 0x2, 0x2, + 0x2, 0xd6, 0xc9, 0x3, 0x2, 0x2, 0x2, 0xd6, 0xca, 0x3, 0x2, 0x2, 0x2, + 0xd6, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xd6, 0xcc, 0x3, 0x2, 0x2, 0x2, 0xd6, + 0xcd, 0x3, 0x2, 0x2, 0x2, 0xd6, 0xd0, 0x3, 0x2, 0x2, 0x2, 0xd6, 0xd3, + 0x3, 0x2, 0x2, 0x2, 0xd7, 0x21, 0x3, 0x2, 0x2, 0x2, 0xd8, 0xd9, 0x7, + 0x11, 0x2, 0x2, 0xd9, 0xda, 0x5, 0x36, 0x1c, 0x2, 0xda, 0xde, 0x5, + 0x16, 0xc, 0x2, 0xdb, 0xdd, 0x5, 0x24, 0x13, 0x2, 0xdc, 0xdb, 0x3, + 0x2, 0x2, 0x2, 0xdd, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdc, 0x3, 0x2, + 0x2, 0x2, 0xde, 0xdf, 0x3, 0x2, 0x2, 0x2, 0xdf, 0xe2, 0x3, 0x2, 0x2, + 0x2, 0xe0, 0xde, 0x3, 0x2, 0x2, 0x2, 0xe1, 0xe3, 0x5, 0x26, 0x14, + 0x2, 0xe2, 0xe1, 0x3, 0x2, 0x2, 0x2, 0xe2, 0xe3, 0x3, 0x2, 0x2, 0x2, + 0xe3, 0x23, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x7, 0x12, 0x2, 0x2, + 0xe5, 0xe6, 0x7, 0x11, 0x2, 0x2, 0xe6, 0xe7, 0x5, 0x36, 0x1c, 0x2, + 0xe7, 0xe8, 0x5, 0x16, 0xc, 0x2, 0xe8, 0x25, 0x3, 0x2, 0x2, 0x2, + 0xe9, 0xea, 0x7, 0x12, 0x2, 0x2, 0xea, 0xeb, 0x5, 0x16, 0xc, 0x2, + 0xeb, 0x27, 0x3, 0x2, 0x2, 0x2, 0xec, 0xed, 0x7, 0x13, 0x2, 0x2, + 0xed, 0xee, 0x5, 0x48, 0x25, 0x2, 0xee, 0xef, 0x5, 0x2a, 0x16, 0x2, + 0xef, 0x29, 0x3, 0x2, 0x2, 0x2, 0xf0, 0xf4, 0x7, 0xe, 0x2, 0x2, 0xf1, + 0xf3, 0x5, 0x2c, 0x17, 0x2, 0xf2, 0xf1, 0x3, 0x2, 0x2, 0x2, 0xf3, + 0xf6, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf2, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf5, + 0x3, 0x2, 0x2, 0x2, 0xf5, 0xf7, 0x3, 0x2, 0x2, 0x2, 0xf6, 0xf4, 0x3, + 0x2, 0x2, 0x2, 0xf7, 0xf8, 0x7, 0xf, 0x2, 0x2, 0xf8, 0x2b, 0x3, 0x2, + 0x2, 0x2, 0xf9, 0xfa, 0x7, 0x14, 0x2, 0x2, 0xfa, 0xfb, 0x5, 0x36, + 0x1c, 0x2, 0xfb, 0xfc, 0x5, 0x16, 0xc, 0x2, 0xfc, 0x2d, 0x3, 0x2, + 0x2, 0x2, 0xfd, 0x100, 0x7, 0x15, 0x2, 0x2, 0xfe, 0x101, 0x5, 0xa, + 0x6, 0x2, 0xff, 0x101, 0x5, 0x32, 0x1a, 0x2, 0x100, 0xfe, 0x3, 0x2, + 0x2, 0x2, 0x100, 0xff, 0x3, 0x2, 0x2, 0x2, 0x101, 0x102, 0x3, 0x2, + 0x2, 0x2, 0x102, 0x103, 0x7, 0xd, 0x2, 0x2, 0x103, 0x104, 0x5, 0x36, + 0x1c, 0x2, 0x104, 0x105, 0x7, 0xd, 0x2, 0x2, 0x105, 0x106, 0x5, 0x36, + 0x1c, 0x2, 0x106, 0x107, 0x5, 0x16, 0xc, 0x2, 0x107, 0x2f, 0x3, 0x2, + 0x2, 0x2, 0x108, 0x109, 0x7, 0x16, 0x2, 0x2, 0x109, 0x10a, 0x5, 0x36, + 0x1c, 0x2, 0x10a, 0x10b, 0x5, 0x16, 0xc, 0x2, 0x10b, 0x31, 0x3, 0x2, + 0x2, 0x2, 0x10c, 0x10d, 0x5, 0x48, 0x25, 0x2, 0x10d, 0x10e, 0x7, + 0x6, 0x2, 0x2, 0x10e, 0x10f, 0x5, 0x36, 0x1c, 0x2, 0x10f, 0x33, 0x3, + 0x2, 0x2, 0x2, 0x110, 0x111, 0x7, 0x17, 0x2, 0x2, 0x111, 0x112, 0x5, + 0x36, 0x1c, 0x2, 0x112, 0x35, 0x3, 0x2, 0x2, 0x2, 0x113, 0x11a, 0x5, + 0x3c, 0x1f, 0x2, 0x114, 0x11a, 0x5, 0x4a, 0x26, 0x2, 0x115, 0x11a, + 0x5, 0x48, 0x25, 0x2, 0x116, 0x11a, 0x5, 0x54, 0x2b, 0x2, 0x117, + 0x11a, 0x5, 0x4c, 0x27, 0x2, 0x118, 0x11a, 0x5, 0x3e, 0x20, 0x2, + 0x119, 0x113, 0x3, 0x2, 0x2, 0x2, 0x119, 0x114, 0x3, 0x2, 0x2, 0x2, + 0x119, 0x115, 0x3, 0x2, 0x2, 0x2, 0x119, 0x116, 0x3, 0x2, 0x2, 0x2, + 0x119, 0x117, 0x3, 0x2, 0x2, 0x2, 0x119, 0x118, 0x3, 0x2, 0x2, 0x2, + 0x11a, 0x37, 0x3, 0x2, 0x2, 0x2, 0x11b, 0x121, 0x5, 0x3c, 0x1f, 0x2, + 0x11c, 0x121, 0x5, 0x4a, 0x26, 0x2, 0x11d, 0x121, 0x5, 0x48, 0x25, + 0x2, 0x11e, 0x121, 0x5, 0x54, 0x2b, 0x2, 0x11f, 0x121, 0x5, 0x4c, + 0x27, 0x2, 0x120, 0x11b, 0x3, 0x2, 0x2, 0x2, 0x120, 0x11c, 0x3, 0x2, + 0x2, 0x2, 0x120, 0x11d, 0x3, 0x2, 0x2, 0x2, 0x120, 0x11e, 0x3, 0x2, + 0x2, 0x2, 0x120, 0x11f, 0x3, 0x2, 0x2, 0x2, 0x121, 0x39, 0x3, 0x2, + 0x2, 0x2, 0x122, 0x126, 0x5, 0x3c, 0x1f, 0x2, 0x123, 0x126, 0x5, + 0x48, 0x25, 0x2, 0x124, 0x126, 0x5, 0x54, 0x2b, 0x2, 0x125, 0x122, + 0x3, 0x2, 0x2, 0x2, 0x125, 0x123, 0x3, 0x2, 0x2, 0x2, 0x125, 0x124, + 0x3, 0x2, 0x2, 0x2, 0x126, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x127, 0x128, + 0x5, 0x56, 0x2c, 0x2, 0x128, 0x131, 0x7, 0xb, 0x2, 0x2, 0x129, 0x12e, + 0x5, 0x36, 0x1c, 0x2, 0x12a, 0x12b, 0x7, 0xd, 0x2, 0x2, 0x12b, 0x12d, + 0x5, 0x36, 0x1c, 0x2, 0x12c, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x12d, 0x130, + 0x3, 0x2, 0x2, 0x2, 0x12e, 0x12c, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x12f, + 0x3, 0x2, 0x2, 0x2, 0x12f, 0x132, 0x3, 0x2, 0x2, 0x2, 0x130, 0x12e, + 0x3, 0x2, 0x2, 0x2, 0x131, 0x129, 0x3, 0x2, 0x2, 0x2, 0x131, 0x132, + 0x3, 0x2, 0x2, 0x2, 0x132, 0x133, 0x3, 0x2, 0x2, 0x2, 0x133, 0x134, + 0x7, 0xc, 0x2, 0x2, 0x134, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x135, 0x13a, + 0x5, 0x40, 0x21, 0x2, 0x136, 0x13a, 0x5, 0x42, 0x22, 0x2, 0x137, + 0x13a, 0x5, 0x44, 0x23, 0x2, 0x138, 0x13a, 0x5, 0x46, 0x24, 0x2, + 0x139, 0x135, 0x3, 0x2, 0x2, 0x2, 0x139, 0x136, 0x3, 0x2, 0x2, 0x2, + 0x139, 0x137, 0x3, 0x2, 0x2, 0x2, 0x139, 0x138, 0x3, 0x2, 0x2, 0x2, + 0x13a, 0x3f, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13c, 0x5, 0x38, 0x1d, 0x2, + 0x13c, 0x13d, 0x5, 0x62, 0x32, 0x2, 0x13d, 0x143, 0x5, 0x38, 0x1d, + 0x2, 0x13e, 0x13f, 0x5, 0x62, 0x32, 0x2, 0x13f, 0x140, 0x5, 0x38, + 0x1d, 0x2, 0x140, 0x142, 0x3, 0x2, 0x2, 0x2, 0x141, 0x13e, 0x3, 0x2, + 0x2, 0x2, 0x142, 0x145, 0x3, 0x2, 0x2, 0x2, 0x143, 0x141, 0x3, 0x2, + 0x2, 0x2, 0x143, 0x144, 0x3, 0x2, 0x2, 0x2, 0x144, 0x41, 0x3, 0x2, + 0x2, 0x2, 0x145, 0x143, 0x3, 0x2, 0x2, 0x2, 0x146, 0x147, 0x5, 0x60, + 0x31, 0x2, 0x147, 0x148, 0x5, 0x38, 0x1d, 0x2, 0x148, 0x43, 0x3, + 0x2, 0x2, 0x2, 0x149, 0x14a, 0x5, 0x38, 0x1d, 0x2, 0x14a, 0x14b, + 0x5, 0x5e, 0x30, 0x2, 0x14b, 0x45, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x14d, + 0x5, 0x38, 0x1d, 0x2, 0x14d, 0x14e, 0x7, 0x18, 0x2, 0x2, 0x14e, 0x14f, + 0x5, 0x36, 0x1c, 0x2, 0x14f, 0x150, 0x7, 0x5, 0x2, 0x2, 0x150, 0x151, + 0x5, 0x36, 0x1c, 0x2, 0x151, 0x47, 0x3, 0x2, 0x2, 0x2, 0x152, 0x153, + 0x5, 0x58, 0x2d, 0x2, 0x153, 0x49, 0x3, 0x2, 0x2, 0x2, 0x154, 0x155, + 0x9, 0x2, 0x2, 0x2, 0x155, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x156, 0x158, + 0x5, 0x3a, 0x1e, 0x2, 0x157, 0x159, 0x5, 0x4e, 0x28, 0x2, 0x158, + 0x157, 0x3, 0x2, 0x2, 0x2, 0x159, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x15a, + 0x158, 0x3, 0x2, 0x2, 0x2, 0x15a, 0x15b, 0x3, 0x2, 0x2, 0x2, 0x15b, + 0x4d, 0x3, 0x2, 0x2, 0x2, 0x15c, 0x15f, 0x5, 0x50, 0x29, 0x2, 0x15d, + 0x15f, 0x5, 0x52, 0x2a, 0x2, 0x15e, 0x15c, 0x3, 0x2, 0x2, 0x2, 0x15e, + 0x15d, 0x3, 0x2, 0x2, 0x2, 0x15f, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x160, + 0x161, 0x9, 0x3, 0x2, 0x2, 0x161, 0x162, 0x5, 0x48, 0x25, 0x2, 0x162, + 0x51, 0x3, 0x2, 0x2, 0x2, 0x163, 0x164, 0x7, 0x8, 0x2, 0x2, 0x164, + 0x165, 0x5, 0x36, 0x1c, 0x2, 0x165, 0x166, 0x7, 0x9, 0x2, 0x2, 0x166, + 0x53, 0x3, 0x2, 0x2, 0x2, 0x167, 0x168, 0x7, 0xb, 0x2, 0x2, 0x168, + 0x169, 0x5, 0x36, 0x1c, 0x2, 0x169, 0x16a, 0x7, 0xc, 0x2, 0x2, 0x16a, + 0x55, 0x3, 0x2, 0x2, 0x2, 0x16b, 0x16c, 0x7, 0x3e, 0x2, 0x2, 0x16c, + 0x57, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x16e, 0x7, 0x3e, 0x2, 0x2, 0x16e, + 0x59, 0x3, 0x2, 0x2, 0x2, 0x16f, 0x170, 0x7, 0x3e, 0x2, 0x2, 0x170, + 0x5b, 0x3, 0x2, 0x2, 0x2, 0x171, 0x172, 0x7, 0x3e, 0x2, 0x2, 0x172, + 0x5d, 0x3, 0x2, 0x2, 0x2, 0x173, 0x174, 0x9, 0x4, 0x2, 0x2, 0x174, + 0x5f, 0x3, 0x2, 0x2, 0x2, 0x175, 0x17d, 0x7, 0x1d, 0x2, 0x2, 0x176, + 0x17d, 0x7, 0x1e, 0x2, 0x2, 0x177, 0x17d, 0x7, 0x1f, 0x2, 0x2, 0x178, + 0x17d, 0x7, 0x20, 0x2, 0x2, 0x179, 0x17d, 0x7, 0x21, 0x2, 0x2, 0x17a, + 0x17d, 0x7, 0x7, 0x2, 0x2, 0x17b, 0x17d, 0x5, 0x5e, 0x30, 0x2, 0x17c, + 0x175, 0x3, 0x2, 0x2, 0x2, 0x17c, 0x176, 0x3, 0x2, 0x2, 0x2, 0x17c, + 0x177, 0x3, 0x2, 0x2, 0x2, 0x17c, 0x178, 0x3, 0x2, 0x2, 0x2, 0x17c, + 0x179, 0x3, 0x2, 0x2, 0x2, 0x17c, 0x17a, 0x3, 0x2, 0x2, 0x2, 0x17c, + 0x17b, 0x3, 0x2, 0x2, 0x2, 0x17d, 0x61, 0x3, 0x2, 0x2, 0x2, 0x17e, + 0x17f, 0x9, 0x5, 0x2, 0x2, 0x17f, 0x63, 0x3, 0x2, 0x2, 0x2, 0x1c, + 0x67, 0x70, 0x7b, 0x88, 0x8e, 0x91, 0xa4, 0xa7, 0xad, 0xb8, 0xbf, + 0xd6, 0xde, 0xe2, 0xf4, 0x100, 0x119, 0x120, 0x125, 0x12e, 0x131, + 0x139, 0x143, 0x15a, 0x15e, 0x17c, }; _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,