org.hpccsystems.ws.client.antlr.EclRecordParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of wsclient Show documentation
Show all versions of wsclient Show documentation
This project allows a user to interact with ESP services in a controlled manner. The API calls available under org.hpccsystems.ws.client.platform allow for a user to target ESP's across multiple environments running a range of hpccsystems-platform versions. There is no guarantee that if a user utilizes org.hpccsystems.ws.client.gen generated stub code from wsdl, that the calls will be backwards compatible with older hpccsystems-platform versions.
// Generated from EclRecord.g4 by ANTLR 4.7
package org.hpccsystems.ws.client.antlr;
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"})
public class EclRecordParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, OPAREN=15, CPAREN=16,
OCURLY=17, CCURLY=18, COMMA=19, SEMI=20, EQ=21, ASSING_SYM=22, REC_SYM=23,
END_SYM=24, DATASET_SYM=25, WS=26, INT=27, STRING=28, ATOKEN=29, TOKEN=30,
UTOKEN=31, ECL_NUMBERED_TYPE=32;
public static final int
RULE_program = 0, RULE_value = 1, RULE_value_list = 2, RULE_token_list = 3,
RULE_assign = 4, RULE_assign_list = 5, RULE_eclfield_decl = 6, RULE_eclfield_type = 7,
RULE_eclfield_name = 8, RULE_eclfield_recref = 9, RULE_record_def_inline = 10,
RULE_record_def = 11, RULE_defined_record_def = 12, RULE_exploded_dataset_record_def = 13,
RULE_inline_dataset_record_def = 14, RULE_record_defs = 15, RULE_nested_dataset_decl = 16,
RULE_nested_inline_dataset_decl = 17, RULE_opts = 18, RULE_opt = 19, RULE_maxlength = 20,
RULE_blob = 21, RULE_maxcount = 22, RULE_defaultval = 23, RULE_xpath = 24,
RULE_xmldefaultval = 25, RULE_annotation_name = 26, RULE_annotation_param = 27,
RULE_annotation_arguments = 28, RULE_annotation = 29, RULE_comment = 30;
public static final String[] ruleNames = {
"program", "value", "value_list", "token_list", "assign", "assign_list",
"eclfield_decl", "eclfield_type", "eclfield_name", "eclfield_recref",
"record_def_inline", "record_def", "defined_record_def", "exploded_dataset_record_def",
"inline_dataset_record_def", "record_defs", "nested_dataset_decl", "nested_inline_dataset_decl",
"opts", "opt", "maxlength", "blob", "maxcount", "defaultval", "xpath",
"xmldefaultval", "annotation_name", "annotation_param", "annotation_arguments",
"annotation", "comment"
};
private static final String[] _LITERAL_NAMES = {
null, "'SET OF'", "'set of'", "'MAXLENGTH'", "'maxlength'", "'maxLength'",
"'BLOB'", "'blob'", "'MAXCOUNT'", "'DEFAULT'", "'XPATH'", "'XMLDEFAULT'",
"'//'", "'/*'", "'*/'", "'('", "')'", "'{'", "'}'", "','", "';'", "'='",
"':='", "'RECORD'", "'END'", "'DATASET'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, "OPAREN", "CPAREN", "OCURLY", "CCURLY", "COMMA", "SEMI",
"EQ", "ASSING_SYM", "REC_SYM", "END_SYM", "DATASET_SYM", "WS", "INT",
"STRING", "ATOKEN", "TOKEN", "UTOKEN", "ECL_NUMBERED_TYPE"
};
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 "EclRecord.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public EclRecordParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ProgramContext extends ParserRuleContext {
public List record_defs() {
return getRuleContexts(Record_defsContext.class);
}
public Record_defsContext record_defs(int i) {
return getRuleContext(Record_defsContext.class,i);
}
public ProgramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_program; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterProgram(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitProgram(this);
}
}
public final ProgramContext program() throws RecognitionException {
ProgramContext _localctx = new ProgramContext(_ctx, getState());
enterRule(_localctx, 0, RULE_program);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(62);
record_defs();
setState(66);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OCURLY) | (1L << REC_SYM) | (1L << TOKEN) | (1L << UTOKEN))) != 0)) {
{
{
setState(63);
record_defs();
}
}
setState(68);
_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;
}
public static class ValueContext extends ParserRuleContext {
public TerminalNode UTOKEN() { return getToken(EclRecordParser.UTOKEN, 0); }
public TerminalNode TOKEN() { return getToken(EclRecordParser.TOKEN, 0); }
public TerminalNode INT() { return getToken(EclRecordParser.INT, 0); }
public TerminalNode STRING() { return getToken(EclRecordParser.STRING, 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 EclRecordListener ) ((EclRecordListener)listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitValue(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 2, RULE_value);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(69);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INT) | (1L << STRING) | (1L << TOKEN) | (1L << UTOKEN))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Value_listContext extends ParserRuleContext {
public List value() {
return getRuleContexts(ValueContext.class);
}
public ValueContext value(int i) {
return getRuleContext(ValueContext.class,i);
}
public List COMMA() { return getTokens(EclRecordParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EclRecordParser.COMMA, i);
}
public Value_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterValue_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitValue_list(this);
}
}
public final Value_listContext value_list() throws RecognitionException {
Value_listContext _localctx = new Value_listContext(_ctx, getState());
enterRule(_localctx, 4, RULE_value_list);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(71);
value();
setState(76);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(72);
match(COMMA);
setState(73);
value();
}
}
}
setState(78);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Token_listContext extends ParserRuleContext {
public List TOKEN() { return getTokens(EclRecordParser.TOKEN); }
public TerminalNode TOKEN(int i) {
return getToken(EclRecordParser.TOKEN, i);
}
public List COMMA() { return getTokens(EclRecordParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EclRecordParser.COMMA, i);
}
public Token_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_token_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterToken_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitToken_list(this);
}
}
public final Token_listContext token_list() throws RecognitionException {
Token_listContext _localctx = new Token_listContext(_ctx, getState());
enterRule(_localctx, 6, RULE_token_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(79);
match(TOKEN);
setState(84);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(80);
match(COMMA);
setState(81);
match(TOKEN);
}
}
setState(86);
_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;
}
public static class AssignContext extends ParserRuleContext {
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public TerminalNode EQ() { return getToken(EclRecordParser.EQ, 0); }
public Value_listContext value_list() {
return getRuleContext(Value_listContext.class,0);
}
public AssignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assign; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterAssign(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitAssign(this);
}
}
public final AssignContext assign() throws RecognitionException {
AssignContext _localctx = new AssignContext(_ctx, getState());
enterRule(_localctx, 8, RULE_assign);
try {
enterOuterAlt(_localctx, 1);
{
setState(87);
value();
setState(88);
match(EQ);
setState(89);
value_list();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Assign_listContext extends ParserRuleContext {
public List assign() {
return getRuleContexts(AssignContext.class);
}
public AssignContext assign(int i) {
return getRuleContext(AssignContext.class,i);
}
public List COMMA() { return getTokens(EclRecordParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EclRecordParser.COMMA, i);
}
public Assign_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assign_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterAssign_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitAssign_list(this);
}
}
public final Assign_listContext assign_list() throws RecognitionException {
Assign_listContext _localctx = new Assign_listContext(_ctx, getState());
enterRule(_localctx, 10, RULE_assign_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(91);
assign();
setState(96);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(92);
match(COMMA);
setState(93);
assign();
}
}
setState(98);
_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;
}
public static class Eclfield_declContext extends ParserRuleContext {
public Eclfield_typeContext eclfield_type() {
return getRuleContext(Eclfield_typeContext.class,0);
}
public Eclfield_nameContext eclfield_name() {
return getRuleContext(Eclfield_nameContext.class,0);
}
public Nested_dataset_declContext nested_dataset_decl() {
return getRuleContext(Nested_dataset_declContext.class,0);
}
public Nested_inline_dataset_declContext nested_inline_dataset_decl() {
return getRuleContext(Nested_inline_dataset_declContext.class,0);
}
public Eclfield_recrefContext eclfield_recref() {
return getRuleContext(Eclfield_recrefContext.class,0);
}
public Inline_dataset_record_defContext inline_dataset_record_def() {
return getRuleContext(Inline_dataset_record_defContext.class,0);
}
public TerminalNode OCURLY() { return getToken(EclRecordParser.OCURLY, 0); }
public OptsContext opts() {
return getRuleContext(OptsContext.class,0);
}
public TerminalNode CCURLY() { return getToken(EclRecordParser.CCURLY, 0); }
public Eclfield_declContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eclfield_decl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterEclfield_decl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitEclfield_decl(this);
}
}
public final Eclfield_declContext eclfield_decl() throws RecognitionException {
Eclfield_declContext _localctx = new Eclfield_declContext(_ctx, getState());
enterRule(_localctx, 12, RULE_eclfield_decl);
try {
enterOuterAlt(_localctx, 1);
{
setState(113);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(99);
eclfield_type();
setState(100);
eclfield_name();
setState(105);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(101);
match(OCURLY);
setState(102);
opts();
setState(103);
match(CCURLY);
}
break;
}
}
break;
case 2:
{
setState(107);
nested_dataset_decl();
}
break;
case 3:
{
setState(108);
nested_inline_dataset_decl();
}
break;
case 4:
{
{
setState(109);
inline_dataset_record_def();
setState(110);
eclfield_name();
}
}
break;
case 5:
{
setState(112);
eclfield_recref();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Eclfield_typeContext extends ParserRuleContext {
public TerminalNode UTOKEN() { return getToken(EclRecordParser.UTOKEN, 0); }
public TerminalNode TOKEN() { return getToken(EclRecordParser.TOKEN, 0); }
public Eclfield_typeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eclfield_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterEclfield_type(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitEclfield_type(this);
}
}
public final Eclfield_typeContext eclfield_type() throws RecognitionException {
Eclfield_typeContext _localctx = new Eclfield_typeContext(_ctx, getState());
enterRule(_localctx, 14, RULE_eclfield_type);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(116);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || _la==T__1) {
{
setState(115);
_la = _input.LA(1);
if ( !(_la==T__0 || _la==T__1) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(118);
_la = _input.LA(1);
if ( !(_la==TOKEN || _la==UTOKEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Eclfield_nameContext extends ParserRuleContext {
public TerminalNode UTOKEN() { return getToken(EclRecordParser.UTOKEN, 0); }
public TerminalNode TOKEN() { return getToken(EclRecordParser.TOKEN, 0); }
public Eclfield_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eclfield_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterEclfield_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitEclfield_name(this);
}
}
public final Eclfield_nameContext eclfield_name() throws RecognitionException {
Eclfield_nameContext _localctx = new Eclfield_nameContext(_ctx, getState());
enterRule(_localctx, 16, RULE_eclfield_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(120);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << TOKEN) | (1L << UTOKEN))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Eclfield_recrefContext extends ParserRuleContext {
public TerminalNode OPAREN() { return getToken(EclRecordParser.OPAREN, 0); }
public TerminalNode TOKEN() { return getToken(EclRecordParser.TOKEN, 0); }
public TerminalNode CPAREN() { return getToken(EclRecordParser.CPAREN, 0); }
public Eclfield_recrefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eclfield_recref; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterEclfield_recref(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitEclfield_recref(this);
}
}
public final Eclfield_recrefContext eclfield_recref() throws RecognitionException {
Eclfield_recrefContext _localctx = new Eclfield_recrefContext(_ctx, getState());
enterRule(_localctx, 18, RULE_eclfield_recref);
try {
enterOuterAlt(_localctx, 1);
{
setState(122);
match(OPAREN);
setState(123);
match(TOKEN);
setState(124);
match(CPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Record_def_inlineContext extends ParserRuleContext {
public TerminalNode OCURLY() { return getToken(EclRecordParser.OCURLY, 0); }
public List eclfield_decl() {
return getRuleContexts(Eclfield_declContext.class);
}
public Eclfield_declContext eclfield_decl(int i) {
return getRuleContext(Eclfield_declContext.class,i);
}
public TerminalNode CCURLY() { return getToken(EclRecordParser.CCURLY, 0); }
public TerminalNode SEMI() { return getToken(EclRecordParser.SEMI, 0); }
public List COMMA() { return getTokens(EclRecordParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EclRecordParser.COMMA, i);
}
public MaxlengthContext maxlength() {
return getRuleContext(MaxlengthContext.class,0);
}
public Record_def_inlineContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_record_def_inline; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterRecord_def_inline(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitRecord_def_inline(this);
}
}
public final Record_def_inlineContext record_def_inline() throws RecognitionException {
Record_def_inlineContext _localctx = new Record_def_inlineContext(_ctx, getState());
enterRule(_localctx, 20, RULE_record_def_inline);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(126);
match(OCURLY);
setState(129);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(127);
match(COMMA);
setState(128);
maxlength();
}
}
setState(131);
eclfield_decl();
setState(141);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << OPAREN) | (1L << OCURLY) | (1L << COMMA) | (1L << DATASET_SYM) | (1L << TOKEN) | (1L << UTOKEN))) != 0)) {
{
{
setState(135);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(132);
match(COMMA);
}
}
setState(137);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(138);
eclfield_decl();
}
}
setState(143);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(144);
match(CCURLY);
setState(145);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Record_defContext extends ParserRuleContext {
public TerminalNode REC_SYM() { return getToken(EclRecordParser.REC_SYM, 0); }
public List eclfield_decl() {
return getRuleContexts(Eclfield_declContext.class);
}
public Eclfield_declContext eclfield_decl(int i) {
return getRuleContext(Eclfield_declContext.class,i);
}
public List SEMI() { return getTokens(EclRecordParser.SEMI); }
public TerminalNode SEMI(int i) {
return getToken(EclRecordParser.SEMI, i);
}
public TerminalNode END_SYM() { return getToken(EclRecordParser.END_SYM, 0); }
public TerminalNode COMMA() { return getToken(EclRecordParser.COMMA, 0); }
public MaxlengthContext maxlength() {
return getRuleContext(MaxlengthContext.class,0);
}
public List comment() {
return getRuleContexts(CommentContext.class);
}
public CommentContext comment(int i) {
return getRuleContext(CommentContext.class,i);
}
public Record_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_record_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterRecord_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitRecord_def(this);
}
}
public final Record_defContext record_def() throws RecognitionException {
Record_defContext _localctx = new Record_defContext(_ctx, getState());
enterRule(_localctx, 22, RULE_record_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(147);
match(REC_SYM);
setState(150);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(148);
match(COMMA);
setState(149);
maxlength();
}
}
setState(153);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__11 || _la==T__12) {
{
setState(152);
comment();
}
}
setState(155);
eclfield_decl();
setState(156);
match(SEMI);
setState(158);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__11 || _la==T__12) {
{
setState(157);
comment();
}
}
setState(167);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << OPAREN) | (1L << OCURLY) | (1L << DATASET_SYM) | (1L << TOKEN) | (1L << UTOKEN))) != 0)) {
{
{
setState(160);
eclfield_decl();
setState(161);
match(SEMI);
setState(163);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__11 || _la==T__12) {
{
setState(162);
comment();
}
}
}
}
setState(169);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(170);
match(END_SYM);
setState(171);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Defined_record_defContext extends ParserRuleContext {
public TerminalNode ASSING_SYM() { return getToken(EclRecordParser.ASSING_SYM, 0); }
public TerminalNode UTOKEN() { return getToken(EclRecordParser.UTOKEN, 0); }
public TerminalNode TOKEN() { return getToken(EclRecordParser.TOKEN, 0); }
public Record_defContext record_def() {
return getRuleContext(Record_defContext.class,0);
}
public Record_def_inlineContext record_def_inline() {
return getRuleContext(Record_def_inlineContext.class,0);
}
public Defined_record_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defined_record_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterDefined_record_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitDefined_record_def(this);
}
}
public final Defined_record_defContext defined_record_def() throws RecognitionException {
Defined_record_defContext _localctx = new Defined_record_defContext(_ctx, getState());
enterRule(_localctx, 24, RULE_defined_record_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(173);
_la = _input.LA(1);
if ( !(_la==TOKEN || _la==UTOKEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(174);
match(ASSING_SYM);
setState(177);
_errHandler.sync(this);
switch (_input.LA(1)) {
case REC_SYM:
{
setState(175);
record_def();
}
break;
case OCURLY:
{
setState(176);
record_def_inline();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Exploded_dataset_record_defContext extends ParserRuleContext {
public TerminalNode REC_SYM() { return getToken(EclRecordParser.REC_SYM, 0); }
public List eclfield_decl() {
return getRuleContexts(Eclfield_declContext.class);
}
public Eclfield_declContext eclfield_decl(int i) {
return getRuleContext(Eclfield_declContext.class,i);
}
public List SEMI() { return getTokens(EclRecordParser.SEMI); }
public TerminalNode SEMI(int i) {
return getToken(EclRecordParser.SEMI, i);
}
public TerminalNode END_SYM() { return getToken(EclRecordParser.END_SYM, 0); }
public TerminalNode COMMA() { return getToken(EclRecordParser.COMMA, 0); }
public MaxlengthContext maxlength() {
return getRuleContext(MaxlengthContext.class,0);
}
public List comment() {
return getRuleContexts(CommentContext.class);
}
public CommentContext comment(int i) {
return getRuleContext(CommentContext.class,i);
}
public Exploded_dataset_record_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exploded_dataset_record_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterExploded_dataset_record_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitExploded_dataset_record_def(this);
}
}
public final Exploded_dataset_record_defContext exploded_dataset_record_def() throws RecognitionException {
Exploded_dataset_record_defContext _localctx = new Exploded_dataset_record_defContext(_ctx, getState());
enterRule(_localctx, 26, RULE_exploded_dataset_record_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(179);
match(REC_SYM);
setState(182);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(180);
match(COMMA);
setState(181);
maxlength();
}
}
setState(185);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__11 || _la==T__12) {
{
setState(184);
comment();
}
}
setState(187);
eclfield_decl();
setState(188);
match(SEMI);
setState(190);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__11 || _la==T__12) {
{
setState(189);
comment();
}
}
setState(199);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << OPAREN) | (1L << OCURLY) | (1L << DATASET_SYM) | (1L << TOKEN) | (1L << UTOKEN))) != 0)) {
{
{
setState(192);
eclfield_decl();
setState(193);
match(SEMI);
setState(195);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__11 || _la==T__12) {
{
setState(194);
comment();
}
}
}
}
setState(201);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(202);
match(END_SYM);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Inline_dataset_record_defContext extends ParserRuleContext {
public TerminalNode OCURLY() { return getToken(EclRecordParser.OCURLY, 0); }
public List eclfield_decl() {
return getRuleContexts(Eclfield_declContext.class);
}
public Eclfield_declContext eclfield_decl(int i) {
return getRuleContext(Eclfield_declContext.class,i);
}
public TerminalNode CCURLY() { return getToken(EclRecordParser.CCURLY, 0); }
public List COMMA() { return getTokens(EclRecordParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EclRecordParser.COMMA, i);
}
public Inline_dataset_record_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inline_dataset_record_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterInline_dataset_record_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitInline_dataset_record_def(this);
}
}
public final Inline_dataset_record_defContext inline_dataset_record_def() throws RecognitionException {
Inline_dataset_record_defContext _localctx = new Inline_dataset_record_defContext(_ctx, getState());
enterRule(_localctx, 28, RULE_inline_dataset_record_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(204);
match(OCURLY);
setState(205);
eclfield_decl();
setState(210);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(206);
match(COMMA);
setState(207);
eclfield_decl();
}
}
setState(212);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(213);
match(CCURLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Record_defsContext extends ParserRuleContext {
public Record_def_inlineContext record_def_inline() {
return getRuleContext(Record_def_inlineContext.class,0);
}
public Record_defContext record_def() {
return getRuleContext(Record_defContext.class,0);
}
public Defined_record_defContext defined_record_def() {
return getRuleContext(Defined_record_defContext.class,0);
}
public Record_defsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_record_defs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterRecord_defs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitRecord_defs(this);
}
}
public final Record_defsContext record_defs() throws RecognitionException {
Record_defsContext _localctx = new Record_defsContext(_ctx, getState());
enterRule(_localctx, 30, RULE_record_defs);
try {
setState(218);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OCURLY:
enterOuterAlt(_localctx, 1);
{
setState(215);
record_def_inline();
}
break;
case REC_SYM:
enterOuterAlt(_localctx, 2);
{
setState(216);
record_def();
}
break;
case TOKEN:
case UTOKEN:
enterOuterAlt(_localctx, 3);
{
setState(217);
defined_record_def();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Nested_dataset_declContext extends ParserRuleContext {
public List UTOKEN() { return getTokens(EclRecordParser.UTOKEN); }
public TerminalNode UTOKEN(int i) {
return getToken(EclRecordParser.UTOKEN, i);
}
public List TOKEN() { return getTokens(EclRecordParser.TOKEN); }
public TerminalNode TOKEN(int i) {
return getToken(EclRecordParser.TOKEN, i);
}
public OptsContext opts() {
return getRuleContext(OptsContext.class,0);
}
public Nested_dataset_declContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nested_dataset_decl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterNested_dataset_decl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitNested_dataset_decl(this);
}
}
public final Nested_dataset_declContext nested_dataset_decl() throws RecognitionException {
Nested_dataset_declContext _localctx = new Nested_dataset_declContext(_ctx, getState());
enterRule(_localctx, 32, RULE_nested_dataset_decl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(220);
match(DATASET_SYM);
setState(221);
match(OPAREN);
setState(222);
_la = _input.LA(1);
if ( !(_la==TOKEN || _la==UTOKEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(223);
match(CPAREN);
setState(224);
_la = _input.LA(1);
if ( !(_la==TOKEN || _la==UTOKEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(229);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
setState(225);
match(OCURLY);
setState(226);
opts();
setState(227);
match(CCURLY);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Nested_inline_dataset_declContext extends ParserRuleContext {
public TerminalNode DATASET_SYM() { return getToken(EclRecordParser.DATASET_SYM, 0); }
public TerminalNode OPAREN() { return getToken(EclRecordParser.OPAREN, 0); }
public TerminalNode CPAREN() { return getToken(EclRecordParser.CPAREN, 0); }
public TerminalNode TOKEN() { return getToken(EclRecordParser.TOKEN, 0); }
public TerminalNode UTOKEN() { return getToken(EclRecordParser.UTOKEN, 0); }
public Exploded_dataset_record_defContext exploded_dataset_record_def() {
return getRuleContext(Exploded_dataset_record_defContext.class,0);
}
public Inline_dataset_record_defContext inline_dataset_record_def() {
return getRuleContext(Inline_dataset_record_defContext.class,0);
}
public TerminalNode OCURLY() { return getToken(EclRecordParser.OCURLY, 0); }
public OptsContext opts() {
return getRuleContext(OptsContext.class,0);
}
public TerminalNode CCURLY() { return getToken(EclRecordParser.CCURLY, 0); }
public Nested_inline_dataset_declContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nested_inline_dataset_decl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterNested_inline_dataset_decl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitNested_inline_dataset_decl(this);
}
}
public final Nested_inline_dataset_declContext nested_inline_dataset_decl() throws RecognitionException {
Nested_inline_dataset_declContext _localctx = new Nested_inline_dataset_declContext(_ctx, getState());
enterRule(_localctx, 34, RULE_nested_inline_dataset_decl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(231);
match(DATASET_SYM);
setState(232);
match(OPAREN);
setState(235);
_errHandler.sync(this);
switch (_input.LA(1)) {
case REC_SYM:
{
setState(233);
exploded_dataset_record_def();
}
break;
case OCURLY:
{
setState(234);
inline_dataset_record_def();
}
break;
default:
throw new NoViableAltException(this);
}
setState(237);
match(CPAREN);
setState(238);
_la = _input.LA(1);
if ( !(_la==TOKEN || _la==UTOKEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(243);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(239);
match(OCURLY);
setState(240);
opts();
setState(241);
match(CCURLY);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptsContext extends ParserRuleContext {
public List opt() {
return getRuleContexts(OptContext.class);
}
public OptContext opt(int i) {
return getRuleContext(OptContext.class,i);
}
public List COMMA() { return getTokens(EclRecordParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EclRecordParser.COMMA, i);
}
public OptsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_opts; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterOpts(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitOpts(this);
}
}
public final OptsContext opts() throws RecognitionException {
OptsContext _localctx = new OptsContext(_ctx, getState());
enterRule(_localctx, 36, RULE_opts);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(245);
opt();
setState(250);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(246);
match(COMMA);
setState(247);
opt();
}
}
setState(252);
_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;
}
public static class OptContext extends ParserRuleContext {
public MaxlengthContext maxlength() {
return getRuleContext(MaxlengthContext.class,0);
}
public MaxcountContext maxcount() {
return getRuleContext(MaxcountContext.class,0);
}
public DefaultvalContext defaultval() {
return getRuleContext(DefaultvalContext.class,0);
}
public XpathContext xpath() {
return getRuleContext(XpathContext.class,0);
}
public XmldefaultvalContext xmldefaultval() {
return getRuleContext(XmldefaultvalContext.class,0);
}
public BlobContext blob() {
return getRuleContext(BlobContext.class,0);
}
public OptContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_opt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterOpt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitOpt(this);
}
}
public final OptContext opt() throws RecognitionException {
OptContext _localctx = new OptContext(_ctx, getState());
enterRule(_localctx, 38, RULE_opt);
try {
setState(259);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__2:
case T__3:
case T__4:
enterOuterAlt(_localctx, 1);
{
setState(253);
maxlength();
}
break;
case T__7:
enterOuterAlt(_localctx, 2);
{
setState(254);
maxcount();
}
break;
case T__8:
enterOuterAlt(_localctx, 3);
{
setState(255);
defaultval();
}
break;
case T__9:
enterOuterAlt(_localctx, 4);
{
setState(256);
xpath();
}
break;
case T__10:
enterOuterAlt(_localctx, 5);
{
setState(257);
xmldefaultval();
}
break;
case T__5:
case T__6:
enterOuterAlt(_localctx, 6);
{
setState(258);
blob();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MaxlengthContext extends ParserRuleContext {
public TerminalNode OPAREN() { return getToken(EclRecordParser.OPAREN, 0); }
public TerminalNode INT() { return getToken(EclRecordParser.INT, 0); }
public TerminalNode CPAREN() { return getToken(EclRecordParser.CPAREN, 0); }
public MaxlengthContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_maxlength; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterMaxlength(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitMaxlength(this);
}
}
public final MaxlengthContext maxlength() throws RecognitionException {
MaxlengthContext _localctx = new MaxlengthContext(_ctx, getState());
enterRule(_localctx, 40, RULE_maxlength);
try {
enterOuterAlt(_localctx, 1);
{
setState(273);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__2:
{
setState(261);
match(T__2);
setState(262);
match(OPAREN);
setState(263);
match(INT);
setState(264);
match(CPAREN);
}
break;
case T__3:
{
setState(265);
match(T__3);
setState(266);
match(OPAREN);
setState(267);
match(INT);
setState(268);
match(CPAREN);
}
break;
case T__4:
{
setState(269);
match(T__4);
setState(270);
match(OPAREN);
setState(271);
match(INT);
setState(272);
match(CPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlobContext extends ParserRuleContext {
public BlobContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blob; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterBlob(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitBlob(this);
}
}
public final BlobContext blob() throws RecognitionException {
BlobContext _localctx = new BlobContext(_ctx, getState());
enterRule(_localctx, 42, RULE_blob);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(275);
_la = _input.LA(1);
if ( !(_la==T__5 || _la==T__6) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MaxcountContext extends ParserRuleContext {
public TerminalNode OPAREN() { return getToken(EclRecordParser.OPAREN, 0); }
public TerminalNode INT() { return getToken(EclRecordParser.INT, 0); }
public TerminalNode CPAREN() { return getToken(EclRecordParser.CPAREN, 0); }
public MaxcountContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_maxcount; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterMaxcount(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitMaxcount(this);
}
}
public final MaxcountContext maxcount() throws RecognitionException {
MaxcountContext _localctx = new MaxcountContext(_ctx, getState());
enterRule(_localctx, 44, RULE_maxcount);
try {
enterOuterAlt(_localctx, 1);
{
setState(277);
match(T__7);
setState(278);
match(OPAREN);
setState(279);
match(INT);
setState(280);
match(CPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultvalContext extends ParserRuleContext {
public TerminalNode OPAREN() { return getToken(EclRecordParser.OPAREN, 0); }
public TerminalNode STRING() { return getToken(EclRecordParser.STRING, 0); }
public TerminalNode CPAREN() { return getToken(EclRecordParser.CPAREN, 0); }
public DefaultvalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultval; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterDefaultval(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitDefaultval(this);
}
}
public final DefaultvalContext defaultval() throws RecognitionException {
DefaultvalContext _localctx = new DefaultvalContext(_ctx, getState());
enterRule(_localctx, 46, RULE_defaultval);
try {
enterOuterAlt(_localctx, 1);
{
setState(282);
match(T__8);
setState(283);
match(OPAREN);
setState(284);
match(STRING);
setState(285);
match(CPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class XpathContext extends ParserRuleContext {
public TerminalNode OPAREN() { return getToken(EclRecordParser.OPAREN, 0); }
public TerminalNode STRING() { return getToken(EclRecordParser.STRING, 0); }
public TerminalNode CPAREN() { return getToken(EclRecordParser.CPAREN, 0); }
public XpathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_xpath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterXpath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitXpath(this);
}
}
public final XpathContext xpath() throws RecognitionException {
XpathContext _localctx = new XpathContext(_ctx, getState());
enterRule(_localctx, 48, RULE_xpath);
try {
enterOuterAlt(_localctx, 1);
{
setState(287);
match(T__9);
setState(288);
match(OPAREN);
setState(289);
match(STRING);
setState(290);
match(CPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class XmldefaultvalContext extends ParserRuleContext {
public TerminalNode OPAREN() { return getToken(EclRecordParser.OPAREN, 0); }
public TerminalNode STRING() { return getToken(EclRecordParser.STRING, 0); }
public TerminalNode CPAREN() { return getToken(EclRecordParser.CPAREN, 0); }
public XmldefaultvalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_xmldefaultval; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterXmldefaultval(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitXmldefaultval(this);
}
}
public final XmldefaultvalContext xmldefaultval() throws RecognitionException {
XmldefaultvalContext _localctx = new XmldefaultvalContext(_ctx, getState());
enterRule(_localctx, 50, RULE_xmldefaultval);
try {
enterOuterAlt(_localctx, 1);
{
setState(292);
match(T__10);
setState(293);
match(OPAREN);
setState(294);
match(STRING);
setState(295);
match(CPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Annotation_nameContext extends ParserRuleContext {
public TerminalNode ATOKEN() { return getToken(EclRecordParser.ATOKEN, 0); }
public Annotation_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotation_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterAnnotation_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitAnnotation_name(this);
}
}
public final Annotation_nameContext annotation_name() throws RecognitionException {
Annotation_nameContext _localctx = new Annotation_nameContext(_ctx, getState());
enterRule(_localctx, 52, RULE_annotation_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(297);
match(ATOKEN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Annotation_paramContext extends ParserRuleContext {
public TerminalNode TOKEN() { return getToken(EclRecordParser.TOKEN, 0); }
public TerminalNode UTOKEN() { return getToken(EclRecordParser.UTOKEN, 0); }
public Annotation_paramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotation_param; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterAnnotation_param(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitAnnotation_param(this);
}
}
public final Annotation_paramContext annotation_param() throws RecognitionException {
Annotation_paramContext _localctx = new Annotation_paramContext(_ctx, getState());
enterRule(_localctx, 54, RULE_annotation_param);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(299);
_la = _input.LA(1);
if ( !(_la==TOKEN || _la==UTOKEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Annotation_argumentsContext extends ParserRuleContext {
public List annotation_param() {
return getRuleContexts(Annotation_paramContext.class);
}
public Annotation_paramContext annotation_param(int i) {
return getRuleContext(Annotation_paramContext.class,i);
}
public List COMMA() { return getTokens(EclRecordParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EclRecordParser.COMMA, i);
}
public Annotation_argumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotation_arguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterAnnotation_arguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitAnnotation_arguments(this);
}
}
public final Annotation_argumentsContext annotation_arguments() throws RecognitionException {
Annotation_argumentsContext _localctx = new Annotation_argumentsContext(_ctx, getState());
enterRule(_localctx, 56, RULE_annotation_arguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(301);
annotation_param();
setState(306);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(302);
match(COMMA);
setState(303);
annotation_param();
}
}
setState(308);
_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;
}
public static class AnnotationContext extends ParserRuleContext {
public Annotation_nameContext annotation_name() {
return getRuleContext(Annotation_nameContext.class,0);
}
public TerminalNode OPAREN() { return getToken(EclRecordParser.OPAREN, 0); }
public Annotation_argumentsContext annotation_arguments() {
return getRuleContext(Annotation_argumentsContext.class,0);
}
public TerminalNode CPAREN() { return getToken(EclRecordParser.CPAREN, 0); }
public AnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).enterAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitAnnotation(this);
}
}
public final AnnotationContext annotation() throws RecognitionException {
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
enterRule(_localctx, 58, RULE_annotation);
try {
enterOuterAlt(_localctx, 1);
{
setState(309);
annotation_name();
setState(314);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
{
setState(310);
match(OPAREN);
setState(311);
annotation_arguments();
setState(312);
match(CPAREN);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommentContext extends ParserRuleContext {
public List annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public List COMMA() { return getTokens(EclRecordParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(EclRecordParser.COMMA, i);
}
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 EclRecordListener ) ((EclRecordListener)listener).enterComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EclRecordListener ) ((EclRecordListener)listener).exitComment(this);
}
}
public final CommentContext comment() throws RecognitionException {
CommentContext _localctx = new CommentContext(_ctx, getState());
enterRule(_localctx, 60, RULE_comment);
try {
int _alt;
setState(360);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__11:
enterOuterAlt(_localctx, 1);
{
{
setState(316);
match(T__11);
setState(318);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(317);
annotation();
}
break;
}
setState(324);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(320);
match(COMMA);
setState(321);
annotation();
}
}
}
setState(326);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
}
setState(330);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(327);
matchWildcard();
}
}
}
setState(332);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
}
}
}
break;
case T__12:
enterOuterAlt(_localctx, 2);
{
{
setState(333);
match(T__12);
setState(335);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
{
setState(334);
annotation();
}
break;
}
setState(341);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(337);
match(COMMA);
setState(338);
annotation();
}
}
}
setState(343);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
}
setState(347);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(344);
matchWildcard();
}
}
}
setState(349);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
}
setState(358);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
{
setState(353);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(350);
matchWildcard();
}
}
}
setState(355);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
}
setState(356);
match(T__13);
}
break;
case 2:
{
setState(357);
match(T__13);
}
break;
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\"\u016d\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \3\2"+
"\3\2\7\2C\n\2\f\2\16\2F\13\2\3\3\3\3\3\4\3\4\3\4\7\4M\n\4\f\4\16\4P\13"+
"\4\3\5\3\5\3\5\7\5U\n\5\f\5\16\5X\13\5\3\6\3\6\3\6\3\6\3\7\3\7\3\7\7\7"+
"a\n\7\f\7\16\7d\13\7\3\b\3\b\3\b\3\b\3\b\3\b\5\bl\n\b\3\b\3\b\3\b\3\b"+
"\3\b\3\b\5\bt\n\b\3\t\5\tw\n\t\3\t\3\t\3\n\3\n\3\13\3\13\3\13\3\13\3\f"+
"\3\f\3\f\5\f\u0084\n\f\3\f\3\f\7\f\u0088\n\f\f\f\16\f\u008b\13\f\3\f\7"+
"\f\u008e\n\f\f\f\16\f\u0091\13\f\3\f\3\f\3\f\3\r\3\r\3\r\5\r\u0099\n\r"+
"\3\r\5\r\u009c\n\r\3\r\3\r\3\r\5\r\u00a1\n\r\3\r\3\r\3\r\5\r\u00a6\n\r"+
"\7\r\u00a8\n\r\f\r\16\r\u00ab\13\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\5\16"+
"\u00b4\n\16\3\17\3\17\3\17\5\17\u00b9\n\17\3\17\5\17\u00bc\n\17\3\17\3"+
"\17\3\17\5\17\u00c1\n\17\3\17\3\17\3\17\5\17\u00c6\n\17\7\17\u00c8\n\17"+
"\f\17\16\17\u00cb\13\17\3\17\3\17\3\20\3\20\3\20\3\20\7\20\u00d3\n\20"+
"\f\20\16\20\u00d6\13\20\3\20\3\20\3\21\3\21\3\21\5\21\u00dd\n\21\3\22"+
"\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u00e8\n\22\3\23\3\23\3\23"+
"\3\23\5\23\u00ee\n\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u00f6\n\23\3"+
"\24\3\24\3\24\7\24\u00fb\n\24\f\24\16\24\u00fe\13\24\3\25\3\25\3\25\3"+
"\25\3\25\3\25\5\25\u0106\n\25\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+
"\3\26\3\26\3\26\3\26\5\26\u0114\n\26\3\27\3\27\3\30\3\30\3\30\3\30\3\30"+
"\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33"+
"\3\33\3\34\3\34\3\35\3\35\3\36\3\36\3\36\7\36\u0133\n\36\f\36\16\36\u0136"+
"\13\36\3\37\3\37\3\37\3\37\3\37\5\37\u013d\n\37\3 \3 \5 \u0141\n \3 \3"+
" \7 \u0145\n \f \16 \u0148\13 \3 \7 \u014b\n \f \16 \u014e\13 \3 \3 \5"+
" \u0152\n \3 \3 \7 \u0156\n \f \16 \u0159\13 \3 \7 \u015c\n \f \16 \u015f"+
"\13 \3 \7 \u0162\n \f \16 \u0165\13 \3 \3 \5 \u0169\n \5 \u016b\n \3 "+
"\5\u014c\u015d\u0163\2!\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*"+
",.\60\62\64\668:<>\2\7\4\2\35\36 !\3\2\3\4\3\2 !\4\2\5\6 !\3\2\b\t\2\u017e"+
"\2@\3\2\2\2\4G\3\2\2\2\6I\3\2\2\2\bQ\3\2\2\2\nY\3\2\2\2\f]\3\2\2\2\16"+
"s\3\2\2\2\20v\3\2\2\2\22z\3\2\2\2\24|\3\2\2\2\26\u0080\3\2\2\2\30\u0095"+
"\3\2\2\2\32\u00af\3\2\2\2\34\u00b5\3\2\2\2\36\u00ce\3\2\2\2 \u00dc\3\2"+
"\2\2\"\u00de\3\2\2\2$\u00e9\3\2\2\2&\u00f7\3\2\2\2(\u0105\3\2\2\2*\u0113"+
"\3\2\2\2,\u0115\3\2\2\2.\u0117\3\2\2\2\60\u011c\3\2\2\2\62\u0121\3\2\2"+
"\2\64\u0126\3\2\2\2\66\u012b\3\2\2\28\u012d\3\2\2\2:\u012f\3\2\2\2<\u0137"+
"\3\2\2\2>\u016a\3\2\2\2@D\5 \21\2AC\5 \21\2BA\3\2\2\2CF\3\2\2\2DB\3\2"+
"\2\2DE\3\2\2\2E\3\3\2\2\2FD\3\2\2\2GH\t\2\2\2H\5\3\2\2\2IN\5\4\3\2JK\7"+
"\25\2\2KM\5\4\3\2LJ\3\2\2\2MP\3\2\2\2NL\3\2\2\2NO\3\2\2\2O\7\3\2\2\2P"+
"N\3\2\2\2QV\7 \2\2RS\7\25\2\2SU\7 \2\2TR\3\2\2\2UX\3\2\2\2VT\3\2\2\2V"+
"W\3\2\2\2W\t\3\2\2\2XV\3\2\2\2YZ\5\4\3\2Z[\7\27\2\2[\\\5\6\4\2\\\13\3"+
"\2\2\2]b\5\n\6\2^_\7\25\2\2_a\5\n\6\2`^\3\2\2\2ad\3\2\2\2b`\3\2\2\2bc"+
"\3\2\2\2c\r\3\2\2\2db\3\2\2\2ef\5\20\t\2fk\5\22\n\2gh\7\23\2\2hi\5&\24"+
"\2ij\7\24\2\2jl\3\2\2\2kg\3\2\2\2kl\3\2\2\2lt\3\2\2\2mt\5\"\22\2nt\5$"+
"\23\2op\5\36\20\2pq\5\22\n\2qt\3\2\2\2rt\5\24\13\2se\3\2\2\2sm\3\2\2\2"+
"sn\3\2\2\2so\3\2\2\2sr\3\2\2\2t\17\3\2\2\2uw\t\3\2\2vu\3\2\2\2vw\3\2\2"+
"\2wx\3\2\2\2xy\t\4\2\2y\21\3\2\2\2z{\t\5\2\2{\23\3\2\2\2|}\7\21\2\2}~"+
"\7 \2\2~\177\7\22\2\2\177\25\3\2\2\2\u0080\u0083\7\23\2\2\u0081\u0082"+
"\7\25\2\2\u0082\u0084\5*\26\2\u0083\u0081\3\2\2\2\u0083\u0084\3\2\2\2"+
"\u0084\u0085\3\2\2\2\u0085\u008f\5\16\b\2\u0086\u0088\7\25\2\2\u0087\u0086"+
"\3\2\2\2\u0088\u008b\3\2\2\2\u0089\u0087\3\2\2\2\u0089\u008a\3\2\2\2\u008a"+
"\u008c\3\2\2\2\u008b\u0089\3\2\2\2\u008c\u008e\5\16\b\2\u008d\u0089\3"+
"\2\2\2\u008e\u0091\3\2\2\2\u008f\u008d\3\2\2\2\u008f\u0090\3\2\2\2\u0090"+
"\u0092\3\2\2\2\u0091\u008f\3\2\2\2\u0092\u0093\7\24\2\2\u0093\u0094\7"+
"\26\2\2\u0094\27\3\2\2\2\u0095\u0098\7\31\2\2\u0096\u0097\7\25\2\2\u0097"+
"\u0099\5*\26\2\u0098\u0096\3\2\2\2\u0098\u0099\3\2\2\2\u0099\u009b\3\2"+
"\2\2\u009a\u009c\5> \2\u009b\u009a\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009d"+
"\3\2\2\2\u009d\u009e\5\16\b\2\u009e\u00a0\7\26\2\2\u009f\u00a1\5> \2\u00a0"+
"\u009f\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a9\3\2\2\2\u00a2\u00a3\5\16"+
"\b\2\u00a3\u00a5\7\26\2\2\u00a4\u00a6\5> \2\u00a5\u00a4\3\2\2\2\u00a5"+
"\u00a6\3\2\2\2\u00a6\u00a8\3\2\2\2\u00a7\u00a2\3\2\2\2\u00a8\u00ab\3\2"+
"\2\2\u00a9\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ac\3\2\2\2\u00ab"+
"\u00a9\3\2\2\2\u00ac\u00ad\7\32\2\2\u00ad\u00ae\7\26\2\2\u00ae\31\3\2"+
"\2\2\u00af\u00b0\t\4\2\2\u00b0\u00b3\7\30\2\2\u00b1\u00b4\5\30\r\2\u00b2"+
"\u00b4\5\26\f\2\u00b3\u00b1\3\2\2\2\u00b3\u00b2\3\2\2\2\u00b4\33\3\2\2"+
"\2\u00b5\u00b8\7\31\2\2\u00b6\u00b7\7\25\2\2\u00b7\u00b9\5*\26\2\u00b8"+
"\u00b6\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\u00bb\3\2\2\2\u00ba\u00bc\5>"+
" \2\u00bb\u00ba\3\2\2\2\u00bb\u00bc\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd"+
"\u00be\5\16\b\2\u00be\u00c0\7\26\2\2\u00bf\u00c1\5> \2\u00c0\u00bf\3\2"+
"\2\2\u00c0\u00c1\3\2\2\2\u00c1\u00c9\3\2\2\2\u00c2\u00c3\5\16\b\2\u00c3"+
"\u00c5\7\26\2\2\u00c4\u00c6\5> \2\u00c5\u00c4\3\2\2\2\u00c5\u00c6\3\2"+
"\2\2\u00c6\u00c8\3\2\2\2\u00c7\u00c2\3\2\2\2\u00c8\u00cb\3\2\2\2\u00c9"+
"\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cc\3\2\2\2\u00cb\u00c9\3\2"+
"\2\2\u00cc\u00cd\7\32\2\2\u00cd\35\3\2\2\2\u00ce\u00cf\7\23\2\2\u00cf"+
"\u00d4\5\16\b\2\u00d0\u00d1\7\25\2\2\u00d1\u00d3\5\16\b\2\u00d2\u00d0"+
"\3\2\2\2\u00d3\u00d6\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5"+
"\u00d7\3\2\2\2\u00d6\u00d4\3\2\2\2\u00d7\u00d8\7\24\2\2\u00d8\37\3\2\2"+
"\2\u00d9\u00dd\5\26\f\2\u00da\u00dd\5\30\r\2\u00db\u00dd\5\32\16\2\u00dc"+
"\u00d9\3\2\2\2\u00dc\u00da\3\2\2\2\u00dc\u00db\3\2\2\2\u00dd!\3\2\2\2"+
"\u00de\u00df\7\33\2\2\u00df\u00e0\7\21\2\2\u00e0\u00e1\t\4\2\2\u00e1\u00e2"+
"\7\22\2\2\u00e2\u00e7\t\4\2\2\u00e3\u00e4\7\23\2\2\u00e4\u00e5\5&\24\2"+
"\u00e5\u00e6\7\24\2\2\u00e6\u00e8\3\2\2\2\u00e7\u00e3\3\2\2\2\u00e7\u00e8"+
"\3\2\2\2\u00e8#\3\2\2\2\u00e9\u00ea\7\33\2\2\u00ea\u00ed\7\21\2\2\u00eb"+
"\u00ee\5\34\17\2\u00ec\u00ee\5\36\20\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec"+
"\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\7\22\2\2\u00f0\u00f5\t\4\2\2"+
"\u00f1\u00f2\7\23\2\2\u00f2\u00f3\5&\24\2\u00f3\u00f4\7\24\2\2\u00f4\u00f6"+
"\3\2\2\2\u00f5\u00f1\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6%\3\2\2\2\u00f7"+
"\u00fc\5(\25\2\u00f8\u00f9\7\25\2\2\u00f9\u00fb\5(\25\2\u00fa\u00f8\3"+
"\2\2\2\u00fb\u00fe\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd"+
"\'\3\2\2\2\u00fe\u00fc\3\2\2\2\u00ff\u0106\5*\26\2\u0100\u0106\5.\30\2"+
"\u0101\u0106\5\60\31\2\u0102\u0106\5\62\32\2\u0103\u0106\5\64\33\2\u0104"+
"\u0106\5,\27\2\u0105\u00ff\3\2\2\2\u0105\u0100\3\2\2\2\u0105\u0101\3\2"+
"\2\2\u0105\u0102\3\2\2\2\u0105\u0103\3\2\2\2\u0105\u0104\3\2\2\2\u0106"+
")\3\2\2\2\u0107\u0108\7\5\2\2\u0108\u0109\7\21\2\2\u0109\u010a\7\35\2"+
"\2\u010a\u0114\7\22\2\2\u010b\u010c\7\6\2\2\u010c\u010d\7\21\2\2\u010d"+
"\u010e\7\35\2\2\u010e\u0114\7\22\2\2\u010f\u0110\7\7\2\2\u0110\u0111\7"+
"\21\2\2\u0111\u0112\7\35\2\2\u0112\u0114\7\22\2\2\u0113\u0107\3\2\2\2"+
"\u0113\u010b\3\2\2\2\u0113\u010f\3\2\2\2\u0114+\3\2\2\2\u0115\u0116\t"+
"\6\2\2\u0116-\3\2\2\2\u0117\u0118\7\n\2\2\u0118\u0119\7\21\2\2\u0119\u011a"+
"\7\35\2\2\u011a\u011b\7\22\2\2\u011b/\3\2\2\2\u011c\u011d\7\13\2\2\u011d"+
"\u011e\7\21\2\2\u011e\u011f\7\36\2\2\u011f\u0120\7\22\2\2\u0120\61\3\2"+
"\2\2\u0121\u0122\7\f\2\2\u0122\u0123\7\21\2\2\u0123\u0124\7\36\2\2\u0124"+
"\u0125\7\22\2\2\u0125\63\3\2\2\2\u0126\u0127\7\r\2\2\u0127\u0128\7\21"+
"\2\2\u0128\u0129\7\36\2\2\u0129\u012a\7\22\2\2\u012a\65\3\2\2\2\u012b"+
"\u012c\7\37\2\2\u012c\67\3\2\2\2\u012d\u012e\t\4\2\2\u012e9\3\2\2\2\u012f"+
"\u0134\58\35\2\u0130\u0131\7\25\2\2\u0131\u0133\58\35\2\u0132\u0130\3"+
"\2\2\2\u0133\u0136\3\2\2\2\u0134\u0132\3\2\2\2\u0134\u0135\3\2\2\2\u0135"+
";\3\2\2\2\u0136\u0134\3\2\2\2\u0137\u013c\5\66\34\2\u0138\u0139\7\21\2"+
"\2\u0139\u013a\5:\36\2\u013a\u013b\7\22\2\2\u013b\u013d\3\2\2\2\u013c"+
"\u0138\3\2\2\2\u013c\u013d\3\2\2\2\u013d=\3\2\2\2\u013e\u0140\7\16\2\2"+
"\u013f\u0141\5<\37\2\u0140\u013f\3\2\2\2\u0140\u0141\3\2\2\2\u0141\u0146"+
"\3\2\2\2\u0142\u0143\7\25\2\2\u0143\u0145\5<\37\2\u0144\u0142\3\2\2\2"+
"\u0145\u0148\3\2\2\2\u0146\u0144\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u014c"+
"\3\2\2\2\u0148\u0146\3\2\2\2\u0149\u014b\13\2\2\2\u014a\u0149\3\2\2\2"+
"\u014b\u014e\3\2\2\2\u014c\u014d\3\2\2\2\u014c\u014a\3\2\2\2\u014d\u016b"+
"\3\2\2\2\u014e\u014c\3\2\2\2\u014f\u0151\7\17\2\2\u0150\u0152\5<\37\2"+
"\u0151\u0150\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0157\3\2\2\2\u0153\u0154"+
"\7\25\2\2\u0154\u0156\5<\37\2\u0155\u0153\3\2\2\2\u0156\u0159\3\2\2\2"+
"\u0157\u0155\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u015d\3\2\2\2\u0159\u0157"+
"\3\2\2\2\u015a\u015c\13\2\2\2\u015b\u015a\3\2\2\2\u015c\u015f\3\2\2\2"+
"\u015d\u015e\3\2\2\2\u015d\u015b\3\2\2\2\u015e\u0168\3\2\2\2\u015f\u015d"+
"\3\2\2\2\u0160\u0162\13\2\2\2\u0161\u0160\3\2\2\2\u0162\u0165\3\2\2\2"+
"\u0163\u0164\3\2\2\2\u0163\u0161\3\2\2\2\u0164\u0166\3\2\2\2\u0165\u0163"+
"\3\2\2\2\u0166\u0169\7\20\2\2\u0167\u0169\7\20\2\2\u0168\u0163\3\2\2\2"+
"\u0168\u0167\3\2\2\2\u0169\u016b\3\2\2\2\u016a\u013e\3\2\2\2\u016a\u014f"+
"\3\2\2\2\u016b?\3\2\2\2*DNVbksv\u0083\u0089\u008f\u0098\u009b\u00a0\u00a5"+
"\u00a9\u00b3\u00b8\u00bb\u00c0\u00c5\u00c9\u00d4\u00dc\u00e7\u00ed\u00f5"+
"\u00fc\u0105\u0113\u0134\u013c\u0140\u0146\u014c\u0151\u0157\u015d\u0163"+
"\u0168\u016a";
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);
}
}
}