de.sayayi.lib.message.parser.MessageParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of message-format Show documentation
Show all versions of message-format Show documentation
Highly configurable message format library supporting message definition through annotations
The newest version!
// Generated from MessageParser.g4 by ANTLR 4.13.2
package de.sayayi.lib.message.parser;
import de.sayayi.lib.message.Message;
import de.sayayi.lib.message.part.TemplatePart;
import de.sayayi.lib.message.part.TextPart;
import de.sayayi.lib.message.part.parameter.ParameterPart;
import de.sayayi.lib.message.part.parameter.key.ConfigKey;
import de.sayayi.lib.message.part.parameter.key.ConfigKeyName;
import de.sayayi.lib.message.part.parameter.value.ConfigValue;
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", "CheckReturnValue", "this-escape"})
public class MessageParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
SQ_START=1, DQ_START=2, COMMA=3, COLON=4, BOOL=5, NUMBER=6, NAME=7, EQ=8,
L_PAREN=9, R_PAREN=10, P_START=11, TPL_START=12, CH=13, CTRL_CHAR=14,
SQ_END=15, CTRL_CHAR1=16, DQ_END=17, CTRL_CHAR2=18, P_END=19, NULL=20,
EMPTY=21, P_WS=22, NE=23, LT=24, LTE=25, GT=26, GTE=27, TPL_END=28, T_WS=29,
P_COMMA=30, P_COLON=31, P_EQ=32, P_L_PAREN=33, P_R_PAREN=34;
public static final int
RULE_message = 0, RULE_message0 = 1, RULE_textPart = 2, RULE_text = 3,
RULE_quotedMessage = 4, RULE_quotedString = 5, RULE_simpleString = 6,
RULE_forceQuotedMessage = 7, RULE_parameterPart = 8, RULE_parameterConfigElement = 9,
RULE_templatePart = 10, RULE_templateParameterDelegate = 11, RULE_configMapElement = 12,
RULE_configNamedElement = 13, RULE_configMapKeys = 14, RULE_configMapKey = 15,
RULE_relationalOperatorOptional = 16, RULE_relationalOperator = 17, RULE_equalOperatorOptional = 18,
RULE_equalOperator = 19, RULE_nameOrKeyword = 20;
private static String[] makeRuleNames() {
return new String[] {
"message", "message0", "textPart", "text", "quotedMessage", "quotedString",
"simpleString", "forceQuotedMessage", "parameterPart", "parameterConfigElement",
"templatePart", "templateParameterDelegate", "configMapElement", "configNamedElement",
"configMapKeys", "configMapKey", "relationalOperatorOptional", "relationalOperator",
"equalOperatorOptional", "equalOperator", "nameOrKeyword"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, "'''", null, "'\"'", null, "'}'", "'null'", "'empty'",
null, null, "'<'", "'<='", "'>'", "'>='", "']'", null, null, null, null,
"'('", "')'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "SQ_START", "DQ_START", "COMMA", "COLON", "BOOL", "NUMBER", "NAME",
"EQ", "L_PAREN", "R_PAREN", "P_START", "TPL_START", "CH", "CTRL_CHAR",
"SQ_END", "CTRL_CHAR1", "DQ_END", "CTRL_CHAR2", "P_END", "NULL", "EMPTY",
"P_WS", "NE", "LT", "LTE", "GT", "GTE", "TPL_END", "T_WS", "P_COMMA",
"P_COLON", "P_EQ", "P_L_PAREN", "P_R_PAREN"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
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] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "MessageParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public MessageParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class MessageContext extends ParserRuleContext {
public Message.WithSpaces messageWithSpaces;
public Message0Context message0() {
return getRuleContext(Message0Context.class,0);
}
public TerminalNode EOF() { return getToken(MessageParser.EOF, 0); }
public MessageContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_message; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterMessage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitMessage(this);
}
}
public final MessageContext message() throws RecognitionException {
MessageContext _localctx = new MessageContext(_ctx, getState());
enterRule(_localctx, 0, RULE_message);
try {
enterOuterAlt(_localctx, 1);
{
setState(42);
message0();
setState(43);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Message0Context extends ParserRuleContext {
public Message.WithSpaces messageWithSpaces;
public List textPart() {
return getRuleContexts(TextPartContext.class);
}
public TextPartContext textPart(int i) {
return getRuleContext(TextPartContext.class,i);
}
public List parameterPart() {
return getRuleContexts(ParameterPartContext.class);
}
public ParameterPartContext parameterPart(int i) {
return getRuleContext(ParameterPartContext.class,i);
}
public List templatePart() {
return getRuleContexts(TemplatePartContext.class);
}
public TemplatePartContext templatePart(int i) {
return getRuleContext(TemplatePartContext.class,i);
}
public Message0Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_message0; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterMessage0(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitMessage0(this);
}
}
public final Message0Context message0() throws RecognitionException {
Message0Context _localctx = new Message0Context(_ctx, getState());
enterRule(_localctx, 2, RULE_message0);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(50);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 14336L) != 0)) {
{
setState(48);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CH:
{
setState(45);
textPart();
}
break;
case P_START:
{
setState(46);
parameterPart();
}
break;
case TPL_START:
{
setState(47);
templatePart();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(52);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TextPartContext extends ParserRuleContext {
public TextPart part;
public TextContext text() {
return getRuleContext(TextContext.class,0);
}
public TextPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_textPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterTextPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitTextPart(this);
}
}
public final TextPartContext textPart() throws RecognitionException {
TextPartContext _localctx = new TextPartContext(_ctx, getState());
enterRule(_localctx, 4, RULE_textPart);
try {
enterOuterAlt(_localctx, 1);
{
setState(53);
text();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TextContext extends ParserRuleContext {
public String characters;
public List CH() { return getTokens(MessageParser.CH); }
public TerminalNode CH(int i) {
return getToken(MessageParser.CH, i);
}
public TextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_text; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterText(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitText(this);
}
}
public final TextContext text() throws RecognitionException {
TextContext _localctx = new TextContext(_ctx, getState());
enterRule(_localctx, 6, RULE_text);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(56);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(55);
match(CH);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(58);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QuotedMessageContext extends ParserRuleContext {
public Message.WithSpaces messageWithSpaces;
public TerminalNode SQ_START() { return getToken(MessageParser.SQ_START, 0); }
public Message0Context message0() {
return getRuleContext(Message0Context.class,0);
}
public TerminalNode SQ_END() { return getToken(MessageParser.SQ_END, 0); }
public TerminalNode DQ_START() { return getToken(MessageParser.DQ_START, 0); }
public TerminalNode DQ_END() { return getToken(MessageParser.DQ_END, 0); }
public QuotedMessageContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quotedMessage; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterQuotedMessage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitQuotedMessage(this);
}
}
public final QuotedMessageContext quotedMessage() throws RecognitionException {
QuotedMessageContext _localctx = new QuotedMessageContext(_ctx, getState());
enterRule(_localctx, 8, RULE_quotedMessage);
try {
setState(68);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SQ_START:
enterOuterAlt(_localctx, 1);
{
setState(60);
match(SQ_START);
setState(61);
message0();
setState(62);
match(SQ_END);
}
break;
case DQ_START:
enterOuterAlt(_localctx, 2);
{
setState(64);
match(DQ_START);
setState(65);
message0();
setState(66);
match(DQ_END);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QuotedStringContext extends ParserRuleContext {
public String string;
public TerminalNode SQ_START() { return getToken(MessageParser.SQ_START, 0); }
public TerminalNode SQ_END() { return getToken(MessageParser.SQ_END, 0); }
public TextContext text() {
return getRuleContext(TextContext.class,0);
}
public TerminalNode DQ_START() { return getToken(MessageParser.DQ_START, 0); }
public TerminalNode DQ_END() { return getToken(MessageParser.DQ_END, 0); }
public QuotedStringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quotedString; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterQuotedString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitQuotedString(this);
}
}
public final QuotedStringContext quotedString() throws RecognitionException {
QuotedStringContext _localctx = new QuotedStringContext(_ctx, getState());
enterRule(_localctx, 10, RULE_quotedString);
int _la;
try {
setState(80);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SQ_START:
enterOuterAlt(_localctx, 1);
{
setState(70);
match(SQ_START);
setState(72);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CH) {
{
setState(71);
text();
}
}
setState(74);
match(SQ_END);
}
break;
case DQ_START:
enterOuterAlt(_localctx, 2);
{
setState(75);
match(DQ_START);
setState(77);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CH) {
{
setState(76);
text();
}
}
setState(79);
match(DQ_END);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleStringContext extends ParserRuleContext {
public String string;
public NameOrKeywordContext nameOrKeyword() {
return getRuleContext(NameOrKeywordContext.class,0);
}
public QuotedStringContext quotedString() {
return getRuleContext(QuotedStringContext.class,0);
}
public SimpleStringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleString; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterSimpleString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitSimpleString(this);
}
}
public final SimpleStringContext simpleString() throws RecognitionException {
SimpleStringContext _localctx = new SimpleStringContext(_ctx, getState());
enterRule(_localctx, 12, RULE_simpleString);
try {
setState(84);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOL:
case NAME:
case NULL:
case EMPTY:
enterOuterAlt(_localctx, 1);
{
setState(82);
nameOrKeyword();
}
break;
case SQ_START:
case DQ_START:
enterOuterAlt(_localctx, 2);
{
setState(83);
quotedString();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ForceQuotedMessageContext extends ParserRuleContext {
public Message.WithSpaces messageWithSpaces;
public QuotedMessageContext quotedMessage() {
return getRuleContext(QuotedMessageContext.class,0);
}
public SimpleStringContext simpleString() {
return getRuleContext(SimpleStringContext.class,0);
}
public ForceQuotedMessageContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forceQuotedMessage; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterForceQuotedMessage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitForceQuotedMessage(this);
}
}
public final ForceQuotedMessageContext forceQuotedMessage() throws RecognitionException {
ForceQuotedMessageContext _localctx = new ForceQuotedMessageContext(_ctx, getState());
enterRule(_localctx, 14, RULE_forceQuotedMessage);
try {
setState(88);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(86);
quotedMessage();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(87);
simpleString();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParameterPartContext extends ParserRuleContext {
public ParameterPart part;
public SimpleStringContext name;
public NameOrKeywordContext format;
public TerminalNode P_START() { return getToken(MessageParser.P_START, 0); }
public TerminalNode P_END() { return getToken(MessageParser.P_END, 0); }
public SimpleStringContext simpleString() {
return getRuleContext(SimpleStringContext.class,0);
}
public List COMMA() { return getTokens(MessageParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MessageParser.COMMA, i);
}
public List parameterConfigElement() {
return getRuleContexts(ParameterConfigElementContext.class);
}
public ParameterConfigElementContext parameterConfigElement(int i) {
return getRuleContext(ParameterConfigElementContext.class,i);
}
public TerminalNode COLON() { return getToken(MessageParser.COLON, 0); }
public ForceQuotedMessageContext forceQuotedMessage() {
return getRuleContext(ForceQuotedMessageContext.class,0);
}
public NameOrKeywordContext nameOrKeyword() {
return getRuleContext(NameOrKeywordContext.class,0);
}
public ParameterPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterParameterPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitParameterPart(this);
}
}
public final ParameterPartContext parameterPart() throws RecognitionException {
ParameterPartContext _localctx = new ParameterPartContext(_ctx, getState());
enterRule(_localctx, 16, RULE_parameterPart);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(90);
match(P_START);
setState(91);
((ParameterPartContext)_localctx).name = simpleString();
setState(94);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(92);
match(COMMA);
setState(93);
((ParameterPartContext)_localctx).format = nameOrKeyword();
}
break;
}
setState(100);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(96);
match(COMMA);
setState(97);
parameterConfigElement();
}
}
}
setState(102);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
}
setState(106);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(103);
match(COMMA);
setState(104);
match(COLON);
setState(105);
forceQuotedMessage();
}
}
setState(108);
match(P_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParameterConfigElementContext extends ParserRuleContext {
public List configKeys;
public ConfigValue configValue;
public ConfigNamedElementContext configNamedElement() {
return getRuleContext(ConfigNamedElementContext.class,0);
}
public ConfigMapElementContext configMapElement() {
return getRuleContext(ConfigMapElementContext.class,0);
}
public ParameterConfigElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterConfigElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterParameterConfigElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitParameterConfigElement(this);
}
}
public final ParameterConfigElementContext parameterConfigElement() throws RecognitionException {
ParameterConfigElementContext _localctx = new ParameterConfigElementContext(_ctx, getState());
enterRule(_localctx, 18, RULE_parameterConfigElement);
try {
setState(112);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NAME:
enterOuterAlt(_localctx, 1);
{
setState(110);
configNamedElement();
}
break;
case SQ_START:
case DQ_START:
case BOOL:
case NUMBER:
case EQ:
case L_PAREN:
case NULL:
case EMPTY:
case NE:
case LT:
case LTE:
case GT:
case GTE:
enterOuterAlt(_localctx, 2);
{
setState(111);
configMapElement();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TemplatePartContext extends ParserRuleContext {
public TemplatePart part;
public SimpleStringContext name;
public TerminalNode TPL_START() { return getToken(MessageParser.TPL_START, 0); }
public TerminalNode TPL_END() { return getToken(MessageParser.TPL_END, 0); }
public SimpleStringContext simpleString() {
return getRuleContext(SimpleStringContext.class,0);
}
public List COMMA() { return getTokens(MessageParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MessageParser.COMMA, i);
}
public List configNamedElement() {
return getRuleContexts(ConfigNamedElementContext.class);
}
public ConfigNamedElementContext configNamedElement(int i) {
return getRuleContext(ConfigNamedElementContext.class,i);
}
public List templateParameterDelegate() {
return getRuleContexts(TemplateParameterDelegateContext.class);
}
public TemplateParameterDelegateContext templateParameterDelegate(int i) {
return getRuleContext(TemplateParameterDelegateContext.class,i);
}
public TemplatePartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templatePart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterTemplatePart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitTemplatePart(this);
}
}
public final TemplatePartContext templatePart() throws RecognitionException {
TemplatePartContext _localctx = new TemplatePartContext(_ctx, getState());
enterRule(_localctx, 20, RULE_templatePart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(114);
match(TPL_START);
setState(115);
((TemplatePartContext)_localctx).name = simpleString();
setState(123);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(116);
match(COMMA);
setState(119);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(117);
configNamedElement();
}
break;
case 2:
{
setState(118);
templateParameterDelegate();
}
break;
}
}
}
setState(125);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(126);
match(TPL_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TemplateParameterDelegateContext extends ParserRuleContext {
public String parameter;
public String delegatedParameter;
public List simpleString() {
return getRuleContexts(SimpleStringContext.class);
}
public SimpleStringContext simpleString(int i) {
return getRuleContext(SimpleStringContext.class,i);
}
public TerminalNode EQ() { return getToken(MessageParser.EQ, 0); }
public TemplateParameterDelegateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templateParameterDelegate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterTemplateParameterDelegate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitTemplateParameterDelegate(this);
}
}
public final TemplateParameterDelegateContext templateParameterDelegate() throws RecognitionException {
TemplateParameterDelegateContext _localctx = new TemplateParameterDelegateContext(_ctx, getState());
enterRule(_localctx, 22, RULE_templateParameterDelegate);
try {
enterOuterAlt(_localctx, 1);
{
setState(128);
simpleString();
setState(129);
match(EQ);
setState(130);
simpleString();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapElementContext extends ParserRuleContext {
public List configKeys;
public ConfigValue configValue;
public ConfigMapElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_configMapElement; }
public ConfigMapElementContext() { }
public void copyFrom(ConfigMapElementContext ctx) {
super.copyFrom(ctx);
this.configKeys = ctx.configKeys;
this.configValue = ctx.configValue;
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapStringContext extends ConfigMapElementContext {
public ConfigMapKeysContext configMapKeys() {
return getRuleContext(ConfigMapKeysContext.class,0);
}
public TerminalNode COLON() { return getToken(MessageParser.COLON, 0); }
public SimpleStringContext simpleString() {
return getRuleContext(SimpleStringContext.class,0);
}
public ConfigMapStringContext(ConfigMapElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigMapString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigMapString(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapMessageContext extends ConfigMapElementContext {
public ConfigMapKeysContext configMapKeys() {
return getRuleContext(ConfigMapKeysContext.class,0);
}
public TerminalNode COLON() { return getToken(MessageParser.COLON, 0); }
public QuotedMessageContext quotedMessage() {
return getRuleContext(QuotedMessageContext.class,0);
}
public ConfigMapMessageContext(ConfigMapElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigMapMessage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigMapMessage(this);
}
}
public final ConfigMapElementContext configMapElement() throws RecognitionException {
ConfigMapElementContext _localctx = new ConfigMapElementContext(_ctx, getState());
enterRule(_localctx, 24, RULE_configMapElement);
try {
setState(140);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
_localctx = new ConfigMapMessageContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(132);
configMapKeys();
setState(133);
match(COLON);
setState(134);
quotedMessage();
}
break;
case 2:
_localctx = new ConfigMapStringContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(136);
configMapKeys();
setState(137);
match(COLON);
setState(138);
simpleString();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigNamedElementContext extends ParserRuleContext {
public ConfigKeyName configKey;
public ConfigValue configValue;
public ConfigNamedElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_configNamedElement; }
public ConfigNamedElementContext() { }
public void copyFrom(ConfigNamedElementContext ctx) {
super.copyFrom(ctx);
this.configKey = ctx.configKey;
this.configValue = ctx.configValue;
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigNamedMessageContext extends ConfigNamedElementContext {
public TerminalNode NAME() { return getToken(MessageParser.NAME, 0); }
public TerminalNode COLON() { return getToken(MessageParser.COLON, 0); }
public QuotedMessageContext quotedMessage() {
return getRuleContext(QuotedMessageContext.class,0);
}
public ConfigNamedMessageContext(ConfigNamedElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigNamedMessage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigNamedMessage(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigNamedBoolContext extends ConfigNamedElementContext {
public TerminalNode NAME() { return getToken(MessageParser.NAME, 0); }
public TerminalNode COLON() { return getToken(MessageParser.COLON, 0); }
public TerminalNode BOOL() { return getToken(MessageParser.BOOL, 0); }
public ConfigNamedBoolContext(ConfigNamedElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigNamedBool(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigNamedBool(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigNamedNumberContext extends ConfigNamedElementContext {
public TerminalNode NAME() { return getToken(MessageParser.NAME, 0); }
public TerminalNode COLON() { return getToken(MessageParser.COLON, 0); }
public TerminalNode NUMBER() { return getToken(MessageParser.NUMBER, 0); }
public ConfigNamedNumberContext(ConfigNamedElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigNamedNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigNamedNumber(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigNamedStringContext extends ConfigNamedElementContext {
public TerminalNode NAME() { return getToken(MessageParser.NAME, 0); }
public TerminalNode COLON() { return getToken(MessageParser.COLON, 0); }
public SimpleStringContext simpleString() {
return getRuleContext(SimpleStringContext.class,0);
}
public ConfigNamedStringContext(ConfigNamedElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigNamedString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigNamedString(this);
}
}
public final ConfigNamedElementContext configNamedElement() throws RecognitionException {
ConfigNamedElementContext _localctx = new ConfigNamedElementContext(_ctx, getState());
enterRule(_localctx, 26, RULE_configNamedElement);
try {
setState(154);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
_localctx = new ConfigNamedBoolContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(142);
match(NAME);
setState(143);
match(COLON);
setState(144);
match(BOOL);
}
break;
case 2:
_localctx = new ConfigNamedNumberContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(145);
match(NAME);
setState(146);
match(COLON);
setState(147);
match(NUMBER);
}
break;
case 3:
_localctx = new ConfigNamedStringContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(148);
match(NAME);
setState(149);
match(COLON);
setState(150);
simpleString();
}
break;
case 4:
_localctx = new ConfigNamedMessageContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(151);
match(NAME);
setState(152);
match(COLON);
setState(153);
quotedMessage();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapKeysContext extends ParserRuleContext {
public List configKeys;
public List configMapKey() {
return getRuleContexts(ConfigMapKeyContext.class);
}
public ConfigMapKeyContext configMapKey(int i) {
return getRuleContext(ConfigMapKeyContext.class,i);
}
public TerminalNode L_PAREN() { return getToken(MessageParser.L_PAREN, 0); }
public TerminalNode R_PAREN() { return getToken(MessageParser.R_PAREN, 0); }
public List COMMA() { return getTokens(MessageParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(MessageParser.COMMA, i);
}
public ConfigMapKeysContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_configMapKeys; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigMapKeys(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigMapKeys(this);
}
}
public final ConfigMapKeysContext configMapKeys() throws RecognitionException {
ConfigMapKeysContext _localctx = new ConfigMapKeysContext(_ctx, getState());
enterRule(_localctx, 28, RULE_configMapKeys);
int _la;
try {
setState(167);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SQ_START:
case DQ_START:
case BOOL:
case NUMBER:
case EQ:
case NULL:
case EMPTY:
case NE:
case LT:
case LTE:
case GT:
case GTE:
enterOuterAlt(_localctx, 1);
{
setState(156);
configMapKey();
}
break;
case L_PAREN:
enterOuterAlt(_localctx, 2);
{
setState(157);
match(L_PAREN);
setState(158);
configMapKey();
setState(161);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(159);
match(COMMA);
setState(160);
configMapKey();
}
}
setState(163);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==COMMA );
setState(165);
match(R_PAREN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapKeyContext extends ParserRuleContext {
public ConfigKey configKey;
public ConfigMapKeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_configMapKey; }
public ConfigMapKeyContext() { }
public void copyFrom(ConfigMapKeyContext ctx) {
super.copyFrom(ctx);
this.configKey = ctx.configKey;
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapKeyBoolContext extends ConfigMapKeyContext {
public TerminalNode BOOL() { return getToken(MessageParser.BOOL, 0); }
public ConfigMapKeyBoolContext(ConfigMapKeyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigMapKeyBool(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigMapKeyBool(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapKeyStringContext extends ConfigMapKeyContext {
public RelationalOperatorOptionalContext relationalOperatorOptional() {
return getRuleContext(RelationalOperatorOptionalContext.class,0);
}
public QuotedStringContext quotedString() {
return getRuleContext(QuotedStringContext.class,0);
}
public ConfigMapKeyStringContext(ConfigMapKeyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigMapKeyString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigMapKeyString(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapKeyEmptyContext extends ConfigMapKeyContext {
public EqualOperatorOptionalContext equalOperatorOptional() {
return getRuleContext(EqualOperatorOptionalContext.class,0);
}
public TerminalNode EMPTY() { return getToken(MessageParser.EMPTY, 0); }
public ConfigMapKeyEmptyContext(ConfigMapKeyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigMapKeyEmpty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigMapKeyEmpty(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapKeyNumberContext extends ConfigMapKeyContext {
public RelationalOperatorOptionalContext relationalOperatorOptional() {
return getRuleContext(RelationalOperatorOptionalContext.class,0);
}
public TerminalNode NUMBER() { return getToken(MessageParser.NUMBER, 0); }
public ConfigMapKeyNumberContext(ConfigMapKeyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigMapKeyNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigMapKeyNumber(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConfigMapKeyNullContext extends ConfigMapKeyContext {
public EqualOperatorOptionalContext equalOperatorOptional() {
return getRuleContext(EqualOperatorOptionalContext.class,0);
}
public TerminalNode NULL() { return getToken(MessageParser.NULL, 0); }
public ConfigMapKeyNullContext(ConfigMapKeyContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterConfigMapKeyNull(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitConfigMapKeyNull(this);
}
}
public final ConfigMapKeyContext configMapKey() throws RecognitionException {
ConfigMapKeyContext _localctx = new ConfigMapKeyContext(_ctx, getState());
enterRule(_localctx, 30, RULE_configMapKey);
try {
setState(182);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
_localctx = new ConfigMapKeyNullContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(169);
equalOperatorOptional();
setState(170);
match(NULL);
}
break;
case 2:
_localctx = new ConfigMapKeyEmptyContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(172);
equalOperatorOptional();
setState(173);
match(EMPTY);
}
break;
case 3:
_localctx = new ConfigMapKeyBoolContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(175);
match(BOOL);
}
break;
case 4:
_localctx = new ConfigMapKeyNumberContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(176);
relationalOperatorOptional();
setState(177);
match(NUMBER);
}
break;
case 5:
_localctx = new ConfigMapKeyStringContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(179);
relationalOperatorOptional();
setState(180);
quotedString();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationalOperatorOptionalContext extends ParserRuleContext {
public ConfigKey.CompareType cmp;
public RelationalOperatorContext relationalOperator() {
return getRuleContext(RelationalOperatorContext.class,0);
}
public RelationalOperatorOptionalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationalOperatorOptional; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterRelationalOperatorOptional(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitRelationalOperatorOptional(this);
}
}
public final RelationalOperatorOptionalContext relationalOperatorOptional() throws RecognitionException {
RelationalOperatorOptionalContext _localctx = new RelationalOperatorOptionalContext(_ctx, getState());
enterRule(_localctx, 32, RULE_relationalOperatorOptional);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(185);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 260047104L) != 0)) {
{
setState(184);
relationalOperator();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationalOperatorContext extends ParserRuleContext {
public ConfigKey.CompareType cmp;
public EqualOperatorContext equalOperator() {
return getRuleContext(EqualOperatorContext.class,0);
}
public TerminalNode LTE() { return getToken(MessageParser.LTE, 0); }
public TerminalNode LT() { return getToken(MessageParser.LT, 0); }
public TerminalNode GT() { return getToken(MessageParser.GT, 0); }
public TerminalNode GTE() { return getToken(MessageParser.GTE, 0); }
public RelationalOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationalOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterRelationalOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitRelationalOperator(this);
}
}
public final RelationalOperatorContext relationalOperator() throws RecognitionException {
RelationalOperatorContext _localctx = new RelationalOperatorContext(_ctx, getState());
enterRule(_localctx, 34, RULE_relationalOperator);
try {
setState(192);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EQ:
case NE:
enterOuterAlt(_localctx, 1);
{
setState(187);
equalOperator();
}
break;
case LTE:
enterOuterAlt(_localctx, 2);
{
setState(188);
match(LTE);
}
break;
case LT:
enterOuterAlt(_localctx, 3);
{
setState(189);
match(LT);
}
break;
case GT:
enterOuterAlt(_localctx, 4);
{
setState(190);
match(GT);
}
break;
case GTE:
enterOuterAlt(_localctx, 5);
{
setState(191);
match(GTE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EqualOperatorOptionalContext extends ParserRuleContext {
public ConfigKey.CompareType cmp;
public EqualOperatorContext equalOperator() {
return getRuleContext(EqualOperatorContext.class,0);
}
public EqualOperatorOptionalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalOperatorOptional; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterEqualOperatorOptional(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitEqualOperatorOptional(this);
}
}
public final EqualOperatorOptionalContext equalOperatorOptional() throws RecognitionException {
EqualOperatorOptionalContext _localctx = new EqualOperatorOptionalContext(_ctx, getState());
enterRule(_localctx, 36, RULE_equalOperatorOptional);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(195);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ || _la==NE) {
{
setState(194);
equalOperator();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EqualOperatorContext extends ParserRuleContext {
public ConfigKey.CompareType cmp;
public TerminalNode EQ() { return getToken(MessageParser.EQ, 0); }
public TerminalNode NE() { return getToken(MessageParser.NE, 0); }
public EqualOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterEqualOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitEqualOperator(this);
}
}
public final EqualOperatorContext equalOperator() throws RecognitionException {
EqualOperatorContext _localctx = new EqualOperatorContext(_ctx, getState());
enterRule(_localctx, 38, RULE_equalOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(197);
_la = _input.LA(1);
if ( !(_la==EQ || _la==NE) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class NameOrKeywordContext extends ParserRuleContext {
public String name;
public TerminalNode NAME() { return getToken(MessageParser.NAME, 0); }
public TerminalNode BOOL() { return getToken(MessageParser.BOOL, 0); }
public TerminalNode NULL() { return getToken(MessageParser.NULL, 0); }
public TerminalNode EMPTY() { return getToken(MessageParser.EMPTY, 0); }
public NameOrKeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nameOrKeyword; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).enterNameOrKeyword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MessageParserListener ) ((MessageParserListener)listener).exitNameOrKeyword(this);
}
}
public final NameOrKeywordContext nameOrKeyword() throws RecognitionException {
NameOrKeywordContext _localctx = new NameOrKeywordContext(_ctx, getState());
enterRule(_localctx, 40, RULE_nameOrKeyword);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(199);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 3145888L) != 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 final String _serializedATN =
"\u0004\u0001\"\u00ca\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0001\u0000\u0001\u0000"+
"\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0005\u00011\b\u0001"+
"\n\u0001\f\u00014\t\u0001\u0001\u0002\u0001\u0002\u0001\u0003\u0004\u0003"+
"9\b\u0003\u000b\u0003\f\u0003:\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004E\b"+
"\u0004\u0001\u0005\u0001\u0005\u0003\u0005I\b\u0005\u0001\u0005\u0001"+
"\u0005\u0001\u0005\u0003\u0005N\b\u0005\u0001\u0005\u0003\u0005Q\b\u0005"+
"\u0001\u0006\u0001\u0006\u0003\u0006U\b\u0006\u0001\u0007\u0001\u0007"+
"\u0003\u0007Y\b\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0003\b_\b\b\u0001"+
"\b\u0001\b\u0005\bc\b\b\n\b\f\bf\t\b\u0001\b\u0001\b\u0001\b\u0003\bk"+
"\b\b\u0001\b\u0001\b\u0001\t\u0001\t\u0003\tq\b\t\u0001\n\u0001\n\u0001"+
"\n\u0001\n\u0001\n\u0003\nx\b\n\u0005\nz\b\n\n\n\f\n}\t\n\u0001\n\u0001"+
"\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001"+
"\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0003\f\u008d\b\f\u0001\r\u0001"+
"\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+
"\r\u0001\r\u0003\r\u009b\b\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+
"\u000e\u0001\u000e\u0004\u000e\u00a2\b\u000e\u000b\u000e\f\u000e\u00a3"+
"\u0001\u000e\u0001\u000e\u0003\u000e\u00a8\b\u000e\u0001\u000f\u0001\u000f"+
"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f"+
"\u00b7\b\u000f\u0001\u0010\u0003\u0010\u00ba\b\u0010\u0001\u0011\u0001"+
"\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0003\u0011\u00c1\b\u0011\u0001"+
"\u0012\u0003\u0012\u00c4\b\u0012\u0001\u0013\u0001\u0013\u0001\u0014\u0001"+
"\u0014\u0001\u0014\u0000\u0000\u0015\u0000\u0002\u0004\u0006\b\n\f\u000e"+
"\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(\u0000\u0002\u0002"+
"\u0000\b\b\u0017\u0017\u0003\u0000\u0005\u0005\u0007\u0007\u0014\u0015"+
"\u00d4\u0000*\u0001\u0000\u0000\u0000\u00022\u0001\u0000\u0000\u0000\u0004"+
"5\u0001\u0000\u0000\u0000\u00068\u0001\u0000\u0000\u0000\bD\u0001\u0000"+
"\u0000\u0000\nP\u0001\u0000\u0000\u0000\fT\u0001\u0000\u0000\u0000\u000e"+
"X\u0001\u0000\u0000\u0000\u0010Z\u0001\u0000\u0000\u0000\u0012p\u0001"+
"\u0000\u0000\u0000\u0014r\u0001\u0000\u0000\u0000\u0016\u0080\u0001\u0000"+
"\u0000\u0000\u0018\u008c\u0001\u0000\u0000\u0000\u001a\u009a\u0001\u0000"+
"\u0000\u0000\u001c\u00a7\u0001\u0000\u0000\u0000\u001e\u00b6\u0001\u0000"+
"\u0000\u0000 \u00b9\u0001\u0000\u0000\u0000\"\u00c0\u0001\u0000\u0000"+
"\u0000$\u00c3\u0001\u0000\u0000\u0000&\u00c5\u0001\u0000\u0000\u0000("+
"\u00c7\u0001\u0000\u0000\u0000*+\u0003\u0002\u0001\u0000+,\u0005\u0000"+
"\u0000\u0001,\u0001\u0001\u0000\u0000\u0000-1\u0003\u0004\u0002\u0000"+
".1\u0003\u0010\b\u0000/1\u0003\u0014\n\u00000-\u0001\u0000\u0000\u0000"+
"0.\u0001\u0000\u0000\u00000/\u0001\u0000\u0000\u000014\u0001\u0000\u0000"+
"\u000020\u0001\u0000\u0000\u000023\u0001\u0000\u0000\u00003\u0003\u0001"+
"\u0000\u0000\u000042\u0001\u0000\u0000\u000056\u0003\u0006\u0003\u0000"+
"6\u0005\u0001\u0000\u0000\u000079\u0005\r\u0000\u000087\u0001\u0000\u0000"+
"\u00009:\u0001\u0000\u0000\u0000:8\u0001\u0000\u0000\u0000:;\u0001\u0000"+
"\u0000\u0000;\u0007\u0001\u0000\u0000\u0000<=\u0005\u0001\u0000\u0000"+
"=>\u0003\u0002\u0001\u0000>?\u0005\u000f\u0000\u0000?E\u0001\u0000\u0000"+
"\u0000@A\u0005\u0002\u0000\u0000AB\u0003\u0002\u0001\u0000BC\u0005\u0011"+
"\u0000\u0000CE\u0001\u0000\u0000\u0000D<\u0001\u0000\u0000\u0000D@\u0001"+
"\u0000\u0000\u0000E\t\u0001\u0000\u0000\u0000FH\u0005\u0001\u0000\u0000"+
"GI\u0003\u0006\u0003\u0000HG\u0001\u0000\u0000\u0000HI\u0001\u0000\u0000"+
"\u0000IJ\u0001\u0000\u0000\u0000JQ\u0005\u000f\u0000\u0000KM\u0005\u0002"+
"\u0000\u0000LN\u0003\u0006\u0003\u0000ML\u0001\u0000\u0000\u0000MN\u0001"+
"\u0000\u0000\u0000NO\u0001\u0000\u0000\u0000OQ\u0005\u0011\u0000\u0000"+
"PF\u0001\u0000\u0000\u0000PK\u0001\u0000\u0000\u0000Q\u000b\u0001\u0000"+
"\u0000\u0000RU\u0003(\u0014\u0000SU\u0003\n\u0005\u0000TR\u0001\u0000"+
"\u0000\u0000TS\u0001\u0000\u0000\u0000U\r\u0001\u0000\u0000\u0000VY\u0003"+
"\b\u0004\u0000WY\u0003\f\u0006\u0000XV\u0001\u0000\u0000\u0000XW\u0001"+
"\u0000\u0000\u0000Y\u000f\u0001\u0000\u0000\u0000Z[\u0005\u000b\u0000"+
"\u0000[^\u0003\f\u0006\u0000\\]\u0005\u0003\u0000\u0000]_\u0003(\u0014"+
"\u0000^\\\u0001\u0000\u0000\u0000^_\u0001\u0000\u0000\u0000_d\u0001\u0000"+
"\u0000\u0000`a\u0005\u0003\u0000\u0000ac\u0003\u0012\t\u0000b`\u0001\u0000"+
"\u0000\u0000cf\u0001\u0000\u0000\u0000db\u0001\u0000\u0000\u0000de\u0001"+
"\u0000\u0000\u0000ej\u0001\u0000\u0000\u0000fd\u0001\u0000\u0000\u0000"+
"gh\u0005\u0003\u0000\u0000hi\u0005\u0004\u0000\u0000ik\u0003\u000e\u0007"+
"\u0000jg\u0001\u0000\u0000\u0000jk\u0001\u0000\u0000\u0000kl\u0001\u0000"+
"\u0000\u0000lm\u0005\u0013\u0000\u0000m\u0011\u0001\u0000\u0000\u0000"+
"nq\u0003\u001a\r\u0000oq\u0003\u0018\f\u0000pn\u0001\u0000\u0000\u0000"+
"po\u0001\u0000\u0000\u0000q\u0013\u0001\u0000\u0000\u0000rs\u0005\f\u0000"+
"\u0000s{\u0003\f\u0006\u0000tw\u0005\u0003\u0000\u0000ux\u0003\u001a\r"+
"\u0000vx\u0003\u0016\u000b\u0000wu\u0001\u0000\u0000\u0000wv\u0001\u0000"+
"\u0000\u0000xz\u0001\u0000\u0000\u0000yt\u0001\u0000\u0000\u0000z}\u0001"+
"\u0000\u0000\u0000{y\u0001\u0000\u0000\u0000{|\u0001\u0000\u0000\u0000"+
"|~\u0001\u0000\u0000\u0000}{\u0001\u0000\u0000\u0000~\u007f\u0005\u001c"+
"\u0000\u0000\u007f\u0015\u0001\u0000\u0000\u0000\u0080\u0081\u0003\f\u0006"+
"\u0000\u0081\u0082\u0005\b\u0000\u0000\u0082\u0083\u0003\f\u0006\u0000"+
"\u0083\u0017\u0001\u0000\u0000\u0000\u0084\u0085\u0003\u001c\u000e\u0000"+
"\u0085\u0086\u0005\u0004\u0000\u0000\u0086\u0087\u0003\b\u0004\u0000\u0087"+
"\u008d\u0001\u0000\u0000\u0000\u0088\u0089\u0003\u001c\u000e\u0000\u0089"+
"\u008a\u0005\u0004\u0000\u0000\u008a\u008b\u0003\f\u0006\u0000\u008b\u008d"+
"\u0001\u0000\u0000\u0000\u008c\u0084\u0001\u0000\u0000\u0000\u008c\u0088"+
"\u0001\u0000\u0000\u0000\u008d\u0019\u0001\u0000\u0000\u0000\u008e\u008f"+
"\u0005\u0007\u0000\u0000\u008f\u0090\u0005\u0004\u0000\u0000\u0090\u009b"+
"\u0005\u0005\u0000\u0000\u0091\u0092\u0005\u0007\u0000\u0000\u0092\u0093"+
"\u0005\u0004\u0000\u0000\u0093\u009b\u0005\u0006\u0000\u0000\u0094\u0095"+
"\u0005\u0007\u0000\u0000\u0095\u0096\u0005\u0004\u0000\u0000\u0096\u009b"+
"\u0003\f\u0006\u0000\u0097\u0098\u0005\u0007\u0000\u0000\u0098\u0099\u0005"+
"\u0004\u0000\u0000\u0099\u009b\u0003\b\u0004\u0000\u009a\u008e\u0001\u0000"+
"\u0000\u0000\u009a\u0091\u0001\u0000\u0000\u0000\u009a\u0094\u0001\u0000"+
"\u0000\u0000\u009a\u0097\u0001\u0000\u0000\u0000\u009b\u001b\u0001\u0000"+
"\u0000\u0000\u009c\u00a8\u0003\u001e\u000f\u0000\u009d\u009e\u0005\t\u0000"+
"\u0000\u009e\u00a1\u0003\u001e\u000f\u0000\u009f\u00a0\u0005\u0003\u0000"+
"\u0000\u00a0\u00a2\u0003\u001e\u000f\u0000\u00a1\u009f\u0001\u0000\u0000"+
"\u0000\u00a2\u00a3\u0001\u0000\u0000\u0000\u00a3\u00a1\u0001\u0000\u0000"+
"\u0000\u00a3\u00a4\u0001\u0000\u0000\u0000\u00a4\u00a5\u0001\u0000\u0000"+
"\u0000\u00a5\u00a6\u0005\n\u0000\u0000\u00a6\u00a8\u0001\u0000\u0000\u0000"+
"\u00a7\u009c\u0001\u0000\u0000\u0000\u00a7\u009d\u0001\u0000\u0000\u0000"+
"\u00a8\u001d\u0001\u0000\u0000\u0000\u00a9\u00aa\u0003$\u0012\u0000\u00aa"+
"\u00ab\u0005\u0014\u0000\u0000\u00ab\u00b7\u0001\u0000\u0000\u0000\u00ac"+
"\u00ad\u0003$\u0012\u0000\u00ad\u00ae\u0005\u0015\u0000\u0000\u00ae\u00b7"+
"\u0001\u0000\u0000\u0000\u00af\u00b7\u0005\u0005\u0000\u0000\u00b0\u00b1"+
"\u0003 \u0010\u0000\u00b1\u00b2\u0005\u0006\u0000\u0000\u00b2\u00b7\u0001"+
"\u0000\u0000\u0000\u00b3\u00b4\u0003 \u0010\u0000\u00b4\u00b5\u0003\n"+
"\u0005\u0000\u00b5\u00b7\u0001\u0000\u0000\u0000\u00b6\u00a9\u0001\u0000"+
"\u0000\u0000\u00b6\u00ac\u0001\u0000\u0000\u0000\u00b6\u00af\u0001\u0000"+
"\u0000\u0000\u00b6\u00b0\u0001\u0000\u0000\u0000\u00b6\u00b3\u0001\u0000"+
"\u0000\u0000\u00b7\u001f\u0001\u0000\u0000\u0000\u00b8\u00ba\u0003\"\u0011"+
"\u0000\u00b9\u00b8\u0001\u0000\u0000\u0000\u00b9\u00ba\u0001\u0000\u0000"+
"\u0000\u00ba!\u0001\u0000\u0000\u0000\u00bb\u00c1\u0003&\u0013\u0000\u00bc"+
"\u00c1\u0005\u0019\u0000\u0000\u00bd\u00c1\u0005\u0018\u0000\u0000\u00be"+
"\u00c1\u0005\u001a\u0000\u0000\u00bf\u00c1\u0005\u001b\u0000\u0000\u00c0"+
"\u00bb\u0001\u0000\u0000\u0000\u00c0\u00bc\u0001\u0000\u0000\u0000\u00c0"+
"\u00bd\u0001\u0000\u0000\u0000\u00c0\u00be\u0001\u0000\u0000\u0000\u00c0"+
"\u00bf\u0001\u0000\u0000\u0000\u00c1#\u0001\u0000\u0000\u0000\u00c2\u00c4"+
"\u0003&\u0013\u0000\u00c3\u00c2\u0001\u0000\u0000\u0000\u00c3\u00c4\u0001"+
"\u0000\u0000\u0000\u00c4%\u0001\u0000\u0000\u0000\u00c5\u00c6\u0007\u0000"+
"\u0000\u0000\u00c6\'\u0001\u0000\u0000\u0000\u00c7\u00c8\u0007\u0001\u0000"+
"\u0000\u00c8)\u0001\u0000\u0000\u0000\u001702:DHMPTX^djpw{\u008c\u009a"+
"\u00a3\u00a7\u00b6\u00b9\u00c0\u00c3";
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);
}
}
}