com.googlecode.cqengine.query.parser.cqn.grammar.CQNGrammarParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cqengine Show documentation
Show all versions of cqengine Show documentation
Collection Query Engine: NoSQL indexing and query engine for Java collections with ultra-low latency
// Generated from com/googlecode/cqengine/query/parser/cqn/grammar/CQNGrammar.g4 by ANTLR 4.5
package com.googlecode.cqengine.query.parser.cqn.grammar;
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 CQNGrammarParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, IntegerLiteral=24,
DecimalIntegerLiteral=25, FloatingPointLiteral=26, DecimalFloatingPointLiteral=27,
ABSTRACT=28, ASSERT=29, BOOLEAN=30, BREAK=31, BYTE=32, CASE=33, CATCH=34,
CHAR=35, CLASS=36, CONST=37, CONTINUE=38, DEFAULT=39, DO=40, DOUBLE=41,
ELSE=42, ENUM=43, EXTENDS=44, FINAL=45, FINALLY=46, FLOAT=47, FOR=48,
IF=49, GOTO=50, IMPLEMENTS=51, IMPORT=52, INSTANCEOF=53, INT=54, INTERFACE=55,
LONG=56, NATIVE=57, NEW=58, PACKAGE=59, PRIVATE=60, PROTECTED=61, PUBLIC=62,
RETURN=63, SHORT=64, STATIC=65, STRICTFP=66, SUPER=67, SWITCH=68, SYNCHRONIZED=69,
THIS=70, THROW=71, THROWS=72, TRANSIENT=73, TRY=74, VOID=75, VOLATILE=76,
WHILE=77, BooleanLiteral=78, CharacterLiteral=79, StringLiteral=80, NullLiteral=81,
LPAREN=82, RPAREN=83, LBRACE=84, RBRACE=85, LBRACK=86, RBRACK=87, SEMI=88,
COMMA=89, DOT=90, ASSIGN=91, GT=92, LT=93, BANG=94, TILDE=95, QUESTION=96,
COLON=97, EQUAL=98, LE=99, GE=100, NOTEQUAL=101, AND=102, OR=103, INC=104,
DEC=105, ADD=106, SUB=107, MUL=108, DIV=109, BITAND=110, BITOR=111, CARET=112,
MOD=113, ADD_ASSIGN=114, SUB_ASSIGN=115, MUL_ASSIGN=116, DIV_ASSIGN=117,
AND_ASSIGN=118, OR_ASSIGN=119, XOR_ASSIGN=120, MOD_ASSIGN=121, LSHIFT_ASSIGN=122,
RSHIFT_ASSIGN=123, URSHIFT_ASSIGN=124, Identifier=125, AT=126, ELLIPSIS=127,
WS=128, COMMENT=129, LINE_COMMENT=130;
public static final int
RULE_start = 0, RULE_query = 1, RULE_logicalQuery = 2, RULE_andQuery = 3,
RULE_orQuery = 4, RULE_notQuery = 5, RULE_simpleQuery = 6, RULE_equalQuery = 7,
RULE_lessThanOrEqualToQuery = 8, RULE_lessThanQuery = 9, RULE_greaterThanOrEqualToQuery = 10,
RULE_greaterThanQuery = 11, RULE_verboseBetweenQuery = 12, RULE_betweenQuery = 13,
RULE_inQuery = 14, RULE_startsWithQuery = 15, RULE_endsWithQuery = 16,
RULE_containsQuery = 17, RULE_isContainedInQuery = 18, RULE_matchesRegexQuery = 19,
RULE_hasQuery = 20, RULE_allQuery = 21, RULE_noneQuery = 22, RULE_objectType = 23,
RULE_attributeName = 24, RULE_queryParameter = 25, RULE_stringQueryParameter = 26,
RULE_queryOptions = 27, RULE_queryOption = 28, RULE_orderByOption = 29,
RULE_attributeOrder = 30, RULE_direction = 31, RULE_literal = 32, RULE_compilationUnit = 33,
RULE_packageDeclaration = 34, RULE_importDeclaration = 35, RULE_typeDeclaration = 36,
RULE_modifier = 37, RULE_classOrInterfaceModifier = 38, RULE_variableModifier = 39,
RULE_classDeclaration = 40, RULE_typeParameters = 41, RULE_typeParameter = 42,
RULE_typeBound = 43, RULE_enumDeclaration = 44, RULE_enumConstants = 45,
RULE_enumConstant = 46, RULE_enumBodyDeclarations = 47, RULE_interfaceDeclaration = 48,
RULE_typeList = 49, RULE_classBody = 50, RULE_interfaceBody = 51, RULE_classBodyDeclaration = 52,
RULE_memberDeclaration = 53, RULE_methodDeclaration = 54, RULE_genericMethodDeclaration = 55,
RULE_constructorDeclaration = 56, RULE_genericConstructorDeclaration = 57,
RULE_fieldDeclaration = 58, RULE_interfaceBodyDeclaration = 59, RULE_interfaceMemberDeclaration = 60,
RULE_constDeclaration = 61, RULE_constantDeclarator = 62, RULE_interfaceMethodDeclaration = 63,
RULE_genericInterfaceMethodDeclaration = 64, RULE_variableDeclarators = 65,
RULE_variableDeclarator = 66, RULE_variableDeclaratorId = 67, RULE_variableInitializer = 68,
RULE_arrayInitializer = 69, RULE_enumConstantName = 70, RULE_type = 71,
RULE_classOrInterfaceType = 72, RULE_primitiveType = 73, RULE_typeArguments = 74,
RULE_typeArgument = 75, RULE_qualifiedNameList = 76, RULE_formalParameters = 77,
RULE_formalParameterList = 78, RULE_formalParameter = 79, RULE_lastFormalParameter = 80,
RULE_methodBody = 81, RULE_constructorBody = 82, RULE_qualifiedName = 83,
RULE_annotation = 84, RULE_annotationName = 85, RULE_elementValuePairs = 86,
RULE_elementValuePair = 87, RULE_elementValue = 88, RULE_elementValueArrayInitializer = 89,
RULE_annotationTypeDeclaration = 90, RULE_annotationTypeBody = 91, RULE_annotationTypeElementDeclaration = 92,
RULE_annotationTypeElementRest = 93, RULE_annotationMethodOrConstantRest = 94,
RULE_annotationMethodRest = 95, RULE_annotationConstantRest = 96, RULE_defaultValue = 97,
RULE_block = 98, RULE_blockStatement = 99, RULE_localVariableDeclarationStatement = 100,
RULE_localVariableDeclaration = 101, RULE_statement = 102, RULE_catchClause = 103,
RULE_catchType = 104, RULE_finallyBlock = 105, RULE_resourceSpecification = 106,
RULE_resources = 107, RULE_resource = 108, RULE_switchBlockStatementGroup = 109,
RULE_switchLabel = 110, RULE_forControl = 111, RULE_forInit = 112, RULE_enhancedForControl = 113,
RULE_forUpdate = 114, RULE_parExpression = 115, RULE_expressionList = 116,
RULE_statementExpression = 117, RULE_constantExpression = 118, RULE_expression = 119,
RULE_primary = 120, RULE_creator = 121, RULE_createdName = 122, RULE_innerCreator = 123,
RULE_arrayCreatorRest = 124, RULE_classCreatorRest = 125, RULE_explicitGenericInvocation = 126,
RULE_nonWildcardTypeArguments = 127, RULE_typeArgumentsOrDiamond = 128,
RULE_nonWildcardTypeArgumentsOrDiamond = 129, RULE_superSuffix = 130,
RULE_explicitGenericInvocationSuffix = 131, RULE_arguments = 132;
public static final String[] ruleNames = {
"start", "query", "logicalQuery", "andQuery", "orQuery", "notQuery", "simpleQuery",
"equalQuery", "lessThanOrEqualToQuery", "lessThanQuery", "greaterThanOrEqualToQuery",
"greaterThanQuery", "verboseBetweenQuery", "betweenQuery", "inQuery",
"startsWithQuery", "endsWithQuery", "containsQuery", "isContainedInQuery",
"matchesRegexQuery", "hasQuery", "allQuery", "noneQuery", "objectType",
"attributeName", "queryParameter", "stringQueryParameter", "queryOptions",
"queryOption", "orderByOption", "attributeOrder", "direction", "literal",
"compilationUnit", "packageDeclaration", "importDeclaration", "typeDeclaration",
"modifier", "classOrInterfaceModifier", "variableModifier", "classDeclaration",
"typeParameters", "typeParameter", "typeBound", "enumDeclaration", "enumConstants",
"enumConstant", "enumBodyDeclarations", "interfaceDeclaration", "typeList",
"classBody", "interfaceBody", "classBodyDeclaration", "memberDeclaration",
"methodDeclaration", "genericMethodDeclaration", "constructorDeclaration",
"genericConstructorDeclaration", "fieldDeclaration", "interfaceBodyDeclaration",
"interfaceMemberDeclaration", "constDeclaration", "constantDeclarator",
"interfaceMethodDeclaration", "genericInterfaceMethodDeclaration", "variableDeclarators",
"variableDeclarator", "variableDeclaratorId", "variableInitializer", "arrayInitializer",
"enumConstantName", "type", "classOrInterfaceType", "primitiveType", "typeArguments",
"typeArgument", "qualifiedNameList", "formalParameters", "formalParameterList",
"formalParameter", "lastFormalParameter", "methodBody", "constructorBody",
"qualifiedName", "annotation", "annotationName", "elementValuePairs",
"elementValuePair", "elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration",
"annotationTypeBody", "annotationTypeElementDeclaration", "annotationTypeElementRest",
"annotationMethodOrConstantRest", "annotationMethodRest", "annotationConstantRest",
"defaultValue", "block", "blockStatement", "localVariableDeclarationStatement",
"localVariableDeclaration", "statement", "catchClause", "catchType", "finallyBlock",
"resourceSpecification", "resources", "resource", "switchBlockStatementGroup",
"switchLabel", "forControl", "forInit", "enhancedForControl", "forUpdate",
"parExpression", "expressionList", "statementExpression", "constantExpression",
"expression", "primary", "creator", "createdName", "innerCreator", "arrayCreatorRest",
"classCreatorRest", "explicitGenericInvocation", "nonWildcardTypeArguments",
"typeArgumentsOrDiamond", "nonWildcardTypeArgumentsOrDiamond", "superSuffix",
"explicitGenericInvocationSuffix", "arguments"
};
private static final String[] _LITERAL_NAMES = {
null, "'and'", "'or'", "'not'", "'equal'", "'lessThanOrEqualTo'", "'lessThan'",
"'greaterThanOrEqualTo'", "'greaterThan'", "'between'", "'in'", "'startsWith'",
"'endsWith'", "'contains'", "'isContainedIn'", "'matchesRegex'", "'has'",
"'all'", "'.class'", "'none'", "'queryOptions'", "'orderBy'", "'ascending'",
"'descending'", null, null, null, null, "'abstract'", "'assert'", "'boolean'",
"'break'", "'byte'", "'case'", "'catch'", "'char'", "'class'", "'const'",
"'continue'", "'default'", "'do'", "'double'", "'else'", "'enum'", "'extends'",
"'final'", "'finally'", "'float'", "'for'", "'if'", "'goto'", "'implements'",
"'import'", "'instanceof'", "'int'", "'interface'", "'long'", "'native'",
"'new'", "'package'", "'private'", "'protected'", "'public'", "'return'",
"'short'", "'static'", "'strictfp'", "'super'", "'switch'", "'synchronized'",
"'this'", "'throw'", "'throws'", "'transient'", "'try'", "'void'", "'volatile'",
"'while'", null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['",
"']'", "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'",
"':'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'",
"'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'+='", "'-='",
"'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", "'>>>='",
null, "'@'", "'...'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
"IntegerLiteral", "DecimalIntegerLiteral", "FloatingPointLiteral", "DecimalFloatingPointLiteral",
"ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR",
"CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM",
"EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS",
"IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE",
"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP",
"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT",
"TRY", "VOID", "VOLATILE", "WHILE", "BooleanLiteral", "CharacterLiteral",
"StringLiteral", "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE",
"LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG",
"TILDE", "QUESTION", "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND",
"OR", "INC", "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET",
"MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN",
"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN",
"URSHIFT_ASSIGN", "Identifier", "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
};
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 "CQNGrammar.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public CQNGrammarParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class StartContext extends ParserRuleContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode EOF() { return getToken(CQNGrammarParser.EOF, 0); }
public QueryOptionsContext queryOptions() {
return getRuleContext(QueryOptionsContext.class,0);
}
public StartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_start; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterStart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitStart(this);
}
}
public final StartContext start() throws RecognitionException {
StartContext _localctx = new StartContext(_ctx, getState());
enterRule(_localctx, 0, RULE_start);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(266);
query();
setState(269);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(267);
match(COMMA);
setState(268);
queryOptions();
}
}
setState(271);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QueryContext extends ParserRuleContext {
public LogicalQueryContext logicalQuery() {
return getRuleContext(LogicalQueryContext.class,0);
}
public SimpleQueryContext simpleQuery() {
return getRuleContext(SimpleQueryContext.class,0);
}
public QueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_query; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitQuery(this);
}
}
public final QueryContext query() throws RecognitionException {
QueryContext _localctx = new QueryContext(_ctx, getState());
enterRule(_localctx, 2, RULE_query);
try {
setState(275);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
enterOuterAlt(_localctx, 1);
{
setState(273);
logicalQuery();
}
break;
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__10:
case T__11:
case T__12:
case T__13:
case T__14:
case T__15:
case T__16:
case T__18:
enterOuterAlt(_localctx, 2);
{
setState(274);
simpleQuery();
}
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 LogicalQueryContext extends ParserRuleContext {
public AndQueryContext andQuery() {
return getRuleContext(AndQueryContext.class,0);
}
public OrQueryContext orQuery() {
return getRuleContext(OrQueryContext.class,0);
}
public NotQueryContext notQuery() {
return getRuleContext(NotQueryContext.class,0);
}
public LogicalQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_logicalQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterLogicalQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitLogicalQuery(this);
}
}
public final LogicalQueryContext logicalQuery() throws RecognitionException {
LogicalQueryContext _localctx = new LogicalQueryContext(_ctx, getState());
enterRule(_localctx, 4, RULE_logicalQuery);
try {
setState(280);
switch (_input.LA(1)) {
case T__0:
enterOuterAlt(_localctx, 1);
{
setState(277);
andQuery();
}
break;
case T__1:
enterOuterAlt(_localctx, 2);
{
setState(278);
orQuery();
}
break;
case T__2:
enterOuterAlt(_localctx, 3);
{
setState(279);
notQuery();
}
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 AndQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public List query() {
return getRuleContexts(QueryContext.class);
}
public QueryContext query(int i) {
return getRuleContext(QueryContext.class,i);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public AndQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAndQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAndQuery(this);
}
}
public final AndQueryContext andQuery() throws RecognitionException {
AndQueryContext _localctx = new AndQueryContext(_ctx, getState());
enterRule(_localctx, 6, RULE_andQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(282);
match(T__0);
setState(283);
match(LPAREN);
setState(284);
query();
setState(287);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(285);
match(COMMA);
setState(286);
query();
}
}
setState(289);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==COMMA );
setState(291);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public List query() {
return getRuleContexts(QueryContext.class);
}
public QueryContext query(int i) {
return getRuleContext(QueryContext.class,i);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public OrQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterOrQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitOrQuery(this);
}
}
public final OrQueryContext orQuery() throws RecognitionException {
OrQueryContext _localctx = new OrQueryContext(_ctx, getState());
enterRule(_localctx, 8, RULE_orQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(293);
match(T__1);
setState(294);
match(LPAREN);
setState(295);
query();
setState(298);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(296);
match(COMMA);
setState(297);
query();
}
}
setState(300);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==COMMA );
setState(302);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NotQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public NotQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterNotQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitNotQuery(this);
}
}
public final NotQueryContext notQuery() throws RecognitionException {
NotQueryContext _localctx = new NotQueryContext(_ctx, getState());
enterRule(_localctx, 10, RULE_notQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(304);
match(T__2);
setState(305);
match(LPAREN);
setState(306);
query();
setState(307);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleQueryContext extends ParserRuleContext {
public EqualQueryContext equalQuery() {
return getRuleContext(EqualQueryContext.class,0);
}
public LessThanOrEqualToQueryContext lessThanOrEqualToQuery() {
return getRuleContext(LessThanOrEqualToQueryContext.class,0);
}
public LessThanQueryContext lessThanQuery() {
return getRuleContext(LessThanQueryContext.class,0);
}
public GreaterThanOrEqualToQueryContext greaterThanOrEqualToQuery() {
return getRuleContext(GreaterThanOrEqualToQueryContext.class,0);
}
public GreaterThanQueryContext greaterThanQuery() {
return getRuleContext(GreaterThanQueryContext.class,0);
}
public VerboseBetweenQueryContext verboseBetweenQuery() {
return getRuleContext(VerboseBetweenQueryContext.class,0);
}
public BetweenQueryContext betweenQuery() {
return getRuleContext(BetweenQueryContext.class,0);
}
public InQueryContext inQuery() {
return getRuleContext(InQueryContext.class,0);
}
public StartsWithQueryContext startsWithQuery() {
return getRuleContext(StartsWithQueryContext.class,0);
}
public EndsWithQueryContext endsWithQuery() {
return getRuleContext(EndsWithQueryContext.class,0);
}
public ContainsQueryContext containsQuery() {
return getRuleContext(ContainsQueryContext.class,0);
}
public IsContainedInQueryContext isContainedInQuery() {
return getRuleContext(IsContainedInQueryContext.class,0);
}
public MatchesRegexQueryContext matchesRegexQuery() {
return getRuleContext(MatchesRegexQueryContext.class,0);
}
public HasQueryContext hasQuery() {
return getRuleContext(HasQueryContext.class,0);
}
public AllQueryContext allQuery() {
return getRuleContext(AllQueryContext.class,0);
}
public NoneQueryContext noneQuery() {
return getRuleContext(NoneQueryContext.class,0);
}
public SimpleQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterSimpleQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitSimpleQuery(this);
}
}
public final SimpleQueryContext simpleQuery() throws RecognitionException {
SimpleQueryContext _localctx = new SimpleQueryContext(_ctx, getState());
enterRule(_localctx, 12, RULE_simpleQuery);
try {
setState(325);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(309);
equalQuery();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(310);
lessThanOrEqualToQuery();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(311);
lessThanQuery();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(312);
greaterThanOrEqualToQuery();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(313);
greaterThanQuery();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(314);
verboseBetweenQuery();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(315);
betweenQuery();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(316);
inQuery();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(317);
startsWithQuery();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(318);
endsWithQuery();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(319);
containsQuery();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(320);
isContainedInQuery();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(321);
matchesRegexQuery();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(322);
hasQuery();
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(323);
allQuery();
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(324);
noneQuery();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EqualQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public QueryParameterContext queryParameter() {
return getRuleContext(QueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public EqualQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterEqualQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitEqualQuery(this);
}
}
public final EqualQueryContext equalQuery() throws RecognitionException {
EqualQueryContext _localctx = new EqualQueryContext(_ctx, getState());
enterRule(_localctx, 14, RULE_equalQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(327);
match(T__3);
setState(328);
match(LPAREN);
setState(329);
attributeName();
setState(330);
match(COMMA);
setState(331);
queryParameter();
setState(332);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LessThanOrEqualToQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public QueryParameterContext queryParameter() {
return getRuleContext(QueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public LessThanOrEqualToQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lessThanOrEqualToQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterLessThanOrEqualToQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitLessThanOrEqualToQuery(this);
}
}
public final LessThanOrEqualToQueryContext lessThanOrEqualToQuery() throws RecognitionException {
LessThanOrEqualToQueryContext _localctx = new LessThanOrEqualToQueryContext(_ctx, getState());
enterRule(_localctx, 16, RULE_lessThanOrEqualToQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(334);
match(T__4);
setState(335);
match(LPAREN);
setState(336);
attributeName();
setState(337);
match(COMMA);
setState(338);
queryParameter();
setState(339);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LessThanQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public QueryParameterContext queryParameter() {
return getRuleContext(QueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public LessThanQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lessThanQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterLessThanQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitLessThanQuery(this);
}
}
public final LessThanQueryContext lessThanQuery() throws RecognitionException {
LessThanQueryContext _localctx = new LessThanQueryContext(_ctx, getState());
enterRule(_localctx, 18, RULE_lessThanQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(341);
match(T__5);
setState(342);
match(LPAREN);
setState(343);
attributeName();
setState(344);
match(COMMA);
setState(345);
queryParameter();
setState(346);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GreaterThanOrEqualToQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public QueryParameterContext queryParameter() {
return getRuleContext(QueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public GreaterThanOrEqualToQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_greaterThanOrEqualToQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterGreaterThanOrEqualToQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitGreaterThanOrEqualToQuery(this);
}
}
public final GreaterThanOrEqualToQueryContext greaterThanOrEqualToQuery() throws RecognitionException {
GreaterThanOrEqualToQueryContext _localctx = new GreaterThanOrEqualToQueryContext(_ctx, getState());
enterRule(_localctx, 20, RULE_greaterThanOrEqualToQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(348);
match(T__6);
setState(349);
match(LPAREN);
setState(350);
attributeName();
setState(351);
match(COMMA);
setState(352);
queryParameter();
setState(353);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GreaterThanQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public QueryParameterContext queryParameter() {
return getRuleContext(QueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public GreaterThanQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_greaterThanQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterGreaterThanQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitGreaterThanQuery(this);
}
}
public final GreaterThanQueryContext greaterThanQuery() throws RecognitionException {
GreaterThanQueryContext _localctx = new GreaterThanQueryContext(_ctx, getState());
enterRule(_localctx, 22, RULE_greaterThanQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(355);
match(T__7);
setState(356);
match(LPAREN);
setState(357);
attributeName();
setState(358);
match(COMMA);
setState(359);
queryParameter();
setState(360);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VerboseBetweenQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public List queryParameter() {
return getRuleContexts(QueryParameterContext.class);
}
public QueryParameterContext queryParameter(int i) {
return getRuleContext(QueryParameterContext.class,i);
}
public List BooleanLiteral() { return getTokens(CQNGrammarParser.BooleanLiteral); }
public TerminalNode BooleanLiteral(int i) {
return getToken(CQNGrammarParser.BooleanLiteral, i);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public VerboseBetweenQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_verboseBetweenQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterVerboseBetweenQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitVerboseBetweenQuery(this);
}
}
public final VerboseBetweenQueryContext verboseBetweenQuery() throws RecognitionException {
VerboseBetweenQueryContext _localctx = new VerboseBetweenQueryContext(_ctx, getState());
enterRule(_localctx, 24, RULE_verboseBetweenQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(362);
match(T__8);
setState(363);
match(LPAREN);
setState(364);
attributeName();
setState(365);
match(COMMA);
setState(366);
queryParameter();
setState(367);
match(COMMA);
setState(368);
match(BooleanLiteral);
setState(369);
match(COMMA);
setState(370);
queryParameter();
setState(371);
match(COMMA);
setState(372);
match(BooleanLiteral);
setState(373);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BetweenQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public List queryParameter() {
return getRuleContexts(QueryParameterContext.class);
}
public QueryParameterContext queryParameter(int i) {
return getRuleContext(QueryParameterContext.class,i);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public BetweenQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_betweenQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterBetweenQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitBetweenQuery(this);
}
}
public final BetweenQueryContext betweenQuery() throws RecognitionException {
BetweenQueryContext _localctx = new BetweenQueryContext(_ctx, getState());
enterRule(_localctx, 26, RULE_betweenQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(375);
match(T__8);
setState(376);
match(LPAREN);
setState(377);
attributeName();
setState(378);
match(COMMA);
setState(379);
queryParameter();
setState(380);
match(COMMA);
setState(381);
queryParameter();
setState(382);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public List queryParameter() {
return getRuleContexts(QueryParameterContext.class);
}
public QueryParameterContext queryParameter(int i) {
return getRuleContext(QueryParameterContext.class,i);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public InQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterInQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitInQuery(this);
}
}
public final InQueryContext inQuery() throws RecognitionException {
InQueryContext _localctx = new InQueryContext(_ctx, getState());
enterRule(_localctx, 28, RULE_inQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(384);
match(T__9);
setState(385);
match(LPAREN);
setState(386);
attributeName();
setState(387);
match(COMMA);
setState(388);
queryParameter();
setState(393);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(389);
match(COMMA);
setState(390);
queryParameter();
}
}
setState(395);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(396);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StartsWithQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public StringQueryParameterContext stringQueryParameter() {
return getRuleContext(StringQueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public StartsWithQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startsWithQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterStartsWithQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitStartsWithQuery(this);
}
}
public final StartsWithQueryContext startsWithQuery() throws RecognitionException {
StartsWithQueryContext _localctx = new StartsWithQueryContext(_ctx, getState());
enterRule(_localctx, 30, RULE_startsWithQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(398);
match(T__10);
setState(399);
match(LPAREN);
setState(400);
attributeName();
setState(401);
match(COMMA);
setState(402);
stringQueryParameter();
setState(403);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EndsWithQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public StringQueryParameterContext stringQueryParameter() {
return getRuleContext(StringQueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public EndsWithQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_endsWithQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterEndsWithQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitEndsWithQuery(this);
}
}
public final EndsWithQueryContext endsWithQuery() throws RecognitionException {
EndsWithQueryContext _localctx = new EndsWithQueryContext(_ctx, getState());
enterRule(_localctx, 32, RULE_endsWithQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(405);
match(T__11);
setState(406);
match(LPAREN);
setState(407);
attributeName();
setState(408);
match(COMMA);
setState(409);
stringQueryParameter();
setState(410);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContainsQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public StringQueryParameterContext stringQueryParameter() {
return getRuleContext(StringQueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public ContainsQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_containsQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterContainsQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitContainsQuery(this);
}
}
public final ContainsQueryContext containsQuery() throws RecognitionException {
ContainsQueryContext _localctx = new ContainsQueryContext(_ctx, getState());
enterRule(_localctx, 34, RULE_containsQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(412);
match(T__12);
setState(413);
match(LPAREN);
setState(414);
attributeName();
setState(415);
match(COMMA);
setState(416);
stringQueryParameter();
setState(417);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IsContainedInQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public StringQueryParameterContext stringQueryParameter() {
return getRuleContext(StringQueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public IsContainedInQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_isContainedInQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterIsContainedInQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitIsContainedInQuery(this);
}
}
public final IsContainedInQueryContext isContainedInQuery() throws RecognitionException {
IsContainedInQueryContext _localctx = new IsContainedInQueryContext(_ctx, getState());
enterRule(_localctx, 36, RULE_isContainedInQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(419);
match(T__13);
setState(420);
match(LPAREN);
setState(421);
attributeName();
setState(422);
match(COMMA);
setState(423);
stringQueryParameter();
setState(424);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchesRegexQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public StringQueryParameterContext stringQueryParameter() {
return getRuleContext(StringQueryParameterContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public MatchesRegexQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchesRegexQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterMatchesRegexQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitMatchesRegexQuery(this);
}
}
public final MatchesRegexQueryContext matchesRegexQuery() throws RecognitionException {
MatchesRegexQueryContext _localctx = new MatchesRegexQueryContext(_ctx, getState());
enterRule(_localctx, 38, RULE_matchesRegexQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(426);
match(T__14);
setState(427);
match(LPAREN);
setState(428);
attributeName();
setState(429);
match(COMMA);
setState(430);
stringQueryParameter();
setState(431);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HasQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public HasQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hasQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterHasQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitHasQuery(this);
}
}
public final HasQueryContext hasQuery() throws RecognitionException {
HasQueryContext _localctx = new HasQueryContext(_ctx, getState());
enterRule(_localctx, 40, RULE_hasQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(433);
match(T__15);
setState(434);
match(LPAREN);
setState(435);
attributeName();
setState(436);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AllQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public ObjectTypeContext objectType() {
return getRuleContext(ObjectTypeContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public AllQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_allQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAllQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAllQuery(this);
}
}
public final AllQueryContext allQuery() throws RecognitionException {
AllQueryContext _localctx = new AllQueryContext(_ctx, getState());
enterRule(_localctx, 42, RULE_allQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(438);
match(T__16);
setState(439);
match(LPAREN);
setState(440);
objectType();
setState(441);
match(T__17);
setState(442);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NoneQueryContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public ObjectTypeContext objectType() {
return getRuleContext(ObjectTypeContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public NoneQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_noneQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterNoneQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitNoneQuery(this);
}
}
public final NoneQueryContext noneQuery() throws RecognitionException {
NoneQueryContext _localctx = new NoneQueryContext(_ctx, getState());
enterRule(_localctx, 44, RULE_noneQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(444);
match(T__18);
setState(445);
match(LPAREN);
setState(446);
objectType();
setState(447);
match(T__17);
setState(448);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectTypeContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public ObjectTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterObjectType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitObjectType(this);
}
}
public final ObjectTypeContext objectType() throws RecognitionException {
ObjectTypeContext _localctx = new ObjectTypeContext(_ctx, getState());
enterRule(_localctx, 46, RULE_objectType);
try {
enterOuterAlt(_localctx, 1);
{
setState(450);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeNameContext extends ParserRuleContext {
public TerminalNode StringLiteral() { return getToken(CQNGrammarParser.StringLiteral, 0); }
public AttributeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAttributeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAttributeName(this);
}
}
public final AttributeNameContext attributeName() throws RecognitionException {
AttributeNameContext _localctx = new AttributeNameContext(_ctx, getState());
enterRule(_localctx, 48, RULE_attributeName);
try {
enterOuterAlt(_localctx, 1);
{
setState(452);
match(StringLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QueryParameterContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public QueryParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterQueryParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitQueryParameter(this);
}
}
public final QueryParameterContext queryParameter() throws RecognitionException {
QueryParameterContext _localctx = new QueryParameterContext(_ctx, getState());
enterRule(_localctx, 50, RULE_queryParameter);
try {
setState(456);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case NullLiteral:
enterOuterAlt(_localctx, 1);
{
setState(454);
literal();
}
break;
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(455);
match(Identifier);
}
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 StringQueryParameterContext extends ParserRuleContext {
public TerminalNode StringLiteral() { return getToken(CQNGrammarParser.StringLiteral, 0); }
public StringQueryParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringQueryParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterStringQueryParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitStringQueryParameter(this);
}
}
public final StringQueryParameterContext stringQueryParameter() throws RecognitionException {
StringQueryParameterContext _localctx = new StringQueryParameterContext(_ctx, getState());
enterRule(_localctx, 52, RULE_stringQueryParameter);
try {
enterOuterAlt(_localctx, 1);
{
setState(458);
match(StringLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QueryOptionsContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public List queryOption() {
return getRuleContexts(QueryOptionContext.class);
}
public QueryOptionContext queryOption(int i) {
return getRuleContext(QueryOptionContext.class,i);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public QueryOptionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryOptions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterQueryOptions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitQueryOptions(this);
}
}
public final QueryOptionsContext queryOptions() throws RecognitionException {
QueryOptionsContext _localctx = new QueryOptionsContext(_ctx, getState());
enterRule(_localctx, 54, RULE_queryOptions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(460);
match(T__19);
setState(461);
match(LPAREN);
setState(462);
queryOption();
setState(467);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(463);
match(COMMA);
setState(464);
queryOption();
}
}
setState(469);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(470);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QueryOptionContext extends ParserRuleContext {
public OrderByOptionContext orderByOption() {
return getRuleContext(OrderByOptionContext.class,0);
}
public QueryOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryOption; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterQueryOption(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitQueryOption(this);
}
}
public final QueryOptionContext queryOption() throws RecognitionException {
QueryOptionContext _localctx = new QueryOptionContext(_ctx, getState());
enterRule(_localctx, 56, RULE_queryOption);
try {
enterOuterAlt(_localctx, 1);
{
setState(472);
orderByOption();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderByOptionContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public List attributeOrder() {
return getRuleContexts(AttributeOrderContext.class);
}
public AttributeOrderContext attributeOrder(int i) {
return getRuleContext(AttributeOrderContext.class,i);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public OrderByOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderByOption; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterOrderByOption(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitOrderByOption(this);
}
}
public final OrderByOptionContext orderByOption() throws RecognitionException {
OrderByOptionContext _localctx = new OrderByOptionContext(_ctx, getState());
enterRule(_localctx, 58, RULE_orderByOption);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(474);
match(T__20);
setState(475);
match(LPAREN);
setState(476);
attributeOrder();
setState(481);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(477);
match(COMMA);
setState(478);
attributeOrder();
}
}
setState(483);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(484);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeOrderContext extends ParserRuleContext {
public DirectionContext direction() {
return getRuleContext(DirectionContext.class,0);
}
public TerminalNode LPAREN() { return getToken(CQNGrammarParser.LPAREN, 0); }
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public TerminalNode RPAREN() { return getToken(CQNGrammarParser.RPAREN, 0); }
public AttributeOrderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeOrder; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAttributeOrder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAttributeOrder(this);
}
}
public final AttributeOrderContext attributeOrder() throws RecognitionException {
AttributeOrderContext _localctx = new AttributeOrderContext(_ctx, getState());
enterRule(_localctx, 60, RULE_attributeOrder);
try {
enterOuterAlt(_localctx, 1);
{
setState(486);
direction();
setState(487);
match(LPAREN);
setState(488);
attributeName();
setState(489);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DirectionContext extends ParserRuleContext {
public DirectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_direction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterDirection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitDirection(this);
}
}
public final DirectionContext direction() throws RecognitionException {
DirectionContext _localctx = new DirectionContext(_ctx, getState());
enterRule(_localctx, 62, RULE_direction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(491);
_la = _input.LA(1);
if ( !(_la==T__21 || _la==T__22) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode IntegerLiteral() { return getToken(CQNGrammarParser.IntegerLiteral, 0); }
public TerminalNode FloatingPointLiteral() { return getToken(CQNGrammarParser.FloatingPointLiteral, 0); }
public TerminalNode CharacterLiteral() { return getToken(CQNGrammarParser.CharacterLiteral, 0); }
public TerminalNode StringLiteral() { return getToken(CQNGrammarParser.StringLiteral, 0); }
public TerminalNode BooleanLiteral() { return getToken(CQNGrammarParser.BooleanLiteral, 0); }
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitLiteral(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 64, RULE_literal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(493);
_la = _input.LA(1);
if ( !(((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (IntegerLiteral - 24)) | (1L << (FloatingPointLiteral - 24)) | (1L << (BooleanLiteral - 24)) | (1L << (CharacterLiteral - 24)) | (1L << (StringLiteral - 24)) | (1L << (NullLiteral - 24)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CompilationUnitContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(CQNGrammarParser.EOF, 0); }
public PackageDeclarationContext packageDeclaration() {
return getRuleContext(PackageDeclarationContext.class,0);
}
public List importDeclaration() {
return getRuleContexts(ImportDeclarationContext.class);
}
public ImportDeclarationContext importDeclaration(int i) {
return getRuleContext(ImportDeclarationContext.class,i);
}
public List typeDeclaration() {
return getRuleContexts(TypeDeclarationContext.class);
}
public TypeDeclarationContext typeDeclaration(int i) {
return getRuleContext(TypeDeclarationContext.class,i);
}
public CompilationUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compilationUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterCompilationUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitCompilationUnit(this);
}
}
public final CompilationUnitContext compilationUnit() throws RecognitionException {
CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
enterRule(_localctx, 66, RULE_compilationUnit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(496);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(495);
packageDeclaration();
}
break;
}
setState(501);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IMPORT) {
{
{
setState(498);
importDeclaration();
}
}
setState(503);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(507);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (STATIC - 65)) | (1L << (STRICTFP - 65)) | (1L << (SEMI - 65)) | (1L << (AT - 65)))) != 0)) {
{
{
setState(504);
typeDeclaration();
}
}
setState(509);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(510);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PackageDeclarationContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public List annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public PackageDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterPackageDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitPackageDeclaration(this);
}
}
public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
enterRule(_localctx, 68, RULE_packageDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(515);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(512);
annotation();
}
}
setState(517);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(518);
match(PACKAGE);
setState(519);
qualifiedName();
setState(520);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportDeclarationContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterImportDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitImportDeclaration(this);
}
}
public final ImportDeclarationContext importDeclaration() throws RecognitionException {
ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
enterRule(_localctx, 70, RULE_importDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(522);
match(IMPORT);
setState(524);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(523);
match(STATIC);
}
}
setState(526);
qualifiedName();
setState(529);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(527);
match(DOT);
setState(528);
match(MUL);
}
}
setState(531);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeDeclarationContext extends ParserRuleContext {
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public List classOrInterfaceModifier() {
return getRuleContexts(ClassOrInterfaceModifierContext.class);
}
public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) {
return getRuleContext(ClassOrInterfaceModifierContext.class,i);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public TypeDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitTypeDeclaration(this);
}
}
public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 72, RULE_typeDeclaration);
int _la;
try {
int _alt;
setState(562);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(536);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (STATIC - 65)) | (1L << (STRICTFP - 65)) | (1L << (AT - 65)))) != 0)) {
{
{
setState(533);
classOrInterfaceModifier();
}
}
setState(538);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(539);
classDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(543);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (STATIC - 65)) | (1L << (STRICTFP - 65)) | (1L << (AT - 65)))) != 0)) {
{
{
setState(540);
classOrInterfaceModifier();
}
}
setState(545);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(546);
enumDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(550);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (STATIC - 65)) | (1L << (STRICTFP - 65)) | (1L << (AT - 65)))) != 0)) {
{
{
setState(547);
classOrInterfaceModifier();
}
}
setState(552);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(553);
interfaceDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(557);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(554);
classOrInterfaceModifier();
}
}
}
setState(559);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
}
setState(560);
annotationTypeDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(561);
match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModifierContext extends ParserRuleContext {
public ClassOrInterfaceModifierContext classOrInterfaceModifier() {
return getRuleContext(ClassOrInterfaceModifierContext.class,0);
}
public ModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_modifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitModifier(this);
}
}
public final ModifierContext modifier() throws RecognitionException {
ModifierContext _localctx = new ModifierContext(_ctx, getState());
enterRule(_localctx, 74, RULE_modifier);
int _la;
try {
setState(566);
switch (_input.LA(1)) {
case ABSTRACT:
case FINAL:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case STATIC:
case STRICTFP:
case AT:
enterOuterAlt(_localctx, 1);
{
setState(564);
classOrInterfaceModifier();
}
break;
case NATIVE:
case SYNCHRONIZED:
case TRANSIENT:
case VOLATILE:
enterOuterAlt(_localctx, 2);
{
setState(565);
_la = _input.LA(1);
if ( !(((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & ((1L << (NATIVE - 57)) | (1L << (SYNCHRONIZED - 57)) | (1L << (TRANSIENT - 57)) | (1L << (VOLATILE - 57)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
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 ClassOrInterfaceModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public ClassOrInterfaceModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classOrInterfaceModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterClassOrInterfaceModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitClassOrInterfaceModifier(this);
}
}
public final ClassOrInterfaceModifierContext classOrInterfaceModifier() throws RecognitionException {
ClassOrInterfaceModifierContext _localctx = new ClassOrInterfaceModifierContext(_ctx, getState());
enterRule(_localctx, 76, RULE_classOrInterfaceModifier);
int _la;
try {
setState(570);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(568);
annotation();
}
break;
case ABSTRACT:
case FINAL:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case STATIC:
case STRICTFP:
enterOuterAlt(_localctx, 2);
{
setState(569);
_la = _input.LA(1);
if ( !(((((_la - 28)) & ~0x3f) == 0 && ((1L << (_la - 28)) & ((1L << (ABSTRACT - 28)) | (1L << (FINAL - 28)) | (1L << (PRIVATE - 28)) | (1L << (PROTECTED - 28)) | (1L << (PUBLIC - 28)) | (1L << (STATIC - 28)) | (1L << (STRICTFP - 28)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
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 VariableModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public VariableModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterVariableModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitVariableModifier(this);
}
}
public final VariableModifierContext variableModifier() throws RecognitionException {
VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
enterRule(_localctx, 78, RULE_variableModifier);
try {
setState(574);
switch (_input.LA(1)) {
case FINAL:
enterOuterAlt(_localctx, 1);
{
setState(572);
match(FINAL);
}
break;
case AT:
enterOuterAlt(_localctx, 2);
{
setState(573);
annotation();
}
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 ClassDeclarationContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterClassDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitClassDeclaration(this);
}
}
public final ClassDeclarationContext classDeclaration() throws RecognitionException {
ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
enterRule(_localctx, 80, RULE_classDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(576);
match(CLASS);
setState(577);
match(Identifier);
setState(579);
_la = _input.LA(1);
if (_la==LT) {
{
setState(578);
typeParameters();
}
}
setState(583);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(581);
match(EXTENDS);
setState(582);
type();
}
}
setState(587);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(585);
match(IMPLEMENTS);
setState(586);
typeList();
}
}
setState(589);
classBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParametersContext extends ParserRuleContext {
public List typeParameter() {
return getRuleContexts(TypeParameterContext.class);
}
public TypeParameterContext typeParameter(int i) {
return getRuleContext(TypeParameterContext.class,i);
}
public TypeParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterTypeParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitTypeParameters(this);
}
}
public final TypeParametersContext typeParameters() throws RecognitionException {
TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
enterRule(_localctx, 82, RULE_typeParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(591);
match(LT);
setState(592);
typeParameter();
setState(597);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(593);
match(COMMA);
setState(594);
typeParameter();
}
}
setState(599);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(600);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParameterContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public TypeBoundContext typeBound() {
return getRuleContext(TypeBoundContext.class,0);
}
public TypeParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterTypeParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitTypeParameter(this);
}
}
public final TypeParameterContext typeParameter() throws RecognitionException {
TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
enterRule(_localctx, 84, RULE_typeParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(602);
match(Identifier);
setState(605);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(603);
match(EXTENDS);
setState(604);
typeBound();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeBoundContext extends ParserRuleContext {
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public TypeBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeBound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterTypeBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitTypeBound(this);
}
}
public final TypeBoundContext typeBound() throws RecognitionException {
TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
enterRule(_localctx, 86, RULE_typeBound);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(607);
type();
setState(612);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITAND) {
{
{
setState(608);
match(BITAND);
setState(609);
type();
}
}
setState(614);
_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 EnumDeclarationContext extends ParserRuleContext {
public TerminalNode ENUM() { return getToken(CQNGrammarParser.ENUM, 0); }
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public EnumConstantsContext enumConstants() {
return getRuleContext(EnumConstantsContext.class,0);
}
public EnumBodyDeclarationsContext enumBodyDeclarations() {
return getRuleContext(EnumBodyDeclarationsContext.class,0);
}
public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterEnumDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitEnumDeclaration(this);
}
}
public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
enterRule(_localctx, 88, RULE_enumDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(615);
match(ENUM);
setState(616);
match(Identifier);
setState(619);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(617);
match(IMPLEMENTS);
setState(618);
typeList();
}
}
setState(621);
match(LBRACE);
setState(623);
_la = _input.LA(1);
if (_la==Identifier || _la==AT) {
{
setState(622);
enumConstants();
}
}
setState(626);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(625);
match(COMMA);
}
}
setState(629);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(628);
enumBodyDeclarations();
}
}
setState(631);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantsContext extends ParserRuleContext {
public List enumConstant() {
return getRuleContexts(EnumConstantContext.class);
}
public EnumConstantContext enumConstant(int i) {
return getRuleContext(EnumConstantContext.class,i);
}
public EnumConstantsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstants; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterEnumConstants(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitEnumConstants(this);
}
}
public final EnumConstantsContext enumConstants() throws RecognitionException {
EnumConstantsContext _localctx = new EnumConstantsContext(_ctx, getState());
enterRule(_localctx, 90, RULE_enumConstants);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(633);
enumConstant();
setState(638);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(634);
match(COMMA);
setState(635);
enumConstant();
}
}
}
setState(640);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public List annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public EnumConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterEnumConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitEnumConstant(this);
}
}
public final EnumConstantContext enumConstant() throws RecognitionException {
EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
enterRule(_localctx, 92, RULE_enumConstant);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(644);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(641);
annotation();
}
}
setState(646);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(647);
match(Identifier);
setState(649);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(648);
arguments();
}
}
setState(652);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(651);
classBody();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumBodyDeclarationsContext extends ParserRuleContext {
public List classBodyDeclaration() {
return getRuleContexts(ClassBodyDeclarationContext.class);
}
public ClassBodyDeclarationContext classBodyDeclaration(int i) {
return getRuleContext(ClassBodyDeclarationContext.class,i);
}
public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumBodyDeclarations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterEnumBodyDeclarations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitEnumBodyDeclarations(this);
}
}
public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
enterRule(_localctx, 94, RULE_enumBodyDeclarations);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(654);
match(SEMI);
setState(658);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRICTFP - 64)) | (1L << (SYNCHRONIZED - 64)) | (1L << (TRANSIENT - 64)) | (1L << (VOID - 64)) | (1L << (VOLATILE - 64)) | (1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (LT - 64)) | (1L << (Identifier - 64)) | (1L << (AT - 64)))) != 0)) {
{
{
setState(655);
classBodyDeclaration();
}
}
setState(660);
_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 InterfaceDeclarationContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public InterfaceBodyContext interfaceBody() {
return getRuleContext(InterfaceBodyContext.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterInterfaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitInterfaceDeclaration(this);
}
}
public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 96, RULE_interfaceDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(661);
match(INTERFACE);
setState(662);
match(Identifier);
setState(664);
_la = _input.LA(1);
if (_la==LT) {
{
setState(663);
typeParameters();
}
}
setState(668);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(666);
match(EXTENDS);
setState(667);
typeList();
}
}
setState(670);
interfaceBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeListContext extends ParserRuleContext {
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public TypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitTypeList(this);
}
}
public final TypeListContext typeList() throws RecognitionException {
TypeListContext _localctx = new TypeListContext(_ctx, getState());
enterRule(_localctx, 98, RULE_typeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(672);
type();
setState(677);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(673);
match(COMMA);
setState(674);
type();
}
}
setState(679);
_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 ClassBodyContext extends ParserRuleContext {
public List classBodyDeclaration() {
return getRuleContexts(ClassBodyDeclarationContext.class);
}
public ClassBodyDeclarationContext classBodyDeclaration(int i) {
return getRuleContext(ClassBodyDeclarationContext.class,i);
}
public ClassBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterClassBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitClassBody(this);
}
}
public final ClassBodyContext classBody() throws RecognitionException {
ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
enterRule(_localctx, 100, RULE_classBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(680);
match(LBRACE);
setState(684);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRICTFP - 64)) | (1L << (SYNCHRONIZED - 64)) | (1L << (TRANSIENT - 64)) | (1L << (VOID - 64)) | (1L << (VOLATILE - 64)) | (1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (LT - 64)) | (1L << (Identifier - 64)) | (1L << (AT - 64)))) != 0)) {
{
{
setState(681);
classBodyDeclaration();
}
}
setState(686);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(687);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceBodyContext extends ParserRuleContext {
public List interfaceBodyDeclaration() {
return getRuleContexts(InterfaceBodyDeclarationContext.class);
}
public InterfaceBodyDeclarationContext interfaceBodyDeclaration(int i) {
return getRuleContext(InterfaceBodyDeclarationContext.class,i);
}
public InterfaceBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterInterfaceBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitInterfaceBody(this);
}
}
public final InterfaceBodyContext interfaceBody() throws RecognitionException {
InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
enterRule(_localctx, 102, RULE_interfaceBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(689);
match(LBRACE);
setState(693);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRICTFP - 64)) | (1L << (SYNCHRONIZED - 64)) | (1L << (TRANSIENT - 64)) | (1L << (VOID - 64)) | (1L << (VOLATILE - 64)) | (1L << (SEMI - 64)) | (1L << (LT - 64)) | (1L << (Identifier - 64)) | (1L << (AT - 64)))) != 0)) {
{
{
setState(690);
interfaceBodyDeclaration();
}
}
setState(695);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(696);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassBodyDeclarationContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public MemberDeclarationContext memberDeclaration() {
return getRuleContext(MemberDeclarationContext.class,0);
}
public List modifier() {
return getRuleContexts(ModifierContext.class);
}
public ModifierContext modifier(int i) {
return getRuleContext(ModifierContext.class,i);
}
public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classBodyDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterClassBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitClassBodyDeclaration(this);
}
}
public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
enterRule(_localctx, 104, RULE_classBodyDeclaration);
int _la;
try {
int _alt;
setState(710);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(698);
match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(700);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(699);
match(STATIC);
}
}
setState(702);
block();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(706);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(703);
modifier();
}
}
}
setState(708);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
}
setState(709);
memberDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MemberDeclarationContext extends ParserRuleContext {
public MethodDeclarationContext methodDeclaration() {
return getRuleContext(MethodDeclarationContext.class,0);
}
public GenericMethodDeclarationContext genericMethodDeclaration() {
return getRuleContext(GenericMethodDeclarationContext.class,0);
}
public FieldDeclarationContext fieldDeclaration() {
return getRuleContext(FieldDeclarationContext.class,0);
}
public ConstructorDeclarationContext constructorDeclaration() {
return getRuleContext(ConstructorDeclarationContext.class,0);
}
public GenericConstructorDeclarationContext genericConstructorDeclaration() {
return getRuleContext(GenericConstructorDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public MemberDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_memberDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitMemberDeclaration(this);
}
}
public final MemberDeclarationContext memberDeclaration() throws RecognitionException {
MemberDeclarationContext _localctx = new MemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 106, RULE_memberDeclaration);
try {
setState(721);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(712);
methodDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(713);
genericMethodDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(714);
fieldDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(715);
constructorDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(716);
genericConstructorDeclaration();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(717);
interfaceDeclaration();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(718);
annotationTypeDeclaration();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(719);
classDeclaration();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(720);
enumDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodDeclarationContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public MethodBodyContext methodBody() {
return getRuleContext(MethodBodyContext.class,0);
}
public QualifiedNameListContext qualifiedNameList() {
return getRuleContext(QualifiedNameListContext.class,0);
}
public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitMethodDeclaration(this);
}
}
public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 108, RULE_methodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(725);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
{
setState(723);
type();
}
break;
case VOID:
{
setState(724);
match(VOID);
}
break;
default:
throw new NoViableAltException(this);
}
setState(727);
match(Identifier);
setState(728);
formalParameters();
setState(733);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(729);
match(LBRACK);
setState(730);
match(RBRACK);
}
}
setState(735);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(738);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(736);
match(THROWS);
setState(737);
qualifiedNameList();
}
}
setState(742);
switch (_input.LA(1)) {
case LBRACE:
{
setState(740);
methodBody();
}
break;
case SEMI:
{
setState(741);
match(SEMI);
}
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 GenericMethodDeclarationContext extends ParserRuleContext {
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public MethodDeclarationContext methodDeclaration() {
return getRuleContext(MethodDeclarationContext.class,0);
}
public GenericMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterGenericMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitGenericMethodDeclaration(this);
}
}
public final GenericMethodDeclarationContext genericMethodDeclaration() throws RecognitionException {
GenericMethodDeclarationContext _localctx = new GenericMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 110, RULE_genericMethodDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(744);
typeParameters();
setState(745);
methodDeclaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorDeclarationContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public ConstructorBodyContext constructorBody() {
return getRuleContext(ConstructorBodyContext.class,0);
}
public QualifiedNameListContext qualifiedNameList() {
return getRuleContext(QualifiedNameListContext.class,0);
}
public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitConstructorDeclaration(this);
}
}
public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
enterRule(_localctx, 112, RULE_constructorDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(747);
match(Identifier);
setState(748);
formalParameters();
setState(751);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(749);
match(THROWS);
setState(750);
qualifiedNameList();
}
}
setState(753);
constructorBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GenericConstructorDeclarationContext extends ParserRuleContext {
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public ConstructorDeclarationContext constructorDeclaration() {
return getRuleContext(ConstructorDeclarationContext.class,0);
}
public GenericConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericConstructorDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterGenericConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitGenericConstructorDeclaration(this);
}
}
public final GenericConstructorDeclarationContext genericConstructorDeclaration() throws RecognitionException {
GenericConstructorDeclarationContext _localctx = new GenericConstructorDeclarationContext(_ctx, getState());
enterRule(_localctx, 114, RULE_genericConstructorDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(755);
typeParameters();
setState(756);
constructorDeclaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldDeclarationContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public VariableDeclaratorsContext variableDeclarators() {
return getRuleContext(VariableDeclaratorsContext.class,0);
}
public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterFieldDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitFieldDeclaration(this);
}
}
public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
enterRule(_localctx, 116, RULE_fieldDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(758);
type();
setState(759);
variableDeclarators();
setState(760);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceBodyDeclarationContext extends ParserRuleContext {
public InterfaceMemberDeclarationContext interfaceMemberDeclaration() {
return getRuleContext(InterfaceMemberDeclarationContext.class,0);
}
public List modifier() {
return getRuleContexts(ModifierContext.class);
}
public ModifierContext modifier(int i) {
return getRuleContext(ModifierContext.class,i);
}
public InterfaceBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceBodyDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterInterfaceBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitInterfaceBodyDeclaration(this);
}
}
public final InterfaceBodyDeclarationContext interfaceBodyDeclaration() throws RecognitionException {
InterfaceBodyDeclarationContext _localctx = new InterfaceBodyDeclarationContext(_ctx, getState());
enterRule(_localctx, 118, RULE_interfaceBodyDeclaration);
try {
int _alt;
setState(770);
switch (_input.LA(1)) {
case ABSTRACT:
case BOOLEAN:
case BYTE:
case CHAR:
case CLASS:
case DOUBLE:
case ENUM:
case FINAL:
case FLOAT:
case INT:
case INTERFACE:
case LONG:
case NATIVE:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case SHORT:
case STATIC:
case STRICTFP:
case SYNCHRONIZED:
case TRANSIENT:
case VOID:
case VOLATILE:
case LT:
case Identifier:
case AT:
enterOuterAlt(_localctx, 1);
{
setState(765);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(762);
modifier();
}
}
}
setState(767);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
}
setState(768);
interfaceMemberDeclaration();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(769);
match(SEMI);
}
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 InterfaceMemberDeclarationContext extends ParserRuleContext {
public ConstDeclarationContext constDeclaration() {
return getRuleContext(ConstDeclarationContext.class,0);
}
public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
return getRuleContext(InterfaceMethodDeclarationContext.class,0);
}
public GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() {
return getRuleContext(GenericInterfaceMethodDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterInterfaceMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitInterfaceMemberDeclaration(this);
}
}
public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 120, RULE_interfaceMemberDeclaration);
try {
setState(779);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(772);
constDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(773);
interfaceMethodDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(774);
genericInterfaceMethodDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(775);
interfaceDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(776);
annotationTypeDeclaration();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(777);
classDeclaration();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(778);
enumDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstDeclarationContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public List constantDeclarator() {
return getRuleContexts(ConstantDeclaratorContext.class);
}
public ConstantDeclaratorContext constantDeclarator(int i) {
return getRuleContext(ConstantDeclaratorContext.class,i);
}
public ConstDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterConstDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitConstDeclaration(this);
}
}
public final ConstDeclarationContext constDeclaration() throws RecognitionException {
ConstDeclarationContext _localctx = new ConstDeclarationContext(_ctx, getState());
enterRule(_localctx, 122, RULE_constDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(781);
type();
setState(782);
constantDeclarator();
setState(787);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(783);
match(COMMA);
setState(784);
constantDeclarator();
}
}
setState(789);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(790);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantDeclaratorContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public VariableInitializerContext variableInitializer() {
return getRuleContext(VariableInitializerContext.class,0);
}
public ConstantDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantDeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterConstantDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitConstantDeclarator(this);
}
}
public final ConstantDeclaratorContext constantDeclarator() throws RecognitionException {
ConstantDeclaratorContext _localctx = new ConstantDeclaratorContext(_ctx, getState());
enterRule(_localctx, 124, RULE_constantDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(792);
match(Identifier);
setState(797);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(793);
match(LBRACK);
setState(794);
match(RBRACK);
}
}
setState(799);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(800);
match(ASSIGN);
setState(801);
variableInitializer();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceMethodDeclarationContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public QualifiedNameListContext qualifiedNameList() {
return getRuleContext(QualifiedNameListContext.class,0);
}
public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterInterfaceMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitInterfaceMethodDeclaration(this);
}
}
public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 126, RULE_interfaceMethodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(805);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
{
setState(803);
type();
}
break;
case VOID:
{
setState(804);
match(VOID);
}
break;
default:
throw new NoViableAltException(this);
}
setState(807);
match(Identifier);
setState(808);
formalParameters();
setState(813);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(809);
match(LBRACK);
setState(810);
match(RBRACK);
}
}
setState(815);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(818);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(816);
match(THROWS);
setState(817);
qualifiedNameList();
}
}
setState(820);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GenericInterfaceMethodDeclarationContext extends ParserRuleContext {
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
return getRuleContext(InterfaceMethodDeclarationContext.class,0);
}
public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericInterfaceMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterGenericInterfaceMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitGenericInterfaceMethodDeclaration(this);
}
}
public final GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() throws RecognitionException {
GenericInterfaceMethodDeclarationContext _localctx = new GenericInterfaceMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 128, RULE_genericInterfaceMethodDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(822);
typeParameters();
setState(823);
interfaceMethodDeclaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclaratorsContext extends ParserRuleContext {
public List variableDeclarator() {
return getRuleContexts(VariableDeclaratorContext.class);
}
public VariableDeclaratorContext variableDeclarator(int i) {
return getRuleContext(VariableDeclaratorContext.class,i);
}
public VariableDeclaratorsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclarators; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterVariableDeclarators(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitVariableDeclarators(this);
}
}
public final VariableDeclaratorsContext variableDeclarators() throws RecognitionException {
VariableDeclaratorsContext _localctx = new VariableDeclaratorsContext(_ctx, getState());
enterRule(_localctx, 130, RULE_variableDeclarators);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(825);
variableDeclarator();
setState(830);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(826);
match(COMMA);
setState(827);
variableDeclarator();
}
}
setState(832);
_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 VariableDeclaratorContext extends ParserRuleContext {
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public VariableInitializerContext variableInitializer() {
return getRuleContext(VariableInitializerContext.class,0);
}
public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterVariableDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitVariableDeclarator(this);
}
}
public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
enterRule(_localctx, 132, RULE_variableDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(833);
variableDeclaratorId();
setState(836);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(834);
match(ASSIGN);
setState(835);
variableInitializer();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclaratorIdContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclaratorId; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterVariableDeclaratorId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitVariableDeclaratorId(this);
}
}
public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
enterRule(_localctx, 134, RULE_variableDeclaratorId);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(838);
match(Identifier);
setState(843);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(839);
match(LBRACK);
setState(840);
match(RBRACK);
}
}
setState(845);
_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 VariableInitializerContext extends ParserRuleContext {
public ArrayInitializerContext arrayInitializer() {
return getRuleContext(ArrayInitializerContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public VariableInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterVariableInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitVariableInitializer(this);
}
}
public final VariableInitializerContext variableInitializer() throws RecognitionException {
VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
enterRule(_localctx, 136, RULE_variableInitializer);
try {
setState(848);
switch (_input.LA(1)) {
case LBRACE:
enterOuterAlt(_localctx, 1);
{
setState(846);
arrayInitializer();
}
break;
case IntegerLiteral:
case FloatingPointLiteral:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case NullLiteral:
case LPAREN:
case LT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(847);
expression(0);
}
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 ArrayInitializerContext extends ParserRuleContext {
public List variableInitializer() {
return getRuleContexts(VariableInitializerContext.class);
}
public VariableInitializerContext variableInitializer(int i) {
return getRuleContext(VariableInitializerContext.class,i);
}
public ArrayInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitArrayInitializer(this);
}
}
public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 138, RULE_arrayInitializer);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(850);
match(LBRACE);
setState(862);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (SUPER - 64)) | (1L << (THIS - 64)) | (1L << (VOID - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(851);
variableInitializer();
setState(856);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,65,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(852);
match(COMMA);
setState(853);
variableInitializer();
}
}
}
setState(858);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,65,_ctx);
}
setState(860);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(859);
match(COMMA);
}
}
}
}
setState(864);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantNameContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public EnumConstantNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstantName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterEnumConstantName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitEnumConstantName(this);
}
}
public final EnumConstantNameContext enumConstantName() throws RecognitionException {
EnumConstantNameContext _localctx = new EnumConstantNameContext(_ctx, getState());
enterRule(_localctx, 140, RULE_enumConstantName);
try {
enterOuterAlt(_localctx, 1);
{
setState(866);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeContext extends ParserRuleContext {
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitType(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 142, RULE_type);
try {
int _alt;
setState(884);
switch (_input.LA(1)) {
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(868);
classOrInterfaceType();
setState(873);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,68,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(869);
match(LBRACK);
setState(870);
match(RBRACK);
}
}
}
setState(875);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,68,_ctx);
}
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
enterOuterAlt(_localctx, 2);
{
setState(876);
primitiveType();
setState(881);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,69,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(877);
match(LBRACK);
setState(878);
match(RBRACK);
}
}
}
setState(883);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,69,_ctx);
}
}
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 ClassOrInterfaceTypeContext extends ParserRuleContext {
public List Identifier() { return getTokens(CQNGrammarParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(CQNGrammarParser.Identifier, i);
}
public List typeArguments() {
return getRuleContexts(TypeArgumentsContext.class);
}
public TypeArgumentsContext typeArguments(int i) {
return getRuleContext(TypeArgumentsContext.class,i);
}
public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitClassOrInterfaceType(this);
}
}
public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 144, RULE_classOrInterfaceType);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(886);
match(Identifier);
setState(888);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
{
setState(887);
typeArguments();
}
break;
}
setState(897);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,73,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(890);
match(DOT);
setState(891);
match(Identifier);
setState(893);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
{
setState(892);
typeArguments();
}
break;
}
}
}
}
setState(899);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,73,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimitiveTypeContext extends ParserRuleContext {
public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primitiveType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterPrimitiveType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitPrimitiveType(this);
}
}
public final PrimitiveTypeContext primitiveType() throws RecognitionException {
PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
enterRule(_localctx, 146, RULE_primitiveType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(900);
_la = _input.LA(1);
if ( !(((((_la - 30)) & ~0x3f) == 0 && ((1L << (_la - 30)) & ((1L << (BOOLEAN - 30)) | (1L << (BYTE - 30)) | (1L << (CHAR - 30)) | (1L << (DOUBLE - 30)) | (1L << (FLOAT - 30)) | (1L << (INT - 30)) | (1L << (LONG - 30)) | (1L << (SHORT - 30)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentsContext extends ParserRuleContext {
public List typeArgument() {
return getRuleContexts(TypeArgumentContext.class);
}
public TypeArgumentContext typeArgument(int i) {
return getRuleContext(TypeArgumentContext.class,i);
}
public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitTypeArguments(this);
}
}
public final TypeArgumentsContext typeArguments() throws RecognitionException {
TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 148, RULE_typeArguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(902);
match(LT);
setState(903);
typeArgument();
setState(908);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(904);
match(COMMA);
setState(905);
typeArgument();
}
}
setState(910);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(911);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterTypeArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitTypeArgument(this);
}
}
public final TypeArgumentContext typeArgument() throws RecognitionException {
TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
enterRule(_localctx, 150, RULE_typeArgument);
int _la;
try {
setState(919);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(913);
type();
}
break;
case QUESTION:
enterOuterAlt(_localctx, 2);
{
setState(914);
match(QUESTION);
setState(917);
_la = _input.LA(1);
if (_la==EXTENDS || _la==SUPER) {
{
setState(915);
_la = _input.LA(1);
if ( !(_la==EXTENDS || _la==SUPER) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(916);
type();
}
}
}
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 QualifiedNameListContext extends ParserRuleContext {
public List qualifiedName() {
return getRuleContexts(QualifiedNameContext.class);
}
public QualifiedNameContext qualifiedName(int i) {
return getRuleContext(QualifiedNameContext.class,i);
}
public QualifiedNameListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedNameList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterQualifiedNameList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitQualifiedNameList(this);
}
}
public final QualifiedNameListContext qualifiedNameList() throws RecognitionException {
QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, getState());
enterRule(_localctx, 152, RULE_qualifiedNameList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(921);
qualifiedName();
setState(926);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(922);
match(COMMA);
setState(923);
qualifiedName();
}
}
setState(928);
_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 FormalParametersContext extends ParserRuleContext {
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,0);
}
public FormalParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterFormalParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitFormalParameters(this);
}
}
public final FormalParametersContext formalParameters() throws RecognitionException {
FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
enterRule(_localctx, 154, RULE_formalParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(929);
match(LPAREN);
setState(931);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (Identifier - 64)) | (1L << (AT - 64)))) != 0)) {
{
setState(930);
formalParameterList();
}
}
setState(933);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParameterListContext extends ParserRuleContext {
public List formalParameter() {
return getRuleContexts(FormalParameterContext.class);
}
public FormalParameterContext formalParameter(int i) {
return getRuleContext(FormalParameterContext.class,i);
}
public LastFormalParameterContext lastFormalParameter() {
return getRuleContext(LastFormalParameterContext.class,0);
}
public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterFormalParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitFormalParameterList(this);
}
}
public final FormalParameterListContext formalParameterList() throws RecognitionException {
FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
enterRule(_localctx, 156, RULE_formalParameterList);
int _la;
try {
int _alt;
setState(948);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(935);
formalParameter();
setState(940);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,79,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(936);
match(COMMA);
setState(937);
formalParameter();
}
}
}
setState(942);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,79,_ctx);
}
setState(945);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(943);
match(COMMA);
setState(944);
lastFormalParameter();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(947);
lastFormalParameter();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParameterContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public FormalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitFormalParameter(this);
}
}
public final FormalParameterContext formalParameter() throws RecognitionException {
FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
enterRule(_localctx, 158, RULE_formalParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(953);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(950);
variableModifier();
}
}
setState(955);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(956);
type();
setState(957);
variableDeclaratorId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LastFormalParameterContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public LastFormalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lastFormalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterLastFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitLastFormalParameter(this);
}
}
public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
enterRule(_localctx, 160, RULE_lastFormalParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(962);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(959);
variableModifier();
}
}
setState(964);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(965);
type();
setState(966);
match(ELLIPSIS);
setState(967);
variableDeclaratorId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodBodyContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public MethodBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterMethodBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitMethodBody(this);
}
}
public final MethodBodyContext methodBody() throws RecognitionException {
MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
enterRule(_localctx, 162, RULE_methodBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(969);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorBodyContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public ConstructorBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterConstructorBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitConstructorBody(this);
}
}
public final ConstructorBodyContext constructorBody() throws RecognitionException {
ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState());
enterRule(_localctx, 164, RULE_constructorBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(971);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedNameContext extends ParserRuleContext {
public List Identifier() { return getTokens(CQNGrammarParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(CQNGrammarParser.Identifier, i);
}
public QualifiedNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterQualifiedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitQualifiedName(this);
}
}
public final QualifiedNameContext qualifiedName() throws RecognitionException {
QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
enterRule(_localctx, 166, RULE_qualifiedName);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(973);
match(Identifier);
setState(978);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(974);
match(DOT);
setState(975);
match(Identifier);
}
}
}
setState(980);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
}
}
}
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 AnnotationNameContext annotationName() {
return getRuleContext(AnnotationNameContext.class,0);
}
public ElementValuePairsContext elementValuePairs() {
return getRuleContext(ElementValuePairsContext.class,0);
}
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,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 CQNGrammarListener ) ((CQNGrammarListener)listener).enterAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAnnotation(this);
}
}
public final AnnotationContext annotation() throws RecognitionException {
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
enterRule(_localctx, 168, RULE_annotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(981);
match(AT);
setState(982);
annotationName();
setState(989);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(983);
match(LPAREN);
setState(986);
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
case 1:
{
setState(984);
elementValuePairs();
}
break;
case 2:
{
setState(985);
elementValue();
}
break;
}
setState(988);
match(RPAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationNameContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public AnnotationNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAnnotationName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAnnotationName(this);
}
}
public final AnnotationNameContext annotationName() throws RecognitionException {
AnnotationNameContext _localctx = new AnnotationNameContext(_ctx, getState());
enterRule(_localctx, 170, RULE_annotationName);
try {
enterOuterAlt(_localctx, 1);
{
setState(991);
qualifiedName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValuePairsContext extends ParserRuleContext {
public List elementValuePair() {
return getRuleContexts(ElementValuePairContext.class);
}
public ElementValuePairContext elementValuePair(int i) {
return getRuleContext(ElementValuePairContext.class,i);
}
public ElementValuePairsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValuePairs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterElementValuePairs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitElementValuePairs(this);
}
}
public final ElementValuePairsContext elementValuePairs() throws RecognitionException {
ElementValuePairsContext _localctx = new ElementValuePairsContext(_ctx, getState());
enterRule(_localctx, 172, RULE_elementValuePairs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(993);
elementValuePair();
setState(998);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(994);
match(COMMA);
setState(995);
elementValuePair();
}
}
setState(1000);
_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 ElementValuePairContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public ElementValuePairContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValuePair; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterElementValuePair(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitElementValuePair(this);
}
}
public final ElementValuePairContext elementValuePair() throws RecognitionException {
ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
enterRule(_localctx, 174, RULE_elementValuePair);
try {
enterOuterAlt(_localctx, 1);
{
setState(1001);
match(Identifier);
setState(1002);
match(ASSIGN);
setState(1003);
elementValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValueContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public ElementValueArrayInitializerContext elementValueArrayInitializer() {
return getRuleContext(ElementValueArrayInitializerContext.class,0);
}
public ElementValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterElementValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitElementValue(this);
}
}
public final ElementValueContext elementValue() throws RecognitionException {
ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
enterRule(_localctx, 176, RULE_elementValue);
try {
setState(1008);
switch (_input.LA(1)) {
case IntegerLiteral:
case FloatingPointLiteral:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case NullLiteral:
case LPAREN:
case LT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1005);
expression(0);
}
break;
case AT:
enterOuterAlt(_localctx, 2);
{
setState(1006);
annotation();
}
break;
case LBRACE:
enterOuterAlt(_localctx, 3);
{
setState(1007);
elementValueArrayInitializer();
}
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 ElementValueArrayInitializerContext extends ParserRuleContext {
public List elementValue() {
return getRuleContexts(ElementValueContext.class);
}
public ElementValueContext elementValue(int i) {
return getRuleContext(ElementValueContext.class,i);
}
public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterElementValueArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitElementValueArrayInitializer(this);
}
}
public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 178, RULE_elementValueArrayInitializer);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1010);
match(LBRACE);
setState(1019);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (SUPER - 64)) | (1L << (THIS - 64)) | (1L << (VOID - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)) | (1L << (AT - 64)))) != 0)) {
{
setState(1011);
elementValue();
setState(1016);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1012);
match(COMMA);
setState(1013);
elementValue();
}
}
}
setState(1018);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
}
}
}
setState(1022);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1021);
match(COMMA);
}
}
setState(1024);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeDeclarationContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public AnnotationTypeBodyContext annotationTypeBody() {
return getRuleContext(AnnotationTypeBodyContext.class,0);
}
public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAnnotationTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAnnotationTypeDeclaration(this);
}
}
public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 180, RULE_annotationTypeDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(1026);
match(AT);
setState(1027);
match(INTERFACE);
setState(1028);
match(Identifier);
setState(1029);
annotationTypeBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeBodyContext extends ParserRuleContext {
public List annotationTypeElementDeclaration() {
return getRuleContexts(AnnotationTypeElementDeclarationContext.class);
}
public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration(int i) {
return getRuleContext(AnnotationTypeElementDeclarationContext.class,i);
}
public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAnnotationTypeBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAnnotationTypeBody(this);
}
}
public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
enterRule(_localctx, 182, RULE_annotationTypeBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1031);
match(LBRACE);
setState(1035);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRICTFP - 64)) | (1L << (SYNCHRONIZED - 64)) | (1L << (TRANSIENT - 64)) | (1L << (VOLATILE - 64)) | (1L << (SEMI - 64)) | (1L << (Identifier - 64)) | (1L << (AT - 64)))) != 0)) {
{
{
setState(1032);
annotationTypeElementDeclaration();
}
}
setState(1037);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1038);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext {
public AnnotationTypeElementRestContext annotationTypeElementRest() {
return getRuleContext(AnnotationTypeElementRestContext.class,0);
}
public List modifier() {
return getRuleContexts(ModifierContext.class);
}
public ModifierContext modifier(int i) {
return getRuleContext(ModifierContext.class,i);
}
public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAnnotationTypeElementDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAnnotationTypeElementDeclaration(this);
}
}
public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException {
AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState());
enterRule(_localctx, 184, RULE_annotationTypeElementDeclaration);
try {
int _alt;
setState(1048);
switch (_input.LA(1)) {
case ABSTRACT:
case BOOLEAN:
case BYTE:
case CHAR:
case CLASS:
case DOUBLE:
case ENUM:
case FINAL:
case FLOAT:
case INT:
case INTERFACE:
case LONG:
case NATIVE:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case SHORT:
case STATIC:
case STRICTFP:
case SYNCHRONIZED:
case TRANSIENT:
case VOLATILE:
case Identifier:
case AT:
enterOuterAlt(_localctx, 1);
{
setState(1043);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1040);
modifier();
}
}
}
setState(1045);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
}
setState(1046);
annotationTypeElementRest();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(1047);
match(SEMI);
}
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 AnnotationTypeElementRestContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() {
return getRuleContext(AnnotationMethodOrConstantRestContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public AnnotationTypeElementRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeElementRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAnnotationTypeElementRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAnnotationTypeElementRest(this);
}
}
public final AnnotationTypeElementRestContext annotationTypeElementRest() throws RecognitionException {
AnnotationTypeElementRestContext _localctx = new AnnotationTypeElementRestContext(_ctx, getState());
enterRule(_localctx, 186, RULE_annotationTypeElementRest);
try {
setState(1070);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1050);
type();
setState(1051);
annotationMethodOrConstantRest();
setState(1052);
match(SEMI);
}
break;
case CLASS:
enterOuterAlt(_localctx, 2);
{
setState(1054);
classDeclaration();
setState(1056);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(1055);
match(SEMI);
}
break;
}
}
break;
case INTERFACE:
enterOuterAlt(_localctx, 3);
{
setState(1058);
interfaceDeclaration();
setState(1060);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
{
setState(1059);
match(SEMI);
}
break;
}
}
break;
case ENUM:
enterOuterAlt(_localctx, 4);
{
setState(1062);
enumDeclaration();
setState(1064);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(1063);
match(SEMI);
}
break;
}
}
break;
case AT:
enterOuterAlt(_localctx, 5);
{
setState(1066);
annotationTypeDeclaration();
setState(1068);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(1067);
match(SEMI);
}
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 class AnnotationMethodOrConstantRestContext extends ParserRuleContext {
public AnnotationMethodRestContext annotationMethodRest() {
return getRuleContext(AnnotationMethodRestContext.class,0);
}
public AnnotationConstantRestContext annotationConstantRest() {
return getRuleContext(AnnotationConstantRestContext.class,0);
}
public AnnotationMethodOrConstantRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationMethodOrConstantRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAnnotationMethodOrConstantRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAnnotationMethodOrConstantRest(this);
}
}
public final AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() throws RecognitionException {
AnnotationMethodOrConstantRestContext _localctx = new AnnotationMethodOrConstantRestContext(_ctx, getState());
enterRule(_localctx, 188, RULE_annotationMethodOrConstantRest);
try {
setState(1074);
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1072);
annotationMethodRest();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1073);
annotationConstantRest();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationMethodRestContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public DefaultValueContext defaultValue() {
return getRuleContext(DefaultValueContext.class,0);
}
public AnnotationMethodRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationMethodRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAnnotationMethodRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAnnotationMethodRest(this);
}
}
public final AnnotationMethodRestContext annotationMethodRest() throws RecognitionException {
AnnotationMethodRestContext _localctx = new AnnotationMethodRestContext(_ctx, getState());
enterRule(_localctx, 190, RULE_annotationMethodRest);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1076);
match(Identifier);
setState(1077);
match(LPAREN);
setState(1078);
match(RPAREN);
setState(1080);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(1079);
defaultValue();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationConstantRestContext extends ParserRuleContext {
public VariableDeclaratorsContext variableDeclarators() {
return getRuleContext(VariableDeclaratorsContext.class,0);
}
public AnnotationConstantRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationConstantRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterAnnotationConstantRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitAnnotationConstantRest(this);
}
}
public final AnnotationConstantRestContext annotationConstantRest() throws RecognitionException {
AnnotationConstantRestContext _localctx = new AnnotationConstantRestContext(_ctx, getState());
enterRule(_localctx, 192, RULE_annotationConstantRest);
try {
enterOuterAlt(_localctx, 1);
{
setState(1082);
variableDeclarators();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultValueContext extends ParserRuleContext {
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public DefaultValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterDefaultValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitDefaultValue(this);
}
}
public final DefaultValueContext defaultValue() throws RecognitionException {
DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState());
enterRule(_localctx, 194, RULE_defaultValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(1084);
match(DEFAULT);
setState(1085);
elementValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockContext extends ParserRuleContext {
public List blockStatement() {
return getRuleContexts(BlockStatementContext.class);
}
public BlockStatementContext blockStatement(int i) {
return getRuleContext(BlockStatementContext.class,i);
}
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitBlock(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 196, RULE_block);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1087);
match(LBRACE);
setState(1091);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRICTFP - 64)) | (1L << (SUPER - 64)) | (1L << (SWITCH - 64)) | (1L << (SYNCHRONIZED - 64)) | (1L << (THIS - 64)) | (1L << (THROW - 64)) | (1L << (TRY - 64)) | (1L << (VOID - 64)) | (1L << (WHILE - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)) | (1L << (AT - 64)))) != 0)) {
{
{
setState(1088);
blockStatement();
}
}
setState(1093);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1094);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockStatementContext extends ParserRuleContext {
public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() {
return getRuleContext(LocalVariableDeclarationStatementContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TypeDeclarationContext typeDeclaration() {
return getRuleContext(TypeDeclarationContext.class,0);
}
public BlockStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blockStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterBlockStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitBlockStatement(this);
}
}
public final BlockStatementContext blockStatement() throws RecognitionException {
BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
enterRule(_localctx, 198, RULE_blockStatement);
try {
setState(1099);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1096);
localVariableDeclarationStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1097);
statement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1098);
typeDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocalVariableDeclarationStatementContext extends ParserRuleContext {
public LocalVariableDeclarationContext localVariableDeclaration() {
return getRuleContext(LocalVariableDeclarationContext.class,0);
}
public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localVariableDeclarationStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterLocalVariableDeclarationStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitLocalVariableDeclarationStatement(this);
}
}
public final LocalVariableDeclarationStatementContext localVariableDeclarationStatement() throws RecognitionException {
LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(_ctx, getState());
enterRule(_localctx, 200, RULE_localVariableDeclarationStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1101);
localVariableDeclaration();
setState(1102);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocalVariableDeclarationContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public VariableDeclaratorsContext variableDeclarators() {
return getRuleContext(VariableDeclaratorsContext.class,0);
}
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localVariableDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterLocalVariableDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitLocalVariableDeclaration(this);
}
}
public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
enterRule(_localctx, 202, RULE_localVariableDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1107);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1104);
variableModifier();
}
}
setState(1109);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1110);
type();
setState(1111);
variableDeclarators();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode ASSERT() { return getToken(CQNGrammarParser.ASSERT, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ParExpressionContext parExpression() {
return getRuleContext(ParExpressionContext.class,0);
}
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public ForControlContext forControl() {
return getRuleContext(ForControlContext.class,0);
}
public FinallyBlockContext finallyBlock() {
return getRuleContext(FinallyBlockContext.class,0);
}
public List catchClause() {
return getRuleContexts(CatchClauseContext.class);
}
public CatchClauseContext catchClause(int i) {
return getRuleContext(CatchClauseContext.class,i);
}
public ResourceSpecificationContext resourceSpecification() {
return getRuleContext(ResourceSpecificationContext.class,0);
}
public List switchBlockStatementGroup() {
return getRuleContexts(SwitchBlockStatementGroupContext.class);
}
public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) {
return getRuleContext(SwitchBlockStatementGroupContext.class,i);
}
public List switchLabel() {
return getRuleContexts(SwitchLabelContext.class);
}
public SwitchLabelContext switchLabel(int i) {
return getRuleContext(SwitchLabelContext.class,i);
}
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public StatementExpressionContext statementExpression() {
return getRuleContext(StatementExpressionContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitStatement(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 204, RULE_statement);
int _la;
try {
int _alt;
setState(1217);
switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1113);
block();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1114);
match(ASSERT);
setState(1115);
expression(0);
setState(1118);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(1116);
match(COLON);
setState(1117);
expression(0);
}
}
setState(1120);
match(SEMI);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1122);
match(IF);
setState(1123);
parExpression();
setState(1124);
statement();
setState(1127);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
{
setState(1125);
match(ELSE);
setState(1126);
statement();
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1129);
match(FOR);
setState(1130);
match(LPAREN);
setState(1131);
forControl();
setState(1132);
match(RPAREN);
setState(1133);
statement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1135);
match(WHILE);
setState(1136);
parExpression();
setState(1137);
statement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1139);
match(DO);
setState(1140);
statement();
setState(1141);
match(WHILE);
setState(1142);
parExpression();
setState(1143);
match(SEMI);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1145);
match(TRY);
setState(1146);
block();
setState(1156);
switch (_input.LA(1)) {
case CATCH:
{
setState(1148);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1147);
catchClause();
}
}
setState(1150);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CATCH );
setState(1153);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(1152);
finallyBlock();
}
}
}
break;
case FINALLY:
{
setState(1155);
finallyBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1158);
match(TRY);
setState(1159);
resourceSpecification();
setState(1160);
block();
setState(1164);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CATCH) {
{
{
setState(1161);
catchClause();
}
}
setState(1166);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1168);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(1167);
finallyBlock();
}
}
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(1170);
match(SWITCH);
setState(1171);
parExpression();
setState(1172);
match(LBRACE);
setState(1176);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,112,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1173);
switchBlockStatementGroup();
}
}
}
setState(1178);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,112,_ctx);
}
setState(1182);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CASE || _la==DEFAULT) {
{
{
setState(1179);
switchLabel();
}
}
setState(1184);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1185);
match(RBRACE);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(1187);
match(SYNCHRONIZED);
setState(1188);
parExpression();
setState(1189);
block();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(1191);
match(RETURN);
setState(1193);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (SUPER - 64)) | (1L << (THIS - 64)) | (1L << (VOID - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1192);
expression(0);
}
}
setState(1195);
match(SEMI);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(1196);
match(THROW);
setState(1197);
expression(0);
setState(1198);
match(SEMI);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(1200);
match(BREAK);
setState(1202);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(1201);
match(Identifier);
}
}
setState(1204);
match(SEMI);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(1205);
match(CONTINUE);
setState(1207);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(1206);
match(Identifier);
}
}
setState(1209);
match(SEMI);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(1210);
match(SEMI);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(1211);
statementExpression();
setState(1212);
match(SEMI);
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(1214);
match(Identifier);
setState(1215);
match(COLON);
setState(1216);
statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchClauseContext extends ParserRuleContext {
public CatchTypeContext catchType() {
return getRuleContext(CatchTypeContext.class,0);
}
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public CatchClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterCatchClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitCatchClause(this);
}
}
public final CatchClauseContext catchClause() throws RecognitionException {
CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
enterRule(_localctx, 206, RULE_catchClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1219);
match(CATCH);
setState(1220);
match(LPAREN);
setState(1224);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1221);
variableModifier();
}
}
setState(1226);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1227);
catchType();
setState(1228);
match(Identifier);
setState(1229);
match(RPAREN);
setState(1230);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchTypeContext extends ParserRuleContext {
public List qualifiedName() {
return getRuleContexts(QualifiedNameContext.class);
}
public QualifiedNameContext qualifiedName(int i) {
return getRuleContext(QualifiedNameContext.class,i);
}
public CatchTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterCatchType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitCatchType(this);
}
}
public final CatchTypeContext catchType() throws RecognitionException {
CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState());
enterRule(_localctx, 208, RULE_catchType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1232);
qualifiedName();
setState(1237);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITOR) {
{
{
setState(1233);
match(BITOR);
setState(1234);
qualifiedName();
}
}
setState(1239);
_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 FinallyBlockContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public FinallyBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_finallyBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterFinallyBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitFinallyBlock(this);
}
}
public final FinallyBlockContext finallyBlock() throws RecognitionException {
FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState());
enterRule(_localctx, 210, RULE_finallyBlock);
try {
enterOuterAlt(_localctx, 1);
{
setState(1240);
match(FINALLY);
setState(1241);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourceSpecificationContext extends ParserRuleContext {
public ResourcesContext resources() {
return getRuleContext(ResourcesContext.class,0);
}
public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resourceSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterResourceSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitResourceSpecification(this);
}
}
public final ResourceSpecificationContext resourceSpecification() throws RecognitionException {
ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState());
enterRule(_localctx, 212, RULE_resourceSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1243);
match(LPAREN);
setState(1244);
resources();
setState(1246);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(1245);
match(SEMI);
}
}
setState(1248);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourcesContext extends ParserRuleContext {
public List resource() {
return getRuleContexts(ResourceContext.class);
}
public ResourceContext resource(int i) {
return getRuleContext(ResourceContext.class,i);
}
public ResourcesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resources; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterResources(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitResources(this);
}
}
public final ResourcesContext resources() throws RecognitionException {
ResourcesContext _localctx = new ResourcesContext(_ctx, getState());
enterRule(_localctx, 214, RULE_resources);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1250);
resource();
setState(1255);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,121,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1251);
match(SEMI);
setState(1252);
resource();
}
}
}
setState(1257);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,121,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourceContext extends ParserRuleContext {
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public ResourceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resource; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitResource(this);
}
}
public final ResourceContext resource() throws RecognitionException {
ResourceContext _localctx = new ResourceContext(_ctx, getState());
enterRule(_localctx, 216, RULE_resource);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1261);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1258);
variableModifier();
}
}
setState(1263);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1264);
classOrInterfaceType();
setState(1265);
variableDeclaratorId();
setState(1266);
match(ASSIGN);
setState(1267);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchBlockStatementGroupContext extends ParserRuleContext {
public List switchLabel() {
return getRuleContexts(SwitchLabelContext.class);
}
public SwitchLabelContext switchLabel(int i) {
return getRuleContext(SwitchLabelContext.class,i);
}
public List blockStatement() {
return getRuleContexts(BlockStatementContext.class);
}
public BlockStatementContext blockStatement(int i) {
return getRuleContext(BlockStatementContext.class,i);
}
public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterSwitchBlockStatementGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitSwitchBlockStatementGroup(this);
}
}
public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException {
SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState());
enterRule(_localctx, 218, RULE_switchBlockStatementGroup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1270);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1269);
switchLabel();
}
}
setState(1272);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CASE || _la==DEFAULT );
setState(1275);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1274);
blockStatement();
}
}
setState(1277);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (STATIC - 64)) | (1L << (STRICTFP - 64)) | (1L << (SUPER - 64)) | (1L << (SWITCH - 64)) | (1L << (SYNCHRONIZED - 64)) | (1L << (THIS - 64)) | (1L << (THROW - 64)) | (1L << (TRY - 64)) | (1L << (VOID - 64)) | (1L << (WHILE - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)) | (1L << (AT - 64)))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchLabelContext extends ParserRuleContext {
public ConstantExpressionContext constantExpression() {
return getRuleContext(ConstantExpressionContext.class,0);
}
public EnumConstantNameContext enumConstantName() {
return getRuleContext(EnumConstantNameContext.class,0);
}
public SwitchLabelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchLabel; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterSwitchLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitSwitchLabel(this);
}
}
public final SwitchLabelContext switchLabel() throws RecognitionException {
SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState());
enterRule(_localctx, 220, RULE_switchLabel);
try {
setState(1289);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1279);
match(CASE);
setState(1280);
constantExpression();
setState(1281);
match(COLON);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1283);
match(CASE);
setState(1284);
enumConstantName();
setState(1285);
match(COLON);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1287);
match(DEFAULT);
setState(1288);
match(COLON);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForControlContext extends ParserRuleContext {
public EnhancedForControlContext enhancedForControl() {
return getRuleContext(EnhancedForControlContext.class,0);
}
public ForInitContext forInit() {
return getRuleContext(ForInitContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ForUpdateContext forUpdate() {
return getRuleContext(ForUpdateContext.class,0);
}
public ForControlContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forControl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterForControl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitForControl(this);
}
}
public final ForControlContext forControl() throws RecognitionException {
ForControlContext _localctx = new ForControlContext(_ctx, getState());
enterRule(_localctx, 222, RULE_forControl);
int _la;
try {
setState(1303);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1291);
enhancedForControl();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1293);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (SUPER - 64)) | (1L << (THIS - 64)) | (1L << (VOID - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)) | (1L << (AT - 64)))) != 0)) {
{
setState(1292);
forInit();
}
}
setState(1295);
match(SEMI);
setState(1297);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (SUPER - 64)) | (1L << (THIS - 64)) | (1L << (VOID - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1296);
expression(0);
}
}
setState(1299);
match(SEMI);
setState(1301);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (SUPER - 64)) | (1L << (THIS - 64)) | (1L << (VOID - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1300);
forUpdate();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForInitContext extends ParserRuleContext {
public LocalVariableDeclarationContext localVariableDeclaration() {
return getRuleContext(LocalVariableDeclarationContext.class,0);
}
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public ForInitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forInit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterForInit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitForInit(this);
}
}
public final ForInitContext forInit() throws RecognitionException {
ForInitContext _localctx = new ForInitContext(_ctx, getState());
enterRule(_localctx, 224, RULE_forInit);
try {
setState(1307);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1305);
localVariableDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1306);
expressionList();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnhancedForControlContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public EnhancedForControlContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enhancedForControl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterEnhancedForControl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitEnhancedForControl(this);
}
}
public final EnhancedForControlContext enhancedForControl() throws RecognitionException {
EnhancedForControlContext _localctx = new EnhancedForControlContext(_ctx, getState());
enterRule(_localctx, 226, RULE_enhancedForControl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1312);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1309);
variableModifier();
}
}
setState(1314);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1315);
type();
setState(1316);
variableDeclaratorId();
setState(1317);
match(COLON);
setState(1318);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForUpdateContext extends ParserRuleContext {
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public ForUpdateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forUpdate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterForUpdate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitForUpdate(this);
}
}
public final ForUpdateContext forUpdate() throws RecognitionException {
ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState());
enterRule(_localctx, 228, RULE_forUpdate);
try {
enterOuterAlt(_localctx, 1);
{
setState(1320);
expressionList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ParExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterParExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitParExpression(this);
}
}
public final ParExpressionContext parExpression() throws RecognitionException {
ParExpressionContext _localctx = new ParExpressionContext(_ctx, getState());
enterRule(_localctx, 230, RULE_parExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1322);
match(LPAREN);
setState(1323);
expression(0);
setState(1324);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionListContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitExpressionList(this);
}
}
public final ExpressionListContext expressionList() throws RecognitionException {
ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
enterRule(_localctx, 232, RULE_expressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1326);
expression(0);
setState(1331);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1327);
match(COMMA);
setState(1328);
expression(0);
}
}
setState(1333);
_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 StatementExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterStatementExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitStatementExpression(this);
}
}
public final StatementExpressionContext statementExpression() throws RecognitionException {
StatementExpressionContext _localctx = new StatementExpressionContext(_ctx, getState());
enterRule(_localctx, 234, RULE_statementExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1334);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ConstantExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterConstantExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitConstantExpression(this);
}
}
public final ConstantExpressionContext constantExpression() throws RecognitionException {
ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState());
enterRule(_localctx, 236, RULE_constantExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1336);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public CreatorContext creator() {
return getRuleContext(CreatorContext.class,0);
}
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public InnerCreatorContext innerCreator() {
return getRuleContext(InnerCreatorContext.class,0);
}
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public SuperSuffixContext superSuffix() {
return getRuleContext(SuperSuffixContext.class,0);
}
public ExplicitGenericInvocationContext explicitGenericInvocation() {
return getRuleContext(ExplicitGenericInvocationContext.class,0);
}
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.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 CQNGrammarListener ) ((CQNGrammarListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitExpression(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 238;
enterRecursionRule(_localctx, 238, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1351);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
{
setState(1339);
match(LPAREN);
setState(1340);
type();
setState(1341);
match(RPAREN);
setState(1342);
expression(17);
}
break;
case 2:
{
setState(1344);
_la = _input.LA(1);
if ( !(((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (INC - 104)) | (1L << (DEC - 104)) | (1L << (ADD - 104)) | (1L << (SUB - 104)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1345);
expression(15);
}
break;
case 3:
{
setState(1346);
_la = _input.LA(1);
if ( !(_la==BANG || _la==TILDE) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1347);
expression(14);
}
break;
case 4:
{
setState(1348);
primary();
}
break;
case 5:
{
setState(1349);
match(NEW);
setState(1350);
creator();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1438);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,138,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1436);
switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
case 1:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1353);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(1354);
_la = _input.LA(1);
if ( !(((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (MUL - 108)) | (1L << (DIV - 108)) | (1L << (MOD - 108)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1355);
expression(14);
}
break;
case 2:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1356);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(1357);
_la = _input.LA(1);
if ( !(_la==ADD || _la==SUB) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1358);
expression(13);
}
break;
case 3:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1359);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(1367);
switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
case 1:
{
setState(1360);
match(LT);
setState(1361);
match(LT);
}
break;
case 2:
{
setState(1362);
match(GT);
setState(1363);
match(GT);
setState(1364);
match(GT);
}
break;
case 3:
{
setState(1365);
match(GT);
setState(1366);
match(GT);
}
break;
}
setState(1369);
expression(12);
}
break;
case 4:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1370);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(1371);
_la = _input.LA(1);
if ( !(((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (GT - 92)) | (1L << (LT - 92)) | (1L << (LE - 92)) | (1L << (GE - 92)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1372);
expression(11);
}
break;
case 5:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1373);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(1374);
_la = _input.LA(1);
if ( !(_la==EQUAL || _la==NOTEQUAL) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1375);
expression(9);
}
break;
case 6:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1376);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(1377);
match(BITAND);
setState(1378);
expression(8);
}
break;
case 7:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1379);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(1380);
match(CARET);
setState(1381);
expression(7);
}
break;
case 8:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1382);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1383);
match(BITOR);
setState(1384);
expression(6);
}
break;
case 9:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1385);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(1386);
match(AND);
setState(1387);
expression(5);
}
break;
case 10:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1388);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1389);
match(OR);
setState(1390);
expression(4);
}
break;
case 11:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1391);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1392);
match(QUESTION);
setState(1393);
expression(0);
setState(1394);
match(COLON);
setState(1395);
expression(3);
}
break;
case 12:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1397);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1398);
_la = _input.LA(1);
if ( !(((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (ASSIGN - 91)) | (1L << (ADD_ASSIGN - 91)) | (1L << (SUB_ASSIGN - 91)) | (1L << (MUL_ASSIGN - 91)) | (1L << (DIV_ASSIGN - 91)) | (1L << (AND_ASSIGN - 91)) | (1L << (OR_ASSIGN - 91)) | (1L << (XOR_ASSIGN - 91)) | (1L << (MOD_ASSIGN - 91)) | (1L << (LSHIFT_ASSIGN - 91)) | (1L << (RSHIFT_ASSIGN - 91)) | (1L << (URSHIFT_ASSIGN - 91)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(1399);
expression(1);
}
break;
case 13:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1400);
if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)");
setState(1401);
match(DOT);
setState(1402);
match(Identifier);
}
break;
case 14:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1403);
if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)");
setState(1404);
match(DOT);
setState(1405);
match(THIS);
}
break;
case 15:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1406);
if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)");
setState(1407);
match(DOT);
setState(1408);
match(NEW);
setState(1410);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1409);
nonWildcardTypeArguments();
}
}
setState(1412);
innerCreator();
}
break;
case 16:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1413);
if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)");
setState(1414);
match(DOT);
setState(1415);
match(SUPER);
setState(1416);
superSuffix();
}
break;
case 17:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1417);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(1418);
match(DOT);
setState(1419);
explicitGenericInvocation();
}
break;
case 18:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1420);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(1421);
match(LBRACK);
setState(1422);
expression(0);
setState(1423);
match(RBRACK);
}
break;
case 19:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1425);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(1426);
match(LPAREN);
setState(1428);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (SUPER - 64)) | (1L << (THIS - 64)) | (1L << (VOID - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1427);
expressionList();
}
}
setState(1430);
match(RPAREN);
}
break;
case 20:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1431);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(1432);
_la = _input.LA(1);
if ( !(_la==INC || _la==DEC) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
break;
case 21:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1433);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(1434);
match(INSTANCEOF);
setState(1435);
type();
}
break;
}
}
}
setState(1440);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,138,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class PrimaryContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() {
return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0);
}
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public PrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitPrimary(this);
}
}
public final PrimaryContext primary() throws RecognitionException {
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
enterRule(_localctx, 240, RULE_primary);
try {
setState(1462);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1441);
match(LPAREN);
setState(1442);
expression(0);
setState(1443);
match(RPAREN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1445);
match(THIS);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1446);
match(SUPER);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1447);
literal();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1448);
match(Identifier);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1449);
type();
setState(1450);
match(DOT);
setState(1451);
match(CLASS);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1453);
match(VOID);
setState(1454);
match(DOT);
setState(1455);
match(CLASS);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1456);
nonWildcardTypeArguments();
setState(1460);
switch (_input.LA(1)) {
case SUPER:
case Identifier:
{
setState(1457);
explicitGenericInvocationSuffix();
}
break;
case THIS:
{
setState(1458);
match(THIS);
setState(1459);
arguments();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreatorContext extends ParserRuleContext {
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public CreatedNameContext createdName() {
return getRuleContext(CreatedNameContext.class,0);
}
public ClassCreatorRestContext classCreatorRest() {
return getRuleContext(ClassCreatorRestContext.class,0);
}
public ArrayCreatorRestContext arrayCreatorRest() {
return getRuleContext(ArrayCreatorRestContext.class,0);
}
public CreatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_creator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterCreator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitCreator(this);
}
}
public final CreatorContext creator() throws RecognitionException {
CreatorContext _localctx = new CreatorContext(_ctx, getState());
enterRule(_localctx, 242, RULE_creator);
try {
setState(1473);
switch (_input.LA(1)) {
case LT:
enterOuterAlt(_localctx, 1);
{
setState(1464);
nonWildcardTypeArguments();
setState(1465);
createdName();
setState(1466);
classCreatorRest();
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(1468);
createdName();
setState(1471);
switch (_input.LA(1)) {
case LBRACK:
{
setState(1469);
arrayCreatorRest();
}
break;
case LPAREN:
{
setState(1470);
classCreatorRest();
}
break;
default:
throw new NoViableAltException(this);
}
}
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 CreatedNameContext extends ParserRuleContext {
public List Identifier() { return getTokens(CQNGrammarParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(CQNGrammarParser.Identifier, i);
}
public List typeArgumentsOrDiamond() {
return getRuleContexts(TypeArgumentsOrDiamondContext.class);
}
public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond(int i) {
return getRuleContext(TypeArgumentsOrDiamondContext.class,i);
}
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public CreatedNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createdName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterCreatedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitCreatedName(this);
}
}
public final CreatedNameContext createdName() throws RecognitionException {
CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState());
enterRule(_localctx, 244, RULE_createdName);
int _la;
try {
setState(1490);
switch (_input.LA(1)) {
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1475);
match(Identifier);
setState(1477);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1476);
typeArgumentsOrDiamond();
}
}
setState(1486);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(1479);
match(DOT);
setState(1480);
match(Identifier);
setState(1482);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1481);
typeArgumentsOrDiamond();
}
}
}
}
setState(1488);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
enterOuterAlt(_localctx, 2);
{
setState(1489);
primitiveType();
}
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 InnerCreatorContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public ClassCreatorRestContext classCreatorRest() {
return getRuleContext(ClassCreatorRestContext.class,0);
}
public NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() {
return getRuleContext(NonWildcardTypeArgumentsOrDiamondContext.class,0);
}
public InnerCreatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_innerCreator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterInnerCreator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitInnerCreator(this);
}
}
public final InnerCreatorContext innerCreator() throws RecognitionException {
InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState());
enterRule(_localctx, 246, RULE_innerCreator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1492);
match(Identifier);
setState(1494);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1493);
nonWildcardTypeArgumentsOrDiamond();
}
}
setState(1496);
classCreatorRest();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayCreatorRestContext extends ParserRuleContext {
public ArrayInitializerContext arrayInitializer() {
return getRuleContext(ArrayInitializerContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ArrayCreatorRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayCreatorRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterArrayCreatorRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitArrayCreatorRest(this);
}
}
public final ArrayCreatorRestContext arrayCreatorRest() throws RecognitionException {
ArrayCreatorRestContext _localctx = new ArrayCreatorRestContext(_ctx, getState());
enterRule(_localctx, 248, RULE_arrayCreatorRest);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1498);
match(LBRACK);
setState(1526);
switch (_input.LA(1)) {
case RBRACK:
{
setState(1499);
match(RBRACK);
setState(1504);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(1500);
match(LBRACK);
setState(1501);
match(RBRACK);
}
}
setState(1506);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1507);
arrayInitializer();
}
break;
case IntegerLiteral:
case FloatingPointLiteral:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case NullLiteral:
case LPAREN:
case LT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case Identifier:
{
setState(1508);
expression(0);
setState(1509);
match(RBRACK);
setState(1516);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,149,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1510);
match(LBRACK);
setState(1511);
expression(0);
setState(1512);
match(RBRACK);
}
}
}
setState(1518);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,149,_ctx);
}
setState(1523);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1519);
match(LBRACK);
setState(1520);
match(RBRACK);
}
}
}
setState(1525);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
}
}
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 ClassCreatorRestContext extends ParserRuleContext {
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public ClassCreatorRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classCreatorRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterClassCreatorRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitClassCreatorRest(this);
}
}
public final ClassCreatorRestContext classCreatorRest() throws RecognitionException {
ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState());
enterRule(_localctx, 250, RULE_classCreatorRest);
try {
enterOuterAlt(_localctx, 1);
{
setState(1528);
arguments();
setState(1530);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
{
setState(1529);
classBody();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExplicitGenericInvocationContext extends ParserRuleContext {
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() {
return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0);
}
public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explicitGenericInvocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterExplicitGenericInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitExplicitGenericInvocation(this);
}
}
public final ExplicitGenericInvocationContext explicitGenericInvocation() throws RecognitionException {
ExplicitGenericInvocationContext _localctx = new ExplicitGenericInvocationContext(_ctx, getState());
enterRule(_localctx, 252, RULE_explicitGenericInvocation);
try {
enterOuterAlt(_localctx, 1);
{
setState(1532);
nonWildcardTypeArguments();
setState(1533);
explicitGenericInvocationSuffix();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NonWildcardTypeArgumentsContext extends ParserRuleContext {
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public NonWildcardTypeArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonWildcardTypeArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterNonWildcardTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitNonWildcardTypeArguments(this);
}
}
public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() throws RecognitionException {
NonWildcardTypeArgumentsContext _localctx = new NonWildcardTypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 254, RULE_nonWildcardTypeArguments);
try {
enterOuterAlt(_localctx, 1);
{
setState(1535);
match(LT);
setState(1536);
typeList();
setState(1537);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentsOrDiamondContext extends ParserRuleContext {
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterTypeArgumentsOrDiamond(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitTypeArgumentsOrDiamond(this);
}
}
public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException {
TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState());
enterRule(_localctx, 256, RULE_typeArgumentsOrDiamond);
try {
setState(1542);
switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1539);
match(LT);
setState(1540);
match(GT);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1541);
typeArguments();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NonWildcardTypeArgumentsOrDiamondContext extends ParserRuleContext {
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonWildcardTypeArgumentsOrDiamond; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterNonWildcardTypeArgumentsOrDiamond(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitNonWildcardTypeArgumentsOrDiamond(this);
}
}
public final NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() throws RecognitionException {
NonWildcardTypeArgumentsOrDiamondContext _localctx = new NonWildcardTypeArgumentsOrDiamondContext(_ctx, getState());
enterRule(_localctx, 258, RULE_nonWildcardTypeArgumentsOrDiamond);
try {
setState(1547);
switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1544);
match(LT);
setState(1545);
match(GT);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1546);
nonWildcardTypeArguments();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SuperSuffixContext extends ParserRuleContext {
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public SuperSuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_superSuffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterSuperSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitSuperSuffix(this);
}
}
public final SuperSuffixContext superSuffix() throws RecognitionException {
SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState());
enterRule(_localctx, 260, RULE_superSuffix);
try {
setState(1555);
switch (_input.LA(1)) {
case LPAREN:
enterOuterAlt(_localctx, 1);
{
setState(1549);
arguments();
}
break;
case DOT:
enterOuterAlt(_localctx, 2);
{
setState(1550);
match(DOT);
setState(1551);
match(Identifier);
setState(1553);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
{
setState(1552);
arguments();
}
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 class ExplicitGenericInvocationSuffixContext extends ParserRuleContext {
public SuperSuffixContext superSuffix() {
return getRuleContext(SuperSuffixContext.class,0);
}
public TerminalNode Identifier() { return getToken(CQNGrammarParser.Identifier, 0); }
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterExplicitGenericInvocationSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitExplicitGenericInvocationSuffix(this);
}
}
public final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() throws RecognitionException {
ExplicitGenericInvocationSuffixContext _localctx = new ExplicitGenericInvocationSuffixContext(_ctx, getState());
enterRule(_localctx, 262, RULE_explicitGenericInvocationSuffix);
try {
setState(1561);
switch (_input.LA(1)) {
case SUPER:
enterOuterAlt(_localctx, 1);
{
setState(1557);
match(SUPER);
setState(1558);
superSuffix();
}
break;
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(1559);
match(Identifier);
setState(1560);
arguments();
}
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 ArgumentsContext extends ParserRuleContext {
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public ArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).enterArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CQNGrammarListener ) ((CQNGrammarListener)listener).exitArguments(this);
}
}
public final ArgumentsContext arguments() throws RecognitionException {
ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState());
enterRule(_localctx, 264, RULE_arguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1563);
match(LPAREN);
setState(1565);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SHORT - 64)) | (1L << (SUPER - 64)) | (1L << (THIS - 64)) | (1L << (VOID - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1564);
expressionList();
}
}
setState(1567);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 119:
return expression_sempred((ExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 13);
case 1:
return precpred(_ctx, 12);
case 2:
return precpred(_ctx, 11);
case 3:
return precpred(_ctx, 10);
case 4:
return precpred(_ctx, 8);
case 5:
return precpred(_ctx, 7);
case 6:
return precpred(_ctx, 6);
case 7:
return precpred(_ctx, 5);
case 8:
return precpred(_ctx, 4);
case 9:
return precpred(_ctx, 3);
case 10:
return precpred(_ctx, 2);
case 11:
return precpred(_ctx, 1);
case 12:
return precpred(_ctx, 25);
case 13:
return precpred(_ctx, 24);
case 14:
return precpred(_ctx, 23);
case 15:
return precpred(_ctx, 22);
case 16:
return precpred(_ctx, 21);
case 17:
return precpred(_ctx, 20);
case 18:
return precpred(_ctx, 19);
case 19:
return precpred(_ctx, 16);
case 20:
return precpred(_ctx, 9);
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\u0084\u0624\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 \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
"\t\u0085\4\u0086\t\u0086\3\2\3\2\3\2\5\2\u0110\n\2\3\2\3\2\3\3\3\3\5\3"+
"\u0116\n\3\3\4\3\4\3\4\5\4\u011b\n\4\3\5\3\5\3\5\3\5\3\5\6\5\u0122\n\5"+
"\r\5\16\5\u0123\3\5\3\5\3\6\3\6\3\6\3\6\3\6\6\6\u012d\n\6\r\6\16\6\u012e"+
"\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3"+
"\b\3\b\3\b\3\b\3\b\3\b\5\b\u0148\n\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3"+
"\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f"+
"\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16"+
"\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17"+
"\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u018a\n\20\f\20"+
"\16\20\u018d\13\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\22\3"+
"\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3"+
"\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3"+
"\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3"+
"\30\3\30\3\31\3\31\3\32\3\32\3\33\3\33\5\33\u01cb\n\33\3\34\3\34\3\35"+
"\3\35\3\35\3\35\3\35\7\35\u01d4\n\35\f\35\16\35\u01d7\13\35\3\35\3\35"+
"\3\36\3\36\3\37\3\37\3\37\3\37\3\37\7\37\u01e2\n\37\f\37\16\37\u01e5\13"+
"\37\3\37\3\37\3 \3 \3 \3 \3 \3!\3!\3\"\3\"\3#\5#\u01f3\n#\3#\7#\u01f6"+
"\n#\f#\16#\u01f9\13#\3#\7#\u01fc\n#\f#\16#\u01ff\13#\3#\3#\3$\7$\u0204"+
"\n$\f$\16$\u0207\13$\3$\3$\3$\3$\3%\3%\5%\u020f\n%\3%\3%\3%\5%\u0214\n"+
"%\3%\3%\3&\7&\u0219\n&\f&\16&\u021c\13&\3&\3&\7&\u0220\n&\f&\16&\u0223"+
"\13&\3&\3&\7&\u0227\n&\f&\16&\u022a\13&\3&\3&\7&\u022e\n&\f&\16&\u0231"+
"\13&\3&\3&\5&\u0235\n&\3\'\3\'\5\'\u0239\n\'\3(\3(\5(\u023d\n(\3)\3)\5"+
")\u0241\n)\3*\3*\3*\5*\u0246\n*\3*\3*\5*\u024a\n*\3*\3*\5*\u024e\n*\3"+
"*\3*\3+\3+\3+\3+\7+\u0256\n+\f+\16+\u0259\13+\3+\3+\3,\3,\3,\5,\u0260"+
"\n,\3-\3-\3-\7-\u0265\n-\f-\16-\u0268\13-\3.\3.\3.\3.\5.\u026e\n.\3.\3"+
".\5.\u0272\n.\3.\5.\u0275\n.\3.\5.\u0278\n.\3.\3.\3/\3/\3/\7/\u027f\n"+
"/\f/\16/\u0282\13/\3\60\7\60\u0285\n\60\f\60\16\60\u0288\13\60\3\60\3"+
"\60\5\60\u028c\n\60\3\60\5\60\u028f\n\60\3\61\3\61\7\61\u0293\n\61\f\61"+
"\16\61\u0296\13\61\3\62\3\62\3\62\5\62\u029b\n\62\3\62\3\62\5\62\u029f"+
"\n\62\3\62\3\62\3\63\3\63\3\63\7\63\u02a6\n\63\f\63\16\63\u02a9\13\63"+
"\3\64\3\64\7\64\u02ad\n\64\f\64\16\64\u02b0\13\64\3\64\3\64\3\65\3\65"+
"\7\65\u02b6\n\65\f\65\16\65\u02b9\13\65\3\65\3\65\3\66\3\66\5\66\u02bf"+
"\n\66\3\66\3\66\7\66\u02c3\n\66\f\66\16\66\u02c6\13\66\3\66\5\66\u02c9"+
"\n\66\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\5\67\u02d4\n\67\38"+
"\38\58\u02d8\n8\38\38\38\38\78\u02de\n8\f8\168\u02e1\138\38\38\58\u02e5"+
"\n8\38\38\58\u02e9\n8\39\39\39\3:\3:\3:\3:\5:\u02f2\n:\3:\3:\3;\3;\3;"+
"\3<\3<\3<\3<\3=\7=\u02fe\n=\f=\16=\u0301\13=\3=\3=\5=\u0305\n=\3>\3>\3"+
">\3>\3>\3>\3>\5>\u030e\n>\3?\3?\3?\3?\7?\u0314\n?\f?\16?\u0317\13?\3?"+
"\3?\3@\3@\3@\7@\u031e\n@\f@\16@\u0321\13@\3@\3@\3@\3A\3A\5A\u0328\nA\3"+
"A\3A\3A\3A\7A\u032e\nA\fA\16A\u0331\13A\3A\3A\5A\u0335\nA\3A\3A\3B\3B"+
"\3B\3C\3C\3C\7C\u033f\nC\fC\16C\u0342\13C\3D\3D\3D\5D\u0347\nD\3E\3E\3"+
"E\7E\u034c\nE\fE\16E\u034f\13E\3F\3F\5F\u0353\nF\3G\3G\3G\3G\7G\u0359"+
"\nG\fG\16G\u035c\13G\3G\5G\u035f\nG\5G\u0361\nG\3G\3G\3H\3H\3I\3I\3I\7"+
"I\u036a\nI\fI\16I\u036d\13I\3I\3I\3I\7I\u0372\nI\fI\16I\u0375\13I\5I\u0377"+
"\nI\3J\3J\5J\u037b\nJ\3J\3J\3J\5J\u0380\nJ\7J\u0382\nJ\fJ\16J\u0385\13"+
"J\3K\3K\3L\3L\3L\3L\7L\u038d\nL\fL\16L\u0390\13L\3L\3L\3M\3M\3M\3M\5M"+
"\u0398\nM\5M\u039a\nM\3N\3N\3N\7N\u039f\nN\fN\16N\u03a2\13N\3O\3O\5O\u03a6"+
"\nO\3O\3O\3P\3P\3P\7P\u03ad\nP\fP\16P\u03b0\13P\3P\3P\5P\u03b4\nP\3P\5"+
"P\u03b7\nP\3Q\7Q\u03ba\nQ\fQ\16Q\u03bd\13Q\3Q\3Q\3Q\3R\7R\u03c3\nR\fR"+
"\16R\u03c6\13R\3R\3R\3R\3R\3S\3S\3T\3T\3U\3U\3U\7U\u03d3\nU\fU\16U\u03d6"+
"\13U\3V\3V\3V\3V\3V\5V\u03dd\nV\3V\5V\u03e0\nV\3W\3W\3X\3X\3X\7X\u03e7"+
"\nX\fX\16X\u03ea\13X\3Y\3Y\3Y\3Y\3Z\3Z\3Z\5Z\u03f3\nZ\3[\3[\3[\3[\7[\u03f9"+
"\n[\f[\16[\u03fc\13[\5[\u03fe\n[\3[\5[\u0401\n[\3[\3[\3\\\3\\\3\\\3\\"+
"\3\\\3]\3]\7]\u040c\n]\f]\16]\u040f\13]\3]\3]\3^\7^\u0414\n^\f^\16^\u0417"+
"\13^\3^\3^\5^\u041b\n^\3_\3_\3_\3_\3_\3_\5_\u0423\n_\3_\3_\5_\u0427\n"+
"_\3_\3_\5_\u042b\n_\3_\3_\5_\u042f\n_\5_\u0431\n_\3`\3`\5`\u0435\n`\3"+
"a\3a\3a\3a\5a\u043b\na\3b\3b\3c\3c\3c\3d\3d\7d\u0444\nd\fd\16d\u0447\13"+
"d\3d\3d\3e\3e\3e\5e\u044e\ne\3f\3f\3f\3g\7g\u0454\ng\fg\16g\u0457\13g"+
"\3g\3g\3g\3h\3h\3h\3h\3h\5h\u0461\nh\3h\3h\3h\3h\3h\3h\3h\5h\u046a\nh"+
"\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\3h\6h\u047f\nh"+
"\rh\16h\u0480\3h\5h\u0484\nh\3h\5h\u0487\nh\3h\3h\3h\3h\7h\u048d\nh\f"+
"h\16h\u0490\13h\3h\5h\u0493\nh\3h\3h\3h\3h\7h\u0499\nh\fh\16h\u049c\13"+
"h\3h\7h\u049f\nh\fh\16h\u04a2\13h\3h\3h\3h\3h\3h\3h\3h\3h\5h\u04ac\nh"+
"\3h\3h\3h\3h\3h\3h\3h\5h\u04b5\nh\3h\3h\3h\5h\u04ba\nh\3h\3h\3h\3h\3h"+
"\3h\3h\3h\5h\u04c4\nh\3i\3i\3i\7i\u04c9\ni\fi\16i\u04cc\13i\3i\3i\3i\3"+
"i\3i\3j\3j\3j\7j\u04d6\nj\fj\16j\u04d9\13j\3k\3k\3k\3l\3l\3l\5l\u04e1"+
"\nl\3l\3l\3m\3m\3m\7m\u04e8\nm\fm\16m\u04eb\13m\3n\7n\u04ee\nn\fn\16n"+
"\u04f1\13n\3n\3n\3n\3n\3n\3o\6o\u04f9\no\ro\16o\u04fa\3o\6o\u04fe\no\r"+
"o\16o\u04ff\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\5p\u050c\np\3q\3q\5q\u0510\n"+
"q\3q\3q\5q\u0514\nq\3q\3q\5q\u0518\nq\5q\u051a\nq\3r\3r\5r\u051e\nr\3"+
"s\7s\u0521\ns\fs\16s\u0524\13s\3s\3s\3s\3s\3s\3t\3t\3u\3u\3u\3u\3v\3v"+
"\3v\7v\u0534\nv\fv\16v\u0537\13v\3w\3w\3x\3x\3y\3y\3y\3y\3y\3y\3y\3y\3"+
"y\3y\3y\3y\3y\5y\u054a\ny\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\5"+
"y\u055a\ny\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3"+
"y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\5y\u0585"+
"\ny\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\5y\u0597\ny\3y\3y"+
"\3y\3y\3y\3y\7y\u059f\ny\fy\16y\u05a2\13y\3z\3z\3z\3z\3z\3z\3z\3z\3z\3"+
"z\3z\3z\3z\3z\3z\3z\3z\3z\3z\5z\u05b7\nz\5z\u05b9\nz\3{\3{\3{\3{\3{\3"+
"{\3{\5{\u05c2\n{\5{\u05c4\n{\3|\3|\5|\u05c8\n|\3|\3|\3|\5|\u05cd\n|\7"+
"|\u05cf\n|\f|\16|\u05d2\13|\3|\5|\u05d5\n|\3}\3}\5}\u05d9\n}\3}\3}\3~"+
"\3~\3~\3~\7~\u05e1\n~\f~\16~\u05e4\13~\3~\3~\3~\3~\3~\3~\3~\7~\u05ed\n"+
"~\f~\16~\u05f0\13~\3~\3~\7~\u05f4\n~\f~\16~\u05f7\13~\5~\u05f9\n~\3\177"+
"\3\177\5\177\u05fd\n\177\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081"+
"\3\u0081\3\u0082\3\u0082\3\u0082\5\u0082\u0609\n\u0082\3\u0083\3\u0083"+
"\3\u0083\5\u0083\u060e\n\u0083\3\u0084\3\u0084\3\u0084\3\u0084\5\u0084"+
"\u0614\n\u0084\5\u0084\u0616\n\u0084\3\u0085\3\u0085\3\u0085\3\u0085\5"+
"\u0085\u061c\n\u0085\3\u0086\3\u0086\5\u0086\u0620\n\u0086\3\u0086\3\u0086"+
"\3\u0086\2\3\u00f0\u0087\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+
"*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+
"\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c"+
"\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4"+
"\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc"+
"\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4"+
"\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc"+
"\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\2\20\3\2\30\31\5\2\32\32\34"+
"\34PS\6\2;;GGKKNN\6\2\36\36//>@CD\n\2 \"\"%%++\61\6188::BB\4\2..EE\3"+
"\2jm\3\2`a\4\2noss\3\2lm\4\2^_ef\4\2ddgg\4\2]]t~\3\2jk\u068f\2\u010c\3"+
"\2\2\2\4\u0115\3\2\2\2\6\u011a\3\2\2\2\b\u011c\3\2\2\2\n\u0127\3\2\2\2"+
"\f\u0132\3\2\2\2\16\u0147\3\2\2\2\20\u0149\3\2\2\2\22\u0150\3\2\2\2\24"+
"\u0157\3\2\2\2\26\u015e\3\2\2\2\30\u0165\3\2\2\2\32\u016c\3\2\2\2\34\u0179"+
"\3\2\2\2\36\u0182\3\2\2\2 \u0190\3\2\2\2\"\u0197\3\2\2\2$\u019e\3\2\2"+
"\2&\u01a5\3\2\2\2(\u01ac\3\2\2\2*\u01b3\3\2\2\2,\u01b8\3\2\2\2.\u01be"+
"\3\2\2\2\60\u01c4\3\2\2\2\62\u01c6\3\2\2\2\64\u01ca\3\2\2\2\66\u01cc\3"+
"\2\2\28\u01ce\3\2\2\2:\u01da\3\2\2\2<\u01dc\3\2\2\2>\u01e8\3\2\2\2@\u01ed"+
"\3\2\2\2B\u01ef\3\2\2\2D\u01f2\3\2\2\2F\u0205\3\2\2\2H\u020c\3\2\2\2J"+
"\u0234\3\2\2\2L\u0238\3\2\2\2N\u023c\3\2\2\2P\u0240\3\2\2\2R\u0242\3\2"+
"\2\2T\u0251\3\2\2\2V\u025c\3\2\2\2X\u0261\3\2\2\2Z\u0269\3\2\2\2\\\u027b"+
"\3\2\2\2^\u0286\3\2\2\2`\u0290\3\2\2\2b\u0297\3\2\2\2d\u02a2\3\2\2\2f"+
"\u02aa\3\2\2\2h\u02b3\3\2\2\2j\u02c8\3\2\2\2l\u02d3\3\2\2\2n\u02d7\3\2"+
"\2\2p\u02ea\3\2\2\2r\u02ed\3\2\2\2t\u02f5\3\2\2\2v\u02f8\3\2\2\2x\u0304"+
"\3\2\2\2z\u030d\3\2\2\2|\u030f\3\2\2\2~\u031a\3\2\2\2\u0080\u0327\3\2"+
"\2\2\u0082\u0338\3\2\2\2\u0084\u033b\3\2\2\2\u0086\u0343\3\2\2\2\u0088"+
"\u0348\3\2\2\2\u008a\u0352\3\2\2\2\u008c\u0354\3\2\2\2\u008e\u0364\3\2"+
"\2\2\u0090\u0376\3\2\2\2\u0092\u0378\3\2\2\2\u0094\u0386\3\2\2\2\u0096"+
"\u0388\3\2\2\2\u0098\u0399\3\2\2\2\u009a\u039b\3\2\2\2\u009c\u03a3\3\2"+
"\2\2\u009e\u03b6\3\2\2\2\u00a0\u03bb\3\2\2\2\u00a2\u03c4\3\2\2\2\u00a4"+
"\u03cb\3\2\2\2\u00a6\u03cd\3\2\2\2\u00a8\u03cf\3\2\2\2\u00aa\u03d7\3\2"+
"\2\2\u00ac\u03e1\3\2\2\2\u00ae\u03e3\3\2\2\2\u00b0\u03eb\3\2\2\2\u00b2"+
"\u03f2\3\2\2\2\u00b4\u03f4\3\2\2\2\u00b6\u0404\3\2\2\2\u00b8\u0409\3\2"+
"\2\2\u00ba\u041a\3\2\2\2\u00bc\u0430\3\2\2\2\u00be\u0434\3\2\2\2\u00c0"+
"\u0436\3\2\2\2\u00c2\u043c\3\2\2\2\u00c4\u043e\3\2\2\2\u00c6\u0441\3\2"+
"\2\2\u00c8\u044d\3\2\2\2\u00ca\u044f\3\2\2\2\u00cc\u0455\3\2\2\2\u00ce"+
"\u04c3\3\2\2\2\u00d0\u04c5\3\2\2\2\u00d2\u04d2\3\2\2\2\u00d4\u04da\3\2"+
"\2\2\u00d6\u04dd\3\2\2\2\u00d8\u04e4\3\2\2\2\u00da\u04ef\3\2\2\2\u00dc"+
"\u04f8\3\2\2\2\u00de\u050b\3\2\2\2\u00e0\u0519\3\2\2\2\u00e2\u051d\3\2"+
"\2\2\u00e4\u0522\3\2\2\2\u00e6\u052a\3\2\2\2\u00e8\u052c\3\2\2\2\u00ea"+
"\u0530\3\2\2\2\u00ec\u0538\3\2\2\2\u00ee\u053a\3\2\2\2\u00f0\u0549\3\2"+
"\2\2\u00f2\u05b8\3\2\2\2\u00f4\u05c3\3\2\2\2\u00f6\u05d4\3\2\2\2\u00f8"+
"\u05d6\3\2\2\2\u00fa\u05dc\3\2\2\2\u00fc\u05fa\3\2\2\2\u00fe\u05fe\3\2"+
"\2\2\u0100\u0601\3\2\2\2\u0102\u0608\3\2\2\2\u0104\u060d\3\2\2\2\u0106"+
"\u0615\3\2\2\2\u0108\u061b\3\2\2\2\u010a\u061d\3\2\2\2\u010c\u010f\5\4"+
"\3\2\u010d\u010e\7[\2\2\u010e\u0110\58\35\2\u010f\u010d\3\2\2\2\u010f"+
"\u0110\3\2\2\2\u0110\u0111\3\2\2\2\u0111\u0112\7\2\2\3\u0112\3\3\2\2\2"+
"\u0113\u0116\5\6\4\2\u0114\u0116\5\16\b\2\u0115\u0113\3\2\2\2\u0115\u0114"+
"\3\2\2\2\u0116\5\3\2\2\2\u0117\u011b\5\b\5\2\u0118\u011b\5\n\6\2\u0119"+
"\u011b\5\f\7\2\u011a\u0117\3\2\2\2\u011a\u0118\3\2\2\2\u011a\u0119\3\2"+
"\2\2\u011b\7\3\2\2\2\u011c\u011d\7\3\2\2\u011d\u011e\7T\2\2\u011e\u0121"+
"\5\4\3\2\u011f\u0120\7[\2\2\u0120\u0122\5\4\3\2\u0121\u011f\3\2\2\2\u0122"+
"\u0123\3\2\2\2\u0123\u0121\3\2\2\2\u0123\u0124\3\2\2\2\u0124\u0125\3\2"+
"\2\2\u0125\u0126\7U\2\2\u0126\t\3\2\2\2\u0127\u0128\7\4\2\2\u0128\u0129"+
"\7T\2\2\u0129\u012c\5\4\3\2\u012a\u012b\7[\2\2\u012b\u012d\5\4\3\2\u012c"+
"\u012a\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u012c\3\2\2\2\u012e\u012f\3\2"+
"\2\2\u012f\u0130\3\2\2\2\u0130\u0131\7U\2\2\u0131\13\3\2\2\2\u0132\u0133"+
"\7\5\2\2\u0133\u0134\7T\2\2\u0134\u0135\5\4\3\2\u0135\u0136\7U\2\2\u0136"+
"\r\3\2\2\2\u0137\u0148\5\20\t\2\u0138\u0148\5\22\n\2\u0139\u0148\5\24"+
"\13\2\u013a\u0148\5\26\f\2\u013b\u0148\5\30\r\2\u013c\u0148\5\32\16\2"+
"\u013d\u0148\5\34\17\2\u013e\u0148\5\36\20\2\u013f\u0148\5 \21\2\u0140"+
"\u0148\5\"\22\2\u0141\u0148\5$\23\2\u0142\u0148\5&\24\2\u0143\u0148\5"+
"(\25\2\u0144\u0148\5*\26\2\u0145\u0148\5,\27\2\u0146\u0148\5.\30\2\u0147"+
"\u0137\3\2\2\2\u0147\u0138\3\2\2\2\u0147\u0139\3\2\2\2\u0147\u013a\3\2"+
"\2\2\u0147\u013b\3\2\2\2\u0147\u013c\3\2\2\2\u0147\u013d\3\2\2\2\u0147"+
"\u013e\3\2\2\2\u0147\u013f\3\2\2\2\u0147\u0140\3\2\2\2\u0147\u0141\3\2"+
"\2\2\u0147\u0142\3\2\2\2\u0147\u0143\3\2\2\2\u0147\u0144\3\2\2\2\u0147"+
"\u0145\3\2\2\2\u0147\u0146\3\2\2\2\u0148\17\3\2\2\2\u0149\u014a\7\6\2"+
"\2\u014a\u014b\7T\2\2\u014b\u014c\5\62\32\2\u014c\u014d\7[\2\2\u014d\u014e"+
"\5\64\33\2\u014e\u014f\7U\2\2\u014f\21\3\2\2\2\u0150\u0151\7\7\2\2\u0151"+
"\u0152\7T\2\2\u0152\u0153\5\62\32\2\u0153\u0154\7[\2\2\u0154\u0155\5\64"+
"\33\2\u0155\u0156\7U\2\2\u0156\23\3\2\2\2\u0157\u0158\7\b\2\2\u0158\u0159"+
"\7T\2\2\u0159\u015a\5\62\32\2\u015a\u015b\7[\2\2\u015b\u015c\5\64\33\2"+
"\u015c\u015d\7U\2\2\u015d\25\3\2\2\2\u015e\u015f\7\t\2\2\u015f\u0160\7"+
"T\2\2\u0160\u0161\5\62\32\2\u0161\u0162\7[\2\2\u0162\u0163\5\64\33\2\u0163"+
"\u0164\7U\2\2\u0164\27\3\2\2\2\u0165\u0166\7\n\2\2\u0166\u0167\7T\2\2"+
"\u0167\u0168\5\62\32\2\u0168\u0169\7[\2\2\u0169\u016a\5\64\33\2\u016a"+
"\u016b\7U\2\2\u016b\31\3\2\2\2\u016c\u016d\7\13\2\2\u016d\u016e\7T\2\2"+
"\u016e\u016f\5\62\32\2\u016f\u0170\7[\2\2\u0170\u0171\5\64\33\2\u0171"+
"\u0172\7[\2\2\u0172\u0173\7P\2\2\u0173\u0174\7[\2\2\u0174\u0175\5\64\33"+
"\2\u0175\u0176\7[\2\2\u0176\u0177\7P\2\2\u0177\u0178\7U\2\2\u0178\33\3"+
"\2\2\2\u0179\u017a\7\13\2\2\u017a\u017b\7T\2\2\u017b\u017c\5\62\32\2\u017c"+
"\u017d\7[\2\2\u017d\u017e\5\64\33\2\u017e\u017f\7[\2\2\u017f\u0180\5\64"+
"\33\2\u0180\u0181\7U\2\2\u0181\35\3\2\2\2\u0182\u0183\7\f\2\2\u0183\u0184"+
"\7T\2\2\u0184\u0185\5\62\32\2\u0185\u0186\7[\2\2\u0186\u018b\5\64\33\2"+
"\u0187\u0188\7[\2\2\u0188\u018a\5\64\33\2\u0189\u0187\3\2\2\2\u018a\u018d"+
"\3\2\2\2\u018b\u0189\3\2\2\2\u018b\u018c\3\2\2\2\u018c\u018e\3\2\2\2\u018d"+
"\u018b\3\2\2\2\u018e\u018f\7U\2\2\u018f\37\3\2\2\2\u0190\u0191\7\r\2\2"+
"\u0191\u0192\7T\2\2\u0192\u0193\5\62\32\2\u0193\u0194\7[\2\2\u0194\u0195"+
"\5\66\34\2\u0195\u0196\7U\2\2\u0196!\3\2\2\2\u0197\u0198\7\16\2\2\u0198"+
"\u0199\7T\2\2\u0199\u019a\5\62\32\2\u019a\u019b\7[\2\2\u019b\u019c\5\66"+
"\34\2\u019c\u019d\7U\2\2\u019d#\3\2\2\2\u019e\u019f\7\17\2\2\u019f\u01a0"+
"\7T\2\2\u01a0\u01a1\5\62\32\2\u01a1\u01a2\7[\2\2\u01a2\u01a3\5\66\34\2"+
"\u01a3\u01a4\7U\2\2\u01a4%\3\2\2\2\u01a5\u01a6\7\20\2\2\u01a6\u01a7\7"+
"T\2\2\u01a7\u01a8\5\62\32\2\u01a8\u01a9\7[\2\2\u01a9\u01aa\5\66\34\2\u01aa"+
"\u01ab\7U\2\2\u01ab\'\3\2\2\2\u01ac\u01ad\7\21\2\2\u01ad\u01ae\7T\2\2"+
"\u01ae\u01af\5\62\32\2\u01af\u01b0\7[\2\2\u01b0\u01b1\5\66\34\2\u01b1"+
"\u01b2\7U\2\2\u01b2)\3\2\2\2\u01b3\u01b4\7\22\2\2\u01b4\u01b5\7T\2\2\u01b5"+
"\u01b6\5\62\32\2\u01b6\u01b7\7U\2\2\u01b7+\3\2\2\2\u01b8\u01b9\7\23\2"+
"\2\u01b9\u01ba\7T\2\2\u01ba\u01bb\5\60\31\2\u01bb\u01bc\7\24\2\2\u01bc"+
"\u01bd\7U\2\2\u01bd-\3\2\2\2\u01be\u01bf\7\25\2\2\u01bf\u01c0\7T\2\2\u01c0"+
"\u01c1\5\60\31\2\u01c1\u01c2\7\24\2\2\u01c2\u01c3\7U\2\2\u01c3/\3\2\2"+
"\2\u01c4\u01c5\7\177\2\2\u01c5\61\3\2\2\2\u01c6\u01c7\7R\2\2\u01c7\63"+
"\3\2\2\2\u01c8\u01cb\5B\"\2\u01c9\u01cb\7\177\2\2\u01ca\u01c8\3\2\2\2"+
"\u01ca\u01c9\3\2\2\2\u01cb\65\3\2\2\2\u01cc\u01cd\7R\2\2\u01cd\67\3\2"+
"\2\2\u01ce\u01cf\7\26\2\2\u01cf\u01d0\7T\2\2\u01d0\u01d5\5:\36\2\u01d1"+
"\u01d2\7[\2\2\u01d2\u01d4\5:\36\2\u01d3\u01d1\3\2\2\2\u01d4\u01d7\3\2"+
"\2\2\u01d5\u01d3\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\u01d8\3\2\2\2\u01d7"+
"\u01d5\3\2\2\2\u01d8\u01d9\7U\2\2\u01d99\3\2\2\2\u01da\u01db\5<\37\2\u01db"+
";\3\2\2\2\u01dc\u01dd\7\27\2\2\u01dd\u01de\7T\2\2\u01de\u01e3\5> \2\u01df"+
"\u01e0\7[\2\2\u01e0\u01e2\5> \2\u01e1\u01df\3\2\2\2\u01e2\u01e5\3\2\2"+
"\2\u01e3\u01e1\3\2\2\2\u01e3\u01e4\3\2\2\2\u01e4\u01e6\3\2\2\2\u01e5\u01e3"+
"\3\2\2\2\u01e6\u01e7\7U\2\2\u01e7=\3\2\2\2\u01e8\u01e9\5@!\2\u01e9\u01ea"+
"\7T\2\2\u01ea\u01eb\5\62\32\2\u01eb\u01ec\7U\2\2\u01ec?\3\2\2\2\u01ed"+
"\u01ee\t\2\2\2\u01eeA\3\2\2\2\u01ef\u01f0\t\3\2\2\u01f0C\3\2\2\2\u01f1"+
"\u01f3\5F$\2\u01f2\u01f1\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f7\3\2\2"+
"\2\u01f4\u01f6\5H%\2\u01f5\u01f4\3\2\2\2\u01f6\u01f9\3\2\2\2\u01f7\u01f5"+
"\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8\u01fd\3\2\2\2\u01f9\u01f7\3\2\2\2\u01fa"+
"\u01fc\5J&\2\u01fb\u01fa\3\2\2\2\u01fc\u01ff\3\2\2\2\u01fd\u01fb\3\2\2"+
"\2\u01fd\u01fe\3\2\2\2\u01fe\u0200\3\2\2\2\u01ff\u01fd\3\2\2\2\u0200\u0201"+
"\7\2\2\3\u0201E\3\2\2\2\u0202\u0204\5\u00aaV\2\u0203\u0202\3\2\2\2\u0204"+
"\u0207\3\2\2\2\u0205\u0203\3\2\2\2\u0205\u0206\3\2\2\2\u0206\u0208\3\2"+
"\2\2\u0207\u0205\3\2\2\2\u0208\u0209\7=\2\2\u0209\u020a\5\u00a8U\2\u020a"+
"\u020b\7Z\2\2\u020bG\3\2\2\2\u020c\u020e\7\66\2\2\u020d\u020f\7C\2\2\u020e"+
"\u020d\3\2\2\2\u020e\u020f\3\2\2\2\u020f\u0210\3\2\2\2\u0210\u0213\5\u00a8"+
"U\2\u0211\u0212\7\\\2\2\u0212\u0214\7n\2\2\u0213\u0211\3\2\2\2\u0213\u0214"+
"\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0216\7Z\2\2\u0216I\3\2\2\2\u0217\u0219"+
"\5N(\2\u0218\u0217\3\2\2\2\u0219\u021c\3\2\2\2\u021a\u0218\3\2\2\2\u021a"+
"\u021b\3\2\2\2\u021b\u021d\3\2\2\2\u021c\u021a\3\2\2\2\u021d\u0235\5R"+
"*\2\u021e\u0220\5N(\2\u021f\u021e\3\2\2\2\u0220\u0223\3\2\2\2\u0221\u021f"+
"\3\2\2\2\u0221\u0222\3\2\2\2\u0222\u0224\3\2\2\2\u0223\u0221\3\2\2\2\u0224"+
"\u0235\5Z.\2\u0225\u0227\5N(\2\u0226\u0225\3\2\2\2\u0227\u022a\3\2\2\2"+
"\u0228\u0226\3\2\2\2\u0228\u0229\3\2\2\2\u0229\u022b\3\2\2\2\u022a\u0228"+
"\3\2\2\2\u022b\u0235\5b\62\2\u022c\u022e\5N(\2\u022d\u022c\3\2\2\2\u022e"+
"\u0231\3\2\2\2\u022f\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0232\3\2"+
"\2\2\u0231\u022f\3\2\2\2\u0232\u0235\5\u00b6\\\2\u0233\u0235\7Z\2\2\u0234"+
"\u021a\3\2\2\2\u0234\u0221\3\2\2\2\u0234\u0228\3\2\2\2\u0234\u022f\3\2"+
"\2\2\u0234\u0233\3\2\2\2\u0235K\3\2\2\2\u0236\u0239\5N(\2\u0237\u0239"+
"\t\4\2\2\u0238\u0236\3\2\2\2\u0238\u0237\3\2\2\2\u0239M\3\2\2\2\u023a"+
"\u023d\5\u00aaV\2\u023b\u023d\t\5\2\2\u023c\u023a\3\2\2\2\u023c\u023b"+
"\3\2\2\2\u023dO\3\2\2\2\u023e\u0241\7/\2\2\u023f\u0241\5\u00aaV\2\u0240"+
"\u023e\3\2\2\2\u0240\u023f\3\2\2\2\u0241Q\3\2\2\2\u0242\u0243\7&\2\2\u0243"+
"\u0245\7\177\2\2\u0244\u0246\5T+\2\u0245\u0244\3\2\2\2\u0245\u0246\3\2"+
"\2\2\u0246\u0249\3\2\2\2\u0247\u0248\7.\2\2\u0248\u024a\5\u0090I\2\u0249"+
"\u0247\3\2\2\2\u0249\u024a\3\2\2\2\u024a\u024d\3\2\2\2\u024b\u024c\7\65"+
"\2\2\u024c\u024e\5d\63\2\u024d\u024b\3\2\2\2\u024d\u024e\3\2\2\2\u024e"+
"\u024f\3\2\2\2\u024f\u0250\5f\64\2\u0250S\3\2\2\2\u0251\u0252\7_\2\2\u0252"+
"\u0257\5V,\2\u0253\u0254\7[\2\2\u0254\u0256\5V,\2\u0255\u0253\3\2\2\2"+
"\u0256\u0259\3\2\2\2\u0257\u0255\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u025a"+
"\3\2\2\2\u0259\u0257\3\2\2\2\u025a\u025b\7^\2\2\u025bU\3\2\2\2\u025c\u025f"+
"\7\177\2\2\u025d\u025e\7.\2\2\u025e\u0260\5X-\2\u025f\u025d\3\2\2\2\u025f"+
"\u0260\3\2\2\2\u0260W\3\2\2\2\u0261\u0266\5\u0090I\2\u0262\u0263\7p\2"+
"\2\u0263\u0265\5\u0090I\2\u0264\u0262\3\2\2\2\u0265\u0268\3\2\2\2\u0266"+
"\u0264\3\2\2\2\u0266\u0267\3\2\2\2\u0267Y\3\2\2\2\u0268\u0266\3\2\2\2"+
"\u0269\u026a\7-\2\2\u026a\u026d\7\177\2\2\u026b\u026c\7\65\2\2\u026c\u026e"+
"\5d\63\2\u026d\u026b\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u026f\3\2\2\2\u026f"+
"\u0271\7V\2\2\u0270\u0272\5\\/\2\u0271\u0270\3\2\2\2\u0271\u0272\3\2\2"+
"\2\u0272\u0274\3\2\2\2\u0273\u0275\7[\2\2\u0274\u0273\3\2\2\2\u0274\u0275"+
"\3\2\2\2\u0275\u0277\3\2\2\2\u0276\u0278\5`\61\2\u0277\u0276\3\2\2\2\u0277"+
"\u0278\3\2\2\2\u0278\u0279\3\2\2\2\u0279\u027a\7W\2\2\u027a[\3\2\2\2\u027b"+
"\u0280\5^\60\2\u027c\u027d\7[\2\2\u027d\u027f\5^\60\2\u027e\u027c\3\2"+
"\2\2\u027f\u0282\3\2\2\2\u0280\u027e\3\2\2\2\u0280\u0281\3\2\2\2\u0281"+
"]\3\2\2\2\u0282\u0280\3\2\2\2\u0283\u0285\5\u00aaV\2\u0284\u0283\3\2\2"+
"\2\u0285\u0288\3\2\2\2\u0286\u0284\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0289"+
"\3\2\2\2\u0288\u0286\3\2\2\2\u0289\u028b\7\177\2\2\u028a\u028c\5\u010a"+
"\u0086\2\u028b\u028a\3\2\2\2\u028b\u028c\3\2\2\2\u028c\u028e\3\2\2\2\u028d"+
"\u028f\5f\64\2\u028e\u028d\3\2\2\2\u028e\u028f\3\2\2\2\u028f_\3\2\2\2"+
"\u0290\u0294\7Z\2\2\u0291\u0293\5j\66\2\u0292\u0291\3\2\2\2\u0293\u0296"+
"\3\2\2\2\u0294\u0292\3\2\2\2\u0294\u0295\3\2\2\2\u0295a\3\2\2\2\u0296"+
"\u0294\3\2\2\2\u0297\u0298\79\2\2\u0298\u029a\7\177\2\2\u0299\u029b\5"+
"T+\2\u029a\u0299\3\2\2\2\u029a\u029b\3\2\2\2\u029b\u029e\3\2\2\2\u029c"+
"\u029d\7.\2\2\u029d\u029f\5d\63\2\u029e\u029c\3\2\2\2\u029e\u029f\3\2"+
"\2\2\u029f\u02a0\3\2\2\2\u02a0\u02a1\5h\65\2\u02a1c\3\2\2\2\u02a2\u02a7"+
"\5\u0090I\2\u02a3\u02a4\7[\2\2\u02a4\u02a6\5\u0090I\2\u02a5\u02a3\3\2"+
"\2\2\u02a6\u02a9\3\2\2\2\u02a7\u02a5\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8"+
"e\3\2\2\2\u02a9\u02a7\3\2\2\2\u02aa\u02ae\7V\2\2\u02ab\u02ad\5j\66\2\u02ac"+
"\u02ab\3\2\2\2\u02ad\u02b0\3\2\2\2\u02ae\u02ac\3\2\2\2\u02ae\u02af\3\2"+
"\2\2\u02af\u02b1\3\2\2\2\u02b0\u02ae\3\2\2\2\u02b1\u02b2\7W\2\2\u02b2"+
"g\3\2\2\2\u02b3\u02b7\7V\2\2\u02b4\u02b6\5x=\2\u02b5\u02b4\3\2\2\2\u02b6"+
"\u02b9\3\2\2\2\u02b7\u02b5\3\2\2\2\u02b7\u02b8\3\2\2\2\u02b8\u02ba\3\2"+
"\2\2\u02b9\u02b7\3\2\2\2\u02ba\u02bb\7W\2\2\u02bbi\3\2\2\2\u02bc\u02c9"+
"\7Z\2\2\u02bd\u02bf\7C\2\2\u02be\u02bd\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf"+
"\u02c0\3\2\2\2\u02c0\u02c9\5\u00c6d\2\u02c1\u02c3\5L\'\2\u02c2\u02c1\3"+
"\2\2\2\u02c3\u02c6\3\2\2\2\u02c4\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5"+
"\u02c7\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c7\u02c9\5l\67\2\u02c8\u02bc\3\2"+
"\2\2\u02c8\u02be\3\2\2\2\u02c8\u02c4\3\2\2\2\u02c9k\3\2\2\2\u02ca\u02d4"+
"\5n8\2\u02cb\u02d4\5p9\2\u02cc\u02d4\5v<\2\u02cd\u02d4\5r:\2\u02ce\u02d4"+
"\5t;\2\u02cf\u02d4\5b\62\2\u02d0\u02d4\5\u00b6\\\2\u02d1\u02d4\5R*\2\u02d2"+
"\u02d4\5Z.\2\u02d3\u02ca\3\2\2\2\u02d3\u02cb\3\2\2\2\u02d3\u02cc\3\2\2"+
"\2\u02d3\u02cd\3\2\2\2\u02d3\u02ce\3\2\2\2\u02d3\u02cf\3\2\2\2\u02d3\u02d0"+
"\3\2\2\2\u02d3\u02d1\3\2\2\2\u02d3\u02d2\3\2\2\2\u02d4m\3\2\2\2\u02d5"+
"\u02d8\5\u0090I\2\u02d6\u02d8\7M\2\2\u02d7\u02d5\3\2\2\2\u02d7\u02d6\3"+
"\2\2\2\u02d8\u02d9\3\2\2\2\u02d9\u02da\7\177\2\2\u02da\u02df\5\u009cO"+
"\2\u02db\u02dc\7X\2\2\u02dc\u02de\7Y\2\2\u02dd\u02db\3\2\2\2\u02de\u02e1"+
"\3\2\2\2\u02df\u02dd\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e4\3\2\2\2\u02e1"+
"\u02df\3\2\2\2\u02e2\u02e3\7J\2\2\u02e3\u02e5\5\u009aN\2\u02e4\u02e2\3"+
"\2\2\2\u02e4\u02e5\3\2\2\2\u02e5\u02e8\3\2\2\2\u02e6\u02e9\5\u00a4S\2"+
"\u02e7\u02e9\7Z\2\2\u02e8\u02e6\3\2\2\2\u02e8\u02e7\3\2\2\2\u02e9o\3\2"+
"\2\2\u02ea\u02eb\5T+\2\u02eb\u02ec\5n8\2\u02ecq\3\2\2\2\u02ed\u02ee\7"+
"\177\2\2\u02ee\u02f1\5\u009cO\2\u02ef\u02f0\7J\2\2\u02f0\u02f2\5\u009a"+
"N\2\u02f1\u02ef\3\2\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3"+
"\u02f4\5\u00a6T\2\u02f4s\3\2\2\2\u02f5\u02f6\5T+\2\u02f6\u02f7\5r:\2\u02f7"+
"u\3\2\2\2\u02f8\u02f9\5\u0090I\2\u02f9\u02fa\5\u0084C\2\u02fa\u02fb\7"+
"Z\2\2\u02fbw\3\2\2\2\u02fc\u02fe\5L\'\2\u02fd\u02fc\3\2\2\2\u02fe\u0301"+
"\3\2\2\2\u02ff\u02fd\3\2\2\2\u02ff\u0300\3\2\2\2\u0300\u0302\3\2\2\2\u0301"+
"\u02ff\3\2\2\2\u0302\u0305\5z>\2\u0303\u0305\7Z\2\2\u0304\u02ff\3\2\2"+
"\2\u0304\u0303\3\2\2\2\u0305y\3\2\2\2\u0306\u030e\5|?\2\u0307\u030e\5"+
"\u0080A\2\u0308\u030e\5\u0082B\2\u0309\u030e\5b\62\2\u030a\u030e\5\u00b6"+
"\\\2\u030b\u030e\5R*\2\u030c\u030e\5Z.\2\u030d\u0306\3\2\2\2\u030d\u0307"+
"\3\2\2\2\u030d\u0308\3\2\2\2\u030d\u0309\3\2\2\2\u030d\u030a\3\2\2\2\u030d"+
"\u030b\3\2\2\2\u030d\u030c\3\2\2\2\u030e{\3\2\2\2\u030f\u0310\5\u0090"+
"I\2\u0310\u0315\5~@\2\u0311\u0312\7[\2\2\u0312\u0314\5~@\2\u0313\u0311"+
"\3\2\2\2\u0314\u0317\3\2\2\2\u0315\u0313\3\2\2\2\u0315\u0316\3\2\2\2\u0316"+
"\u0318\3\2\2\2\u0317\u0315\3\2\2\2\u0318\u0319\7Z\2\2\u0319}\3\2\2\2\u031a"+
"\u031f\7\177\2\2\u031b\u031c\7X\2\2\u031c\u031e\7Y\2\2\u031d\u031b\3\2"+
"\2\2\u031e\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320"+
"\u0322\3\2\2\2\u0321\u031f\3\2\2\2\u0322\u0323\7]\2\2\u0323\u0324\5\u008a"+
"F\2\u0324\177\3\2\2\2\u0325\u0328\5\u0090I\2\u0326\u0328\7M\2\2\u0327"+
"\u0325\3\2\2\2\u0327\u0326\3\2\2\2\u0328\u0329\3\2\2\2\u0329\u032a\7\177"+
"\2\2\u032a\u032f\5\u009cO\2\u032b\u032c\7X\2\2\u032c\u032e\7Y\2\2\u032d"+
"\u032b\3\2\2\2\u032e\u0331\3\2\2\2\u032f\u032d\3\2\2\2\u032f\u0330\3\2"+
"\2\2\u0330\u0334\3\2\2\2\u0331\u032f\3\2\2\2\u0332\u0333\7J\2\2\u0333"+
"\u0335\5\u009aN\2\u0334\u0332\3\2\2\2\u0334\u0335\3\2\2\2\u0335\u0336"+
"\3\2\2\2\u0336\u0337\7Z\2\2\u0337\u0081\3\2\2\2\u0338\u0339\5T+\2\u0339"+
"\u033a\5\u0080A\2\u033a\u0083\3\2\2\2\u033b\u0340\5\u0086D\2\u033c\u033d"+
"\7[\2\2\u033d\u033f\5\u0086D\2\u033e\u033c\3\2\2\2\u033f\u0342\3\2\2\2"+
"\u0340\u033e\3\2\2\2\u0340\u0341\3\2\2\2\u0341\u0085\3\2\2\2\u0342\u0340"+
"\3\2\2\2\u0343\u0346\5\u0088E\2\u0344\u0345\7]\2\2\u0345\u0347\5\u008a"+
"F\2\u0346\u0344\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0087\3\2\2\2\u0348"+
"\u034d\7\177\2\2\u0349\u034a\7X\2\2\u034a\u034c\7Y\2\2\u034b\u0349\3\2"+
"\2\2\u034c\u034f\3\2\2\2\u034d\u034b\3\2\2\2\u034d\u034e\3\2\2\2\u034e"+
"\u0089\3\2\2\2\u034f\u034d\3\2\2\2\u0350\u0353\5\u008cG\2\u0351\u0353"+
"\5\u00f0y\2\u0352\u0350\3\2\2\2\u0352\u0351\3\2\2\2\u0353\u008b\3\2\2"+
"\2\u0354\u0360\7V\2\2\u0355\u035a\5\u008aF\2\u0356\u0357\7[\2\2\u0357"+
"\u0359\5\u008aF\2\u0358\u0356\3\2\2\2\u0359\u035c\3\2\2\2\u035a\u0358"+
"\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u035e\3\2\2\2\u035c\u035a\3\2\2\2\u035d"+
"\u035f\7[\2\2\u035e\u035d\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0361\3\2"+
"\2\2\u0360\u0355\3\2\2\2\u0360\u0361\3\2\2\2\u0361\u0362\3\2\2\2\u0362"+
"\u0363\7W\2\2\u0363\u008d\3\2\2\2\u0364\u0365\7\177\2\2\u0365\u008f\3"+
"\2\2\2\u0366\u036b\5\u0092J\2\u0367\u0368\7X\2\2\u0368\u036a\7Y\2\2\u0369"+
"\u0367\3\2\2\2\u036a\u036d\3\2\2\2\u036b\u0369\3\2\2\2\u036b\u036c\3\2"+
"\2\2\u036c\u0377\3\2\2\2\u036d\u036b\3\2\2\2\u036e\u0373\5\u0094K\2\u036f"+
"\u0370\7X\2\2\u0370\u0372\7Y\2\2\u0371\u036f\3\2\2\2\u0372\u0375\3\2\2"+
"\2\u0373\u0371\3\2\2\2\u0373\u0374\3\2\2\2\u0374\u0377\3\2\2\2\u0375\u0373"+
"\3\2\2\2\u0376\u0366\3\2\2\2\u0376\u036e\3\2\2\2\u0377\u0091\3\2\2\2\u0378"+
"\u037a\7\177\2\2\u0379\u037b\5\u0096L\2\u037a\u0379\3\2\2\2\u037a\u037b"+
"\3\2\2\2\u037b\u0383\3\2\2\2\u037c\u037d\7\\\2\2\u037d\u037f\7\177\2\2"+
"\u037e\u0380\5\u0096L\2\u037f\u037e\3\2\2\2\u037f\u0380\3\2\2\2\u0380"+
"\u0382\3\2\2\2\u0381\u037c\3\2\2\2\u0382\u0385\3\2\2\2\u0383\u0381\3\2"+
"\2\2\u0383\u0384\3\2\2\2\u0384\u0093\3\2\2\2\u0385\u0383\3\2\2\2\u0386"+
"\u0387\t\6\2\2\u0387\u0095\3\2\2\2\u0388\u0389\7_\2\2\u0389\u038e\5\u0098"+
"M\2\u038a\u038b\7[\2\2\u038b\u038d\5\u0098M\2\u038c\u038a\3\2\2\2\u038d"+
"\u0390\3\2\2\2\u038e\u038c\3\2\2\2\u038e\u038f\3\2\2\2\u038f\u0391\3\2"+
"\2\2\u0390\u038e\3\2\2\2\u0391\u0392\7^\2\2\u0392\u0097\3\2\2\2\u0393"+
"\u039a\5\u0090I\2\u0394\u0397\7b\2\2\u0395\u0396\t\7\2\2\u0396\u0398\5"+
"\u0090I\2\u0397\u0395\3\2\2\2\u0397\u0398\3\2\2\2\u0398\u039a\3\2\2\2"+
"\u0399\u0393\3\2\2\2\u0399\u0394\3\2\2\2\u039a\u0099\3\2\2\2\u039b\u03a0"+
"\5\u00a8U\2\u039c\u039d\7[\2\2\u039d\u039f\5\u00a8U\2\u039e\u039c\3\2"+
"\2\2\u039f\u03a2\3\2\2\2\u03a0\u039e\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1"+
"\u009b\3\2\2\2\u03a2\u03a0\3\2\2\2\u03a3\u03a5\7T\2\2\u03a4\u03a6\5\u009e"+
"P\2\u03a5\u03a4\3\2\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03a7\3\2\2\2\u03a7"+
"\u03a8\7U\2\2\u03a8\u009d\3\2\2\2\u03a9\u03ae\5\u00a0Q\2\u03aa\u03ab\7"+
"[\2\2\u03ab\u03ad\5\u00a0Q\2\u03ac\u03aa\3\2\2\2\u03ad\u03b0\3\2\2\2\u03ae"+
"\u03ac\3\2\2\2\u03ae\u03af\3\2\2\2\u03af\u03b3\3\2\2\2\u03b0\u03ae\3\2"+
"\2\2\u03b1\u03b2\7[\2\2\u03b2\u03b4\5\u00a2R\2\u03b3\u03b1\3\2\2\2\u03b3"+
"\u03b4\3\2\2\2\u03b4\u03b7\3\2\2\2\u03b5\u03b7\5\u00a2R\2\u03b6\u03a9"+
"\3\2\2\2\u03b6\u03b5\3\2\2\2\u03b7\u009f\3\2\2\2\u03b8\u03ba\5P)\2\u03b9"+
"\u03b8\3\2\2\2\u03ba\u03bd\3\2\2\2\u03bb\u03b9\3\2\2\2\u03bb\u03bc\3\2"+
"\2\2\u03bc\u03be\3\2\2\2\u03bd\u03bb\3\2\2\2\u03be\u03bf\5\u0090I\2\u03bf"+
"\u03c0\5\u0088E\2\u03c0\u00a1\3\2\2\2\u03c1\u03c3\5P)\2\u03c2\u03c1\3"+
"\2\2\2\u03c3\u03c6\3\2\2\2\u03c4\u03c2\3\2\2\2\u03c4\u03c5\3\2\2\2\u03c5"+
"\u03c7\3\2\2\2\u03c6\u03c4\3\2\2\2\u03c7\u03c8\5\u0090I\2\u03c8\u03c9"+
"\7\u0081\2\2\u03c9\u03ca\5\u0088E\2\u03ca\u00a3\3\2\2\2\u03cb\u03cc\5"+
"\u00c6d\2\u03cc\u00a5\3\2\2\2\u03cd\u03ce\5\u00c6d\2\u03ce\u00a7\3\2\2"+
"\2\u03cf\u03d4\7\177\2\2\u03d0\u03d1\7\\\2\2\u03d1\u03d3\7\177\2\2\u03d2"+
"\u03d0\3\2\2\2\u03d3\u03d6\3\2\2\2\u03d4\u03d2\3\2\2\2\u03d4\u03d5\3\2"+
"\2\2\u03d5\u00a9\3\2\2\2\u03d6\u03d4\3\2\2\2\u03d7\u03d8\7\u0080\2\2\u03d8"+
"\u03df\5\u00acW\2\u03d9\u03dc\7T\2\2\u03da\u03dd\5\u00aeX\2\u03db\u03dd"+
"\5\u00b2Z\2\u03dc\u03da\3\2\2\2\u03dc\u03db\3\2\2\2\u03dc\u03dd\3\2\2"+
"\2\u03dd\u03de\3\2\2\2\u03de\u03e0\7U\2\2\u03df\u03d9\3\2\2\2\u03df\u03e0"+
"\3\2\2\2\u03e0\u00ab\3\2\2\2\u03e1\u03e2\5\u00a8U\2\u03e2\u00ad\3\2\2"+
"\2\u03e3\u03e8\5\u00b0Y\2\u03e4\u03e5\7[\2\2\u03e5\u03e7\5\u00b0Y\2\u03e6"+
"\u03e4\3\2\2\2\u03e7\u03ea\3\2\2\2\u03e8\u03e6\3\2\2\2\u03e8\u03e9\3\2"+
"\2\2\u03e9\u00af\3\2\2\2\u03ea\u03e8\3\2\2\2\u03eb\u03ec\7\177\2\2\u03ec"+
"\u03ed\7]\2\2\u03ed\u03ee\5\u00b2Z\2\u03ee\u00b1\3\2\2\2\u03ef\u03f3\5"+
"\u00f0y\2\u03f0\u03f3\5\u00aaV\2\u03f1\u03f3\5\u00b4[\2\u03f2\u03ef\3"+
"\2\2\2\u03f2\u03f0\3\2\2\2\u03f2\u03f1\3\2\2\2\u03f3\u00b3\3\2\2\2\u03f4"+
"\u03fd\7V\2\2\u03f5\u03fa\5\u00b2Z\2\u03f6\u03f7\7[\2\2\u03f7\u03f9\5"+
"\u00b2Z\2\u03f8\u03f6\3\2\2\2\u03f9\u03fc\3\2\2\2\u03fa\u03f8\3\2\2\2"+
"\u03fa\u03fb\3\2\2\2\u03fb\u03fe\3\2\2\2\u03fc\u03fa\3\2\2\2\u03fd\u03f5"+
"\3\2\2\2\u03fd\u03fe\3\2\2\2\u03fe\u0400\3\2\2\2\u03ff\u0401\7[\2\2\u0400"+
"\u03ff\3\2\2\2\u0400\u0401\3\2\2\2\u0401\u0402\3\2\2\2\u0402\u0403\7W"+
"\2\2\u0403\u00b5\3\2\2\2\u0404\u0405\7\u0080\2\2\u0405\u0406\79\2\2\u0406"+
"\u0407\7\177\2\2\u0407\u0408\5\u00b8]\2\u0408\u00b7\3\2\2\2\u0409\u040d"+
"\7V\2\2\u040a\u040c\5\u00ba^\2\u040b\u040a\3\2\2\2\u040c\u040f\3\2\2\2"+
"\u040d\u040b\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u0410\3\2\2\2\u040f\u040d"+
"\3\2\2\2\u0410\u0411\7W\2\2\u0411\u00b9\3\2\2\2\u0412\u0414\5L\'\2\u0413"+
"\u0412\3\2\2\2\u0414\u0417\3\2\2\2\u0415\u0413\3\2\2\2\u0415\u0416\3\2"+
"\2\2\u0416\u0418\3\2\2\2\u0417\u0415\3\2\2\2\u0418\u041b\5\u00bc_\2\u0419"+
"\u041b\7Z\2\2\u041a\u0415\3\2\2\2\u041a\u0419\3\2\2\2\u041b\u00bb\3\2"+
"\2\2\u041c\u041d\5\u0090I\2\u041d\u041e\5\u00be`\2\u041e\u041f\7Z\2\2"+
"\u041f\u0431\3\2\2\2\u0420\u0422\5R*\2\u0421\u0423\7Z\2\2\u0422\u0421"+
"\3\2\2\2\u0422\u0423\3\2\2\2\u0423\u0431\3\2\2\2\u0424\u0426\5b\62\2\u0425"+
"\u0427\7Z\2\2\u0426\u0425\3\2\2\2\u0426\u0427\3\2\2\2\u0427\u0431\3\2"+
"\2\2\u0428\u042a\5Z.\2\u0429\u042b\7Z\2\2\u042a\u0429\3\2\2\2\u042a\u042b"+
"\3\2\2\2\u042b\u0431\3\2\2\2\u042c\u042e\5\u00b6\\\2\u042d\u042f\7Z\2"+
"\2\u042e\u042d\3\2\2\2\u042e\u042f\3\2\2\2\u042f\u0431\3\2\2\2\u0430\u041c"+
"\3\2\2\2\u0430\u0420\3\2\2\2\u0430\u0424\3\2\2\2\u0430\u0428\3\2\2\2\u0430"+
"\u042c\3\2\2\2\u0431\u00bd\3\2\2\2\u0432\u0435\5\u00c0a\2\u0433\u0435"+
"\5\u00c2b\2\u0434\u0432\3\2\2\2\u0434\u0433\3\2\2\2\u0435\u00bf\3\2\2"+
"\2\u0436\u0437\7\177\2\2\u0437\u0438\7T\2\2\u0438\u043a\7U\2\2\u0439\u043b"+
"\5\u00c4c\2\u043a\u0439\3\2\2\2\u043a\u043b\3\2\2\2\u043b\u00c1\3\2\2"+
"\2\u043c\u043d\5\u0084C\2\u043d\u00c3\3\2\2\2\u043e\u043f\7)\2\2\u043f"+
"\u0440\5\u00b2Z\2\u0440\u00c5\3\2\2\2\u0441\u0445\7V\2\2\u0442\u0444\5"+
"\u00c8e\2\u0443\u0442\3\2\2\2\u0444\u0447\3\2\2\2\u0445\u0443\3\2\2\2"+
"\u0445\u0446\3\2\2\2\u0446\u0448\3\2\2\2\u0447\u0445\3\2\2\2\u0448\u0449"+
"\7W\2\2\u0449\u00c7\3\2\2\2\u044a\u044e\5\u00caf\2\u044b\u044e\5\u00ce"+
"h\2\u044c\u044e\5J&\2\u044d\u044a\3\2\2\2\u044d\u044b\3\2\2\2\u044d\u044c"+
"\3\2\2\2\u044e\u00c9\3\2\2\2\u044f\u0450\5\u00ccg\2\u0450\u0451\7Z\2\2"+
"\u0451\u00cb\3\2\2\2\u0452\u0454\5P)\2\u0453\u0452\3\2\2\2\u0454\u0457"+
"\3\2\2\2\u0455\u0453\3\2\2\2\u0455\u0456\3\2\2\2\u0456\u0458\3\2\2\2\u0457"+
"\u0455\3\2\2\2\u0458\u0459\5\u0090I\2\u0459\u045a\5\u0084C\2\u045a\u00cd"+
"\3\2\2\2\u045b\u04c4\5\u00c6d\2\u045c\u045d\7\37\2\2\u045d\u0460\5\u00f0"+
"y\2\u045e\u045f\7c\2\2\u045f\u0461\5\u00f0y\2\u0460\u045e\3\2\2\2\u0460"+
"\u0461\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0463\7Z\2\2\u0463\u04c4\3\2"+
"\2\2\u0464\u0465\7\63\2\2\u0465\u0466\5\u00e8u\2\u0466\u0469\5\u00ceh"+
"\2\u0467\u0468\7,\2\2\u0468\u046a\5\u00ceh\2\u0469\u0467\3\2\2\2\u0469"+
"\u046a\3\2\2\2\u046a\u04c4\3\2\2\2\u046b\u046c\7\62\2\2\u046c\u046d\7"+
"T\2\2\u046d\u046e\5\u00e0q\2\u046e\u046f\7U\2\2\u046f\u0470\5\u00ceh\2"+
"\u0470\u04c4\3\2\2\2\u0471\u0472\7O\2\2\u0472\u0473\5\u00e8u\2\u0473\u0474"+
"\5\u00ceh\2\u0474\u04c4\3\2\2\2\u0475\u0476\7*\2\2\u0476\u0477\5\u00ce"+
"h\2\u0477\u0478\7O\2\2\u0478\u0479\5\u00e8u\2\u0479\u047a\7Z\2\2\u047a"+
"\u04c4\3\2\2\2\u047b\u047c\7L\2\2\u047c\u0486\5\u00c6d\2\u047d\u047f\5"+
"\u00d0i\2\u047e\u047d\3\2\2\2\u047f\u0480\3\2\2\2\u0480\u047e\3\2\2\2"+
"\u0480\u0481\3\2\2\2\u0481\u0483\3\2\2\2\u0482\u0484\5\u00d4k\2\u0483"+
"\u0482\3\2\2\2\u0483\u0484\3\2\2\2\u0484\u0487\3\2\2\2\u0485\u0487\5\u00d4"+
"k\2\u0486\u047e\3\2\2\2\u0486\u0485\3\2\2\2\u0487\u04c4\3\2\2\2\u0488"+
"\u0489\7L\2\2\u0489\u048a\5\u00d6l\2\u048a\u048e\5\u00c6d\2\u048b\u048d"+
"\5\u00d0i\2\u048c\u048b\3\2\2\2\u048d\u0490\3\2\2\2\u048e\u048c\3\2\2"+
"\2\u048e\u048f\3\2\2\2\u048f\u0492\3\2\2\2\u0490\u048e\3\2\2\2\u0491\u0493"+
"\5\u00d4k\2\u0492\u0491\3\2\2\2\u0492\u0493\3\2\2\2\u0493\u04c4\3\2\2"+
"\2\u0494\u0495\7F\2\2\u0495\u0496\5\u00e8u\2\u0496\u049a\7V\2\2\u0497"+
"\u0499\5\u00dco\2\u0498\u0497\3\2\2\2\u0499\u049c\3\2\2\2\u049a\u0498"+
"\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u04a0\3\2\2\2\u049c\u049a\3\2\2\2\u049d"+
"\u049f\5\u00dep\2\u049e\u049d\3\2\2\2\u049f\u04a2\3\2\2\2\u04a0\u049e"+
"\3\2\2\2\u04a0\u04a1\3\2\2\2\u04a1\u04a3\3\2\2\2\u04a2\u04a0\3\2\2\2\u04a3"+
"\u04a4\7W\2\2\u04a4\u04c4\3\2\2\2\u04a5\u04a6\7G\2\2\u04a6\u04a7\5\u00e8"+
"u\2\u04a7\u04a8\5\u00c6d\2\u04a8\u04c4\3\2\2\2\u04a9\u04ab\7A\2\2\u04aa"+
"\u04ac\5\u00f0y\2\u04ab\u04aa\3\2\2\2\u04ab\u04ac\3\2\2\2\u04ac\u04ad"+
"\3\2\2\2\u04ad\u04c4\7Z\2\2\u04ae\u04af\7I\2\2\u04af\u04b0\5\u00f0y\2"+
"\u04b0\u04b1\7Z\2\2\u04b1\u04c4\3\2\2\2\u04b2\u04b4\7!\2\2\u04b3\u04b5"+
"\7\177\2\2\u04b4\u04b3\3\2\2\2\u04b4\u04b5\3\2\2\2\u04b5\u04b6\3\2\2\2"+
"\u04b6\u04c4\7Z\2\2\u04b7\u04b9\7(\2\2\u04b8\u04ba\7\177\2\2\u04b9\u04b8"+
"\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04bb\3\2\2\2\u04bb\u04c4\7Z\2\2\u04bc"+
"\u04c4\7Z\2\2\u04bd\u04be\5\u00ecw\2\u04be\u04bf\7Z\2\2\u04bf\u04c4\3"+
"\2\2\2\u04c0\u04c1\7\177\2\2\u04c1\u04c2\7c\2\2\u04c2\u04c4\5\u00ceh\2"+
"\u04c3\u045b\3\2\2\2\u04c3\u045c\3\2\2\2\u04c3\u0464\3\2\2\2\u04c3\u046b"+
"\3\2\2\2\u04c3\u0471\3\2\2\2\u04c3\u0475\3\2\2\2\u04c3\u047b\3\2\2\2\u04c3"+
"\u0488\3\2\2\2\u04c3\u0494\3\2\2\2\u04c3\u04a5\3\2\2\2\u04c3\u04a9\3\2"+
"\2\2\u04c3\u04ae\3\2\2\2\u04c3\u04b2\3\2\2\2\u04c3\u04b7\3\2\2\2\u04c3"+
"\u04bc\3\2\2\2\u04c3\u04bd\3\2\2\2\u04c3\u04c0\3\2\2\2\u04c4\u00cf\3\2"+
"\2\2\u04c5\u04c6\7$\2\2\u04c6\u04ca\7T\2\2\u04c7\u04c9\5P)\2\u04c8\u04c7"+
"\3\2\2\2\u04c9\u04cc\3\2\2\2\u04ca\u04c8\3\2\2\2\u04ca\u04cb\3\2\2\2\u04cb"+
"\u04cd\3\2\2\2\u04cc\u04ca\3\2\2\2\u04cd\u04ce\5\u00d2j\2\u04ce\u04cf"+
"\7\177\2\2\u04cf\u04d0\7U\2\2\u04d0\u04d1\5\u00c6d\2\u04d1\u00d1\3\2\2"+
"\2\u04d2\u04d7\5\u00a8U\2\u04d3\u04d4\7q\2\2\u04d4\u04d6\5\u00a8U\2\u04d5"+
"\u04d3\3\2\2\2\u04d6\u04d9\3\2\2\2\u04d7\u04d5\3\2\2\2\u04d7\u04d8\3\2"+
"\2\2\u04d8\u00d3\3\2\2\2\u04d9\u04d7\3\2\2\2\u04da\u04db\7\60\2\2\u04db"+
"\u04dc\5\u00c6d\2\u04dc\u00d5\3\2\2\2\u04dd\u04de\7T\2\2\u04de\u04e0\5"+
"\u00d8m\2\u04df\u04e1\7Z\2\2\u04e0\u04df\3\2\2\2\u04e0\u04e1\3\2\2\2\u04e1"+
"\u04e2\3\2\2\2\u04e2\u04e3\7U\2\2\u04e3\u00d7\3\2\2\2\u04e4\u04e9\5\u00da"+
"n\2\u04e5\u04e6\7Z\2\2\u04e6\u04e8\5\u00dan\2\u04e7\u04e5\3\2\2\2\u04e8"+
"\u04eb\3\2\2\2\u04e9\u04e7\3\2\2\2\u04e9\u04ea\3\2\2\2\u04ea\u00d9\3\2"+
"\2\2\u04eb\u04e9\3\2\2\2\u04ec\u04ee\5P)\2\u04ed\u04ec\3\2\2\2\u04ee\u04f1"+
"\3\2\2\2\u04ef\u04ed\3\2\2\2\u04ef\u04f0\3\2\2\2\u04f0\u04f2\3\2\2\2\u04f1"+
"\u04ef\3\2\2\2\u04f2\u04f3\5\u0092J\2\u04f3\u04f4\5\u0088E\2\u04f4\u04f5"+
"\7]\2\2\u04f5\u04f6\5\u00f0y\2\u04f6\u00db\3\2\2\2\u04f7\u04f9\5\u00de"+
"p\2\u04f8\u04f7\3\2\2\2\u04f9\u04fa\3\2\2\2\u04fa\u04f8\3\2\2\2\u04fa"+
"\u04fb\3\2\2\2\u04fb\u04fd\3\2\2\2\u04fc\u04fe\5\u00c8e\2\u04fd\u04fc"+
"\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff\u04fd\3\2\2\2\u04ff\u0500\3\2\2\2\u0500"+
"\u00dd\3\2\2\2\u0501\u0502\7#\2\2\u0502\u0503\5\u00eex\2\u0503\u0504\7"+
"c\2\2\u0504\u050c\3\2\2\2\u0505\u0506\7#\2\2\u0506\u0507\5\u008eH\2\u0507"+
"\u0508\7c\2\2\u0508\u050c\3\2\2\2\u0509\u050a\7)\2\2\u050a\u050c\7c\2"+
"\2\u050b\u0501\3\2\2\2\u050b\u0505\3\2\2\2\u050b\u0509\3\2\2\2\u050c\u00df"+
"\3\2\2\2\u050d\u051a\5\u00e4s\2\u050e\u0510\5\u00e2r\2\u050f\u050e\3\2"+
"\2\2\u050f\u0510\3\2\2\2\u0510\u0511\3\2\2\2\u0511\u0513\7Z\2\2\u0512"+
"\u0514\5\u00f0y\2\u0513\u0512\3\2\2\2\u0513\u0514\3\2\2\2\u0514\u0515"+
"\3\2\2\2\u0515\u0517\7Z\2\2\u0516\u0518\5\u00e6t\2\u0517\u0516\3\2\2\2"+
"\u0517\u0518\3\2\2\2\u0518\u051a\3\2\2\2\u0519\u050d\3\2\2\2\u0519\u050f"+
"\3\2\2\2\u051a\u00e1\3\2\2\2\u051b\u051e\5\u00ccg\2\u051c\u051e\5\u00ea"+
"v\2\u051d\u051b\3\2\2\2\u051d\u051c\3\2\2\2\u051e\u00e3\3\2\2\2\u051f"+
"\u0521\5P)\2\u0520\u051f\3\2\2\2\u0521\u0524\3\2\2\2\u0522\u0520\3\2\2"+
"\2\u0522\u0523\3\2\2\2\u0523\u0525\3\2\2\2\u0524\u0522\3\2\2\2\u0525\u0526"+
"\5\u0090I\2\u0526\u0527\5\u0088E\2\u0527\u0528\7c\2\2\u0528\u0529\5\u00f0"+
"y\2\u0529\u00e5\3\2\2\2\u052a\u052b\5\u00eav\2\u052b\u00e7\3\2\2\2\u052c"+
"\u052d\7T\2\2\u052d\u052e\5\u00f0y\2\u052e\u052f\7U\2\2\u052f\u00e9\3"+
"\2\2\2\u0530\u0535\5\u00f0y\2\u0531\u0532\7[\2\2\u0532\u0534\5\u00f0y"+
"\2\u0533\u0531\3\2\2\2\u0534\u0537\3\2\2\2\u0535\u0533\3\2\2\2\u0535\u0536"+
"\3\2\2\2\u0536\u00eb\3\2\2\2\u0537\u0535\3\2\2\2\u0538\u0539\5\u00f0y"+
"\2\u0539\u00ed\3\2\2\2\u053a\u053b\5\u00f0y\2\u053b\u00ef\3\2\2\2\u053c"+
"\u053d\by\1\2\u053d\u053e\7T\2\2\u053e\u053f\5\u0090I\2\u053f\u0540\7"+
"U\2\2\u0540\u0541\5\u00f0y\23\u0541\u054a\3\2\2\2\u0542\u0543\t\b\2\2"+
"\u0543\u054a\5\u00f0y\21\u0544\u0545\t\t\2\2\u0545\u054a\5\u00f0y\20\u0546"+
"\u054a\5\u00f2z\2\u0547\u0548\7<\2\2\u0548\u054a\5\u00f4{\2\u0549\u053c"+
"\3\2\2\2\u0549\u0542\3\2\2\2\u0549\u0544\3\2\2\2\u0549\u0546\3\2\2\2\u0549"+
"\u0547\3\2\2\2\u054a\u05a0\3\2\2\2\u054b\u054c\f\17\2\2\u054c\u054d\t"+
"\n\2\2\u054d\u059f\5\u00f0y\20\u054e\u054f\f\16\2\2\u054f\u0550\t\13\2"+
"\2\u0550\u059f\5\u00f0y\17\u0551\u0559\f\r\2\2\u0552\u0553\7_\2\2\u0553"+
"\u055a\7_\2\2\u0554\u0555\7^\2\2\u0555\u0556\7^\2\2\u0556\u055a\7^\2\2"+
"\u0557\u0558\7^\2\2\u0558\u055a\7^\2\2\u0559\u0552\3\2\2\2\u0559\u0554"+
"\3\2\2\2\u0559\u0557\3\2\2\2\u055a\u055b\3\2\2\2\u055b\u059f\5\u00f0y"+
"\16\u055c\u055d\f\f\2\2\u055d\u055e\t\f\2\2\u055e\u059f\5\u00f0y\r\u055f"+
"\u0560\f\n\2\2\u0560\u0561\t\r\2\2\u0561\u059f\5\u00f0y\13\u0562\u0563"+
"\f\t\2\2\u0563\u0564\7p\2\2\u0564\u059f\5\u00f0y\n\u0565\u0566\f\b\2\2"+
"\u0566\u0567\7r\2\2\u0567\u059f\5\u00f0y\t\u0568\u0569\f\7\2\2\u0569\u056a"+
"\7q\2\2\u056a\u059f\5\u00f0y\b\u056b\u056c\f\6\2\2\u056c\u056d\7h\2\2"+
"\u056d\u059f\5\u00f0y\7\u056e\u056f\f\5\2\2\u056f\u0570\7i\2\2\u0570\u059f"+
"\5\u00f0y\6\u0571\u0572\f\4\2\2\u0572\u0573\7b\2\2\u0573\u0574\5\u00f0"+
"y\2\u0574\u0575\7c\2\2\u0575\u0576\5\u00f0y\5\u0576\u059f\3\2\2\2\u0577"+
"\u0578\f\3\2\2\u0578\u0579\t\16\2\2\u0579\u059f\5\u00f0y\3\u057a\u057b"+
"\f\33\2\2\u057b\u057c\7\\\2\2\u057c\u059f\7\177\2\2\u057d\u057e\f\32\2"+
"\2\u057e\u057f\7\\\2\2\u057f\u059f\7H\2\2\u0580\u0581\f\31\2\2\u0581\u0582"+
"\7\\\2\2\u0582\u0584\7<\2\2\u0583\u0585\5\u0100\u0081\2\u0584\u0583\3"+
"\2\2\2\u0584\u0585\3\2\2\2\u0585\u0586\3\2\2\2\u0586\u059f\5\u00f8}\2"+
"\u0587\u0588\f\30\2\2\u0588\u0589\7\\\2\2\u0589\u058a\7E\2\2\u058a\u059f"+
"\5\u0106\u0084\2\u058b\u058c\f\27\2\2\u058c\u058d\7\\\2\2\u058d\u059f"+
"\5\u00fe\u0080\2\u058e\u058f\f\26\2\2\u058f\u0590\7X\2\2\u0590\u0591\5"+
"\u00f0y\2\u0591\u0592\7Y\2\2\u0592\u059f\3\2\2\2\u0593\u0594\f\25\2\2"+
"\u0594\u0596\7T\2\2\u0595\u0597\5\u00eav\2\u0596\u0595\3\2\2\2\u0596\u0597"+
"\3\2\2\2\u0597\u0598\3\2\2\2\u0598\u059f\7U\2\2\u0599\u059a\f\22\2\2\u059a"+
"\u059f\t\17\2\2\u059b\u059c\f\13\2\2\u059c\u059d\7\67\2\2\u059d\u059f"+
"\5\u0090I\2\u059e\u054b\3\2\2\2\u059e\u054e\3\2\2\2\u059e\u0551\3\2\2"+
"\2\u059e\u055c\3\2\2\2\u059e\u055f\3\2\2\2\u059e\u0562\3\2\2\2\u059e\u0565"+
"\3\2\2\2\u059e\u0568\3\2\2\2\u059e\u056b\3\2\2\2\u059e\u056e\3\2\2\2\u059e"+
"\u0571\3\2\2\2\u059e\u0577\3\2\2\2\u059e\u057a\3\2\2\2\u059e\u057d\3\2"+
"\2\2\u059e\u0580\3\2\2\2\u059e\u0587\3\2\2\2\u059e\u058b\3\2\2\2\u059e"+
"\u058e\3\2\2\2\u059e\u0593\3\2\2\2\u059e\u0599\3\2\2\2\u059e\u059b\3\2"+
"\2\2\u059f\u05a2\3\2\2\2\u05a0\u059e\3\2\2\2\u05a0\u05a1\3\2\2\2\u05a1"+
"\u00f1\3\2\2\2\u05a2\u05a0\3\2\2\2\u05a3\u05a4\7T\2\2\u05a4\u05a5\5\u00f0"+
"y\2\u05a5\u05a6\7U\2\2\u05a6\u05b9\3\2\2\2\u05a7\u05b9\7H\2\2\u05a8\u05b9"+
"\7E\2\2\u05a9\u05b9\5B\"\2\u05aa\u05b9\7\177\2\2\u05ab\u05ac\5\u0090I"+
"\2\u05ac\u05ad\7\\\2\2\u05ad\u05ae\7&\2\2\u05ae\u05b9\3\2\2\2\u05af\u05b0"+
"\7M\2\2\u05b0\u05b1\7\\\2\2\u05b1\u05b9\7&\2\2\u05b2\u05b6\5\u0100\u0081"+
"\2\u05b3\u05b7\5\u0108\u0085\2\u05b4\u05b5\7H\2\2\u05b5\u05b7\5\u010a"+
"\u0086\2\u05b6\u05b3\3\2\2\2\u05b6\u05b4\3\2\2\2\u05b7\u05b9\3\2\2\2\u05b8"+
"\u05a3\3\2\2\2\u05b8\u05a7\3\2\2\2\u05b8\u05a8\3\2\2\2\u05b8\u05a9\3\2"+
"\2\2\u05b8\u05aa\3\2\2\2\u05b8\u05ab\3\2\2\2\u05b8\u05af\3\2\2\2\u05b8"+
"\u05b2\3\2\2\2\u05b9\u00f3\3\2\2\2\u05ba\u05bb\5\u0100\u0081\2\u05bb\u05bc"+
"\5\u00f6|\2\u05bc\u05bd\5\u00fc\177\2\u05bd\u05c4\3\2\2\2\u05be\u05c1"+
"\5\u00f6|\2\u05bf\u05c2\5\u00fa~\2\u05c0\u05c2\5\u00fc\177\2\u05c1\u05bf"+
"\3\2\2\2\u05c1\u05c0\3\2\2\2\u05c2\u05c4\3\2\2\2\u05c3\u05ba\3\2\2\2\u05c3"+
"\u05be\3\2\2\2\u05c4\u00f5\3\2\2\2\u05c5\u05c7\7\177\2\2\u05c6\u05c8\5"+
"\u0102\u0082\2\u05c7\u05c6\3\2\2\2\u05c7\u05c8\3\2\2\2\u05c8\u05d0\3\2"+
"\2\2\u05c9\u05ca\7\\\2\2\u05ca\u05cc\7\177\2\2\u05cb\u05cd\5\u0102\u0082"+
"\2\u05cc\u05cb\3\2\2\2\u05cc\u05cd\3\2\2\2\u05cd\u05cf\3\2\2\2\u05ce\u05c9"+
"\3\2\2\2\u05cf\u05d2\3\2\2\2\u05d0\u05ce\3\2\2\2\u05d0\u05d1\3\2\2\2\u05d1"+
"\u05d5\3\2\2\2\u05d2\u05d0\3\2\2\2\u05d3\u05d5\5\u0094K\2\u05d4\u05c5"+
"\3\2\2\2\u05d4\u05d3\3\2\2\2\u05d5\u00f7\3\2\2\2\u05d6\u05d8\7\177\2\2"+
"\u05d7\u05d9\5\u0104\u0083\2\u05d8\u05d7\3\2\2\2\u05d8\u05d9\3\2\2\2\u05d9"+
"\u05da\3\2\2\2\u05da\u05db\5\u00fc\177\2\u05db\u00f9\3\2\2\2\u05dc\u05f8"+
"\7X\2\2\u05dd\u05e2\7Y\2\2\u05de\u05df\7X\2\2\u05df\u05e1\7Y\2\2\u05e0"+
"\u05de\3\2\2\2\u05e1\u05e4\3\2\2\2\u05e2\u05e0\3\2\2\2\u05e2\u05e3\3\2"+
"\2\2\u05e3\u05e5\3\2\2\2\u05e4\u05e2\3\2\2\2\u05e5\u05f9\5\u008cG\2\u05e6"+
"\u05e7\5\u00f0y\2\u05e7\u05ee\7Y\2\2\u05e8\u05e9\7X\2\2\u05e9\u05ea\5"+
"\u00f0y\2\u05ea\u05eb\7Y\2\2\u05eb\u05ed\3\2\2\2\u05ec\u05e8\3\2\2\2\u05ed"+
"\u05f0\3\2\2\2\u05ee\u05ec\3\2\2\2\u05ee\u05ef\3\2\2\2\u05ef\u05f5\3\2"+
"\2\2\u05f0\u05ee\3\2\2\2\u05f1\u05f2\7X\2\2\u05f2\u05f4\7Y\2\2\u05f3\u05f1"+
"\3\2\2\2\u05f4\u05f7\3\2\2\2\u05f5\u05f3\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6"+
"\u05f9\3\2\2\2\u05f7\u05f5\3\2\2\2\u05f8\u05dd\3\2\2\2\u05f8\u05e6\3\2"+
"\2\2\u05f9\u00fb\3\2\2\2\u05fa\u05fc\5\u010a\u0086\2\u05fb\u05fd\5f\64"+
"\2\u05fc\u05fb\3\2\2\2\u05fc\u05fd\3\2\2\2\u05fd\u00fd\3\2\2\2\u05fe\u05ff"+
"\5\u0100\u0081\2\u05ff\u0600\5\u0108\u0085\2\u0600\u00ff\3\2\2\2\u0601"+
"\u0602\7_\2\2\u0602\u0603\5d\63\2\u0603\u0604\7^\2\2\u0604\u0101\3\2\2"+
"\2\u0605\u0606\7_\2\2\u0606\u0609\7^\2\2\u0607\u0609\5\u0096L\2\u0608"+
"\u0605\3\2\2\2\u0608\u0607\3\2\2\2\u0609\u0103\3\2\2\2\u060a\u060b\7_"+
"\2\2\u060b\u060e\7^\2\2\u060c\u060e\5\u0100\u0081\2\u060d\u060a\3\2\2"+
"\2\u060d\u060c\3\2\2\2\u060e\u0105\3\2\2\2\u060f\u0616\5\u010a\u0086\2"+
"\u0610\u0611\7\\\2\2\u0611\u0613\7\177\2\2\u0612\u0614\5\u010a\u0086\2"+
"\u0613\u0612\3\2\2\2\u0613\u0614\3\2\2\2\u0614\u0616\3\2\2\2\u0615\u060f"+
"\3\2\2\2\u0615\u0610\3\2\2\2\u0616\u0107\3\2\2\2\u0617\u0618\7E\2\2\u0618"+
"\u061c\5\u0106\u0084\2\u0619\u061a\7\177\2\2\u061a\u061c\5\u010a\u0086"+
"\2\u061b\u0617\3\2\2\2\u061b\u0619\3\2\2\2\u061c\u0109\3\2\2\2\u061d\u061f"+
"\7T\2\2\u061e\u0620\5\u00eav\2\u061f\u061e\3\2\2\2\u061f\u0620\3\2\2\2"+
"\u0620\u0621\3\2\2\2\u0621\u0622\7U\2\2\u0622\u010b\3\2\2\2\u00a1\u010f"+
"\u0115\u011a\u0123\u012e\u0147\u018b\u01ca\u01d5\u01e3\u01f2\u01f7\u01fd"+
"\u0205\u020e\u0213\u021a\u0221\u0228\u022f\u0234\u0238\u023c\u0240\u0245"+
"\u0249\u024d\u0257\u025f\u0266\u026d\u0271\u0274\u0277\u0280\u0286\u028b"+
"\u028e\u0294\u029a\u029e\u02a7\u02ae\u02b7\u02be\u02c4\u02c8\u02d3\u02d7"+
"\u02df\u02e4\u02e8\u02f1\u02ff\u0304\u030d\u0315\u031f\u0327\u032f\u0334"+
"\u0340\u0346\u034d\u0352\u035a\u035e\u0360\u036b\u0373\u0376\u037a\u037f"+
"\u0383\u038e\u0397\u0399\u03a0\u03a5\u03ae\u03b3\u03b6\u03bb\u03c4\u03d4"+
"\u03dc\u03df\u03e8\u03f2\u03fa\u03fd\u0400\u040d\u0415\u041a\u0422\u0426"+
"\u042a\u042e\u0430\u0434\u043a\u0445\u044d\u0455\u0460\u0469\u0480\u0483"+
"\u0486\u048e\u0492\u049a\u04a0\u04ab\u04b4\u04b9\u04c3\u04ca\u04d7\u04e0"+
"\u04e9\u04ef\u04fa\u04ff\u050b\u050f\u0513\u0517\u0519\u051d\u0522\u0535"+
"\u0549\u0559\u0584\u0596\u059e\u05a0\u05b6\u05b8\u05c1\u05c3\u05c7\u05cc"+
"\u05d0\u05d4\u05d8\u05e2\u05ee\u05f5\u05f8\u05fc\u0608\u060d\u0613\u0615"+
"\u061b\u061f";
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);
}
}
}