LCOV - code coverage report
Current view: top level - build directory/src/plugins/yanlr - YAMLImprovedSymbolNames.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 389 592 65.7 %
Date: 2019-09-12 12:28:41 Functions: 56 127 44.1 %

          Line data    Source code
       1             : 
       2             : // Generated from /home/jenkins/workspace/libelektra_PR-2949-JSVQFJNQUXFDDEIVMWX2NWLWVTIX5MLFKA62ACPFOA3QLNMROQ7Q/src/plugins/yanlr/YAML.g4 by ANTLR 4.7.2
       3             : 
       4             : 
       5             : #include "YAMLListener.h"
       6             : 
       7             : #include "YAML.h"
       8             : 
       9             : 
      10             : using namespace antlrcpp;
      11             : using namespace yanlr;
      12             : using namespace antlr4;
      13             : 
      14          31 : YAML::YAML(TokenStream *input) : Parser(input) {
      15          31 :   _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
      16          31 : }
      17             : 
      18          62 : YAML::~YAML() {
      19          31 :   delete _interpreter;
      20          31 : }
      21             : 
      22           0 : std::string YAML::getGrammarFileName() const {
      23           0 :   return "YAML.g4";
      24             : }
      25             : 
      26           0 : const std::vector<std::string>& YAML::getRuleNames() const {
      27           0 :   return _ruleNames;
      28             : }
      29             : 
      30           6 : dfa::Vocabulary& YAML::getVocabulary() const {
      31           6 :   return _vocabulary;
      32             : }
      33             : 
      34             : 
      35             : //----------------- YamlContext ------------------------------------------------------------------
      36             : 
      37          31 : YAML::YamlContext::YamlContext(ParserRuleContext *parent, size_t invokingState)
      38          31 :   : ParserRuleContext(parent, invokingState) {
      39          31 : }
      40             : 
      41           0 : tree::TerminalNode* YAML::YamlContext::STREAM_START() {
      42           0 :   return getToken(YAML::STREAM_START, 0);
      43             : }
      44             : 
      45           0 : tree::TerminalNode* YAML::YamlContext::STREAM_END() {
      46           0 :   return getToken(YAML::STREAM_END, 0);
      47             : }
      48             : 
      49           0 : tree::TerminalNode* YAML::YamlContext::EOF() {
      50           0 :   return getToken(YAML::EOF, 0);
      51             : }
      52             : 
      53           0 : YAML::ChildContext* YAML::YamlContext::child() {
      54           0 :   return getRuleContext<YAML::ChildContext>(0);
      55             : }
      56             : 
      57           0 : YAML::EmptyContext* YAML::YamlContext::empty() {
      58           0 :   return getRuleContext<YAML::EmptyContext>(0);
      59             : }
      60             : 
      61           0 : std::vector<YAML::CommentContext *> YAML::YamlContext::comment() {
      62           0 :   return getRuleContexts<YAML::CommentContext>();
      63             : }
      64             : 
      65           0 : YAML::CommentContext* YAML::YamlContext::comment(size_t i) {
      66           0 :   return getRuleContext<YAML::CommentContext>(i);
      67             : }
      68             : 
      69             : 
      70           0 : size_t YAML::YamlContext::getRuleIndex() const {
      71           0 :   return YAML::RuleYaml;
      72             : }
      73             : 
      74          28 : void YAML::YamlContext::enterRule(tree::ParseTreeListener *listener) {
      75          28 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
      76          28 :   if (parserListener != nullptr)
      77          28 :     parserListener->enterYaml(this);
      78          28 : }
      79             : 
      80          28 : void YAML::YamlContext::exitRule(tree::ParseTreeListener *listener) {
      81          28 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
      82          28 :   if (parserListener != nullptr)
      83          28 :     parserListener->exitYaml(this);
      84          28 : }
      85             : 
      86          31 : YAML::YamlContext* YAML::yaml() {
      87          31 :   YamlContext *_localctx = _tracker.createInstance<YamlContext>(_ctx, getState());
      88          31 :   enterRule(_localctx, 0, YAML::RuleYaml);
      89          31 :   size_t _la = 0;
      90             : 
      91             :   auto onExit = finally([=] {
      92          31 :     exitRule();
      93         124 :   });
      94             :   try {
      95          31 :     enterOuterAlt(_localctx, 1);
      96          31 :     setState(26);
      97          31 :     match(YAML::STREAM_START);
      98          31 :     setState(35);
      99          31 :     _errHandler->sync(this);
     100          62 :     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx)) {
     101             :     case 1: {
     102          31 :       setState(30);
     103          31 :       _errHandler->sync(this);
     104          31 :       _la = _input->LA(1);
     105          31 :       while (_la == YAML::COMMENT) {
     106           0 :         setState(27);
     107           0 :         comment();
     108           0 :         setState(32);
     109           0 :         _errHandler->sync(this);
     110           0 :         _la = _input->LA(1);
     111             :       }
     112          31 :       setState(33);
     113          31 :       child();
     114             :       break;
     115             :     }
     116             : 
     117             :     case 2: {
     118           0 :       setState(34);
     119           0 :       empty();
     120             :       break;
     121             :     }
     122             : 
     123             :     }
     124          31 :     setState(37);
     125          31 :     match(YAML::STREAM_END);
     126          31 :     setState(38);
     127          31 :     match(YAML::EOF);
     128             :    
     129             :   }
     130           0 :   catch (RecognitionException &e) {
     131           0 :     _errHandler->reportError(this, e);
     132           0 :     _localctx->exception = std::current_exception();
     133           0 :     _errHandler->recover(this, _localctx->exception);
     134             :   }
     135             : 
     136          31 :   return _localctx;
     137             : }
     138             : 
     139             : //----------------- ChildContext ------------------------------------------------------------------
     140             : 
     141         137 : YAML::ChildContext::ChildContext(ParserRuleContext *parent, size_t invokingState)
     142         137 :   : ParserRuleContext(parent, invokingState) {
     143         137 : }
     144             : 
     145           0 : YAML::ValueContext* YAML::ChildContext::value() {
     146           0 :   return getRuleContext<YAML::ValueContext>(0);
     147             : }
     148             : 
     149           0 : YAML::MapContext* YAML::ChildContext::map() {
     150           0 :   return getRuleContext<YAML::MapContext>(0);
     151             : }
     152             : 
     153           0 : YAML::SequenceContext* YAML::ChildContext::sequence() {
     154           0 :   return getRuleContext<YAML::SequenceContext>(0);
     155             : }
     156             : 
     157           0 : std::vector<YAML::CommentContext *> YAML::ChildContext::comment() {
     158           0 :   return getRuleContexts<YAML::CommentContext>();
     159             : }
     160             : 
     161           0 : YAML::CommentContext* YAML::ChildContext::comment(size_t i) {
     162           0 :   return getRuleContext<YAML::CommentContext>(i);
     163             : }
     164             : 
     165             : 
     166           0 : size_t YAML::ChildContext::getRuleIndex() const {
     167           0 :   return YAML::RuleChild;
     168             : }
     169             : 
     170         128 : void YAML::ChildContext::enterRule(tree::ParseTreeListener *listener) {
     171         128 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     172         128 :   if (parserListener != nullptr)
     173         128 :     parserListener->enterChild(this);
     174         128 : }
     175             : 
     176         128 : void YAML::ChildContext::exitRule(tree::ParseTreeListener *listener) {
     177         128 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     178         128 :   if (parserListener != nullptr)
     179         128 :     parserListener->exitChild(this);
     180         128 : }
     181             : 
     182         137 : YAML::ChildContext* YAML::child() {
     183         137 :   ChildContext *_localctx = _tracker.createInstance<ChildContext>(_ctx, getState());
     184         137 :   enterRule(_localctx, 2, YAML::RuleChild);
     185         137 :   size_t _la = 0;
     186             : 
     187             :   auto onExit = finally([=] {
     188         137 :     exitRule();
     189         548 :   });
     190             :   try {
     191         137 :     enterOuterAlt(_localctx, 1);
     192         137 :     setState(43);
     193         137 :     _errHandler->sync(this);
     194         137 :     switch (_input->LA(1)) {
     195             :       case YAML::PLAIN_SCALAR:
     196             :       case YAML::SINGLE_QUOTED_SCALAR:
     197             :       case YAML::DOUBLE_QUOTED_SCALAR: {
     198          82 :         setState(40);
     199          82 :         value();
     200             :         break;
     201             :       }
     202             : 
     203             :       case YAML::MAP_START: {
     204          42 :         setState(41);
     205          42 :         map();
     206             :         break;
     207             :       }
     208             : 
     209             :       case YAML::SEQUENCE_START: {
     210          13 :         setState(42);
     211          13 :         sequence();
     212             :         break;
     213             :       }
     214             : 
     215             :     default:
     216           0 :       throw NoViableAltException(this);
     217             :     }
     218         137 :     setState(48);
     219         137 :     _errHandler->sync(this);
     220         137 :     _la = _input->LA(1);
     221         142 :     while (_la == YAML::COMMENT) {
     222           5 :       setState(45);
     223           5 :       comment();
     224           5 :       setState(50);
     225           5 :       _errHandler->sync(this);
     226           5 :       _la = _input->LA(1);
     227             :     }
     228             :    
     229             :   }
     230           0 :   catch (RecognitionException &e) {
     231           0 :     _errHandler->reportError(this, e);
     232           0 :     _localctx->exception = std::current_exception();
     233           0 :     _errHandler->recover(this, _localctx->exception);
     234             :   }
     235             : 
     236         137 :   return _localctx;
     237             : }
     238             : 
     239             : //----------------- EmptyContext ------------------------------------------------------------------
     240             : 
     241           0 : YAML::EmptyContext::EmptyContext(ParserRuleContext *parent, size_t invokingState)
     242           0 :   : ParserRuleContext(parent, invokingState) {
     243           0 : }
     244             : 
     245           0 : std::vector<YAML::CommentContext *> YAML::EmptyContext::comment() {
     246           0 :   return getRuleContexts<YAML::CommentContext>();
     247             : }
     248             : 
     249           0 : YAML::CommentContext* YAML::EmptyContext::comment(size_t i) {
     250           0 :   return getRuleContext<YAML::CommentContext>(i);
     251             : }
     252             : 
     253             : 
     254           0 : size_t YAML::EmptyContext::getRuleIndex() const {
     255           0 :   return YAML::RuleEmpty;
     256             : }
     257             : 
     258           0 : void YAML::EmptyContext::enterRule(tree::ParseTreeListener *listener) {
     259           0 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     260           0 :   if (parserListener != nullptr)
     261           0 :     parserListener->enterEmpty(this);
     262           0 : }
     263             : 
     264           0 : void YAML::EmptyContext::exitRule(tree::ParseTreeListener *listener) {
     265           0 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     266           0 :   if (parserListener != nullptr)
     267           0 :     parserListener->exitEmpty(this);
     268           0 : }
     269             : 
     270           0 : YAML::EmptyContext* YAML::empty() {
     271           0 :   EmptyContext *_localctx = _tracker.createInstance<EmptyContext>(_ctx, getState());
     272           0 :   enterRule(_localctx, 4, YAML::RuleEmpty);
     273           0 :   size_t _la = 0;
     274             : 
     275             :   auto onExit = finally([=] {
     276           0 :     exitRule();
     277           0 :   });
     278             :   try {
     279           0 :     enterOuterAlt(_localctx, 1);
     280           0 :     setState(54);
     281           0 :     _errHandler->sync(this);
     282           0 :     _la = _input->LA(1);
     283           0 :     while (_la == YAML::COMMENT) {
     284           0 :       setState(51);
     285           0 :       comment();
     286           0 :       setState(56);
     287           0 :       _errHandler->sync(this);
     288           0 :       _la = _input->LA(1);
     289             :     }
     290             :    
     291             :   }
     292           0 :   catch (RecognitionException &e) {
     293           0 :     _errHandler->reportError(this, e);
     294           0 :     _localctx->exception = std::current_exception();
     295           0 :     _errHandler->recover(this, _localctx->exception);
     296             :   }
     297             : 
     298           0 :   return _localctx;
     299             : }
     300             : 
     301             : //----------------- ValueContext ------------------------------------------------------------------
     302             : 
     303          82 : YAML::ValueContext::ValueContext(ParserRuleContext *parent, size_t invokingState)
     304          82 :   : ParserRuleContext(parent, invokingState) {
     305          82 : }
     306             : 
     307           0 : YAML::ScalarContext* YAML::ValueContext::scalar() {
     308           0 :   return getRuleContext<YAML::ScalarContext>(0);
     309             : }
     310             : 
     311             : 
     312           0 : size_t YAML::ValueContext::getRuleIndex() const {
     313           0 :   return YAML::RuleValue;
     314             : }
     315             : 
     316          79 : void YAML::ValueContext::enterRule(tree::ParseTreeListener *listener) {
     317          79 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     318          79 :   if (parserListener != nullptr)
     319          79 :     parserListener->enterValue(this);
     320          79 : }
     321             : 
     322          79 : void YAML::ValueContext::exitRule(tree::ParseTreeListener *listener) {
     323          79 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     324          79 :   if (parserListener != nullptr)
     325          79 :     parserListener->exitValue(this);
     326          79 : }
     327             : 
     328          82 : YAML::ValueContext* YAML::value() {
     329          82 :   ValueContext *_localctx = _tracker.createInstance<ValueContext>(_ctx, getState());
     330          82 :   enterRule(_localctx, 6, YAML::RuleValue);
     331             : 
     332             :   auto onExit = finally([=] {
     333          82 :     exitRule();
     334         328 :   });
     335             :   try {
     336          82 :     enterOuterAlt(_localctx, 1);
     337          82 :     setState(57);
     338          82 :     scalar();
     339             :    
     340             :   }
     341           0 :   catch (RecognitionException &e) {
     342           0 :     _errHandler->reportError(this, e);
     343           0 :     _localctx->exception = std::current_exception();
     344           0 :     _errHandler->recover(this, _localctx->exception);
     345             :   }
     346             : 
     347          82 :   return _localctx;
     348             : }
     349             : 
     350             : //----------------- ScalarContext ------------------------------------------------------------------
     351             : 
     352         163 : YAML::ScalarContext::ScalarContext(ParserRuleContext *parent, size_t invokingState)
     353         163 :   : ParserRuleContext(parent, invokingState) {
     354         163 : }
     355             : 
     356           0 : tree::TerminalNode* YAML::ScalarContext::PLAIN_SCALAR() {
     357           0 :   return getToken(YAML::PLAIN_SCALAR, 0);
     358             : }
     359             : 
     360           0 : tree::TerminalNode* YAML::ScalarContext::SINGLE_QUOTED_SCALAR() {
     361           0 :   return getToken(YAML::SINGLE_QUOTED_SCALAR, 0);
     362             : }
     363             : 
     364           0 : tree::TerminalNode* YAML::ScalarContext::DOUBLE_QUOTED_SCALAR() {
     365           0 :   return getToken(YAML::DOUBLE_QUOTED_SCALAR, 0);
     366             : }
     367             : 
     368             : 
     369           0 : size_t YAML::ScalarContext::getRuleIndex() const {
     370           0 :   return YAML::RuleScalar;
     371             : }
     372             : 
     373         157 : void YAML::ScalarContext::enterRule(tree::ParseTreeListener *listener) {
     374         157 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     375         157 :   if (parserListener != nullptr)
     376         157 :     parserListener->enterScalar(this);
     377         157 : }
     378             : 
     379         157 : void YAML::ScalarContext::exitRule(tree::ParseTreeListener *listener) {
     380         157 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     381         157 :   if (parserListener != nullptr)
     382         157 :     parserListener->exitScalar(this);
     383         157 : }
     384             : 
     385         163 : YAML::ScalarContext* YAML::scalar() {
     386         163 :   ScalarContext *_localctx = _tracker.createInstance<ScalarContext>(_ctx, getState());
     387         163 :   enterRule(_localctx, 8, YAML::RuleScalar);
     388         163 :   size_t _la = 0;
     389             : 
     390             :   auto onExit = finally([=] {
     391         163 :     exitRule();
     392         652 :   });
     393             :   try {
     394         163 :     enterOuterAlt(_localctx, 1);
     395         163 :     setState(59);
     396         163 :     _la = _input->LA(1);
     397         326 :     if (!((((_la & ~ 0x3fULL) == 0) &&
     398             :       ((1ULL << _la) & ((1ULL << YAML::PLAIN_SCALAR)
     399             :       | (1ULL << YAML::SINGLE_QUOTED_SCALAR)
     400         163 :       | (1ULL << YAML::DOUBLE_QUOTED_SCALAR))) != 0))) {
     401           0 :     _errHandler->recoverInline(this);
     402             :     }
     403             :     else {
     404         163 :       _errHandler->reportMatch(this);
     405         163 :       consume();
     406             :     }
     407             :    
     408             :   }
     409           0 :   catch (RecognitionException &e) {
     410           0 :     _errHandler->reportError(this, e);
     411           0 :     _localctx->exception = std::current_exception();
     412           0 :     _errHandler->recover(this, _localctx->exception);
     413             :   }
     414             : 
     415         163 :   return _localctx;
     416             : }
     417             : 
     418             : //----------------- MapContext ------------------------------------------------------------------
     419             : 
     420          42 : YAML::MapContext::MapContext(ParserRuleContext *parent, size_t invokingState)
     421          42 :   : ParserRuleContext(parent, invokingState) {
     422          42 : }
     423             : 
     424           0 : tree::TerminalNode* YAML::MapContext::MAP_START() {
     425           0 :   return getToken(YAML::MAP_START, 0);
     426             : }
     427             : 
     428           0 : YAML::PairsContext* YAML::MapContext::pairs() {
     429           0 :   return getRuleContext<YAML::PairsContext>(0);
     430             : }
     431             : 
     432           0 : tree::TerminalNode* YAML::MapContext::MAP_END() {
     433           0 :   return getToken(YAML::MAP_END, 0);
     434             : }
     435             : 
     436             : 
     437           0 : size_t YAML::MapContext::getRuleIndex() const {
     438           0 :   return YAML::RuleMap;
     439             : }
     440             : 
     441          39 : void YAML::MapContext::enterRule(tree::ParseTreeListener *listener) {
     442          39 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     443          39 :   if (parserListener != nullptr)
     444          39 :     parserListener->enterMap(this);
     445          39 : }
     446             : 
     447          39 : void YAML::MapContext::exitRule(tree::ParseTreeListener *listener) {
     448          39 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     449          39 :   if (parserListener != nullptr)
     450          39 :     parserListener->exitMap(this);
     451          39 : }
     452             : 
     453          42 : YAML::MapContext* YAML::map() {
     454          42 :   MapContext *_localctx = _tracker.createInstance<MapContext>(_ctx, getState());
     455          42 :   enterRule(_localctx, 10, YAML::RuleMap);
     456             : 
     457             :   auto onExit = finally([=] {
     458          42 :     exitRule();
     459         168 :   });
     460             :   try {
     461          42 :     enterOuterAlt(_localctx, 1);
     462          42 :     setState(61);
     463          42 :     match(YAML::MAP_START);
     464          42 :     setState(62);
     465          42 :     pairs();
     466          42 :     setState(63);
     467          42 :     match(YAML::MAP_END);
     468             :    
     469             :   }
     470           6 :   catch (RecognitionException &e) {
     471           3 :     _errHandler->reportError(this, e);
     472           6 :     _localctx->exception = std::current_exception();
     473           3 :     _errHandler->recover(this, _localctx->exception);
     474             :   }
     475             : 
     476          42 :   return _localctx;
     477             : }
     478             : 
     479             : //----------------- PairsContext ------------------------------------------------------------------
     480             : 
     481          42 : YAML::PairsContext::PairsContext(ParserRuleContext *parent, size_t invokingState)
     482          42 :   : ParserRuleContext(parent, invokingState) {
     483          42 : }
     484             : 
     485           0 : std::vector<YAML::PairContext *> YAML::PairsContext::pair() {
     486           0 :   return getRuleContexts<YAML::PairContext>();
     487             : }
     488             : 
     489           0 : YAML::PairContext* YAML::PairsContext::pair(size_t i) {
     490           0 :   return getRuleContext<YAML::PairContext>(i);
     491             : }
     492             : 
     493             : 
     494           0 : size_t YAML::PairsContext::getRuleIndex() const {
     495           0 :   return YAML::RulePairs;
     496             : }
     497             : 
     498          39 : void YAML::PairsContext::enterRule(tree::ParseTreeListener *listener) {
     499          39 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     500          39 :   if (parserListener != nullptr)
     501          39 :     parserListener->enterPairs(this);
     502          39 : }
     503             : 
     504          39 : void YAML::PairsContext::exitRule(tree::ParseTreeListener *listener) {
     505          39 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     506          39 :   if (parserListener != nullptr)
     507          39 :     parserListener->exitPairs(this);
     508          39 : }
     509             : 
     510          42 : YAML::PairsContext* YAML::pairs() {
     511          42 :   PairsContext *_localctx = _tracker.createInstance<PairsContext>(_ctx, getState());
     512          42 :   enterRule(_localctx, 12, YAML::RulePairs);
     513          42 :   size_t _la = 0;
     514             : 
     515             :   auto onExit = finally([=] {
     516          42 :     exitRule();
     517         168 :   });
     518             :   try {
     519          42 :     enterOuterAlt(_localctx, 1);
     520          42 :     setState(66); 
     521          42 :     _errHandler->sync(this);
     522          42 :     _la = _input->LA(1);
     523             :     do {
     524          81 :       setState(65);
     525          81 :       pair();
     526          81 :       setState(68); 
     527          81 :       _errHandler->sync(this);
     528          81 :       _la = _input->LA(1);
     529          81 :     } while (_la == YAML::KEY);
     530             :    
     531             :   }
     532           0 :   catch (RecognitionException &e) {
     533           0 :     _errHandler->reportError(this, e);
     534           0 :     _localctx->exception = std::current_exception();
     535           0 :     _errHandler->recover(this, _localctx->exception);
     536             :   }
     537             : 
     538          42 :   return _localctx;
     539             : }
     540             : 
     541             : //----------------- PairContext ------------------------------------------------------------------
     542             : 
     543          81 : YAML::PairContext::PairContext(ParserRuleContext *parent, size_t invokingState)
     544          81 :   : ParserRuleContext(parent, invokingState) {
     545          81 : }
     546             : 
     547           0 : tree::TerminalNode* YAML::PairContext::KEY() {
     548           0 :   return getToken(YAML::KEY, 0);
     549             : }
     550             : 
     551          78 : YAML::KeyContext* YAML::PairContext::key() {
     552          78 :   return getRuleContext<YAML::KeyContext>(0);
     553             : }
     554             : 
     555           0 : tree::TerminalNode* YAML::PairContext::VALUE() {
     556           0 :   return getToken(YAML::VALUE, 0);
     557             : }
     558             : 
     559           0 : std::vector<YAML::CommentContext *> YAML::PairContext::comment() {
     560           0 :   return getRuleContexts<YAML::CommentContext>();
     561             : }
     562             : 
     563           0 : YAML::CommentContext* YAML::PairContext::comment(size_t i) {
     564           0 :   return getRuleContext<YAML::CommentContext>(i);
     565             : }
     566             : 
     567          78 : YAML::ChildContext* YAML::PairContext::child() {
     568          78 :   return getRuleContext<YAML::ChildContext>(0);
     569             : }
     570             : 
     571             : 
     572           0 : size_t YAML::PairContext::getRuleIndex() const {
     573           0 :   return YAML::RulePair;
     574             : }
     575             : 
     576          78 : void YAML::PairContext::enterRule(tree::ParseTreeListener *listener) {
     577          78 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     578          78 :   if (parserListener != nullptr)
     579          78 :     parserListener->enterPair(this);
     580          78 : }
     581             : 
     582          78 : void YAML::PairContext::exitRule(tree::ParseTreeListener *listener) {
     583          78 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     584          78 :   if (parserListener != nullptr)
     585          78 :     parserListener->exitPair(this);
     586          78 : }
     587             : 
     588          81 : YAML::PairContext* YAML::pair() {
     589          81 :   PairContext *_localctx = _tracker.createInstance<PairContext>(_ctx, getState());
     590          81 :   enterRule(_localctx, 14, YAML::RulePair);
     591          81 :   size_t _la = 0;
     592             : 
     593             :   auto onExit = finally([=] {
     594          81 :     exitRule();
     595         324 :   });
     596             :   try {
     597          81 :     enterOuterAlt(_localctx, 1);
     598          81 :     setState(70);
     599          81 :     match(YAML::KEY);
     600          81 :     setState(71);
     601          81 :     key();
     602          81 :     setState(72);
     603          81 :     match(YAML::VALUE);
     604          81 :     setState(76);
     605          81 :     _errHandler->sync(this);
     606          81 :     _la = _input->LA(1);
     607          81 :     while (_la == YAML::COMMENT) {
     608           0 :       setState(73);
     609           0 :       comment();
     610           0 :       setState(78);
     611           0 :       _errHandler->sync(this);
     612           0 :       _la = _input->LA(1);
     613             :     }
     614          81 :     setState(80);
     615          81 :     _errHandler->sync(this);
     616             : 
     617          81 :     _la = _input->LA(1);
     618         162 :     if ((((_la & ~ 0x3fULL) == 0) &&
     619             :       ((1ULL << _la) & ((1ULL << YAML::PLAIN_SCALAR)
     620             :       | (1ULL << YAML::SINGLE_QUOTED_SCALAR)
     621             :       | (1ULL << YAML::DOUBLE_QUOTED_SCALAR)
     622             :       | (1ULL << YAML::MAP_START)
     623          81 :       | (1ULL << YAML::SEQUENCE_START))) != 0)) {
     624          78 :       setState(79);
     625          78 :       child();
     626             :     }
     627             :    
     628             :   }
     629           0 :   catch (RecognitionException &e) {
     630           0 :     _errHandler->reportError(this, e);
     631           0 :     _localctx->exception = std::current_exception();
     632           0 :     _errHandler->recover(this, _localctx->exception);
     633             :   }
     634             : 
     635          81 :   return _localctx;
     636             : }
     637             : 
     638             : //----------------- KeyContext ------------------------------------------------------------------
     639             : 
     640          81 : YAML::KeyContext::KeyContext(ParserRuleContext *parent, size_t invokingState)
     641          81 :   : ParserRuleContext(parent, invokingState) {
     642          81 : }
     643             : 
     644           0 : YAML::ScalarContext* YAML::KeyContext::scalar() {
     645           0 :   return getRuleContext<YAML::ScalarContext>(0);
     646             : }
     647             : 
     648             : 
     649           0 : size_t YAML::KeyContext::getRuleIndex() const {
     650           0 :   return YAML::RuleKey;
     651             : }
     652             : 
     653          78 : void YAML::KeyContext::enterRule(tree::ParseTreeListener *listener) {
     654          78 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     655          78 :   if (parserListener != nullptr)
     656          78 :     parserListener->enterKey(this);
     657          78 : }
     658             : 
     659          78 : void YAML::KeyContext::exitRule(tree::ParseTreeListener *listener) {
     660          78 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     661          78 :   if (parserListener != nullptr)
     662          78 :     parserListener->exitKey(this);
     663          78 : }
     664             : 
     665          81 : YAML::KeyContext* YAML::key() {
     666          81 :   KeyContext *_localctx = _tracker.createInstance<KeyContext>(_ctx, getState());
     667          81 :   enterRule(_localctx, 16, YAML::RuleKey);
     668             : 
     669             :   auto onExit = finally([=] {
     670          81 :     exitRule();
     671         324 :   });
     672             :   try {
     673          81 :     enterOuterAlt(_localctx, 1);
     674          81 :     setState(82);
     675          81 :     scalar();
     676             :    
     677             :   }
     678           0 :   catch (RecognitionException &e) {
     679           0 :     _errHandler->reportError(this, e);
     680           0 :     _localctx->exception = std::current_exception();
     681           0 :     _errHandler->recover(this, _localctx->exception);
     682             :   }
     683             : 
     684          81 :   return _localctx;
     685             : }
     686             : 
     687             : //----------------- SequenceContext ------------------------------------------------------------------
     688             : 
     689          13 : YAML::SequenceContext::SequenceContext(ParserRuleContext *parent, size_t invokingState)
     690          13 :   : ParserRuleContext(parent, invokingState) {
     691          13 : }
     692             : 
     693           0 : tree::TerminalNode* YAML::SequenceContext::SEQUENCE_START() {
     694           0 :   return getToken(YAML::SEQUENCE_START, 0);
     695             : }
     696             : 
     697           0 : YAML::ElementsContext* YAML::SequenceContext::elements() {
     698           0 :   return getRuleContext<YAML::ElementsContext>(0);
     699             : }
     700             : 
     701           0 : tree::TerminalNode* YAML::SequenceContext::SEQUENCE_END() {
     702           0 :   return getToken(YAML::SEQUENCE_END, 0);
     703             : }
     704             : 
     705             : 
     706           0 : size_t YAML::SequenceContext::getRuleIndex() const {
     707           0 :   return YAML::RuleSequence;
     708             : }
     709             : 
     710          10 : void YAML::SequenceContext::enterRule(tree::ParseTreeListener *listener) {
     711          10 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     712          10 :   if (parserListener != nullptr)
     713          10 :     parserListener->enterSequence(this);
     714          10 : }
     715             : 
     716          10 : void YAML::SequenceContext::exitRule(tree::ParseTreeListener *listener) {
     717          10 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     718          10 :   if (parserListener != nullptr)
     719          10 :     parserListener->exitSequence(this);
     720          10 : }
     721             : 
     722          13 : YAML::SequenceContext* YAML::sequence() {
     723          13 :   SequenceContext *_localctx = _tracker.createInstance<SequenceContext>(_ctx, getState());
     724          13 :   enterRule(_localctx, 18, YAML::RuleSequence);
     725             : 
     726             :   auto onExit = finally([=] {
     727          13 :     exitRule();
     728          52 :   });
     729             :   try {
     730          13 :     enterOuterAlt(_localctx, 1);
     731          13 :     setState(84);
     732          13 :     match(YAML::SEQUENCE_START);
     733          13 :     setState(85);
     734          13 :     elements();
     735          13 :     setState(86);
     736          13 :     match(YAML::SEQUENCE_END);
     737             :    
     738             :   }
     739           0 :   catch (RecognitionException &e) {
     740           0 :     _errHandler->reportError(this, e);
     741           0 :     _localctx->exception = std::current_exception();
     742           0 :     _errHandler->recover(this, _localctx->exception);
     743             :   }
     744             : 
     745          13 :   return _localctx;
     746             : }
     747             : 
     748             : //----------------- ElementsContext ------------------------------------------------------------------
     749             : 
     750          13 : YAML::ElementsContext::ElementsContext(ParserRuleContext *parent, size_t invokingState)
     751          13 :   : ParserRuleContext(parent, invokingState) {
     752          13 : }
     753             : 
     754           0 : std::vector<YAML::ElementContext *> YAML::ElementsContext::element() {
     755           0 :   return getRuleContexts<YAML::ElementContext>();
     756             : }
     757             : 
     758           0 : YAML::ElementContext* YAML::ElementsContext::element(size_t i) {
     759           0 :   return getRuleContext<YAML::ElementContext>(i);
     760             : }
     761             : 
     762             : 
     763           0 : size_t YAML::ElementsContext::getRuleIndex() const {
     764           0 :   return YAML::RuleElements;
     765             : }
     766             : 
     767          10 : void YAML::ElementsContext::enterRule(tree::ParseTreeListener *listener) {
     768          10 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     769          10 :   if (parserListener != nullptr)
     770          10 :     parserListener->enterElements(this);
     771          10 : }
     772             : 
     773          10 : void YAML::ElementsContext::exitRule(tree::ParseTreeListener *listener) {
     774          10 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     775          10 :   if (parserListener != nullptr)
     776          10 :     parserListener->exitElements(this);
     777          10 : }
     778             : 
     779          13 : YAML::ElementsContext* YAML::elements() {
     780          13 :   ElementsContext *_localctx = _tracker.createInstance<ElementsContext>(_ctx, getState());
     781          13 :   enterRule(_localctx, 20, YAML::RuleElements);
     782          13 :   size_t _la = 0;
     783             : 
     784             :   auto onExit = finally([=] {
     785          13 :     exitRule();
     786          52 :   });
     787             :   try {
     788          13 :     enterOuterAlt(_localctx, 1);
     789          13 :     setState(89); 
     790          13 :     _errHandler->sync(this);
     791          13 :     _la = _input->LA(1);
     792             :     do {
     793          28 :       setState(88);
     794          28 :       element();
     795          28 :       setState(91); 
     796          28 :       _errHandler->sync(this);
     797          28 :       _la = _input->LA(1);
     798          28 :     } while (_la == YAML::ELEMENT);
     799             :    
     800             :   }
     801           0 :   catch (RecognitionException &e) {
     802           0 :     _errHandler->reportError(this, e);
     803           0 :     _localctx->exception = std::current_exception();
     804           0 :     _errHandler->recover(this, _localctx->exception);
     805             :   }
     806             : 
     807          13 :   return _localctx;
     808             : }
     809             : 
     810             : //----------------- ElementContext ------------------------------------------------------------------
     811             : 
     812          28 : YAML::ElementContext::ElementContext(ParserRuleContext *parent, size_t invokingState)
     813          28 :   : ParserRuleContext(parent, invokingState) {
     814          28 : }
     815             : 
     816           0 : tree::TerminalNode* YAML::ElementContext::ELEMENT() {
     817           0 :   return getToken(YAML::ELEMENT, 0);
     818             : }
     819             : 
     820           0 : YAML::ChildContext* YAML::ElementContext::child() {
     821           0 :   return getRuleContext<YAML::ChildContext>(0);
     822             : }
     823             : 
     824           0 : std::vector<YAML::CommentContext *> YAML::ElementContext::comment() {
     825           0 :   return getRuleContexts<YAML::CommentContext>();
     826             : }
     827             : 
     828           0 : YAML::CommentContext* YAML::ElementContext::comment(size_t i) {
     829           0 :   return getRuleContext<YAML::CommentContext>(i);
     830             : }
     831             : 
     832             : 
     833           0 : size_t YAML::ElementContext::getRuleIndex() const {
     834           0 :   return YAML::RuleElement;
     835             : }
     836             : 
     837          25 : void YAML::ElementContext::enterRule(tree::ParseTreeListener *listener) {
     838          25 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     839          25 :   if (parserListener != nullptr)
     840          25 :     parserListener->enterElement(this);
     841          25 : }
     842             : 
     843          25 : void YAML::ElementContext::exitRule(tree::ParseTreeListener *listener) {
     844          25 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     845          25 :   if (parserListener != nullptr)
     846          25 :     parserListener->exitElement(this);
     847          25 : }
     848             : 
     849          28 : YAML::ElementContext* YAML::element() {
     850          28 :   ElementContext *_localctx = _tracker.createInstance<ElementContext>(_ctx, getState());
     851          28 :   enterRule(_localctx, 22, YAML::RuleElement);
     852          28 :   size_t _la = 0;
     853             : 
     854             :   auto onExit = finally([=] {
     855          28 :     exitRule();
     856         112 :   });
     857             :   try {
     858          28 :     enterOuterAlt(_localctx, 1);
     859          28 :     setState(93);
     860          28 :     match(YAML::ELEMENT);
     861          28 :     setState(97);
     862          28 :     _errHandler->sync(this);
     863          28 :     _la = _input->LA(1);
     864          28 :     while (_la == YAML::COMMENT) {
     865           0 :       setState(94);
     866           0 :       comment();
     867           0 :       setState(99);
     868           0 :       _errHandler->sync(this);
     869           0 :       _la = _input->LA(1);
     870             :     }
     871          28 :     setState(100);
     872          28 :     child();
     873             :    
     874             :   }
     875           0 :   catch (RecognitionException &e) {
     876           0 :     _errHandler->reportError(this, e);
     877           0 :     _localctx->exception = std::current_exception();
     878           0 :     _errHandler->recover(this, _localctx->exception);
     879             :   }
     880             : 
     881          28 :   return _localctx;
     882             : }
     883             : 
     884             : //----------------- CommentContext ------------------------------------------------------------------
     885             : 
     886           5 : YAML::CommentContext::CommentContext(ParserRuleContext *parent, size_t invokingState)
     887           5 :   : ParserRuleContext(parent, invokingState) {
     888           5 : }
     889             : 
     890           0 : tree::TerminalNode* YAML::CommentContext::COMMENT() {
     891           0 :   return getToken(YAML::COMMENT, 0);
     892             : }
     893             : 
     894             : 
     895           0 : size_t YAML::CommentContext::getRuleIndex() const {
     896           0 :   return YAML::RuleComment;
     897             : }
     898             : 
     899           2 : void YAML::CommentContext::enterRule(tree::ParseTreeListener *listener) {
     900           2 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     901           2 :   if (parserListener != nullptr)
     902           2 :     parserListener->enterComment(this);
     903           2 : }
     904             : 
     905           2 : void YAML::CommentContext::exitRule(tree::ParseTreeListener *listener) {
     906           2 :   auto parserListener = dynamic_cast<YAMLListener *>(listener);
     907           2 :   if (parserListener != nullptr)
     908           2 :     parserListener->exitComment(this);
     909           2 : }
     910             : 
     911           5 : YAML::CommentContext* YAML::comment() {
     912           5 :   CommentContext *_localctx = _tracker.createInstance<CommentContext>(_ctx, getState());
     913           5 :   enterRule(_localctx, 24, YAML::RuleComment);
     914             : 
     915             :   auto onExit = finally([=] {
     916           5 :     exitRule();
     917          20 :   });
     918             :   try {
     919           5 :     enterOuterAlt(_localctx, 1);
     920           5 :     setState(102);
     921           5 :     match(YAML::COMMENT);
     922             :    
     923             :   }
     924           0 :   catch (RecognitionException &e) {
     925           0 :     _errHandler->reportError(this, e);
     926           0 :     _localctx->exception = std::current_exception();
     927           0 :     _errHandler->recover(this, _localctx->exception);
     928             :   }
     929             : 
     930           5 :   return _localctx;
     931             : }
     932             : 
     933             : // Static vars and initialization.
     934          70 : std::vector<dfa::DFA> YAML::_decisionToDFA;
     935          70 : atn::PredictionContextCache YAML::_sharedContextCache;
     936             : 
     937             : // We own the ATN which in turn owns the ATN states.
     938          70 : atn::ATN YAML::_atn;
     939          70 : std::vector<uint16_t> YAML::_serializedATN;
     940             : 
     941        2100 : std::vector<std::string> YAML::_ruleNames = {
     942             :   "yaml", "child", "empty", "value", "scalar", "map", "pairs", "pair", "key", 
     943             :   "sequence", "elements", "element", "comment"
     944             : };
     945             : 
     946          70 : std::vector<std::string> YAML::_literalNames = {
     947             : };
     948             : 
     949        2240 : std::vector<std::string> YAML::_symbolicNames = {
     950             :   "", "start of document", "end of document", "comment", "plain scalar", "single quoted scalar", 
     951             :   "double quoted scalar", "start of map", "end of map", "key", "value", "start of sequence", 
     952             :   "end of sequence", "element"
     953             : };
     954             : 
     955          70 : dfa::Vocabulary YAML::_vocabulary(_literalNames, _symbolicNames);
     956             : 
     957          70 : std::vector<std::string> YAML::_tokenNames;
     958             : 
     959          70 : YAML::Initializer::Initializer() {
     960        2100 :         for (size_t i = 0; i < _symbolicNames.size(); ++i) {
     961        1960 :                 std::string name = _vocabulary.getLiteralName(i);
     962         980 :                 if (name.empty()) {
     963        1960 :                         name = _vocabulary.getSymbolicName(i);
     964             :                 }
     965             : 
     966         980 :                 if (name.empty()) {
     967         350 :                         _tokenNames.push_back("<INVALID>");
     968             :                 } else {
     969         910 :       _tokenNames.push_back(name);
     970             :     }
     971             :         }
     972             : 
     973             :   _serializedATN = {
     974             :     0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, 
     975             :     0x3, 0xf, 0x6b, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 0x9, 
     976             :     0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, 0x4, 
     977             :     0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, 0x9, 
     978             :     0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe, 0x3, 
     979             :     0x2, 0x3, 0x2, 0x7, 0x2, 0x1f, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2, 0x22, 0xb, 
     980             :     0x2, 0x3, 0x2, 0x3, 0x2, 0x5, 0x2, 0x26, 0xa, 0x2, 0x3, 0x2, 0x3, 0x2, 
     981             :     0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 0x2e, 0xa, 0x3, 0x3, 
     982             :     0x3, 0x7, 0x3, 0x31, 0xa, 0x3, 0xc, 0x3, 0xe, 0x3, 0x34, 0xb, 0x3, 0x3, 
     983             :     0x4, 0x7, 0x4, 0x37, 0xa, 0x4, 0xc, 0x4, 0xe, 0x4, 0x3a, 0xb, 0x4, 0x3, 
     984             :     0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 
     985             :     0x7, 0x3, 0x8, 0x6, 0x8, 0x45, 0xa, 0x8, 0xd, 0x8, 0xe, 0x8, 0x46, 0x3, 
     986             :     0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x4d, 0xa, 0x9, 0xc, 0x9, 
     987             :     0xe, 0x9, 0x50, 0xb, 0x9, 0x3, 0x9, 0x5, 0x9, 0x53, 0xa, 0x9, 0x3, 0xa, 
     988             :     0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc, 0x6, 0xc, 
     989             :     0x5c, 0xa, 0xc, 0xd, 0xc, 0xe, 0xc, 0x5d, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 
     990             :     0x62, 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0x65, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 
     991             :     0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x2, 0x2, 0xf, 0x2, 0x4, 0x6, 0x8, 0xa, 
     992             :     0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x2, 0x3, 0x3, 0x2, 0x6, 
     993             :     0x8, 0x2, 0x68, 0x2, 0x1c, 0x3, 0x2, 0x2, 0x2, 0x4, 0x2d, 0x3, 0x2, 
     994             :     0x2, 0x2, 0x6, 0x38, 0x3, 0x2, 0x2, 0x2, 0x8, 0x3b, 0x3, 0x2, 0x2, 0x2, 
     995             :     0xa, 0x3d, 0x3, 0x2, 0x2, 0x2, 0xc, 0x3f, 0x3, 0x2, 0x2, 0x2, 0xe, 0x44, 
     996             :     0x3, 0x2, 0x2, 0x2, 0x10, 0x48, 0x3, 0x2, 0x2, 0x2, 0x12, 0x54, 0x3, 
     997             :     0x2, 0x2, 0x2, 0x14, 0x56, 0x3, 0x2, 0x2, 0x2, 0x16, 0x5b, 0x3, 0x2, 
     998             :     0x2, 0x2, 0x18, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x68, 0x3, 0x2, 0x2, 
     999             :     0x2, 0x1c, 0x25, 0x7, 0x3, 0x2, 0x2, 0x1d, 0x1f, 0x5, 0x1a, 0xe, 0x2, 
    1000             :     0x1e, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x22, 0x3, 0x2, 0x2, 0x2, 0x20, 
    1001             :     0x1e, 0x3, 0x2, 0x2, 0x2, 0x20, 0x21, 0x3, 0x2, 0x2, 0x2, 0x21, 0x23, 
    1002             :     0x3, 0x2, 0x2, 0x2, 0x22, 0x20, 0x3, 0x2, 0x2, 0x2, 0x23, 0x26, 0x5, 
    1003             :     0x4, 0x3, 0x2, 0x24, 0x26, 0x5, 0x6, 0x4, 0x2, 0x25, 0x20, 0x3, 0x2, 
    1004             :     0x2, 0x2, 0x25, 0x24, 0x3, 0x2, 0x2, 0x2, 0x26, 0x27, 0x3, 0x2, 0x2, 
    1005             :     0x2, 0x27, 0x28, 0x7, 0x4, 0x2, 0x2, 0x28, 0x29, 0x7, 0x2, 0x2, 0x3, 
    1006             :     0x29, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2a, 0x2e, 0x5, 0x8, 0x5, 0x2, 0x2b, 
    1007             :     0x2e, 0x5, 0xc, 0x7, 0x2, 0x2c, 0x2e, 0x5, 0x14, 0xb, 0x2, 0x2d, 0x2a, 
    1008             :     0x3, 0x2, 0x2, 0x2, 0x2d, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x2d, 0x2c, 0x3, 
    1009             :     0x2, 0x2, 0x2, 0x2e, 0x32, 0x3, 0x2, 0x2, 0x2, 0x2f, 0x31, 0x5, 0x1a, 
    1010             :     0xe, 0x2, 0x30, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x31, 0x34, 0x3, 0x2, 0x2, 
    1011             :     0x2, 0x32, 0x30, 0x3, 0x2, 0x2, 0x2, 0x32, 0x33, 0x3, 0x2, 0x2, 0x2, 
    1012             :     0x33, 0x5, 0x3, 0x2, 0x2, 0x2, 0x34, 0x32, 0x3, 0x2, 0x2, 0x2, 0x35, 
    1013             :     0x37, 0x5, 0x1a, 0xe, 0x2, 0x36, 0x35, 0x3, 0x2, 0x2, 0x2, 0x37, 0x3a, 
    1014             :     0x3, 0x2, 0x2, 0x2, 0x38, 0x36, 0x3, 0x2, 0x2, 0x2, 0x38, 0x39, 0x3, 
    1015             :     0x2, 0x2, 0x2, 0x39, 0x7, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x38, 0x3, 0x2, 
    1016             :     0x2, 0x2, 0x3b, 0x3c, 0x5, 0xa, 0x6, 0x2, 0x3c, 0x9, 0x3, 0x2, 0x2, 
    1017             :     0x2, 0x3d, 0x3e, 0x9, 0x2, 0x2, 0x2, 0x3e, 0xb, 0x3, 0x2, 0x2, 0x2, 
    1018             :     0x3f, 0x40, 0x7, 0x9, 0x2, 0x2, 0x40, 0x41, 0x5, 0xe, 0x8, 0x2, 0x41, 
    1019             :     0x42, 0x7, 0xa, 0x2, 0x2, 0x42, 0xd, 0x3, 0x2, 0x2, 0x2, 0x43, 0x45, 
    1020             :     0x5, 0x10, 0x9, 0x2, 0x44, 0x43, 0x3, 0x2, 0x2, 0x2, 0x45, 0x46, 0x3, 
    1021             :     0x2, 0x2, 0x2, 0x46, 0x44, 0x3, 0x2, 0x2, 0x2, 0x46, 0x47, 0x3, 0x2, 
    1022             :     0x2, 0x2, 0x47, 0xf, 0x3, 0x2, 0x2, 0x2, 0x48, 0x49, 0x7, 0xb, 0x2, 
    1023             :     0x2, 0x49, 0x4a, 0x5, 0x12, 0xa, 0x2, 0x4a, 0x4e, 0x7, 0xc, 0x2, 0x2, 
    1024             :     0x4b, 0x4d, 0x5, 0x1a, 0xe, 0x2, 0x4c, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x4d, 
    1025             :     0x50, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x4c, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x4f, 
    1026             :     0x3, 0x2, 0x2, 0x2, 0x4f, 0x52, 0x3, 0x2, 0x2, 0x2, 0x50, 0x4e, 0x3, 
    1027             :     0x2, 0x2, 0x2, 0x51, 0x53, 0x5, 0x4, 0x3, 0x2, 0x52, 0x51, 0x3, 0x2, 
    1028             :     0x2, 0x2, 0x52, 0x53, 0x3, 0x2, 0x2, 0x2, 0x53, 0x11, 0x3, 0x2, 0x2, 
    1029             :     0x2, 0x54, 0x55, 0x5, 0xa, 0x6, 0x2, 0x55, 0x13, 0x3, 0x2, 0x2, 0x2, 
    1030             :     0x56, 0x57, 0x7, 0xd, 0x2, 0x2, 0x57, 0x58, 0x5, 0x16, 0xc, 0x2, 0x58, 
    1031             :     0x59, 0x7, 0xe, 0x2, 0x2, 0x59, 0x15, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x5c, 
    1032             :     0x5, 0x18, 0xd, 0x2, 0x5b, 0x5a, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x5d, 0x3, 
    1033             :     0x2, 0x2, 0x2, 0x5d, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x5d, 0x5e, 0x3, 0x2, 
    1034             :     0x2, 0x2, 0x5e, 0x17, 0x3, 0x2, 0x2, 0x2, 0x5f, 0x63, 0x7, 0xf, 0x2, 
    1035             :     0x2, 0x60, 0x62, 0x5, 0x1a, 0xe, 0x2, 0x61, 0x60, 0x3, 0x2, 0x2, 0x2, 
    1036             :     0x62, 0x65, 0x3, 0x2, 0x2, 0x2, 0x63, 0x61, 0x3, 0x2, 0x2, 0x2, 0x63, 
    1037             :     0x64, 0x3, 0x2, 0x2, 0x2, 0x64, 0x66, 0x3, 0x2, 0x2, 0x2, 0x65, 0x63, 
    1038             :     0x3, 0x2, 0x2, 0x2, 0x66, 0x67, 0x5, 0x4, 0x3, 0x2, 0x67, 0x19, 0x3, 
    1039             :     0x2, 0x2, 0x2, 0x68, 0x69, 0x7, 0x5, 0x2, 0x2, 0x69, 0x1b, 0x3, 0x2, 
    1040             :     0x2, 0x2, 0xc, 0x20, 0x25, 0x2d, 0x32, 0x38, 0x46, 0x4e, 0x52, 0x5d, 
    1041             :     0x63, 
    1042         140 :   };
    1043             : 
    1044         140 :   atn::ATNDeserializer deserializer;
    1045          70 :   _atn = deserializer.deserialize(_serializedATN);
    1046             : 
    1047          70 :   size_t count = _atn.getNumberOfDecisions();
    1048          70 :   _decisionToDFA.reserve(count);
    1049         770 :   for (size_t i = 0; i < count; i++) { 
    1050         700 :     _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
    1051             :   }
    1052          70 : }
    1053             : 
    1054         210 : YAML::Initializer YAML::_init;

Generated by: LCOV version 1.13