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;
|