ManifestParser.java
// Generated from io/earcam/instrumental/module/osgi/parser/Manifest.g4 by ANTLR 4.7.1
package io.earcam.instrumental.module.osgi.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
class ManifestParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
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,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, Alpha=24,
AlphaNum=25, Number=26, Digit=27, Path=28, Extended=29, QuotedString=30,
NL=31, WS=32, UniqueName=33, Identifier=34, ANYCHAR=35;
public static final int
RULE_manifest = 0, RULE_bundleManifestVersion = 1, RULE_bundleActivator = 2,
RULE_symbolicName = 3, RULE_fragmentHost = 4, RULE_manifestAttributes = 5,
RULE_manifestAttribute = 6, RULE_dynamicImports = 7, RULE_dynamicDescription = 8,
RULE_wildcardName = 9, RULE_imports = 10, RULE_exports = 11, RULE_port = 12,
RULE_paquet = 13, RULE_parameter = 14, RULE_directive = 15, RULE_attribute = 16,
RULE_argument = 17, RULE_anything = 18, RULE_genericManifestEntry = 19;
public static final String[] ruleNames = {
"manifest", "bundleManifestVersion", "bundleActivator", "symbolicName",
"fragmentHost", "manifestAttributes", "manifestAttribute", "dynamicImports",
"dynamicDescription", "wildcardName", "imports", "exports", "port", "paquet",
"parameter", "directive", "attribute", "argument", "anything", "genericManifestEntry"
};
private static final String[] _LITERAL_NAMES = {
null, "'Manifest-Version'", "': '", "'Bundle-ManifestVersion'", "'Bundle-Activator'",
"'Bundle-SymbolicName'", "';'", "'Fragment-Host'", "'DynamicImport-Package'",
"','", "'*'", "'Import-Package: '", "'Export-Package: '", "':='", "'='",
"'@'", "':'", "'&'", "'('", "')'", "'!'", "'~'", "'+'", "'$'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
"Alpha", "AlphaNum", "Number", "Digit", "Path", "Extended", "QuotedString",
"NL", "WS", "UniqueName", "Identifier", "ANYCHAR"
};
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "<INVALID>";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "Manifest.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public ManifestParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ManifestContext extends ParserRuleContext {
public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
public List<TerminalNode> NL() { return getTokens(ManifestParser.NL); }
public TerminalNode NL(int i) {
return getToken(ManifestParser.NL, i);
}
public TerminalNode EOF() { return getToken(ManifestParser.EOF, 0); }
public List<ImportsContext> imports() {
return getRuleContexts(ImportsContext.class);
}
public ImportsContext imports(int i) {
return getRuleContext(ImportsContext.class,i);
}
public List<ExportsContext> exports() {
return getRuleContexts(ExportsContext.class);
}
public ExportsContext exports(int i) {
return getRuleContext(ExportsContext.class,i);
}
public List<SymbolicNameContext> symbolicName() {
return getRuleContexts(SymbolicNameContext.class);
}
public SymbolicNameContext symbolicName(int i) {
return getRuleContext(SymbolicNameContext.class,i);
}
public List<BundleManifestVersionContext> bundleManifestVersion() {
return getRuleContexts(BundleManifestVersionContext.class);
}
public BundleManifestVersionContext bundleManifestVersion(int i) {
return getRuleContext(BundleManifestVersionContext.class,i);
}
public List<BundleActivatorContext> bundleActivator() {
return getRuleContexts(BundleActivatorContext.class);
}
public BundleActivatorContext bundleActivator(int i) {
return getRuleContext(BundleActivatorContext.class,i);
}
public List<FragmentHostContext> fragmentHost() {
return getRuleContexts(FragmentHostContext.class);
}
public FragmentHostContext fragmentHost(int i) {
return getRuleContext(FragmentHostContext.class,i);
}
public List<DynamicImportsContext> dynamicImports() {
return getRuleContexts(DynamicImportsContext.class);
}
public DynamicImportsContext dynamicImports(int i) {
return getRuleContext(DynamicImportsContext.class,i);
}
public List<GenericManifestEntryContext> genericManifestEntry() {
return getRuleContexts(GenericManifestEntryContext.class);
}
public GenericManifestEntryContext genericManifestEntry(int i) {
return getRuleContext(GenericManifestEntryContext.class,i);
}
public ManifestAttributesContext manifestAttributes() {
return getRuleContext(ManifestAttributesContext.class,0);
}
public ManifestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_manifest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterManifest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitManifest(this);
}
}
public final ManifestContext manifest() throws RecognitionException {
ManifestContext _localctx = new ManifestContext(_ctx, getState());
enterRule(_localctx, 0, RULE_manifest);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(40);
match(T__0);
setState(41);
match(T__1);
setState(42);
match(Extended);
setState(43);
match(NL);
setState(54);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(52);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__10:
{
setState(44);
imports();
}
break;
case T__11:
{
setState(45);
exports();
}
break;
case T__4:
{
setState(46);
symbolicName();
}
break;
case T__2:
{
setState(47);
bundleManifestVersion();
}
break;
case T__3:
{
setState(48);
bundleActivator();
}
break;
case T__6:
{
setState(49);
fragmentHost();
}
break;
case T__7:
{
setState(50);
dynamicImports();
}
break;
case Extended:
{
setState(51);
genericManifestEntry();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(56);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(57);
match(NL);
setState(59);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Extended) {
{
setState(58);
manifestAttributes();
}
}
setState(64);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(61);
match(NL);
}
}
setState(66);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(67);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BundleManifestVersionContext extends ParserRuleContext {
public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
public TerminalNode Number() { return getToken(ManifestParser.Number, 0); }
public TerminalNode AlphaNum() { return getToken(ManifestParser.AlphaNum, 0); }
public TerminalNode Digit() { return getToken(ManifestParser.Digit, 0); }
public BundleManifestVersionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bundleManifestVersion; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterBundleManifestVersion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitBundleManifestVersion(this);
}
}
public final BundleManifestVersionContext bundleManifestVersion() throws RecognitionException {
BundleManifestVersionContext _localctx = new BundleManifestVersionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_bundleManifestVersion);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(69);
match(T__2);
setState(70);
match(T__1);
setState(71);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AlphaNum) | (1L << Number) | (1L << Digit))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(72);
match(NL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BundleActivatorContext extends ParserRuleContext {
public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
public TerminalNode UniqueName() { return getToken(ManifestParser.UniqueName, 0); }
public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
public BundleActivatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bundleActivator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterBundleActivator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitBundleActivator(this);
}
}
public final BundleActivatorContext bundleActivator() throws RecognitionException {
BundleActivatorContext _localctx = new BundleActivatorContext(_ctx, getState());
enterRule(_localctx, 4, RULE_bundleActivator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(74);
match(T__3);
setState(75);
match(T__1);
setState(76);
_la = _input.LA(1);
if ( !(_la==Extended || _la==UniqueName) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(77);
match(NL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SymbolicNameContext extends ParserRuleContext {
public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
public List<ParameterContext> parameter() {
return getRuleContexts(ParameterContext.class);
}
public ParameterContext parameter(int i) {
return getRuleContext(ParameterContext.class,i);
}
public SymbolicNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_symbolicName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterSymbolicName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitSymbolicName(this);
}
}
public final SymbolicNameContext symbolicName() throws RecognitionException {
SymbolicNameContext _localctx = new SymbolicNameContext(_ctx, getState());
enterRule(_localctx, 6, RULE_symbolicName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(79);
match(T__4);
setState(80);
match(T__1);
setState(81);
match(Extended);
setState(86);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(82);
match(T__5);
setState(83);
parameter();
}
}
setState(88);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(89);
match(NL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FragmentHostContext extends ParserRuleContext {
public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
public List<ParameterContext> parameter() {
return getRuleContexts(ParameterContext.class);
}
public ParameterContext parameter(int i) {
return getRuleContext(ParameterContext.class,i);
}
public FragmentHostContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fragmentHost; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterFragmentHost(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitFragmentHost(this);
}
}
public final FragmentHostContext fragmentHost() throws RecognitionException {
FragmentHostContext _localctx = new FragmentHostContext(_ctx, getState());
enterRule(_localctx, 8, RULE_fragmentHost);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(91);
match(T__6);
setState(92);
match(T__1);
setState(93);
match(Extended);
setState(98);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(94);
match(T__5);
setState(95);
parameter();
}
}
setState(100);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(101);
match(NL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ManifestAttributesContext extends ParserRuleContext {
public List<ManifestAttributeContext> manifestAttribute() {
return getRuleContexts(ManifestAttributeContext.class);
}
public ManifestAttributeContext manifestAttribute(int i) {
return getRuleContext(ManifestAttributeContext.class,i);
}
public ManifestAttributesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_manifestAttributes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterManifestAttributes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitManifestAttributes(this);
}
}
public final ManifestAttributesContext manifestAttributes() throws RecognitionException {
ManifestAttributesContext _localctx = new ManifestAttributesContext(_ctx, getState());
enterRule(_localctx, 10, RULE_manifestAttributes);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(104);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(103);
manifestAttribute();
}
}
setState(106);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Extended );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ManifestAttributeContext extends ParserRuleContext {
public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
public List<GenericManifestEntryContext> genericManifestEntry() {
return getRuleContexts(GenericManifestEntryContext.class);
}
public GenericManifestEntryContext genericManifestEntry(int i) {
return getRuleContext(GenericManifestEntryContext.class,i);
}
public ManifestAttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_manifestAttribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterManifestAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitManifestAttribute(this);
}
}
public final ManifestAttributeContext manifestAttribute() throws RecognitionException {
ManifestAttributeContext _localctx = new ManifestAttributeContext(_ctx, getState());
enterRule(_localctx, 12, RULE_manifestAttribute);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(109);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(108);
genericManifestEntry();
}
}
setState(111);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Extended );
setState(113);
match(NL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DynamicImportsContext extends ParserRuleContext {
public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
public List<DynamicDescriptionContext> dynamicDescription() {
return getRuleContexts(DynamicDescriptionContext.class);
}
public DynamicDescriptionContext dynamicDescription(int i) {
return getRuleContext(DynamicDescriptionContext.class,i);
}
public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
public TerminalNode WS(int i) {
return getToken(ManifestParser.WS, i);
}
public DynamicImportsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dynamicImports; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterDynamicImports(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitDynamicImports(this);
}
}
public final DynamicImportsContext dynamicImports() throws RecognitionException {
DynamicImportsContext _localctx = new DynamicImportsContext(_ctx, getState());
enterRule(_localctx, 14, RULE_dynamicImports);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(115);
match(T__7);
setState(116);
match(T__1);
setState(131);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(117);
dynamicDescription();
}
break;
case 2:
{
setState(118);
dynamicDescription();
setState(127);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(119);
match(T__8);
setState(123);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WS) {
{
{
setState(120);
match(WS);
}
}
setState(125);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(126);
dynamicDescription();
}
}
setState(129);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__8 );
}
break;
}
setState(133);
match(NL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DynamicDescriptionContext extends ParserRuleContext {
public List<WildcardNameContext> wildcardName() {
return getRuleContexts(WildcardNameContext.class);
}
public WildcardNameContext wildcardName(int i) {
return getRuleContext(WildcardNameContext.class,i);
}
public List<ParameterContext> parameter() {
return getRuleContexts(ParameterContext.class);
}
public ParameterContext parameter(int i) {
return getRuleContext(ParameterContext.class,i);
}
public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
public TerminalNode WS(int i) {
return getToken(ManifestParser.WS, i);
}
public DynamicDescriptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dynamicDescription; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterDynamicDescription(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitDynamicDescription(this);
}
}
public final DynamicDescriptionContext dynamicDescription() throws RecognitionException {
DynamicDescriptionContext _localctx = new DynamicDescriptionContext(_ctx, getState());
enterRule(_localctx, 16, RULE_dynamicDescription);
int _la;
try {
int _alt;
setState(169);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(135);
wildcardName();
setState(146);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(136);
match(T__5);
setState(140);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WS) {
{
{
setState(137);
match(WS);
}
}
setState(142);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(143);
parameter();
}
}
}
setState(148);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(149);
wildcardName();
setState(158);
_errHandler.sync(this);
_alt = 1+1;
do {
switch (_alt) {
case 1+1:
{
{
setState(150);
match(T__5);
setState(154);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WS) {
{
{
setState(151);
match(WS);
}
}
setState(156);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(157);
wildcardName();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(160);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(166);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(162);
match(T__5);
setState(163);
parameter();
}
}
setState(168);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WildcardNameContext extends ParserRuleContext {
public List<TerminalNode> UniqueName() { return getTokens(ManifestParser.UniqueName); }
public TerminalNode UniqueName(int i) {
return getToken(ManifestParser.UniqueName, i);
}
public List<TerminalNode> Extended() { return getTokens(ManifestParser.Extended); }
public TerminalNode Extended(int i) {
return getToken(ManifestParser.Extended, i);
}
public PaquetContext paquet() {
return getRuleContext(PaquetContext.class,0);
}
public WildcardNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_wildcardName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterWildcardName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitWildcardName(this);
}
}
public final WildcardNameContext wildcardName() throws RecognitionException {
WildcardNameContext _localctx = new WildcardNameContext(_ctx, getState());
enterRule(_localctx, 18, RULE_wildcardName);
int _la;
try {
int _alt;
setState(179);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(172);
_errHandler.sync(this);
_alt = 1+1;
do {
switch (_alt) {
case 1+1:
{
{
setState(171);
_la = _input.LA(1);
if ( !(_la==Extended || _la==UniqueName) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(174);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(176);
match(T__9);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(177);
paquet();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(178);
match(T__9);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportsContext extends ParserRuleContext {
public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
public List<PortContext> port() {
return getRuleContexts(PortContext.class);
}
public PortContext port(int i) {
return getRuleContext(PortContext.class,i);
}
public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
public TerminalNode WS(int i) {
return getToken(ManifestParser.WS, i);
}
public ImportsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_imports; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterImports(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitImports(this);
}
}
public final ImportsContext imports() throws RecognitionException {
ImportsContext _localctx = new ImportsContext(_ctx, getState());
enterRule(_localctx, 20, RULE_imports);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(181);
match(T__10);
setState(196);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(182);
port();
}
break;
case 2:
{
setState(183);
port();
setState(192);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(184);
match(T__8);
setState(188);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WS) {
{
{
setState(185);
match(WS);
}
}
setState(190);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(191);
port();
}
}
setState(194);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__8 );
}
break;
}
setState(198);
match(NL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExportsContext extends ParserRuleContext {
public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
public List<PortContext> port() {
return getRuleContexts(PortContext.class);
}
public PortContext port(int i) {
return getRuleContext(PortContext.class,i);
}
public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
public TerminalNode WS(int i) {
return getToken(ManifestParser.WS, i);
}
public ExportsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exports; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterExports(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitExports(this);
}
}
public final ExportsContext exports() throws RecognitionException {
ExportsContext _localctx = new ExportsContext(_ctx, getState());
enterRule(_localctx, 22, RULE_exports);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(200);
match(T__11);
setState(215);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(201);
port();
}
break;
case 2:
{
setState(202);
port();
setState(211);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(203);
match(T__8);
setState(207);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WS) {
{
{
setState(204);
match(WS);
}
}
setState(209);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(210);
port();
}
}
setState(213);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__8 );
}
break;
}
setState(217);
match(NL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PortContext extends ParserRuleContext {
public List<PaquetContext> paquet() {
return getRuleContexts(PaquetContext.class);
}
public PaquetContext paquet(int i) {
return getRuleContext(PaquetContext.class,i);
}
public List<ParameterContext> parameter() {
return getRuleContexts(ParameterContext.class);
}
public ParameterContext parameter(int i) {
return getRuleContext(ParameterContext.class,i);
}
public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
public TerminalNode WS(int i) {
return getToken(ManifestParser.WS, i);
}
public PortContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_port; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterPort(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitPort(this);
}
}
public final PortContext port() throws RecognitionException {
PortContext _localctx = new PortContext(_ctx, getState());
enterRule(_localctx, 24, RULE_port);
int _la;
try {
int _alt;
setState(253);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(219);
paquet();
setState(230);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(220);
match(T__5);
setState(224);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WS) {
{
{
setState(221);
match(WS);
}
}
setState(226);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(227);
parameter();
}
}
}
setState(232);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(233);
paquet();
setState(242);
_errHandler.sync(this);
_alt = 1+1;
do {
switch (_alt) {
case 1+1:
{
{
setState(234);
match(T__5);
setState(238);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WS) {
{
{
setState(235);
match(WS);
}
}
setState(240);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(241);
paquet();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(244);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(250);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(246);
match(T__5);
setState(247);
parameter();
}
}
setState(252);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PaquetContext extends ParserRuleContext {
public TerminalNode UniqueName() { return getToken(ManifestParser.UniqueName, 0); }
public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
public PaquetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_paquet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterPaquet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitPaquet(this);
}
}
public final PaquetContext paquet() throws RecognitionException {
PaquetContext _localctx = new PaquetContext(_ctx, getState());
enterRule(_localctx, 26, RULE_paquet);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(255);
_la = _input.LA(1);
if ( !(_la==Extended || _la==UniqueName) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterContext extends ParserRuleContext {
public DirectiveContext directive() {
return getRuleContext(DirectiveContext.class,0);
}
public AttributeContext attribute() {
return getRuleContext(AttributeContext.class,0);
}
public ParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitParameter(this);
}
}
public final ParameterContext parameter() throws RecognitionException {
ParameterContext _localctx = new ParameterContext(_ctx, getState());
enterRule(_localctx, 28, RULE_parameter);
try {
setState(259);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(257);
directive();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(258);
attribute();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DirectiveContext extends ParserRuleContext {
public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
public ArgumentContext argument() {
return getRuleContext(ArgumentContext.class,0);
}
public DirectiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_directive; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterDirective(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitDirective(this);
}
}
public final DirectiveContext directive() throws RecognitionException {
DirectiveContext _localctx = new DirectiveContext(_ctx, getState());
enterRule(_localctx, 30, RULE_directive);
try {
enterOuterAlt(_localctx, 1);
{
setState(261);
match(Extended);
setState(262);
match(T__12);
setState(263);
argument();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeContext extends ParserRuleContext {
public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
public ArgumentContext argument() {
return getRuleContext(ArgumentContext.class,0);
}
public AttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitAttribute(this);
}
}
public final AttributeContext attribute() throws RecognitionException {
AttributeContext _localctx = new AttributeContext(_ctx, getState());
enterRule(_localctx, 32, RULE_attribute);
try {
enterOuterAlt(_localctx, 1);
{
setState(265);
match(Extended);
setState(266);
match(T__13);
setState(267);
argument();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentContext extends ParserRuleContext {
public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
public TerminalNode QuotedString() { return getToken(ManifestParser.QuotedString, 0); }
public TerminalNode AlphaNum() { return getToken(ManifestParser.AlphaNum, 0); }
public ArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitArgument(this);
}
}
public final ArgumentContext argument() throws RecognitionException {
ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
enterRule(_localctx, 34, RULE_argument);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(269);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AlphaNum) | (1L << Extended) | (1L << QuotedString))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnythingContext extends ParserRuleContext {
public List<TerminalNode> Alpha() { return getTokens(ManifestParser.Alpha); }
public TerminalNode Alpha(int i) {
return getToken(ManifestParser.Alpha, i);
}
public List<TerminalNode> AlphaNum() { return getTokens(ManifestParser.AlphaNum); }
public TerminalNode AlphaNum(int i) {
return getToken(ManifestParser.AlphaNum, i);
}
public List<TerminalNode> Digit() { return getTokens(ManifestParser.Digit); }
public TerminalNode Digit(int i) {
return getToken(ManifestParser.Digit, i);
}
public List<TerminalNode> Number() { return getTokens(ManifestParser.Number); }
public TerminalNode Number(int i) {
return getToken(ManifestParser.Number, i);
}
public List<TerminalNode> Path() { return getTokens(ManifestParser.Path); }
public TerminalNode Path(int i) {
return getToken(ManifestParser.Path, i);
}
public List<TerminalNode> Extended() { return getTokens(ManifestParser.Extended); }
public TerminalNode Extended(int i) {
return getToken(ManifestParser.Extended, i);
}
public List<TerminalNode> QuotedString() { return getTokens(ManifestParser.QuotedString); }
public TerminalNode QuotedString(int i) {
return getToken(ManifestParser.QuotedString, i);
}
public List<TerminalNode> UniqueName() { return getTokens(ManifestParser.UniqueName); }
public TerminalNode UniqueName(int i) {
return getToken(ManifestParser.UniqueName, i);
}
public List<TerminalNode> Identifier() { return getTokens(ManifestParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(ManifestParser.Identifier, i);
}
public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
public TerminalNode WS(int i) {
return getToken(ManifestParser.WS, i);
}
public List<TerminalNode> ANYCHAR() { return getTokens(ManifestParser.ANYCHAR); }
public TerminalNode ANYCHAR(int i) {
return getToken(ManifestParser.ANYCHAR, i);
}
public AnythingContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_anything; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterAnything(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitAnything(this);
}
}
public final AnythingContext anything() throws RecognitionException {
AnythingContext _localctx = new AnythingContext(_ctx, getState());
enterRule(_localctx, 36, RULE_anything);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(272);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(271);
_la = _input.LA(1);
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)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(274);
_errHandler.sync(this);
_la = _input.LA(1);
} 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) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GenericManifestEntryContext extends ParserRuleContext {
public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
public AnythingContext anything() {
return getRuleContext(AnythingContext.class,0);
}
public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
public GenericManifestEntryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericManifestEntry; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterGenericManifestEntry(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitGenericManifestEntry(this);
}
}
public final GenericManifestEntryContext genericManifestEntry() throws RecognitionException {
GenericManifestEntryContext _localctx = new GenericManifestEntryContext(_ctx, getState());
enterRule(_localctx, 38, RULE_genericManifestEntry);
try {
enterOuterAlt(_localctx, 1);
{
setState(276);
match(Extended);
setState(277);
match(T__1);
setState(278);
anything();
setState(279);
match(NL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3%\u011c\4\2\t\2\4"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\3\16\7\16\u00e1\n\16\f\16\16\16\u00e4\13\16\3\16\7\16\u00e7\n\16\f\16"+
"\16\16\u00ea\13\16\3\16\3\16\3\16\7\16\u00ef\n\16\f\16\16\16\u00f2\13"+
"\16\3\16\6\16\u00f5\n\16\r\16\16\16\u00f6\3\16\3\16\7\16\u00fb\n\16\f"+
"\16\16\16\u00fe\13\16\5\16\u0100\n\16\3\17\3\17\3\20\3\20\5\20\u0106\n"+
"\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"+
"\n\24\r\24\16\24\u0114\3\25\3\25\3\25\3\25\3\25\3\25\7\u0094\u00a2\u00b0"+
"\u00e8\u00f6\2\26\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(\2\6\3\2"+
"\33\35\4\2\37\37##\4\2\33\33\37 \6\2\b\b\13\f\17 \"%\2\u012f\2*\3\2\2"+
"\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"+
"\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"+
"\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"+
"\2\2\"\u010b\3\2\2\2$\u010f\3\2\2\2&\u0112\3\2\2\2(\u0116\3\2\2\2*+\7"+
"\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"+
"\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"+
"\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"+
"\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"+
"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"+
">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"+
"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"+
"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"+
"\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"+
"\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^"+
"_\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\u0082\5\22\n\2\u0081y\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0081\3\2\2\2"+
"\u0083\u0084\3\2\2\2\u0084\u0086\3\2\2\2\u0085w\3\2\2\2\u0085x\3\2\2\2"+
"\u0086\u0087\3\2\2\2\u0087\u0088\7!\2\2\u0088\21\3\2\2\2\u0089\u0094\5"+
"\24\13\2\u008a\u008e\7\b\2\2\u008b\u008d\7\"\2\2\u008c\u008b\3\2\2\2\u008d"+
"\u0090\3\2\2\2\u008e\u008c\3\2\2\2\u008e\u008f\3\2\2\2\u008f\u0091\3\2"+
"\2\2\u0090\u008e\3\2\2\2\u0091\u0093\5\36\20\2\u0092\u008a\3\2\2\2\u0093"+
"\u0096\3\2\2\2\u0094\u0095\3\2\2\2\u0094\u0092\3\2\2\2\u0095\u00ac\3\2"+
"\2\2\u0096\u0094\3\2\2\2\u0097\u00a0\5\24\13\2\u0098\u009c\7\b\2\2\u0099"+
"\u009b\7\"\2\2\u009a\u0099\3\2\2\2\u009b\u009e\3\2\2\2\u009c\u009a\3\2"+
"\2\2\u009c\u009d\3\2\2\2\u009d\u009f\3\2\2\2\u009e\u009c\3\2\2\2\u009f"+
"\u00a1\5\24\13\2\u00a0\u0098\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\u00a3\3"+
"\2\2\2\u00a2\u00a0\3\2\2\2\u00a3\u00a8\3\2\2\2\u00a4\u00a5\7\b\2\2\u00a5"+
"\u00a7\5\36\20\2\u00a6\u00a4\3\2\2\2\u00a7\u00aa\3\2\2\2\u00a8\u00a6\3"+
"\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00ac\3\2\2\2\u00aa\u00a8\3\2\2\2\u00ab"+
"\u0089\3\2\2\2\u00ab\u0097\3\2\2\2\u00ac\23\3\2\2\2\u00ad\u00af\t\3\2"+
"\2\u00ae\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b0\u00ae"+
"\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b6\7\f\2\2\u00b3\u00b6\5\34\17\2"+
"\u00b4\u00b6\7\f\2\2\u00b5\u00ae\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b4"+
"\3\2\2\2\u00b6\25\3\2\2\2\u00b7\u00c6\7\r\2\2\u00b8\u00c7\5\32\16\2\u00b9"+
"\u00c2\5\32\16\2\u00ba\u00be\7\13\2\2\u00bb\u00bd\7\"\2\2\u00bc\u00bb"+
"\3\2\2\2\u00bd\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf"+
"\u00c1\3\2\2\2\u00c0\u00be\3\2\2\2\u00c1\u00c3\5\32\16\2\u00c2\u00ba\3"+
"\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5"+
"\u00c7\3\2\2\2\u00c6\u00b8\3\2\2\2\u00c6\u00b9\3\2\2\2\u00c7\u00c8\3\2"+
"\2\2\u00c8\u00c9\7!\2\2\u00c9\27\3\2\2\2\u00ca\u00d9\7\16\2\2\u00cb\u00da"+
"\5\32\16\2\u00cc\u00d5\5\32\16\2\u00cd\u00d1\7\13\2\2\u00ce\u00d0\7\""+
"\2\2\u00cf\u00ce\3\2\2\2\u00d0\u00d3\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1"+
"\u00d2\3\2\2\2\u00d2\u00d4\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d4\u00d6\5\32"+
"\16\2\u00d5\u00cd\3\2\2\2\u00d6\u00d7\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d7"+
"\u00d8\3\2\2\2\u00d8\u00da\3\2\2\2\u00d9\u00cb\3\2\2\2\u00d9\u00cc\3\2"+
"\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\7!\2\2\u00dc\31\3\2\2\2\u00dd\u00e8"+
"\5\34\17\2\u00de\u00e2\7\b\2\2\u00df\u00e1\7\"\2\2\u00e0\u00df\3\2\2\2"+
"\u00e1\u00e4\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\u00e5"+
"\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e5\u00e7\5\36\20\2\u00e6\u00de\3\2\2\2"+
"\u00e7\u00ea\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e9\u0100"+
"\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00f4\5\34\17\2\u00ec\u00f0\7\b\2\2"+
"\u00ed\u00ef\7\"\2\2\u00ee\u00ed\3\2\2\2\u00ef\u00f2\3\2\2\2\u00f0\u00ee"+
"\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f3\3\2\2\2\u00f2\u00f0\3\2\2\2\u00f3"+
"\u00f5\5\34\17\2\u00f4\u00ec\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f7\3"+
"\2\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00fc\3\2\2\2\u00f8\u00f9\7\b\2\2\u00f9"+
"\u00fb\5\36\20\2\u00fa\u00f8\3\2\2\2\u00fb\u00fe\3\2\2\2\u00fc\u00fa\3"+
"\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u0100\3\2\2\2\u00fe\u00fc\3\2\2\2\u00ff"+
"\u00dd\3\2\2\2\u00ff\u00eb\3\2\2\2\u0100\33\3\2\2\2\u0101\u0102\t\3\2"+
"\2\u0102\35\3\2\2\2\u0103\u0106\5 \21\2\u0104\u0106\5\"\22\2\u0105\u0103"+
"\3\2\2\2\u0105\u0104\3\2\2\2\u0106\37\3\2\2\2\u0107\u0108\7\37\2\2\u0108"+
"\u0109\7\17\2\2\u0109\u010a\5$\23\2\u010a!\3\2\2\2\u010b\u010c\7\37\2"+
"\2\u010c\u010d\7\20\2\2\u010d\u010e\5$\23\2\u010e#\3\2\2\2\u010f\u0110"+
"\t\4\2\2\u0110%\3\2\2\2\u0111\u0113\t\5\2\2\u0112\u0111\3\2\2\2\u0113"+
"\u0114\3\2\2\2\u0114\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115\'\3\2\2\2"+
"\u0116\u0117\7\37\2\2\u0117\u0118\7\4\2\2\u0118\u0119\5&\24\2\u0119\u011a"+
"\7!\2\2\u011a)\3\2\2\2#\668=BXdlq}\u0083\u0085\u008e\u0094\u009c\u00a2"+
"\u00a8\u00ab\u00b0\u00b5\u00be\u00c4\u00c6\u00d1\u00d7\u00d9\u00e2\u00e8"+
"\u00f0\u00f6\u00fc\u00ff\u0105\u0114";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}