1
2 package io.earcam.instrumental.module.osgi.parser;
3 import org.antlr.v4.runtime.atn.*;
4 import org.antlr.v4.runtime.dfa.DFA;
5 import org.antlr.v4.runtime.*;
6 import org.antlr.v4.runtime.misc.*;
7 import org.antlr.v4.runtime.tree.*;
8 import java.util.List;
9 import java.util.Iterator;
10 import java.util.ArrayList;
11
12 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
13 class ManifestParser extends Parser {
14 static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
15
16 protected static final DFA[] _decisionToDFA;
17 protected static final PredictionContextCache _sharedContextCache =
18 new PredictionContextCache();
19 public static final int
20 T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
21 T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
22 T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, Alpha=24,
23 AlphaNum=25, Number=26, Digit=27, Path=28, Extended=29, QuotedString=30,
24 NL=31, WS=32, UniqueName=33, Identifier=34, ANYCHAR=35;
25 public static final int
26 RULE_manifest = 0, RULE_bundleManifestVersion = 1, RULE_bundleActivator = 2,
27 RULE_symbolicName = 3, RULE_fragmentHost = 4, RULE_manifestAttributes = 5,
28 RULE_manifestAttribute = 6, RULE_dynamicImports = 7, RULE_dynamicDescription = 8,
29 RULE_wildcardName = 9, RULE_imports = 10, RULE_exports = 11, RULE_port = 12,
30 RULE_paquet = 13, RULE_parameter = 14, RULE_directive = 15, RULE_attribute = 16,
31 RULE_argument = 17, RULE_anything = 18, RULE_genericManifestEntry = 19;
32 public static final String[] ruleNames = {
33 "manifest", "bundleManifestVersion", "bundleActivator", "symbolicName",
34 "fragmentHost", "manifestAttributes", "manifestAttribute", "dynamicImports",
35 "dynamicDescription", "wildcardName", "imports", "exports", "port", "paquet",
36 "parameter", "directive", "attribute", "argument", "anything", "genericManifestEntry"
37 };
38
39 private static final String[] _LITERAL_NAMES = {
40 null, "'Manifest-Version'", "': '", "'Bundle-ManifestVersion'", "'Bundle-Activator'",
41 "'Bundle-SymbolicName'", "';'", "'Fragment-Host'", "'DynamicImport-Package'",
42 "','", "'*'", "'Import-Package: '", "'Export-Package: '", "':='", "'='",
43 "'@'", "':'", "'&'", "'('", "')'", "'!'", "'~'", "'+'", "'$'"
44 };
45 private static final String[] _SYMBOLIC_NAMES = {
46 null, null, null, null, null, null, null, null, null, null, null, null,
47 null, null, null, null, null, null, null, null, null, null, null, null,
48 "Alpha", "AlphaNum", "Number", "Digit", "Path", "Extended", "QuotedString",
49 "NL", "WS", "UniqueName", "Identifier", "ANYCHAR"
50 };
51 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
52
53
54
55
56 @Deprecated
57 public static final String[] tokenNames;
58 static {
59 tokenNames = new String[_SYMBOLIC_NAMES.length];
60 for (int i = 0; i < tokenNames.length; i++) {
61 tokenNames[i] = VOCABULARY.getLiteralName(i);
62 if (tokenNames[i] == null) {
63 tokenNames[i] = VOCABULARY.getSymbolicName(i);
64 }
65
66 if (tokenNames[i] == null) {
67 tokenNames[i] = "<INVALID>";
68 }
69 }
70 }
71
72 @Override
73 @Deprecated
74 public String[] getTokenNames() {
75 return tokenNames;
76 }
77
78 @Override
79
80 public Vocabulary getVocabulary() {
81 return VOCABULARY;
82 }
83
84 @Override
85 public String getGrammarFileName() { return "Manifest.g4"; }
86
87 @Override
88 public String[] getRuleNames() { return ruleNames; }
89
90 @Override
91 public String getSerializedATN() { return _serializedATN; }
92
93 @Override
94 public ATN getATN() { return _ATN; }
95
96 public ManifestParser(TokenStream input) {
97 super(input);
98 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
99 }
100 public static class ManifestContext extends ParserRuleContext {
101 public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
102 public List<TerminalNode> NL() { return getTokens(ManifestParser.NL); }
103 public TerminalNode NL(int i) {
104 return getToken(ManifestParser.NL, i);
105 }
106 public TerminalNode EOF() { return getToken(ManifestParser.EOF, 0); }
107 public List<ImportsContext> imports() {
108 return getRuleContexts(ImportsContext.class);
109 }
110 public ImportsContext imports(int i) {
111 return getRuleContext(ImportsContext.class,i);
112 }
113 public List<ExportsContext> exports() {
114 return getRuleContexts(ExportsContext.class);
115 }
116 public ExportsContext exports(int i) {
117 return getRuleContext(ExportsContext.class,i);
118 }
119 public List<SymbolicNameContext> symbolicName() {
120 return getRuleContexts(SymbolicNameContext.class);
121 }
122 public SymbolicNameContext symbolicName(int i) {
123 return getRuleContext(SymbolicNameContext.class,i);
124 }
125 public List<BundleManifestVersionContext> bundleManifestVersion() {
126 return getRuleContexts(BundleManifestVersionContext.class);
127 }
128 public BundleManifestVersionContext bundleManifestVersion(int i) {
129 return getRuleContext(BundleManifestVersionContext.class,i);
130 }
131 public List<BundleActivatorContext> bundleActivator() {
132 return getRuleContexts(BundleActivatorContext.class);
133 }
134 public BundleActivatorContext bundleActivator(int i) {
135 return getRuleContext(BundleActivatorContext.class,i);
136 }
137 public List<FragmentHostContext> fragmentHost() {
138 return getRuleContexts(FragmentHostContext.class);
139 }
140 public FragmentHostContext fragmentHost(int i) {
141 return getRuleContext(FragmentHostContext.class,i);
142 }
143 public List<DynamicImportsContext> dynamicImports() {
144 return getRuleContexts(DynamicImportsContext.class);
145 }
146 public DynamicImportsContext dynamicImports(int i) {
147 return getRuleContext(DynamicImportsContext.class,i);
148 }
149 public List<GenericManifestEntryContext> genericManifestEntry() {
150 return getRuleContexts(GenericManifestEntryContext.class);
151 }
152 public GenericManifestEntryContext genericManifestEntry(int i) {
153 return getRuleContext(GenericManifestEntryContext.class,i);
154 }
155 public ManifestAttributesContext manifestAttributes() {
156 return getRuleContext(ManifestAttributesContext.class,0);
157 }
158 public ManifestContext(ParserRuleContext parent, int invokingState) {
159 super(parent, invokingState);
160 }
161 @Override public int getRuleIndex() { return RULE_manifest; }
162 @Override
163 public void enterRule(ParseTreeListener listener) {
164 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterManifest(this);
165 }
166 @Override
167 public void exitRule(ParseTreeListener listener) {
168 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitManifest(this);
169 }
170 }
171
172 public final ManifestContext manifest() throws RecognitionException {
173 ManifestContext _localctx = new ManifestContext(_ctx, getState());
174 enterRule(_localctx, 0, RULE_manifest);
175 int _la;
176 try {
177 enterOuterAlt(_localctx, 1);
178 {
179 setState(40);
180 match(T__0);
181 setState(41);
182 match(T__1);
183 setState(42);
184 match(Extended);
185 setState(43);
186 match(NL);
187 setState(54);
188 _errHandler.sync(this);
189 _la = _input.LA(1);
190 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__6) | (1L << T__7) | (1L << T__10) | (1L << T__11) | (1L << Extended))) != 0)) {
191 {
192 setState(52);
193 _errHandler.sync(this);
194 switch (_input.LA(1)) {
195 case T__10:
196 {
197 setState(44);
198 imports();
199 }
200 break;
201 case T__11:
202 {
203 setState(45);
204 exports();
205 }
206 break;
207 case T__4:
208 {
209 setState(46);
210 symbolicName();
211 }
212 break;
213 case T__2:
214 {
215 setState(47);
216 bundleManifestVersion();
217 }
218 break;
219 case T__3:
220 {
221 setState(48);
222 bundleActivator();
223 }
224 break;
225 case T__6:
226 {
227 setState(49);
228 fragmentHost();
229 }
230 break;
231 case T__7:
232 {
233 setState(50);
234 dynamicImports();
235 }
236 break;
237 case Extended:
238 {
239 setState(51);
240 genericManifestEntry();
241 }
242 break;
243 default:
244 throw new NoViableAltException(this);
245 }
246 }
247 setState(56);
248 _errHandler.sync(this);
249 _la = _input.LA(1);
250 }
251 setState(57);
252 match(NL);
253 setState(59);
254 _errHandler.sync(this);
255 _la = _input.LA(1);
256 if (_la==Extended) {
257 {
258 setState(58);
259 manifestAttributes();
260 }
261 }
262
263 setState(64);
264 _errHandler.sync(this);
265 _la = _input.LA(1);
266 while (_la==NL) {
267 {
268 {
269 setState(61);
270 match(NL);
271 }
272 }
273 setState(66);
274 _errHandler.sync(this);
275 _la = _input.LA(1);
276 }
277 setState(67);
278 match(EOF);
279 }
280 }
281 catch (RecognitionException re) {
282 _localctx.exception = re;
283 _errHandler.reportError(this, re);
284 _errHandler.recover(this, re);
285 }
286 finally {
287 exitRule();
288 }
289 return _localctx;
290 }
291
292 public static class BundleManifestVersionContext extends ParserRuleContext {
293 public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
294 public TerminalNode Number() { return getToken(ManifestParser.Number, 0); }
295 public TerminalNode AlphaNum() { return getToken(ManifestParser.AlphaNum, 0); }
296 public TerminalNode Digit() { return getToken(ManifestParser.Digit, 0); }
297 public BundleManifestVersionContext(ParserRuleContext parent, int invokingState) {
298 super(parent, invokingState);
299 }
300 @Override public int getRuleIndex() { return RULE_bundleManifestVersion; }
301 @Override
302 public void enterRule(ParseTreeListener listener) {
303 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterBundleManifestVersion(this);
304 }
305 @Override
306 public void exitRule(ParseTreeListener listener) {
307 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitBundleManifestVersion(this);
308 }
309 }
310
311 public final BundleManifestVersionContext bundleManifestVersion() throws RecognitionException {
312 BundleManifestVersionContext _localctx = new BundleManifestVersionContext(_ctx, getState());
313 enterRule(_localctx, 2, RULE_bundleManifestVersion);
314 int _la;
315 try {
316 enterOuterAlt(_localctx, 1);
317 {
318 setState(69);
319 match(T__2);
320 setState(70);
321 match(T__1);
322 setState(71);
323 _la = _input.LA(1);
324 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AlphaNum) | (1L << Number) | (1L << Digit))) != 0)) ) {
325 _errHandler.recoverInline(this);
326 }
327 else {
328 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
329 _errHandler.reportMatch(this);
330 consume();
331 }
332 setState(72);
333 match(NL);
334 }
335 }
336 catch (RecognitionException re) {
337 _localctx.exception = re;
338 _errHandler.reportError(this, re);
339 _errHandler.recover(this, re);
340 }
341 finally {
342 exitRule();
343 }
344 return _localctx;
345 }
346
347 public static class BundleActivatorContext extends ParserRuleContext {
348 public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
349 public TerminalNode UniqueName() { return getToken(ManifestParser.UniqueName, 0); }
350 public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
351 public BundleActivatorContext(ParserRuleContext parent, int invokingState) {
352 super(parent, invokingState);
353 }
354 @Override public int getRuleIndex() { return RULE_bundleActivator; }
355 @Override
356 public void enterRule(ParseTreeListener listener) {
357 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterBundleActivator(this);
358 }
359 @Override
360 public void exitRule(ParseTreeListener listener) {
361 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitBundleActivator(this);
362 }
363 }
364
365 public final BundleActivatorContext bundleActivator() throws RecognitionException {
366 BundleActivatorContext _localctx = new BundleActivatorContext(_ctx, getState());
367 enterRule(_localctx, 4, RULE_bundleActivator);
368 int _la;
369 try {
370 enterOuterAlt(_localctx, 1);
371 {
372 setState(74);
373 match(T__3);
374 setState(75);
375 match(T__1);
376 setState(76);
377 _la = _input.LA(1);
378 if ( !(_la==Extended || _la==UniqueName) ) {
379 _errHandler.recoverInline(this);
380 }
381 else {
382 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
383 _errHandler.reportMatch(this);
384 consume();
385 }
386 setState(77);
387 match(NL);
388 }
389 }
390 catch (RecognitionException re) {
391 _localctx.exception = re;
392 _errHandler.reportError(this, re);
393 _errHandler.recover(this, re);
394 }
395 finally {
396 exitRule();
397 }
398 return _localctx;
399 }
400
401 public static class SymbolicNameContext extends ParserRuleContext {
402 public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
403 public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
404 public List<ParameterContext> parameter() {
405 return getRuleContexts(ParameterContext.class);
406 }
407 public ParameterContext parameter(int i) {
408 return getRuleContext(ParameterContext.class,i);
409 }
410 public SymbolicNameContext(ParserRuleContext parent, int invokingState) {
411 super(parent, invokingState);
412 }
413 @Override public int getRuleIndex() { return RULE_symbolicName; }
414 @Override
415 public void enterRule(ParseTreeListener listener) {
416 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterSymbolicName(this);
417 }
418 @Override
419 public void exitRule(ParseTreeListener listener) {
420 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitSymbolicName(this);
421 }
422 }
423
424 public final SymbolicNameContext symbolicName() throws RecognitionException {
425 SymbolicNameContext _localctx = new SymbolicNameContext(_ctx, getState());
426 enterRule(_localctx, 6, RULE_symbolicName);
427 int _la;
428 try {
429 enterOuterAlt(_localctx, 1);
430 {
431 setState(79);
432 match(T__4);
433 setState(80);
434 match(T__1);
435 setState(81);
436 match(Extended);
437 setState(86);
438 _errHandler.sync(this);
439 _la = _input.LA(1);
440 while (_la==T__5) {
441 {
442 {
443 setState(82);
444 match(T__5);
445 setState(83);
446 parameter();
447 }
448 }
449 setState(88);
450 _errHandler.sync(this);
451 _la = _input.LA(1);
452 }
453 setState(89);
454 match(NL);
455 }
456 }
457 catch (RecognitionException re) {
458 _localctx.exception = re;
459 _errHandler.reportError(this, re);
460 _errHandler.recover(this, re);
461 }
462 finally {
463 exitRule();
464 }
465 return _localctx;
466 }
467
468 public static class FragmentHostContext extends ParserRuleContext {
469 public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
470 public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
471 public List<ParameterContext> parameter() {
472 return getRuleContexts(ParameterContext.class);
473 }
474 public ParameterContext parameter(int i) {
475 return getRuleContext(ParameterContext.class,i);
476 }
477 public FragmentHostContext(ParserRuleContext parent, int invokingState) {
478 super(parent, invokingState);
479 }
480 @Override public int getRuleIndex() { return RULE_fragmentHost; }
481 @Override
482 public void enterRule(ParseTreeListener listener) {
483 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterFragmentHost(this);
484 }
485 @Override
486 public void exitRule(ParseTreeListener listener) {
487 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitFragmentHost(this);
488 }
489 }
490
491 public final FragmentHostContext fragmentHost() throws RecognitionException {
492 FragmentHostContext _localctx = new FragmentHostContext(_ctx, getState());
493 enterRule(_localctx, 8, RULE_fragmentHost);
494 int _la;
495 try {
496 enterOuterAlt(_localctx, 1);
497 {
498 setState(91);
499 match(T__6);
500 setState(92);
501 match(T__1);
502 setState(93);
503 match(Extended);
504 setState(98);
505 _errHandler.sync(this);
506 _la = _input.LA(1);
507 while (_la==T__5) {
508 {
509 {
510 setState(94);
511 match(T__5);
512 setState(95);
513 parameter();
514 }
515 }
516 setState(100);
517 _errHandler.sync(this);
518 _la = _input.LA(1);
519 }
520 setState(101);
521 match(NL);
522 }
523 }
524 catch (RecognitionException re) {
525 _localctx.exception = re;
526 _errHandler.reportError(this, re);
527 _errHandler.recover(this, re);
528 }
529 finally {
530 exitRule();
531 }
532 return _localctx;
533 }
534
535 public static class ManifestAttributesContext extends ParserRuleContext {
536 public List<ManifestAttributeContext> manifestAttribute() {
537 return getRuleContexts(ManifestAttributeContext.class);
538 }
539 public ManifestAttributeContext manifestAttribute(int i) {
540 return getRuleContext(ManifestAttributeContext.class,i);
541 }
542 public ManifestAttributesContext(ParserRuleContext parent, int invokingState) {
543 super(parent, invokingState);
544 }
545 @Override public int getRuleIndex() { return RULE_manifestAttributes; }
546 @Override
547 public void enterRule(ParseTreeListener listener) {
548 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterManifestAttributes(this);
549 }
550 @Override
551 public void exitRule(ParseTreeListener listener) {
552 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitManifestAttributes(this);
553 }
554 }
555
556 public final ManifestAttributesContext manifestAttributes() throws RecognitionException {
557 ManifestAttributesContext _localctx = new ManifestAttributesContext(_ctx, getState());
558 enterRule(_localctx, 10, RULE_manifestAttributes);
559 int _la;
560 try {
561 enterOuterAlt(_localctx, 1);
562 {
563 setState(104);
564 _errHandler.sync(this);
565 _la = _input.LA(1);
566 do {
567 {
568 {
569 setState(103);
570 manifestAttribute();
571 }
572 }
573 setState(106);
574 _errHandler.sync(this);
575 _la = _input.LA(1);
576 } while ( _la==Extended );
577 }
578 }
579 catch (RecognitionException re) {
580 _localctx.exception = re;
581 _errHandler.reportError(this, re);
582 _errHandler.recover(this, re);
583 }
584 finally {
585 exitRule();
586 }
587 return _localctx;
588 }
589
590 public static class ManifestAttributeContext extends ParserRuleContext {
591 public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
592 public List<GenericManifestEntryContext> genericManifestEntry() {
593 return getRuleContexts(GenericManifestEntryContext.class);
594 }
595 public GenericManifestEntryContext genericManifestEntry(int i) {
596 return getRuleContext(GenericManifestEntryContext.class,i);
597 }
598 public ManifestAttributeContext(ParserRuleContext parent, int invokingState) {
599 super(parent, invokingState);
600 }
601 @Override public int getRuleIndex() { return RULE_manifestAttribute; }
602 @Override
603 public void enterRule(ParseTreeListener listener) {
604 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterManifestAttribute(this);
605 }
606 @Override
607 public void exitRule(ParseTreeListener listener) {
608 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitManifestAttribute(this);
609 }
610 }
611
612 public final ManifestAttributeContext manifestAttribute() throws RecognitionException {
613 ManifestAttributeContext _localctx = new ManifestAttributeContext(_ctx, getState());
614 enterRule(_localctx, 12, RULE_manifestAttribute);
615 int _la;
616 try {
617 enterOuterAlt(_localctx, 1);
618 {
619 setState(109);
620 _errHandler.sync(this);
621 _la = _input.LA(1);
622 do {
623 {
624 {
625 setState(108);
626 genericManifestEntry();
627 }
628 }
629 setState(111);
630 _errHandler.sync(this);
631 _la = _input.LA(1);
632 } while ( _la==Extended );
633 setState(113);
634 match(NL);
635 }
636 }
637 catch (RecognitionException re) {
638 _localctx.exception = re;
639 _errHandler.reportError(this, re);
640 _errHandler.recover(this, re);
641 }
642 finally {
643 exitRule();
644 }
645 return _localctx;
646 }
647
648 public static class DynamicImportsContext extends ParserRuleContext {
649 public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
650 public List<DynamicDescriptionContext> dynamicDescription() {
651 return getRuleContexts(DynamicDescriptionContext.class);
652 }
653 public DynamicDescriptionContext dynamicDescription(int i) {
654 return getRuleContext(DynamicDescriptionContext.class,i);
655 }
656 public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
657 public TerminalNode WS(int i) {
658 return getToken(ManifestParser.WS, i);
659 }
660 public DynamicImportsContext(ParserRuleContext parent, int invokingState) {
661 super(parent, invokingState);
662 }
663 @Override public int getRuleIndex() { return RULE_dynamicImports; }
664 @Override
665 public void enterRule(ParseTreeListener listener) {
666 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterDynamicImports(this);
667 }
668 @Override
669 public void exitRule(ParseTreeListener listener) {
670 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitDynamicImports(this);
671 }
672 }
673
674 public final DynamicImportsContext dynamicImports() throws RecognitionException {
675 DynamicImportsContext _localctx = new DynamicImportsContext(_ctx, getState());
676 enterRule(_localctx, 14, RULE_dynamicImports);
677 int _la;
678 try {
679 enterOuterAlt(_localctx, 1);
680 {
681 setState(115);
682 match(T__7);
683 setState(116);
684 match(T__1);
685 setState(131);
686 _errHandler.sync(this);
687 switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
688 case 1:
689 {
690 setState(117);
691 dynamicDescription();
692 }
693 break;
694 case 2:
695 {
696 setState(118);
697 dynamicDescription();
698 setState(127);
699 _errHandler.sync(this);
700 _la = _input.LA(1);
701 do {
702 {
703 {
704 setState(119);
705 match(T__8);
706 setState(123);
707 _errHandler.sync(this);
708 _la = _input.LA(1);
709 while (_la==WS) {
710 {
711 {
712 setState(120);
713 match(WS);
714 }
715 }
716 setState(125);
717 _errHandler.sync(this);
718 _la = _input.LA(1);
719 }
720 setState(126);
721 dynamicDescription();
722 }
723 }
724 setState(129);
725 _errHandler.sync(this);
726 _la = _input.LA(1);
727 } while ( _la==T__8 );
728 }
729 break;
730 }
731 setState(133);
732 match(NL);
733 }
734 }
735 catch (RecognitionException re) {
736 _localctx.exception = re;
737 _errHandler.reportError(this, re);
738 _errHandler.recover(this, re);
739 }
740 finally {
741 exitRule();
742 }
743 return _localctx;
744 }
745
746 public static class DynamicDescriptionContext extends ParserRuleContext {
747 public List<WildcardNameContext> wildcardName() {
748 return getRuleContexts(WildcardNameContext.class);
749 }
750 public WildcardNameContext wildcardName(int i) {
751 return getRuleContext(WildcardNameContext.class,i);
752 }
753 public List<ParameterContext> parameter() {
754 return getRuleContexts(ParameterContext.class);
755 }
756 public ParameterContext parameter(int i) {
757 return getRuleContext(ParameterContext.class,i);
758 }
759 public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
760 public TerminalNode WS(int i) {
761 return getToken(ManifestParser.WS, i);
762 }
763 public DynamicDescriptionContext(ParserRuleContext parent, int invokingState) {
764 super(parent, invokingState);
765 }
766 @Override public int getRuleIndex() { return RULE_dynamicDescription; }
767 @Override
768 public void enterRule(ParseTreeListener listener) {
769 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterDynamicDescription(this);
770 }
771 @Override
772 public void exitRule(ParseTreeListener listener) {
773 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitDynamicDescription(this);
774 }
775 }
776
777 public final DynamicDescriptionContext dynamicDescription() throws RecognitionException {
778 DynamicDescriptionContext _localctx = new DynamicDescriptionContext(_ctx, getState());
779 enterRule(_localctx, 16, RULE_dynamicDescription);
780 int _la;
781 try {
782 int _alt;
783 setState(169);
784 _errHandler.sync(this);
785 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
786 case 1:
787 enterOuterAlt(_localctx, 1);
788 {
789 setState(135);
790 wildcardName();
791 setState(146);
792 _errHandler.sync(this);
793 _alt = getInterpreter().adaptivePredict(_input,12,_ctx);
794 while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
795 if ( _alt==1+1 ) {
796 {
797 {
798 setState(136);
799 match(T__5);
800 setState(140);
801 _errHandler.sync(this);
802 _la = _input.LA(1);
803 while (_la==WS) {
804 {
805 {
806 setState(137);
807 match(WS);
808 }
809 }
810 setState(142);
811 _errHandler.sync(this);
812 _la = _input.LA(1);
813 }
814 setState(143);
815 parameter();
816 }
817 }
818 }
819 setState(148);
820 _errHandler.sync(this);
821 _alt = getInterpreter().adaptivePredict(_input,12,_ctx);
822 }
823 }
824 break;
825 case 2:
826 enterOuterAlt(_localctx, 2);
827 {
828 setState(149);
829 wildcardName();
830 setState(158);
831 _errHandler.sync(this);
832 _alt = 1+1;
833 do {
834 switch (_alt) {
835 case 1+1:
836 {
837 {
838 setState(150);
839 match(T__5);
840 setState(154);
841 _errHandler.sync(this);
842 _la = _input.LA(1);
843 while (_la==WS) {
844 {
845 {
846 setState(151);
847 match(WS);
848 }
849 }
850 setState(156);
851 _errHandler.sync(this);
852 _la = _input.LA(1);
853 }
854 setState(157);
855 wildcardName();
856 }
857 }
858 break;
859 default:
860 throw new NoViableAltException(this);
861 }
862 setState(160);
863 _errHandler.sync(this);
864 _alt = getInterpreter().adaptivePredict(_input,14,_ctx);
865 } while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
866 setState(166);
867 _errHandler.sync(this);
868 _la = _input.LA(1);
869 while (_la==T__5) {
870 {
871 {
872 setState(162);
873 match(T__5);
874 setState(163);
875 parameter();
876 }
877 }
878 setState(168);
879 _errHandler.sync(this);
880 _la = _input.LA(1);
881 }
882 }
883 break;
884 }
885 }
886 catch (RecognitionException re) {
887 _localctx.exception = re;
888 _errHandler.reportError(this, re);
889 _errHandler.recover(this, re);
890 }
891 finally {
892 exitRule();
893 }
894 return _localctx;
895 }
896
897 public static class WildcardNameContext extends ParserRuleContext {
898 public List<TerminalNode> UniqueName() { return getTokens(ManifestParser.UniqueName); }
899 public TerminalNode UniqueName(int i) {
900 return getToken(ManifestParser.UniqueName, i);
901 }
902 public List<TerminalNode> Extended() { return getTokens(ManifestParser.Extended); }
903 public TerminalNode Extended(int i) {
904 return getToken(ManifestParser.Extended, i);
905 }
906 public PaquetContext paquet() {
907 return getRuleContext(PaquetContext.class,0);
908 }
909 public WildcardNameContext(ParserRuleContext parent, int invokingState) {
910 super(parent, invokingState);
911 }
912 @Override public int getRuleIndex() { return RULE_wildcardName; }
913 @Override
914 public void enterRule(ParseTreeListener listener) {
915 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterWildcardName(this);
916 }
917 @Override
918 public void exitRule(ParseTreeListener listener) {
919 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitWildcardName(this);
920 }
921 }
922
923 public final WildcardNameContext wildcardName() throws RecognitionException {
924 WildcardNameContext _localctx = new WildcardNameContext(_ctx, getState());
925 enterRule(_localctx, 18, RULE_wildcardName);
926 int _la;
927 try {
928 int _alt;
929 setState(179);
930 _errHandler.sync(this);
931 switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
932 case 1:
933 enterOuterAlt(_localctx, 1);
934 {
935 {
936 setState(172);
937 _errHandler.sync(this);
938 _alt = 1+1;
939 do {
940 switch (_alt) {
941 case 1+1:
942 {
943 {
944 setState(171);
945 _la = _input.LA(1);
946 if ( !(_la==Extended || _la==UniqueName) ) {
947 _errHandler.recoverInline(this);
948 }
949 else {
950 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
951 _errHandler.reportMatch(this);
952 consume();
953 }
954 }
955 }
956 break;
957 default:
958 throw new NoViableAltException(this);
959 }
960 setState(174);
961 _errHandler.sync(this);
962 _alt = getInterpreter().adaptivePredict(_input,17,_ctx);
963 } while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
964 setState(176);
965 match(T__9);
966 }
967 }
968 break;
969 case 2:
970 enterOuterAlt(_localctx, 2);
971 {
972 setState(177);
973 paquet();
974 }
975 break;
976 case 3:
977 enterOuterAlt(_localctx, 3);
978 {
979 setState(178);
980 match(T__9);
981 }
982 break;
983 }
984 }
985 catch (RecognitionException re) {
986 _localctx.exception = re;
987 _errHandler.reportError(this, re);
988 _errHandler.recover(this, re);
989 }
990 finally {
991 exitRule();
992 }
993 return _localctx;
994 }
995
996 public static class ImportsContext extends ParserRuleContext {
997 public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
998 public List<PortContext> port() {
999 return getRuleContexts(PortContext.class);
1000 }
1001 public PortContext port(int i) {
1002 return getRuleContext(PortContext.class,i);
1003 }
1004 public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
1005 public TerminalNode WS(int i) {
1006 return getToken(ManifestParser.WS, i);
1007 }
1008 public ImportsContext(ParserRuleContext parent, int invokingState) {
1009 super(parent, invokingState);
1010 }
1011 @Override public int getRuleIndex() { return RULE_imports; }
1012 @Override
1013 public void enterRule(ParseTreeListener listener) {
1014 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterImports(this);
1015 }
1016 @Override
1017 public void exitRule(ParseTreeListener listener) {
1018 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitImports(this);
1019 }
1020 }
1021
1022 public final ImportsContext imports() throws RecognitionException {
1023 ImportsContext _localctx = new ImportsContext(_ctx, getState());
1024 enterRule(_localctx, 20, RULE_imports);
1025 int _la;
1026 try {
1027 enterOuterAlt(_localctx, 1);
1028 {
1029 setState(181);
1030 match(T__10);
1031 setState(196);
1032 _errHandler.sync(this);
1033 switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
1034 case 1:
1035 {
1036 setState(182);
1037 port();
1038 }
1039 break;
1040 case 2:
1041 {
1042 setState(183);
1043 port();
1044 setState(192);
1045 _errHandler.sync(this);
1046 _la = _input.LA(1);
1047 do {
1048 {
1049 {
1050 setState(184);
1051 match(T__8);
1052 setState(188);
1053 _errHandler.sync(this);
1054 _la = _input.LA(1);
1055 while (_la==WS) {
1056 {
1057 {
1058 setState(185);
1059 match(WS);
1060 }
1061 }
1062 setState(190);
1063 _errHandler.sync(this);
1064 _la = _input.LA(1);
1065 }
1066 setState(191);
1067 port();
1068 }
1069 }
1070 setState(194);
1071 _errHandler.sync(this);
1072 _la = _input.LA(1);
1073 } while ( _la==T__8 );
1074 }
1075 break;
1076 }
1077 setState(198);
1078 match(NL);
1079 }
1080 }
1081 catch (RecognitionException re) {
1082 _localctx.exception = re;
1083 _errHandler.reportError(this, re);
1084 _errHandler.recover(this, re);
1085 }
1086 finally {
1087 exitRule();
1088 }
1089 return _localctx;
1090 }
1091
1092 public static class ExportsContext extends ParserRuleContext {
1093 public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
1094 public List<PortContext> port() {
1095 return getRuleContexts(PortContext.class);
1096 }
1097 public PortContext port(int i) {
1098 return getRuleContext(PortContext.class,i);
1099 }
1100 public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
1101 public TerminalNode WS(int i) {
1102 return getToken(ManifestParser.WS, i);
1103 }
1104 public ExportsContext(ParserRuleContext parent, int invokingState) {
1105 super(parent, invokingState);
1106 }
1107 @Override public int getRuleIndex() { return RULE_exports; }
1108 @Override
1109 public void enterRule(ParseTreeListener listener) {
1110 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterExports(this);
1111 }
1112 @Override
1113 public void exitRule(ParseTreeListener listener) {
1114 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitExports(this);
1115 }
1116 }
1117
1118 public final ExportsContext exports() throws RecognitionException {
1119 ExportsContext _localctx = new ExportsContext(_ctx, getState());
1120 enterRule(_localctx, 22, RULE_exports);
1121 int _la;
1122 try {
1123 enterOuterAlt(_localctx, 1);
1124 {
1125 setState(200);
1126 match(T__11);
1127 setState(215);
1128 _errHandler.sync(this);
1129 switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
1130 case 1:
1131 {
1132 setState(201);
1133 port();
1134 }
1135 break;
1136 case 2:
1137 {
1138 setState(202);
1139 port();
1140 setState(211);
1141 _errHandler.sync(this);
1142 _la = _input.LA(1);
1143 do {
1144 {
1145 {
1146 setState(203);
1147 match(T__8);
1148 setState(207);
1149 _errHandler.sync(this);
1150 _la = _input.LA(1);
1151 while (_la==WS) {
1152 {
1153 {
1154 setState(204);
1155 match(WS);
1156 }
1157 }
1158 setState(209);
1159 _errHandler.sync(this);
1160 _la = _input.LA(1);
1161 }
1162 setState(210);
1163 port();
1164 }
1165 }
1166 setState(213);
1167 _errHandler.sync(this);
1168 _la = _input.LA(1);
1169 } while ( _la==T__8 );
1170 }
1171 break;
1172 }
1173 setState(217);
1174 match(NL);
1175 }
1176 }
1177 catch (RecognitionException re) {
1178 _localctx.exception = re;
1179 _errHandler.reportError(this, re);
1180 _errHandler.recover(this, re);
1181 }
1182 finally {
1183 exitRule();
1184 }
1185 return _localctx;
1186 }
1187
1188 public static class PortContext extends ParserRuleContext {
1189 public List<PaquetContext> paquet() {
1190 return getRuleContexts(PaquetContext.class);
1191 }
1192 public PaquetContext paquet(int i) {
1193 return getRuleContext(PaquetContext.class,i);
1194 }
1195 public List<ParameterContext> parameter() {
1196 return getRuleContexts(ParameterContext.class);
1197 }
1198 public ParameterContext parameter(int i) {
1199 return getRuleContext(ParameterContext.class,i);
1200 }
1201 public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
1202 public TerminalNode WS(int i) {
1203 return getToken(ManifestParser.WS, i);
1204 }
1205 public PortContext(ParserRuleContext parent, int invokingState) {
1206 super(parent, invokingState);
1207 }
1208 @Override public int getRuleIndex() { return RULE_port; }
1209 @Override
1210 public void enterRule(ParseTreeListener listener) {
1211 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterPort(this);
1212 }
1213 @Override
1214 public void exitRule(ParseTreeListener listener) {
1215 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitPort(this);
1216 }
1217 }
1218
1219 public final PortContext port() throws RecognitionException {
1220 PortContext _localctx = new PortContext(_ctx, getState());
1221 enterRule(_localctx, 24, RULE_port);
1222 int _la;
1223 try {
1224 int _alt;
1225 setState(253);
1226 _errHandler.sync(this);
1227 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
1228 case 1:
1229 enterOuterAlt(_localctx, 1);
1230 {
1231 setState(219);
1232 paquet();
1233 setState(230);
1234 _errHandler.sync(this);
1235 _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
1236 while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1237 if ( _alt==1+1 ) {
1238 {
1239 {
1240 setState(220);
1241 match(T__5);
1242 setState(224);
1243 _errHandler.sync(this);
1244 _la = _input.LA(1);
1245 while (_la==WS) {
1246 {
1247 {
1248 setState(221);
1249 match(WS);
1250 }
1251 }
1252 setState(226);
1253 _errHandler.sync(this);
1254 _la = _input.LA(1);
1255 }
1256 setState(227);
1257 parameter();
1258 }
1259 }
1260 }
1261 setState(232);
1262 _errHandler.sync(this);
1263 _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
1264 }
1265 }
1266 break;
1267 case 2:
1268 enterOuterAlt(_localctx, 2);
1269 {
1270 setState(233);
1271 paquet();
1272 setState(242);
1273 _errHandler.sync(this);
1274 _alt = 1+1;
1275 do {
1276 switch (_alt) {
1277 case 1+1:
1278 {
1279 {
1280 setState(234);
1281 match(T__5);
1282 setState(238);
1283 _errHandler.sync(this);
1284 _la = _input.LA(1);
1285 while (_la==WS) {
1286 {
1287 {
1288 setState(235);
1289 match(WS);
1290 }
1291 }
1292 setState(240);
1293 _errHandler.sync(this);
1294 _la = _input.LA(1);
1295 }
1296 setState(241);
1297 paquet();
1298 }
1299 }
1300 break;
1301 default:
1302 throw new NoViableAltException(this);
1303 }
1304 setState(244);
1305 _errHandler.sync(this);
1306 _alt = getInterpreter().adaptivePredict(_input,28,_ctx);
1307 } while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
1308 setState(250);
1309 _errHandler.sync(this);
1310 _la = _input.LA(1);
1311 while (_la==T__5) {
1312 {
1313 {
1314 setState(246);
1315 match(T__5);
1316 setState(247);
1317 parameter();
1318 }
1319 }
1320 setState(252);
1321 _errHandler.sync(this);
1322 _la = _input.LA(1);
1323 }
1324 }
1325 break;
1326 }
1327 }
1328 catch (RecognitionException re) {
1329 _localctx.exception = re;
1330 _errHandler.reportError(this, re);
1331 _errHandler.recover(this, re);
1332 }
1333 finally {
1334 exitRule();
1335 }
1336 return _localctx;
1337 }
1338
1339 public static class PaquetContext extends ParserRuleContext {
1340 public TerminalNode UniqueName() { return getToken(ManifestParser.UniqueName, 0); }
1341 public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
1342 public PaquetContext(ParserRuleContext parent, int invokingState) {
1343 super(parent, invokingState);
1344 }
1345 @Override public int getRuleIndex() { return RULE_paquet; }
1346 @Override
1347 public void enterRule(ParseTreeListener listener) {
1348 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterPaquet(this);
1349 }
1350 @Override
1351 public void exitRule(ParseTreeListener listener) {
1352 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitPaquet(this);
1353 }
1354 }
1355
1356 public final PaquetContext paquet() throws RecognitionException {
1357 PaquetContext _localctx = new PaquetContext(_ctx, getState());
1358 enterRule(_localctx, 26, RULE_paquet);
1359 int _la;
1360 try {
1361 enterOuterAlt(_localctx, 1);
1362 {
1363 setState(255);
1364 _la = _input.LA(1);
1365 if ( !(_la==Extended || _la==UniqueName) ) {
1366 _errHandler.recoverInline(this);
1367 }
1368 else {
1369 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1370 _errHandler.reportMatch(this);
1371 consume();
1372 }
1373 }
1374 }
1375 catch (RecognitionException re) {
1376 _localctx.exception = re;
1377 _errHandler.reportError(this, re);
1378 _errHandler.recover(this, re);
1379 }
1380 finally {
1381 exitRule();
1382 }
1383 return _localctx;
1384 }
1385
1386 public static class ParameterContext extends ParserRuleContext {
1387 public DirectiveContext directive() {
1388 return getRuleContext(DirectiveContext.class,0);
1389 }
1390 public AttributeContext attribute() {
1391 return getRuleContext(AttributeContext.class,0);
1392 }
1393 public ParameterContext(ParserRuleContext parent, int invokingState) {
1394 super(parent, invokingState);
1395 }
1396 @Override public int getRuleIndex() { return RULE_parameter; }
1397 @Override
1398 public void enterRule(ParseTreeListener listener) {
1399 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterParameter(this);
1400 }
1401 @Override
1402 public void exitRule(ParseTreeListener listener) {
1403 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitParameter(this);
1404 }
1405 }
1406
1407 public final ParameterContext parameter() throws RecognitionException {
1408 ParameterContext _localctx = new ParameterContext(_ctx, getState());
1409 enterRule(_localctx, 28, RULE_parameter);
1410 try {
1411 setState(259);
1412 _errHandler.sync(this);
1413 switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
1414 case 1:
1415 enterOuterAlt(_localctx, 1);
1416 {
1417 setState(257);
1418 directive();
1419 }
1420 break;
1421 case 2:
1422 enterOuterAlt(_localctx, 2);
1423 {
1424 setState(258);
1425 attribute();
1426 }
1427 break;
1428 }
1429 }
1430 catch (RecognitionException re) {
1431 _localctx.exception = re;
1432 _errHandler.reportError(this, re);
1433 _errHandler.recover(this, re);
1434 }
1435 finally {
1436 exitRule();
1437 }
1438 return _localctx;
1439 }
1440
1441 public static class DirectiveContext extends ParserRuleContext {
1442 public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
1443 public ArgumentContext argument() {
1444 return getRuleContext(ArgumentContext.class,0);
1445 }
1446 public DirectiveContext(ParserRuleContext parent, int invokingState) {
1447 super(parent, invokingState);
1448 }
1449 @Override public int getRuleIndex() { return RULE_directive; }
1450 @Override
1451 public void enterRule(ParseTreeListener listener) {
1452 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterDirective(this);
1453 }
1454 @Override
1455 public void exitRule(ParseTreeListener listener) {
1456 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitDirective(this);
1457 }
1458 }
1459
1460 public final DirectiveContext directive() throws RecognitionException {
1461 DirectiveContext _localctx = new DirectiveContext(_ctx, getState());
1462 enterRule(_localctx, 30, RULE_directive);
1463 try {
1464 enterOuterAlt(_localctx, 1);
1465 {
1466 setState(261);
1467 match(Extended);
1468 setState(262);
1469 match(T__12);
1470 setState(263);
1471 argument();
1472 }
1473 }
1474 catch (RecognitionException re) {
1475 _localctx.exception = re;
1476 _errHandler.reportError(this, re);
1477 _errHandler.recover(this, re);
1478 }
1479 finally {
1480 exitRule();
1481 }
1482 return _localctx;
1483 }
1484
1485 public static class AttributeContext extends ParserRuleContext {
1486 public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
1487 public ArgumentContext argument() {
1488 return getRuleContext(ArgumentContext.class,0);
1489 }
1490 public AttributeContext(ParserRuleContext parent, int invokingState) {
1491 super(parent, invokingState);
1492 }
1493 @Override public int getRuleIndex() { return RULE_attribute; }
1494 @Override
1495 public void enterRule(ParseTreeListener listener) {
1496 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterAttribute(this);
1497 }
1498 @Override
1499 public void exitRule(ParseTreeListener listener) {
1500 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitAttribute(this);
1501 }
1502 }
1503
1504 public final AttributeContext attribute() throws RecognitionException {
1505 AttributeContext _localctx = new AttributeContext(_ctx, getState());
1506 enterRule(_localctx, 32, RULE_attribute);
1507 try {
1508 enterOuterAlt(_localctx, 1);
1509 {
1510 setState(265);
1511 match(Extended);
1512 setState(266);
1513 match(T__13);
1514 setState(267);
1515 argument();
1516 }
1517 }
1518 catch (RecognitionException re) {
1519 _localctx.exception = re;
1520 _errHandler.reportError(this, re);
1521 _errHandler.recover(this, re);
1522 }
1523 finally {
1524 exitRule();
1525 }
1526 return _localctx;
1527 }
1528
1529 public static class ArgumentContext extends ParserRuleContext {
1530 public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
1531 public TerminalNode QuotedString() { return getToken(ManifestParser.QuotedString, 0); }
1532 public TerminalNode AlphaNum() { return getToken(ManifestParser.AlphaNum, 0); }
1533 public ArgumentContext(ParserRuleContext parent, int invokingState) {
1534 super(parent, invokingState);
1535 }
1536 @Override public int getRuleIndex() { return RULE_argument; }
1537 @Override
1538 public void enterRule(ParseTreeListener listener) {
1539 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterArgument(this);
1540 }
1541 @Override
1542 public void exitRule(ParseTreeListener listener) {
1543 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitArgument(this);
1544 }
1545 }
1546
1547 public final ArgumentContext argument() throws RecognitionException {
1548 ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
1549 enterRule(_localctx, 34, RULE_argument);
1550 int _la;
1551 try {
1552 enterOuterAlt(_localctx, 1);
1553 {
1554 setState(269);
1555 _la = _input.LA(1);
1556 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AlphaNum) | (1L << Extended) | (1L << QuotedString))) != 0)) ) {
1557 _errHandler.recoverInline(this);
1558 }
1559 else {
1560 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1561 _errHandler.reportMatch(this);
1562 consume();
1563 }
1564 }
1565 }
1566 catch (RecognitionException re) {
1567 _localctx.exception = re;
1568 _errHandler.reportError(this, re);
1569 _errHandler.recover(this, re);
1570 }
1571 finally {
1572 exitRule();
1573 }
1574 return _localctx;
1575 }
1576
1577 public static class AnythingContext extends ParserRuleContext {
1578 public List<TerminalNode> Alpha() { return getTokens(ManifestParser.Alpha); }
1579 public TerminalNode Alpha(int i) {
1580 return getToken(ManifestParser.Alpha, i);
1581 }
1582 public List<TerminalNode> AlphaNum() { return getTokens(ManifestParser.AlphaNum); }
1583 public TerminalNode AlphaNum(int i) {
1584 return getToken(ManifestParser.AlphaNum, i);
1585 }
1586 public List<TerminalNode> Digit() { return getTokens(ManifestParser.Digit); }
1587 public TerminalNode Digit(int i) {
1588 return getToken(ManifestParser.Digit, i);
1589 }
1590 public List<TerminalNode> Number() { return getTokens(ManifestParser.Number); }
1591 public TerminalNode Number(int i) {
1592 return getToken(ManifestParser.Number, i);
1593 }
1594 public List<TerminalNode> Path() { return getTokens(ManifestParser.Path); }
1595 public TerminalNode Path(int i) {
1596 return getToken(ManifestParser.Path, i);
1597 }
1598 public List<TerminalNode> Extended() { return getTokens(ManifestParser.Extended); }
1599 public TerminalNode Extended(int i) {
1600 return getToken(ManifestParser.Extended, i);
1601 }
1602 public List<TerminalNode> QuotedString() { return getTokens(ManifestParser.QuotedString); }
1603 public TerminalNode QuotedString(int i) {
1604 return getToken(ManifestParser.QuotedString, i);
1605 }
1606 public List<TerminalNode> UniqueName() { return getTokens(ManifestParser.UniqueName); }
1607 public TerminalNode UniqueName(int i) {
1608 return getToken(ManifestParser.UniqueName, i);
1609 }
1610 public List<TerminalNode> Identifier() { return getTokens(ManifestParser.Identifier); }
1611 public TerminalNode Identifier(int i) {
1612 return getToken(ManifestParser.Identifier, i);
1613 }
1614 public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
1615 public TerminalNode WS(int i) {
1616 return getToken(ManifestParser.WS, i);
1617 }
1618 public List<TerminalNode> ANYCHAR() { return getTokens(ManifestParser.ANYCHAR); }
1619 public TerminalNode ANYCHAR(int i) {
1620 return getToken(ManifestParser.ANYCHAR, i);
1621 }
1622 public AnythingContext(ParserRuleContext parent, int invokingState) {
1623 super(parent, invokingState);
1624 }
1625 @Override public int getRuleIndex() { return RULE_anything; }
1626 @Override
1627 public void enterRule(ParseTreeListener listener) {
1628 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterAnything(this);
1629 }
1630 @Override
1631 public void exitRule(ParseTreeListener listener) {
1632 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitAnything(this);
1633 }
1634 }
1635
1636 public final AnythingContext anything() throws RecognitionException {
1637 AnythingContext _localctx = new AnythingContext(_ctx, getState());
1638 enterRule(_localctx, 36, RULE_anything);
1639 int _la;
1640 try {
1641 enterOuterAlt(_localctx, 1);
1642 {
1643 setState(272);
1644 _errHandler.sync(this);
1645 _la = _input.LA(1);
1646 do {
1647 {
1648 {
1649 setState(271);
1650 _la = _input.LA(1);
1651 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__5) | (1L << T__8) | (1L << T__9) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << Alpha) | (1L << AlphaNum) | (1L << Number) | (1L << Digit) | (1L << Path) | (1L << Extended) | (1L << QuotedString) | (1L << WS) | (1L << UniqueName) | (1L << Identifier) | (1L << ANYCHAR))) != 0)) ) {
1652 _errHandler.recoverInline(this);
1653 }
1654 else {
1655 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1656 _errHandler.reportMatch(this);
1657 consume();
1658 }
1659 }
1660 }
1661 setState(274);
1662 _errHandler.sync(this);
1663 _la = _input.LA(1);
1664 } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__5) | (1L << T__8) | (1L << T__9) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << Alpha) | (1L << AlphaNum) | (1L << Number) | (1L << Digit) | (1L << Path) | (1L << Extended) | (1L << QuotedString) | (1L << WS) | (1L << UniqueName) | (1L << Identifier) | (1L << ANYCHAR))) != 0) );
1665 }
1666 }
1667 catch (RecognitionException re) {
1668 _localctx.exception = re;
1669 _errHandler.reportError(this, re);
1670 _errHandler.recover(this, re);
1671 }
1672 finally {
1673 exitRule();
1674 }
1675 return _localctx;
1676 }
1677
1678 public static class GenericManifestEntryContext extends ParserRuleContext {
1679 public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
1680 public AnythingContext anything() {
1681 return getRuleContext(AnythingContext.class,0);
1682 }
1683 public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
1684 public GenericManifestEntryContext(ParserRuleContext parent, int invokingState) {
1685 super(parent, invokingState);
1686 }
1687 @Override public int getRuleIndex() { return RULE_genericManifestEntry; }
1688 @Override
1689 public void enterRule(ParseTreeListener listener) {
1690 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterGenericManifestEntry(this);
1691 }
1692 @Override
1693 public void exitRule(ParseTreeListener listener) {
1694 if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitGenericManifestEntry(this);
1695 }
1696 }
1697
1698 public final GenericManifestEntryContext genericManifestEntry() throws RecognitionException {
1699 GenericManifestEntryContext _localctx = new GenericManifestEntryContext(_ctx, getState());
1700 enterRule(_localctx, 38, RULE_genericManifestEntry);
1701 try {
1702 enterOuterAlt(_localctx, 1);
1703 {
1704 setState(276);
1705 match(Extended);
1706 setState(277);
1707 match(T__1);
1708 setState(278);
1709 anything();
1710 setState(279);
1711 match(NL);
1712 }
1713 }
1714 catch (RecognitionException re) {
1715 _localctx.exception = re;
1716 _errHandler.reportError(this, re);
1717 _errHandler.recover(this, re);
1718 }
1719 finally {
1720 exitRule();
1721 }
1722 return _localctx;
1723 }
1724
1725 public static final String _serializedATN =
1726 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3%\u011c\4\2\t\2\4"+
1727 "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
1728 "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
1729 "\4\23\t\23\4\24\t\24\4\25\t\25\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2"+
1730 "\3\2\3\2\7\2\67\n\2\f\2\16\2:\13\2\3\2\3\2\5\2>\n\2\3\2\7\2A\n\2\f\2\16"+
1731 "\2D\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3"+
1732 "\5\3\5\7\5W\n\5\f\5\16\5Z\13\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\7\6c\n\6\f"+
1733 "\6\16\6f\13\6\3\6\3\6\3\7\6\7k\n\7\r\7\16\7l\3\b\6\bp\n\b\r\b\16\bq\3"+
1734 "\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\7\t|\n\t\f\t\16\t\177\13\t\3\t\6\t\u0082"+
1735 "\n\t\r\t\16\t\u0083\5\t\u0086\n\t\3\t\3\t\3\n\3\n\3\n\7\n\u008d\n\n\f"+
1736 "\n\16\n\u0090\13\n\3\n\7\n\u0093\n\n\f\n\16\n\u0096\13\n\3\n\3\n\3\n\7"+
1737 "\n\u009b\n\n\f\n\16\n\u009e\13\n\3\n\6\n\u00a1\n\n\r\n\16\n\u00a2\3\n"+
1738 "\3\n\7\n\u00a7\n\n\f\n\16\n\u00aa\13\n\5\n\u00ac\n\n\3\13\6\13\u00af\n"+
1739 "\13\r\13\16\13\u00b0\3\13\3\13\3\13\5\13\u00b6\n\13\3\f\3\f\3\f\3\f\3"+
1740 "\f\7\f\u00bd\n\f\f\f\16\f\u00c0\13\f\3\f\6\f\u00c3\n\f\r\f\16\f\u00c4"+
1741 "\5\f\u00c7\n\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\7\r\u00d0\n\r\f\r\16\r\u00d3"+
1742 "\13\r\3\r\6\r\u00d6\n\r\r\r\16\r\u00d7\5\r\u00da\n\r\3\r\3\r\3\16\3\16"+
1743 "\3\16\7\16\u00e1\n\16\f\16\16\16\u00e4\13\16\3\16\7\16\u00e7\n\16\f\16"+
1744 "\16\16\u00ea\13\16\3\16\3\16\3\16\7\16\u00ef\n\16\f\16\16\16\u00f2\13"+
1745 "\16\3\16\6\16\u00f5\n\16\r\16\16\16\u00f6\3\16\3\16\7\16\u00fb\n\16\f"+
1746 "\16\16\16\u00fe\13\16\5\16\u0100\n\16\3\17\3\17\3\20\3\20\5\20\u0106\n"+
1747 "\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\24\6\24\u0113"+
1748 "\n\24\r\24\16\24\u0114\3\25\3\25\3\25\3\25\3\25\3\25\7\u0094\u00a2\u00b0"+
1749 "\u00e8\u00f6\2\26\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(\2\6\3\2"+
1750 "\33\35\4\2\37\37##\4\2\33\33\37 \6\2\b\b\13\f\17 \"%\2\u012f\2*\3\2\2"+
1751 "\2\4G\3\2\2\2\6L\3\2\2\2\bQ\3\2\2\2\n]\3\2\2\2\fj\3\2\2\2\16o\3\2\2\2"+
1752 "\20u\3\2\2\2\22\u00ab\3\2\2\2\24\u00b5\3\2\2\2\26\u00b7\3\2\2\2\30\u00ca"+
1753 "\3\2\2\2\32\u00ff\3\2\2\2\34\u0101\3\2\2\2\36\u0105\3\2\2\2 \u0107\3\2"+
1754 "\2\2\"\u010b\3\2\2\2$\u010f\3\2\2\2&\u0112\3\2\2\2(\u0116\3\2\2\2*+\7"+
1755 "\3\2\2+,\7\4\2\2,-\7\37\2\2-8\7!\2\2.\67\5\26\f\2/\67\5\30\r\2\60\67\5"+
1756 "\b\5\2\61\67\5\4\3\2\62\67\5\6\4\2\63\67\5\n\6\2\64\67\5\20\t\2\65\67"+
1757 "\5(\25\2\66.\3\2\2\2\66/\3\2\2\2\66\60\3\2\2\2\66\61\3\2\2\2\66\62\3\2"+
1758 "\2\2\66\63\3\2\2\2\66\64\3\2\2\2\66\65\3\2\2\2\67:\3\2\2\28\66\3\2\2\2"+
1759 "89\3\2\2\29;\3\2\2\2:8\3\2\2\2;=\7!\2\2<>\5\f\7\2=<\3\2\2\2=>\3\2\2\2"+
1760 ">B\3\2\2\2?A\7!\2\2@?\3\2\2\2AD\3\2\2\2B@\3\2\2\2BC\3\2\2\2CE\3\2\2\2"+
1761 "DB\3\2\2\2EF\7\2\2\3F\3\3\2\2\2GH\7\5\2\2HI\7\4\2\2IJ\t\2\2\2JK\7!\2\2"+
1762 "K\5\3\2\2\2LM\7\6\2\2MN\7\4\2\2NO\t\3\2\2OP\7!\2\2P\7\3\2\2\2QR\7\7\2"+
1763 "\2RS\7\4\2\2SX\7\37\2\2TU\7\b\2\2UW\5\36\20\2VT\3\2\2\2WZ\3\2\2\2XV\3"+
1764 "\2\2\2XY\3\2\2\2Y[\3\2\2\2ZX\3\2\2\2[\\\7!\2\2\\\t\3\2\2\2]^\7\t\2\2^"+
1765 "_\7\4\2\2_d\7\37\2\2`a\7\b\2\2ac\5\36\20\2b`\3\2\2\2cf\3\2\2\2db\3\2\2"+
1766 "\2de\3\2\2\2eg\3\2\2\2fd\3\2\2\2gh\7!\2\2h\13\3\2\2\2ik\5\16\b\2ji\3\2"+
1767 "\2\2kl\3\2\2\2lj\3\2\2\2lm\3\2\2\2m\r\3\2\2\2np\5(\25\2on\3\2\2\2pq\3"+
1768 "\2\2\2qo\3\2\2\2qr\3\2\2\2rs\3\2\2\2st\7!\2\2t\17\3\2\2\2uv\7\n\2\2v\u0085"+
1769 "\7\4\2\2w\u0086\5\22\n\2x\u0081\5\22\n\2y}\7\13\2\2z|\7\"\2\2{z\3\2\2"+
1770 "\2|\177\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\u0080\3\2\2\2\177}\3\2\2\2\u0080"+
1771 "\u0082\5\22\n\2\u0081y\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0081\3\2\2\2"+
1772 "\u0083\u0084\3\2\2\2\u0084\u0086\3\2\2\2\u0085w\3\2\2\2\u0085x\3\2\2\2"+
1773 "\u0086\u0087\3\2\2\2\u0087\u0088\7!\2\2\u0088\21\3\2\2\2\u0089\u0094\5"+
1774 "\24\13\2\u008a\u008e\7\b\2\2\u008b\u008d\7\"\2\2\u008c\u008b\3\2\2\2\u008d"+
1775 "\u0090\3\2\2\2\u008e\u008c\3\2\2\2\u008e\u008f\3\2\2\2\u008f\u0091\3\2"+
1776 "\2\2\u0090\u008e\3\2\2\2\u0091\u0093\5\36\20\2\u0092\u008a\3\2\2\2\u0093"+
1777 "\u0096\3\2\2\2\u0094\u0095\3\2\2\2\u0094\u0092\3\2\2\2\u0095\u00ac\3\2"+
1778 "\2\2\u0096\u0094\3\2\2\2\u0097\u00a0\5\24\13\2\u0098\u009c\7\b\2\2\u0099"+
1779 "\u009b\7\"\2\2\u009a\u0099\3\2\2\2\u009b\u009e\3\2\2\2\u009c\u009a\3\2"+
1780 "\2\2\u009c\u009d\3\2\2\2\u009d\u009f\3\2\2\2\u009e\u009c\3\2\2\2\u009f"+
1781 "\u00a1\5\24\13\2\u00a0\u0098\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\u00a3\3"+
1782 "\2\2\2\u00a2\u00a0\3\2\2\2\u00a3\u00a8\3\2\2\2\u00a4\u00a5\7\b\2\2\u00a5"+
1783 "\u00a7\5\36\20\2\u00a6\u00a4\3\2\2\2\u00a7\u00aa\3\2\2\2\u00a8\u00a6\3"+
1784 "\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00ac\3\2\2\2\u00aa\u00a8\3\2\2\2\u00ab"+
1785 "\u0089\3\2\2\2\u00ab\u0097\3\2\2\2\u00ac\23\3\2\2\2\u00ad\u00af\t\3\2"+
1786 "\2\u00ae\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b0\u00ae"+
1787 "\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b6\7\f\2\2\u00b3\u00b6\5\34\17\2"+
1788 "\u00b4\u00b6\7\f\2\2\u00b5\u00ae\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b4"+
1789 "\3\2\2\2\u00b6\25\3\2\2\2\u00b7\u00c6\7\r\2\2\u00b8\u00c7\5\32\16\2\u00b9"+
1790 "\u00c2\5\32\16\2\u00ba\u00be\7\13\2\2\u00bb\u00bd\7\"\2\2\u00bc\u00bb"+
1791 "\3\2\2\2\u00bd\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf"+
1792 "\u00c1\3\2\2\2\u00c0\u00be\3\2\2\2\u00c1\u00c3\5\32\16\2\u00c2\u00ba\3"+
1793 "\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5"+
1794 "\u00c7\3\2\2\2\u00c6\u00b8\3\2\2\2\u00c6\u00b9\3\2\2\2\u00c7\u00c8\3\2"+
1795 "\2\2\u00c8\u00c9\7!\2\2\u00c9\27\3\2\2\2\u00ca\u00d9\7\16\2\2\u00cb\u00da"+
1796 "\5\32\16\2\u00cc\u00d5\5\32\16\2\u00cd\u00d1\7\13\2\2\u00ce\u00d0\7\""+
1797 "\2\2\u00cf\u00ce\3\2\2\2\u00d0\u00d3\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1"+
1798 "\u00d2\3\2\2\2\u00d2\u00d4\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d4\u00d6\5\32"+
1799 "\16\2\u00d5\u00cd\3\2\2\2\u00d6\u00d7\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d7"+
1800 "\u00d8\3\2\2\2\u00d8\u00da\3\2\2\2\u00d9\u00cb\3\2\2\2\u00d9\u00cc\3\2"+
1801 "\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\7!\2\2\u00dc\31\3\2\2\2\u00dd\u00e8"+
1802 "\5\34\17\2\u00de\u00e2\7\b\2\2\u00df\u00e1\7\"\2\2\u00e0\u00df\3\2\2\2"+
1803 "\u00e1\u00e4\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\u00e5"+
1804 "\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e5\u00e7\5\36\20\2\u00e6\u00de\3\2\2\2"+
1805 "\u00e7\u00ea\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e9\u0100"+
1806 "\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00f4\5\34\17\2\u00ec\u00f0\7\b\2\2"+
1807 "\u00ed\u00ef\7\"\2\2\u00ee\u00ed\3\2\2\2\u00ef\u00f2\3\2\2\2\u00f0\u00ee"+
1808 "\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f3\3\2\2\2\u00f2\u00f0\3\2\2\2\u00f3"+
1809 "\u00f5\5\34\17\2\u00f4\u00ec\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f7\3"+
1810 "\2\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00fc\3\2\2\2\u00f8\u00f9\7\b\2\2\u00f9"+
1811 "\u00fb\5\36\20\2\u00fa\u00f8\3\2\2\2\u00fb\u00fe\3\2\2\2\u00fc\u00fa\3"+
1812 "\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u0100\3\2\2\2\u00fe\u00fc\3\2\2\2\u00ff"+
1813 "\u00dd\3\2\2\2\u00ff\u00eb\3\2\2\2\u0100\33\3\2\2\2\u0101\u0102\t\3\2"+
1814 "\2\u0102\35\3\2\2\2\u0103\u0106\5 \21\2\u0104\u0106\5\"\22\2\u0105\u0103"+
1815 "\3\2\2\2\u0105\u0104\3\2\2\2\u0106\37\3\2\2\2\u0107\u0108\7\37\2\2\u0108"+
1816 "\u0109\7\17\2\2\u0109\u010a\5$\23\2\u010a!\3\2\2\2\u010b\u010c\7\37\2"+
1817 "\2\u010c\u010d\7\20\2\2\u010d\u010e\5$\23\2\u010e#\3\2\2\2\u010f\u0110"+
1818 "\t\4\2\2\u0110%\3\2\2\2\u0111\u0113\t\5\2\2\u0112\u0111\3\2\2\2\u0113"+
1819 "\u0114\3\2\2\2\u0114\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115\'\3\2\2\2"+
1820 "\u0116\u0117\7\37\2\2\u0117\u0118\7\4\2\2\u0118\u0119\5&\24\2\u0119\u011a"+
1821 "\7!\2\2\u011a)\3\2\2\2#\668=BXdlq}\u0083\u0085\u008e\u0094\u009c\u00a2"+
1822 "\u00a8\u00ab\u00b0\u00b5\u00be\u00c4\u00c6\u00d1\u00d7\u00d9\u00e2\u00e8"+
1823 "\u00f0\u00f6\u00fc\u00ff\u0105\u0114";
1824 public static final ATN _ATN =
1825 new ATNDeserializer().deserialize(_serializedATN.toCharArray());
1826 static {
1827 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
1828 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
1829 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
1830 }
1831 }
1832 }