chapi.parser.toml.TomlParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of chapi-parser-toml Show documentation
Show all versions of chapi-parser-toml Show documentation
Chapi is A common language meta information convertor, convert different languages to same meta-data model
The newest version!
// Generated from TomlParser.g4 by ANTLR 4.13.1
package chapi.parser.toml;
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"})
public class TomlParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
WS=1, NL=2, COMMENT=3, L_BRACKET=4, DOUBLE_L_BRACKET=5, R_BRACKET=6, DOUBLE_R_BRACKET=7,
EQUALS=8, DOT=9, COMMA=10, BASIC_STRING=11, LITERAL_STRING=12, UNQUOTED_KEY=13,
VALUE_WS=14, L_BRACE=15, BOOLEAN=16, ML_BASIC_STRING=17, ML_LITERAL_STRING=18,
FLOAT=19, INF=20, NAN=21, DEC_INT=22, HEX_INT=23, OCT_INT=24, BIN_INT=25,
OFFSET_DATE_TIME=26, LOCAL_DATE_TIME=27, LOCAL_DATE=28, LOCAL_TIME=29,
INLINE_TABLE_WS=30, R_BRACE=31, ARRAY_WS=32;
public static final int
RULE_document = 0, RULE_expression = 1, RULE_comment = 2, RULE_key_value = 3,
RULE_key = 4, RULE_simple_key = 5, RULE_unquoted_key = 6, RULE_quoted_key = 7,
RULE_dotted_key = 8, RULE_value = 9, RULE_string = 10, RULE_integer = 11,
RULE_floating_point = 12, RULE_bool_ = 13, RULE_date_time = 14, RULE_array_ = 15,
RULE_comment_or_nl = 16, RULE_nl_or_comment = 17, RULE_table = 18, RULE_standard_table = 19,
RULE_inline_table = 20, RULE_inline_table_keyvals = 21, RULE_array_table = 22;
private static String[] makeRuleNames() {
return new String[] {
"document", "expression", "comment", "key_value", "key", "simple_key",
"unquoted_key", "quoted_key", "dotted_key", "value", "string", "integer",
"floating_point", "bool_", "date_time", "array_", "comment_or_nl", "nl_or_comment",
"table", "standard_table", "inline_table", "inline_table_keyvals", "array_table"
};
}
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, null, null, null, null, null, "'}'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "WS", "NL", "COMMENT", "L_BRACKET", "DOUBLE_L_BRACKET", "R_BRACKET",
"DOUBLE_R_BRACKET", "EQUALS", "DOT", "COMMA", "BASIC_STRING", "LITERAL_STRING",
"UNQUOTED_KEY", "VALUE_WS", "L_BRACE", "BOOLEAN", "ML_BASIC_STRING",
"ML_LITERAL_STRING", "FLOAT", "INF", "NAN", "DEC_INT", "HEX_INT", "OCT_INT",
"BIN_INT", "OFFSET_DATE_TIME", "LOCAL_DATE_TIME", "LOCAL_DATE", "LOCAL_TIME",
"INLINE_TABLE_WS", "R_BRACE", "ARRAY_WS"
};
}
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 "TomlParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public TomlParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class DocumentContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode EOF() { return getToken(TomlParser.EOF, 0); }
public List NL() { return getTokens(TomlParser.NL); }
public TerminalNode NL(int i) {
return getToken(TomlParser.NL, i);
}
public DocumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_document; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterDocument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitDocument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitDocument(this);
else return visitor.visitChildren(this);
}
}
public final DocumentContext document() throws RecognitionException {
DocumentContext _localctx = new DocumentContext(_ctx, getState());
enterRule(_localctx, 0, RULE_document);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(46);
expression();
setState(51);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(47);
match(NL);
setState(48);
expression();
}
}
setState(53);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(54);
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 ExpressionContext extends ParserRuleContext {
public Key_valueContext key_value() {
return getRuleContext(Key_valueContext.class,0);
}
public CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public TableContext table() {
return getRuleContext(TableContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_expression);
try {
setState(63);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BASIC_STRING:
case LITERAL_STRING:
case UNQUOTED_KEY:
enterOuterAlt(_localctx, 1);
{
setState(56);
key_value();
setState(57);
comment();
}
break;
case L_BRACKET:
case DOUBLE_L_BRACKET:
enterOuterAlt(_localctx, 2);
{
setState(59);
table();
setState(60);
comment();
}
break;
case EOF:
case NL:
case COMMENT:
enterOuterAlt(_localctx, 3);
{
setState(62);
comment();
}
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 CommentContext extends ParserRuleContext {
public TerminalNode COMMENT() { return getToken(TomlParser.COMMENT, 0); }
public CommentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitComment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitComment(this);
else return visitor.visitChildren(this);
}
}
public final CommentContext comment() throws RecognitionException {
CommentContext _localctx = new CommentContext(_ctx, getState());
enterRule(_localctx, 4, RULE_comment);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(66);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(65);
match(COMMENT);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Key_valueContext extends ParserRuleContext {
public KeyContext key() {
return getRuleContext(KeyContext.class,0);
}
public TerminalNode EQUALS() { return getToken(TomlParser.EQUALS, 0); }
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public Key_valueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_key_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterKey_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitKey_value(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitKey_value(this);
else return visitor.visitChildren(this);
}
}
public final Key_valueContext key_value() throws RecognitionException {
Key_valueContext _localctx = new Key_valueContext(_ctx, getState());
enterRule(_localctx, 6, RULE_key_value);
try {
enterOuterAlt(_localctx, 1);
{
setState(68);
key();
setState(69);
match(EQUALS);
setState(70);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class KeyContext extends ParserRuleContext {
public Simple_keyContext simple_key() {
return getRuleContext(Simple_keyContext.class,0);
}
public Dotted_keyContext dotted_key() {
return getRuleContext(Dotted_keyContext.class,0);
}
public KeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_key; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitKey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitKey(this);
else return visitor.visitChildren(this);
}
}
public final KeyContext key() throws RecognitionException {
KeyContext _localctx = new KeyContext(_ctx, getState());
enterRule(_localctx, 8, RULE_key);
try {
setState(74);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(72);
simple_key();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(73);
dotted_key();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Simple_keyContext extends ParserRuleContext {
public Quoted_keyContext quoted_key() {
return getRuleContext(Quoted_keyContext.class,0);
}
public Unquoted_keyContext unquoted_key() {
return getRuleContext(Unquoted_keyContext.class,0);
}
public Simple_keyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_key; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterSimple_key(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitSimple_key(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitSimple_key(this);
else return visitor.visitChildren(this);
}
}
public final Simple_keyContext simple_key() throws RecognitionException {
Simple_keyContext _localctx = new Simple_keyContext(_ctx, getState());
enterRule(_localctx, 10, RULE_simple_key);
try {
setState(78);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BASIC_STRING:
case LITERAL_STRING:
enterOuterAlt(_localctx, 1);
{
setState(76);
quoted_key();
}
break;
case UNQUOTED_KEY:
enterOuterAlt(_localctx, 2);
{
setState(77);
unquoted_key();
}
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 Unquoted_keyContext extends ParserRuleContext {
public TerminalNode UNQUOTED_KEY() { return getToken(TomlParser.UNQUOTED_KEY, 0); }
public Unquoted_keyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unquoted_key; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterUnquoted_key(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitUnquoted_key(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitUnquoted_key(this);
else return visitor.visitChildren(this);
}
}
public final Unquoted_keyContext unquoted_key() throws RecognitionException {
Unquoted_keyContext _localctx = new Unquoted_keyContext(_ctx, getState());
enterRule(_localctx, 12, RULE_unquoted_key);
try {
enterOuterAlt(_localctx, 1);
{
setState(80);
match(UNQUOTED_KEY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Quoted_keyContext extends ParserRuleContext {
public TerminalNode BASIC_STRING() { return getToken(TomlParser.BASIC_STRING, 0); }
public TerminalNode LITERAL_STRING() { return getToken(TomlParser.LITERAL_STRING, 0); }
public Quoted_keyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quoted_key; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterQuoted_key(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitQuoted_key(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitQuoted_key(this);
else return visitor.visitChildren(this);
}
}
public final Quoted_keyContext quoted_key() throws RecognitionException {
Quoted_keyContext _localctx = new Quoted_keyContext(_ctx, getState());
enterRule(_localctx, 14, RULE_quoted_key);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(82);
_la = _input.LA(1);
if ( !(_la==BASIC_STRING || _la==LITERAL_STRING) ) {
_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 Dotted_keyContext extends ParserRuleContext {
public List simple_key() {
return getRuleContexts(Simple_keyContext.class);
}
public Simple_keyContext simple_key(int i) {
return getRuleContext(Simple_keyContext.class,i);
}
public List DOT() { return getTokens(TomlParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(TomlParser.DOT, i);
}
public Dotted_keyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotted_key; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterDotted_key(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitDotted_key(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitDotted_key(this);
else return visitor.visitChildren(this);
}
}
public final Dotted_keyContext dotted_key() throws RecognitionException {
Dotted_keyContext _localctx = new Dotted_keyContext(_ctx, getState());
enterRule(_localctx, 16, RULE_dotted_key);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(84);
simple_key();
setState(87);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(85);
match(DOT);
setState(86);
simple_key();
}
}
setState(89);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DOT );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ValueContext extends ParserRuleContext {
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public IntegerContext integer() {
return getRuleContext(IntegerContext.class,0);
}
public Floating_pointContext floating_point() {
return getRuleContext(Floating_pointContext.class,0);
}
public Bool_Context bool_() {
return getRuleContext(Bool_Context.class,0);
}
public Date_timeContext date_time() {
return getRuleContext(Date_timeContext.class,0);
}
public Array_Context array_() {
return getRuleContext(Array_Context.class,0);
}
public Inline_tableContext inline_table() {
return getRuleContext(Inline_tableContext.class,0);
}
public ValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitValue(this);
else return visitor.visitChildren(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 18, RULE_value);
try {
setState(98);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BASIC_STRING:
case LITERAL_STRING:
case ML_BASIC_STRING:
case ML_LITERAL_STRING:
enterOuterAlt(_localctx, 1);
{
setState(91);
string();
}
break;
case DEC_INT:
case HEX_INT:
case OCT_INT:
case BIN_INT:
enterOuterAlt(_localctx, 2);
{
setState(92);
integer();
}
break;
case FLOAT:
case INF:
case NAN:
enterOuterAlt(_localctx, 3);
{
setState(93);
floating_point();
}
break;
case BOOLEAN:
enterOuterAlt(_localctx, 4);
{
setState(94);
bool_();
}
break;
case OFFSET_DATE_TIME:
case LOCAL_DATE_TIME:
case LOCAL_DATE:
case LOCAL_TIME:
enterOuterAlt(_localctx, 5);
{
setState(95);
date_time();
}
break;
case L_BRACKET:
enterOuterAlt(_localctx, 6);
{
setState(96);
array_();
}
break;
case L_BRACE:
enterOuterAlt(_localctx, 7);
{
setState(97);
inline_table();
}
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 StringContext extends ParserRuleContext {
public TerminalNode BASIC_STRING() { return getToken(TomlParser.BASIC_STRING, 0); }
public TerminalNode ML_BASIC_STRING() { return getToken(TomlParser.ML_BASIC_STRING, 0); }
public TerminalNode LITERAL_STRING() { return getToken(TomlParser.LITERAL_STRING, 0); }
public TerminalNode ML_LITERAL_STRING() { return getToken(TomlParser.ML_LITERAL_STRING, 0); }
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitString(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitString(this);
else return visitor.visitChildren(this);
}
}
public final StringContext string() throws RecognitionException {
StringContext _localctx = new StringContext(_ctx, getState());
enterRule(_localctx, 20, RULE_string);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(100);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 399360L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class IntegerContext extends ParserRuleContext {
public TerminalNode DEC_INT() { return getToken(TomlParser.DEC_INT, 0); }
public TerminalNode HEX_INT() { return getToken(TomlParser.HEX_INT, 0); }
public TerminalNode OCT_INT() { return getToken(TomlParser.OCT_INT, 0); }
public TerminalNode BIN_INT() { return getToken(TomlParser.BIN_INT, 0); }
public IntegerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_integer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterInteger(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitInteger(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitInteger(this);
else return visitor.visitChildren(this);
}
}
public final IntegerContext integer() throws RecognitionException {
IntegerContext _localctx = new IntegerContext(_ctx, getState());
enterRule(_localctx, 22, RULE_integer);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(102);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 62914560L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class Floating_pointContext extends ParserRuleContext {
public TerminalNode FLOAT() { return getToken(TomlParser.FLOAT, 0); }
public TerminalNode INF() { return getToken(TomlParser.INF, 0); }
public TerminalNode NAN() { return getToken(TomlParser.NAN, 0); }
public Floating_pointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_floating_point; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterFloating_point(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitFloating_point(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitFloating_point(this);
else return visitor.visitChildren(this);
}
}
public final Floating_pointContext floating_point() throws RecognitionException {
Floating_pointContext _localctx = new Floating_pointContext(_ctx, getState());
enterRule(_localctx, 24, RULE_floating_point);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(104);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 3670016L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class Bool_Context extends ParserRuleContext {
public TerminalNode BOOLEAN() { return getToken(TomlParser.BOOLEAN, 0); }
public Bool_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterBool_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitBool_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitBool_(this);
else return visitor.visitChildren(this);
}
}
public final Bool_Context bool_() throws RecognitionException {
Bool_Context _localctx = new Bool_Context(_ctx, getState());
enterRule(_localctx, 26, RULE_bool_);
try {
enterOuterAlt(_localctx, 1);
{
setState(106);
match(BOOLEAN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Date_timeContext extends ParserRuleContext {
public TerminalNode OFFSET_DATE_TIME() { return getToken(TomlParser.OFFSET_DATE_TIME, 0); }
public TerminalNode LOCAL_DATE_TIME() { return getToken(TomlParser.LOCAL_DATE_TIME, 0); }
public TerminalNode LOCAL_DATE() { return getToken(TomlParser.LOCAL_DATE, 0); }
public TerminalNode LOCAL_TIME() { return getToken(TomlParser.LOCAL_TIME, 0); }
public Date_timeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_date_time; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterDate_time(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitDate_time(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitDate_time(this);
else return visitor.visitChildren(this);
}
}
public final Date_timeContext date_time() throws RecognitionException {
Date_timeContext _localctx = new Date_timeContext(_ctx, getState());
enterRule(_localctx, 28, RULE_date_time);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(108);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1006632960L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class Array_Context extends ParserRuleContext {
public TerminalNode L_BRACKET() { return getToken(TomlParser.L_BRACKET, 0); }
public List comment_or_nl() {
return getRuleContexts(Comment_or_nlContext.class);
}
public Comment_or_nlContext comment_or_nl(int i) {
return getRuleContext(Comment_or_nlContext.class,i);
}
public TerminalNode R_BRACKET() { return getToken(TomlParser.R_BRACKET, 0); }
public List value() {
return getRuleContexts(ValueContext.class);
}
public ValueContext value(int i) {
return getRuleContext(ValueContext.class,i);
}
public Nl_or_commentContext nl_or_comment() {
return getRuleContext(Nl_or_commentContext.class,0);
}
public List COMMA() { return getTokens(TomlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(TomlParser.COMMA, i);
}
public Array_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_array_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterArray_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitArray_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitArray_(this);
else return visitor.visitChildren(this);
}
}
public final Array_Context array_() throws RecognitionException {
Array_Context _localctx = new Array_Context(_ctx, getState());
enterRule(_localctx, 30, RULE_array_);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(110);
match(L_BRACKET);
{
setState(111);
comment_or_nl();
setState(112);
value();
setState(113);
nl_or_comment();
setState(120);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(114);
match(COMMA);
setState(115);
value();
setState(116);
comment_or_nl();
}
}
setState(122);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
setState(123);
comment_or_nl();
setState(124);
match(R_BRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Comment_or_nlContext extends ParserRuleContext {
public List NL() { return getTokens(TomlParser.NL); }
public TerminalNode NL(int i) {
return getToken(TomlParser.NL, i);
}
public List COMMENT() { return getTokens(TomlParser.COMMENT); }
public TerminalNode COMMENT(int i) {
return getToken(TomlParser.COMMENT, i);
}
public Comment_or_nlContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comment_or_nl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterComment_or_nl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitComment_or_nl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitComment_or_nl(this);
else return visitor.visitChildren(this);
}
}
public final Comment_or_nlContext comment_or_nl() throws RecognitionException {
Comment_or_nlContext _localctx = new Comment_or_nlContext(_ctx, getState());
enterRule(_localctx, 32, RULE_comment_or_nl);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(132);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(127);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(126);
match(COMMENT);
}
}
setState(129);
match(NL);
}
}
}
setState(134);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Nl_or_commentContext extends ParserRuleContext {
public List NL() { return getTokens(TomlParser.NL); }
public TerminalNode NL(int i) {
return getToken(TomlParser.NL, i);
}
public List COMMENT() { return getTokens(TomlParser.COMMENT); }
public TerminalNode COMMENT(int i) {
return getToken(TomlParser.COMMENT, i);
}
public Nl_or_commentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nl_or_comment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterNl_or_comment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitNl_or_comment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitNl_or_comment(this);
else return visitor.visitChildren(this);
}
}
public final Nl_or_commentContext nl_or_comment() throws RecognitionException {
Nl_or_commentContext _localctx = new Nl_or_commentContext(_ctx, getState());
enterRule(_localctx, 34, RULE_nl_or_comment);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(141);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(135);
match(NL);
setState(137);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(136);
match(COMMENT);
}
break;
}
}
}
}
setState(143);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TableContext extends ParserRuleContext {
public Standard_tableContext standard_table() {
return getRuleContext(Standard_tableContext.class,0);
}
public Array_tableContext array_table() {
return getRuleContext(Array_tableContext.class,0);
}
public TableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitTable(this);
else return visitor.visitChildren(this);
}
}
public final TableContext table() throws RecognitionException {
TableContext _localctx = new TableContext(_ctx, getState());
enterRule(_localctx, 36, RULE_table);
try {
setState(146);
_errHandler.sync(this);
switch (_input.LA(1)) {
case L_BRACKET:
enterOuterAlt(_localctx, 1);
{
setState(144);
standard_table();
}
break;
case DOUBLE_L_BRACKET:
enterOuterAlt(_localctx, 2);
{
setState(145);
array_table();
}
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 Standard_tableContext extends ParserRuleContext {
public TerminalNode L_BRACKET() { return getToken(TomlParser.L_BRACKET, 0); }
public KeyContext key() {
return getRuleContext(KeyContext.class,0);
}
public TerminalNode R_BRACKET() { return getToken(TomlParser.R_BRACKET, 0); }
public Standard_tableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_standard_table; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterStandard_table(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitStandard_table(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitStandard_table(this);
else return visitor.visitChildren(this);
}
}
public final Standard_tableContext standard_table() throws RecognitionException {
Standard_tableContext _localctx = new Standard_tableContext(_ctx, getState());
enterRule(_localctx, 38, RULE_standard_table);
try {
enterOuterAlt(_localctx, 1);
{
setState(148);
match(L_BRACKET);
setState(149);
key();
setState(150);
match(R_BRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Inline_tableContext extends ParserRuleContext {
public TerminalNode L_BRACE() { return getToken(TomlParser.L_BRACE, 0); }
public List inline_table_keyvals() {
return getRuleContexts(Inline_table_keyvalsContext.class);
}
public Inline_table_keyvalsContext inline_table_keyvals(int i) {
return getRuleContext(Inline_table_keyvalsContext.class,i);
}
public TerminalNode R_BRACE() { return getToken(TomlParser.R_BRACE, 0); }
public List COMMA() { return getTokens(TomlParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(TomlParser.COMMA, i);
}
public Inline_tableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inline_table; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterInline_table(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitInline_table(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitInline_table(this);
else return visitor.visitChildren(this);
}
}
public final Inline_tableContext inline_table() throws RecognitionException {
Inline_tableContext _localctx = new Inline_tableContext(_ctx, getState());
enterRule(_localctx, 40, RULE_inline_table);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(152);
match(L_BRACE);
setState(153);
inline_table_keyvals();
setState(158);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(154);
match(COMMA);
setState(155);
inline_table_keyvals();
}
}
setState(160);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(161);
match(R_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Inline_table_keyvalsContext extends ParserRuleContext {
public KeyContext key() {
return getRuleContext(KeyContext.class,0);
}
public TerminalNode EQUALS() { return getToken(TomlParser.EQUALS, 0); }
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public Inline_table_keyvalsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inline_table_keyvals; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterInline_table_keyvals(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitInline_table_keyvals(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitInline_table_keyvals(this);
else return visitor.visitChildren(this);
}
}
public final Inline_table_keyvalsContext inline_table_keyvals() throws RecognitionException {
Inline_table_keyvalsContext _localctx = new Inline_table_keyvalsContext(_ctx, getState());
enterRule(_localctx, 42, RULE_inline_table_keyvals);
try {
enterOuterAlt(_localctx, 1);
{
setState(163);
key();
setState(164);
match(EQUALS);
setState(165);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Array_tableContext extends ParserRuleContext {
public TerminalNode DOUBLE_L_BRACKET() { return getToken(TomlParser.DOUBLE_L_BRACKET, 0); }
public KeyContext key() {
return getRuleContext(KeyContext.class,0);
}
public TerminalNode DOUBLE_R_BRACKET() { return getToken(TomlParser.DOUBLE_R_BRACKET, 0); }
public Array_tableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_array_table; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).enterArray_table(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TomlParserListener ) ((TomlParserListener)listener).exitArray_table(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TomlParserVisitor ) return ((TomlParserVisitor)visitor).visitArray_table(this);
else return visitor.visitChildren(this);
}
}
public final Array_tableContext array_table() throws RecognitionException {
Array_tableContext _localctx = new Array_tableContext(_ctx, getState());
enterRule(_localctx, 44, RULE_array_table);
try {
enterOuterAlt(_localctx, 1);
{
setState(167);
match(DOUBLE_L_BRACKET);
setState(168);
key();
setState(169);
match(DOUBLE_R_BRACKET);
}
}
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 \u00ac\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\u0002\u0015\u0007\u0015"+
"\u0002\u0016\u0007\u0016\u0001\u0000\u0001\u0000\u0001\u0000\u0005\u0000"+
"2\b\u0000\n\u0000\f\u00005\t\u0000\u0001\u0000\u0001\u0000\u0001\u0001"+
"\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
"\u0003\u0001@\b\u0001\u0001\u0002\u0003\u0002C\b\u0002\u0001\u0003\u0001"+
"\u0003\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0003\u0004K\b"+
"\u0004\u0001\u0005\u0001\u0005\u0003\u0005O\b\u0005\u0001\u0006\u0001"+
"\u0006\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0004\bX\b\b\u000b"+
"\b\f\bY\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003"+
"\tc\b\t\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001"+
"\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f"+
"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0005\u000f"+
"w\b\u000f\n\u000f\f\u000fz\t\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
"\u0001\u0010\u0003\u0010\u0080\b\u0010\u0001\u0010\u0005\u0010\u0083\b"+
"\u0010\n\u0010\f\u0010\u0086\t\u0010\u0001\u0011\u0001\u0011\u0003\u0011"+
"\u008a\b\u0011\u0005\u0011\u008c\b\u0011\n\u0011\f\u0011\u008f\t\u0011"+
"\u0001\u0012\u0001\u0012\u0003\u0012\u0093\b\u0012\u0001\u0013\u0001\u0013"+
"\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+
"\u0005\u0014\u009d\b\u0014\n\u0014\f\u0014\u00a0\t\u0014\u0001\u0014\u0001"+
"\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0016\u0001"+
"\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0000\u0000\u0017\u0000\u0002"+
"\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e"+
" \"$&(*,\u0000\u0005\u0001\u0000\u000b\f\u0002\u0000\u000b\f\u0011\u0012"+
"\u0001\u0000\u0016\u0019\u0001\u0000\u0013\u0015\u0001\u0000\u001a\u001d"+
"\u00a8\u0000.\u0001\u0000\u0000\u0000\u0002?\u0001\u0000\u0000\u0000\u0004"+
"B\u0001\u0000\u0000\u0000\u0006D\u0001\u0000\u0000\u0000\bJ\u0001\u0000"+
"\u0000\u0000\nN\u0001\u0000\u0000\u0000\fP\u0001\u0000\u0000\u0000\u000e"+
"R\u0001\u0000\u0000\u0000\u0010T\u0001\u0000\u0000\u0000\u0012b\u0001"+
"\u0000\u0000\u0000\u0014d\u0001\u0000\u0000\u0000\u0016f\u0001\u0000\u0000"+
"\u0000\u0018h\u0001\u0000\u0000\u0000\u001aj\u0001\u0000\u0000\u0000\u001c"+
"l\u0001\u0000\u0000\u0000\u001en\u0001\u0000\u0000\u0000 \u0084\u0001"+
"\u0000\u0000\u0000\"\u008d\u0001\u0000\u0000\u0000$\u0092\u0001\u0000"+
"\u0000\u0000&\u0094\u0001\u0000\u0000\u0000(\u0098\u0001\u0000\u0000\u0000"+
"*\u00a3\u0001\u0000\u0000\u0000,\u00a7\u0001\u0000\u0000\u0000.3\u0003"+
"\u0002\u0001\u0000/0\u0005\u0002\u0000\u000002\u0003\u0002\u0001\u0000"+
"1/\u0001\u0000\u0000\u000025\u0001\u0000\u0000\u000031\u0001\u0000\u0000"+
"\u000034\u0001\u0000\u0000\u000046\u0001\u0000\u0000\u000053\u0001\u0000"+
"\u0000\u000067\u0005\u0000\u0000\u00017\u0001\u0001\u0000\u0000\u0000"+
"89\u0003\u0006\u0003\u00009:\u0003\u0004\u0002\u0000:@\u0001\u0000\u0000"+
"\u0000;<\u0003$\u0012\u0000<=\u0003\u0004\u0002\u0000=@\u0001\u0000\u0000"+
"\u0000>@\u0003\u0004\u0002\u0000?8\u0001\u0000\u0000\u0000?;\u0001\u0000"+
"\u0000\u0000?>\u0001\u0000\u0000\u0000@\u0003\u0001\u0000\u0000\u0000"+
"AC\u0005\u0003\u0000\u0000BA\u0001\u0000\u0000\u0000BC\u0001\u0000\u0000"+
"\u0000C\u0005\u0001\u0000\u0000\u0000DE\u0003\b\u0004\u0000EF\u0005\b"+
"\u0000\u0000FG\u0003\u0012\t\u0000G\u0007\u0001\u0000\u0000\u0000HK\u0003"+
"\n\u0005\u0000IK\u0003\u0010\b\u0000JH\u0001\u0000\u0000\u0000JI\u0001"+
"\u0000\u0000\u0000K\t\u0001\u0000\u0000\u0000LO\u0003\u000e\u0007\u0000"+
"MO\u0003\f\u0006\u0000NL\u0001\u0000\u0000\u0000NM\u0001\u0000\u0000\u0000"+
"O\u000b\u0001\u0000\u0000\u0000PQ\u0005\r\u0000\u0000Q\r\u0001\u0000\u0000"+
"\u0000RS\u0007\u0000\u0000\u0000S\u000f\u0001\u0000\u0000\u0000TW\u0003"+
"\n\u0005\u0000UV\u0005\t\u0000\u0000VX\u0003\n\u0005\u0000WU\u0001\u0000"+
"\u0000\u0000XY\u0001\u0000\u0000\u0000YW\u0001\u0000\u0000\u0000YZ\u0001"+
"\u0000\u0000\u0000Z\u0011\u0001\u0000\u0000\u0000[c\u0003\u0014\n\u0000"+
"\\c\u0003\u0016\u000b\u0000]c\u0003\u0018\f\u0000^c\u0003\u001a\r\u0000"+
"_c\u0003\u001c\u000e\u0000`c\u0003\u001e\u000f\u0000ac\u0003(\u0014\u0000"+
"b[\u0001\u0000\u0000\u0000b\\\u0001\u0000\u0000\u0000b]\u0001\u0000\u0000"+
"\u0000b^\u0001\u0000\u0000\u0000b_\u0001\u0000\u0000\u0000b`\u0001\u0000"+
"\u0000\u0000ba\u0001\u0000\u0000\u0000c\u0013\u0001\u0000\u0000\u0000"+
"de\u0007\u0001\u0000\u0000e\u0015\u0001\u0000\u0000\u0000fg\u0007\u0002"+
"\u0000\u0000g\u0017\u0001\u0000\u0000\u0000hi\u0007\u0003\u0000\u0000"+
"i\u0019\u0001\u0000\u0000\u0000jk\u0005\u0010\u0000\u0000k\u001b\u0001"+
"\u0000\u0000\u0000lm\u0007\u0004\u0000\u0000m\u001d\u0001\u0000\u0000"+
"\u0000no\u0005\u0004\u0000\u0000op\u0003 \u0010\u0000pq\u0003\u0012\t"+
"\u0000qx\u0003\"\u0011\u0000rs\u0005\n\u0000\u0000st\u0003\u0012\t\u0000"+
"tu\u0003 \u0010\u0000uw\u0001\u0000\u0000\u0000vr\u0001\u0000\u0000\u0000"+
"wz\u0001\u0000\u0000\u0000xv\u0001\u0000\u0000\u0000xy\u0001\u0000\u0000"+
"\u0000y{\u0001\u0000\u0000\u0000zx\u0001\u0000\u0000\u0000{|\u0003 \u0010"+
"\u0000|}\u0005\u0006\u0000\u0000}\u001f\u0001\u0000\u0000\u0000~\u0080"+
"\u0005\u0003\u0000\u0000\u007f~\u0001\u0000\u0000\u0000\u007f\u0080\u0001"+
"\u0000\u0000\u0000\u0080\u0081\u0001\u0000\u0000\u0000\u0081\u0083\u0005"+
"\u0002\u0000\u0000\u0082\u007f\u0001\u0000\u0000\u0000\u0083\u0086\u0001"+
"\u0000\u0000\u0000\u0084\u0082\u0001\u0000\u0000\u0000\u0084\u0085\u0001"+
"\u0000\u0000\u0000\u0085!\u0001\u0000\u0000\u0000\u0086\u0084\u0001\u0000"+
"\u0000\u0000\u0087\u0089\u0005\u0002\u0000\u0000\u0088\u008a\u0005\u0003"+
"\u0000\u0000\u0089\u0088\u0001\u0000\u0000\u0000\u0089\u008a\u0001\u0000"+
"\u0000\u0000\u008a\u008c\u0001\u0000\u0000\u0000\u008b\u0087\u0001\u0000"+
"\u0000\u0000\u008c\u008f\u0001\u0000\u0000\u0000\u008d\u008b\u0001\u0000"+
"\u0000\u0000\u008d\u008e\u0001\u0000\u0000\u0000\u008e#\u0001\u0000\u0000"+
"\u0000\u008f\u008d\u0001\u0000\u0000\u0000\u0090\u0093\u0003&\u0013\u0000"+
"\u0091\u0093\u0003,\u0016\u0000\u0092\u0090\u0001\u0000\u0000\u0000\u0092"+
"\u0091\u0001\u0000\u0000\u0000\u0093%\u0001\u0000\u0000\u0000\u0094\u0095"+
"\u0005\u0004\u0000\u0000\u0095\u0096\u0003\b\u0004\u0000\u0096\u0097\u0005"+
"\u0006\u0000\u0000\u0097\'\u0001\u0000\u0000\u0000\u0098\u0099\u0005\u000f"+
"\u0000\u0000\u0099\u009e\u0003*\u0015\u0000\u009a\u009b\u0005\n\u0000"+
"\u0000\u009b\u009d\u0003*\u0015\u0000\u009c\u009a\u0001\u0000\u0000\u0000"+
"\u009d\u00a0\u0001\u0000\u0000\u0000\u009e\u009c\u0001\u0000\u0000\u0000"+
"\u009e\u009f\u0001\u0000\u0000\u0000\u009f\u00a1\u0001\u0000\u0000\u0000"+
"\u00a0\u009e\u0001\u0000\u0000\u0000\u00a1\u00a2\u0005\u001f\u0000\u0000"+
"\u00a2)\u0001\u0000\u0000\u0000\u00a3\u00a4\u0003\b\u0004\u0000\u00a4"+
"\u00a5\u0005\b\u0000\u0000\u00a5\u00a6\u0003\u0012\t\u0000\u00a6+\u0001"+
"\u0000\u0000\u0000\u00a7\u00a8\u0005\u0005\u0000\u0000\u00a8\u00a9\u0003"+
"\b\u0004\u0000\u00a9\u00aa\u0005\u0007\u0000\u0000\u00aa-\u0001\u0000"+
"\u0000\u0000\u000e3?BJNYbx\u007f\u0084\u0089\u008d\u0092\u009e";
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);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy