X-Git-Url: https://gitweb.ps.run/toc/blobdiff_plain/b64d16088b29615d222d33450cf0315467400e59..5f9668526491332f62c05ad831dbf6d5fdc2b6d0:/gen/TocParser.cpp diff --git a/gen/TocParser.cpp b/gen/TocParser.cpp index eb6928d..e1d5b1f 100644 --- a/gen/TocParser.cpp +++ b/gen/TocParser.cpp @@ -80,20 +80,20 @@ TocParser::ProgContext* TocParser::prog() { }); try { enterOuterAlt(_localctx, 1); - setState(73); + setState(81); _errHandler->sync(this); _la = _input->LA(1); do { - setState(72); + setState(80); decl(); - setState(75); + setState(83); _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(77); + | (1ULL << TocParser::T__6) + | (1ULL << TocParser::T__12))) != 0)); + setState(85); match(TocParser::EOF); } @@ -153,26 +153,26 @@ TocParser::DeclContext* TocParser::decl() { exitRule(); }); try { - setState(82); + setState(90); _errHandler->sync(this); switch (_input->LA(1)) { case TocParser::T__0: { enterOuterAlt(_localctx, 1); - setState(79); + setState(87); varDecl(); break; } - case TocParser::T__3: { + case TocParser::T__6: { enterOuterAlt(_localctx, 2); - setState(80); + setState(88); funcDecl(); break; } - case TocParser::T__9: { + case TocParser::T__12: { enterOuterAlt(_localctx, 3); - setState(81); + setState(89); structDecl(); break; } @@ -231,9 +231,9 @@ TocParser::VarDeclContext* TocParser::varDecl() { }); try { enterOuterAlt(_localctx, 1); - setState(84); + setState(92); match(TocParser::T__0); - setState(85); + setState(93); var(); } @@ -295,21 +295,21 @@ TocParser::VarContext* TocParser::var() { }); try { enterOuterAlt(_localctx, 1); - setState(87); + setState(95); varName(); - setState(88); + setState(96); match(TocParser::T__1); - setState(89); + setState(97); type(); - setState(93); + setState(101); _errHandler->sync(this); _la = _input->LA(1); if (_la == TocParser::T__2) { - setState(91); + setState(99); match(TocParser::T__2); - setState(92); + setState(100); expr(); } @@ -323,6 +323,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(103); + varName(); + + setState(104); + match(TocParser::T__1); + setState(105); + type(); + + setState(107); + match(TocParser::T__2); + setState(108); + 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 +404,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 +431,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 +443,101 @@ TocParser::TypeContext* TocParser::type() { }); try { enterOuterAlt(_localctx, 1); - setState(95); + setState(110); typeName(); + setState(114); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TocParser::T__3 + + || _la == TocParser::T__4) { + setState(111); + typeModifier(); + setState(116); + _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::NUMBER() { + return getToken(TocParser::NUMBER, 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(123); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TocParser::T__3: { + enterOuterAlt(_localctx, 1); + setState(117); + match(TocParser::T__3); + break; + } + + case TocParser::T__4: { + enterOuterAlt(_localctx, 2); + setState(118); + match(TocParser::T__4); + setState(120); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == TocParser::NUMBER) { + setState(119); + match(TocParser::NUMBER); + } + setState(122); + match(TocParser::T__5); + break; + } + + default: + throw NoViableAltException(this); + } } catch (RecognitionException &e) { @@ -405,7 +578,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 +589,9 @@ TocParser::FuncDeclContext* TocParser::funcDecl() { }); try { enterOuterAlt(_localctx, 1); - setState(97); - match(TocParser::T__3); - setState(98); + setState(125); + match(TocParser::T__6); + setState(126); func(); } @@ -472,7 +645,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 +656,20 @@ TocParser::FuncContext* TocParser::func() { }); try { enterOuterAlt(_localctx, 1); - setState(100); + setState(128); funcName(); - setState(101); - match(TocParser::T__4); - setState(102); + setState(129); + match(TocParser::T__7); + setState(130); parameter(); - setState(103); - match(TocParser::T__5); + setState(131); + match(TocParser::T__8); - setState(104); + setState(132); match(TocParser::T__1); - setState(105); + setState(133); type(); - setState(107); + setState(135); body(); } @@ -542,7 +715,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 @@ -554,22 +727,22 @@ TocParser::ParameterContext* TocParser::parameter() { }); try { enterOuterAlt(_localctx, 1); - setState(117); + setState(145); _errHandler->sync(this); _la = _input->LA(1); if (_la == TocParser::NAME) { - setState(109); + setState(137); var(); - setState(114); + setState(142); _errHandler->sync(this); _la = _input->LA(1); - while (_la == TocParser::T__6) { - setState(110); - match(TocParser::T__6); - setState(111); + while (_la == TocParser::T__9) { + setState(138); + match(TocParser::T__9); + setState(139); var(); - setState(116); + setState(144); _errHandler->sync(this); _la = _input->LA(1); } @@ -618,7 +791,7 @@ void TocParser::BodyContext::exitRule(tree::ParseTreeListener *listener) { TocParser::BodyContext* TocParser::body() { BodyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 16, TocParser::RuleBody); + enterRule(_localctx, 20, TocParser::RuleBody); size_t _la = 0; #if __cplusplus > 201703L @@ -630,27 +803,33 @@ TocParser::BodyContext* TocParser::body() { }); try { enterOuterAlt(_localctx, 1); - setState(119); - match(TocParser::T__7); - setState(123); + setState(147); + match(TocParser::T__10); + setState(151); _errHandler->sync(this); _la = _input->LA(1); while ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & ((1ULL << TocParser::T__0) - | (1ULL << TocParser::T__4) - | (1ULL << TocParser::T__10) - | (1ULL << TocParser::T__11) - | (1ULL << TocParser::T__12) - | (1ULL << TocParser::INTLIT) + | (1ULL << TocParser::T__7) + | (1ULL << TocParser::T__13) + | (1ULL << TocParser::T__15) + | (1ULL << TocParser::T__17) + | (1ULL << TocParser::T__18) + | (1ULL << TocParser::T__19) + | (1ULL << TocParser::PREFIX_OP) + | (1ULL << TocParser::INT_LIT) + | (1ULL << TocParser::DECIMAL_LIT) + | (1ULL << TocParser::STRING_LIT) + | (1ULL << TocParser::BOOL_LIT) | (1ULL << TocParser::NAME))) != 0)) { - setState(120); + setState(148); stmt(); - setState(125); + setState(153); _errHandler->sync(this); _la = _input->LA(1); } - setState(126); - match(TocParser::T__8); + setState(154); + match(TocParser::T__11); } catch (RecognitionException &e) { @@ -699,7 +878,7 @@ void TocParser::StructDeclContext::exitRule(tree::ParseTreeListener *listener) { TocParser::StructDeclContext* TocParser::structDecl() { StructDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 18, TocParser::RuleStructDecl); + enterRule(_localctx, 22, TocParser::RuleStructDecl); size_t _la = 0; #if __cplusplus > 201703L @@ -711,24 +890,24 @@ TocParser::StructDeclContext* TocParser::structDecl() { }); try { enterOuterAlt(_localctx, 1); - setState(128); - match(TocParser::T__9); - setState(129); + setState(156); + match(TocParser::T__12); + setState(157); structName(); - setState(130); - match(TocParser::T__7); - setState(134); + setState(158); + match(TocParser::T__10); + setState(162); _errHandler->sync(this); _la = _input->LA(1); while (_la == TocParser::NAME) { - setState(131); + setState(159); structMember(); - setState(136); + setState(164); _errHandler->sync(this); _la = _input->LA(1); } - setState(137); - match(TocParser::T__8); + setState(165); + match(TocParser::T__11); } catch (RecognitionException &e) { @@ -773,7 +952,7 @@ void TocParser::StructMemberContext::exitRule(tree::ParseTreeListener *listener) TocParser::StructMemberContext* TocParser::structMember() { StructMemberContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 20, TocParser::RuleStructMember); + enterRule(_localctx, 24, TocParser::RuleStructMember); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -783,19 +962,19 @@ TocParser::StructMemberContext* TocParser::structMember() { exitRule(); }); try { - setState(141); + setState(169); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 7, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 10, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(139); + setState(167); structVar(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(140); + setState(168); structMethod(); break; } @@ -843,7 +1022,7 @@ void TocParser::StructVarContext::exitRule(tree::ParseTreeListener *listener) { TocParser::StructVarContext* TocParser::structVar() { StructVarContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 22, TocParser::RuleStructVar); + enterRule(_localctx, 26, TocParser::RuleStructVar); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -854,7 +1033,7 @@ TocParser::StructVarContext* TocParser::structVar() { }); try { enterOuterAlt(_localctx, 1); - setState(143); + setState(171); var(); } @@ -896,7 +1075,7 @@ void TocParser::StructMethodContext::exitRule(tree::ParseTreeListener *listener) TocParser::StructMethodContext* TocParser::structMethod() { StructMethodContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 24, TocParser::RuleStructMethod); + enterRule(_localctx, 28, TocParser::RuleStructMethod); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -907,7 +1086,7 @@ TocParser::StructMethodContext* TocParser::structMethod() { }); try { enterOuterAlt(_localctx, 1); - setState(145); + setState(173); func(); } @@ -930,16 +1109,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() { @@ -969,7 +1156,7 @@ void TocParser::StmtContext::exitRule(tree::ParseTreeListener *listener) { TocParser::StmtContext* TocParser::stmt() { StmtContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 26, TocParser::RuleStmt); + enterRule(_localctx, 30, TocParser::RuleStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -979,42 +1166,61 @@ TocParser::StmtContext* TocParser::stmt() { exitRule(); }); try { - enterOuterAlt(_localctx, 1); - setState(153); + setState(183); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 8, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { case 1: { - setState(147); + enterOuterAlt(_localctx, 1); + setState(175); varDecl(); break; } case 2: { - setState(148); - conditional(); + enterOuterAlt(_localctx, 2); + setState(176); + ifStmt(); break; } case 3: { - setState(149); - loop(); + enterOuterAlt(_localctx, 3); + setState(177); + switchStmt(); break; } case 4: { - setState(150); - assignment(); + enterOuterAlt(_localctx, 4); + setState(178); + forStmt(); break; } case 5: { - setState(151); - returnStmt(); + enterOuterAlt(_localctx, 5); + setState(179); + whileStmt(); break; } case 6: { - setState(152); + enterOuterAlt(_localctx, 6); + setState(180); + assignStmt(); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(181); + returnStmt(); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(182); expr(); break; } @@ -1033,36 +1239,49 @@ 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); +std::vector TocParser::IfStmtContext::expr() { + return getRuleContexts(); +} + +TocParser::ExprContext* TocParser::IfStmtContext::expr(size_t i) { + return getRuleContext(i); +} + +std::vector TocParser::IfStmtContext::body() { + return getRuleContexts(); +} + +TocParser::BodyContext* TocParser::IfStmtContext::body(size_t i) { + return getRuleContext(i); } -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, 28, 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] { @@ -1072,9 +1291,42 @@ TocParser::ConditionalContext* TocParser::conditional() { exitRule(); }); try { + size_t alt; enterOuterAlt(_localctx, 1); - setState(155); - ifCond(); + setState(185); + match(TocParser::T__13); + setState(186); + expr(); + setState(187); + body(); + setState(195); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 12, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(188); + match(TocParser::T__14); + setState(189); + match(TocParser::T__13); + setState(190); + expr(); + setState(191); + body(); + } + setState(197); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 12, _ctx); + } + setState(200); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == TocParser::T__14) { + setState(198); + match(TocParser::T__14); + setState(199); + body(); + } } catch (RecognitionException &e) { @@ -1086,40 +1338,40 @@ TocParser::ConditionalContext* TocParser::conditional() { return _localctx; } -//----------------- IfCondContext ------------------------------------------------------------------ +//----------------- SwitchStmtContext ------------------------------------------------------------------ -TocParser::IfCondContext::IfCondContext(ParserRuleContext *parent, size_t invokingState) +TocParser::SwitchStmtContext::SwitchStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::ExprContext* TocParser::IfCondContext::expr() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::SwitchStmtContext::identifierExpr() { + return getRuleContext(0); } -TocParser::BodyContext* TocParser::IfCondContext::body() { - return getRuleContext(0); +TocParser::SwitchBodyContext* TocParser::SwitchStmtContext::switchBody() { + return getRuleContext(0); } -size_t TocParser::IfCondContext::getRuleIndex() const { - return TocParser::RuleIfCond; +size_t TocParser::SwitchStmtContext::getRuleIndex() const { + return TocParser::RuleSwitchStmt; } -void TocParser::IfCondContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchStmtContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterIfCond(this); + parserListener->enterSwitchStmt(this); } -void TocParser::IfCondContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitIfCond(this); + parserListener->exitSwitchStmt(this); } -TocParser::IfCondContext* TocParser::ifCond() { - IfCondContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 30, TocParser::RuleIfCond); +TocParser::SwitchStmtContext* TocParser::switchStmt() { + SwitchStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 34, TocParser::RuleSwitchStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1130,12 +1382,12 @@ TocParser::IfCondContext* TocParser::ifCond() { }); try { enterOuterAlt(_localctx, 1); - setState(157); - match(TocParser::T__10); - setState(158); - expr(); - setState(159); - body(); + setState(202); + match(TocParser::T__15); + setState(203); + identifierExpr(); + setState(204); + switchBody(); } catch (RecognitionException &e) { @@ -1147,36 +1399,49 @@ TocParser::IfCondContext* TocParser::ifCond() { return _localctx; } -//----------------- LoopContext ------------------------------------------------------------------ +//----------------- SwitchBodyContext ------------------------------------------------------------------ -TocParser::LoopContext::LoopContext(ParserRuleContext *parent, size_t invokingState) +TocParser::SwitchBodyContext::SwitchBodyContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::WhileLoopContext* TocParser::LoopContext::whileLoop() { - return getRuleContext(0); +std::vector TocParser::SwitchBodyContext::expr() { + return getRuleContexts(); +} + +TocParser::ExprContext* TocParser::SwitchBodyContext::expr(size_t i) { + return getRuleContext(i); +} + +std::vector TocParser::SwitchBodyContext::body() { + return getRuleContexts(); +} + +TocParser::BodyContext* TocParser::SwitchBodyContext::body(size_t i) { + return getRuleContext(i); } -size_t TocParser::LoopContext::getRuleIndex() const { - return TocParser::RuleLoop; +size_t TocParser::SwitchBodyContext::getRuleIndex() const { + return TocParser::RuleSwitchBody; } -void TocParser::LoopContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchBodyContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterLoop(this); + parserListener->enterSwitchBody(this); } -void TocParser::LoopContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::SwitchBodyContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitLoop(this); + parserListener->exitSwitchBody(this); } -TocParser::LoopContext* TocParser::loop() { - LoopContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 32, TocParser::RuleLoop); +TocParser::SwitchBodyContext* TocParser::switchBody() { + SwitchBodyContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 36, TocParser::RuleSwitchBody); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1187,8 +1452,24 @@ TocParser::LoopContext* TocParser::loop() { }); try { enterOuterAlt(_localctx, 1); - setState(161); - whileLoop(); + setState(206); + match(TocParser::T__10); + setState(213); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TocParser::T__16) { + setState(207); + match(TocParser::T__16); + setState(208); + expr(); + setState(209); + body(); + setState(215); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(216); + match(TocParser::T__11); } catch (RecognitionException &e) { @@ -1200,40 +1481,52 @@ TocParser::LoopContext* TocParser::loop() { return _localctx; } -//----------------- WhileLoopContext ------------------------------------------------------------------ +//----------------- ForStmtContext ------------------------------------------------------------------ -TocParser::WhileLoopContext::WhileLoopContext(ParserRuleContext *parent, size_t invokingState) +TocParser::ForStmtContext::ForStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::ExprContext* TocParser::WhileLoopContext::expr() { - return getRuleContext(0); +std::vector TocParser::ForStmtContext::expr() { + return getRuleContexts(); +} + +TocParser::ExprContext* TocParser::ForStmtContext::expr(size_t i) { + return getRuleContext(i); } -TocParser::BodyContext* TocParser::WhileLoopContext::body() { +TocParser::BodyContext* TocParser::ForStmtContext::body() { return getRuleContext(0); } +TocParser::VarInitContext* TocParser::ForStmtContext::varInit() { + return getRuleContext(0); +} -size_t TocParser::WhileLoopContext::getRuleIndex() const { - return TocParser::RuleWhileLoop; +TocParser::AssignStmtContext* TocParser::ForStmtContext::assignStmt() { + return getRuleContext(0); } -void TocParser::WhileLoopContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); + +size_t TocParser::ForStmtContext::getRuleIndex() const { + return TocParser::RuleForStmt; +} + +void TocParser::ForStmtContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterWhileLoop(this); + parserListener->enterForStmt(this); } -void TocParser::WhileLoopContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::ForStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitWhileLoop(this); + parserListener->exitForStmt(this); } -TocParser::WhileLoopContext* TocParser::whileLoop() { - WhileLoopContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 34, TocParser::RuleWhileLoop); +TocParser::ForStmtContext* TocParser::forStmt() { + ForStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 38, TocParser::RuleForStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1244,11 +1537,35 @@ TocParser::WhileLoopContext* TocParser::whileLoop() { }); try { enterOuterAlt(_localctx, 1); - setState(163); - match(TocParser::T__11); - setState(164); + setState(218); + match(TocParser::T__17); + setState(221); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 15, _ctx)) { + case 1: { + setState(219); + varInit(); + break; + } + + case 2: { + setState(220); + assignStmt(); + break; + } + + default: + break; + } + setState(223); + match(TocParser::T__9); + setState(224); expr(); - setState(165); + setState(225); + match(TocParser::T__9); + setState(226); + expr(); + setState(227); body(); } @@ -1261,40 +1578,101 @@ TocParser::WhileLoopContext* TocParser::whileLoop() { return _localctx; } -//----------------- AssignmentContext ------------------------------------------------------------------ +//----------------- WhileStmtContext ------------------------------------------------------------------ -TocParser::AssignmentContext::AssignmentContext(ParserRuleContext *parent, size_t invokingState) +TocParser::WhileStmtContext::WhileStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::IdentifierContext* TocParser::AssignmentContext::identifier() { - return getRuleContext(0); +TocParser::ExprContext* TocParser::WhileStmtContext::expr() { + return getRuleContext(0); +} + +TocParser::BodyContext* TocParser::WhileStmtContext::body() { + return getRuleContext(0); +} + + +size_t TocParser::WhileStmtContext::getRuleIndex() const { + return TocParser::RuleWhileStmt; +} + +void TocParser::WhileStmtContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterWhileStmt(this); } -TocParser::ExprContext* TocParser::AssignmentContext::expr() { +void TocParser::WhileStmtContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitWhileStmt(this); +} + +TocParser::WhileStmtContext* TocParser::whileStmt() { + WhileStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 40, TocParser::RuleWhileStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(229); + match(TocParser::T__18); + setState(230); + expr(); + setState(231); + body(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AssignStmtContext ------------------------------------------------------------------ + +TocParser::AssignStmtContext::AssignStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::IdentifierExprContext* TocParser::AssignStmtContext::identifierExpr() { + return getRuleContext(0); +} + +TocParser::ExprContext* TocParser::AssignStmtContext::expr() { return getRuleContext(0); } -size_t TocParser::AssignmentContext::getRuleIndex() const { - return TocParser::RuleAssignment; +size_t TocParser::AssignStmtContext::getRuleIndex() const { + return TocParser::RuleAssignStmt; } -void TocParser::AssignmentContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::AssignStmtContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterAssignment(this); + parserListener->enterAssignStmt(this); } -void TocParser::AssignmentContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::AssignStmtContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitAssignment(this); + parserListener->exitAssignStmt(this); } -TocParser::AssignmentContext* TocParser::assignment() { - AssignmentContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 36, TocParser::RuleAssignment); +TocParser::AssignStmtContext* TocParser::assignStmt() { + AssignStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 42, TocParser::RuleAssignStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1305,11 +1683,11 @@ TocParser::AssignmentContext* TocParser::assignment() { }); try { enterOuterAlt(_localctx, 1); - setState(167); - identifier(); - setState(168); + setState(233); + identifierExpr(); + setState(234); match(TocParser::T__2); - setState(169); + setState(235); expr(); } @@ -1351,7 +1729,7 @@ void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) { TocParser::ReturnStmtContext* TocParser::returnStmt() { ReturnStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 38, TocParser::RuleReturnStmt); + enterRule(_localctx, 44, TocParser::RuleReturnStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1362,9 +1740,9 @@ TocParser::ReturnStmtContext* TocParser::returnStmt() { }); try { enterOuterAlt(_localctx, 1); - setState(171); - match(TocParser::T__12); - setState(172); + setState(237); + match(TocParser::T__19); + setState(238); expr(); } @@ -1383,32 +1761,28 @@ TocParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingSt : 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); +TocParser::FuncExprContext* TocParser::ExprContext::funcExpr() { + return getRuleContext(0); } -TocParser::SubscriptContext* TocParser::ExprContext::subscript() { - return getRuleContext(0); +TocParser::LitExprContext* TocParser::ExprContext::litExpr() { + return getRuleContext(0); } -TocParser::MemberAccessContext* TocParser::ExprContext::memberAccess() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::ExprContext::identifierExpr() { + return getRuleContext(0); } TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() { return getRuleContext(0); } -TocParser::OperatorExprContext* TocParser::ExprContext::operatorExpr() { - return getRuleContext(0); +TocParser::AccessExprContext* TocParser::ExprContext::accessExpr() { + return getRuleContext(0); +} + +TocParser::OpExprContext* TocParser::ExprContext::opExpr() { + return getRuleContext(0); } @@ -1430,7 +1804,7 @@ void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) { TocParser::ExprContext* TocParser::expr() { ExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 40, TocParser::RuleExpr); + enterRule(_localctx, 46, TocParser::RuleExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1440,55 +1814,48 @@ TocParser::ExprContext* TocParser::expr() { exitRule(); }); try { - setState(181); + setState(246); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 9, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 16, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(174); - funcCall(); + setState(240); + funcExpr(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(175); - literal(); + setState(241); + litExpr(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(176); - identifier(); + setState(242); + identifierExpr(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(177); - subscript(); + setState(243); + parenExpr(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(178); - memberAccess(); + setState(244); + accessExpr(); break; } case 6: { enterOuterAlt(_localctx, 6); - setState(179); - parenExpr(); - break; - } - - case 7: { - enterOuterAlt(_localctx, 7); - setState(180); - operatorExpr(); + setState(245); + opExpr(); break; } @@ -1512,30 +1879,26 @@ TocParser::NonOpExprContext::NonOpExprContext(ParserRuleContext *parent, size_t : 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::FuncExprContext* TocParser::NonOpExprContext::funcExpr() { + return getRuleContext(0); } -TocParser::SubscriptContext* TocParser::NonOpExprContext::subscript() { - return getRuleContext(0); +TocParser::LitExprContext* TocParser::NonOpExprContext::litExpr() { + return getRuleContext(0); } -TocParser::MemberAccessContext* TocParser::NonOpExprContext::memberAccess() { - 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; @@ -1555,7 +1918,7 @@ void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) { TocParser::NonOpExprContext* TocParser::nonOpExpr() { NonOpExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 42, TocParser::RuleNonOpExpr); + enterRule(_localctx, 48, TocParser::RuleNonOpExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1565,48 +1928,41 @@ TocParser::NonOpExprContext* TocParser::nonOpExpr() { exitRule(); }); try { - setState(189); + setState(253); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 10, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 17, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(183); - funcCall(); + setState(248); + funcExpr(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(184); - literal(); + setState(249); + litExpr(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(185); - identifier(); + setState(250); + identifierExpr(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(186); - subscript(); + setState(251); + parenExpr(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(187); - memberAccess(); - break; - } - - case 6: { - enterOuterAlt(_localctx, 6); - setState(188); - parenExpr(); + setState(252); + accessExpr(); break; } @@ -1624,52 +1980,44 @@ TocParser::NonOpExprContext* TocParser::nonOpExpr() { return _localctx; } -//----------------- NonSubscriptExprContext ------------------------------------------------------------------ +//----------------- NonAccessExprContext ------------------------------------------------------------------ -TocParser::NonSubscriptExprContext::NonSubscriptExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncCallContext* TocParser::NonSubscriptExprContext::funcCall() { - return getRuleContext(0); -} - -TocParser::LiteralContext* TocParser::NonSubscriptExprContext::literal() { - return getRuleContext(0); +TocParser::FuncExprContext* TocParser::NonAccessExprContext::funcExpr() { + return getRuleContext(0); } -TocParser::IdentifierContext* TocParser::NonSubscriptExprContext::identifier() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::NonAccessExprContext::identifierExpr() { + return getRuleContext(0); } -TocParser::MemberAccessContext* TocParser::NonSubscriptExprContext::memberAccess() { - return getRuleContext(0); -} - -TocParser::ParenExprContext* TocParser::NonSubscriptExprContext::parenExpr() { +TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() { return getRuleContext(0); } -size_t TocParser::NonSubscriptExprContext::getRuleIndex() const { - return TocParser::RuleNonSubscriptExpr; +size_t TocParser::NonAccessExprContext::getRuleIndex() const { + return TocParser::RuleNonAccessExpr; } -void TocParser::NonSubscriptExprContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::NonAccessExprContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterNonSubscriptExpr(this); + parserListener->enterNonAccessExpr(this); } -void TocParser::NonSubscriptExprContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::NonAccessExprContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitNonSubscriptExpr(this); + parserListener->exitNonAccessExpr(this); } -TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { - NonSubscriptExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 44, TocParser::RuleNonSubscriptExpr); +TocParser::NonAccessExprContext* TocParser::nonAccessExpr() { + NonAccessExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 50, TocParser::RuleNonAccessExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1679,40 +2027,26 @@ TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { exitRule(); }); try { - setState(196); + setState(258); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 18, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(191); - funcCall(); + setState(255); + funcExpr(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(192); - literal(); + setState(256); + identifierExpr(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(193); - identifier(); - break; - } - - case 4: { - enterOuterAlt(_localctx, 4); - setState(194); - memberAccess(); - break; - } - - case 5: { - enterOuterAlt(_localctx, 5); - setState(195); + setState(257); parenExpr(); break; } @@ -1731,56 +2065,141 @@ TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { return _localctx; } -//----------------- NonAccessExprContext ------------------------------------------------------------------ +//----------------- FuncExprContext ------------------------------------------------------------------ -TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::FuncExprContext::FuncExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncCallContext* TocParser::NonAccessExprContext::funcCall() { - return getRuleContext(0); +TocParser::FuncNameContext* TocParser::FuncExprContext::funcName() { + return getRuleContext(0); } -TocParser::LiteralContext* TocParser::NonAccessExprContext::literal() { - return getRuleContext(0); +std::vector TocParser::FuncExprContext::expr() { + return getRuleContexts(); } -TocParser::IdentifierContext* TocParser::NonAccessExprContext::identifier() { - return getRuleContext(0); +TocParser::ExprContext* TocParser::FuncExprContext::expr(size_t i) { + return getRuleContext(i); } -TocParser::SubscriptContext* TocParser::NonAccessExprContext::subscript() { - return getRuleContext(0); + +size_t TocParser::FuncExprContext::getRuleIndex() const { + return TocParser::RuleFuncExpr; } -TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() { - return getRuleContext(0); +void TocParser::FuncExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterFuncExpr(this); } -TocParser::OperatorExprContext* TocParser::NonAccessExprContext::operatorExpr() { - return getRuleContext(0); +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, 52, TocParser::RuleFuncExpr); + size_t _la = 0; -size_t TocParser::NonAccessExprContext::getRuleIndex() const { - return TocParser::RuleNonAccessExpr; +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(260); + funcName(); + setState(261); + match(TocParser::T__7); + setState(270); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__7) + | (1ULL << TocParser::PREFIX_OP) + | (1ULL << TocParser::INT_LIT) + | (1ULL << TocParser::DECIMAL_LIT) + | (1ULL << TocParser::STRING_LIT) + | (1ULL << TocParser::BOOL_LIT) + | (1ULL << TocParser::NAME))) != 0)) { + setState(262); + expr(); + setState(267); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TocParser::T__9) { + setState(263); + match(TocParser::T__9); + setState(264); + expr(); + setState(269); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(272); + match(TocParser::T__8); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; } -void TocParser::NonAccessExprContext::enterRule(tree::ParseTreeListener *listener) { +//----------------- 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->enterNonAccessExpr(this); + parserListener->enterOpExpr(this); } -void TocParser::NonAccessExprContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::OpExprContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitNonAccessExpr(this); + parserListener->exitOpExpr(this); } -TocParser::NonAccessExprContext* TocParser::nonAccessExpr() { - NonAccessExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 46, TocParser::RuleNonAccessExpr); +TocParser::OpExprContext* TocParser::opExpr() { + OpExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 54, TocParser::RuleOpExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1790,48 +2209,34 @@ TocParser::NonAccessExprContext* TocParser::nonAccessExpr() { exitRule(); }); try { - setState(204); + setState(278); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 12, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 21, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(198); - funcCall(); + setState(274); + binaryOp(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(199); - literal(); + setState(275); + prefixOp(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(200); - identifier(); + setState(276); + postfixOp(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(201); - subscript(); - break; - } - - case 5: { - enterOuterAlt(_localctx, 5); - setState(202); - parenExpr(); - break; - } - - case 6: { - enterOuterAlt(_localctx, 6); - setState(203); - operatorExpr(); + setState(277); + ternaryOp(); break; } @@ -1849,44 +2254,48 @@ TocParser::NonAccessExprContext* TocParser::nonAccessExpr() { return _localctx; } -//----------------- FuncCallContext ------------------------------------------------------------------ +//----------------- BinaryOpContext ------------------------------------------------------------------ -TocParser::FuncCallContext::FuncCallContext(ParserRuleContext *parent, size_t invokingState) +TocParser::BinaryOpContext::BinaryOpContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncNameContext* TocParser::FuncCallContext::funcName() { - return getRuleContext(0); +std::vector TocParser::BinaryOpContext::nonOpExpr() { + return getRuleContexts(); } -std::vector TocParser::FuncCallContext::expr() { - return getRuleContexts(); +TocParser::NonOpExprContext* TocParser::BinaryOpContext::nonOpExpr(size_t i) { + return getRuleContext(i); } -TocParser::ExprContext* TocParser::FuncCallContext::expr(size_t i) { - return getRuleContext(i); +std::vector TocParser::BinaryOpContext::BINARY_OP() { + return getTokens(TocParser::BINARY_OP); } +tree::TerminalNode* TocParser::BinaryOpContext::BINARY_OP(size_t i) { + return getToken(TocParser::BINARY_OP, i); +} -size_t TocParser::FuncCallContext::getRuleIndex() const { - return TocParser::RuleFuncCall; + +size_t TocParser::BinaryOpContext::getRuleIndex() const { + return TocParser::RuleBinaryOp; } -void TocParser::FuncCallContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::BinaryOpContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterFuncCall(this); + parserListener->enterBinaryOp(this); } -void TocParser::FuncCallContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::BinaryOpContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitFuncCall(this); + parserListener->exitBinaryOp(this); } -TocParser::FuncCallContext* TocParser::funcCall() { - FuncCallContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 48, TocParser::RuleFuncCall); +TocParser::BinaryOpContext* TocParser::binaryOp() { + BinaryOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 56, TocParser::RuleBinaryOp); size_t _la = 0; #if __cplusplus > 201703L @@ -1898,35 +2307,24 @@ TocParser::FuncCallContext* TocParser::funcCall() { }); try { enterOuterAlt(_localctx, 1); - setState(206); - funcName(); - setState(207); - match(TocParser::T__4); - setState(216); + setState(280); + nonOpExpr(); + setState(281); + match(TocParser::BINARY_OP); + setState(282); + nonOpExpr(); + setState(287); _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(208); - expr(); - setState(213); + while (_la == TocParser::BINARY_OP) { + setState(283); + match(TocParser::BINARY_OP); + setState(284); + nonOpExpr(); + setState(289); _errHandler->sync(this); _la = _input->LA(1); - while (_la == TocParser::T__6) { - setState(209); - match(TocParser::T__6); - setState(210); - expr(); - setState(215); - _errHandler->sync(this); - _la = _input->LA(1); - } } - setState(218); - match(TocParser::T__5); } catch (RecognitionException &e) { @@ -1938,36 +2336,40 @@ TocParser::FuncCallContext* TocParser::funcCall() { return _localctx; } -//----------------- OperatorExprContext ------------------------------------------------------------------ +//----------------- PrefixOpContext ------------------------------------------------------------------ -TocParser::OperatorExprContext::OperatorExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::PrefixOpContext::PrefixOpContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::BinaryOperatorContext* TocParser::OperatorExprContext::binaryOperator() { - return getRuleContext(0); +tree::TerminalNode* TocParser::PrefixOpContext::PREFIX_OP() { + return getToken(TocParser::PREFIX_OP, 0); } +TocParser::NonOpExprContext* TocParser::PrefixOpContext::nonOpExpr() { + return getRuleContext(0); +} -size_t TocParser::OperatorExprContext::getRuleIndex() const { - return TocParser::RuleOperatorExpr; + +size_t TocParser::PrefixOpContext::getRuleIndex() const { + return TocParser::RulePrefixOp; } -void TocParser::OperatorExprContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::PrefixOpContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterOperatorExpr(this); + parserListener->enterPrefixOp(this); } -void TocParser::OperatorExprContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::PrefixOpContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitOperatorExpr(this); + parserListener->exitPrefixOp(this); } -TocParser::OperatorExprContext* TocParser::operatorExpr() { - OperatorExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 50, TocParser::RuleOperatorExpr); +TocParser::PrefixOpContext* TocParser::prefixOp() { + PrefixOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 58, TocParser::RulePrefixOp); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1978,8 +2380,10 @@ TocParser::OperatorExprContext* TocParser::operatorExpr() { }); try { enterOuterAlt(_localctx, 1); - setState(220); - binaryOperator(); + setState(290); + match(TocParser::PREFIX_OP); + setState(291); + nonOpExpr(); } catch (RecognitionException &e) { @@ -1991,49 +2395,40 @@ TocParser::OperatorExprContext* TocParser::operatorExpr() { return _localctx; } -//----------------- BinaryOperatorContext ------------------------------------------------------------------ +//----------------- PostfixOpContext ------------------------------------------------------------------ -TocParser::BinaryOperatorContext::BinaryOperatorContext(ParserRuleContext *parent, size_t invokingState) +TocParser::PostfixOpContext::PostfixOpContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -std::vector TocParser::BinaryOperatorContext::nonOpExpr() { - return getRuleContexts(); -} - -TocParser::NonOpExprContext* TocParser::BinaryOperatorContext::nonOpExpr(size_t i) { - return getRuleContext(i); -} - -std::vector TocParser::BinaryOperatorContext::BINARY_OPERATOR() { - return getTokens(TocParser::BINARY_OPERATOR); +TocParser::NonOpExprContext* TocParser::PostfixOpContext::nonOpExpr() { + return getRuleContext(0); } -tree::TerminalNode* TocParser::BinaryOperatorContext::BINARY_OPERATOR(size_t i) { - return getToken(TocParser::BINARY_OPERATOR, i); +tree::TerminalNode* TocParser::PostfixOpContext::POSTFIX_OP() { + return getToken(TocParser::POSTFIX_OP, 0); } -size_t TocParser::BinaryOperatorContext::getRuleIndex() const { - return TocParser::RuleBinaryOperator; +size_t TocParser::PostfixOpContext::getRuleIndex() const { + return TocParser::RulePostfixOp; } -void TocParser::BinaryOperatorContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::PostfixOpContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterBinaryOperator(this); + parserListener->enterPostfixOp(this); } -void TocParser::BinaryOperatorContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::PostfixOpContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitBinaryOperator(this); + parserListener->exitPostfixOp(this); } -TocParser::BinaryOperatorContext* TocParser::binaryOperator() { - BinaryOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 52, TocParser::RuleBinaryOperator); - size_t _la = 0; +TocParser::PostfixOpContext* TocParser::postfixOp() { + PostfixOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 60, TocParser::RulePostfixOp); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2044,24 +2439,10 @@ TocParser::BinaryOperatorContext* TocParser::binaryOperator() { }); try { enterOuterAlt(_localctx, 1); - setState(222); - nonOpExpr(); - setState(223); - match(TocParser::BINARY_OPERATOR); - setState(224); + setState(293); nonOpExpr(); - setState(229); - _errHandler->sync(this); - _la = _input->LA(1); - while (_la == TocParser::BINARY_OPERATOR) { - setState(225); - match(TocParser::BINARY_OPERATOR); - setState(226); - nonOpExpr(); - setState(231); - _errHandler->sync(this); - _la = _input->LA(1); - } + setState(294); + match(TocParser::POSTFIX_OP); } catch (RecognitionException &e) { @@ -2073,36 +2454,44 @@ TocParser::BinaryOperatorContext* TocParser::binaryOperator() { return _localctx; } -//----------------- IdentifierContext ------------------------------------------------------------------ +//----------------- TernaryOpContext ------------------------------------------------------------------ -TocParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState) +TocParser::TernaryOpContext::TernaryOpContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::VarNameContext* TocParser::IdentifierContext::varName() { - return getRuleContext(0); +TocParser::NonOpExprContext* TocParser::TernaryOpContext::nonOpExpr() { + return getRuleContext(0); } +std::vector TocParser::TernaryOpContext::expr() { + return getRuleContexts(); +} -size_t TocParser::IdentifierContext::getRuleIndex() const { - return TocParser::RuleIdentifier; +TocParser::ExprContext* TocParser::TernaryOpContext::expr(size_t i) { + return getRuleContext(i); } -void TocParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) { + +size_t TocParser::TernaryOpContext::getRuleIndex() const { + return TocParser::RuleTernaryOp; +} + +void TocParser::TernaryOpContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterIdentifier(this); + parserListener->enterTernaryOp(this); } -void TocParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::TernaryOpContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitIdentifier(this); + parserListener->exitTernaryOp(this); } -TocParser::IdentifierContext* TocParser::identifier() { - IdentifierContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 54, TocParser::RuleIdentifier); +TocParser::TernaryOpContext* TocParser::ternaryOp() { + TernaryOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 62, TocParser::RuleTernaryOp); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2113,8 +2502,16 @@ TocParser::IdentifierContext* TocParser::identifier() { }); try { enterOuterAlt(_localctx, 1); - setState(232); - varName(); + setState(296); + nonOpExpr(); + setState(297); + match(TocParser::T__20); + setState(298); + expr(); + setState(299); + match(TocParser::T__1); + setState(300); + expr(); } catch (RecognitionException &e) { @@ -2126,36 +2523,36 @@ TocParser::IdentifierContext* TocParser::identifier() { return _localctx; } -//----------------- LiteralContext ------------------------------------------------------------------ +//----------------- IdentifierExprContext ------------------------------------------------------------------ -TocParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState) +TocParser::IdentifierExprContext::IdentifierExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -tree::TerminalNode* TocParser::LiteralContext::INTLIT() { - return getToken(TocParser::INTLIT, 0); +TocParser::VarNameContext* TocParser::IdentifierExprContext::varName() { + return getRuleContext(0); } -size_t TocParser::LiteralContext::getRuleIndex() const { - return TocParser::RuleLiteral; +size_t TocParser::IdentifierExprContext::getRuleIndex() const { + return TocParser::RuleIdentifierExpr; } -void TocParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::IdentifierExprContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterLiteral(this); + parserListener->enterIdentifierExpr(this); } -void TocParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::IdentifierExprContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitLiteral(this); + parserListener->exitIdentifierExpr(this); } -TocParser::LiteralContext* TocParser::literal() { - LiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 56, TocParser::RuleLiteral); +TocParser::IdentifierExprContext* TocParser::identifierExpr() { + IdentifierExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 64, TocParser::RuleIdentifierExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2166,8 +2563,8 @@ TocParser::LiteralContext* TocParser::literal() { }); try { enterOuterAlt(_localctx, 1); - setState(234); - match(TocParser::INTLIT); + setState(302); + varName(); } catch (RecognitionException &e) { @@ -2179,40 +2576,49 @@ TocParser::LiteralContext* TocParser::literal() { return _localctx; } -//----------------- SubscriptContext ------------------------------------------------------------------ +//----------------- LitExprContext ------------------------------------------------------------------ -TocParser::SubscriptContext::SubscriptContext(ParserRuleContext *parent, size_t invokingState) +TocParser::LitExprContext::LitExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::NonSubscriptExprContext* TocParser::SubscriptContext::nonSubscriptExpr() { - return getRuleContext(0); +tree::TerminalNode* TocParser::LitExprContext::INT_LIT() { + return getToken(TocParser::INT_LIT, 0); } -TocParser::ExprContext* TocParser::SubscriptContext::expr() { - return getRuleContext(0); +tree::TerminalNode* TocParser::LitExprContext::DECIMAL_LIT() { + return getToken(TocParser::DECIMAL_LIT, 0); +} + +tree::TerminalNode* TocParser::LitExprContext::STRING_LIT() { + return getToken(TocParser::STRING_LIT, 0); +} + +tree::TerminalNode* TocParser::LitExprContext::BOOL_LIT() { + return getToken(TocParser::BOOL_LIT, 0); } -size_t TocParser::SubscriptContext::getRuleIndex() const { - return TocParser::RuleSubscript; +size_t TocParser::LitExprContext::getRuleIndex() const { + return TocParser::RuleLitExpr; } -void TocParser::SubscriptContext::enterRule(tree::ParseTreeListener *listener) { +void TocParser::LitExprContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterSubscript(this); + parserListener->enterLitExpr(this); } -void TocParser::SubscriptContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::LitExprContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitSubscript(this); + parserListener->exitLitExpr(this); } -TocParser::SubscriptContext* TocParser::subscript() { - SubscriptContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 58, TocParser::RuleSubscript); +TocParser::LitExprContext* TocParser::litExpr() { + LitExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 66, TocParser::RuleLitExpr); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2223,14 +2629,19 @@ TocParser::SubscriptContext* TocParser::subscript() { }); try { enterOuterAlt(_localctx, 1); - setState(236); - nonSubscriptExpr(); - setState(237); - match(TocParser::T__13); - setState(238); - expr(); - setState(239); - match(TocParser::T__14); + setState(304); + _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(); + } } catch (RecognitionException &e) { @@ -2242,40 +2653,53 @@ TocParser::SubscriptContext* TocParser::subscript() { return _localctx; } -//----------------- MemberAccessContext ------------------------------------------------------------------ +//----------------- AccessExprContext ------------------------------------------------------------------ -TocParser::MemberAccessContext::MemberAccessContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AccessExprContext::AccessExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -std::vector TocParser::MemberAccessContext::identifier() { - return getRuleContexts(); +TocParser::NonAccessExprContext* TocParser::AccessExprContext::nonAccessExpr() { + return getRuleContext(0); } -TocParser::IdentifierContext* TocParser::MemberAccessContext::identifier(size_t i) { - return getRuleContext(i); +std::vector TocParser::AccessExprContext::identifierExpr() { + return getRuleContexts(); } +TocParser::IdentifierExprContext* TocParser::AccessExprContext::identifierExpr(size_t i) { + return getRuleContext(i); +} -size_t TocParser::MemberAccessContext::getRuleIndex() const { - return TocParser::RuleMemberAccess; +std::vector TocParser::AccessExprContext::expr() { + return getRuleContexts(); } -void TocParser::MemberAccessContext::enterRule(tree::ParseTreeListener *listener) { +TocParser::ExprContext* TocParser::AccessExprContext::expr(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::AccessExprContext::getRuleIndex() const { + return TocParser::RuleAccessExpr; +} + +void TocParser::AccessExprContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->enterMemberAccess(this); + parserListener->enterAccessExpr(this); } -void TocParser::MemberAccessContext::exitRule(tree::ParseTreeListener *listener) { +void TocParser::AccessExprContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) - parserListener->exitMemberAccess(this); + parserListener->exitAccessExpr(this); } -TocParser::MemberAccessContext* TocParser::memberAccess() { - MemberAccessContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 60, TocParser::RuleMemberAccess); +TocParser::AccessExprContext* TocParser::accessExpr() { + AccessExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 68, TocParser::RuleAccessExpr); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2286,12 +2710,53 @@ TocParser::MemberAccessContext* TocParser::memberAccess() { }); try { enterOuterAlt(_localctx, 1); - setState(241); - identifier(); - setState(242); - match(TocParser::T__15); - setState(243); - identifier(); + setState(306); + nonAccessExpr(); + setState(313); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(313); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TocParser::T__21: + case TocParser::T__22: { + setState(307); + _la = _input->LA(1); + if (!(_la == TocParser::T__21 + + || _la == TocParser::T__22)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(308); + identifierExpr(); + break; + } + + case TocParser::T__4: { + setState(309); + match(TocParser::T__4); + setState(310); + expr(); + setState(311); + match(TocParser::T__5); + break; + } + + default: + throw NoViableAltException(this); + } + setState(315); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__4) + | (1ULL << TocParser::T__21) + | (1ULL << TocParser::T__22))) != 0)); } catch (RecognitionException &e) { @@ -2332,7 +2797,7 @@ void TocParser::ParenExprContext::exitRule(tree::ParseTreeListener *listener) { TocParser::ParenExprContext* TocParser::parenExpr() { ParenExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 62, TocParser::RuleParenExpr); + enterRule(_localctx, 70, TocParser::RuleParenExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2343,12 +2808,12 @@ TocParser::ParenExprContext* TocParser::parenExpr() { }); try { enterOuterAlt(_localctx, 1); - setState(245); - match(TocParser::T__4); - setState(246); + setState(317); + match(TocParser::T__7); + setState(318); expr(); - setState(247); - match(TocParser::T__5); + setState(319); + match(TocParser::T__8); } catch (RecognitionException &e) { @@ -2389,7 +2854,7 @@ void TocParser::FuncNameContext::exitRule(tree::ParseTreeListener *listener) { TocParser::FuncNameContext* TocParser::funcName() { FuncNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 64, TocParser::RuleFuncName); + enterRule(_localctx, 72, TocParser::RuleFuncName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2400,7 +2865,7 @@ TocParser::FuncNameContext* TocParser::funcName() { }); try { enterOuterAlt(_localctx, 1); - setState(249); + setState(321); match(TocParser::NAME); } @@ -2442,7 +2907,7 @@ void TocParser::VarNameContext::exitRule(tree::ParseTreeListener *listener) { TocParser::VarNameContext* TocParser::varName() { VarNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 66, TocParser::RuleVarName); + enterRule(_localctx, 74, TocParser::RuleVarName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2453,7 +2918,7 @@ TocParser::VarNameContext* TocParser::varName() { }); try { enterOuterAlt(_localctx, 1); - setState(251); + setState(323); match(TocParser::NAME); } @@ -2495,7 +2960,7 @@ void TocParser::TypeNameContext::exitRule(tree::ParseTreeListener *listener) { TocParser::TypeNameContext* TocParser::typeName() { TypeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 68, TocParser::RuleTypeName); + enterRule(_localctx, 76, TocParser::RuleTypeName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2506,7 +2971,7 @@ TocParser::TypeNameContext* TocParser::typeName() { }); try { enterOuterAlt(_localctx, 1); - setState(253); + setState(325); match(TocParser::NAME); } @@ -2548,7 +3013,7 @@ void TocParser::StructNameContext::exitRule(tree::ParseTreeListener *listener) { TocParser::StructNameContext* TocParser::structName() { StructNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 70, TocParser::RuleStructName); + enterRule(_localctx, 78, TocParser::RuleStructName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2559,7 +3024,7 @@ TocParser::StructNameContext* TocParser::structName() { }); try { enterOuterAlt(_localctx, 1); - setState(255); + setState(327); match(TocParser::NAME); } @@ -2581,22 +3046,25 @@ atn::ATN TocParser::_atn; std::vector TocParser::_serializedATN; std::vector TocParser::_ruleNames = { - "prog", "decl", "varDecl", "var", "type", "funcDecl", "func", "parameter", - "body", "structDecl", "structMember", "structVar", "structMethod", "stmt", - "conditional", "ifCond", "loop", "whileLoop", "assignment", "returnStmt", - "expr", "nonOpExpr", "nonSubscriptExpr", "nonAccessExpr", "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", "switchStmt", "switchBody", "forStmt", + "whileStmt", "assignStmt", "returnStmt", "expr", "nonOpExpr", "nonAccessExpr", + "funcExpr", "opExpr", "binaryOp", "prefixOp", "postfixOp", "ternaryOp", + "identifierExpr", "litExpr", "accessExpr", "parenExpr", "funcName", "varName", + "typeName", "structName" }; 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" + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "POSTFIX_OP", "PREFIX_OP", "BINARY_OP", "INT_LIT", + "DECIMAL_LIT", "STRING_LIT", "BOOL_LIT", "NAME", "WS", "NEWLINE", "NUMBER" }; dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames); @@ -2619,7 +3087,7 @@ TocParser::Initializer::Initializer() { static const uint16_t serializedATNSegment0[] = { 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, - 0x3, 0x17, 0x104, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, + 0x3, 0x24, 0x14c, 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, @@ -2630,167 +3098,220 @@ TocParser::Initializer::Initializer() { 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 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, 0x3, 0x2, - 0x6, 0x2, 0x4c, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, 0x4d, 0x3, 0x2, 0x3, - 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 0x55, 0xa, 0x3, 0x3, - 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, - 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x60, 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, 0x3, 0x9, 0x7, 0x9, 0x73, 0xa, 0x9, 0xc, 0x9, 0xe, 0x9, - 0x76, 0xb, 0x9, 0x5, 0x9, 0x78, 0xa, 0x9, 0x3, 0xa, 0x3, 0xa, 0x7, - 0xa, 0x7c, 0xa, 0xa, 0xc, 0xa, 0xe, 0xa, 0x7f, 0xb, 0xa, 0x3, 0xa, - 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0x87, - 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x8a, 0xb, 0xb, 0x3, 0xb, 0x3, 0xb, - 0x3, 0xc, 0x3, 0xc, 0x5, 0xc, 0x90, 0xa, 0xc, 0x3, 0xd, 0x3, 0xd, - 0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, - 0xf, 0x3, 0xf, 0x5, 0xf, 0x9c, 0xa, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, - 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, - 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, - 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, - 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, - 0x16, 0xb8, 0xa, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, - 0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0xc0, 0xa, 0x17, 0x3, 0x18, 0x3, - 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0xc7, 0xa, 0x18, - 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, - 0x5, 0x19, 0xcf, 0xa, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, - 0x1a, 0x3, 0x1a, 0x7, 0x1a, 0xd6, 0xa, 0x1a, 0xc, 0x1a, 0xe, 0x1a, - 0xd9, 0xb, 0x1a, 0x5, 0x1a, 0xdb, 0xa, 0x1a, 0x3, 0x1a, 0x3, 0x1a, - 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, - 0x3, 0x1c, 0x7, 0x1c, 0xe6, 0xa, 0x1c, 0xc, 0x1c, 0xe, 0x1c, 0xe9, - 0xb, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, - 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, - 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, - 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, - 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x2, 0x2, 0x26, 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, 0x2, 0x2, 0x2, - 0x104, 0x2, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x4, 0x54, 0x3, 0x2, 0x2, 0x2, - 0x6, 0x56, 0x3, 0x2, 0x2, 0x2, 0x8, 0x59, 0x3, 0x2, 0x2, 0x2, 0xa, - 0x61, 0x3, 0x2, 0x2, 0x2, 0xc, 0x63, 0x3, 0x2, 0x2, 0x2, 0xe, 0x66, - 0x3, 0x2, 0x2, 0x2, 0x10, 0x77, 0x3, 0x2, 0x2, 0x2, 0x12, 0x79, 0x3, - 0x2, 0x2, 0x2, 0x14, 0x82, 0x3, 0x2, 0x2, 0x2, 0x16, 0x8f, 0x3, 0x2, - 0x2, 0x2, 0x18, 0x91, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x93, 0x3, 0x2, 0x2, - 0x2, 0x1c, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x9d, 0x3, 0x2, 0x2, 0x2, - 0x20, 0x9f, 0x3, 0x2, 0x2, 0x2, 0x22, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x24, - 0xa5, 0x3, 0x2, 0x2, 0x2, 0x26, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x28, 0xad, - 0x3, 0x2, 0x2, 0x2, 0x2a, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xbf, 0x3, - 0x2, 0x2, 0x2, 0x2e, 0xc6, 0x3, 0x2, 0x2, 0x2, 0x30, 0xce, 0x3, 0x2, - 0x2, 0x2, 0x32, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x34, 0xde, 0x3, 0x2, 0x2, - 0x2, 0x36, 0xe0, 0x3, 0x2, 0x2, 0x2, 0x38, 0xea, 0x3, 0x2, 0x2, 0x2, - 0x3a, 0xec, 0x3, 0x2, 0x2, 0x2, 0x3c, 0xee, 0x3, 0x2, 0x2, 0x2, 0x3e, - 0xf3, 0x3, 0x2, 0x2, 0x2, 0x40, 0xf7, 0x3, 0x2, 0x2, 0x2, 0x42, 0xfb, - 0x3, 0x2, 0x2, 0x2, 0x44, 0xfd, 0x3, 0x2, 0x2, 0x2, 0x46, 0xff, 0x3, - 0x2, 0x2, 0x2, 0x48, 0x101, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x4c, 0x5, - 0x4, 0x3, 0x2, 0x4b, 0x4a, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x4d, 0x3, 0x2, - 0x2, 0x2, 0x4d, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x4e, 0x3, 0x2, 0x2, - 0x2, 0x4e, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0x7, 0x2, 0x2, 0x3, - 0x50, 0x3, 0x3, 0x2, 0x2, 0x2, 0x51, 0x55, 0x5, 0x6, 0x4, 0x2, 0x52, - 0x55, 0x5, 0xc, 0x7, 0x2, 0x53, 0x55, 0x5, 0x14, 0xb, 0x2, 0x54, - 0x51, 0x3, 0x2, 0x2, 0x2, 0x54, 0x52, 0x3, 0x2, 0x2, 0x2, 0x54, 0x53, - 0x3, 0x2, 0x2, 0x2, 0x55, 0x5, 0x3, 0x2, 0x2, 0x2, 0x56, 0x57, 0x7, - 0x3, 0x2, 0x2, 0x57, 0x58, 0x5, 0x8, 0x5, 0x2, 0x58, 0x7, 0x3, 0x2, - 0x2, 0x2, 0x59, 0x5a, 0x5, 0x44, 0x23, 0x2, 0x5a, 0x5b, 0x7, 0x4, - 0x2, 0x2, 0x5b, 0x5c, 0x5, 0xa, 0x6, 0x2, 0x5c, 0x5f, 0x3, 0x2, 0x2, - 0x2, 0x5d, 0x5e, 0x7, 0x5, 0x2, 0x2, 0x5e, 0x60, 0x5, 0x2a, 0x16, - 0x2, 0x5f, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x5f, 0x60, 0x3, 0x2, 0x2, 0x2, - 0x60, 0x9, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x5, 0x46, 0x24, 0x2, - 0x62, 0xb, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, 0x7, 0x6, 0x2, 0x2, 0x64, - 0x65, 0x5, 0xe, 0x8, 0x2, 0x65, 0xd, 0x3, 0x2, 0x2, 0x2, 0x66, 0x67, - 0x5, 0x42, 0x22, 0x2, 0x67, 0x68, 0x7, 0x7, 0x2, 0x2, 0x68, 0x69, - 0x5, 0x10, 0x9, 0x2, 0x69, 0x6a, 0x7, 0x8, 0x2, 0x2, 0x6a, 0x6b, - 0x7, 0x4, 0x2, 0x2, 0x6b, 0x6c, 0x5, 0xa, 0x6, 0x2, 0x6c, 0x6d, 0x3, - 0x2, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0x12, 0xa, 0x2, 0x6e, 0xf, 0x3, 0x2, - 0x2, 0x2, 0x6f, 0x74, 0x5, 0x8, 0x5, 0x2, 0x70, 0x71, 0x7, 0x9, 0x2, - 0x2, 0x71, 0x73, 0x5, 0x8, 0x5, 0x2, 0x72, 0x70, 0x3, 0x2, 0x2, 0x2, - 0x73, 0x76, 0x3, 0x2, 0x2, 0x2, 0x74, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, - 0x75, 0x3, 0x2, 0x2, 0x2, 0x75, 0x78, 0x3, 0x2, 0x2, 0x2, 0x76, 0x74, - 0x3, 0x2, 0x2, 0x2, 0x77, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x77, 0x78, 0x3, - 0x2, 0x2, 0x2, 0x78, 0x11, 0x3, 0x2, 0x2, 0x2, 0x79, 0x7d, 0x7, 0xa, - 0x2, 0x2, 0x7a, 0x7c, 0x5, 0x1c, 0xf, 0x2, 0x7b, 0x7a, 0x3, 0x2, - 0x2, 0x2, 0x7c, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x7b, 0x3, 0x2, 0x2, - 0x2, 0x7d, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x80, 0x3, 0x2, 0x2, 0x2, - 0x7f, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x80, 0x81, 0x7, 0xb, 0x2, 0x2, 0x81, - 0x13, 0x3, 0x2, 0x2, 0x2, 0x82, 0x83, 0x7, 0xc, 0x2, 0x2, 0x83, 0x84, - 0x5, 0x48, 0x25, 0x2, 0x84, 0x88, 0x7, 0xa, 0x2, 0x2, 0x85, 0x87, - 0x5, 0x16, 0xc, 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, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x88, 0x3, 0x2, - 0x2, 0x2, 0x8b, 0x8c, 0x7, 0xb, 0x2, 0x2, 0x8c, 0x15, 0x3, 0x2, 0x2, - 0x2, 0x8d, 0x90, 0x5, 0x18, 0xd, 0x2, 0x8e, 0x90, 0x5, 0x1a, 0xe, - 0x2, 0x8f, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x8f, 0x8e, 0x3, 0x2, 0x2, 0x2, - 0x90, 0x17, 0x3, 0x2, 0x2, 0x2, 0x91, 0x92, 0x5, 0x8, 0x5, 0x2, 0x92, - 0x19, 0x3, 0x2, 0x2, 0x2, 0x93, 0x94, 0x5, 0xe, 0x8, 0x2, 0x94, 0x1b, - 0x3, 0x2, 0x2, 0x2, 0x95, 0x9c, 0x5, 0x6, 0x4, 0x2, 0x96, 0x9c, 0x5, - 0x1e, 0x10, 0x2, 0x97, 0x9c, 0x5, 0x22, 0x12, 0x2, 0x98, 0x9c, 0x5, - 0x26, 0x14, 0x2, 0x99, 0x9c, 0x5, 0x28, 0x15, 0x2, 0x9a, 0x9c, 0x5, - 0x2a, 0x16, 0x2, 0x9b, 0x95, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x96, 0x3, - 0x2, 0x2, 0x2, 0x9b, 0x97, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x98, 0x3, 0x2, - 0x2, 0x2, 0x9b, 0x99, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x9a, 0x3, 0x2, 0x2, - 0x2, 0x9c, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x9d, 0x9e, 0x5, 0x20, 0x11, - 0x2, 0x9e, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x9f, 0xa0, 0x7, 0xd, 0x2, 0x2, - 0xa0, 0xa1, 0x5, 0x2a, 0x16, 0x2, 0xa1, 0xa2, 0x5, 0x12, 0xa, 0x2, - 0xa2, 0x21, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x5, 0x24, 0x13, 0x2, - 0xa4, 0x23, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x7, 0xe, 0x2, 0x2, 0xa6, - 0xa7, 0x5, 0x2a, 0x16, 0x2, 0xa7, 0xa8, 0x5, 0x12, 0xa, 0x2, 0xa8, - 0x25, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x5, 0x38, 0x1d, 0x2, 0xaa, - 0xab, 0x7, 0x5, 0x2, 0x2, 0xab, 0xac, 0x5, 0x2a, 0x16, 0x2, 0xac, - 0x27, 0x3, 0x2, 0x2, 0x2, 0xad, 0xae, 0x7, 0xf, 0x2, 0x2, 0xae, 0xaf, - 0x5, 0x2a, 0x16, 0x2, 0xaf, 0x29, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xb8, - 0x5, 0x32, 0x1a, 0x2, 0xb1, 0xb8, 0x5, 0x3a, 0x1e, 0x2, 0xb2, 0xb8, - 0x5, 0x38, 0x1d, 0x2, 0xb3, 0xb8, 0x5, 0x3c, 0x1f, 0x2, 0xb4, 0xb8, - 0x5, 0x3e, 0x20, 0x2, 0xb5, 0xb8, 0x5, 0x40, 0x21, 0x2, 0xb6, 0xb8, - 0x5, 0x34, 0x1b, 0x2, 0xb7, 0xb0, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb1, - 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb3, 0x3, - 0x2, 0x2, 0x2, 0xb7, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb5, 0x3, 0x2, - 0x2, 0x2, 0xb7, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb8, 0x2b, 0x3, 0x2, 0x2, - 0x2, 0xb9, 0xc0, 0x5, 0x32, 0x1a, 0x2, 0xba, 0xc0, 0x5, 0x3a, 0x1e, - 0x2, 0xbb, 0xc0, 0x5, 0x38, 0x1d, 0x2, 0xbc, 0xc0, 0x5, 0x3c, 0x1f, - 0x2, 0xbd, 0xc0, 0x5, 0x3e, 0x20, 0x2, 0xbe, 0xc0, 0x5, 0x40, 0x21, - 0x2, 0xbf, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xba, 0x3, 0x2, 0x2, 0x2, - 0xbf, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbf, - 0xbd, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xbe, 0x3, 0x2, 0x2, 0x2, 0xc0, 0x2d, - 0x3, 0x2, 0x2, 0x2, 0xc1, 0xc7, 0x5, 0x32, 0x1a, 0x2, 0xc2, 0xc7, - 0x5, 0x3a, 0x1e, 0x2, 0xc3, 0xc7, 0x5, 0x38, 0x1d, 0x2, 0xc4, 0xc7, - 0x5, 0x3e, 0x20, 0x2, 0xc5, 0xc7, 0x5, 0x40, 0x21, 0x2, 0xc6, 0xc1, - 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc2, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc3, 0x3, - 0x2, 0x2, 0x2, 0xc6, 0xc4, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc5, 0x3, 0x2, - 0x2, 0x2, 0xc7, 0x2f, 0x3, 0x2, 0x2, 0x2, 0xc8, 0xcf, 0x5, 0x32, - 0x1a, 0x2, 0xc9, 0xcf, 0x5, 0x3a, 0x1e, 0x2, 0xca, 0xcf, 0x5, 0x38, - 0x1d, 0x2, 0xcb, 0xcf, 0x5, 0x3c, 0x1f, 0x2, 0xcc, 0xcf, 0x5, 0x40, - 0x21, 0x2, 0xcd, 0xcf, 0x5, 0x34, 0x1b, 0x2, 0xce, 0xc8, 0x3, 0x2, - 0x2, 0x2, 0xce, 0xc9, 0x3, 0x2, 0x2, 0x2, 0xce, 0xca, 0x3, 0x2, 0x2, - 0x2, 0xce, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xce, 0xcc, 0x3, 0x2, 0x2, 0x2, - 0xce, 0xcd, 0x3, 0x2, 0x2, 0x2, 0xcf, 0x31, 0x3, 0x2, 0x2, 0x2, 0xd0, - 0xd1, 0x5, 0x42, 0x22, 0x2, 0xd1, 0xda, 0x7, 0x7, 0x2, 0x2, 0xd2, - 0xd7, 0x5, 0x2a, 0x16, 0x2, 0xd3, 0xd4, 0x7, 0x9, 0x2, 0x2, 0xd4, - 0xd6, 0x5, 0x2a, 0x16, 0x2, 0xd5, 0xd3, 0x3, 0x2, 0x2, 0x2, 0xd6, - 0xd9, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, - 0x3, 0x2, 0x2, 0x2, 0xd8, 0xdb, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xd7, 0x3, - 0x2, 0x2, 0x2, 0xda, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xda, 0xdb, 0x3, 0x2, - 0x2, 0x2, 0xdb, 0xdc, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xdd, 0x7, 0x8, 0x2, - 0x2, 0xdd, 0x33, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdf, 0x5, 0x36, 0x1c, - 0x2, 0xdf, 0x35, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xe1, 0x5, 0x2c, 0x17, - 0x2, 0xe1, 0xe2, 0x7, 0x13, 0x2, 0x2, 0xe2, 0xe7, 0x5, 0x2c, 0x17, - 0x2, 0xe3, 0xe4, 0x7, 0x13, 0x2, 0x2, 0xe4, 0xe6, 0x5, 0x2c, 0x17, - 0x2, 0xe5, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe9, 0x3, 0x2, 0x2, 0x2, - 0xe7, 0xe5, 0x3, 0x2, 0x2, 0x2, 0xe7, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xe8, - 0x37, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xe7, 0x3, 0x2, 0x2, 0x2, 0xea, 0xeb, - 0x5, 0x44, 0x23, 0x2, 0xeb, 0x39, 0x3, 0x2, 0x2, 0x2, 0xec, 0xed, - 0x7, 0x14, 0x2, 0x2, 0xed, 0x3b, 0x3, 0x2, 0x2, 0x2, 0xee, 0xef, - 0x5, 0x2e, 0x18, 0x2, 0xef, 0xf0, 0x7, 0x10, 0x2, 0x2, 0xf0, 0xf1, - 0x5, 0x2a, 0x16, 0x2, 0xf1, 0xf2, 0x7, 0x11, 0x2, 0x2, 0xf2, 0x3d, - 0x3, 0x2, 0x2, 0x2, 0xf3, 0xf4, 0x5, 0x38, 0x1d, 0x2, 0xf4, 0xf5, - 0x7, 0x12, 0x2, 0x2, 0xf5, 0xf6, 0x5, 0x38, 0x1d, 0x2, 0xf6, 0x3f, - 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf8, 0x7, 0x7, 0x2, 0x2, 0xf8, 0xf9, 0x5, - 0x2a, 0x16, 0x2, 0xf9, 0xfa, 0x7, 0x8, 0x2, 0x2, 0xfa, 0x41, 0x3, - 0x2, 0x2, 0x2, 0xfb, 0xfc, 0x7, 0x15, 0x2, 0x2, 0xfc, 0x43, 0x3, - 0x2, 0x2, 0x2, 0xfd, 0xfe, 0x7, 0x15, 0x2, 0x2, 0xfe, 0x45, 0x3, - 0x2, 0x2, 0x2, 0xff, 0x100, 0x7, 0x15, 0x2, 0x2, 0x100, 0x47, 0x3, - 0x2, 0x2, 0x2, 0x101, 0x102, 0x7, 0x15, 0x2, 0x2, 0x102, 0x49, 0x3, - 0x2, 0x2, 0x2, 0x12, 0x4d, 0x54, 0x5f, 0x74, 0x77, 0x7d, 0x88, 0x8f, - 0x9b, 0xb7, 0xbf, 0xc6, 0xce, 0xd7, 0xda, 0xe7, + 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, + 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 0x4, 0x29, + 0x9, 0x29, 0x3, 0x2, 0x6, 0x2, 0x54, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, + 0x55, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, + 0x5d, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, + 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x68, 0xa, 0x5, + 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, + 0x6, 0x3, 0x7, 0x3, 0x7, 0x7, 0x7, 0x73, 0xa, 0x7, 0xc, 0x7, 0xe, + 0x7, 0x76, 0xb, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x5, 0x8, 0x7b, + 0xa, 0x8, 0x3, 0x8, 0x5, 0x8, 0x7e, 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, 0x8f, 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x92, 0xb, 0xb, 0x5, + 0xb, 0x94, 0xa, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 0x98, 0xa, 0xc, + 0xc, 0xc, 0xe, 0xc, 0x9b, 0xb, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd, + 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0xa3, 0xa, 0xd, 0xc, 0xd, + 0xe, 0xd, 0xa6, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, + 0x5, 0xe, 0xac, 0xa, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, + 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, + 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0xba, 0xa, 0x11, 0x3, 0x12, 0x3, + 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, + 0x12, 0x7, 0x12, 0xc4, 0xa, 0x12, 0xc, 0x12, 0xe, 0x12, 0xc7, 0xb, + 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0xcb, 0xa, 0x12, 0x3, 0x13, + 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, + 0x3, 0x14, 0x3, 0x14, 0x7, 0x14, 0xd6, 0xa, 0x14, 0xc, 0x14, 0xe, + 0x14, 0xd9, 0xb, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, + 0x3, 0x15, 0x5, 0x15, 0xe0, 0xa, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, + 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, + 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, + 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, + 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0xf9, 0xa, 0x19, 0x3, 0x1a, + 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0x100, 0xa, + 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x5, 0x1b, 0x105, 0xa, 0x1b, + 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x7, 0x1c, + 0x10c, 0xa, 0x1c, 0xc, 0x1c, 0xe, 0x1c, 0x10f, 0xb, 0x1c, 0x5, 0x1c, + 0x111, 0xa, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x119, 0xa, 0x1d, 0x3, 0x1e, 0x3, 0x1e, + 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x7, 0x1e, 0x120, 0xa, 0x1e, 0xc, + 0x1e, 0xe, 0x1e, 0x123, 0xb, 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, + 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, + 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, + 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, + 0x3, 0x24, 0x3, 0x24, 0x6, 0x24, 0x13c, 0xa, 0x24, 0xd, 0x24, 0xe, + 0x24, 0x13d, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, + 0x3, 0x26, 0x3, 0x27, 0x3, 0x27, 0x3, 0x28, 0x3, 0x28, 0x3, 0x29, + 0x3, 0x29, 0x3, 0x29, 0x2, 0x2, 0x2a, 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, 0x2, 0x4, 0x3, 0x2, 0x1d, 0x20, 0x3, 0x2, 0x18, 0x19, 0x2, + 0x14d, 0x2, 0x53, 0x3, 0x2, 0x2, 0x2, 0x4, 0x5c, 0x3, 0x2, 0x2, 0x2, + 0x6, 0x5e, 0x3, 0x2, 0x2, 0x2, 0x8, 0x61, 0x3, 0x2, 0x2, 0x2, 0xa, + 0x69, 0x3, 0x2, 0x2, 0x2, 0xc, 0x70, 0x3, 0x2, 0x2, 0x2, 0xe, 0x7d, + 0x3, 0x2, 0x2, 0x2, 0x10, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x12, 0x82, 0x3, + 0x2, 0x2, 0x2, 0x14, 0x93, 0x3, 0x2, 0x2, 0x2, 0x16, 0x95, 0x3, 0x2, + 0x2, 0x2, 0x18, 0x9e, 0x3, 0x2, 0x2, 0x2, 0x1a, 0xab, 0x3, 0x2, 0x2, + 0x2, 0x1c, 0xad, 0x3, 0x2, 0x2, 0x2, 0x1e, 0xaf, 0x3, 0x2, 0x2, 0x2, + 0x20, 0xb9, 0x3, 0x2, 0x2, 0x2, 0x22, 0xbb, 0x3, 0x2, 0x2, 0x2, 0x24, + 0xcc, 0x3, 0x2, 0x2, 0x2, 0x26, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x28, 0xdc, + 0x3, 0x2, 0x2, 0x2, 0x2a, 0xe7, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xeb, 0x3, + 0x2, 0x2, 0x2, 0x2e, 0xef, 0x3, 0x2, 0x2, 0x2, 0x30, 0xf8, 0x3, 0x2, + 0x2, 0x2, 0x32, 0xff, 0x3, 0x2, 0x2, 0x2, 0x34, 0x104, 0x3, 0x2, + 0x2, 0x2, 0x36, 0x106, 0x3, 0x2, 0x2, 0x2, 0x38, 0x118, 0x3, 0x2, + 0x2, 0x2, 0x3a, 0x11a, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x124, 0x3, 0x2, + 0x2, 0x2, 0x3e, 0x127, 0x3, 0x2, 0x2, 0x2, 0x40, 0x12a, 0x3, 0x2, + 0x2, 0x2, 0x42, 0x130, 0x3, 0x2, 0x2, 0x2, 0x44, 0x132, 0x3, 0x2, + 0x2, 0x2, 0x46, 0x134, 0x3, 0x2, 0x2, 0x2, 0x48, 0x13f, 0x3, 0x2, + 0x2, 0x2, 0x4a, 0x143, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x145, 0x3, 0x2, + 0x2, 0x2, 0x4e, 0x147, 0x3, 0x2, 0x2, 0x2, 0x50, 0x149, 0x3, 0x2, + 0x2, 0x2, 0x52, 0x54, 0x5, 0x4, 0x3, 0x2, 0x53, 0x52, 0x3, 0x2, 0x2, + 0x2, 0x54, 0x55, 0x3, 0x2, 0x2, 0x2, 0x55, 0x53, 0x3, 0x2, 0x2, 0x2, + 0x55, 0x56, 0x3, 0x2, 0x2, 0x2, 0x56, 0x57, 0x3, 0x2, 0x2, 0x2, 0x57, + 0x58, 0x7, 0x2, 0x2, 0x3, 0x58, 0x3, 0x3, 0x2, 0x2, 0x2, 0x59, 0x5d, + 0x5, 0x6, 0x4, 0x2, 0x5a, 0x5d, 0x5, 0x10, 0x9, 0x2, 0x5b, 0x5d, + 0x5, 0x18, 0xd, 0x2, 0x5c, 0x59, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x5a, + 0x3, 0x2, 0x2, 0x2, 0x5c, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x5d, 0x5, 0x3, + 0x2, 0x2, 0x2, 0x5e, 0x5f, 0x7, 0x3, 0x2, 0x2, 0x5f, 0x60, 0x5, 0x8, + 0x5, 0x2, 0x60, 0x7, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x5, 0x4c, 0x27, + 0x2, 0x62, 0x63, 0x7, 0x4, 0x2, 0x2, 0x63, 0x64, 0x5, 0xc, 0x7, 0x2, + 0x64, 0x67, 0x3, 0x2, 0x2, 0x2, 0x65, 0x66, 0x7, 0x5, 0x2, 0x2, 0x66, + 0x68, 0x5, 0x30, 0x19, 0x2, 0x67, 0x65, 0x3, 0x2, 0x2, 0x2, 0x67, + 0x68, 0x3, 0x2, 0x2, 0x2, 0x68, 0x9, 0x3, 0x2, 0x2, 0x2, 0x69, 0x6a, + 0x5, 0x4c, 0x27, 0x2, 0x6a, 0x6b, 0x7, 0x4, 0x2, 0x2, 0x6b, 0x6c, + 0x5, 0xc, 0x7, 0x2, 0x6c, 0x6d, 0x3, 0x2, 0x2, 0x2, 0x6d, 0x6e, 0x7, + 0x5, 0x2, 0x2, 0x6e, 0x6f, 0x5, 0x30, 0x19, 0x2, 0x6f, 0xb, 0x3, + 0x2, 0x2, 0x2, 0x70, 0x74, 0x5, 0x4e, 0x28, 0x2, 0x71, 0x73, 0x5, + 0xe, 0x8, 0x2, 0x72, 0x71, 0x3, 0x2, 0x2, 0x2, 0x73, 0x76, 0x3, 0x2, + 0x2, 0x2, 0x74, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, 0x75, 0x3, 0x2, 0x2, + 0x2, 0x75, 0xd, 0x3, 0x2, 0x2, 0x2, 0x76, 0x74, 0x3, 0x2, 0x2, 0x2, + 0x77, 0x7e, 0x7, 0x6, 0x2, 0x2, 0x78, 0x7a, 0x7, 0x7, 0x2, 0x2, 0x79, + 0x7b, 0x7, 0x24, 0x2, 0x2, 0x7a, 0x79, 0x3, 0x2, 0x2, 0x2, 0x7a, + 0x7b, 0x3, 0x2, 0x2, 0x2, 0x7b, 0x7c, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x7e, + 0x7, 0x8, 0x2, 0x2, 0x7d, 0x77, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x78, 0x3, + 0x2, 0x2, 0x2, 0x7e, 0xf, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x80, 0x7, 0x9, + 0x2, 0x2, 0x80, 0x81, 0x5, 0x12, 0xa, 0x2, 0x81, 0x11, 0x3, 0x2, + 0x2, 0x2, 0x82, 0x83, 0x5, 0x4a, 0x26, 0x2, 0x83, 0x84, 0x7, 0xa, + 0x2, 0x2, 0x84, 0x85, 0x5, 0x14, 0xb, 0x2, 0x85, 0x86, 0x7, 0xb, + 0x2, 0x2, 0x86, 0x87, 0x7, 0x4, 0x2, 0x2, 0x87, 0x88, 0x5, 0xc, 0x7, + 0x2, 0x88, 0x89, 0x3, 0x2, 0x2, 0x2, 0x89, 0x8a, 0x5, 0x16, 0xc, + 0x2, 0x8a, 0x13, 0x3, 0x2, 0x2, 0x2, 0x8b, 0x90, 0x5, 0x8, 0x5, 0x2, + 0x8c, 0x8d, 0x7, 0xc, 0x2, 0x2, 0x8d, 0x8f, 0x5, 0x8, 0x5, 0x2, 0x8e, + 0x8c, 0x3, 0x2, 0x2, 0x2, 0x8f, 0x92, 0x3, 0x2, 0x2, 0x2, 0x90, 0x8e, + 0x3, 0x2, 0x2, 0x2, 0x90, 0x91, 0x3, 0x2, 0x2, 0x2, 0x91, 0x94, 0x3, + 0x2, 0x2, 0x2, 0x92, 0x90, 0x3, 0x2, 0x2, 0x2, 0x93, 0x8b, 0x3, 0x2, + 0x2, 0x2, 0x93, 0x94, 0x3, 0x2, 0x2, 0x2, 0x94, 0x15, 0x3, 0x2, 0x2, + 0x2, 0x95, 0x99, 0x7, 0xd, 0x2, 0x2, 0x96, 0x98, 0x5, 0x20, 0x11, + 0x2, 0x97, 0x96, 0x3, 0x2, 0x2, 0x2, 0x98, 0x9b, 0x3, 0x2, 0x2, 0x2, + 0x99, 0x97, 0x3, 0x2, 0x2, 0x2, 0x99, 0x9a, 0x3, 0x2, 0x2, 0x2, 0x9a, + 0x9c, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x99, 0x3, 0x2, 0x2, 0x2, 0x9c, 0x9d, + 0x7, 0xe, 0x2, 0x2, 0x9d, 0x17, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x9f, 0x7, + 0xf, 0x2, 0x2, 0x9f, 0xa0, 0x5, 0x50, 0x29, 0x2, 0xa0, 0xa4, 0x7, + 0xd, 0x2, 0x2, 0xa1, 0xa3, 0x5, 0x1a, 0xe, 0x2, 0xa2, 0xa1, 0x3, + 0x2, 0x2, 0x2, 0xa3, 0xa6, 0x3, 0x2, 0x2, 0x2, 0xa4, 0xa2, 0x3, 0x2, + 0x2, 0x2, 0xa4, 0xa5, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa7, 0x3, 0x2, 0x2, + 0x2, 0xa6, 0xa4, 0x3, 0x2, 0x2, 0x2, 0xa7, 0xa8, 0x7, 0xe, 0x2, 0x2, + 0xa8, 0x19, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xac, 0x5, 0x1c, 0xf, 0x2, + 0xaa, 0xac, 0x5, 0x1e, 0x10, 0x2, 0xab, 0xa9, 0x3, 0x2, 0x2, 0x2, + 0xab, 0xaa, 0x3, 0x2, 0x2, 0x2, 0xac, 0x1b, 0x3, 0x2, 0x2, 0x2, 0xad, + 0xae, 0x5, 0x8, 0x5, 0x2, 0xae, 0x1d, 0x3, 0x2, 0x2, 0x2, 0xaf, 0xb0, + 0x5, 0x12, 0xa, 0x2, 0xb0, 0x1f, 0x3, 0x2, 0x2, 0x2, 0xb1, 0xba, + 0x5, 0x6, 0x4, 0x2, 0xb2, 0xba, 0x5, 0x22, 0x12, 0x2, 0xb3, 0xba, + 0x5, 0x24, 0x13, 0x2, 0xb4, 0xba, 0x5, 0x28, 0x15, 0x2, 0xb5, 0xba, + 0x5, 0x2a, 0x16, 0x2, 0xb6, 0xba, 0x5, 0x2c, 0x17, 0x2, 0xb7, 0xba, + 0x5, 0x2e, 0x18, 0x2, 0xb8, 0xba, 0x5, 0x30, 0x19, 0x2, 0xb9, 0xb1, + 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb3, 0x3, + 0x2, 0x2, 0x2, 0xb9, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb5, 0x3, 0x2, + 0x2, 0x2, 0xb9, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb7, 0x3, 0x2, 0x2, + 0x2, 0xb9, 0xb8, 0x3, 0x2, 0x2, 0x2, 0xba, 0x21, 0x3, 0x2, 0x2, 0x2, + 0xbb, 0xbc, 0x7, 0x10, 0x2, 0x2, 0xbc, 0xbd, 0x5, 0x30, 0x19, 0x2, + 0xbd, 0xc5, 0x5, 0x16, 0xc, 0x2, 0xbe, 0xbf, 0x7, 0x11, 0x2, 0x2, + 0xbf, 0xc0, 0x7, 0x10, 0x2, 0x2, 0xc0, 0xc1, 0x5, 0x30, 0x19, 0x2, + 0xc1, 0xc2, 0x5, 0x16, 0xc, 0x2, 0xc2, 0xc4, 0x3, 0x2, 0x2, 0x2, + 0xc3, 0xbe, 0x3, 0x2, 0x2, 0x2, 0xc4, 0xc7, 0x3, 0x2, 0x2, 0x2, 0xc5, + 0xc3, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc6, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xca, + 0x3, 0x2, 0x2, 0x2, 0xc7, 0xc5, 0x3, 0x2, 0x2, 0x2, 0xc8, 0xc9, 0x7, + 0x11, 0x2, 0x2, 0xc9, 0xcb, 0x5, 0x16, 0xc, 0x2, 0xca, 0xc8, 0x3, + 0x2, 0x2, 0x2, 0xca, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xcb, 0x23, 0x3, 0x2, + 0x2, 0x2, 0xcc, 0xcd, 0x7, 0x12, 0x2, 0x2, 0xcd, 0xce, 0x5, 0x42, + 0x22, 0x2, 0xce, 0xcf, 0x5, 0x26, 0x14, 0x2, 0xcf, 0x25, 0x3, 0x2, + 0x2, 0x2, 0xd0, 0xd7, 0x7, 0xd, 0x2, 0x2, 0xd1, 0xd2, 0x7, 0x13, + 0x2, 0x2, 0xd2, 0xd3, 0x5, 0x30, 0x19, 0x2, 0xd3, 0xd4, 0x5, 0x16, + 0xc, 0x2, 0xd4, 0xd6, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd1, 0x3, 0x2, 0x2, + 0x2, 0xd6, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd5, 0x3, 0x2, 0x2, 0x2, + 0xd7, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd8, 0xda, 0x3, 0x2, 0x2, 0x2, 0xd9, + 0xd7, 0x3, 0x2, 0x2, 0x2, 0xda, 0xdb, 0x7, 0xe, 0x2, 0x2, 0xdb, 0x27, + 0x3, 0x2, 0x2, 0x2, 0xdc, 0xdf, 0x7, 0x14, 0x2, 0x2, 0xdd, 0xe0, + 0x5, 0xa, 0x6, 0x2, 0xde, 0xe0, 0x5, 0x2c, 0x17, 0x2, 0xdf, 0xdd, + 0x3, 0x2, 0x2, 0x2, 0xdf, 0xde, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xe1, 0x3, + 0x2, 0x2, 0x2, 0xe1, 0xe2, 0x7, 0xc, 0x2, 0x2, 0xe2, 0xe3, 0x5, 0x30, + 0x19, 0x2, 0xe3, 0xe4, 0x7, 0xc, 0x2, 0x2, 0xe4, 0xe5, 0x5, 0x30, + 0x19, 0x2, 0xe5, 0xe6, 0x5, 0x16, 0xc, 0x2, 0xe6, 0x29, 0x3, 0x2, + 0x2, 0x2, 0xe7, 0xe8, 0x7, 0x15, 0x2, 0x2, 0xe8, 0xe9, 0x5, 0x30, + 0x19, 0x2, 0xe9, 0xea, 0x5, 0x16, 0xc, 0x2, 0xea, 0x2b, 0x3, 0x2, + 0x2, 0x2, 0xeb, 0xec, 0x5, 0x42, 0x22, 0x2, 0xec, 0xed, 0x7, 0x5, + 0x2, 0x2, 0xed, 0xee, 0x5, 0x30, 0x19, 0x2, 0xee, 0x2d, 0x3, 0x2, + 0x2, 0x2, 0xef, 0xf0, 0x7, 0x16, 0x2, 0x2, 0xf0, 0xf1, 0x5, 0x30, + 0x19, 0x2, 0xf1, 0x2f, 0x3, 0x2, 0x2, 0x2, 0xf2, 0xf9, 0x5, 0x36, + 0x1c, 0x2, 0xf3, 0xf9, 0x5, 0x44, 0x23, 0x2, 0xf4, 0xf9, 0x5, 0x42, + 0x22, 0x2, 0xf5, 0xf9, 0x5, 0x48, 0x25, 0x2, 0xf6, 0xf9, 0x5, 0x46, + 0x24, 0x2, 0xf7, 0xf9, 0x5, 0x38, 0x1d, 0x2, 0xf8, 0xf2, 0x3, 0x2, + 0x2, 0x2, 0xf8, 0xf3, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xf4, 0x3, 0x2, 0x2, + 0x2, 0xf8, 0xf5, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xf6, 0x3, 0x2, 0x2, 0x2, + 0xf8, 0xf7, 0x3, 0x2, 0x2, 0x2, 0xf9, 0x31, 0x3, 0x2, 0x2, 0x2, 0xfa, + 0x100, 0x5, 0x36, 0x1c, 0x2, 0xfb, 0x100, 0x5, 0x44, 0x23, 0x2, 0xfc, + 0x100, 0x5, 0x42, 0x22, 0x2, 0xfd, 0x100, 0x5, 0x48, 0x25, 0x2, 0xfe, + 0x100, 0x5, 0x46, 0x24, 0x2, 0xff, 0xfa, 0x3, 0x2, 0x2, 0x2, 0xff, + 0xfb, 0x3, 0x2, 0x2, 0x2, 0xff, 0xfc, 0x3, 0x2, 0x2, 0x2, 0xff, 0xfd, + 0x3, 0x2, 0x2, 0x2, 0xff, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x100, 0x33, + 0x3, 0x2, 0x2, 0x2, 0x101, 0x105, 0x5, 0x36, 0x1c, 0x2, 0x102, 0x105, + 0x5, 0x42, 0x22, 0x2, 0x103, 0x105, 0x5, 0x48, 0x25, 0x2, 0x104, + 0x101, 0x3, 0x2, 0x2, 0x2, 0x104, 0x102, 0x3, 0x2, 0x2, 0x2, 0x104, + 0x103, 0x3, 0x2, 0x2, 0x2, 0x105, 0x35, 0x3, 0x2, 0x2, 0x2, 0x106, + 0x107, 0x5, 0x4a, 0x26, 0x2, 0x107, 0x110, 0x7, 0xa, 0x2, 0x2, 0x108, + 0x10d, 0x5, 0x30, 0x19, 0x2, 0x109, 0x10a, 0x7, 0xc, 0x2, 0x2, 0x10a, + 0x10c, 0x5, 0x30, 0x19, 0x2, 0x10b, 0x109, 0x3, 0x2, 0x2, 0x2, 0x10c, + 0x10f, 0x3, 0x2, 0x2, 0x2, 0x10d, 0x10b, 0x3, 0x2, 0x2, 0x2, 0x10d, + 0x10e, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x111, 0x3, 0x2, 0x2, 0x2, 0x10f, + 0x10d, 0x3, 0x2, 0x2, 0x2, 0x110, 0x108, 0x3, 0x2, 0x2, 0x2, 0x110, + 0x111, 0x3, 0x2, 0x2, 0x2, 0x111, 0x112, 0x3, 0x2, 0x2, 0x2, 0x112, + 0x113, 0x7, 0xb, 0x2, 0x2, 0x113, 0x37, 0x3, 0x2, 0x2, 0x2, 0x114, + 0x119, 0x5, 0x3a, 0x1e, 0x2, 0x115, 0x119, 0x5, 0x3c, 0x1f, 0x2, + 0x116, 0x119, 0x5, 0x3e, 0x20, 0x2, 0x117, 0x119, 0x5, 0x40, 0x21, + 0x2, 0x118, 0x114, 0x3, 0x2, 0x2, 0x2, 0x118, 0x115, 0x3, 0x2, 0x2, + 0x2, 0x118, 0x116, 0x3, 0x2, 0x2, 0x2, 0x118, 0x117, 0x3, 0x2, 0x2, + 0x2, 0x119, 0x39, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x11b, 0x5, 0x32, 0x1a, + 0x2, 0x11b, 0x11c, 0x7, 0x1c, 0x2, 0x2, 0x11c, 0x121, 0x5, 0x32, + 0x1a, 0x2, 0x11d, 0x11e, 0x7, 0x1c, 0x2, 0x2, 0x11e, 0x120, 0x5, + 0x32, 0x1a, 0x2, 0x11f, 0x11d, 0x3, 0x2, 0x2, 0x2, 0x120, 0x123, + 0x3, 0x2, 0x2, 0x2, 0x121, 0x11f, 0x3, 0x2, 0x2, 0x2, 0x121, 0x122, + 0x3, 0x2, 0x2, 0x2, 0x122, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x123, 0x121, + 0x3, 0x2, 0x2, 0x2, 0x124, 0x125, 0x7, 0x1b, 0x2, 0x2, 0x125, 0x126, + 0x5, 0x32, 0x1a, 0x2, 0x126, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x127, 0x128, + 0x5, 0x32, 0x1a, 0x2, 0x128, 0x129, 0x7, 0x1a, 0x2, 0x2, 0x129, 0x3f, + 0x3, 0x2, 0x2, 0x2, 0x12a, 0x12b, 0x5, 0x32, 0x1a, 0x2, 0x12b, 0x12c, + 0x7, 0x17, 0x2, 0x2, 0x12c, 0x12d, 0x5, 0x30, 0x19, 0x2, 0x12d, 0x12e, + 0x7, 0x4, 0x2, 0x2, 0x12e, 0x12f, 0x5, 0x30, 0x19, 0x2, 0x12f, 0x41, + 0x3, 0x2, 0x2, 0x2, 0x130, 0x131, 0x5, 0x4c, 0x27, 0x2, 0x131, 0x43, + 0x3, 0x2, 0x2, 0x2, 0x132, 0x133, 0x9, 0x2, 0x2, 0x2, 0x133, 0x45, + 0x3, 0x2, 0x2, 0x2, 0x134, 0x13b, 0x5, 0x34, 0x1b, 0x2, 0x135, 0x136, + 0x9, 0x3, 0x2, 0x2, 0x136, 0x13c, 0x5, 0x42, 0x22, 0x2, 0x137, 0x138, + 0x7, 0x7, 0x2, 0x2, 0x138, 0x139, 0x5, 0x30, 0x19, 0x2, 0x139, 0x13a, + 0x7, 0x8, 0x2, 0x2, 0x13a, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x135, + 0x3, 0x2, 0x2, 0x2, 0x13b, 0x137, 0x3, 0x2, 0x2, 0x2, 0x13c, 0x13d, + 0x3, 0x2, 0x2, 0x2, 0x13d, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x13d, 0x13e, + 0x3, 0x2, 0x2, 0x2, 0x13e, 0x47, 0x3, 0x2, 0x2, 0x2, 0x13f, 0x140, + 0x7, 0xa, 0x2, 0x2, 0x140, 0x141, 0x5, 0x30, 0x19, 0x2, 0x141, 0x142, + 0x7, 0xb, 0x2, 0x2, 0x142, 0x49, 0x3, 0x2, 0x2, 0x2, 0x143, 0x144, + 0x7, 0x21, 0x2, 0x2, 0x144, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x145, 0x146, + 0x7, 0x21, 0x2, 0x2, 0x146, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x147, 0x148, + 0x7, 0x21, 0x2, 0x2, 0x148, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x149, 0x14a, + 0x7, 0x21, 0x2, 0x2, 0x14a, 0x51, 0x3, 0x2, 0x2, 0x2, 0x1b, 0x55, + 0x5c, 0x67, 0x74, 0x7a, 0x7d, 0x90, 0x93, 0x99, 0xa4, 0xab, 0xb9, + 0xc5, 0xca, 0xd7, 0xdf, 0xf8, 0xff, 0x104, 0x10d, 0x110, 0x118, 0x121, + 0x13b, 0x13d, }; _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,